source: proto/xmlschema/src/xmlwf_multipass.cpp @ 2234

Last change on this file since 2234 was 2234, checked in by shiyangy, 7 years ago
File size: 52.3 KB
Line 
1#include <stdio.h>
2#include <stdlib.h>
3#include <errno.h>
4#include <sys/types.h>
5#include <sys/stat.h>
6#include "../lib/lib_simd.h"
7
8#define BLOCK_SIZE 128
9#define SEGMENT_BLOCKS 28
10#define BUFFER_SIZE (BLOCK_SIZE * SEGMENT_BLOCKS * 1)
11#define OVERLAP_BUFSIZE 16
12
13#include "../lib/carryQ.h"
14#include "xmldecl.h"
15#include "xml_error.c"
16#include "xmldecl.c"
17#include "namechars.h"
18
19#include "../lib/perflib/perfsec.h"
20#include "../lib/s2p.h"
21
22#include "TagMatcher.h"
23#include "LineColTracker.h"
24
25#define TOTAL 0
26#define S2P 1
27#define CLASSIFY 2
28#define SCOPE 3
29#define CTCDPI 4
30#define TAGS 5
31#define REFS 6
32#define VALIDATE 7
33#define CHECK 8
34#define POSTPROCESS 9
35
36#ifdef BUFFER_PROFILING
37        BOM_Table * parser_timer;
38        BOM_Table * s2p_timer;
39        BOM_Table * classify_timer;
40        BOM_Table * scope_timer;
41        BOM_Table * tags_timer;
42        BOM_Table * refs_timer;
43        BOM_Table * CtCDPI_timer;
44        BOM_Table * validate_timer;
45        BOM_Table * check_timer;
46        BOM_Table * postprocess_timer;
47
48#elif CODE_CLOCKER
49        #define NUM_EVENTS 1
50//      int Events[NUM_EVENTS] = {PAPI_TOT_CYC};
51        int Events[NUM_EVENTS] = {PAPI_VEC_INS};
52//      int Events[NUM_EVENTS] = {PAPI_L1_DCM};
53//      int Events[NUM_EVENTS] = {PAPI_TOT_CYC, PAPI_BR_MSP};
54        int cal_size = 20;
55#if PASS == TOTAL
56        CC * parser_timer = new CC(Events,NUM_EVENTS,cal_size);
57#endif
58#if PASS == S2P
59        CC * s2p_timer = new CC(Events,NUM_EVENTS,cal_size);
60#endif
61#if PASS == CLASSIFY
62        CC * classify_timer = new CC(Events,NUM_EVENTS,cal_size);
63#endif
64#if PASS == SCOPE
65        CC * scope_timer = new CC(Events,NUM_EVENTS,cal_size);
66#endif
67#if PASS == CTCDPI
68        CC * CtCDPI_timer = new CC(Events,NUM_EVENTS,cal_size);
69#endif
70#if PASS == TAGS
71        CC * tags_timer = new CC(Events,NUM_EVENTS,cal_size);
72#endif
73#if PASS == REFS
74        CC * refs_timer = new CC(Events,NUM_EVENTS,cal_size);
75#endif
76#if PASS == VALIDATE
77        CC * validate_timer = new CC(Events,NUM_EVENTS,cal_size);
78#endif
79#if PASS == CHECK
80        CC * check_timer = new CC(Events,NUM_EVENTS,cal_size);
81#endif
82#if PASS == POSTPROCESS
83        CC * postprocess_timer = new CC(Events,NUM_EVENTS,cal_size);
84#endif
85#else
86        void * parser_timer;
87#endif
88
89int block_base=0;
90int buffer_base=0;
91int buffer_last;
92char * source;
93LineColTracker tracker;
94TagMatcher matcher;
95
96
97static inline int StreamScan(ScanBlock * stream, int blk_count, int ProcessPos(int)) {
98        int blk;
99        int block_pos = 0;
100
101        for (blk = 0; blk < blk_count; blk++) {
102                ScanBlock s = stream[blk];
103                while(s) {
104                        int code = (ProcessPos(cfzl(s) + block_pos));
105                        if (code) return code;
106                        s = s & (s-1);  // clear rightmost bit.
107                }
108                block_pos += 8 * sizeof(ScanBlock);
109        }
110        return 0;
111}
112
113
114static inline void ReportError(const char * error_msg, int error_pos_in_block) {
115  int error_line, error_column;
116  tracker.get_Line_and_Column(error_pos_in_block, error_line, error_column);
117  fprintf(stderr, "%s at line %i, column %i\n", error_msg, error_line, error_column);
118}
119
120
121static inline int NameStrt_check(int pos) {
122        int block_pos = block_base + pos;
123        if(XML_10_UTF8_NameStrt_bytes((unsigned char*)&source[block_pos]) == 0){
124              ReportError("name start error", pos);
125              exit(-1);
126        }
127        return 0;
128}
129
130static inline int Name_check(int pos) {
131        int block_pos = block_base + pos;
132        if(XML_10_UTF8_NameChar_bytes((unsigned char*)&source[block_pos]) == 0){
133              ReportError("name error", pos);
134              exit(-1);
135        }
136        return 0;
137}
138
139static inline int PIName_check(int pos) {
140        int block_pos = block_base + pos;
141        int file_pos = block_pos+buffer_base;
142        if (at_XxMmLll<ASCII>((unsigned char*)&source[block_pos]) && (source[block_pos+3]=='?' || source[block_pos+3]<= ' ')) {
143              // "<?xml" legal at start of file.
144              if ((file_pos == 2) && at_XmlDecl_start<ASCII>((unsigned char*)&source[0])) return 0;
145              ReportError("[Xx][Mm][Ll] illegal as PI name", pos);
146              exit(-1);
147        }
148        return 0;
149}
150
151static inline int CD_check(int pos) {
152        int block_pos = block_base + pos;
153        if (!at_CDATA1<ASCII>((unsigned char*)&source[block_pos])){
154              ReportError("CDATA error", pos);
155              exit(-1);
156        }
157        return 0;
158}
159
160static inline int GenRef_check(int pos) {
161        int block_pos = block_base + pos;
162        unsigned char* s = (unsigned char*)&source[block_pos];
163        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))){
164              ReportError("Undefined reference", pos);
165              exit(-1);
166        }
167        return 0;
168}
169
170static inline int HexRef_check(int pos) {
171        int block_pos = block_base + pos;
172        unsigned char* s = (unsigned char*)&source[block_pos];
173        int ch_val = 0;
174        while(at_HexDigit<ASCII>(s)){
175          ch_val = HexVal<ASCII>(s[0]) + (ch_val<<4);
176          if (ch_val> 0x10FFFF ){
177            ReportError("Illegal character reference", pos);
178            exit(-1);
179          }
180          s++;
181        }
182        if ((ch_val == 0x0) || ((ch_val | 0x7FF) == 0xDFFF)|| ((ch_val | 0x1) == 0xFFFF)){
183          ReportError("Illegal character reference", pos);
184          exit(-1);
185        }
186        else if (((ch_val < 0x20) && (ch_val != 0x9) && (ch_val != 0xD) && (ch_val != 0xA))){
187          ReportError("Illegal XML 1.0 character reference", pos);
188          exit(-1);
189        }
190        return 0;
191}
192
193static inline int DecRef_check(int pos) {
194        int block_pos = block_base + pos;
195        unsigned char* s = (unsigned char*)&source[block_pos];
196        int ch_val = 0;
197        while(at_HexDigit<ASCII>(s)){
198          ch_val = DigitVal<ASCII>(s[0]) + ch_val*10;
199          if (ch_val> 0x10FFFF ){
200            ReportError("Illegal character reference", pos);
201            exit(-1);
202          }
203          s++;
204        }
205        if ((ch_val == 0x0) || ((ch_val | 0x7FF) == 0xDFFF)|| ((ch_val | 0x1) == 0xFFFF)){
206          ReportError("Illegal character reference", pos);
207          exit(-1);
208        }
209        else if (((ch_val < 0x20) && (ch_val != 0x9) && (ch_val != 0xD) && (ch_val != 0xA))){
210          ReportError("Illegal XML 1.0 character reference", pos);
211          exit(-1);
212        }
213        return 0;
214}
215
216static inline int AttRef_check(int pos) {
217        int block_pos = block_base + pos;
218        unsigned char* s = (unsigned char*)&source[block_pos];
219        int ch_val = 0;
220        if(s[0]=='#'){
221          s++;
222          if(s[0]=='x' || s[0]=='X'){
223            s++;
224            while(at_HexDigit<ASCII>(s)){
225              ch_val = HexVal<ASCII>(s[0]) + (ch_val<<4);
226              s++;
227            }
228          }
229          else{
230            while(at_HexDigit<ASCII>(s)){
231              ch_val = DigitVal<ASCII>(s[0]) + ch_val*10;
232              s++;
233            }
234          }
235          if (ch_val==60){
236            ReportError("Attribute values contain '<' characters after reference expansion", pos);
237            exit(-1);
238          }
239        }
240        else if(at_Ref_lt<ASCII>(s)){
241          ReportError("Attribute values contain '<' characters after reference expansion", pos);
242          exit(-1);
243        }
244        return 0;
245}
246
247
248
249  struct U8 {
250  BitBlock unibyte;
251  BitBlock prefix;
252  BitBlock prefix2;
253  BitBlock prefix3;
254  BitBlock prefix4;
255  BitBlock suffix;
256  BitBlock badprefix;
257  BitBlock xE0;
258  BitBlock xED;
259  BitBlock xF0;
260  BitBlock xF4;
261  BitBlock xA0_xBF;
262  BitBlock x80_x9F;
263  BitBlock x90_xBF;
264  BitBlock x80_x8F;
265  BitBlock xEF;
266  BitBlock xBF;
267  BitBlock xBE;
268  BitBlock scope22;
269  BitBlock scope32;
270  BitBlock scope33;
271  BitBlock scope42;
272  BitBlock scope43;
273  BitBlock scope44;
274  BitBlock xE0_scope;
275  BitBlock xED_scope;
276  BitBlock xF0_scope;
277  BitBlock xF4_scope;
278  BitBlock xEF_scope;
279  BitBlock FFFE_FFFF;
280  BitBlock error;
281};
282
283  struct Lex {
284  BitBlock CR;
285  BitBlock LF;
286  BitBlock HT;
287  BitBlock SP;
288  BitBlock CRLF;
289  BitBlock RefStart;
290  BitBlock Semicolon;
291  BitBlock Colon;
292  BitBlock LAngle;
293  BitBlock RAngle;
294  BitBlock LBracket;
295  BitBlock RBracket;
296  BitBlock Exclam;
297  BitBlock QMark;
298  BitBlock Hyphen;
299  BitBlock Equals;
300  BitBlock SQuote;
301  BitBlock DQuote;
302  BitBlock Slash;
303  BitBlock Hash;
304  BitBlock x;
305  BitBlock ASCII_name_start;
306  BitBlock ASCII_name_char;
307  BitBlock NameScan;
308  BitBlock Digit;
309  BitBlock Hex;
310  BitBlock WS;
311  BitBlock error;
312};
313
314  struct Scope1 {
315  BitBlock RefStart;
316  BitBlock LAngle;
317  BitBlock Hyphen;
318  BitBlock QMark;
319  BitBlock RBracket;
320};
321
322  struct CtCDPI_Callouts {
323  BitBlock CD_end;
324  BitBlock Ct_starts;
325  BitBlock Ct_ends;
326  BitBlock CD_starts;
327  BitBlock CD_ends;
328  BitBlock PI_starts;
329  BitBlock PI_name_starts;
330  BitBlock PI_name_ends;
331  BitBlock PI_ends;
332  BitBlock CtCDPI_mask;
333  BitBlock error;
334};
335
336  struct Ref_Callouts {
337  BitBlock GenRef_starts;
338  BitBlock GenRef_ends;
339  BitBlock DecRef_starts;
340  BitBlock DecRef_ends;
341  BitBlock HexRef_starts;
342  BitBlock HexRef_ends;
343  BitBlock error;
344};
345
346  struct Tag_Callouts {
347  BitBlock ElemName_starts;
348  BitBlock ElemName_ends;
349  BitBlock AttName_starts;
350  BitBlock AttName_ends;
351  BitBlock AttVal_starts;
352  BitBlock AttVal_ends;
353  BitBlock AttVal_spans;
354  BitBlock EmptyTag_marks;
355  BitBlock EndTag_marks;
356  BitBlock LAngleFollow;
357  BitBlock error;
358};
359
360  struct Basis_bits {
361  BitBlock bit_0;
362  BitBlock bit_1;
363  BitBlock bit_2;
364  BitBlock bit_3;
365  BitBlock bit_4;
366  BitBlock bit_5;
367  BitBlock bit_6;
368  BitBlock bit_7;
369};
370
371  struct Masks {
372  BitBlock EOF_mask;
373};
374
375  struct Check_streams {
376  BitBlock misc_mask;
377  BitBlock non_ascii_name_starts;
378  BitBlock non_ascii_names;
379  BitBlock tag_marks;
380  BitBlock name_follows;
381  BitBlock att_refs;
382  BitBlock error_mask;
383};
384
385  struct Xml_names {
386  BitBlock namespace_error;
387};
388
389  struct Parse_refs {
390  Parse_refs() { CarryInit(carryQ, 6); }
391  void do_block(Lex & lex, Scope1 & scope1, CtCDPI_Callouts & ctCDPI_Callouts, Ref_Callouts & ref_Callouts) {
392                BitBlock Ref1, NumRef2, NumRef3, HexRef3, ref_error1, ref_error2, ref_ends;
393                BitBlock ref_error3;
394
395
396        ref_Callouts.GenRef_starts = simd_const_1(0);
397        ref_Callouts.GenRef_ends = simd_const_1(0);
398        ref_Callouts.DecRef_starts = simd_const_1(0);
399        ref_Callouts.DecRef_ends = simd_const_1(0);
400        ref_Callouts.HexRef_starts = simd_const_1(0);
401        ref_Callouts.HexRef_ends = simd_const_1(0);
402        ref_Callouts.error = simd_const_1(0);
403        Ref1 = simd_andc(lex.RefStart, ctCDPI_Callouts.CtCDPI_mask);
404        if ((bitblock_has_bit(Ref1) || CarryTest(carryQ, 0, 6))) {
405          scope1.RefStart = BitBlock_advance_ci_co(Ref1, carryQ, 0);
406          NumRef2 = simd_and(scope1.RefStart, lex.Hash);
407          ref_Callouts.GenRef_starts = simd_andc(scope1.RefStart, lex.Hash);
408          NumRef3 = BitBlock_advance_ci_co(NumRef2, carryQ, 1);
409          HexRef3 = simd_and(NumRef3, lex.x);
410          ref_Callouts.DecRef_starts = simd_andc(NumRef3, lex.x);
411          ref_Callouts.HexRef_starts = BitBlock_advance_ci_co(HexRef3, carryQ, 2);
412          ref_Callouts.GenRef_ends = BitBlock_scanthru_ci_co(ref_Callouts.GenRef_starts, lex.NameScan, carryQ, 3);
413          ref_Callouts.DecRef_ends = BitBlock_scanthru_ci_co(ref_Callouts.DecRef_starts, lex.Digit, carryQ, 4);
414          ref_Callouts.HexRef_ends = BitBlock_scanthru_ci_co(ref_Callouts.HexRef_starts, lex.Hex, carryQ, 5);
415          ref_error1 = simd_andc(ref_Callouts.DecRef_starts, lex.Digit);
416          ref_error2 = simd_andc(ref_Callouts.HexRef_starts, lex.Hex);
417          ref_ends = simd_or(simd_or(ref_Callouts.GenRef_ends, ref_Callouts.DecRef_ends), ref_Callouts.HexRef_ends);
418          ref_error3 = simd_andc(ref_ends, lex.Semicolon);
419          ref_Callouts.error = simd_or(simd_or(ref_error1, ref_error2), ref_error3);
420        }
421        else {
422          CarryDequeueEnqueue(carryQ, 0, 6);
423        }
424        CarryQ_Adjust(carryQ, 6);
425  }
426  void do_segment(Lex lex[], Scope1 scope1[], CtCDPI_Callouts ctCDPI_Callouts[], Ref_Callouts ref_Callouts[]) {
427  for (int i = 0; i < SEGMENT_BLOCKS; i++)
428    do_block(lex[i], scope1[i], ctCDPI_Callouts[i], ref_Callouts[i]);
429  }
430  CarryDeclare(carryQ, 6);
431  };
432
433  struct Parse_tags {
434  Parse_tags() { CarryInit(carryQ, 13); }
435  void do_block(Lex & lex, Scope1 & scope1, CtCDPI_Callouts & ctCDPI_Callouts, Tag_Callouts & tag_Callouts, Masks & masks) {
436                BitBlock DQuoteScan, SQuoteScan, AttListDelim, ParseError, EqToCheck;
437                BitBlock AttValEnds, AfterWS, AttListEnd, AttNameStart, AttNameFollow;
438                BitBlock EqExpected, AttValPos, DQuoteAttVal, SQuoteAttVal, DQuoteAttEnd;
439                BitBlock SQuoteAttEnd, AttValEnd, AttValFollow, STagEnds, EndTagEnds;
440
441
442        DQuoteScan = simd_andc(masks.EOF_mask, simd_or(lex.DQuote, lex.LAngle));
443        SQuoteScan = simd_andc(masks.EOF_mask, simd_or(lex.SQuote, lex.LAngle));
444        AttListDelim = simd_or(lex.Slash, lex.RAngle);
445        tag_Callouts.LAngleFollow = simd_andc(scope1.LAngle, ctCDPI_Callouts.CtCDPI_mask);
446        tag_Callouts.ElemName_starts = simd_andc(tag_Callouts.LAngleFollow, lex.Slash);
447        tag_Callouts.EndTag_marks = simd_and(tag_Callouts.LAngleFollow, lex.Slash);
448        tag_Callouts.ElemName_ends = BitBlock_scanthru_ci_co(tag_Callouts.ElemName_starts, lex.NameScan, carryQ, 0);
449        ParseError = simd_and(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends);
450        tag_Callouts.AttName_starts = simd_const_1(0);
451        tag_Callouts.AttName_ends = simd_const_1(0);
452        EqToCheck = simd_const_1(0);
453        tag_Callouts.AttVal_starts = simd_const_1(0);
454        AttValEnds = simd_const_1(0);
455        tag_Callouts.AttVal_ends = simd_const_1(0);
456        AfterWS = BitBlock_scanthru_ci_co(tag_Callouts.ElemName_ends, lex.WS, carryQ, 1);
457        AttListEnd = simd_and(AfterWS, AttListDelim);
458        AttNameStart = simd_andc(AfterWS, AttListDelim);
459        ParseError = simd_or(ParseError, simd_and(tag_Callouts.ElemName_ends, AttNameStart));
460        if ((bitblock_has_bit(AttNameStart) || CarryTest(carryQ, 2, 7))) {
461          tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts, AttNameStart);
462          AttNameFollow = BitBlock_scanthru_ci_co(AttNameStart, lex.NameScan, carryQ, 2);
463          tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends, AttNameFollow);
464          EqExpected = BitBlock_scanthru_ci_co(AttNameFollow, lex.WS, carryQ, 3);
465          EqToCheck = simd_or(EqToCheck, EqExpected);
466          AttValPos = BitBlock_scanthru_ci_co(EqExpected, simd_or(EqExpected, lex.WS), carryQ, 4);
467          tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts, AttValPos);
468          DQuoteAttVal = simd_and(AttValPos, lex.DQuote);
469          SQuoteAttVal = simd_and(AttValPos, lex.SQuote);
470          DQuoteAttEnd = BitBlock_scanthru_ci_co(DQuoteAttVal, simd_or(DQuoteAttVal, DQuoteScan), carryQ, 5);
471          SQuoteAttEnd = BitBlock_scanthru_ci_co(SQuoteAttVal, simd_or(SQuoteAttVal, SQuoteScan), carryQ, 6);
472          AttValEnd = simd_or(DQuoteAttEnd, SQuoteAttEnd);
473          AttValEnds = simd_or(AttValEnds, AttValEnd);
474          AttValFollow = BitBlock_advance_ci_co(AttValEnd, carryQ, 7);
475          tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends, AttValFollow);
476          AfterWS = BitBlock_scanthru_ci_co(AttValFollow, lex.WS, carryQ, 8);
477          AttListEnd = simd_or(AttListEnd, simd_and(AfterWS, AttListDelim));
478          AttNameStart = simd_andc(AfterWS, AttListDelim);
479          while (bitblock_has_bit(AttNameStart)) {
480            CarryDeclare(subcarryQ, 7);
481            CarryInit(subcarryQ, 7);
482            tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts, AttNameStart);
483            AttNameFollow = BitBlock_scanthru_co(AttNameStart, lex.NameScan, subcarryQ, 0);
484            tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends, AttNameFollow);
485            EqExpected = BitBlock_scanthru_co(AttNameFollow, lex.WS, subcarryQ, 1);
486            EqToCheck = simd_or(EqToCheck, EqExpected);
487            AttValPos = BitBlock_scanthru_co(EqExpected, simd_or(EqExpected, lex.WS), subcarryQ, 2);
488            tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts, AttValPos);
489            DQuoteAttVal = simd_and(AttValPos, lex.DQuote);
490            SQuoteAttVal = simd_and(AttValPos, lex.SQuote);
491            DQuoteAttEnd = BitBlock_scanthru_co(DQuoteAttVal, simd_or(DQuoteAttVal, DQuoteScan), subcarryQ, 3);
492            SQuoteAttEnd = BitBlock_scanthru_co(SQuoteAttVal, simd_or(SQuoteAttVal, SQuoteScan), subcarryQ, 4);
493            AttValEnd = simd_or(DQuoteAttEnd, SQuoteAttEnd);
494            AttValEnds = simd_or(AttValEnds, AttValEnd);
495            AttValFollow = BitBlock_advance_co(AttValEnd, subcarryQ, 5);
496            tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends, AttValFollow);
497            AfterWS = BitBlock_scanthru_co(AttValFollow, lex.WS, subcarryQ, 6);
498            AttListEnd = simd_or(AttListEnd, simd_and(AfterWS, AttListDelim));
499            AttNameStart = simd_andc(AfterWS, AttListDelim);
500            CarryCombine(carryQ, subcarryQ, 2, 7);
501          }
502        }
503        else {
504          CarryDequeueEnqueue(carryQ, 2, 7);
505        }
506        STagEnds = simd_and(AttListEnd, lex.RAngle);
507        tag_Callouts.EmptyTag_marks = BitBlock_advance_ci_co(simd_and(AttListEnd, lex.Slash), carryQ, 9);
508        ParseError = simd_or(ParseError, simd_and(tag_Callouts.AttVal_ends, tag_Callouts.AttName_starts));
509        ParseError = simd_or(ParseError, simd_and(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends));
510        ParseError = simd_or(ParseError, simd_andc(EqToCheck, lex.Equals));
511        ParseError = simd_or(ParseError, simd_andc(tag_Callouts.AttVal_starts, simd_or(lex.DQuote, lex.SQuote)));
512        ParseError = simd_or(ParseError, simd_andc(AttValEnds, simd_or(lex.DQuote, lex.SQuote)));
513        ParseError = simd_or(ParseError, simd_andc(tag_Callouts.EmptyTag_marks, lex.RAngle));
514        EndTagEnds = BitBlock_scanthru_ci_co(BitBlock_scanthru_ci_co(tag_Callouts.EndTag_marks, simd_or(tag_Callouts.EndTag_marks, lex.NameScan), carryQ, 10), lex.WS, carryQ, 11);
515        ParseError = simd_or(ParseError, simd_andc(EndTagEnds, lex.RAngle));
516        tag_Callouts.error = ParseError;
517        tag_Callouts.AttVal_spans = BitBlock_sub_ci_co(tag_Callouts.AttVal_ends, tag_Callouts.AttVal_starts, carryQ, 12);
518        CarryQ_Adjust(carryQ, 13);
519  }
520  void do_segment(Lex lex[], Scope1 scope1[], CtCDPI_Callouts ctCDPI_Callouts[], Tag_Callouts tag_Callouts[], Masks masks[]) {
521  for (int i = 0; i < SEGMENT_BLOCKS; i++)
522    do_block(lex[i], scope1[i], ctCDPI_Callouts[i], tag_Callouts[i], masks[i]);
523  }
524  CarryDeclare(carryQ, 13);
525  };
526
527  struct Classify_bytes_Validate_utf8 {
528  Classify_bytes_Validate_utf8() { CarryInit(carryQ, 12); }
529  void do_block(Basis_bits & basis_bits, Lex & lex, U8 & u8) {
530                BitBlock temp1, temp2, temp3, temp4, temp5, temp6, temp7, temp8, temp9, temp10;
531                BitBlock temp11, temp12, temp13, temp14, temp15, temp16, temp17, temp18;
532                BitBlock temp19, temp20, temp21, temp22, temp23, temp24, temp25, temp26;
533                BitBlock temp27, temp28, temp29, temp30, temp31, temp32, temp33, temp34;
534                BitBlock temp35, temp36, temp37, temp38, temp39, temp40, temp41, temp42;
535                BitBlock temp43, temp44, temp45, temp46, temp47, temp48, x00_x1F, temp49;
536                BitBlock temp50, temp51, temp52, temp53, temp54, temp55, temp56, temp57;
537                BitBlock temp58, temp59, temp60, temp61, temp62, temp63, temp64, temp65;
538                BitBlock u8anyscope, temp66, temp67, temp68, temp69, temp70, temp71, xE0, xED;
539                BitBlock xF0, temp72, xF4, xEF, temp73, u8lastscope, u8error1, u8error2;
540                BitBlock u8error3, u8error4, EF_BF_pending, u8mismatch;
541
542
543        temp1 = simd_or(basis_bits.bit_0, basis_bits.bit_1);
544        temp2 = simd_andc(basis_bits.bit_2, basis_bits.bit_3);
545        temp3 = simd_andc(temp2, temp1);
546        temp4 = simd_andc(basis_bits.bit_5, basis_bits.bit_4);
547        temp5 = simd_andc(basis_bits.bit_6, basis_bits.bit_7);
548        temp6 = simd_and(temp4, temp5);
549        lex.RefStart = simd_and(temp3, temp6);
550        temp7 = simd_and(basis_bits.bit_2, basis_bits.bit_3);
551        temp8 = simd_andc(temp7, temp1);
552        temp9 = simd_andc(basis_bits.bit_4, basis_bits.bit_5);
553        temp10 = simd_and(basis_bits.bit_6, basis_bits.bit_7);
554        temp11 = simd_and(temp9, temp10);
555        lex.Semicolon = simd_and(temp8, temp11);
556        temp12 = simd_and(basis_bits.bit_4, basis_bits.bit_5);
557        temp13 = simd_or(basis_bits.bit_6, basis_bits.bit_7);
558        temp14 = simd_andc(temp12, temp13);
559        lex.LAngle = simd_and(temp8, temp14);
560        temp15 = simd_and(temp12, temp5);
561        lex.RAngle = simd_and(temp8, temp15);
562        temp16 = simd_andc(basis_bits.bit_1, basis_bits.bit_0);
563        temp17 = simd_andc(basis_bits.bit_3, basis_bits.bit_2);
564        temp18 = simd_and(temp16, temp17);
565        lex.LBracket = simd_and(temp18, temp11);
566        temp19 = simd_andc(basis_bits.bit_7, basis_bits.bit_6);
567        temp20 = simd_and(temp12, temp19);
568        lex.RBracket = simd_and(temp18, temp20);
569        temp21 = simd_or(basis_bits.bit_4, basis_bits.bit_5);
570        temp22 = simd_andc(temp19, temp21);
571        lex.Exclam = simd_and(temp3, temp22);
572        temp23 = simd_and(temp12, temp10);
573        lex.QMark = simd_and(temp8, temp23);
574        lex.Hyphen = simd_and(temp3, temp20);
575        lex.Equals = simd_and(temp8, temp20);
576        temp24 = simd_and(temp4, temp10);
577        lex.SQuote = simd_and(temp3, temp24);
578        temp25 = simd_andc(temp5, temp21);
579        lex.DQuote = simd_and(temp3, temp25);
580        lex.Slash = simd_and(temp3, temp23);
581        temp26 = simd_andc(temp10, temp21);
582        lex.Hash = simd_and(temp3, temp26);
583        temp27 = simd_and(temp16, temp7);
584        temp28 = simd_andc(temp9, temp13);
585        lex.x = simd_and(temp27, temp28);
586        temp29 = simd_and(temp9, temp5);
587        lex.Colon = simd_and(temp8, temp29);
588        temp30 = simd_and(temp18, temp23);
589        temp31 = simd_or(temp30, lex.Colon);
590        temp32 = simd_andc(temp16, basis_bits.bit_2);
591        temp33 = simd_or(basis_bits.bit_5, temp10);
592        temp34 = simd_and(basis_bits.bit_4, temp33);
593        temp35 = simd_not(temp34);
594        temp36 = simd_or(temp21, temp13);
595        temp37 = simd_or(simd_and(basis_bits.bit_3, temp35), simd_andc(temp36, basis_bits.bit_3));
596        temp38 = simd_and(temp32, temp37);
597        temp39 = simd_or(temp31, temp38);
598        temp40 = simd_and(temp16, basis_bits.bit_2);
599        temp41 = simd_and(temp40, temp37);
600        lex.ASCII_name_start = simd_or(temp39, temp41);
601        temp42 = simd_or(temp30, lex.Hyphen);
602        temp43 = simd_and(temp3, temp15);
603        temp44 = simd_or(temp42, temp43);
604        temp45 = simd_andc(temp8, temp34);
605        temp46 = simd_or(temp44, temp45);
606        temp47 = simd_or(temp46, temp38);
607        lex.ASCII_name_char = simd_or(temp47, temp41);
608        lex.NameScan = simd_or(lex.ASCII_name_char, basis_bits.bit_0);
609        temp48 = simd_or(temp1, basis_bits.bit_2);
610        x00_x1F = simd_not(temp48);
611        temp49 = simd_or(basis_bits.bit_2, basis_bits.bit_3);
612        temp50 = simd_or(temp1, temp49);
613        lex.CR = simd_andc(temp20, temp50);
614        lex.LF = simd_andc(temp29, temp50);
615        temp51 = simd_and(temp9, temp19);
616        lex.HT = simd_andc(temp51, temp50);
617        lex.SP = simd_andc(temp3, temp36);
618        temp52 = simd_or(temp20, temp29);
619        temp53 = simd_or(temp52, temp51);
620        temp54 = simd_andc(temp53, temp50);
621        lex.WS = simd_or(temp54, lex.SP);
622        temp55 = simd_or(basis_bits.bit_5, basis_bits.bit_6);
623        temp56 = simd_and(basis_bits.bit_4, temp55);
624        lex.Digit = simd_andc(temp8, temp56);
625        temp57 = simd_andc(temp16, temp49);
626        temp58 = simd_andc(temp57, basis_bits.bit_4);
627        temp59 = simd_not(temp10);
628        temp60 = simd_or(simd_and(basis_bits.bit_5, temp59), simd_andc(temp13, basis_bits.bit_5));
629        temp61 = simd_and(temp58, temp60);
630        temp62 = simd_or(lex.Digit, temp61);
631        temp63 = simd_and(temp16, temp2);
632        temp64 = simd_andc(temp63, basis_bits.bit_4);
633        temp65 = simd_and(temp64, temp60);
634        lex.Hex = simd_or(temp62, temp65);
635        lex.error = simd_andc(x00_x1F, lex.WS);
636        u8.unibyte = simd_not(basis_bits.bit_0);
637        u8.suffix = simd_const_1(0);
638        u8.error = simd_const_1(0);
639        u8.FFFE_FFFF = simd_const_1(0);
640        u8anyscope = simd_const_1(0);
641        if ((bitblock_has_bit(basis_bits.bit_0) || CarryTest(carryQ, 0, 12))) {
642          u8.prefix = simd_and(basis_bits.bit_0, basis_bits.bit_1);
643          u8.prefix2 = simd_andc(u8.prefix, basis_bits.bit_2);
644          u8.prefix3 = simd_and(u8.prefix, temp2);
645          u8.prefix4 = simd_and(u8.prefix, temp7);
646          u8.suffix = simd_andc(basis_bits.bit_0, basis_bits.bit_1);
647          temp66 = simd_andc(u8.prefix, temp49);
648          temp67 = simd_or(temp21, basis_bits.bit_6);
649          temp68 = simd_andc(temp66, temp67);
650          temp69 = simd_and(basis_bits.bit_5, temp13);
651          temp70 = simd_or(basis_bits.bit_4, temp69);
652          temp71 = simd_and(u8.prefix4, temp70);
653          u8.badprefix = simd_or(temp68, temp71);
654          u8.error = u8.badprefix;
655          u8.scope22 = BitBlock_advance_ci_co(u8.prefix2, carryQ, 0);
656          u8anyscope = u8.scope22;
657          if ((bitblock_has_bit(simd_or(u8.prefix3, u8.prefix4)) || CarryTest(carryQ, 1, 11))) {
658            xE0 = simd_andc(u8.prefix3, temp36);
659            xED = simd_and(u8.prefix3, temp20);
660            xF0 = simd_andc(u8.prefix4, temp36);
661            temp72 = simd_andc(temp4, temp13);
662            xF4 = simd_and(u8.prefix4, temp72);
663            u8.xA0_xBF = simd_and(u8.suffix, basis_bits.bit_2);
664            u8.x80_x9F = simd_andc(u8.suffix, basis_bits.bit_2);
665            u8.x90_xBF = simd_and(u8.suffix, temp49);
666            u8.x80_x8F = simd_andc(u8.suffix, temp49);
667            xEF = simd_and(u8.prefix3, temp23);
668            temp73 = simd_and(u8.suffix, temp7);
669            u8.xBF = simd_and(temp73, temp23);
670            u8.xBE = simd_and(temp73, temp15);
671            u8.xE0_scope = BitBlock_advance_ci_co(xE0, carryQ, 1);
672            u8.xED_scope = BitBlock_advance_ci_co(xED, carryQ, 2);
673            u8.xF0_scope = BitBlock_advance_ci_co(xF0, carryQ, 3);
674            u8.xF4_scope = BitBlock_advance_ci_co(xF4, carryQ, 4);
675            u8.xEF_scope = BitBlock_advance_ci_co(xEF, carryQ, 5);
676            u8.scope32 = BitBlock_advance_ci_co(u8.prefix3, carryQ, 6);
677            u8.scope33 = BitBlock_advance_ci_co(u8.scope32, carryQ, 7);
678            u8.scope42 = BitBlock_advance_ci_co(u8.prefix4, carryQ, 8);
679            u8.scope43 = BitBlock_advance_ci_co(u8.scope42, carryQ, 9);
680            u8.scope44 = BitBlock_advance_ci_co(u8.scope43, carryQ, 10);
681            u8lastscope = simd_or(simd_or(u8.scope22, u8.scope33), u8.scope44);
682            u8anyscope = simd_or(simd_or(simd_or(u8lastscope, u8.scope32), u8.scope42), u8.scope43);
683            u8error1 = simd_and(u8.xE0_scope, u8.x80_x9F);
684            u8error2 = simd_and(u8.xED_scope, u8.xA0_xBF);
685            u8error3 = simd_and(u8.xF0_scope, u8.x80_x8F);
686            u8error4 = simd_and(u8.xF4_scope, u8.x90_xBF);
687            u8.error = simd_or(u8.error, simd_or(simd_or(simd_or(u8error1, u8error2), u8error3), u8error4));
688            EF_BF_pending = BitBlock_advance_ci_co(simd_and(u8.xEF_scope, u8.xBF), carryQ, 11);
689            u8.FFFE_FFFF = simd_and(EF_BF_pending, simd_or(u8.xBE, u8.xBF));
690          }
691          else {
692            CarryDequeueEnqueue(carryQ, 1, 11);
693          }
694        }
695        else {
696          CarryDequeueEnqueue(carryQ, 0, 12);
697        }
698        u8mismatch = simd_xor(u8anyscope, u8.suffix);
699        u8.error = simd_or(u8.error, u8mismatch);
700        CarryQ_Adjust(carryQ, 12);
701  }
702  void do_segment(Basis_bits basis_bits[], Lex lex[], U8 u8[]) {
703  for (int i = 0; i < SEGMENT_BLOCKS; i++)
704    do_block(basis_bits[i], lex[i], u8[i]);
705  }
706  CarryDeclare(carryQ, 12);
707  };
708
709  struct Parse_CtCDPI {
710  Parse_CtCDPI() { CarryInit(carryQ, 18); }
711  void do_block(CtCDPI_Callouts & ctCDPI_Callouts, Lex & lex, Scope1 & scope1, Masks & masks, Check_streams & check_streams) {
712                BitBlock CtCDPI_starts, PI_start, CtCD_start, CtCDPI_start, DoubleHyphen;
713                BitBlock PI_end, CtCDPI_scan, Ct_end_scan, CD_end_scan, PI_end_scan;
714                BitBlock CtCDPI_Cursor, PI_Cursor, CD_Ct_Cursor, CD_Cursor, Ct_Cursor;
715                BitBlock Ct_errors, PI_name_end;
716
717  CtCDPI_Cursor = sisd_from_int(1);
718
719        ctCDPI_Callouts.CD_end = simd_const_1(0);
720        ctCDPI_Callouts.Ct_starts = simd_const_1(0);
721        ctCDPI_Callouts.Ct_ends = simd_const_1(0);
722        ctCDPI_Callouts.CD_starts = simd_const_1(0);
723        ctCDPI_Callouts.CD_ends = simd_const_1(0);
724        ctCDPI_Callouts.PI_starts = simd_const_1(0);
725        ctCDPI_Callouts.PI_name_starts = simd_const_1(0);
726        ctCDPI_Callouts.PI_name_ends = simd_const_1(0);
727        ctCDPI_Callouts.PI_ends = simd_const_1(0);
728        ctCDPI_Callouts.CtCDPI_mask = simd_const_1(0);
729        ctCDPI_Callouts.error = simd_const_1(0);
730        CtCDPI_starts = simd_const_1(0);
731        if ((bitblock_has_bit(lex.RBracket) || CarryTest(carryQ, 0, 2))) {
732          scope1.RBracket = BitBlock_advance_ci_co(lex.RBracket, carryQ, 0);
733          ctCDPI_Callouts.CD_end = simd_and(BitBlock_advance_ci_co(simd_and(scope1.RBracket, lex.RBracket), carryQ, 1), lex.RAngle);
734        }
735        else {
736          CarryDequeueEnqueue(carryQ, 0, 2);
737        }
738        PI_start = simd_and(scope1.LAngle, lex.QMark);
739        CtCD_start = simd_and(scope1.LAngle, lex.Exclam);
740        CtCDPI_start = simd_or(PI_start, CtCD_start);
741        DoubleHyphen = simd_and(scope1.Hyphen, lex.Hyphen);
742        PI_end = simd_and(scope1.QMark, lex.RAngle);
743        CtCDPI_scan = simd_andc(masks.EOF_mask, CtCDPI_start);
744        Ct_end_scan = simd_andc(masks.EOF_mask, DoubleHyphen);
745        CD_end_scan = simd_andc(masks.EOF_mask, ctCDPI_Callouts.CD_end);
746        PI_end_scan = simd_andc(masks.EOF_mask, PI_end);
747        CtCDPI_Cursor = BitBlock_scanthru_ci_co(CtCDPI_Cursor, CtCDPI_scan, carryQ, 2);
748        CtCDPI_Cursor = simd_and(CtCDPI_Cursor, masks.EOF_mask);
749        if ((bitblock_has_bit(CtCDPI_Cursor) || CarryTest(carryQ, 3, 13))) {
750          CtCDPI_starts = simd_or(CtCDPI_starts, CtCDPI_Cursor);
751          PI_Cursor = simd_and(CtCDPI_Cursor, PI_start);
752          CD_Ct_Cursor = BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor, PI_Cursor), carryQ, 3);
753          CD_Cursor = simd_and(CD_Ct_Cursor, lex.LBracket);
754          Ct_Cursor = simd_and(CD_Ct_Cursor, lex.Hyphen);
755          ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts, PI_Cursor);
756          ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts, CD_Cursor);
757          ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts, Ct_Cursor);
758          Ct_Cursor = BitBlock_advance_ci_co(Ct_Cursor, carryQ, 4);
759          Ct_errors = simd_or(Ct_errors, simd_andc(Ct_Cursor, lex.Hyphen));
760          Ct_Cursor = BitBlock_advance_ci_co(Ct_Cursor, carryQ, 5);
761          Ct_end_scan = simd_or(Ct_end_scan, Ct_Cursor);
762          PI_Cursor = BitBlock_advance_ci_co(PI_Cursor, carryQ, 6);
763          ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts, PI_Cursor);
764          PI_name_end = BitBlock_scanthru_ci_co(PI_Cursor, lex.NameScan, carryQ, 7);
765          ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends, PI_name_end);
766          PI_Cursor = BitBlock_scanthru_ci_co(PI_name_end, PI_end_scan, carryQ, 8);
767          CD_Cursor = BitBlock_scanthru_ci_co(CD_Cursor, CD_end_scan, carryQ, 9);
768          Ct_Cursor = BitBlock_advance_ci_co(BitBlock_scanthru_ci_co(Ct_Cursor, Ct_end_scan, carryQ, 10), carryQ, 11);
769          ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends, PI_Cursor);
770          ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends, CD_Cursor);
771          ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends, Ct_Cursor);
772          CtCDPI_Cursor = simd_or(simd_or(PI_Cursor, CD_Cursor), Ct_Cursor);
773          CtCDPI_Cursor = BitBlock_scanthru_ci_co(CtCDPI_Cursor, CtCDPI_scan, carryQ, 12);
774          CtCDPI_Cursor = simd_and(CtCDPI_Cursor, masks.EOF_mask);
775          ctCDPI_Callouts.CtCDPI_mask = BitBlock_sub_ci_co(BitBlock_advance_ci_co(simd_or(simd_or(ctCDPI_Callouts.CD_ends, ctCDPI_Callouts.Ct_ends), ctCDPI_Callouts.PI_ends), carryQ, 13), CtCDPI_starts, carryQ, 14);
776          ctCDPI_Callouts.error = simd_or(Ct_errors, simd_andc(ctCDPI_Callouts.Ct_ends, lex.RAngle));
777          ctCDPI_Callouts.error = simd_or(ctCDPI_Callouts.error, simd_andc(BitBlock_advance_ci_co(simd_andc(ctCDPI_Callouts.PI_name_ends, lex.WS), carryQ, 15), PI_end));
778          ctCDPI_Callouts.error = simd_or(ctCDPI_Callouts.error, simd_and(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends));
779          ctCDPI_Callouts.error = simd_or(ctCDPI_Callouts.error, simd_andc(ctCDPI_Callouts.CtCDPI_mask, masks.EOF_mask));
780          while (bitblock_has_bit(CtCDPI_Cursor)) {
781            CarryDeclare(subcarryQ, 13);
782            CarryInit(subcarryQ, 13);
783            CtCDPI_starts = simd_or(CtCDPI_starts, CtCDPI_Cursor);
784            PI_Cursor = simd_and(CtCDPI_Cursor, PI_start);
785            CD_Ct_Cursor = BitBlock_advance_co(simd_andc(CtCDPI_Cursor, PI_Cursor), subcarryQ, 0);
786            CD_Cursor = simd_and(CD_Ct_Cursor, lex.LBracket);
787            Ct_Cursor = simd_and(CD_Ct_Cursor, lex.Hyphen);
788            ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts, PI_Cursor);
789            ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts, CD_Cursor);
790            ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts, Ct_Cursor);
791            Ct_Cursor = BitBlock_advance_co(Ct_Cursor, subcarryQ, 1);
792            Ct_errors = simd_or(Ct_errors, simd_andc(Ct_Cursor, lex.Hyphen));
793            Ct_Cursor = BitBlock_advance_co(Ct_Cursor, subcarryQ, 2);
794            Ct_end_scan = simd_or(Ct_end_scan, Ct_Cursor);
795            PI_Cursor = BitBlock_advance_co(PI_Cursor, subcarryQ, 3);
796            ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts, PI_Cursor);
797            PI_name_end = BitBlock_scanthru_co(PI_Cursor, lex.NameScan, subcarryQ, 4);
798            ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends, PI_name_end);
799            PI_Cursor = BitBlock_scanthru_co(PI_name_end, PI_end_scan, subcarryQ, 5);
800            CD_Cursor = BitBlock_scanthru_co(CD_Cursor, CD_end_scan, subcarryQ, 6);
801            Ct_Cursor = BitBlock_advance_co(BitBlock_scanthru_co(Ct_Cursor, Ct_end_scan, subcarryQ, 7), subcarryQ, 8);
802            ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends, PI_Cursor);
803            ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends, CD_Cursor);
804            ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends, Ct_Cursor);
805            CtCDPI_Cursor = simd_or(simd_or(PI_Cursor, CD_Cursor), Ct_Cursor);
806            CtCDPI_Cursor = BitBlock_scanthru_co(CtCDPI_Cursor, CtCDPI_scan, subcarryQ, 9);
807            CtCDPI_Cursor = simd_and(CtCDPI_Cursor, masks.EOF_mask);
808            ctCDPI_Callouts.CtCDPI_mask = BitBlock_sub_co(BitBlock_advance_co(simd_or(simd_or(ctCDPI_Callouts.CD_ends, ctCDPI_Callouts.Ct_ends), ctCDPI_Callouts.PI_ends), subcarryQ, 10), CtCDPI_starts, subcarryQ, 11);
809            ctCDPI_Callouts.error = simd_or(Ct_errors, simd_andc(ctCDPI_Callouts.Ct_ends, lex.RAngle));
810            ctCDPI_Callouts.error = simd_or(ctCDPI_Callouts.error, simd_andc(BitBlock_advance_co(simd_andc(ctCDPI_Callouts.PI_name_ends, lex.WS), subcarryQ, 12), PI_end));
811            ctCDPI_Callouts.error = simd_or(ctCDPI_Callouts.error, simd_and(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends));
812            ctCDPI_Callouts.error = simd_or(ctCDPI_Callouts.error, simd_andc(ctCDPI_Callouts.CtCDPI_mask, masks.EOF_mask));
813            CarryCombine(carryQ, subcarryQ, 3, 13);
814          }
815        }
816        else {
817          CarryDequeueEnqueue(carryQ, 3, 13);
818        }
819        check_streams.misc_mask = simd_and(simd_or(simd_or(simd_or(lex.WS, lex.LAngle), BitBlock_sub_ci_co(BitBlock_advance_ci_co(simd_or(ctCDPI_Callouts.Ct_ends, ctCDPI_Callouts.PI_ends), carryQ, 16), simd_or(ctCDPI_Callouts.Ct_starts, ctCDPI_Callouts.PI_starts), carryQ, 17)), CtCDPI_starts), masks.EOF_mask);
820        CarryQ_Adjust(carryQ, 18);
821  }
822  void do_segment(CtCDPI_Callouts ctCDPI_Callouts[], Lex lex[], Scope1 scope1[], Masks masks[], Check_streams check_streams[]) {
823  for (int i = 0; i < SEGMENT_BLOCKS; i++)
824    do_block(ctCDPI_Callouts[i], lex[i], scope1[i], masks[i], check_streams[i]);
825  }
826  CarryDeclare(carryQ, 18);
827  };
828
829  struct Do_check_streams {
830
831  void do_block(CtCDPI_Callouts & ctCDPI_Callouts, Tag_Callouts & tag_Callouts, Lex & lex, U8 & u8, Scope1 & scope1, Ref_Callouts & ref_Callouts, Xml_names & xml_names, Check_streams & check_streams, Masks & masks) {
832                BitBlock CD_end_error;
833
834
835        CD_end_error = simd_andc(ctCDPI_Callouts.CD_end, simd_or(ctCDPI_Callouts.CtCDPI_mask, tag_Callouts.AttVal_spans));
836        check_streams.error_mask = simd_or(simd_or(simd_or(simd_or(simd_or(simd_or(simd_or(simd_and(lex.error, masks.EOF_mask), u8.error), u8.FFFE_FFFF), ctCDPI_Callouts.error), tag_Callouts.error), CD_end_error), ref_Callouts.error), xml_names.namespace_error);
837        check_streams.tag_marks = simd_or(simd_or(tag_Callouts.EmptyTag_marks, tag_Callouts.LAngleFollow), tag_Callouts.AttName_starts);
838        check_streams.name_follows = simd_or(tag_Callouts.ElemName_ends, tag_Callouts.AttName_ends);
839        check_streams.att_refs = simd_and(tag_Callouts.AttVal_spans, scope1.RefStart);
840  }
841  void do_segment(CtCDPI_Callouts ctCDPI_Callouts[], Tag_Callouts tag_Callouts[], Lex lex[], U8 u8[], Scope1 scope1[], Ref_Callouts ref_Callouts[], Xml_names xml_names[], Check_streams check_streams[], Masks masks[]) {
842  for (int i = 0; i < SEGMENT_BLOCKS; i++)
843    do_block(ctCDPI_Callouts[i], tag_Callouts[i], lex[i], u8[i], scope1[i], ref_Callouts[i], xml_names[i], check_streams[i], masks[i]);
844  }
845
846  };
847
848  struct Validate_xml_names {
849  Validate_xml_names() { CarryInit(carryQ, 9); }
850  void do_block(CtCDPI_Callouts & ctCDPI_Callouts, Ref_Callouts & ref_Callouts, Tag_Callouts & tag_Callouts, Lex & lex, U8 & u8, Xml_names & xml_names, Check_streams & check_streams) {
851                BitBlock PI_names, GenRefs, ElemNames, AttNames, qname_stream, ncname_stream;
852                BitBlock name_stream, name_start, name_cursor, void_prefix_err, namespace_sep;
853                BitBlock local_part_start, local_part_err, colon2_err, ncname_err;
854
855
856        PI_names = BitBlock_sub_ci_co(ctCDPI_Callouts.PI_name_ends, ctCDPI_Callouts.PI_name_starts, carryQ, 0);
857        GenRefs = BitBlock_sub_ci_co(ref_Callouts.GenRef_ends, ref_Callouts.GenRef_starts, carryQ, 1);
858        ElemNames = BitBlock_sub_ci_co(tag_Callouts.ElemName_ends, tag_Callouts.ElemName_starts, carryQ, 2);
859        AttNames = BitBlock_sub_ci_co(tag_Callouts.AttName_ends, tag_Callouts.AttName_starts, carryQ, 3);
860        qname_stream = simd_or(ElemNames, AttNames);
861        ncname_stream = simd_or(PI_names, GenRefs);
862        name_stream = simd_or(qname_stream, ncname_stream);
863        name_start = simd_andc(name_stream, BitBlock_advance_ci_co(name_stream, carryQ, 4));
864        name_cursor = simd_andc(name_stream, BitBlock_advance_ci_co(name_stream, carryQ, 5));
865        void_prefix_err = simd_and(name_cursor, lex.Colon);
866        namespace_sep = simd_and(BitBlock_scanthru_ci_co(name_cursor, simd_andc(lex.NameScan, lex.Colon), carryQ, 6), lex.Colon);
867        local_part_start = BitBlock_advance_ci_co(namespace_sep, carryQ, 7);
868        local_part_err = simd_andc(local_part_start, lex.NameScan);
869        colon2_err = simd_and(BitBlock_scanthru_ci_co(local_part_start, simd_andc(lex.NameScan, lex.Colon), carryQ, 8), lex.Colon);
870        ncname_err = simd_and(ncname_stream, lex.Colon);
871        xml_names.namespace_error = simd_or(simd_or(simd_or(void_prefix_err, local_part_err), colon2_err), ncname_err);
872        check_streams.non_ascii_name_starts = simd_andc(name_start, lex.ASCII_name_start);
873        check_streams.non_ascii_names = simd_andc(simd_andc(simd_andc(name_stream, name_start), lex.ASCII_name_char), u8.suffix);
874        CarryQ_Adjust(carryQ, 9);
875  }
876  void do_segment(CtCDPI_Callouts ctCDPI_Callouts[], Ref_Callouts ref_Callouts[], Tag_Callouts tag_Callouts[], Lex lex[], U8 u8[], Xml_names xml_names[], Check_streams check_streams[]) {
877  for (int i = 0; i < SEGMENT_BLOCKS; i++)
878    do_block(ctCDPI_Callouts[i], ref_Callouts[i], tag_Callouts[i], lex[i], u8[i], xml_names[i], check_streams[i]);
879  }
880  CarryDeclare(carryQ, 9);
881  };
882
883  struct Add_scope_streams {
884  Add_scope_streams() { CarryInit(carryQ, 2); }
885  void do_block(Lex & lex, Scope1 & scope1) {
886                BitBlock v, w, v1, w1;
887
888
889        v = simd_or(lex.LAngle, lex.Hyphen);
890        w = simd_or(lex.Hyphen, lex.QMark);
891        v1 = BitBlock_advance_ci_co(v, carryQ, 0);
892        w1 = BitBlock_advance_ci_co(w, carryQ, 1);
893        scope1.LAngle = simd_andc(v1, w1);
894        scope1.Hyphen = simd_and(v1, w1);
895        scope1.QMark = simd_andc(w1, v1);
896        CarryQ_Adjust(carryQ, 2);
897  }
898  void do_segment(Lex lex[], Scope1 scope1[]) {
899  for (int i = 0; i < SEGMENT_BLOCKS; i++)
900    do_block(lex[i], scope1[i]);
901  }
902  CarryDeclare(carryQ, 2);
903  };
904
905
906
907static inline void s2p_do_block(BytePack U8[], Basis_bits & basis_bits) {
908  s2p(U8[0], U8[1], U8[2], U8[3], U8[4], U8[5], U8[6], U8[7],
909        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);
910}
911
912static inline void s2p_do_segment(BytePack U8[], Basis_bits basis_bits[]) {
913  for (int i = 0; i < SEGMENT_BLOCKS; i++)
914           s2p_do_block(&U8[8*i], basis_bits[i]);
915}
916
917static inline void postprocess_do_block(Lex & lex, CtCDPI_Callouts & ctCDPI_Callouts, Ref_Callouts & ref_Callouts, Check_streams & check_streams, int chars_avail){
918            tracker.StoreNewlines(lex.LF);
919
920                if (bitblock_has_bit(simd_or(check_streams.non_ascii_name_starts, check_streams.non_ascii_names))) {
921                  StreamScan((ScanBlock *) &check_streams.non_ascii_name_starts, sizeof(BitBlock)/sizeof(ScanBlock), NameStrt_check);
922                  StreamScan((ScanBlock *) &check_streams.non_ascii_names, sizeof(BitBlock)/sizeof(ScanBlock), Name_check);
923                }
924
925                if (bitblock_has_bit(ctCDPI_Callouts.PI_name_starts)){
926                  StreamScan((ScanBlock *) &ctCDPI_Callouts.PI_name_starts, sizeof(BitBlock)/sizeof(ScanBlock), PIName_check);
927                }
928
929                if (bitblock_has_bit(ctCDPI_Callouts.CD_starts)){
930                  StreamScan((ScanBlock *) &ctCDPI_Callouts.CD_starts, sizeof(BitBlock)/sizeof(ScanBlock), CD_check);
931                }
932
933                if (bitblock_has_bit(ref_Callouts.GenRef_starts)){
934                  StreamScan((ScanBlock *) &ref_Callouts.GenRef_starts, sizeof(BitBlock)/sizeof(ScanBlock), GenRef_check);
935                }
936
937                if (bitblock_has_bit(ref_Callouts.DecRef_starts)){
938                  StreamScan((ScanBlock *) &ref_Callouts.DecRef_starts, sizeof(BitBlock)/sizeof(ScanBlock), DecRef_check);
939                }
940
941                if (bitblock_has_bit(ref_Callouts.HexRef_starts)){
942                  StreamScan((ScanBlock *) &ref_Callouts.HexRef_starts, sizeof(BitBlock)/sizeof(ScanBlock), HexRef_check);
943                }
944
945                if (bitblock_has_bit(check_streams.att_refs)){
946                  StreamScan((ScanBlock *) &check_streams.att_refs, sizeof(BitBlock)/sizeof(ScanBlock), AttRef_check);
947                }
948
949                if (bitblock_has_bit(check_streams.error_mask)) {
950                  int errpos = count_forward_zeroes(check_streams.error_mask);
951                  ReportError("error found", errpos);
952              exit(-1);
953                }
954
955                matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
956                tracker.AdvanceBlock();
957}
958
959static inline void postprocess_do_segment(Lex lex[], CtCDPI_Callouts ctCDPI_Callouts[], Ref_Callouts ref_Callouts[], Check_streams check_streams[], int chars_avail){
960
961  for (int i = 0; i < SEGMENT_BLOCKS; i++){
962           postprocess_do_block(lex[i], ctCDPI_Callouts[i], ref_Callouts[i], check_streams[i], chars_avail);
963           block_base += BLOCK_SIZE;
964  }
965
966        matcher.StreamScan(chars_avail);
967        matcher.Advance_buffer();
968        tracker.Advance_buffer();
969}
970
971void do_process(FILE *infile, FILE *outfile) {
972
973  struct U8 u8[SEGMENT_BLOCKS];
974
975  struct Lex lex[SEGMENT_BLOCKS];
976
977  struct Scope1 scope1[SEGMENT_BLOCKS];
978
979  struct CtCDPI_Callouts ctCDPI_Callouts[SEGMENT_BLOCKS];
980
981  struct Ref_Callouts ref_Callouts[SEGMENT_BLOCKS];
982
983  struct Tag_Callouts tag_Callouts[SEGMENT_BLOCKS];
984
985  struct Basis_bits basis_bits[SEGMENT_BLOCKS];
986
987  struct Masks masks[SEGMENT_BLOCKS];
988
989  struct Check_streams check_streams[SEGMENT_BLOCKS];
990
991  struct Xml_names xml_names[SEGMENT_BLOCKS];
992
993
994  for(int i=0;i<SEGMENT_BLOCKS;i++)
995          masks[i].EOF_mask = simd_const_1(1);
996  BitBlock EOF_mask = simd_const_1(1);
997
998  int buf_pos = 0;
999  int block_pos = 0;
1000  int errpos = 0;
1001  int chars_avail = 0;
1002  int check_pos = 0;
1003  int chars_read = 0;
1004  BytePack buf[(BUFFER_SIZE+BLOCK_SIZE+OVERLAP_BUFSIZE*2)/sizeof(SIMD_type)];
1005
1006  char * srcbuf = ((char *) buf) + OVERLAP_BUFSIZE;
1007  buffer_base = buf_pos;
1008  source = srcbuf;
1009
1010  chars_read = fread((void *)srcbuf, 1, BUFFER_SIZE + OVERLAP_BUFSIZE, infile);
1011  chars_avail = min(chars_read,BUFFER_SIZE);
1012
1013  matcher.setSrc(srcbuf);
1014
1015  if(chars_read<4){
1016    fprintf(stderr,"File is too short. Not well formed.\n");
1017    exit(-1);
1018  }
1019
1020  Entity_Info * e = new Entity_Info;
1021  e->AnalyzeSignature((unsigned char *)srcbuf);
1022
1023  if (e->code_unit_base == ASCII) {
1024
1025    XML_Decl_Parser<ASCII> decl_parser((unsigned char *)srcbuf);
1026
1027    decl_parser.ReadXMLInfo(*e);
1028
1029    if (e->code_unit_size != SingleByte || (e->has_encoding_decl && (!at_UTF_8(e->encoding)))){
1030        fprintf(stderr,"Sorry, this xmlwf demo only works for UTF-8.\n");
1031        exit(-1);
1032    }
1033  }
1034  else {
1035    fprintf(stderr,"Sorry, this xmlwf demo does not process EBCDIC.\n");
1036        exit(-1);
1037  }
1038
1039  if (e->content_start != 0) {
1040        memmove(&srcbuf[0], &srcbuf[e->content_start], chars_read - e->content_start);
1041        buf_pos = e->content_start;
1042        if (chars_avail == BUFFER_SIZE) {
1043                chars_read = chars_read - e->content_start +
1044                             fread(&srcbuf[chars_read-e->content_start], 1, e->content_start, infile);
1045                chars_avail = min(chars_read,BUFFER_SIZE);
1046        }
1047        else {
1048          chars_read -=e->content_start;
1049          chars_avail -=e->content_start;
1050        }
1051  }
1052
1053  Parse_refs parse_refs;
1054  Parse_tags parse_tags;
1055  Classify_bytes_Validate_utf8 classify_bytes_Validate_utf8;
1056  Parse_CtCDPI parse_CtCDPI;
1057  Do_check_streams do_check_streams;
1058  Validate_xml_names validate_xml_names;
1059  Add_scope_streams add_scope_streams;
1060
1061
1062  while(1){
1063#if PASS == TOTAL
1064    PERF_SEC_START(parser_timer);
1065#endif
1066    block_pos = 0;
1067
1068    if(chars_avail < BUFFER_SIZE){
1069
1070                int i=0;
1071                while (block_pos <= chars_avail || CarryTest(parse_refs.carryQ, 0, 6) || CarryTest(parse_tags.carryQ, 0, 13) || CarryTest(classify_bytes_Validate_utf8.carryQ, 0, 12) || CarryTest(parse_CtCDPI.carryQ, 0, 18) || CarryTest(validate_xml_names.carryQ, 0, 9) || CarryTest(add_scope_streams.carryQ, 0, 2)){
1072
1073                        int bytes = chars_avail - block_pos;
1074                        block_base = block_pos;
1075
1076                        if(bytes < BLOCK_SIZE){
1077                          masks[i].EOF_mask = sisd_srl(simd_const_1(1),sisd_from_int(BLOCK_SIZE-bytes));
1078                          EOF_mask = sisd_srl(simd_const_1(1),sisd_from_int(BLOCK_SIZE-bytes));
1079                        }
1080
1081                        s2p_do_block((BytePack *) &srcbuf[block_pos], basis_bits[i]);
1082
1083                        basis_bits[i].bit_0 = simd_and(basis_bits[i].bit_0, masks[i].EOF_mask);
1084                        basis_bits[i].bit_1 = simd_and(basis_bits[i].bit_1, masks[i].EOF_mask);
1085                        basis_bits[i].bit_2 = simd_and(basis_bits[i].bit_2, masks[i].EOF_mask);
1086                        basis_bits[i].bit_3 = simd_and(basis_bits[i].bit_3, masks[i].EOF_mask);
1087                        basis_bits[i].bit_4 = simd_and(basis_bits[i].bit_4, masks[i].EOF_mask);
1088                        basis_bits[i].bit_5 = simd_and(basis_bits[i].bit_5, masks[i].EOF_mask);
1089                        basis_bits[i].bit_6 = simd_and(basis_bits[i].bit_6, masks[i].EOF_mask);
1090                        basis_bits[i].bit_7 = simd_and(basis_bits[i].bit_7, masks[i].EOF_mask);
1091
1092                       
1093  classify_bytes_Validate_utf8.do_block(basis_bits[i], lex[i], u8[i]);
1094  add_scope_streams.do_block(lex[i], scope1[i]);
1095  parse_CtCDPI.do_block(ctCDPI_Callouts[i], lex[i], scope1[i], masks[i], check_streams[i]);
1096  parse_tags.do_block(lex[i], scope1[i], ctCDPI_Callouts[i], tag_Callouts[i], masks[i]);
1097  parse_refs.do_block(lex[i], scope1[i], ctCDPI_Callouts[i], ref_Callouts[i]);
1098  validate_xml_names.do_block(ctCDPI_Callouts[i], ref_Callouts[i], tag_Callouts[i], lex[i], u8[i], xml_names[i], check_streams[i]);
1099  do_check_streams.do_block(ctCDPI_Callouts[i], tag_Callouts[i], lex[i], u8[i], scope1[i], ref_Callouts[i], xml_names[i], check_streams[i], masks[i]);
1100
1101                        postprocess_do_block(lex[i], ctCDPI_Callouts[i], ref_Callouts[i], check_streams[i], chars_avail);
1102
1103                        block_pos += BLOCK_SIZE;
1104                }
1105                i++;
1106
1107            matcher.StreamScan(chars_avail);
1108            matcher.Advance_buffer();
1109            tracker.Advance_buffer();
1110    }
1111    else{
1112      while (block_pos < chars_avail){
1113
1114          block_base = block_pos;
1115
1116#if PASS == S2P
1117          PERF_SEC_START(s2p_timer);
1118#endif
1119          s2p_do_segment((BytePack *) &srcbuf[block_pos], basis_bits);
1120#if PASS == S2P
1121          PERF_SEC_END(s2p_timer, BLOCK_SIZE * SEGMENT_BLOCKS);
1122#endif
1123
1124#if PASS == CLASSIFY
1125          PERF_SEC_START(classify_timer);
1126#endif
1127                  classify_bytes_Validate_utf8.do_segment(basis_bits, lex, u8);
1128#if PASS == CLASSIFY
1129                  PERF_SEC_END(classify_timer, BLOCK_SIZE * SEGMENT_BLOCKS);
1130#endif
1131
1132#if PASS == SCOPE
1133                  PERF_SEC_START(scope_timer);
1134#endif
1135                  add_scope_streams.do_segment(lex, scope1);
1136#if PASS == SCOPE
1137                  PERF_SEC_END(scope_timer, BLOCK_SIZE * SEGMENT_BLOCKS);
1138#endif
1139
1140#if PASS == CTCDPI
1141                  PERF_SEC_START(CtCDPI_timer);
1142#endif
1143                  parse_CtCDPI.do_segment(ctCDPI_Callouts, lex, scope1, masks, check_streams);
1144#if PASS == CTCDPI
1145                  PERF_SEC_END(CtCDPI_timer, BLOCK_SIZE * SEGMENT_BLOCKS);
1146#endif
1147
1148#if PASS == TAGS
1149                  PERF_SEC_START(tags_timer);
1150#endif
1151                  parse_tags.do_segment(lex, scope1, ctCDPI_Callouts, tag_Callouts, masks);
1152#if PASS == TAGS
1153                  PERF_SEC_END(tags_timer, BLOCK_SIZE * SEGMENT_BLOCKS);
1154#endif
1155
1156#if PASS == REFS
1157                  PERF_SEC_START(refs_timer);
1158#endif
1159                  parse_refs.do_segment(lex, scope1, ctCDPI_Callouts, ref_Callouts);
1160#if PASS == REFS
1161                  PERF_SEC_END(refs_timer, BLOCK_SIZE * SEGMENT_BLOCKS);
1162#endif
1163
1164#if PASS == VALIDATE
1165                  PERF_SEC_START(validate_timer);
1166#endif
1167                  validate_xml_names.do_segment(ctCDPI_Callouts, ref_Callouts, tag_Callouts, lex, u8, xml_names, check_streams);
1168#if PASS == VALIDATE
1169                  PERF_SEC_END(validate_timer, BLOCK_SIZE * SEGMENT_BLOCKS);
1170#endif
1171                 
1172#if PASS == CHECK
1173                  PERF_SEC_START(check_timer);
1174#endif
1175                  do_check_streams.do_segment(ctCDPI_Callouts, tag_Callouts, lex, u8, scope1, ref_Callouts, xml_names, check_streams, masks);
1176#if PASS == CHECK
1177                  PERF_SEC_END(check_timer, BLOCK_SIZE * SEGMENT_BLOCKS);
1178#endif
1179
1180#if PASS == POSTPROCESS
1181                  PERF_SEC_START(postprocess_timer);
1182#endif
1183                  postprocess_do_segment(lex, ctCDPI_Callouts, ref_Callouts, check_streams, chars_avail);
1184#if PASS == POSTPROCESS
1185                  PERF_SEC_END(postprocess_timer, BLOCK_SIZE * SEGMENT_BLOCKS);
1186#endif
1187
1188                  block_pos += BLOCK_SIZE * SEGMENT_BLOCKS;
1189      }
1190    }
1191
1192
1193
1194#if PASS == TOTAL
1195    PERF_SEC_END(parser_timer, chars_avail);
1196#endif
1197    buf_pos += chars_avail;
1198    buffer_base = buf_pos;
1199    if(chars_avail!=chars_read){
1200      int bytes_left = chars_read-chars_avail;
1201      memmove(srcbuf, &srcbuf[BUFFER_SIZE], bytes_left);
1202      chars_read = fread(&srcbuf[bytes_left],1, BUFFER_SIZE , infile)+bytes_left;
1203      chars_avail = min(chars_read,BUFFER_SIZE);
1204    }
1205    else
1206      break;
1207  }
1208  if(matcher.depth!=0){
1209    fprintf(stderr, "tag matching error (depth %i) at position %i\n", matcher.depth, buffer_base);
1210    exit(-1);
1211  }
1212
1213}
1214
1215
1216
1217int
1218main(int argc, char * argv[]) {
1219        char * infilename, * outfilename;
1220        FILE *infile, *outfile;
1221        struct stat fileinfo;
1222
1223        if (argc < 2) {
1224                printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
1225                exit(-1);
1226        }
1227
1228        infilename = argv[1];
1229        stat(infilename, &fileinfo);
1230        infile = fopen(infilename, "rb");
1231        if (!infile) {
1232                fprintf(stderr, "Error: cannot open %s for input.\n", infilename);
1233                exit(-1);
1234        }
1235
1236        if (argc < 3) outfile = stdout;
1237        else {
1238                outfilename = argv[2];
1239                outfile = fopen(outfilename, "wb");
1240                if (!outfile) {
1241                        fprintf(stderr, "Error: cannot open %s for writing.\n", outfilename);
1242                        exit(-1);
1243                }
1244        }
1245
1246//      PERF_SEC_BIND(1);
1247#if PASS == TOTAL
1248        PERF_SEC_INIT(parser_timer);
1249#endif
1250#if PASS == S2P
1251        PERF_SEC_INIT(s2p_timer);
1252#endif
1253#if PASS == CLASSIFY
1254        PERF_SEC_INIT(classify_timer);
1255#endif
1256#if PASS == SCOPE
1257        PERF_SEC_INIT(scope_timer);
1258#endif
1259#if PASS == TAGS
1260        PERF_SEC_INIT(tags_timer);
1261#endif
1262#if PASS == CTCDPI
1263        PERF_SEC_INIT(CtCDPI_timer);
1264#endif
1265#if PASS == REFS
1266        PERF_SEC_INIT(refs_timer);
1267#endif
1268#if PASS == VALIDATE
1269        PERF_SEC_INIT(validate_timer);
1270#endif
1271#if PASS == CHECK
1272        PERF_SEC_INIT(check_timer);
1273#endif
1274#if PASS == POSTPROCESS
1275        PERF_SEC_INIT(postprocess_timer);
1276#endif
1277
1278        do_process(infile, outfile);
1279#if PASS == TOTAL
1280//    printf("This is the total time.\n");
1281        PERF_SEC_DUMP(parser_timer);
1282#endif
1283#if PASS == S2P
1284//      printf("This is the transposition time.\n");
1285        PERF_SEC_DUMP(s2p_timer);
1286#endif
1287#if PASS == CLASSIFY
1288//      printf("This is the classification and utf8 validation time.\n");
1289        PERF_SEC_DUMP(classify_timer);
1290#endif
1291#if PASS == SCOPE
1292//      printf("This is the time for generating scope treams.\n");
1293        PERF_SEC_DUMP(scope_timer);
1294#endif
1295#if PASS == CTCDPI
1296//      printf("This is the CtCDPI parsing time.\n");
1297        PERF_SEC_DUMP(CtCDPI_timer);
1298#endif
1299#if PASS == TAGS
1300//      printf("This is the tags parsing time.\n");
1301        PERF_SEC_DUMP(tags_timer);
1302#endif
1303#if PASS == REFS
1304//      printf("This is the reference parsing time.\n");
1305        PERF_SEC_DUMP(refs_timer);
1306#endif
1307#if PASS == VALIDATE
1308//      printf("This is the XML names validation time.\n");
1309        PERF_SEC_DUMP(validate_timer);
1310#endif
1311#if PASS == CHECK
1312//      printf("This is the time for generating check streams.\n");
1313        PERF_SEC_DUMP(check_timer);
1314#endif
1315#if PASS == POSTPROCESS
1316//      printf("This is the post processing time.\n");
1317        PERF_SEC_DUMP(postprocess_timer);
1318#endif
1319
1320
1321#if PASS == TOTAL
1322        parser_timer->display_raw_data();
1323        PERF_SEC_DESTROY(parser_timer);
1324#endif
1325#if PASS == S2P
1326        PERF_SEC_DESTROY(s2p_timer);
1327#endif
1328#if PASS == CLASSIFY
1329        PERF_SEC_DESTROY(classify_timer);
1330#endif
1331#if PASS == SCOPE
1332        PERF_SEC_DESTROY(scope_timer);
1333#endif
1334#if PASS == TAGS
1335        PERF_SEC_DESTROY(tags_timer);
1336#endif
1337#if PASS == CTCDPI
1338        PERF_SEC_DESTROY(CtCDPI_timer);
1339#endif
1340#if PASS == REFS
1341        PERF_SEC_DESTROY(refs_timer);
1342#endif
1343#if PASS == VALIDATE
1344        PERF_SEC_DESTROY(validate_timer);
1345#endif
1346#if PASS == CHECK
1347        PERF_SEC_DESTROY(check_timer);
1348#endif
1349#if PASS == POSTPROCESS
1350        PERF_SEC_DESTROY(postprocess_timer);
1351#endif
1352
1353        fclose(infile);
1354        fclose(outfile);
1355        return(0);
1356}
Note: See TracBrowser for help on using the repository browser.