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

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

Temp fix.

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