source: proto/pabloj/trunk/output/cpplang/pablo_definitions.hpp @ 3260

Last change on this file since 3260 was 3260, checked in by ksherdy, 6 years ago

Added PabloB state node and state parameters to Kernels.

File size: 63.7 KB
Line 
1// GENERATED CODE. DO NOT MODIFY.
2//
3// This template includes the minimal set of runtime support libraries required
4// to support compilation of PabloJ generated C++ code (bitblock.hpp, carryQ.hpp,
5// pabloSupport.hpp, error_tracker.hpp)
6//
7// (c) 2012, 2013 Robert D. Cameron, Ken Herdy
8// All rights reserved.
9// Licensed to International Characters, Inc. under Academic Free License 3.0
10//
11//////////////////////////////////////////////////////////////////////////////////////////
12// @ global - Stream structure and stream function declarations.
13//
14//////////////////////////////////////////////////////////////////////////////////////////
15//
16#ifndef PABLO_DEFINITIONS_HPP
17#define PABLO_DEFINITIONS_HPP
18
19// runtime libraries
20#include <simd-lib/bitblock.hpp>
21#include <simd-lib/carryQ.hpp>
22#include <simd-lib/pabloSupport.hpp>
23
24// migrate error tracker, line/column tracker to compiler runtime
25#include <ErrorTracker.h>
26ErrorTracker error_tracker;
27
28#define assert_0_error(errkind, errstrm) error_tracker.NoteError(errkind, errstrm);
29BitBlock EOF_mask = simd<1>::constant<1>();
30
31
32// XMLWF application headers and definitions
33/*
34#include <stdio.h>
35#include <stdlib.h>
36#include <errno.h>
37#include <sys/types.h>
38#include <sys/stat.h>
39
40#include <simd-lib/s2p.hpp>
41#include <simd-lib/buffer.hpp>
42#include <simd-lib/bitblock_iterator.hpp>
43#include <simd-lib/perflib/perfsec.h>
44
45#include <xmldecl.h>
46#include <namechars.h>
47#include <LineColTracker.hpp>
48#include <XMLTestSuiteError.h>
49
50// Define the mappings for pablo.assert_0(strm, errkind) statements which
51// compile to the the form assert_0_error(errkind, strm)
52#include <ErrorTracker.h>
53
54ErrorTracker error_tracker;
55#define assert_0_error(errkind, errstrm) error_tracker.NoteError(errkind, errstrm);
56*/
57
58// namespace pablo
59// {
60struct Basis_bits
61{
62        BitBlock bit_0;
63        BitBlock bit_1;
64        BitBlock bit_2;
65        BitBlock bit_3;
66        BitBlock bit_4;
67        BitBlock bit_5;
68        BitBlock bit_6;
69        BitBlock bit_7;
70};
71 
72struct U8
73{
74        BitBlock unibyte;
75        BitBlock prefix;
76        BitBlock prefix2;
77        BitBlock prefix3;
78        BitBlock prefix4;
79        BitBlock suffix;
80        BitBlock badprefix;
81        BitBlock xE0;
82        BitBlock xED;
83        BitBlock xF0;
84        BitBlock xF4;
85        BitBlock xA0_xBF;
86        BitBlock x80_x9F;
87        BitBlock x90_xBF;
88        BitBlock x80_x8F;
89        BitBlock xEF;
90        BitBlock xBF;
91        BitBlock xBE;
92        BitBlock scope22;
93        BitBlock scope32;
94        BitBlock scope33;
95        BitBlock scope42;
96        BitBlock scope43;
97        BitBlock scope44;
98        BitBlock xE0_scope;
99        BitBlock xED_scope;
100        BitBlock xF0_scope;
101        BitBlock xF4_scope;
102        BitBlock xEF_scope;
103};
104 
105struct Lex
106{
107        BitBlock CR;
108        BitBlock LF;
109        BitBlock HT;
110        BitBlock SP;
111        BitBlock CRLF;
112        BitBlock RefStart;
113        BitBlock Semicolon;
114        BitBlock Colon;
115        BitBlock LAngle;
116        BitBlock RAngle;
117        BitBlock LBracket;
118        BitBlock RBracket;
119        BitBlock Exclam;
120        BitBlock QMark;
121        BitBlock Hyphen;
122        BitBlock Equals;
123        BitBlock SQuote;
124        BitBlock DQuote;
125        BitBlock Slash;
126        BitBlock Hash;
127        BitBlock x;
128        BitBlock ASCII_name_start;
129        BitBlock ASCII_name_char;
130        BitBlock NameScan;
131        BitBlock Digit;
132        BitBlock Hex;
133        BitBlock WS;
134};
135 
136struct Marker
137{
138        BitBlock LAngle_scope;
139        BitBlock Ref_opener;
140        BitBlock CD_closer;
141};
142 
143struct CtCDPI_Callouts
144{
145        BitBlock Ct_starts;
146        BitBlock Ct_ends;
147        BitBlock CD_starts;
148        BitBlock CD_ends;
149        BitBlock PI_starts;
150        BitBlock PI_name_starts;
151        BitBlock PI_name_ends;
152        BitBlock PI_ends;
153};
154 
155struct Ref_Callouts
156{
157        BitBlock GenRef_starts;
158        BitBlock GenRef_ends;
159        BitBlock DecRef_starts;
160        BitBlock DecRef_ends;
161        BitBlock HexRef_starts;
162        BitBlock HexRef_ends;
163};
164 
165struct Tag_Callouts
166{
167        BitBlock ElemName_starts;
168        BitBlock ElemName_ends;
169        BitBlock AttName_starts;
170        BitBlock AttName_ends;
171        BitBlock AttVal_starts;
172        BitBlock AttVal_ends;
173        BitBlock AttVal_spans;
174        BitBlock EmptyTag_marks;
175        BitBlock EndTag_marks;
176};
177 
178struct Check_streams
179{
180        BitBlock misc_mask;
181        BitBlock non_ascii_name_starts;
182        BitBlock non_ascii_names;
183        BitBlock tag_marks;
184        BitBlock name_follows;
185        BitBlock att_refs;
186};
187 
188struct Classify_bytes_Validate_utf8
189{
190        Classify_bytes_Validate_utf8()
191        {
192        }
193         
194        IDISA_INLINE void do_block(struct Basis_bits & basis_bits,struct Lex & lex,struct U8 & u8)
195        {
196                BitBlock temp1 = simd_or(basis_bits.bit_0,basis_bits.bit_1);
197                BitBlock temp2 = simd_andc(basis_bits.bit_2,basis_bits.bit_3);
198                BitBlock temp3 = simd_andc(temp2,temp1);
199                BitBlock temp4 = simd_andc(basis_bits.bit_5,basis_bits.bit_4);
200                BitBlock temp5 = simd_andc(basis_bits.bit_6,basis_bits.bit_7);
201                BitBlock temp6 = simd_and(temp4,temp5);
202                lex.RefStart = simd_and(temp3,temp6);
203                BitBlock temp7 = simd_and(basis_bits.bit_2,basis_bits.bit_3);
204                BitBlock temp8 = simd_andc(temp7,temp1);
205                BitBlock temp9 = simd_andc(basis_bits.bit_4,basis_bits.bit_5);
206                BitBlock temp10 = simd_and(basis_bits.bit_6,basis_bits.bit_7);
207                BitBlock temp11 = simd_and(temp9,temp10);
208                lex.Semicolon = simd_and(temp8,temp11);
209                BitBlock temp12 = simd_and(basis_bits.bit_4,basis_bits.bit_5);
210                BitBlock temp13 = simd_or(basis_bits.bit_6,basis_bits.bit_7);
211                BitBlock temp14 = simd_andc(temp12,temp13);
212                lex.LAngle = simd_and(temp8,temp14);
213                BitBlock temp15 = simd_and(temp12,temp5);
214                lex.RAngle = simd_and(temp8,temp15);
215                BitBlock temp16 = simd_andc(basis_bits.bit_1,basis_bits.bit_0);
216                BitBlock temp17 = simd_andc(basis_bits.bit_3,basis_bits.bit_2);
217                BitBlock temp18 = simd_and(temp16,temp17);
218                lex.LBracket = simd_and(temp18,temp11);
219                BitBlock temp19 = simd_andc(basis_bits.bit_7,basis_bits.bit_6);
220                BitBlock temp20 = simd_and(temp12,temp19);
221                lex.RBracket = simd_and(temp18,temp20);
222                BitBlock temp21 = simd_or(basis_bits.bit_4,basis_bits.bit_5);
223                BitBlock temp22 = simd_andc(temp19,temp21);
224                lex.Exclam = simd_and(temp3,temp22);
225                BitBlock temp23 = simd_and(temp12,temp10);
226                lex.QMark = simd_and(temp8,temp23);
227                lex.Hyphen = simd_and(temp3,temp20);
228                lex.Equals = simd_and(temp8,temp20);
229                BitBlock temp24 = simd_and(temp4,temp10);
230                lex.SQuote = simd_and(temp3,temp24);
231                BitBlock temp25 = simd_andc(temp5,temp21);
232                lex.DQuote = simd_and(temp3,temp25);
233                lex.Slash = simd_and(temp3,temp23);
234                BitBlock temp26 = simd_andc(temp10,temp21);
235                lex.Hash = simd_and(temp3,temp26);
236                BitBlock temp27 = simd_and(temp16,temp7);
237                BitBlock temp28 = simd_andc(temp9,temp13);
238                lex.x = simd_and(temp27,temp28);
239                BitBlock temp29 = simd_and(temp9,temp5);
240                lex.Colon = simd_and(temp8,temp29);
241                BitBlock temp30 = simd_and(temp18,temp23);
242                BitBlock temp31 = simd_or(temp30,lex.Colon);
243                BitBlock temp32 = simd_andc(temp16,basis_bits.bit_2);
244                BitBlock temp33 = simd_or(basis_bits.bit_5,temp10);
245                BitBlock temp34 = simd_and(basis_bits.bit_4,temp33);
246                BitBlock temp35 = simd_not(temp34);
247                BitBlock temp36 = simd_or(temp21,temp13);
248                BitBlock temp37 = simd_or(simd_and(basis_bits.bit_3,temp35),simd_andc(temp36,basis_bits.bit_3));
249                BitBlock temp38 = simd_and(temp32,temp37);
250                BitBlock temp39 = simd_or(temp31,temp38);
251                BitBlock temp40 = simd_and(temp16,basis_bits.bit_2);
252                BitBlock temp41 = simd_and(temp40,temp37);
253                lex.ASCII_name_start = simd_or(temp39,temp41);
254                BitBlock temp42 = simd_or(temp30,lex.Hyphen);
255                BitBlock temp43 = simd_and(temp3,temp15);
256                BitBlock temp44 = simd_or(temp42,temp43);
257                BitBlock temp45 = simd_andc(temp8,temp34);
258                BitBlock temp46 = simd_or(temp44,temp45);
259                BitBlock temp47 = simd_or(temp46,temp38);
260                lex.ASCII_name_char = simd_or(temp47,temp41);
261                lex.NameScan = simd_or(lex.ASCII_name_char,basis_bits.bit_0);
262                BitBlock temp48 = simd_or(temp1,basis_bits.bit_2);
263                BitBlock x00_x1F = simd_not(temp48);
264                BitBlock temp49 = simd_or(basis_bits.bit_2,basis_bits.bit_3);
265                BitBlock temp50 = simd_or(temp1,temp49);
266                lex.CR = simd_andc(temp20,temp50);
267                lex.LF = simd_andc(temp29,temp50);
268                BitBlock temp51 = simd_and(temp9,temp19);
269                lex.HT = simd_andc(temp51,temp50);
270                lex.SP = simd_andc(temp3,temp36);
271                BitBlock temp52 = simd_or(temp20,temp29);
272                BitBlock temp53 = simd_or(temp52,temp51);
273                BitBlock temp54 = simd_andc(temp53,temp50);
274                lex.WS = simd_or(temp54,lex.SP);
275                BitBlock temp55 = simd_or(basis_bits.bit_5,basis_bits.bit_6);
276                BitBlock temp56 = simd_and(basis_bits.bit_4,temp55);
277                lex.Digit = simd_andc(temp8,temp56);
278                BitBlock temp57 = simd_andc(temp16,temp49);
279                BitBlock temp58 = simd_andc(temp57,basis_bits.bit_4);
280                BitBlock temp59 = simd_not(temp10);
281                BitBlock temp60 = simd_or(simd_and(basis_bits.bit_5,temp59),simd_andc(temp13,basis_bits.bit_5));
282                BitBlock temp61 = simd_and(temp58,temp60);
283                BitBlock temp62 = simd_or(lex.Digit,temp61);
284                BitBlock temp63 = simd_and(temp16,temp2);
285                BitBlock temp64 = simd_andc(temp63,basis_bits.bit_4);
286                BitBlock temp65 = simd_and(temp64,temp60);
287                lex.Hex = simd_or(temp62,temp65);
288                BitBlock lex_error = simd_andc(x00_x1F,lex.WS);
289                if (bitblock::any(lex_error))
290                {
291                        assert_0_error("Error: illegal character",lex_error);
292                }
293                u8.unibyte = simd_not(basis_bits.bit_0);
294                u8.suffix = simd<1>::constant<0>();
295                BitBlock u8_error = simd<1>::constant<0>();
296                BitBlock u8_FFFE_FFFF = simd<1>::constant<0>();
297                BitBlock u8anyscope = simd<1>::constant<0>();
298                if (bitblock::any(simd_or(basis_bits.bit_0,carry_set_0.CarryRange(0,10))))
299                {
300                        u8.prefix = simd_and(basis_bits.bit_0,basis_bits.bit_1);
301                        u8.prefix2 = simd_andc(u8.prefix,basis_bits.bit_2);
302                        u8.prefix3 = simd_and(u8.prefix,temp2);
303                        u8.prefix4 = simd_and(u8.prefix,temp7);
304                        u8.suffix = simd_andc(basis_bits.bit_0,basis_bits.bit_1);
305                        BitBlock temp66 = simd_andc(u8.prefix,temp49);
306                        BitBlock temp67 = simd_or(temp21,basis_bits.bit_6);
307                        BitBlock temp68 = simd_andc(temp66,temp67);
308                        BitBlock temp69 = simd_and(basis_bits.bit_5,temp13);
309                        BitBlock temp70 = simd_or(basis_bits.bit_4,temp69);
310                        BitBlock temp71 = simd_and(u8.prefix4,temp70);
311                        u8.badprefix = simd_or(temp68,temp71);
312                        u8_error = u8.badprefix;
313                        u8.scope22 = carry_set_0.BitBlock_advance_ci_co(u8.prefix2,carry_set_0.GetCarry(0),0);
314                        u8anyscope = u8.scope22;
315                        if (bitblock::any(simd_or(simd_or(u8.prefix3,u8.prefix4),carry_set_0.CarryRange(1,9))))
316                        {
317                                BitBlock xE0 = simd_andc(u8.prefix3,temp36);
318                                BitBlock xED = simd_and(u8.prefix3,temp20);
319                                BitBlock xF0 = simd_andc(u8.prefix4,temp36);
320                                BitBlock temp72 = simd_andc(temp4,temp13);
321                                BitBlock xF4 = simd_and(u8.prefix4,temp72);
322                                u8.xA0_xBF = simd_and(u8.suffix,basis_bits.bit_2);
323                                u8.x80_x9F = simd_andc(u8.suffix,basis_bits.bit_2);
324                                u8.x90_xBF = simd_and(u8.suffix,temp49);
325                                u8.x80_x8F = simd_andc(u8.suffix,temp49);
326                                BitBlock xEF = simd_and(u8.prefix3,temp23);
327                                BitBlock temp73 = simd_and(u8.suffix,temp7);
328                                u8.xBF = simd_and(temp73,temp23);
329                                u8.xBE = simd_and(temp73,temp15);
330                                u8.scope32 = carry_set_0.BitBlock_advance_ci_co(u8.prefix3,carry_set_0.GetCarry(1),1);
331                                u8.scope33 = carry_set_0.BitBlock_advance_ci_co(u8.scope32,carry_set_0.GetCarry(2),2);
332                                u8.scope42 = carry_set_0.BitBlock_advance_ci_co(u8.prefix4,carry_set_0.GetCarry(3),3);
333                                u8.scope43 = carry_set_0.BitBlock_advance_ci_co(u8.scope42,carry_set_0.GetCarry(4),4);
334                                u8.scope44 = carry_set_0.BitBlock_advance_ci_co(u8.scope43,carry_set_0.GetCarry(5),5);
335                                BitBlock E0_F0_scope = carry_set_0.BitBlock_advance_ci_co(simd_or(xE0,xF0),carry_set_0.GetCarry(6),6);
336                                BitBlock ED_F4_scope = carry_set_0.BitBlock_advance_ci_co(simd_or(xED,xF4),carry_set_0.GetCarry(7),7);
337                                u8.xE0_scope = simd_and(u8.scope32,E0_F0_scope);
338                                u8.xED_scope = simd_and(u8.scope32,ED_F4_scope);
339                                u8.xF0_scope = simd_and(u8.scope42,E0_F0_scope);
340                                u8.xF4_scope = simd_and(u8.scope42,ED_F4_scope);
341                                u8.xEF_scope = carry_set_0.BitBlock_advance_ci_co(xEF,carry_set_0.GetCarry(8),8);
342                                BitBlock u8lastscope = simd_or(simd_or(u8.scope22,u8.scope33),u8.scope44);
343                                u8anyscope = simd_or(simd_or(simd_or(u8lastscope,u8.scope32),u8.scope42),u8.scope43);
344                                BitBlock u8error1 = simd_and(u8.xE0_scope,u8.x80_x9F);
345                                BitBlock u8error2 = simd_and(u8.xED_scope,u8.xA0_xBF);
346                                BitBlock u8error3 = simd_and(u8.xF0_scope,u8.x80_x8F);
347                                BitBlock u8error4 = simd_and(u8.xF4_scope,u8.x90_xBF);
348                                u8_error = simd_or(u8_error,simd_or(simd_or(simd_or(u8error1,u8error2),u8error3),u8error4));
349                                BitBlock EF_BF_pending = carry_set_0.BitBlock_advance_ci_co(simd_and(u8.xEF_scope,u8.xBF),carry_set_0.GetCarry(9),9);
350                                u8_FFFE_FFFF = simd_and(EF_BF_pending,simd_or(u8.xBE,u8.xBF));
351                        }
352                        else
353                        {
354                                carry_set_0.CarryDequeueEnqueue(1,9);
355                        }
356                        BitBlock u8mismatch = simd_xor(u8anyscope,u8.suffix);
357                        if (bitblock::any(simd_or(simd_or(u8_error,u8mismatch),u8_FFFE_FFFF)))
358                        {
359                                assert_0_error("UTF-8 error found",simd_or(simd_or(u8_error,u8mismatch),u8_FFFE_FFFF));
360                        }
361                }
362                else
363                {
364                        carry_set_0.CarryDequeueEnqueue(0,10);
365                }
366                carry_set_0.CarryAdjust(10);
367        }
368       
369        void do_final_block(struct Basis_bits & basis_bits,struct Lex & lex,struct U8 & u8,BitBlock & EOF_mask)
370        {
371                BitBlock temp1 = simd_or(basis_bits.bit_0,basis_bits.bit_1);
372                BitBlock temp2 = simd_andc(basis_bits.bit_2,basis_bits.bit_3);
373                BitBlock temp3 = simd_andc(temp2,temp1);
374                BitBlock temp4 = simd_andc(basis_bits.bit_5,basis_bits.bit_4);
375                BitBlock temp5 = simd_andc(basis_bits.bit_6,basis_bits.bit_7);
376                BitBlock temp6 = simd_and(temp4,temp5);
377                lex.RefStart = simd_and(temp3,temp6);
378                BitBlock temp7 = simd_and(basis_bits.bit_2,basis_bits.bit_3);
379                BitBlock temp8 = simd_andc(temp7,temp1);
380                BitBlock temp9 = simd_andc(basis_bits.bit_4,basis_bits.bit_5);
381                BitBlock temp10 = simd_and(basis_bits.bit_6,basis_bits.bit_7);
382                BitBlock temp11 = simd_and(temp9,temp10);
383                lex.Semicolon = simd_and(temp8,temp11);
384                BitBlock temp12 = simd_and(basis_bits.bit_4,basis_bits.bit_5);
385                BitBlock temp13 = simd_or(basis_bits.bit_6,basis_bits.bit_7);
386                BitBlock temp14 = simd_andc(temp12,temp13);
387                lex.LAngle = simd_and(temp8,temp14);
388                BitBlock temp15 = simd_and(temp12,temp5);
389                lex.RAngle = simd_and(temp8,temp15);
390                BitBlock temp16 = simd_andc(basis_bits.bit_1,basis_bits.bit_0);
391                BitBlock temp17 = simd_andc(basis_bits.bit_3,basis_bits.bit_2);
392                BitBlock temp18 = simd_and(temp16,temp17);
393                lex.LBracket = simd_and(temp18,temp11);
394                BitBlock temp19 = simd_andc(basis_bits.bit_7,basis_bits.bit_6);
395                BitBlock temp20 = simd_and(temp12,temp19);
396                lex.RBracket = simd_and(temp18,temp20);
397                BitBlock temp21 = simd_or(basis_bits.bit_4,basis_bits.bit_5);
398                BitBlock temp22 = simd_andc(temp19,temp21);
399                lex.Exclam = simd_and(temp3,temp22);
400                BitBlock temp23 = simd_and(temp12,temp10);
401                lex.QMark = simd_and(temp8,temp23);
402                lex.Hyphen = simd_and(temp3,temp20);
403                lex.Equals = simd_and(temp8,temp20);
404                BitBlock temp24 = simd_and(temp4,temp10);
405                lex.SQuote = simd_and(temp3,temp24);
406                BitBlock temp25 = simd_andc(temp5,temp21);
407                lex.DQuote = simd_and(temp3,temp25);
408                lex.Slash = simd_and(temp3,temp23);
409                BitBlock temp26 = simd_andc(temp10,temp21);
410                lex.Hash = simd_and(temp3,temp26);
411                BitBlock temp27 = simd_and(temp16,temp7);
412                BitBlock temp28 = simd_andc(temp9,temp13);
413                lex.x = simd_and(temp27,temp28);
414                BitBlock temp29 = simd_and(temp9,temp5);
415                lex.Colon = simd_and(temp8,temp29);
416                BitBlock temp30 = simd_and(temp18,temp23);
417                BitBlock temp31 = simd_or(temp30,lex.Colon);
418                BitBlock temp32 = simd_andc(temp16,basis_bits.bit_2);
419                BitBlock temp33 = simd_or(basis_bits.bit_5,temp10);
420                BitBlock temp34 = simd_and(basis_bits.bit_4,temp33);
421                BitBlock temp35 = simd_not(temp34);
422                BitBlock temp36 = simd_or(temp21,temp13);
423                BitBlock temp37 = simd_or(simd_and(basis_bits.bit_3,temp35),simd_andc(temp36,basis_bits.bit_3));
424                BitBlock temp38 = simd_and(temp32,temp37);
425                BitBlock temp39 = simd_or(temp31,temp38);
426                BitBlock temp40 = simd_and(temp16,basis_bits.bit_2);
427                BitBlock temp41 = simd_and(temp40,temp37);
428                lex.ASCII_name_start = simd_or(temp39,temp41);
429                BitBlock temp42 = simd_or(temp30,lex.Hyphen);
430                BitBlock temp43 = simd_and(temp3,temp15);
431                BitBlock temp44 = simd_or(temp42,temp43);
432                BitBlock temp45 = simd_andc(temp8,temp34);
433                BitBlock temp46 = simd_or(temp44,temp45);
434                BitBlock temp47 = simd_or(temp46,temp38);
435                lex.ASCII_name_char = simd_or(temp47,temp41);
436                lex.NameScan = simd_or(lex.ASCII_name_char,basis_bits.bit_0);
437                BitBlock temp48 = simd_or(temp1,basis_bits.bit_2);
438                BitBlock x00_x1F = simd_not(temp48);
439                BitBlock temp49 = simd_or(basis_bits.bit_2,basis_bits.bit_3);
440                BitBlock temp50 = simd_or(temp1,temp49);
441                lex.CR = simd_andc(temp20,temp50);
442                lex.LF = simd_andc(temp29,temp50);
443                BitBlock temp51 = simd_and(temp9,temp19);
444                lex.HT = simd_andc(temp51,temp50);
445                lex.SP = simd_andc(temp3,temp36);
446                BitBlock temp52 = simd_or(temp20,temp29);
447                BitBlock temp53 = simd_or(temp52,temp51);
448                BitBlock temp54 = simd_andc(temp53,temp50);
449                lex.WS = simd_or(temp54,lex.SP);
450                BitBlock temp55 = simd_or(basis_bits.bit_5,basis_bits.bit_6);
451                BitBlock temp56 = simd_and(basis_bits.bit_4,temp55);
452                lex.Digit = simd_andc(temp8,temp56);
453                BitBlock temp57 = simd_andc(temp16,temp49);
454                BitBlock temp58 = simd_andc(temp57,basis_bits.bit_4);
455                BitBlock temp59 = simd_not(temp10);
456                BitBlock temp60 = simd_or(simd_and(basis_bits.bit_5,temp59),simd_andc(temp13,basis_bits.bit_5));
457                BitBlock temp61 = simd_and(temp58,temp60);
458                BitBlock temp62 = simd_or(lex.Digit,temp61);
459                BitBlock temp63 = simd_and(temp16,temp2);
460                BitBlock temp64 = simd_andc(temp63,basis_bits.bit_4);
461                BitBlock temp65 = simd_and(temp64,temp60);
462                lex.Hex = simd_or(temp62,temp65);
463                BitBlock lex_error = simd_andc(x00_x1F,lex.WS);
464                if (bitblock::any(simd_and(lex_error,EOF_mask)))
465                {
466                        assert_0_error("Error: illegal character",simd_and(lex_error,EOF_mask));
467                }
468                u8.unibyte = simd_not(basis_bits.bit_0);
469                u8.suffix = simd<1>::constant<0>();
470                BitBlock u8_error = simd<1>::constant<0>();
471                BitBlock u8_FFFE_FFFF = simd<1>::constant<0>();
472                BitBlock u8anyscope = simd<1>::constant<0>();
473                if (bitblock::any(simd_or(basis_bits.bit_0,carry_set_0.CarryRange(0,10))))
474                {
475                        u8.prefix = simd_and(basis_bits.bit_0,basis_bits.bit_1);
476                        u8.prefix2 = simd_andc(u8.prefix,basis_bits.bit_2);
477                        u8.prefix3 = simd_and(u8.prefix,temp2);
478                        u8.prefix4 = simd_and(u8.prefix,temp7);
479                        u8.suffix = simd_andc(basis_bits.bit_0,basis_bits.bit_1);
480                        BitBlock temp66 = simd_andc(u8.prefix,temp49);
481                        BitBlock temp67 = simd_or(temp21,basis_bits.bit_6);
482                        BitBlock temp68 = simd_andc(temp66,temp67);
483                        BitBlock temp69 = simd_and(basis_bits.bit_5,temp13);
484                        BitBlock temp70 = simd_or(basis_bits.bit_4,temp69);
485                        BitBlock temp71 = simd_and(u8.prefix4,temp70);
486                        u8.badprefix = simd_or(temp68,temp71);
487                        u8_error = u8.badprefix;
488                        u8.scope22 = carry_set_0.BitBlock_advance_ci_co(u8.prefix2,carry_set_0.GetCarry(0),0);
489                        u8anyscope = u8.scope22;
490                        if (bitblock::any(simd_or(simd_or(u8.prefix3,u8.prefix4),carry_set_0.CarryRange(1,9))))
491                        {
492                                BitBlock xE0 = simd_andc(u8.prefix3,temp36);
493                                BitBlock xED = simd_and(u8.prefix3,temp20);
494                                BitBlock xF0 = simd_andc(u8.prefix4,temp36);
495                                BitBlock temp72 = simd_andc(temp4,temp13);
496                                BitBlock xF4 = simd_and(u8.prefix4,temp72);
497                                u8.xA0_xBF = simd_and(u8.suffix,basis_bits.bit_2);
498                                u8.x80_x9F = simd_andc(u8.suffix,basis_bits.bit_2);
499                                u8.x90_xBF = simd_and(u8.suffix,temp49);
500                                u8.x80_x8F = simd_andc(u8.suffix,temp49);
501                                BitBlock xEF = simd_and(u8.prefix3,temp23);
502                                BitBlock temp73 = simd_and(u8.suffix,temp7);
503                                u8.xBF = simd_and(temp73,temp23);
504                                u8.xBE = simd_and(temp73,temp15);
505                                u8.scope32 = carry_set_0.BitBlock_advance_ci_co(u8.prefix3,carry_set_0.GetCarry(1),1);
506                                u8.scope33 = carry_set_0.BitBlock_advance_ci_co(u8.scope32,carry_set_0.GetCarry(2),2);
507                                u8.scope42 = carry_set_0.BitBlock_advance_ci_co(u8.prefix4,carry_set_0.GetCarry(3),3);
508                                u8.scope43 = carry_set_0.BitBlock_advance_ci_co(u8.scope42,carry_set_0.GetCarry(4),4);
509                                u8.scope44 = carry_set_0.BitBlock_advance_ci_co(u8.scope43,carry_set_0.GetCarry(5),5);
510                                BitBlock E0_F0_scope = carry_set_0.BitBlock_advance_ci_co(simd_or(xE0,xF0),carry_set_0.GetCarry(6),6);
511                                BitBlock ED_F4_scope = carry_set_0.BitBlock_advance_ci_co(simd_or(xED,xF4),carry_set_0.GetCarry(7),7);
512                                u8.xE0_scope = simd_and(u8.scope32,E0_F0_scope);
513                                u8.xED_scope = simd_and(u8.scope32,ED_F4_scope);
514                                u8.xF0_scope = simd_and(u8.scope42,E0_F0_scope);
515                                u8.xF4_scope = simd_and(u8.scope42,ED_F4_scope);
516                                u8.xEF_scope = carry_set_0.BitBlock_advance_ci_co(xEF,carry_set_0.GetCarry(8),8);
517                                BitBlock u8lastscope = simd_or(simd_or(u8.scope22,u8.scope33),u8.scope44);
518                                u8anyscope = simd_or(simd_or(simd_or(u8lastscope,u8.scope32),u8.scope42),u8.scope43);
519                                BitBlock u8error1 = simd_and(u8.xE0_scope,u8.x80_x9F);
520                                BitBlock u8error2 = simd_and(u8.xED_scope,u8.xA0_xBF);
521                                BitBlock u8error3 = simd_and(u8.xF0_scope,u8.x80_x8F);
522                                BitBlock u8error4 = simd_and(u8.xF4_scope,u8.x90_xBF);
523                                u8_error = simd_or(u8_error,simd_or(simd_or(simd_or(u8error1,u8error2),u8error3),u8error4));
524                                BitBlock EF_BF_pending = carry_set_0.BitBlock_advance_ci_co(simd_and(u8.xEF_scope,u8.xBF),carry_set_0.GetCarry(9),9);
525                                u8_FFFE_FFFF = simd_and(EF_BF_pending,simd_or(u8.xBE,u8.xBF));
526                        }
527                        else
528                        {
529                                carry_set_0.CarryDequeueEnqueue(1,9);
530                        }
531                        BitBlock u8mismatch = simd_xor(u8anyscope,u8.suffix);
532                        if (bitblock::any(simd_or(simd_or(u8_error,u8mismatch),u8_FFFE_FFFF)))
533                        {
534                                assert_0_error("UTF-8 error found",simd_or(simd_or(u8_error,u8mismatch),u8_FFFE_FFFF));
535                        }
536                }
537                else
538                {
539                        carry_set_0.CarryDequeueEnqueue(0,10);
540                }
541        }
542       
543        CarryDeclare(carry_set_0,10,0);
544};
545 
546struct Parse_CtCDPI
547{
548        Parse_CtCDPI()
549        {
550                carry_set_0.SetCarry(carry_set_0.CarryFlip(carry_set_0.GetCarry(2)),2);
551                }
552                 
553                IDISA_INLINE void do_block(struct Lex & lex,struct Marker & marker,struct CtCDPI_Callouts & ctCDPI_Callouts,struct Check_streams & check_streams)
554                {
555                        ctCDPI_Callouts.Ct_starts = simd<1>::constant<0>();
556                        ctCDPI_Callouts.Ct_ends = simd<1>::constant<0>();
557                        ctCDPI_Callouts.CD_starts = simd<1>::constant<0>();
558                        ctCDPI_Callouts.CD_ends = simd<1>::constant<0>();
559                        ctCDPI_Callouts.PI_starts = simd<1>::constant<0>();
560                        ctCDPI_Callouts.PI_name_starts = simd<1>::constant<0>();
561                        ctCDPI_Callouts.PI_name_ends = simd<1>::constant<0>();
562                        ctCDPI_Callouts.PI_ends = simd<1>::constant<0>();
563                        BitBlock CtCDPI_starts = simd<1>::constant<0>();
564                        BitBlock CtCDPI_ends = simd<1>::constant<0>();
565                        BitBlock ctCDPI_mask = simd<1>::constant<0>();
566                        BitBlock v = simd_or(lex.LAngle,lex.Hyphen);
567                        BitBlock w = simd_or(lex.Hyphen,lex.QMark);
568                        BitBlock v1 = carry_set_0.BitBlock_advance_n_<1>(v,carry_set_0.Pending64(0),0);
569                        BitBlock w1 = carry_set_0.BitBlock_advance_n_<1>(w,carry_set_0.Pending64(1),1);
570                        BitBlock LAngle_scope = simd_andc(v1,w1);
571                        BitBlock PI_opener = simd_and(LAngle_scope,lex.QMark);
572                        BitBlock CtCD_opener = simd_and(LAngle_scope,lex.Exclam);
573                        BitBlock CtCDPI_opener = simd_or(PI_opener,CtCD_opener);
574                        BitBlock CD_closer = simd<1>::constant<0>();
575                        BitBlock DoubleHyphen = simd_and(simd_and(v1,w1),lex.Hyphen);
576                        if (bitblock::any(simd_or(lex.RBracket,carry_set_0.CarryRange(0,2))))
577                        {
578                                BitBlock DoubleRBracket = simd_and(carry_set_0.BitBlock_advance_ci_co(lex.RBracket,carry_set_0.GetCarry(0),0),lex.RBracket);
579                                CD_closer = simd_and(carry_set_0.BitBlock_advance_ci_co(DoubleRBracket,carry_set_0.GetCarry(1),1),lex.RAngle);
580                        }
581                        else
582                        {
583                                carry_set_0.CarryDequeueEnqueue(0,2);
584                        }
585                        BitBlock PI_closer = simd_and(simd_andc(w1,v1),lex.RAngle);
586                        BitBlock CtCDPI_Cursor = carry_set_0.BitBlock_scantofirst(CtCDPI_opener,carry_set_0.GetCarry(2),2);
587                        if (bitblock::any(simd_or(CtCDPI_Cursor,carry_set_0.CarryRange(3,13))))
588                        {
589                                CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
590                                BitBlock PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
591                                BitBlock CD_Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor,PI_Cursor),carry_set_0.GetCarry(3),3);
592                                BitBlock CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
593                                BitBlock Ct_Cursor = simd_and(CD_Ct_Cursor,lex.Hyphen);
594                                if (bitblock::any(simd_or(PI_Cursor,carry_set_0.CarryRange(4,4))))
595                                {
596                                        ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts,PI_Cursor);
597                                        PI_Cursor = carry_set_0.BitBlock_advance_ci_co(PI_Cursor,carry_set_0.GetCarry(4),4);
598                                        ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts,PI_Cursor);
599                                        BitBlock PI_name_end = carry_set_0.BitBlock_scanthru_ci_co(PI_Cursor,lex.NameScan,carry_set_0.GetCarry(5),5);
600                                        BitBlock PI_error = simd_and(PI_Cursor,PI_name_end);
601                                        BitBlock PI_noWS = simd_andc(PI_name_end,lex.WS);
602                                        PI_error = simd_or(PI_error,simd_or(simd_andc(PI_noWS,lex.QMark),simd_andc(carry_set_0.BitBlock_advance_ci_co(PI_noWS,carry_set_0.GetCarry(6),6),PI_closer)));
603                                        if (bitblock::any(PI_error))
604                                        {
605                                                assert_0_error("Error in PI syntax",PI_error);
606                                        }
607                                        ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends,PI_name_end);
608                                        PI_Cursor = carry_set_0.BitBlock_scanthru_ci_co(PI_name_end,simd_not(PI_closer),carry_set_0.GetCarry(7),7);
609                                        ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends,PI_Cursor);
610                                        CtCDPI_ends = simd_or(CtCDPI_ends,PI_Cursor);
611                                }
612                                else
613                                {
614                                        carry_set_0.CarryDequeueEnqueue(4,4);
615                                }
616                                if (bitblock::any(simd_or(CD_Cursor,carry_set_0.CarryRange(8,1))))
617                                {
618                                        ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts,CD_Cursor);
619                                        CD_Cursor = carry_set_0.BitBlock_scanthru_ci_co(CD_Cursor,simd_not(CD_closer),carry_set_0.GetCarry(8),8);
620                                        ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends,CD_Cursor);
621                                        CtCDPI_ends = simd_or(CtCDPI_ends,CD_Cursor);
622                                }
623                                else
624                                {
625                                        carry_set_0.CarryDequeueEnqueue(8,1);
626                                }
627                                if (bitblock::any(simd_or(Ct_Cursor,carry_set_0.CarryRange(9,5))))
628                                {
629                                        ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts,Ct_Cursor);
630                                        Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(Ct_Cursor,carry_set_0.GetCarry(9),9);
631                                        BitBlock Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
632                                        Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(carry_set_0.BitBlock_advance_ci_co(Ct_Cursor,carry_set_0.GetCarry(10),10),carry_set_0.GetCarry(11),11);
633                                        Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(carry_set_0.BitBlock_scanthru_ci_co(Ct_Cursor,simd_not(DoubleHyphen),carry_set_0.GetCarry(12),12),carry_set_0.GetCarry(13),13);
634                                        if (bitblock::any(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle))))
635                                        {
636                                                assert_0_error("Error in comment syntax",simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle)));
637                                        }
638                                        ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends,Ct_Cursor);
639                                        CtCDPI_ends = simd_or(CtCDPI_ends,Ct_Cursor);
640                                }
641                                else
642                                {
643                                        carry_set_0.CarryDequeueEnqueue(9,5);
644                                }
645                                CtCDPI_Cursor = simd_or(simd_or(PI_Cursor,CD_Cursor),Ct_Cursor);
646                                ctCDPI_mask = carry_set_0.BitBlock_inclusive_span(CtCDPI_starts,CtCDPI_ends,carry_set_0.GetCarry(14),14);
647                                if (bitblock::any(simd<1>::constant<0>()))
648                                {
649                                        assert_0_error("Error in comment, CDATA or processing instruction syntax",simd<1>::constant<0>());
650                                }
651                                CtCDPI_Cursor = carry_set_0.BitBlock_scanthru_ci_co(CtCDPI_Cursor,simd_not(CtCDPI_opener),carry_set_0.GetCarry(15),15);
652                                while (bitblock::any(CtCDPI_Cursor))
653                                {
654                                        CarryDeclare(carry_set_1,13,0);
655                                        CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
656                                        BitBlock PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
657                                        BitBlock CD_Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor,PI_Cursor),simd<1>::constant<0>(),0);
658                                        BitBlock CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
659                                        BitBlock Ct_Cursor = simd_and(CD_Ct_Cursor,lex.Hyphen);
660                                        if (bitblock::any(PI_Cursor))
661                                        {
662                                                ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts,PI_Cursor);
663                                                PI_Cursor = carry_set_1.BitBlock_advance_ci_co(PI_Cursor,simd<1>::constant<0>(),1);
664                                                ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts,PI_Cursor);
665                                                BitBlock PI_name_end = carry_set_1.BitBlock_scanthru_ci_co(PI_Cursor,lex.NameScan,simd<1>::constant<0>(),2);
666                                                BitBlock PI_error = simd_and(PI_Cursor,PI_name_end);
667                                                BitBlock PI_noWS = simd_andc(PI_name_end,lex.WS);
668                                                PI_error = simd_or(PI_error,simd_or(simd_andc(PI_noWS,lex.QMark),simd_andc(carry_set_1.BitBlock_advance_ci_co(PI_noWS,simd<1>::constant<0>(),3),PI_closer)));
669                                                if (bitblock::any(PI_error))
670                                                {
671                                                        assert_0_error("Error in PI syntax",PI_error);
672                                                }
673                                                ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends,PI_name_end);
674                                                PI_Cursor = carry_set_1.BitBlock_scanthru_ci_co(PI_name_end,simd_not(PI_closer),simd<1>::constant<0>(),4);
675                                                ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends,PI_Cursor);
676                                                CtCDPI_ends = simd_or(CtCDPI_ends,PI_Cursor);
677                                        }
678                                        if (bitblock::any(CD_Cursor))
679                                        {
680                                                ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts,CD_Cursor);
681                                                CD_Cursor = carry_set_1.BitBlock_scanthru_ci_co(CD_Cursor,simd_not(CD_closer),simd<1>::constant<0>(),5);
682                                                ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends,CD_Cursor);
683                                                CtCDPI_ends = simd_or(CtCDPI_ends,CD_Cursor);
684                                        }
685                                        if (bitblock::any(Ct_Cursor))
686                                        {
687                                                ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts,Ct_Cursor);
688                                                Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(Ct_Cursor,simd<1>::constant<0>(),6);
689                                                BitBlock Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
690                                                Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(carry_set_1.BitBlock_advance_ci_co(Ct_Cursor,simd<1>::constant<0>(),7),simd<1>::constant<0>(),8);
691                                                Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(carry_set_1.BitBlock_scanthru_ci_co(Ct_Cursor,simd_not(DoubleHyphen),simd<1>::constant<0>(),9),simd<1>::constant<0>(),10);
692                                                if (bitblock::any(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle))))
693                                                {
694                                                        assert_0_error("Error in comment syntax",simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle)));
695                                                }
696                                                ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends,Ct_Cursor);
697                                                CtCDPI_ends = simd_or(CtCDPI_ends,Ct_Cursor);
698                                        }
699                                        CtCDPI_Cursor = simd_or(simd_or(PI_Cursor,CD_Cursor),Ct_Cursor);
700                                        ctCDPI_mask = carry_set_1.BitBlock_inclusive_span(CtCDPI_starts,CtCDPI_ends,simd<1>::constant<0>(),11);
701                                        if (bitblock::any(simd<1>::constant<0>()))
702                                        {
703                                                assert_0_error("Error in comment, CDATA or processing instruction syntax",simd<1>::constant<0>());
704                                        }
705                                        CtCDPI_Cursor = carry_set_1.BitBlock_scanthru_ci_co(CtCDPI_Cursor,simd_not(CtCDPI_opener),simd<1>::constant<0>(),12);
706                                        LocalCarryCombine(carry_set_0,carry_set_1,3,13);
707                                }
708                        }
709                        else
710                        {
711                                carry_set_0.CarryDequeueEnqueue(3,13);
712                        }
713                        check_streams.misc_mask = simd_and(simd_or(simd_or(simd_or(lex.WS,lex.LAngle),carry_set_0.BitBlock_inclusive_span(simd_or(ctCDPI_Callouts.Ct_starts,ctCDPI_Callouts.PI_starts),simd_or(ctCDPI_Callouts.Ct_ends,ctCDPI_Callouts.PI_ends),carry_set_0.GetCarry(16),16)),CtCDPI_starts),EOF_mask);
714                        marker.LAngle_scope = simd_andc(LAngle_scope,ctCDPI_mask);
715                        marker.Ref_opener = simd_andc(lex.RefStart,ctCDPI_mask);
716                        marker.CD_closer = simd_andc(CD_closer,ctCDPI_mask);
717                        carry_set_0.CarryAdjust(17);
718                }
719               
720                void do_final_block(struct Lex & lex,struct Marker & marker,struct CtCDPI_Callouts & ctCDPI_Callouts,struct Check_streams & check_streams,BitBlock & EOF_mask)
721                {
722                        ctCDPI_Callouts.Ct_starts = simd<1>::constant<0>();
723                        ctCDPI_Callouts.Ct_ends = simd<1>::constant<0>();
724                        ctCDPI_Callouts.CD_starts = simd<1>::constant<0>();
725                        ctCDPI_Callouts.CD_ends = simd<1>::constant<0>();
726                        ctCDPI_Callouts.PI_starts = simd<1>::constant<0>();
727                        ctCDPI_Callouts.PI_name_starts = simd<1>::constant<0>();
728                        ctCDPI_Callouts.PI_name_ends = simd<1>::constant<0>();
729                        ctCDPI_Callouts.PI_ends = simd<1>::constant<0>();
730                        BitBlock CtCDPI_starts = simd<1>::constant<0>();
731                        BitBlock CtCDPI_ends = simd<1>::constant<0>();
732                        BitBlock ctCDPI_mask = simd<1>::constant<0>();
733                        BitBlock v = simd_or(lex.LAngle,lex.Hyphen);
734                        BitBlock w = simd_or(lex.Hyphen,lex.QMark);
735                        BitBlock v1 = carry_set_0.BitBlock_advance_n_<1>(v,carry_set_0.Pending64(0),0);
736                        BitBlock w1 = carry_set_0.BitBlock_advance_n_<1>(w,carry_set_0.Pending64(1),1);
737                        BitBlock LAngle_scope = simd_andc(v1,w1);
738                        BitBlock PI_opener = simd_and(LAngle_scope,lex.QMark);
739                        BitBlock CtCD_opener = simd_and(LAngle_scope,lex.Exclam);
740                        BitBlock CtCDPI_opener = simd_or(PI_opener,CtCD_opener);
741                        BitBlock CD_closer = simd<1>::constant<0>();
742                        BitBlock DoubleHyphen = simd_and(simd_and(v1,w1),lex.Hyphen);
743                        if (bitblock::any(simd_or(lex.RBracket,carry_set_0.CarryRange(0,2))))
744                        {
745                                BitBlock DoubleRBracket = simd_and(carry_set_0.BitBlock_advance_ci_co(lex.RBracket,carry_set_0.GetCarry(0),0),lex.RBracket);
746                                CD_closer = simd_and(carry_set_0.BitBlock_advance_ci_co(DoubleRBracket,carry_set_0.GetCarry(1),1),lex.RAngle);
747                        }
748                        else
749                        {
750                                carry_set_0.CarryDequeueEnqueue(0,2);
751                        }
752                        BitBlock PI_closer = simd_and(simd_andc(w1,v1),lex.RAngle);
753                        BitBlock CtCDPI_Cursor = carry_set_0.BitBlock_scantofirst(CtCDPI_opener,carry_set_0.GetCarry(2),2);
754                        if (bitblock::any(simd_or(simd_and(CtCDPI_Cursor,EOF_mask),carry_set_0.CarryRange(3,13))))
755                        {
756                                CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
757                                BitBlock PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
758                                BitBlock CD_Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor,PI_Cursor),carry_set_0.GetCarry(3),3);
759                                BitBlock CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
760                                BitBlock Ct_Cursor = simd_and(CD_Ct_Cursor,lex.Hyphen);
761                                if (bitblock::any(simd_or(PI_Cursor,carry_set_0.CarryRange(4,4))))
762                                {
763                                        ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts,PI_Cursor);
764                                        PI_Cursor = carry_set_0.BitBlock_advance_ci_co(PI_Cursor,carry_set_0.GetCarry(4),4);
765                                        ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts,PI_Cursor);
766                                        BitBlock PI_name_end = carry_set_0.BitBlock_scanthru_ci_co(PI_Cursor,lex.NameScan,carry_set_0.GetCarry(5),5);
767                                        BitBlock PI_error = simd_and(PI_Cursor,PI_name_end);
768                                        BitBlock PI_noWS = simd_andc(PI_name_end,lex.WS);
769                                        PI_error = simd_or(PI_error,simd_or(simd_andc(PI_noWS,lex.QMark),simd_andc(carry_set_0.BitBlock_advance_ci_co(PI_noWS,carry_set_0.GetCarry(6),6),PI_closer)));
770                                        if (bitblock::any(PI_error))
771                                        {
772                                                assert_0_error("Error in PI syntax",PI_error);
773                                        }
774                                        ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends,PI_name_end);
775                                        PI_Cursor = carry_set_0.BitBlock_scanthru_ci_co(PI_name_end,simd_andc(EOF_mask,PI_closer),carry_set_0.GetCarry(7),7);
776                                        ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends,PI_Cursor);
777                                        CtCDPI_ends = simd_or(CtCDPI_ends,PI_Cursor);
778                                }
779                                else
780                                {
781                                        carry_set_0.CarryDequeueEnqueue(4,4);
782                                }
783                                if (bitblock::any(simd_or(CD_Cursor,carry_set_0.CarryRange(8,1))))
784                                {
785                                        ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts,CD_Cursor);
786                                        CD_Cursor = carry_set_0.BitBlock_scanthru_ci_co(CD_Cursor,simd_andc(EOF_mask,CD_closer),carry_set_0.GetCarry(8),8);
787                                        ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends,CD_Cursor);
788                                        CtCDPI_ends = simd_or(CtCDPI_ends,CD_Cursor);
789                                }
790                                else
791                                {
792                                        carry_set_0.CarryDequeueEnqueue(8,1);
793                                }
794                                if (bitblock::any(simd_or(Ct_Cursor,carry_set_0.CarryRange(9,5))))
795                                {
796                                        ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts,Ct_Cursor);
797                                        Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(Ct_Cursor,carry_set_0.GetCarry(9),9);
798                                        BitBlock Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
799                                        Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(carry_set_0.BitBlock_advance_ci_co(Ct_Cursor,carry_set_0.GetCarry(10),10),carry_set_0.GetCarry(11),11);
800                                        Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(carry_set_0.BitBlock_scanthru_ci_co(Ct_Cursor,simd_andc(EOF_mask,DoubleHyphen),carry_set_0.GetCarry(12),12),carry_set_0.GetCarry(13),13);
801                                        if (bitblock::any(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle))))
802                                        {
803                                                assert_0_error("Error in comment syntax",simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle)));
804                                        }
805                                        ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends,Ct_Cursor);
806                                        CtCDPI_ends = simd_or(CtCDPI_ends,Ct_Cursor);
807                                }
808                                else
809                                {
810                                        carry_set_0.CarryDequeueEnqueue(9,5);
811                                }
812                                CtCDPI_Cursor = simd_or(simd_or(PI_Cursor,CD_Cursor),Ct_Cursor);
813                                ctCDPI_mask = carry_set_0.BitBlock_inclusive_span(CtCDPI_starts,CtCDPI_ends,carry_set_0.GetCarry(14),14);
814                                if (bitblock::any(simd_andc(ctCDPI_mask,EOF_mask)))
815                                {
816                                        assert_0_error("Error in comment, CDATA or processing instruction syntax",simd_andc(ctCDPI_mask,EOF_mask));
817                                }
818                                CtCDPI_Cursor = carry_set_0.BitBlock_scanthru_ci_co(CtCDPI_Cursor,simd_andc(EOF_mask,CtCDPI_opener),carry_set_0.GetCarry(15),15);
819                                while (bitblock::any(simd_and(CtCDPI_Cursor,EOF_mask)))
820                                {
821                                        CarryDeclare(carry_set_1,13,0);
822                                        CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
823                                        BitBlock PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
824                                        BitBlock CD_Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor,PI_Cursor),simd<1>::constant<0>(),0);
825                                        BitBlock CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
826                                        BitBlock Ct_Cursor = simd_and(CD_Ct_Cursor,lex.Hyphen);
827                                        if (bitblock::any(PI_Cursor))
828                                        {
829                                                ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts,PI_Cursor);
830                                                PI_Cursor = carry_set_1.BitBlock_advance_ci_co(PI_Cursor,simd<1>::constant<0>(),1);
831                                                ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts,PI_Cursor);
832                                                BitBlock PI_name_end = carry_set_1.BitBlock_scanthru_ci_co(PI_Cursor,lex.NameScan,simd<1>::constant<0>(),2);
833                                                BitBlock PI_error = simd_and(PI_Cursor,PI_name_end);
834                                                BitBlock PI_noWS = simd_andc(PI_name_end,lex.WS);
835                                                PI_error = simd_or(PI_error,simd_or(simd_andc(PI_noWS,lex.QMark),simd_andc(carry_set_1.BitBlock_advance_ci_co(PI_noWS,simd<1>::constant<0>(),3),PI_closer)));
836                                                if (bitblock::any(PI_error))
837                                                {
838                                                        assert_0_error("Error in PI syntax",PI_error);
839                                                }
840                                                ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends,PI_name_end);
841                                                PI_Cursor = carry_set_1.BitBlock_scanthru_ci_co(PI_name_end,simd_andc(EOF_mask,PI_closer),simd<1>::constant<0>(),4);
842                                                ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends,PI_Cursor);
843                                                CtCDPI_ends = simd_or(CtCDPI_ends,PI_Cursor);
844                                        }
845                                        if (bitblock::any(CD_Cursor))
846                                        {
847                                                ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts,CD_Cursor);
848                                                CD_Cursor = carry_set_1.BitBlock_scanthru_ci_co(CD_Cursor,simd_andc(EOF_mask,CD_closer),simd<1>::constant<0>(),5);
849                                                ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends,CD_Cursor);
850                                                CtCDPI_ends = simd_or(CtCDPI_ends,CD_Cursor);
851                                        }
852                                        if (bitblock::any(Ct_Cursor))
853                                        {
854                                                ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts,Ct_Cursor);
855                                                Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(Ct_Cursor,simd<1>::constant<0>(),6);
856                                                BitBlock Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
857                                                Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(carry_set_1.BitBlock_advance_ci_co(Ct_Cursor,simd<1>::constant<0>(),7),simd<1>::constant<0>(),8);
858                                                Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(carry_set_1.BitBlock_scanthru_ci_co(Ct_Cursor,simd_andc(EOF_mask,DoubleHyphen),simd<1>::constant<0>(),9),simd<1>::constant<0>(),10);
859                                                if (bitblock::any(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle))))
860                                                {
861                                                        assert_0_error("Error in comment syntax",simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle)));
862                                                }
863                                                ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends,Ct_Cursor);
864                                                CtCDPI_ends = simd_or(CtCDPI_ends,Ct_Cursor);
865                                        }
866                                        CtCDPI_Cursor = simd_or(simd_or(PI_Cursor,CD_Cursor),Ct_Cursor);
867                                        ctCDPI_mask = carry_set_1.BitBlock_inclusive_span(CtCDPI_starts,CtCDPI_ends,simd<1>::constant<0>(),11);
868                                        if (bitblock::any(simd_andc(ctCDPI_mask,EOF_mask)))
869                                        {
870                                                assert_0_error("Error in comment, CDATA or processing instruction syntax",simd_andc(ctCDPI_mask,EOF_mask));
871                                        }
872                                        CtCDPI_Cursor = carry_set_1.BitBlock_scanthru_ci_co(CtCDPI_Cursor,simd_andc(EOF_mask,CtCDPI_opener),simd<1>::constant<0>(),12);
873                                        LocalCarryCombine(carry_set_0,carry_set_1,3,13);
874                                }
875                        }
876                        else
877                        {
878                                carry_set_0.CarryDequeueEnqueue(3,13);
879                        }
880                        check_streams.misc_mask = simd_and(simd_or(simd_or(simd_or(lex.WS,lex.LAngle),carry_set_0.BitBlock_inclusive_span(simd_or(ctCDPI_Callouts.Ct_starts,ctCDPI_Callouts.PI_starts),simd_or(ctCDPI_Callouts.Ct_ends,ctCDPI_Callouts.PI_ends),carry_set_0.GetCarry(16),16)),CtCDPI_starts),EOF_mask);
881                        marker.LAngle_scope = simd_andc(LAngle_scope,ctCDPI_mask);
882                        marker.Ref_opener = simd_andc(lex.RefStart,ctCDPI_mask);
883                        marker.CD_closer = simd_andc(CD_closer,ctCDPI_mask);
884                }
885               
886                CarryDeclare(carry_set_0,17,2);
887        };
888         
889struct Parse_tags
890{
891        Parse_tags()
892        {
893        }
894         
895        IDISA_INLINE void do_block(struct Lex & lex,struct Marker & marker,struct Tag_Callouts & tag_Callouts)
896        {
897                BitBlock EqExpected = simd<1>::constant<0>();
898                BitBlock AttListEnd = simd<1>::constant<0>();
899                BitBlock DQuoteDelim = simd_or(lex.DQuote,lex.LAngle);
900                BitBlock SQuoteDelim = simd_or(lex.SQuote,lex.LAngle);
901                BitBlock AttListDelim = simd_or(lex.Slash,lex.RAngle);
902                tag_Callouts.ElemName_starts = simd_andc(marker.LAngle_scope,lex.Slash);
903                tag_Callouts.EndTag_marks = simd_and(marker.LAngle_scope,lex.Slash);
904                tag_Callouts.ElemName_ends = carry_set_0.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_starts,lex.NameScan,carry_set_0.GetCarry(0),0);
905                BitBlock ParseError = simd_and(tag_Callouts.ElemName_starts,tag_Callouts.ElemName_ends);
906                tag_Callouts.AttName_starts = simd<1>::constant<0>();
907                tag_Callouts.AttName_ends = simd<1>::constant<0>();
908                tag_Callouts.AttVal_starts = simd<1>::constant<0>();
909                tag_Callouts.AttVal_ends = simd<1>::constant<0>();
910                if (bitblock::any(simd_or(simd_and(tag_Callouts.ElemName_ends,lex.WS),carry_set_0.CarryRange(1,8))))
911                {
912                        BitBlock AfterWS = carry_set_0.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_ends,lex.WS,carry_set_0.GetCarry(1),1);
913                        AttListEnd = simd_and(AfterWS,AttListDelim);
914                        BitBlock AttNameStart = simd_andc(AfterWS,AttListDelim);
915                        if (bitblock::any(simd_or(AttNameStart,carry_set_0.CarryRange(2,7))))
916                        {
917                                ParseError = simd_or(ParseError,simd_andc(AttNameStart,lex.NameScan));
918                                tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts,AttNameStart);
919                                BitBlock AttNameFollow = carry_set_0.BitBlock_scanthru_ci_co(AttNameStart,lex.NameScan,carry_set_0.GetCarry(2),2);
920                                tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends,AttNameFollow);
921                                if (bitblock::any(simd_or(simd_and(AttNameFollow,lex.WS),carry_set_0.CarryRange(3,1))))
922                                {
923                                        EqExpected = carry_set_0.BitBlock_scanthru_ci_co(AttNameFollow,lex.WS,carry_set_0.GetCarry(3),3);
924                                }
925                                else
926                                {
927                                        EqExpected = AttNameFollow;
928                                        carry_set_0.CarryDequeueEnqueue(3,1);
929                                }
930                                ParseError = simd_or(ParseError,simd_andc(EqExpected,lex.Equals));
931                                BitBlock AttValPos = carry_set_0.BitBlock_advance_then_scanthru(EqExpected,lex.WS,carry_set_0.GetCarry(4),4);
932                                tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts,AttValPos);
933                                BitBlock DQuoteAttVal = simd_and(AttValPos,lex.DQuote);
934                                BitBlock SQuoteAttVal = simd_and(AttValPos,lex.SQuote);
935                                BitBlock DQuoteAttEnd = carry_set_0.BitBlock_advance_then_scanthru(DQuoteAttVal,simd_not(DQuoteDelim),carry_set_0.GetCarry(5),5);
936                                BitBlock SQuoteAttEnd = carry_set_0.BitBlock_advance_then_scanthru(SQuoteAttVal,simd_not(SQuoteDelim),carry_set_0.GetCarry(6),6);
937                                BitBlock AttValEnd = simd_or(DQuoteAttEnd,SQuoteAttEnd);
938                                ParseError = simd_or(ParseError,simd_andc(simd_or(AttValPos,AttValEnd),simd_or(lex.DQuote,lex.SQuote)));
939                                BitBlock AttValFollow = carry_set_0.BitBlock_advance_ci_co(AttValEnd,carry_set_0.GetCarry(7),7);
940                                tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends,AttValFollow);
941                                if (bitblock::any(simd_or(simd_and(AttValFollow,lex.WS),carry_set_0.CarryRange(8,1))))
942                                {
943                                        AfterWS = carry_set_0.BitBlock_scanthru_ci_co(AttValFollow,lex.WS,carry_set_0.GetCarry(8),8);
944                                        AttListEnd = simd_or(AttListEnd,simd_and(AfterWS,AttListDelim));
945                                        AttNameStart = simd_andc(AfterWS,AttListDelim);
946                                }
947                                else
948                                {
949                                        AttListEnd = simd_or(AttListEnd,simd_and(AttValFollow,AttListDelim));
950                                        AttNameStart = simd_andc(AttValFollow,AttListDelim);
951                                        carry_set_0.CarryDequeueEnqueue(8,1);
952                                }
953                                ParseError = simd_or(ParseError,simd_and(AttValFollow,AttNameStart));
954                                while (bitblock::any(AttNameStart))
955                                {
956                                        CarryDeclare(carry_set_1,7,0);
957                                        ParseError = simd_or(ParseError,simd_andc(AttNameStart,lex.NameScan));
958                                        tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts,AttNameStart);
959                                        BitBlock AttNameFollow = carry_set_1.BitBlock_scanthru_ci_co(AttNameStart,lex.NameScan,simd<1>::constant<0>(),0);
960                                        tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends,AttNameFollow);
961                                        if (bitblock::any(simd_and(AttNameFollow,lex.WS)))
962                                        {
963                                                EqExpected = carry_set_1.BitBlock_scanthru_ci_co(AttNameFollow,lex.WS,simd<1>::constant<0>(),1);
964                                        }
965                                        else
966                                        {
967                                                EqExpected = AttNameFollow;
968                                        }
969                                        ParseError = simd_or(ParseError,simd_andc(EqExpected,lex.Equals));
970                                        BitBlock AttValPos = carry_set_1.BitBlock_advance_then_scanthru(EqExpected,lex.WS,simd<1>::constant<0>(),2);
971                                        tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts,AttValPos);
972                                        BitBlock DQuoteAttVal = simd_and(AttValPos,lex.DQuote);
973                                        BitBlock SQuoteAttVal = simd_and(AttValPos,lex.SQuote);
974                                        BitBlock DQuoteAttEnd = carry_set_1.BitBlock_advance_then_scanthru(DQuoteAttVal,simd_not(DQuoteDelim),simd<1>::constant<0>(),3);
975                                        BitBlock SQuoteAttEnd = carry_set_1.BitBlock_advance_then_scanthru(SQuoteAttVal,simd_not(SQuoteDelim),simd<1>::constant<0>(),4);
976                                        BitBlock AttValEnd = simd_or(DQuoteAttEnd,SQuoteAttEnd);
977                                        ParseError = simd_or(ParseError,simd_andc(simd_or(AttValPos,AttValEnd),simd_or(lex.DQuote,lex.SQuote)));
978                                        BitBlock AttValFollow = carry_set_1.BitBlock_advance_ci_co(AttValEnd,simd<1>::constant<0>(),5);
979                                        tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends,AttValFollow);
980                                        if (bitblock::any(simd_and(AttValFollow,lex.WS)))
981                                        {
982                                                AfterWS = carry_set_1.BitBlock_scanthru_ci_co(AttValFollow,lex.WS,simd<1>::constant<0>(),6);
983                                                AttListEnd = simd_or(AttListEnd,simd_and(AfterWS,AttListDelim));
984                                                AttNameStart = simd_andc(AfterWS,AttListDelim);
985                                        }
986                                        else
987                                        {
988                                                AttListEnd = simd_or(AttListEnd,simd_and(AttValFollow,AttListDelim));
989                                                AttNameStart = simd_andc(AttValFollow,AttListDelim);
990                                        }
991                                        ParseError = simd_or(ParseError,simd_and(AttValFollow,AttNameStart));
992                                        LocalCarryCombine(carry_set_0,carry_set_1,2,7);
993                                }
994                        }
995                        else
996                        {
997                                carry_set_0.CarryDequeueEnqueue(2,7);
998                        }
999                }
1000                else
1001                {
1002                        AttListEnd = simd_and(tag_Callouts.ElemName_ends,AttListDelim);
1003                        ParseError = simd_or(ParseError,simd_andc(tag_Callouts.ElemName_ends,AttListDelim));
1004                        carry_set_0.CarryDequeueEnqueue(1,8);
1005                }
1006                BitBlock STagEnds = simd_and(AttListEnd,lex.RAngle);
1007                tag_Callouts.EmptyTag_marks = carry_set_0.BitBlock_advance_ci_co(simd_and(AttListEnd,lex.Slash),carry_set_0.GetCarry(9),9);
1008                ParseError = simd_or(ParseError,simd_andc(tag_Callouts.EmptyTag_marks,lex.RAngle));
1009                BitBlock EndTagEnds = carry_set_0.BitBlock_advance_then_scanthru(tag_Callouts.EndTag_marks,lex.NameScan,carry_set_0.GetCarry(10),10);
1010                if (bitblock::any(simd_or(simd_and(EndTagEnds,lex.WS),carry_set_0.CarryRange(11,1))))
1011                {
1012                        EndTagEnds = carry_set_0.BitBlock_scanthru_ci_co(EndTagEnds,lex.WS,carry_set_0.GetCarry(11),11);
1013                }
1014                else
1015                {
1016                        carry_set_0.CarryDequeueEnqueue(11,1);
1017                }
1018                ParseError = simd_or(ParseError,simd_andc(EndTagEnds,lex.RAngle));
1019                if (bitblock::any(ParseError))
1020                {
1021                        assert_0_error("Tag parsing error found",ParseError);
1022                }
1023                tag_Callouts.AttVal_spans = carry_set_0.BitBlock_span_upto(tag_Callouts.AttVal_starts,tag_Callouts.AttVal_ends,carry_set_0.GetCarry(12),12);
1024                carry_set_0.CarryAdjust(13);
1025        }
1026       
1027        void do_final_block(struct Lex & lex,struct Marker & marker,struct Tag_Callouts & tag_Callouts,BitBlock & EOF_mask)
1028        {
1029                BitBlock EqExpected = simd<1>::constant<0>();
1030                BitBlock AttListEnd = simd<1>::constant<0>();
1031                BitBlock DQuoteDelim = simd_or(lex.DQuote,lex.LAngle);
1032                BitBlock SQuoteDelim = simd_or(lex.SQuote,lex.LAngle);
1033                BitBlock AttListDelim = simd_or(lex.Slash,lex.RAngle);
1034                tag_Callouts.ElemName_starts = simd_andc(marker.LAngle_scope,lex.Slash);
1035                tag_Callouts.EndTag_marks = simd_and(marker.LAngle_scope,lex.Slash);
1036                tag_Callouts.ElemName_ends = carry_set_0.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_starts,lex.NameScan,carry_set_0.GetCarry(0),0);
1037                BitBlock ParseError = simd_and(tag_Callouts.ElemName_starts,tag_Callouts.ElemName_ends);
1038                tag_Callouts.AttName_starts = simd<1>::constant<0>();
1039                tag_Callouts.AttName_ends = simd<1>::constant<0>();
1040                tag_Callouts.AttVal_starts = simd<1>::constant<0>();
1041                tag_Callouts.AttVal_ends = simd<1>::constant<0>();
1042                if (bitblock::any(simd_or(simd_and(tag_Callouts.ElemName_ends,lex.WS),carry_set_0.CarryRange(1,8))))
1043                {
1044                        BitBlock AfterWS = carry_set_0.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_ends,lex.WS,carry_set_0.GetCarry(1),1);
1045                        AttListEnd = simd_and(AfterWS,AttListDelim);
1046                        BitBlock AttNameStart = simd_andc(AfterWS,AttListDelim);
1047                        if (bitblock::any(simd_or(simd_and(AttNameStart,EOF_mask),carry_set_0.CarryRange(2,7))))
1048                        {
1049                                ParseError = simd_or(ParseError,simd_andc(AttNameStart,lex.NameScan));
1050                                tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts,AttNameStart);
1051                                BitBlock AttNameFollow = carry_set_0.BitBlock_scanthru_ci_co(AttNameStart,lex.NameScan,carry_set_0.GetCarry(2),2);
1052                                tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends,AttNameFollow);
1053                                if (bitblock::any(simd_or(simd_and(AttNameFollow,lex.WS),carry_set_0.CarryRange(3,1))))
1054                                {
1055                                        EqExpected = carry_set_0.BitBlock_scanthru_ci_co(AttNameFollow,lex.WS,carry_set_0.GetCarry(3),3);
1056                                }
1057                                else
1058                                {
1059                                        EqExpected = AttNameFollow;
1060                                        carry_set_0.CarryDequeueEnqueue(3,1);
1061                                }
1062                                ParseError = simd_or(ParseError,simd_andc(EqExpected,lex.Equals));
1063                                BitBlock AttValPos = carry_set_0.BitBlock_advance_then_scanthru(EqExpected,lex.WS,carry_set_0.GetCarry(4),4);
1064                                tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts,AttValPos);
1065                                BitBlock DQuoteAttVal = simd_and(AttValPos,lex.DQuote);
1066                                BitBlock SQuoteAttVal = simd_and(AttValPos,lex.SQuote);
1067                                BitBlock DQuoteAttEnd = carry_set_0.BitBlock_advance_then_scanthru(DQuoteAttVal,simd_andc(EOF_mask,DQuoteDelim),carry_set_0.GetCarry(5),5);
1068                                BitBlock SQuoteAttEnd = carry_set_0.BitBlock_advance_then_scanthru(SQuoteAttVal,simd_andc(EOF_mask,SQuoteDelim),carry_set_0.GetCarry(6),6);
1069                                BitBlock AttValEnd = simd_or(DQuoteAttEnd,SQuoteAttEnd);
1070                                ParseError = simd_or(ParseError,simd_andc(simd_or(AttValPos,AttValEnd),simd_or(lex.DQuote,lex.SQuote)));
1071                                BitBlock AttValFollow = carry_set_0.BitBlock_advance_ci_co(AttValEnd,carry_set_0.GetCarry(7),7);
1072                                tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends,AttValFollow);
1073                                if (bitblock::any(simd_or(simd_and(AttValFollow,lex.WS),carry_set_0.CarryRange(8,1))))
1074                                {
1075                                        AfterWS = carry_set_0.BitBlock_scanthru_ci_co(AttValFollow,lex.WS,carry_set_0.GetCarry(8),8);
1076                                        AttListEnd = simd_or(AttListEnd,simd_and(AfterWS,AttListDelim));
1077                                        AttNameStart = simd_andc(AfterWS,AttListDelim);
1078                                }
1079                                else
1080                                {
1081                                        AttListEnd = simd_or(AttListEnd,simd_and(AttValFollow,AttListDelim));
1082                                        AttNameStart = simd_andc(AttValFollow,AttListDelim);
1083                                        carry_set_0.CarryDequeueEnqueue(8,1);
1084                                }
1085                                ParseError = simd_or(ParseError,simd_and(AttValFollow,AttNameStart));
1086                                while (bitblock::any(simd_and(AttNameStart,EOF_mask)))
1087                                {
1088                                        CarryDeclare(carry_set_1,7,0);
1089                                        ParseError = simd_or(ParseError,simd_andc(AttNameStart,lex.NameScan));
1090                                        tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts,AttNameStart);
1091                                        BitBlock AttNameFollow = carry_set_1.BitBlock_scanthru_ci_co(AttNameStart,lex.NameScan,simd<1>::constant<0>(),0);
1092                                        tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends,AttNameFollow);
1093                                        if (bitblock::any(simd_and(AttNameFollow,lex.WS)))
1094                                        {
1095                                                EqExpected = carry_set_1.BitBlock_scanthru_ci_co(AttNameFollow,lex.WS,simd<1>::constant<0>(),1);
1096                                        }
1097                                        else
1098                                        {
1099                                                EqExpected = AttNameFollow;
1100                                        }
1101                                        ParseError = simd_or(ParseError,simd_andc(EqExpected,lex.Equals));
1102                                        BitBlock AttValPos = carry_set_1.BitBlock_advance_then_scanthru(EqExpected,lex.WS,simd<1>::constant<0>(),2);
1103                                        tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts,AttValPos);
1104                                        BitBlock DQuoteAttVal = simd_and(AttValPos,lex.DQuote);
1105                                        BitBlock SQuoteAttVal = simd_and(AttValPos,lex.SQuote);
1106                                        BitBlock DQuoteAttEnd = carry_set_1.BitBlock_advance_then_scanthru(DQuoteAttVal,simd_andc(EOF_mask,DQuoteDelim),simd<1>::constant<0>(),3);
1107                                        BitBlock SQuoteAttEnd = carry_set_1.BitBlock_advance_then_scanthru(SQuoteAttVal,simd_andc(EOF_mask,SQuoteDelim),simd<1>::constant<0>(),4);
1108                                        BitBlock AttValEnd = simd_or(DQuoteAttEnd,SQuoteAttEnd);
1109                                        ParseError = simd_or(ParseError,simd_andc(simd_or(AttValPos,AttValEnd),simd_or(lex.DQuote,lex.SQuote)));
1110                                        BitBlock AttValFollow = carry_set_1.BitBlock_advance_ci_co(AttValEnd,simd<1>::constant<0>(),5);
1111                                        tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends,AttValFollow);
1112                                        if (bitblock::any(simd_and(AttValFollow,lex.WS)))
1113                                        {
1114                                                AfterWS = carry_set_1.BitBlock_scanthru_ci_co(AttValFollow,lex.WS,simd<1>::constant<0>(),6);
1115                                                AttListEnd = simd_or(AttListEnd,simd_and(AfterWS,AttListDelim));
1116                                                AttNameStart = simd_andc(AfterWS,AttListDelim);
1117                                        }
1118                                        else
1119                                        {
1120                                                AttListEnd = simd_or(AttListEnd,simd_and(AttValFollow,AttListDelim));
1121                                                AttNameStart = simd_andc(AttValFollow,AttListDelim);
1122                                        }
1123                                        ParseError = simd_or(ParseError,simd_and(AttValFollow,AttNameStart));
1124                                        LocalCarryCombine(carry_set_0,carry_set_1,2,7);
1125                                }
1126                        }
1127                        else
1128                        {
1129                                carry_set_0.CarryDequeueEnqueue(2,7);
1130                        }
1131                }
1132                else
1133                {
1134                        AttListEnd = simd_and(tag_Callouts.ElemName_ends,AttListDelim);
1135                        ParseError = simd_or(ParseError,simd_andc(tag_Callouts.ElemName_ends,AttListDelim));
1136                        carry_set_0.CarryDequeueEnqueue(1,8);
1137                }
1138                BitBlock STagEnds = simd_and(AttListEnd,lex.RAngle);
1139                tag_Callouts.EmptyTag_marks = carry_set_0.BitBlock_advance_ci_co(simd_and(AttListEnd,lex.Slash),carry_set_0.GetCarry(9),9);
1140                ParseError = simd_or(ParseError,simd_andc(tag_Callouts.EmptyTag_marks,lex.RAngle));
1141                BitBlock EndTagEnds = carry_set_0.BitBlock_advance_then_scanthru(tag_Callouts.EndTag_marks,lex.NameScan,carry_set_0.GetCarry(10),10);
1142                if (bitblock::any(simd_or(simd_and(EndTagEnds,lex.WS),carry_set_0.CarryRange(11,1))))
1143                {
1144                        EndTagEnds = carry_set_0.BitBlock_scanthru_ci_co(EndTagEnds,lex.WS,carry_set_0.GetCarry(11),11);
1145                }
1146                else
1147                {
1148                        carry_set_0.CarryDequeueEnqueue(11,1);
1149                }
1150                ParseError = simd_or(ParseError,simd_andc(EndTagEnds,lex.RAngle));
1151                if (bitblock::any(ParseError))
1152                {
1153                        assert_0_error("Tag parsing error found",ParseError);
1154                }
1155                tag_Callouts.AttVal_spans = carry_set_0.BitBlock_span_upto(tag_Callouts.AttVal_starts,tag_Callouts.AttVal_ends,carry_set_0.GetCarry(12),12);
1156        }
1157       
1158        CarryDeclare(carry_set_0,13,0);
1159};
1160 
1161struct Parse_refs
1162{
1163        Parse_refs()
1164        {
1165        }
1166         
1167        IDISA_INLINE void do_block(struct Lex & lex,struct Marker & marker,struct Ref_Callouts & ref_Callouts)
1168        {
1169                ref_Callouts.GenRef_starts = simd<1>::constant<0>();
1170                ref_Callouts.GenRef_ends = simd<1>::constant<0>();
1171                ref_Callouts.DecRef_starts = simd<1>::constant<0>();
1172                ref_Callouts.DecRef_ends = simd<1>::constant<0>();
1173                ref_Callouts.HexRef_starts = simd<1>::constant<0>();
1174                ref_Callouts.HexRef_ends = simd<1>::constant<0>();
1175                BitBlock ref_error = simd<1>::constant<0>();
1176                if (bitblock::any(simd_or(marker.Ref_opener,carry_set_0.CarryRange(0,6))))
1177                {
1178                        BitBlock Ref_scope = carry_set_0.BitBlock_advance_ci_co(marker.Ref_opener,carry_set_0.GetCarry(0),0);
1179                        BitBlock NumRef2 = simd_and(Ref_scope,lex.Hash);
1180                        ref_Callouts.GenRef_starts = simd_andc(Ref_scope,lex.Hash);
1181                        BitBlock NumRef3 = carry_set_0.BitBlock_advance_ci_co(NumRef2,carry_set_0.GetCarry(1),1);
1182                        BitBlock HexRef3 = simd_and(NumRef3,lex.x);
1183                        ref_Callouts.DecRef_starts = simd_andc(NumRef3,lex.x);
1184                        ref_Callouts.HexRef_starts = carry_set_0.BitBlock_advance_ci_co(HexRef3,carry_set_0.GetCarry(2),2);
1185                        ref_Callouts.GenRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.GenRef_starts,lex.NameScan,carry_set_0.GetCarry(3),3);
1186                        ref_Callouts.DecRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.DecRef_starts,lex.Digit,carry_set_0.GetCarry(4),4);
1187                        ref_Callouts.HexRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.HexRef_starts,lex.Hex,carry_set_0.GetCarry(5),5);
1188                        BitBlock ref_error1 = simd_andc(ref_Callouts.DecRef_starts,lex.Digit);
1189                        BitBlock ref_error2 = simd_andc(ref_Callouts.HexRef_starts,lex.Hex);
1190                        BitBlock ref_ends = simd_or(simd_or(ref_Callouts.GenRef_ends,ref_Callouts.DecRef_ends),ref_Callouts.HexRef_ends);
1191                        BitBlock ref_error3 = simd_andc(ref_ends,lex.Semicolon);
1192                        if (bitblock::any(simd_or(simd_or(ref_error1,ref_error2),ref_error3)))
1193                        {
1194                                assert_0_error("Reference error found",simd_or(simd_or(ref_error1,ref_error2),ref_error3));
1195                        }
1196                }
1197                else
1198                {
1199                        carry_set_0.CarryDequeueEnqueue(0,6);
1200                }
1201                carry_set_0.CarryAdjust(6);
1202        }
1203       
1204        void do_final_block(struct Lex & lex,struct Marker & marker,struct Ref_Callouts & ref_Callouts,BitBlock & EOF_mask)
1205        {
1206                ref_Callouts.GenRef_starts = simd<1>::constant<0>();
1207                ref_Callouts.GenRef_ends = simd<1>::constant<0>();
1208                ref_Callouts.DecRef_starts = simd<1>::constant<0>();
1209                ref_Callouts.DecRef_ends = simd<1>::constant<0>();
1210                ref_Callouts.HexRef_starts = simd<1>::constant<0>();
1211                ref_Callouts.HexRef_ends = simd<1>::constant<0>();
1212                BitBlock ref_error = simd<1>::constant<0>();
1213                if (bitblock::any(simd_or(marker.Ref_opener,carry_set_0.CarryRange(0,6))))
1214                {
1215                        BitBlock Ref_scope = carry_set_0.BitBlock_advance_ci_co(marker.Ref_opener,carry_set_0.GetCarry(0),0);
1216                        BitBlock NumRef2 = simd_and(Ref_scope,lex.Hash);
1217                        ref_Callouts.GenRef_starts = simd_andc(Ref_scope,lex.Hash);
1218                        BitBlock NumRef3 = carry_set_0.BitBlock_advance_ci_co(NumRef2,carry_set_0.GetCarry(1),1);
1219                        BitBlock HexRef3 = simd_and(NumRef3,lex.x);
1220                        ref_Callouts.DecRef_starts = simd_andc(NumRef3,lex.x);
1221                        ref_Callouts.HexRef_starts = carry_set_0.BitBlock_advance_ci_co(HexRef3,carry_set_0.GetCarry(2),2);
1222                        ref_Callouts.GenRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.GenRef_starts,lex.NameScan,carry_set_0.GetCarry(3),3);
1223                        ref_Callouts.DecRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.DecRef_starts,lex.Digit,carry_set_0.GetCarry(4),4);
1224                        ref_Callouts.HexRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.HexRef_starts,lex.Hex,carry_set_0.GetCarry(5),5);
1225                        BitBlock ref_error1 = simd_andc(ref_Callouts.DecRef_starts,lex.Digit);
1226                        BitBlock ref_error2 = simd_andc(ref_Callouts.HexRef_starts,lex.Hex);
1227                        BitBlock ref_ends = simd_or(simd_or(ref_Callouts.GenRef_ends,ref_Callouts.DecRef_ends),ref_Callouts.HexRef_ends);
1228                        BitBlock ref_error3 = simd_andc(ref_ends,lex.Semicolon);
1229                        if (bitblock::any(simd_or(simd_or(ref_error1,ref_error2),ref_error3)))
1230                        {
1231                                assert_0_error("Reference error found",simd_or(simd_or(ref_error1,ref_error2),ref_error3));
1232                        }
1233                }
1234                else
1235                {
1236                        carry_set_0.CarryDequeueEnqueue(0,6);
1237                }
1238        }
1239       
1240        CarryDeclare(carry_set_0,6,0);
1241};
1242 
1243struct Validate_xml_names
1244{
1245        Validate_xml_names()
1246        {
1247        }
1248         
1249        IDISA_INLINE void do_block(struct CtCDPI_Callouts & ctCDPI_Callouts,struct Ref_Callouts & ref_Callouts,struct Tag_Callouts & tag_Callouts,struct Lex & lex,struct U8 & u8,struct Check_streams & check_streams)
1250        {
1251                BitBlock PI_names = carry_set_0.BitBlock_span_upto(ctCDPI_Callouts.PI_name_starts,ctCDPI_Callouts.PI_name_ends,carry_set_0.GetCarry(0),0);
1252                BitBlock GenRefs = carry_set_0.BitBlock_span_upto(ref_Callouts.GenRef_starts,ref_Callouts.GenRef_ends,carry_set_0.GetCarry(1),1);
1253                BitBlock ElemNames = carry_set_0.BitBlock_span_upto(tag_Callouts.ElemName_starts,tag_Callouts.ElemName_ends,carry_set_0.GetCarry(2),2);
1254                BitBlock AttNames = carry_set_0.BitBlock_span_upto(tag_Callouts.AttName_starts,tag_Callouts.AttName_ends,carry_set_0.GetCarry(3),3);
1255                BitBlock qname_stream = simd_or(ElemNames,AttNames);
1256                BitBlock ncname_stream = simd_or(PI_names,GenRefs);
1257                BitBlock name_stream = simd_or(qname_stream,ncname_stream);
1258                BitBlock name_start = simd_andc(name_stream,carry_set_0.BitBlock_advance_ci_co(name_stream,carry_set_0.GetCarry(4),4));
1259                BitBlock name_cursor = simd_andc(name_stream,carry_set_0.BitBlock_advance_ci_co(name_stream,carry_set_0.GetCarry(5),5));
1260                BitBlock void_prefix_err = simd_and(name_cursor,lex.Colon);
1261                BitBlock namespace_sep = simd_and(carry_set_0.BitBlock_scanthru_ci_co(name_cursor,simd_andc(lex.NameScan,lex.Colon),carry_set_0.GetCarry(6),6),lex.Colon);
1262                BitBlock local_part_start = carry_set_0.BitBlock_advance_ci_co(namespace_sep,carry_set_0.GetCarry(7),7);
1263                BitBlock local_part_err = simd_andc(local_part_start,lex.NameScan);
1264                BitBlock colon2_err = simd_and(carry_set_0.BitBlock_scanthru_ci_co(local_part_start,simd_andc(lex.NameScan,lex.Colon),carry_set_0.GetCarry(8),8),lex.Colon);
1265                BitBlock ncname_err = simd_and(ncname_stream,lex.Colon);
1266                if (bitblock::any(simd_or(simd_or(simd_or(void_prefix_err,local_part_err),colon2_err),ncname_err)))
1267                {
1268                        assert_0_error("name syntax error",simd_or(simd_or(simd_or(void_prefix_err,local_part_err),colon2_err),ncname_err));
1269                }
1270                check_streams.non_ascii_name_starts = simd_andc(name_start,lex.ASCII_name_start);
1271                check_streams.non_ascii_names = simd_andc(simd_andc(simd_andc(name_stream,name_start),lex.ASCII_name_char),u8.suffix);
1272                carry_set_0.CarryAdjust(9);
1273        }
1274       
1275        void do_final_block(struct CtCDPI_Callouts & ctCDPI_Callouts,struct Ref_Callouts & ref_Callouts,struct Tag_Callouts & tag_Callouts,struct Lex & lex,struct U8 & u8,struct Check_streams & check_streams,BitBlock & EOF_mask)
1276        {
1277                BitBlock PI_names = carry_set_0.BitBlock_span_upto(ctCDPI_Callouts.PI_name_starts,ctCDPI_Callouts.PI_name_ends,carry_set_0.GetCarry(0),0);
1278                BitBlock GenRefs = carry_set_0.BitBlock_span_upto(ref_Callouts.GenRef_starts,ref_Callouts.GenRef_ends,carry_set_0.GetCarry(1),1);
1279                BitBlock ElemNames = carry_set_0.BitBlock_span_upto(tag_Callouts.ElemName_starts,tag_Callouts.ElemName_ends,carry_set_0.GetCarry(2),2);
1280                BitBlock AttNames = carry_set_0.BitBlock_span_upto(tag_Callouts.AttName_starts,tag_Callouts.AttName_ends,carry_set_0.GetCarry(3),3);
1281                BitBlock qname_stream = simd_or(ElemNames,AttNames);
1282                BitBlock ncname_stream = simd_or(PI_names,GenRefs);
1283                BitBlock name_stream = simd_or(qname_stream,ncname_stream);
1284                BitBlock name_start = simd_andc(name_stream,carry_set_0.BitBlock_advance_ci_co(name_stream,carry_set_0.GetCarry(4),4));
1285                BitBlock name_cursor = simd_andc(name_stream,carry_set_0.BitBlock_advance_ci_co(name_stream,carry_set_0.GetCarry(5),5));
1286                BitBlock void_prefix_err = simd_and(name_cursor,lex.Colon);
1287                BitBlock namespace_sep = simd_and(carry_set_0.BitBlock_scanthru_ci_co(name_cursor,simd_andc(lex.NameScan,lex.Colon),carry_set_0.GetCarry(6),6),lex.Colon);
1288                BitBlock local_part_start = carry_set_0.BitBlock_advance_ci_co(namespace_sep,carry_set_0.GetCarry(7),7);
1289                BitBlock local_part_err = simd_andc(local_part_start,lex.NameScan);
1290                BitBlock colon2_err = simd_and(carry_set_0.BitBlock_scanthru_ci_co(local_part_start,simd_andc(lex.NameScan,lex.Colon),carry_set_0.GetCarry(8),8),lex.Colon);
1291                BitBlock ncname_err = simd_and(ncname_stream,lex.Colon);
1292                if (bitblock::any(simd_or(simd_or(simd_or(void_prefix_err,local_part_err),colon2_err),ncname_err)))
1293                {
1294                        assert_0_error("name syntax error",simd_or(simd_or(simd_or(void_prefix_err,local_part_err),colon2_err),ncname_err));
1295                }
1296                check_streams.non_ascii_name_starts = simd_andc(name_start,lex.ASCII_name_start);
1297                check_streams.non_ascii_names = simd_andc(simd_andc(simd_andc(name_stream,name_start),lex.ASCII_name_char),u8.suffix);
1298        }
1299       
1300        CarryDeclare(carry_set_0,9,0);
1301};
1302 
1303struct Do_check_streams
1304{
1305        Do_check_streams()
1306        {
1307        }
1308         
1309        IDISA_INLINE void do_block(struct Marker & marker,struct Tag_Callouts & tag_Callouts,struct Check_streams & check_streams)
1310        {
1311                if (bitblock::any(simd_andc(marker.CD_closer,tag_Callouts.AttVal_spans)))
1312                {
1313                        assert_0_error("Error: ]]> in text",simd_andc(marker.CD_closer,tag_Callouts.AttVal_spans));
1314                }
1315                check_streams.tag_marks = simd_or(simd_or(simd_or(tag_Callouts.EmptyTag_marks,tag_Callouts.ElemName_starts),tag_Callouts.EndTag_marks),tag_Callouts.AttName_starts);
1316                check_streams.name_follows = simd_or(tag_Callouts.ElemName_ends,tag_Callouts.AttName_ends);
1317                check_streams.att_refs = simd_and(tag_Callouts.AttVal_spans,marker.Ref_opener);
1318        }
1319       
1320        void do_final_block(struct Marker & marker,struct Tag_Callouts & tag_Callouts,struct Check_streams & check_streams,BitBlock & EOF_mask)
1321        {
1322                if (bitblock::any(simd_andc(marker.CD_closer,tag_Callouts.AttVal_spans)))
1323                {
1324                        assert_0_error("Error: ]]> in text",simd_andc(marker.CD_closer,tag_Callouts.AttVal_spans));
1325                }
1326                check_streams.tag_marks = simd_or(simd_or(simd_or(tag_Callouts.EmptyTag_marks,tag_Callouts.ElemName_starts),tag_Callouts.EndTag_marks),tag_Callouts.AttName_starts);
1327                check_streams.name_follows = simd_or(tag_Callouts.ElemName_ends,tag_Callouts.AttName_ends);
1328                check_streams.att_refs = simd_and(tag_Callouts.AttVal_spans,marker.Ref_opener);
1329        }
1330       
1331        CarryDeclare(carry_set_0,0,0);
1332};
1333 
1334
1335// } // pablo namespace
1336
1337#endif // PABLO_DEFINITIONS_HPP
Note: See TracBrowser for help on using the repository browser.