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

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

Partial check in marked for reversion. Progress towards S->S, S->B, B->B translation organization.

File size: 72.5 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/carrySet.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(errstrm,errkind) error_tracker.NoteError(errkind, errstrm);
29BitBlock EOF_mask = simd<1>::constant<1>();
30
31
32// XMLWF application headers and definitions
33/*
34#include <stdio.h>
35#include <stdlib.h>
36#include <errno.h>
37#include <sys/types.h>
38#include <sys/stat.h>
39
40#include <simd-lib/s2p.hpp>
41#include <simd-lib/buffer.hpp>
42#include <simd-lib/bitblock_iterator.hpp>
43#include <simd-lib/perflib/perfsec.h>
44
45#include <xmldecl.h>
46#include <namechars.h>
47#include <LineColTracker.hpp>
48#include <XMLTestSuiteError.h>
49
50// Define the mappings for pablo.assert_0(strm, errkind) statements which
51// compile to the the form assert_0_error(errkind, strm)
52#include <ErrorTracker.h>
53
54ErrorTracker error_tracker;
55#define assert_0_error(errkind, errstrm) error_tracker.NoteError(errkind, errstrm);
56*/
57
58// namespace pablo
59// {
60struct Basis_bits
61{
62        BitBlock bit_0;
63        BitBlock bit_1;
64        BitBlock bit_2;
65        BitBlock bit_3;
66        BitBlock bit_4;
67        BitBlock bit_5;
68        BitBlock bit_6;
69        BitBlock bit_7;
70};
71 
72struct U8
73{
74        BitBlock unibyte;
75        BitBlock prefix;
76        BitBlock prefix2;
77        BitBlock prefix3;
78        BitBlock prefix4;
79        BitBlock suffix;
80        BitBlock badprefix;
81        BitBlock xE0;
82        BitBlock xED;
83        BitBlock xF0;
84        BitBlock xF4;
85        BitBlock xA0_xBF;
86        BitBlock x80_x9F;
87        BitBlock x90_xBF;
88        BitBlock x80_x8F;
89        BitBlock xEF;
90        BitBlock xBF;
91        BitBlock xBE;
92        BitBlock scope22;
93        BitBlock scope32;
94        BitBlock scope33;
95        BitBlock scope42;
96        BitBlock scope43;
97        BitBlock scope44;
98        BitBlock xE0_scope;
99        BitBlock xED_scope;
100        BitBlock xF0_scope;
101        BitBlock xF4_scope;
102        BitBlock xEF_scope;
103};
104 
105struct Lex
106{
107        BitBlock CR;
108        BitBlock LF;
109        BitBlock HT;
110        BitBlock SP;
111        BitBlock CRLF;
112        BitBlock RefStart;
113        BitBlock Semicolon;
114        BitBlock Colon;
115        BitBlock LAngle;
116        BitBlock RAngle;
117        BitBlock LBracket;
118        BitBlock RBracket;
119        BitBlock Exclam;
120        BitBlock QMark;
121        BitBlock Hyphen;
122        BitBlock Equals;
123        BitBlock SQuote;
124        BitBlock DQuote;
125        BitBlock Slash;
126        BitBlock Hash;
127        BitBlock x;
128        BitBlock ASCII_name_start;
129        BitBlock ASCII_name_char;
130        BitBlock NameScan;
131        BitBlock Digit;
132        BitBlock Hex;
133        BitBlock WS;
134};
135 
136struct Marker
137{
138        BitBlock LAngle_scope;
139        BitBlock Ref_opener;
140        BitBlock CD_closer;
141};
142 
143struct CtCDPI_Callouts
144{
145        BitBlock Ct_starts;
146        BitBlock Ct_ends;
147        BitBlock CD_starts;
148        BitBlock CD_ends;
149        BitBlock PI_starts;
150        BitBlock PI_name_starts;
151        BitBlock PI_name_ends;
152        BitBlock PI_ends;
153};
154 
155struct Ref_Callouts
156{
157        BitBlock GenRef_starts;
158        BitBlock GenRef_ends;
159        BitBlock DecRef_starts;
160        BitBlock DecRef_ends;
161        BitBlock HexRef_starts;
162        BitBlock HexRef_ends;
163};
164 
165struct Tag_Callouts
166{
167        BitBlock ElemName_starts;
168        BitBlock ElemName_ends;
169        BitBlock AttName_starts;
170        BitBlock AttName_ends;
171        BitBlock AttVal_starts;
172        BitBlock AttVal_ends;
173        BitBlock AttVal_spans;
174        BitBlock EmptyTag_marks;
175        BitBlock EndTag_marks;
176};
177 
178struct Check_streams
179{
180        BitBlock misc_mask;
181        BitBlock non_ascii_name_starts;
182        BitBlock non_ascii_names;
183        BitBlock tag_marks;
184        BitBlock name_follows;
185        BitBlock att_refs;
186};
187 
188struct Classify_bytes_Validate_utf8
189{
190        Classify_bytes_Validate_utf8()
191        {
192        }
193       
194        IDISA_INLINE void do_block(struct Basis_bits & basis_bits,struct Lex & lex,struct U8 & u8)
195        {
196                BitBlock temp1;
197                temp1 = simd_or(basis_bits.bit_0,basis_bits.bit_1);
198                BitBlock temp2;
199                temp2 = simd_andc(basis_bits.bit_2,basis_bits.bit_3);
200                BitBlock temp3;
201                temp3 = simd_andc(temp2,temp1);
202                BitBlock temp4;
203                temp4 = simd_andc(basis_bits.bit_5,basis_bits.bit_4);
204                BitBlock temp5;
205                temp5 = simd_andc(basis_bits.bit_6,basis_bits.bit_7);
206                BitBlock temp6;
207                temp6 = simd_and(temp4,temp5);
208                lex.RefStart = simd_and(temp3,temp6);
209                BitBlock temp7;
210                temp7 = simd_and(basis_bits.bit_2,basis_bits.bit_3);
211                BitBlock temp8;
212                temp8 = simd_andc(temp7,temp1);
213                BitBlock temp9;
214                temp9 = simd_andc(basis_bits.bit_4,basis_bits.bit_5);
215                BitBlock temp10;
216                temp10 = simd_and(basis_bits.bit_6,basis_bits.bit_7);
217                BitBlock temp11;
218                temp11 = simd_and(temp9,temp10);
219                lex.Semicolon = simd_and(temp8,temp11);
220                BitBlock temp12;
221                temp12 = simd_and(basis_bits.bit_4,basis_bits.bit_5);
222                BitBlock temp13;
223                temp13 = simd_or(basis_bits.bit_6,basis_bits.bit_7);
224                BitBlock temp14;
225                temp14 = simd_andc(temp12,temp13);
226                lex.LAngle = simd_and(temp8,temp14);
227                BitBlock temp15;
228                temp15 = simd_and(temp12,temp5);
229                lex.RAngle = simd_and(temp8,temp15);
230                BitBlock temp16;
231                temp16 = simd_andc(basis_bits.bit_1,basis_bits.bit_0);
232                BitBlock temp17;
233                temp17 = simd_andc(basis_bits.bit_3,basis_bits.bit_2);
234                BitBlock temp18;
235                temp18 = simd_and(temp16,temp17);
236                lex.LBracket = simd_and(temp18,temp11);
237                BitBlock temp19;
238                temp19 = simd_andc(basis_bits.bit_7,basis_bits.bit_6);
239                BitBlock temp20;
240                temp20 = simd_and(temp12,temp19);
241                lex.RBracket = simd_and(temp18,temp20);
242                BitBlock temp21;
243                temp21 = simd_or(basis_bits.bit_4,basis_bits.bit_5);
244                BitBlock temp22;
245                temp22 = simd_andc(temp19,temp21);
246                lex.Exclam = simd_and(temp3,temp22);
247                BitBlock temp23;
248                temp23 = simd_and(temp12,temp10);
249                lex.QMark = simd_and(temp8,temp23);
250                lex.Hyphen = simd_and(temp3,temp20);
251                lex.Equals = simd_and(temp8,temp20);
252                BitBlock temp24;
253                temp24 = simd_and(temp4,temp10);
254                lex.SQuote = simd_and(temp3,temp24);
255                BitBlock temp25;
256                temp25 = simd_andc(temp5,temp21);
257                lex.DQuote = simd_and(temp3,temp25);
258                lex.Slash = simd_and(temp3,temp23);
259                BitBlock temp26;
260                temp26 = simd_andc(temp10,temp21);
261                lex.Hash = simd_and(temp3,temp26);
262                BitBlock temp27;
263                temp27 = simd_and(temp16,temp7);
264                BitBlock temp28;
265                temp28 = simd_andc(temp9,temp13);
266                lex.x = simd_and(temp27,temp28);
267                BitBlock temp29;
268                temp29 = simd_and(temp9,temp5);
269                lex.Colon = simd_and(temp8,temp29);
270                BitBlock temp30;
271                temp30 = simd_and(temp18,temp23);
272                BitBlock temp31;
273                temp31 = simd_or(temp30,lex.Colon);
274                BitBlock temp32;
275                temp32 = simd_andc(temp16,basis_bits.bit_2);
276                BitBlock temp33;
277                temp33 = simd_or(basis_bits.bit_5,temp10);
278                BitBlock temp34;
279                temp34 = simd_and(basis_bits.bit_4,temp33);
280                BitBlock temp35;
281                temp35 = simd_not(temp34);
282                BitBlock temp36;
283                temp36 = simd_or(temp21,temp13);
284                BitBlock temp37;
285                temp37 = simd_or(simd_and(basis_bits.bit_3,temp35),simd_andc(temp36,basis_bits.bit_3));
286                BitBlock temp38;
287                temp38 = simd_and(temp32,temp37);
288                BitBlock temp39;
289                temp39 = simd_or(temp31,temp38);
290                BitBlock temp40;
291                temp40 = simd_and(temp16,basis_bits.bit_2);
292                BitBlock temp41;
293                temp41 = simd_and(temp40,temp37);
294                lex.ASCII_name_start = simd_or(temp39,temp41);
295                BitBlock temp42;
296                temp42 = simd_or(temp30,lex.Hyphen);
297                BitBlock temp43;
298                temp43 = simd_and(temp3,temp15);
299                BitBlock temp44;
300                temp44 = simd_or(temp42,temp43);
301                BitBlock temp45;
302                temp45 = simd_andc(temp8,temp34);
303                BitBlock temp46;
304                temp46 = simd_or(temp44,temp45);
305                BitBlock temp47;
306                temp47 = simd_or(temp46,temp38);
307                lex.ASCII_name_char = simd_or(temp47,temp41);
308                lex.NameScan = simd_or(lex.ASCII_name_char,basis_bits.bit_0);
309                BitBlock temp48;
310                temp48 = simd_or(temp1,basis_bits.bit_2);
311                BitBlock x00_x1F;
312                x00_x1F = simd_not(temp48);
313                BitBlock temp49;
314                temp49 = simd_or(basis_bits.bit_2,basis_bits.bit_3);
315                BitBlock temp50;
316                temp50 = simd_or(temp1,temp49);
317                lex.CR = simd_andc(temp20,temp50);
318                lex.LF = simd_andc(temp29,temp50);
319                BitBlock temp51;
320                temp51 = simd_and(temp9,temp19);
321                lex.HT = simd_andc(temp51,temp50);
322                lex.SP = simd_andc(temp3,temp36);
323                BitBlock temp52;
324                temp52 = simd_or(temp20,temp29);
325                BitBlock temp53;
326                temp53 = simd_or(temp52,temp51);
327                BitBlock temp54;
328                temp54 = simd_andc(temp53,temp50);
329                lex.WS = simd_or(temp54,lex.SP);
330                BitBlock temp55;
331                temp55 = simd_or(basis_bits.bit_5,basis_bits.bit_6);
332                BitBlock temp56;
333                temp56 = simd_and(basis_bits.bit_4,temp55);
334                lex.Digit = simd_andc(temp8,temp56);
335                BitBlock temp57;
336                temp57 = simd_andc(temp16,temp49);
337                BitBlock temp58;
338                temp58 = simd_andc(temp57,basis_bits.bit_4);
339                BitBlock temp59;
340                temp59 = simd_not(temp10);
341                BitBlock temp60;
342                temp60 = simd_or(simd_and(basis_bits.bit_5,temp59),simd_andc(temp13,basis_bits.bit_5));
343                BitBlock temp61;
344                temp61 = simd_and(temp58,temp60);
345                BitBlock temp62;
346                temp62 = simd_or(lex.Digit,temp61);
347                BitBlock temp63;
348                temp63 = simd_and(temp16,temp2);
349                BitBlock temp64;
350                temp64 = simd_andc(temp63,basis_bits.bit_4);
351                BitBlock temp65;
352                temp65 = simd_and(temp64,temp60);
353                lex.Hex = simd_or(temp62,temp65);
354                BitBlock lex_error;
355                lex_error = simd_andc(x00_x1F,lex.WS);
356                if (bitblock::any(lex_error))
357                {
358                        assert_0_error(lex_error,"Error: illegal character");
359                }
360                u8.unibyte = simd_not(basis_bits.bit_0);
361                u8.suffix = simd<1>::constant<0>();
362                BitBlock u8_error;
363                u8_error = simd<1>::constant<0>();
364                BitBlock u8_FFFE_FFFF;
365                u8_FFFE_FFFF = simd<1>::constant<0>();
366                BitBlock u8anyscope;
367                u8anyscope = simd<1>::constant<0>();
368                if (bitblock::any(simd_or(basis_bits.bit_0,carry_set_0.carryRange(0,10))))
369                {
370                        u8.prefix = simd_and(basis_bits.bit_0,basis_bits.bit_1);
371                        u8.prefix2 = simd_andc(u8.prefix,basis_bits.bit_2);
372                        u8.prefix3 = simd_and(u8.prefix,temp2);
373                        u8.prefix4 = simd_and(u8.prefix,temp7);
374                        u8.suffix = simd_andc(basis_bits.bit_0,basis_bits.bit_1);
375                        BitBlock temp66;
376                        temp66 = simd_andc(u8.prefix,temp49);
377                        BitBlock temp67;
378                        temp67 = simd_or(temp21,basis_bits.bit_6);
379                        BitBlock temp68;
380                        temp68 = simd_andc(temp66,temp67);
381                        BitBlock temp69;
382                        temp69 = simd_and(basis_bits.bit_5,temp13);
383                        BitBlock temp70;
384                        temp70 = simd_or(basis_bits.bit_4,temp69);
385                        BitBlock temp71;
386                        temp71 = simd_and(u8.prefix4,temp70);
387                        u8.badprefix = simd_or(temp68,temp71);
388                        u8_error = u8.badprefix;
389                        carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(u8.prefix2,carry_set_0.getCarry(0),u8.scope22));
390                        u8anyscope = u8.scope22;
391                        if (bitblock::any(simd_or(simd_or(u8.prefix3,u8.prefix4),carry_set_0.carryRange(0,9))))
392                        {
393                                BitBlock xE0;
394                                xE0 = simd_andc(u8.prefix3,temp36);
395                                BitBlock xED;
396                                xED = simd_and(u8.prefix3,temp20);
397                                BitBlock xF0;
398                                xF0 = simd_andc(u8.prefix4,temp36);
399                                BitBlock temp72;
400                                temp72 = simd_andc(temp4,temp13);
401                                BitBlock xF4;
402                                xF4 = simd_and(u8.prefix4,temp72);
403                                u8.xA0_xBF = simd_and(u8.suffix,basis_bits.bit_2);
404                                u8.x80_x9F = simd_andc(u8.suffix,basis_bits.bit_2);
405                                u8.x90_xBF = simd_and(u8.suffix,temp49);
406                                u8.x80_x8F = simd_andc(u8.suffix,temp49);
407                                BitBlock xEF;
408                                xEF = simd_and(u8.prefix3,temp23);
409                                BitBlock temp73;
410                                temp73 = simd_and(u8.suffix,temp7);
411                                u8.xBF = simd_and(temp73,temp23);
412                                u8.xBE = simd_and(temp73,temp15);
413                                carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(u8.prefix3,carry_set_0.getCarry(1),u8.scope32));
414                                carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_Advance(u8.scope32,carry_set_0.getCarry(2),u8.scope33));
415                                carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_Advance(u8.prefix4,carry_set_0.getCarry(3),u8.scope42));
416                                carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_Advance(u8.scope42,carry_set_0.getCarry(4),u8.scope43));
417                                carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_Advance(u8.scope43,carry_set_0.getCarry(5),u8.scope44));
418                                BitBlock E0_F0_scope;
419                                carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_Advance(simd_or(xE0,xF0),carry_set_0.getCarry(6),E0_F0_scope));
420                                BitBlock ED_F4_scope;
421                                carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(simd_or(xED,xF4),carry_set_0.getCarry(7),ED_F4_scope));
422                                u8.xE0_scope = simd_and(u8.scope32,E0_F0_scope);
423                                u8.xED_scope = simd_and(u8.scope32,ED_F4_scope);
424                                u8.xF0_scope = simd_and(u8.scope42,E0_F0_scope);
425                                u8.xF4_scope = simd_and(u8.scope42,ED_F4_scope);
426                                carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_Advance(xEF,carry_set_0.getCarry(8),u8.xEF_scope));
427                                BitBlock u8lastscope;
428                                u8lastscope = simd_or(simd_or(u8.scope22,u8.scope33),u8.scope44);
429                                u8anyscope = simd_or(simd_or(simd_or(u8lastscope,u8.scope32),u8.scope42),u8.scope43);
430                                BitBlock u8error1;
431                                u8error1 = simd_and(u8.xE0_scope,u8.x80_x9F);
432                                BitBlock u8error2;
433                                u8error2 = simd_and(u8.xED_scope,u8.xA0_xBF);
434                                BitBlock u8error3;
435                                u8error3 = simd_and(u8.xF0_scope,u8.x80_x8F);
436                                BitBlock u8error4;
437                                u8error4 = simd_and(u8.xF4_scope,u8.x90_xBF);
438                                u8_error = simd_or(u8_error,simd_or(simd_or(simd_or(u8error1,u8error2),u8error3),u8error4));
439                                BitBlock EF_BF_pending;
440                                carry_set_0.getCarry(9) = bitblock::srli<127>(pablo_blk_Advance(simd_and(u8.xEF_scope,u8.xBF),carry_set_0.getCarry(9),EF_BF_pending));
441                                u8_FFFE_FFFF = simd_and(EF_BF_pending,simd_or(u8.xBE,u8.xBF));
442                        }
443                        else
444                        {
445                                carry_set_0.carryDequeueEnqueue(0,9);
446                        }
447                        BitBlock u8mismatch;
448                        u8mismatch = simd_xor(u8anyscope,u8.suffix);
449                        if (bitblock::any(simd_or(simd_or(u8_error,u8mismatch),u8_FFFE_FFFF)))
450                        {
451                                assert_0_error(simd_or(simd_or(u8_error,u8mismatch),u8_FFFE_FFFF),"UTF-8 error found");
452                        }
453                }
454                else
455                {
456                        carry_set_0.carryDequeueEnqueue(0,10);
457                }
458                carry_set_0.carryAdjust(10);
459        }
460       
461        void do_final_block(struct Basis_bits & basis_bits,struct Lex & lex,struct U8 & u8,BitBlock & EOF_mask)
462        {
463                BitBlock temp1;
464                temp1 = simd_or(basis_bits.bit_0,basis_bits.bit_1);
465                BitBlock temp2;
466                temp2 = simd_andc(basis_bits.bit_2,basis_bits.bit_3);
467                BitBlock temp3;
468                temp3 = simd_andc(temp2,temp1);
469                BitBlock temp4;
470                temp4 = simd_andc(basis_bits.bit_5,basis_bits.bit_4);
471                BitBlock temp5;
472                temp5 = simd_andc(basis_bits.bit_6,basis_bits.bit_7);
473                BitBlock temp6;
474                temp6 = simd_and(temp4,temp5);
475                lex.RefStart = simd_and(temp3,temp6);
476                BitBlock temp7;
477                temp7 = simd_and(basis_bits.bit_2,basis_bits.bit_3);
478                BitBlock temp8;
479                temp8 = simd_andc(temp7,temp1);
480                BitBlock temp9;
481                temp9 = simd_andc(basis_bits.bit_4,basis_bits.bit_5);
482                BitBlock temp10;
483                temp10 = simd_and(basis_bits.bit_6,basis_bits.bit_7);
484                BitBlock temp11;
485                temp11 = simd_and(temp9,temp10);
486                lex.Semicolon = simd_and(temp8,temp11);
487                BitBlock temp12;
488                temp12 = simd_and(basis_bits.bit_4,basis_bits.bit_5);
489                BitBlock temp13;
490                temp13 = simd_or(basis_bits.bit_6,basis_bits.bit_7);
491                BitBlock temp14;
492                temp14 = simd_andc(temp12,temp13);
493                lex.LAngle = simd_and(temp8,temp14);
494                BitBlock temp15;
495                temp15 = simd_and(temp12,temp5);
496                lex.RAngle = simd_and(temp8,temp15);
497                BitBlock temp16;
498                temp16 = simd_andc(basis_bits.bit_1,basis_bits.bit_0);
499                BitBlock temp17;
500                temp17 = simd_andc(basis_bits.bit_3,basis_bits.bit_2);
501                BitBlock temp18;
502                temp18 = simd_and(temp16,temp17);
503                lex.LBracket = simd_and(temp18,temp11);
504                BitBlock temp19;
505                temp19 = simd_andc(basis_bits.bit_7,basis_bits.bit_6);
506                BitBlock temp20;
507                temp20 = simd_and(temp12,temp19);
508                lex.RBracket = simd_and(temp18,temp20);
509                BitBlock temp21;
510                temp21 = simd_or(basis_bits.bit_4,basis_bits.bit_5);
511                BitBlock temp22;
512                temp22 = simd_andc(temp19,temp21);
513                lex.Exclam = simd_and(temp3,temp22);
514                BitBlock temp23;
515                temp23 = simd_and(temp12,temp10);
516                lex.QMark = simd_and(temp8,temp23);
517                lex.Hyphen = simd_and(temp3,temp20);
518                lex.Equals = simd_and(temp8,temp20);
519                BitBlock temp24;
520                temp24 = simd_and(temp4,temp10);
521                lex.SQuote = simd_and(temp3,temp24);
522                BitBlock temp25;
523                temp25 = simd_andc(temp5,temp21);
524                lex.DQuote = simd_and(temp3,temp25);
525                lex.Slash = simd_and(temp3,temp23);
526                BitBlock temp26;
527                temp26 = simd_andc(temp10,temp21);
528                lex.Hash = simd_and(temp3,temp26);
529                BitBlock temp27;
530                temp27 = simd_and(temp16,temp7);
531                BitBlock temp28;
532                temp28 = simd_andc(temp9,temp13);
533                lex.x = simd_and(temp27,temp28);
534                BitBlock temp29;
535                temp29 = simd_and(temp9,temp5);
536                lex.Colon = simd_and(temp8,temp29);
537                BitBlock temp30;
538                temp30 = simd_and(temp18,temp23);
539                BitBlock temp31;
540                temp31 = simd_or(temp30,lex.Colon);
541                BitBlock temp32;
542                temp32 = simd_andc(temp16,basis_bits.bit_2);
543                BitBlock temp33;
544                temp33 = simd_or(basis_bits.bit_5,temp10);
545                BitBlock temp34;
546                temp34 = simd_and(basis_bits.bit_4,temp33);
547                BitBlock temp35;
548                temp35 = simd_not(temp34);
549                BitBlock temp36;
550                temp36 = simd_or(temp21,temp13);
551                BitBlock temp37;
552                temp37 = simd_or(simd_and(basis_bits.bit_3,temp35),simd_andc(temp36,basis_bits.bit_3));
553                BitBlock temp38;
554                temp38 = simd_and(temp32,temp37);
555                BitBlock temp39;
556                temp39 = simd_or(temp31,temp38);
557                BitBlock temp40;
558                temp40 = simd_and(temp16,basis_bits.bit_2);
559                BitBlock temp41;
560                temp41 = simd_and(temp40,temp37);
561                lex.ASCII_name_start = simd_or(temp39,temp41);
562                BitBlock temp42;
563                temp42 = simd_or(temp30,lex.Hyphen);
564                BitBlock temp43;
565                temp43 = simd_and(temp3,temp15);
566                BitBlock temp44;
567                temp44 = simd_or(temp42,temp43);
568                BitBlock temp45;
569                temp45 = simd_andc(temp8,temp34);
570                BitBlock temp46;
571                temp46 = simd_or(temp44,temp45);
572                BitBlock temp47;
573                temp47 = simd_or(temp46,temp38);
574                lex.ASCII_name_char = simd_or(temp47,temp41);
575                lex.NameScan = simd_or(lex.ASCII_name_char,basis_bits.bit_0);
576                BitBlock temp48;
577                temp48 = simd_or(temp1,basis_bits.bit_2);
578                BitBlock x00_x1F;
579                x00_x1F = simd_not(temp48);
580                BitBlock temp49;
581                temp49 = simd_or(basis_bits.bit_2,basis_bits.bit_3);
582                BitBlock temp50;
583                temp50 = simd_or(temp1,temp49);
584                lex.CR = simd_andc(temp20,temp50);
585                lex.LF = simd_andc(temp29,temp50);
586                BitBlock temp51;
587                temp51 = simd_and(temp9,temp19);
588                lex.HT = simd_andc(temp51,temp50);
589                lex.SP = simd_andc(temp3,temp36);
590                BitBlock temp52;
591                temp52 = simd_or(temp20,temp29);
592                BitBlock temp53;
593                temp53 = simd_or(temp52,temp51);
594                BitBlock temp54;
595                temp54 = simd_andc(temp53,temp50);
596                lex.WS = simd_or(temp54,lex.SP);
597                BitBlock temp55;
598                temp55 = simd_or(basis_bits.bit_5,basis_bits.bit_6);
599                BitBlock temp56;
600                temp56 = simd_and(basis_bits.bit_4,temp55);
601                lex.Digit = simd_andc(temp8,temp56);
602                BitBlock temp57;
603                temp57 = simd_andc(temp16,temp49);
604                BitBlock temp58;
605                temp58 = simd_andc(temp57,basis_bits.bit_4);
606                BitBlock temp59;
607                temp59 = simd_not(temp10);
608                BitBlock temp60;
609                temp60 = simd_or(simd_and(basis_bits.bit_5,temp59),simd_andc(temp13,basis_bits.bit_5));
610                BitBlock temp61;
611                temp61 = simd_and(temp58,temp60);
612                BitBlock temp62;
613                temp62 = simd_or(lex.Digit,temp61);
614                BitBlock temp63;
615                temp63 = simd_and(temp16,temp2);
616                BitBlock temp64;
617                temp64 = simd_andc(temp63,basis_bits.bit_4);
618                BitBlock temp65;
619                temp65 = simd_and(temp64,temp60);
620                lex.Hex = simd_or(temp62,temp65);
621                BitBlock lex_error;
622                lex_error = simd_andc(x00_x1F,lex.WS);
623                if (bitblock::any(simd_and(lex_error,EOF_mask)))
624                {
625                        assert_0_error(simd_and(lex_error,EOF_mask),"Error: illegal character");
626                }
627                u8.unibyte = simd_not(basis_bits.bit_0);
628                u8.suffix = simd<1>::constant<0>();
629                BitBlock u8_error;
630                u8_error = simd<1>::constant<0>();
631                BitBlock u8_FFFE_FFFF;
632                u8_FFFE_FFFF = simd<1>::constant<0>();
633                BitBlock u8anyscope;
634                u8anyscope = simd<1>::constant<0>();
635                if (bitblock::any(simd_or(basis_bits.bit_0,carry_set_0.carryRange(0,10))))
636                {
637                        u8.prefix = simd_and(basis_bits.bit_0,basis_bits.bit_1);
638                        u8.prefix2 = simd_andc(u8.prefix,basis_bits.bit_2);
639                        u8.prefix3 = simd_and(u8.prefix,temp2);
640                        u8.prefix4 = simd_and(u8.prefix,temp7);
641                        u8.suffix = simd_andc(basis_bits.bit_0,basis_bits.bit_1);
642                        BitBlock temp66;
643                        temp66 = simd_andc(u8.prefix,temp49);
644                        BitBlock temp67;
645                        temp67 = simd_or(temp21,basis_bits.bit_6);
646                        BitBlock temp68;
647                        temp68 = simd_andc(temp66,temp67);
648                        BitBlock temp69;
649                        temp69 = simd_and(basis_bits.bit_5,temp13);
650                        BitBlock temp70;
651                        temp70 = simd_or(basis_bits.bit_4,temp69);
652                        BitBlock temp71;
653                        temp71 = simd_and(u8.prefix4,temp70);
654                        u8.badprefix = simd_or(temp68,temp71);
655                        u8_error = u8.badprefix;
656                        carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(u8.prefix2,carry_set_0.getCarry(0),u8.scope22));
657                        u8anyscope = u8.scope22;
658                        if (bitblock::any(simd_or(simd_or(u8.prefix3,u8.prefix4),carry_set_0.carryRange(0,9))))
659                        {
660                                BitBlock xE0;
661                                xE0 = simd_andc(u8.prefix3,temp36);
662                                BitBlock xED;
663                                xED = simd_and(u8.prefix3,temp20);
664                                BitBlock xF0;
665                                xF0 = simd_andc(u8.prefix4,temp36);
666                                BitBlock temp72;
667                                temp72 = simd_andc(temp4,temp13);
668                                BitBlock xF4;
669                                xF4 = simd_and(u8.prefix4,temp72);
670                                u8.xA0_xBF = simd_and(u8.suffix,basis_bits.bit_2);
671                                u8.x80_x9F = simd_andc(u8.suffix,basis_bits.bit_2);
672                                u8.x90_xBF = simd_and(u8.suffix,temp49);
673                                u8.x80_x8F = simd_andc(u8.suffix,temp49);
674                                BitBlock xEF;
675                                xEF = simd_and(u8.prefix3,temp23);
676                                BitBlock temp73;
677                                temp73 = simd_and(u8.suffix,temp7);
678                                u8.xBF = simd_and(temp73,temp23);
679                                u8.xBE = simd_and(temp73,temp15);
680                                carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(u8.prefix3,carry_set_0.getCarry(1),u8.scope32));
681                                carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_Advance(u8.scope32,carry_set_0.getCarry(2),u8.scope33));
682                                carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_Advance(u8.prefix4,carry_set_0.getCarry(3),u8.scope42));
683                                carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_Advance(u8.scope42,carry_set_0.getCarry(4),u8.scope43));
684                                carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_Advance(u8.scope43,carry_set_0.getCarry(5),u8.scope44));
685                                BitBlock E0_F0_scope;
686                                carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_Advance(simd_or(xE0,xF0),carry_set_0.getCarry(6),E0_F0_scope));
687                                BitBlock ED_F4_scope;
688                                carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(simd_or(xED,xF4),carry_set_0.getCarry(7),ED_F4_scope));
689                                u8.xE0_scope = simd_and(u8.scope32,E0_F0_scope);
690                                u8.xED_scope = simd_and(u8.scope32,ED_F4_scope);
691                                u8.xF0_scope = simd_and(u8.scope42,E0_F0_scope);
692                                u8.xF4_scope = simd_and(u8.scope42,ED_F4_scope);
693                                carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_Advance(xEF,carry_set_0.getCarry(8),u8.xEF_scope));
694                                BitBlock u8lastscope;
695                                u8lastscope = simd_or(simd_or(u8.scope22,u8.scope33),u8.scope44);
696                                u8anyscope = simd_or(simd_or(simd_or(u8lastscope,u8.scope32),u8.scope42),u8.scope43);
697                                BitBlock u8error1;
698                                u8error1 = simd_and(u8.xE0_scope,u8.x80_x9F);
699                                BitBlock u8error2;
700                                u8error2 = simd_and(u8.xED_scope,u8.xA0_xBF);
701                                BitBlock u8error3;
702                                u8error3 = simd_and(u8.xF0_scope,u8.x80_x8F);
703                                BitBlock u8error4;
704                                u8error4 = simd_and(u8.xF4_scope,u8.x90_xBF);
705                                u8_error = simd_or(u8_error,simd_or(simd_or(simd_or(u8error1,u8error2),u8error3),u8error4));
706                                BitBlock EF_BF_pending;
707                                carry_set_0.getCarry(9) = bitblock::srli<127>(pablo_blk_Advance(simd_and(u8.xEF_scope,u8.xBF),carry_set_0.getCarry(9),EF_BF_pending));
708                                u8_FFFE_FFFF = simd_and(EF_BF_pending,simd_or(u8.xBE,u8.xBF));
709                        }
710                        else
711                        {
712                                carry_set_0.carryDequeueEnqueue(0,9);
713                        }
714                        BitBlock u8mismatch;
715                        u8mismatch = simd_xor(u8anyscope,u8.suffix);
716                        if (bitblock::any(simd_or(simd_or(u8_error,u8mismatch),u8_FFFE_FFFF)))
717                        {
718                                assert_0_error(simd_or(simd_or(u8_error,u8mismatch),u8_FFFE_FFFF),"UTF-8 error found");
719                        }
720                }
721                else
722                {
723                        carry_set_0.carryDequeueEnqueue(0,10);
724                }
725        }
726       
727        CarryDeclare(carry_set_0,10,0);
728};
729 
730struct Parse_CtCDPI
731{
732        Parse_CtCDPI()
733        {
734        }
735       
736        IDISA_INLINE void do_block(struct Lex & lex,struct Marker & marker,struct CtCDPI_Callouts & ctCDPI_Callouts,struct Check_streams & check_streams)
737        {
738                ctCDPI_Callouts.Ct_starts = simd<1>::constant<0>();
739                ctCDPI_Callouts.Ct_ends = simd<1>::constant<0>();
740                ctCDPI_Callouts.CD_starts = simd<1>::constant<0>();
741                ctCDPI_Callouts.CD_ends = simd<1>::constant<0>();
742                ctCDPI_Callouts.PI_starts = simd<1>::constant<0>();
743                ctCDPI_Callouts.PI_name_starts = simd<1>::constant<0>();
744                ctCDPI_Callouts.PI_name_ends = simd<1>::constant<0>();
745                ctCDPI_Callouts.PI_ends = simd<1>::constant<0>();
746                BitBlock CtCDPI_starts;
747                CtCDPI_starts = simd<1>::constant<0>();
748                BitBlock CtCDPI_ends;
749                CtCDPI_ends = simd<1>::constant<0>();
750                BitBlock ctCDPI_mask;
751                ctCDPI_mask = simd<1>::constant<0>();
752                BitBlock v;
753                v = simd_or(lex.LAngle,lex.Hyphen);
754                BitBlock w;
755                w = simd_or(lex.Hyphen,lex.QMark);
756                BitBlock v1;
757                carry_set_0.getPending64(0) = bitblock::srli<127>(pablo_blk_Advance_n_<v>(1,carry_set_0.getPending64(0),v1));
758                BitBlock w1;
759                carry_set_0.getPending64(1) = bitblock::srli<127>(pablo_blk_Advance_n_<w>(1,carry_set_0.getPending64(1),w1));
760                BitBlock LAngle_scope;
761                LAngle_scope = simd_andc(v1,w1);
762                BitBlock PI_opener;
763                PI_opener = simd_and(LAngle_scope,lex.QMark);
764                BitBlock CtCD_opener;
765                CtCD_opener = simd_and(LAngle_scope,lex.Exclam);
766                BitBlock CtCDPI_opener;
767                CtCDPI_opener = simd_or(PI_opener,CtCD_opener);
768                BitBlock CD_closer;
769                CD_closer = simd<1>::constant<0>();
770                BitBlock DoubleHyphen;
771                DoubleHyphen = simd_and(simd_and(v1,w1),lex.Hyphen);
772                if (bitblock::any(simd_or(lex.RBracket,carry_set_0.carryRange(0,2))))
773                {
774                        BitBlock DoubleRBracket;
775                        BitBlock _temp0;
776                        carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(lex.RBracket,carry_set_0.getCarry(0),_temp0));
777                        DoubleRBracket = simd_and(_temp0,lex.RBracket);
778                        BitBlock _temp1;
779                        carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(DoubleRBracket,carry_set_0.getCarry(1),_temp1));
780                        CD_closer = simd_and(_temp1,lex.RAngle);
781                }
782                else
783                {
784                        carry_set_0.carryDequeueEnqueue(0,2);
785                }
786                BitBlock PI_closer;
787                PI_closer = simd_and(simd_andc(w1,v1),lex.RAngle);
788                BitBlock CtCDPI_Cursor;
789                carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_ScanToFirst(CtCDPI_opener,carry_set_0.getCarry(2),CtCDPI_Cursor));
790                if (bitblock::any(simd_or(CtCDPI_Cursor,carry_set_0.carryRange(0,13))))
791                {
792                        CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
793                        BitBlock PI_Cursor;
794                        PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
795                        BitBlock CD_Ct_Cursor;
796                        carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_Advance(simd_andc(CtCDPI_Cursor,PI_Cursor),carry_set_0.getCarry(3),CD_Ct_Cursor));
797                        BitBlock CD_Cursor;
798                        CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
799                        BitBlock Ct_Cursor;
800                        Ct_Cursor = simd_and(CD_Ct_Cursor,lex.Hyphen);
801                        if (bitblock::any(simd_or(PI_Cursor,carry_set_0.carryRange(0,4))))
802                        {
803                                ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts,PI_Cursor);
804                                carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_Advance(PI_Cursor,carry_set_0.getCarry(4),PI_Cursor));
805                                ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts,PI_Cursor);
806                                BitBlock PI_name_end;
807                                carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_ScanThru(PI_Cursor,lex.NameScan,carry_set_0.getCarry(5),PI_name_end));
808                                BitBlock PI_error;
809                                PI_error = simd_and(PI_Cursor,PI_name_end);
810                                BitBlock PI_noWS;
811                                PI_noWS = simd_andc(PI_name_end,lex.WS);
812                                BitBlock _temp2;
813                                carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_Advance(PI_noWS,carry_set_0.getCarry(6),_temp2));
814                                PI_error = simd_or(PI_error,simd_or(simd_andc(PI_noWS,lex.QMark),simd_andc(_temp2,PI_closer)));
815                                if (bitblock::any(PI_error))
816                                {
817                                        assert_0_error(PI_error,"Error in PI syntax");
818                                }
819                                ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends,PI_name_end);
820                                carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_ScanThru(PI_name_end,PI_closer,carry_set_0.getCarry(7),PI_Cursor));
821                                ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends,PI_Cursor);
822                                CtCDPI_ends = simd_or(CtCDPI_ends,PI_Cursor);
823                        }
824                        else
825                        {
826                                carry_set_0.carryDequeueEnqueue(0,4);
827                        }
828                        if (bitblock::any(simd_or(CD_Cursor,carry_set_0.carryRange(0,1))))
829                        {
830                                ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts,CD_Cursor);
831                                carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_ScanThru(CD_Cursor,CD_closer,carry_set_0.getCarry(8),CD_Cursor));
832                                ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends,CD_Cursor);
833                                CtCDPI_ends = simd_or(CtCDPI_ends,CD_Cursor);
834                        }
835                        else
836                        {
837                                carry_set_0.carryDequeueEnqueue(0,1);
838                        }
839                        if (bitblock::any(simd_or(Ct_Cursor,carry_set_0.carryRange(0,5))))
840                        {
841                                ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts,Ct_Cursor);
842                                carry_set_0.getCarry(9) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_0.getCarry(9),Ct_Cursor));
843                                BitBlock Ct_error;
844                                Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
845                                BitBlock _temp3;
846                                carry_set_0.getCarry(10) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_0.getCarry(10),_temp3));
847                                carry_set_0.getCarry(11) = bitblock::srli<127>(pablo_blk_Advance(_temp3,carry_set_0.getCarry(11),Ct_Cursor));
848                                BitBlock _temp4;
849                                carry_set_0.getCarry(12) = bitblock::srli<127>(pablo_blk_ScanThru(Ct_Cursor,DoubleHyphen,carry_set_0.getCarry(12),_temp4));
850                                carry_set_0.getCarry(13) = bitblock::srli<127>(pablo_blk_Advance(_temp4,carry_set_0.getCarry(13),Ct_Cursor));
851                                if (bitblock::any(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle))))
852                                {
853                                        assert_0_error(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle)),"Error in comment syntax");
854                                }
855                                ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends,Ct_Cursor);
856                                CtCDPI_ends = simd_or(CtCDPI_ends,Ct_Cursor);
857                        }
858                        else
859                        {
860                                carry_set_0.carryDequeueEnqueue(0,5);
861                        }
862                        CtCDPI_Cursor = simd_or(simd_or(PI_Cursor,CD_Cursor),Ct_Cursor);
863                        carry_set_0.getCarry(14) = bitblock::srli<127>(pablo_blk_InclusiveSpan(CtCDPI_starts,CtCDPI_ends,carry_set_0.getCarry(14),ctCDPI_mask));
864                        if (bitblock::any(simd<1>::constant<0>()))
865                        {
866                                assert_0_error(simd<1>::constant<0>(),"Error in comment, CDATA or processing instruction syntax");
867                        }
868                        carry_set_0.getCarry(15) = bitblock::srli<127>(pablo_blk_ScanThru(CtCDPI_Cursor,CtCDPI_opener,carry_set_0.getCarry(15),CtCDPI_Cursor));
869                        while (bitblock::any(CtCDPI_Cursor))
870                        {
871                                CarryDeclare(carry_set_1,13,0);
872                                CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
873                                BitBlock PI_Cursor;
874                                PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
875                                BitBlock CD_Ct_Cursor;
876                                carry_set_0.getCarry(16) = bitblock::srli<127>(pablo_blk_Advance(simd_andc(CtCDPI_Cursor,PI_Cursor),carry_set_0.getCarry(16),CD_Ct_Cursor));
877                                BitBlock CD_Cursor;
878                                CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
879                                BitBlock Ct_Cursor;
880                                Ct_Cursor = simd_and(CD_Ct_Cursor,lex.Hyphen);
881                                if (bitblock::any(PI_Cursor))
882                                {
883                                        ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts,PI_Cursor);
884                                        carry_set_0.getCarry(17) = bitblock::srli<127>(pablo_blk_Advance(PI_Cursor,carry_set_0.getCarry(17),PI_Cursor));
885                                        ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts,PI_Cursor);
886                                        BitBlock PI_name_end;
887                                        carry_set_0.getCarry(18) = bitblock::srli<127>(pablo_blk_ScanThru(PI_Cursor,lex.NameScan,carry_set_0.getCarry(18),PI_name_end));
888                                        BitBlock PI_error;
889                                        PI_error = simd_and(PI_Cursor,PI_name_end);
890                                        BitBlock PI_noWS;
891                                        PI_noWS = simd_andc(PI_name_end,lex.WS);
892                                        BitBlock _temp2;
893                                        carry_set_0.getCarry(19) = bitblock::srli<127>(pablo_blk_Advance(PI_noWS,carry_set_0.getCarry(19),_temp2));
894                                        PI_error = simd_or(PI_error,simd_or(simd_andc(PI_noWS,lex.QMark),simd_andc(_temp2,PI_closer)));
895                                        if (bitblock::any(PI_error))
896                                        {
897                                                assert_0_error(PI_error,"Error in PI syntax");
898                                        }
899                                        ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends,PI_name_end);
900                                        carry_set_0.getCarry(20) = bitblock::srli<127>(pablo_blk_ScanThru(PI_name_end,PI_closer,carry_set_0.getCarry(20),PI_Cursor));
901                                        ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends,PI_Cursor);
902                                        CtCDPI_ends = simd_or(CtCDPI_ends,PI_Cursor);
903                                }
904                                if (bitblock::any(CD_Cursor))
905                                {
906                                        ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts,CD_Cursor);
907                                        carry_set_0.getCarry(21) = bitblock::srli<127>(pablo_blk_ScanThru(CD_Cursor,CD_closer,carry_set_0.getCarry(21),CD_Cursor));
908                                        ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends,CD_Cursor);
909                                        CtCDPI_ends = simd_or(CtCDPI_ends,CD_Cursor);
910                                }
911                                if (bitblock::any(Ct_Cursor))
912                                {
913                                        ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts,Ct_Cursor);
914                                        carry_set_0.getCarry(22) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_0.getCarry(22),Ct_Cursor));
915                                        BitBlock Ct_error;
916                                        Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
917                                        BitBlock _temp3;
918                                        carry_set_0.getCarry(23) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_0.getCarry(23),_temp3));
919                                        carry_set_0.getCarry(24) = bitblock::srli<127>(pablo_blk_Advance(_temp3,carry_set_0.getCarry(24),Ct_Cursor));
920                                        BitBlock _temp4;
921                                        carry_set_0.getCarry(25) = bitblock::srli<127>(pablo_blk_ScanThru(Ct_Cursor,DoubleHyphen,carry_set_0.getCarry(25),_temp4));
922                                        carry_set_0.getCarry(26) = bitblock::srli<127>(pablo_blk_Advance(_temp4,carry_set_0.getCarry(26),Ct_Cursor));
923                                        if (bitblock::any(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle))))
924                                        {
925                                                assert_0_error(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle)),"Error in comment syntax");
926                                        }
927                                        ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends,Ct_Cursor);
928                                        CtCDPI_ends = simd_or(CtCDPI_ends,Ct_Cursor);
929                                }
930                                CtCDPI_Cursor = simd_or(simd_or(PI_Cursor,CD_Cursor),Ct_Cursor);
931                                carry_set_0.getCarry(27) = bitblock::srli<127>(pablo_blk_InclusiveSpan(CtCDPI_starts,CtCDPI_ends,carry_set_0.getCarry(27),ctCDPI_mask));
932                                if (bitblock::any(simd<1>::constant<0>()))
933                                {
934                                        assert_0_error(simd<1>::constant<0>(),"Error in comment, CDATA or processing instruction syntax");
935                                }
936                                carry_set_0.getCarry(28) = bitblock::srli<127>(pablo_blk_ScanThru(CtCDPI_Cursor,CtCDPI_opener,carry_set_0.getCarry(28),CtCDPI_Cursor));
937                                LocalCarryCombine(carry_set_0,carry_set_1,0,13);
938                        }
939                }
940                else
941                {
942                        carry_set_0.carryDequeueEnqueue(0,13);
943                }
944                BitBlock _temp5;
945                carry_set_0.getCarry(29) = bitblock::srli<127>(pablo_blk_InclusiveSpan(simd_or(ctCDPI_Callouts.Ct_starts,ctCDPI_Callouts.PI_starts),simd_or(ctCDPI_Callouts.Ct_ends,ctCDPI_Callouts.PI_ends),carry_set_0.getCarry(29),_temp5));
946                check_streams.misc_mask = simd_and(simd_or(simd_or(simd_or(lex.WS,lex.LAngle),_temp5),CtCDPI_starts),EOF_mask);
947                marker.LAngle_scope = simd_andc(LAngle_scope,ctCDPI_mask);
948                marker.Ref_opener = simd_andc(lex.RefStart,ctCDPI_mask);
949                marker.CD_closer = simd_andc(CD_closer,ctCDPI_mask);
950                carry_set_0.carryAdjust(17);
951        }
952       
953        void do_final_block(struct Lex & lex,struct Marker & marker,struct CtCDPI_Callouts & ctCDPI_Callouts,struct Check_streams & check_streams,BitBlock & EOF_mask)
954        {
955                ctCDPI_Callouts.Ct_starts = simd<1>::constant<0>();
956                ctCDPI_Callouts.Ct_ends = simd<1>::constant<0>();
957                ctCDPI_Callouts.CD_starts = simd<1>::constant<0>();
958                ctCDPI_Callouts.CD_ends = simd<1>::constant<0>();
959                ctCDPI_Callouts.PI_starts = simd<1>::constant<0>();
960                ctCDPI_Callouts.PI_name_starts = simd<1>::constant<0>();
961                ctCDPI_Callouts.PI_name_ends = simd<1>::constant<0>();
962                ctCDPI_Callouts.PI_ends = simd<1>::constant<0>();
963                BitBlock CtCDPI_starts;
964                CtCDPI_starts = simd<1>::constant<0>();
965                BitBlock CtCDPI_ends;
966                CtCDPI_ends = simd<1>::constant<0>();
967                BitBlock ctCDPI_mask;
968                ctCDPI_mask = simd<1>::constant<0>();
969                BitBlock v;
970                v = simd_or(lex.LAngle,lex.Hyphen);
971                BitBlock w;
972                w = simd_or(lex.Hyphen,lex.QMark);
973                BitBlock v1;
974                carry_set_0.getPending64(0) = bitblock::srli<127>(pablo_blk_Advance_n_<v>(1,carry_set_0.getPending64(0),v1));
975                BitBlock w1;
976                carry_set_0.getPending64(1) = bitblock::srli<127>(pablo_blk_Advance_n_<w>(1,carry_set_0.getPending64(1),w1));
977                BitBlock LAngle_scope;
978                LAngle_scope = simd_andc(v1,w1);
979                BitBlock PI_opener;
980                PI_opener = simd_and(LAngle_scope,lex.QMark);
981                BitBlock CtCD_opener;
982                CtCD_opener = simd_and(LAngle_scope,lex.Exclam);
983                BitBlock CtCDPI_opener;
984                CtCDPI_opener = simd_or(PI_opener,CtCD_opener);
985                BitBlock CD_closer;
986                CD_closer = simd<1>::constant<0>();
987                BitBlock DoubleHyphen;
988                DoubleHyphen = simd_and(simd_and(v1,w1),lex.Hyphen);
989                if (bitblock::any(simd_or(lex.RBracket,carry_set_0.carryRange(0,2))))
990                {
991                        BitBlock DoubleRBracket;
992                        BitBlock _temp0;
993                        carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(lex.RBracket,carry_set_0.getCarry(0),_temp0));
994                        DoubleRBracket = simd_and(_temp0,lex.RBracket);
995                        BitBlock _temp1;
996                        carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(DoubleRBracket,carry_set_0.getCarry(1),_temp1));
997                        CD_closer = simd_and(_temp1,lex.RAngle);
998                }
999                else
1000                {
1001                        carry_set_0.carryDequeueEnqueue(0,2);
1002                }
1003                BitBlock PI_closer;
1004                PI_closer = simd_and(simd_andc(w1,v1),lex.RAngle);
1005                BitBlock CtCDPI_Cursor;
1006                carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_ScanToFirst(CtCDPI_opener,carry_set_0.getCarry(2),CtCDPI_Cursor));
1007                if (bitblock::any(simd_or(simd_and(CtCDPI_Cursor,EOF_mask),carry_set_0.carryRange(0,13))))
1008                {
1009                        CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
1010                        BitBlock PI_Cursor;
1011                        PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
1012                        BitBlock CD_Ct_Cursor;
1013                        carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_Advance(simd_andc(CtCDPI_Cursor,PI_Cursor),carry_set_0.getCarry(3),CD_Ct_Cursor));
1014                        BitBlock CD_Cursor;
1015                        CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
1016                        BitBlock Ct_Cursor;
1017                        Ct_Cursor = simd_and(CD_Ct_Cursor,lex.Hyphen);
1018                        if (bitblock::any(simd_or(PI_Cursor,carry_set_0.carryRange(0,4))))
1019                        {
1020                                ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts,PI_Cursor);
1021                                carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_Advance(PI_Cursor,carry_set_0.getCarry(4),PI_Cursor));
1022                                ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts,PI_Cursor);
1023                                BitBlock PI_name_end;
1024                                carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_ScanThru(PI_Cursor,lex.NameScan,carry_set_0.getCarry(5),PI_name_end));
1025                                BitBlock PI_error;
1026                                PI_error = simd_and(PI_Cursor,PI_name_end);
1027                                BitBlock PI_noWS;
1028                                PI_noWS = simd_andc(PI_name_end,lex.WS);
1029                                BitBlock _temp2;
1030                                carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_Advance(PI_noWS,carry_set_0.getCarry(6),_temp2));
1031                                PI_error = simd_or(PI_error,simd_or(simd_andc(PI_noWS,lex.QMark),simd_andc(_temp2,PI_closer)));
1032                                if (bitblock::any(PI_error))
1033                                {
1034                                        assert_0_error(PI_error,"Error in PI syntax");
1035                                }
1036                                ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends,PI_name_end);
1037                                carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_ScanThru(PI_name_end,PI_closer,carry_set_0.getCarry(7),PI_Cursor));
1038                                ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends,PI_Cursor);
1039                                CtCDPI_ends = simd_or(CtCDPI_ends,PI_Cursor);
1040                        }
1041                        else
1042                        {
1043                                carry_set_0.carryDequeueEnqueue(0,4);
1044                        }
1045                        if (bitblock::any(simd_or(CD_Cursor,carry_set_0.carryRange(0,1))))
1046                        {
1047                                ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts,CD_Cursor);
1048                                carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_ScanThru(CD_Cursor,CD_closer,carry_set_0.getCarry(8),CD_Cursor));
1049                                ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends,CD_Cursor);
1050                                CtCDPI_ends = simd_or(CtCDPI_ends,CD_Cursor);
1051                        }
1052                        else
1053                        {
1054                                carry_set_0.carryDequeueEnqueue(0,1);
1055                        }
1056                        if (bitblock::any(simd_or(Ct_Cursor,carry_set_0.carryRange(0,5))))
1057                        {
1058                                ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts,Ct_Cursor);
1059                                carry_set_0.getCarry(9) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_0.getCarry(9),Ct_Cursor));
1060                                BitBlock Ct_error;
1061                                Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
1062                                BitBlock _temp3;
1063                                carry_set_0.getCarry(10) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_0.getCarry(10),_temp3));
1064                                carry_set_0.getCarry(11) = bitblock::srli<127>(pablo_blk_Advance(_temp3,carry_set_0.getCarry(11),Ct_Cursor));
1065                                BitBlock _temp4;
1066                                carry_set_0.getCarry(12) = bitblock::srli<127>(pablo_blk_ScanThru(Ct_Cursor,DoubleHyphen,carry_set_0.getCarry(12),_temp4));
1067                                carry_set_0.getCarry(13) = bitblock::srli<127>(pablo_blk_Advance(_temp4,carry_set_0.getCarry(13),Ct_Cursor));
1068                                if (bitblock::any(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle))))
1069                                {
1070                                        assert_0_error(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle)),"Error in comment syntax");
1071                                }
1072                                ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends,Ct_Cursor);
1073                                CtCDPI_ends = simd_or(CtCDPI_ends,Ct_Cursor);
1074                        }
1075                        else
1076                        {
1077                                carry_set_0.carryDequeueEnqueue(0,5);
1078                        }
1079                        CtCDPI_Cursor = simd_or(simd_or(PI_Cursor,CD_Cursor),Ct_Cursor);
1080                        carry_set_0.getCarry(14) = bitblock::srli<127>(pablo_blk_InclusiveSpan(CtCDPI_starts,CtCDPI_ends,carry_set_0.getCarry(14),ctCDPI_mask));
1081                        if (bitblock::any(simd_andc(ctCDPI_mask,EOF_mask)))
1082                        {
1083                                assert_0_error(simd_andc(ctCDPI_mask,EOF_mask),"Error in comment, CDATA or processing instruction syntax");
1084                        }
1085                        carry_set_0.getCarry(15) = bitblock::srli<127>(pablo_blk_ScanThru(CtCDPI_Cursor,CtCDPI_opener,carry_set_0.getCarry(15),CtCDPI_Cursor));
1086                        while (bitblock::any(simd_and(CtCDPI_Cursor,EOF_mask)))
1087                        {
1088                                CarryDeclare(carry_set_1,13,0);
1089                                CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
1090                                BitBlock PI_Cursor;
1091                                PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
1092                                BitBlock CD_Ct_Cursor;
1093                                carry_set_0.getCarry(16) = bitblock::srli<127>(pablo_blk_Advance(simd_andc(CtCDPI_Cursor,PI_Cursor),carry_set_0.getCarry(16),CD_Ct_Cursor));
1094                                BitBlock CD_Cursor;
1095                                CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
1096                                BitBlock Ct_Cursor;
1097                                Ct_Cursor = simd_and(CD_Ct_Cursor,lex.Hyphen);
1098                                if (bitblock::any(PI_Cursor))
1099                                {
1100                                        ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts,PI_Cursor);
1101                                        carry_set_0.getCarry(17) = bitblock::srli<127>(pablo_blk_Advance(PI_Cursor,carry_set_0.getCarry(17),PI_Cursor));
1102                                        ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts,PI_Cursor);
1103                                        BitBlock PI_name_end;
1104                                        carry_set_0.getCarry(18) = bitblock::srli<127>(pablo_blk_ScanThru(PI_Cursor,lex.NameScan,carry_set_0.getCarry(18),PI_name_end));
1105                                        BitBlock PI_error;
1106                                        PI_error = simd_and(PI_Cursor,PI_name_end);
1107                                        BitBlock PI_noWS;
1108                                        PI_noWS = simd_andc(PI_name_end,lex.WS);
1109                                        BitBlock _temp2;
1110                                        carry_set_0.getCarry(19) = bitblock::srli<127>(pablo_blk_Advance(PI_noWS,carry_set_0.getCarry(19),_temp2));
1111                                        PI_error = simd_or(PI_error,simd_or(simd_andc(PI_noWS,lex.QMark),simd_andc(_temp2,PI_closer)));
1112                                        if (bitblock::any(PI_error))
1113                                        {
1114                                                assert_0_error(PI_error,"Error in PI syntax");
1115                                        }
1116                                        ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends,PI_name_end);
1117                                        carry_set_0.getCarry(20) = bitblock::srli<127>(pablo_blk_ScanThru(PI_name_end,PI_closer,carry_set_0.getCarry(20),PI_Cursor));
1118                                        ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends,PI_Cursor);
1119                                        CtCDPI_ends = simd_or(CtCDPI_ends,PI_Cursor);
1120                                }
1121                                if (bitblock::any(CD_Cursor))
1122                                {
1123                                        ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts,CD_Cursor);
1124                                        carry_set_0.getCarry(21) = bitblock::srli<127>(pablo_blk_ScanThru(CD_Cursor,CD_closer,carry_set_0.getCarry(21),CD_Cursor));
1125                                        ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends,CD_Cursor);
1126                                        CtCDPI_ends = simd_or(CtCDPI_ends,CD_Cursor);
1127                                }
1128                                if (bitblock::any(Ct_Cursor))
1129                                {
1130                                        ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts,Ct_Cursor);
1131                                        carry_set_0.getCarry(22) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_0.getCarry(22),Ct_Cursor));
1132                                        BitBlock Ct_error;
1133                                        Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
1134                                        BitBlock _temp3;
1135                                        carry_set_0.getCarry(23) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_0.getCarry(23),_temp3));
1136                                        carry_set_0.getCarry(24) = bitblock::srli<127>(pablo_blk_Advance(_temp3,carry_set_0.getCarry(24),Ct_Cursor));
1137                                        BitBlock _temp4;
1138                                        carry_set_0.getCarry(25) = bitblock::srli<127>(pablo_blk_ScanThru(Ct_Cursor,DoubleHyphen,carry_set_0.getCarry(25),_temp4));
1139                                        carry_set_0.getCarry(26) = bitblock::srli<127>(pablo_blk_Advance(_temp4,carry_set_0.getCarry(26),Ct_Cursor));
1140                                        if (bitblock::any(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle))))
1141                                        {
1142                                                assert_0_error(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle)),"Error in comment syntax");
1143                                        }
1144                                        ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends,Ct_Cursor);
1145                                        CtCDPI_ends = simd_or(CtCDPI_ends,Ct_Cursor);
1146                                }
1147                                CtCDPI_Cursor = simd_or(simd_or(PI_Cursor,CD_Cursor),Ct_Cursor);
1148                                carry_set_0.getCarry(27) = bitblock::srli<127>(pablo_blk_InclusiveSpan(CtCDPI_starts,CtCDPI_ends,carry_set_0.getCarry(27),ctCDPI_mask));
1149                                if (bitblock::any(simd_andc(ctCDPI_mask,EOF_mask)))
1150                                {
1151                                        assert_0_error(simd_andc(ctCDPI_mask,EOF_mask),"Error in comment, CDATA or processing instruction syntax");
1152                                }
1153                                carry_set_0.getCarry(28) = bitblock::srli<127>(pablo_blk_ScanThru(CtCDPI_Cursor,CtCDPI_opener,carry_set_0.getCarry(28),CtCDPI_Cursor));
1154                                LocalCarryCombine(carry_set_0,carry_set_1,0,13);
1155                        }
1156                }
1157                else
1158                {
1159                        carry_set_0.carryDequeueEnqueue(0,13);
1160                }
1161                BitBlock _temp5;
1162                carry_set_0.getCarry(29) = bitblock::srli<127>(pablo_blk_InclusiveSpan(simd_or(ctCDPI_Callouts.Ct_starts,ctCDPI_Callouts.PI_starts),simd_or(ctCDPI_Callouts.Ct_ends,ctCDPI_Callouts.PI_ends),carry_set_0.getCarry(29),_temp5));
1163                check_streams.misc_mask = simd_and(simd_or(simd_or(simd_or(lex.WS,lex.LAngle),_temp5),CtCDPI_starts),EOF_mask);
1164                marker.LAngle_scope = simd_andc(LAngle_scope,ctCDPI_mask);
1165                marker.Ref_opener = simd_andc(lex.RefStart,ctCDPI_mask);
1166                marker.CD_closer = simd_andc(CD_closer,ctCDPI_mask);
1167        }
1168       
1169        CarryDeclare(carry_set_0,30,2);
1170};
1171 
1172struct Parse_tags
1173{
1174        Parse_tags()
1175        {
1176        }
1177       
1178        IDISA_INLINE void do_block(struct Lex & lex,struct Marker & marker,struct Tag_Callouts & tag_Callouts)
1179        {
1180                BitBlock EqExpected;
1181                EqExpected = simd<1>::constant<0>();
1182                BitBlock AttListEnd;
1183                AttListEnd = simd<1>::constant<0>();
1184                BitBlock DQuoteDelim;
1185                DQuoteDelim = simd_or(lex.DQuote,lex.LAngle);
1186                BitBlock SQuoteDelim;
1187                SQuoteDelim = simd_or(lex.SQuote,lex.LAngle);
1188                BitBlock AttListDelim;
1189                AttListDelim = simd_or(lex.Slash,lex.RAngle);
1190                tag_Callouts.ElemName_starts = simd_andc(marker.LAngle_scope,lex.Slash);
1191                tag_Callouts.EndTag_marks = simd_and(marker.LAngle_scope,lex.Slash);
1192                carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_ScanThru(tag_Callouts.ElemName_starts,lex.NameScan,carry_set_0.getCarry(0),tag_Callouts.ElemName_ends));
1193                BitBlock ParseError;
1194                ParseError = simd_and(tag_Callouts.ElemName_starts,tag_Callouts.ElemName_ends);
1195                tag_Callouts.AttName_starts = simd<1>::constant<0>();
1196                tag_Callouts.AttName_ends = simd<1>::constant<0>();
1197                tag_Callouts.AttVal_starts = simd<1>::constant<0>();
1198                tag_Callouts.AttVal_ends = simd<1>::constant<0>();
1199                if (bitblock::any(simd_or(simd_and(tag_Callouts.ElemName_ends,lex.WS),carry_set_0.carryRange(0,8))))
1200                {
1201                        BitBlock AfterWS;
1202                        carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_ScanThru(tag_Callouts.ElemName_ends,lex.WS,carry_set_0.getCarry(1),AfterWS));
1203                        AttListEnd = simd_and(AfterWS,AttListDelim);
1204                        BitBlock AttNameStart;
1205                        AttNameStart = simd_andc(AfterWS,AttListDelim);
1206                        if (bitblock::any(simd_or(AttNameStart,carry_set_0.carryRange(0,7))))
1207                        {
1208                                ParseError = simd_or(ParseError,simd_andc(AttNameStart,lex.NameScan));
1209                                tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts,AttNameStart);
1210                                BitBlock AttNameFollow;
1211                                carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameStart,lex.NameScan,carry_set_0.getCarry(2),AttNameFollow));
1212                                tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends,AttNameFollow);
1213                                if (bitblock::any(simd_or(simd_and(AttNameFollow,lex.WS),carry_set_0.carryRange(0,1))))
1214                                {
1215                                        carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameFollow,lex.WS,carry_set_0.getCarry(3),EqExpected));
1216                                }
1217                                else
1218                                {
1219                                        EqExpected = AttNameFollow;
1220                                        carry_set_0.carryDequeueEnqueue(0,1);
1221                                }
1222                                ParseError = simd_or(ParseError,simd_andc(EqExpected,lex.Equals));
1223                                BitBlock AttValPos;
1224                                carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(EqExpected,lex.WS,carry_set_0.getCarry(4),AttValPos));
1225                                tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts,AttValPos);
1226                                BitBlock DQuoteAttVal;
1227                                DQuoteAttVal = simd_and(AttValPos,lex.DQuote);
1228                                BitBlock SQuoteAttVal;
1229                                SQuoteAttVal = simd_and(AttValPos,lex.SQuote);
1230                                BitBlock DQuoteAttEnd;
1231                                carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(DQuoteAttVal,DQuoteDelim,carry_set_0.getCarry(5),DQuoteAttEnd));
1232                                BitBlock SQuoteAttEnd;
1233                                carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(SQuoteAttVal,SQuoteDelim,carry_set_0.getCarry(6),SQuoteAttEnd));
1234                                BitBlock AttValEnd;
1235                                AttValEnd = simd_or(DQuoteAttEnd,SQuoteAttEnd);
1236                                ParseError = simd_or(ParseError,simd_andc(simd_or(AttValPos,AttValEnd),simd_or(lex.DQuote,lex.SQuote)));
1237                                BitBlock AttValFollow;
1238                                carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(AttValEnd,carry_set_0.getCarry(7),AttValFollow));
1239                                tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends,AttValFollow);
1240                                if (bitblock::any(simd_or(simd_and(AttValFollow,lex.WS),carry_set_0.carryRange(0,1))))
1241                                {
1242                                        carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_ScanThru(AttValFollow,lex.WS,carry_set_0.getCarry(8),AfterWS));
1243                                        AttListEnd = simd_or(AttListEnd,simd_and(AfterWS,AttListDelim));
1244                                        AttNameStart = simd_andc(AfterWS,AttListDelim);
1245                                }
1246                                else
1247                                {
1248                                        AttListEnd = simd_or(AttListEnd,simd_and(AttValFollow,AttListDelim));
1249                                        AttNameStart = simd_andc(AttValFollow,AttListDelim);
1250                                        carry_set_0.carryDequeueEnqueue(0,1);
1251                                }
1252                                ParseError = simd_or(ParseError,simd_and(AttValFollow,AttNameStart));
1253                                while (bitblock::any(AttNameStart))
1254                                {
1255                                        CarryDeclare(carry_set_1,7,0);
1256                                        ParseError = simd_or(ParseError,simd_andc(AttNameStart,lex.NameScan));
1257                                        tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts,AttNameStart);
1258                                        BitBlock AttNameFollow;
1259                                        carry_set_0.getCarry(9) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameStart,lex.NameScan,carry_set_0.getCarry(9),AttNameFollow));
1260                                        tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends,AttNameFollow);
1261                                        if (bitblock::any(simd_and(AttNameFollow,lex.WS)))
1262                                        {
1263                                                carry_set_0.getCarry(10) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameFollow,lex.WS,carry_set_0.getCarry(10),EqExpected));
1264                                        }
1265                                        else
1266                                        {
1267                                                EqExpected = AttNameFollow;
1268                                        }
1269                                        ParseError = simd_or(ParseError,simd_andc(EqExpected,lex.Equals));
1270                                        BitBlock AttValPos;
1271                                        carry_set_0.getCarry(11) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(EqExpected,lex.WS,carry_set_0.getCarry(11),AttValPos));
1272                                        tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts,AttValPos);
1273                                        BitBlock DQuoteAttVal;
1274                                        DQuoteAttVal = simd_and(AttValPos,lex.DQuote);
1275                                        BitBlock SQuoteAttVal;
1276                                        SQuoteAttVal = simd_and(AttValPos,lex.SQuote);
1277                                        BitBlock DQuoteAttEnd;
1278                                        carry_set_0.getCarry(12) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(DQuoteAttVal,DQuoteDelim,carry_set_0.getCarry(12),DQuoteAttEnd));
1279                                        BitBlock SQuoteAttEnd;
1280                                        carry_set_0.getCarry(13) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(SQuoteAttVal,SQuoteDelim,carry_set_0.getCarry(13),SQuoteAttEnd));
1281                                        BitBlock AttValEnd;
1282                                        AttValEnd = simd_or(DQuoteAttEnd,SQuoteAttEnd);
1283                                        ParseError = simd_or(ParseError,simd_andc(simd_or(AttValPos,AttValEnd),simd_or(lex.DQuote,lex.SQuote)));
1284                                        BitBlock AttValFollow;
1285                                        carry_set_0.getCarry(14) = bitblock::srli<127>(pablo_blk_Advance(AttValEnd,carry_set_0.getCarry(14),AttValFollow));
1286                                        tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends,AttValFollow);
1287                                        if (bitblock::any(simd_and(AttValFollow,lex.WS)))
1288                                        {
1289                                                carry_set_0.getCarry(15) = bitblock::srli<127>(pablo_blk_ScanThru(AttValFollow,lex.WS,carry_set_0.getCarry(15),AfterWS));
1290                                                AttListEnd = simd_or(AttListEnd,simd_and(AfterWS,AttListDelim));
1291                                                AttNameStart = simd_andc(AfterWS,AttListDelim);
1292                                        }
1293                                        else
1294                                        {
1295                                                AttListEnd = simd_or(AttListEnd,simd_and(AttValFollow,AttListDelim));
1296                                                AttNameStart = simd_andc(AttValFollow,AttListDelim);
1297                                        }
1298                                        ParseError = simd_or(ParseError,simd_and(AttValFollow,AttNameStart));
1299                                        LocalCarryCombine(carry_set_0,carry_set_1,0,7);
1300                                }
1301                        }
1302                        else
1303                        {
1304                                carry_set_0.carryDequeueEnqueue(0,7);
1305                        }
1306                }
1307                else
1308                {
1309                        AttListEnd = simd_and(tag_Callouts.ElemName_ends,AttListDelim);
1310                        ParseError = simd_or(ParseError,simd_andc(tag_Callouts.ElemName_ends,AttListDelim));
1311                        carry_set_0.carryDequeueEnqueue(0,8);
1312                }
1313                BitBlock STagEnds;
1314                STagEnds = simd_and(AttListEnd,lex.RAngle);
1315                carry_set_0.getCarry(16) = bitblock::srli<127>(pablo_blk_Advance(simd_and(AttListEnd,lex.Slash),carry_set_0.getCarry(16),tag_Callouts.EmptyTag_marks));
1316                ParseError = simd_or(ParseError,simd_andc(tag_Callouts.EmptyTag_marks,lex.RAngle));
1317                BitBlock EndTagEnds;
1318                carry_set_0.getCarry(17) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(tag_Callouts.EndTag_marks,lex.NameScan,carry_set_0.getCarry(17),EndTagEnds));
1319                if (bitblock::any(simd_or(simd_and(EndTagEnds,lex.WS),carry_set_0.carryRange(0,1))))
1320                {
1321                        carry_set_0.getCarry(18) = bitblock::srli<127>(pablo_blk_ScanThru(EndTagEnds,lex.WS,carry_set_0.getCarry(18),EndTagEnds));
1322                }
1323                else
1324                {
1325                        carry_set_0.carryDequeueEnqueue(0,1);
1326                }
1327                ParseError = simd_or(ParseError,simd_andc(EndTagEnds,lex.RAngle));
1328                if (bitblock::any(ParseError))
1329                {
1330                        assert_0_error(ParseError,"Tag parsing error found");
1331                }
1332                carry_set_0.getCarry(19) = bitblock::srli<127>(pablo_blk_SpanUpTo(tag_Callouts.AttVal_starts,tag_Callouts.AttVal_ends,carry_set_0.getCarry(19),tag_Callouts.AttVal_spans));
1333                carry_set_0.carryAdjust(13);
1334        }
1335       
1336        void do_final_block(struct Lex & lex,struct Marker & marker,struct Tag_Callouts & tag_Callouts,BitBlock & EOF_mask)
1337        {
1338                BitBlock EqExpected;
1339                EqExpected = simd<1>::constant<0>();
1340                BitBlock AttListEnd;
1341                AttListEnd = simd<1>::constant<0>();
1342                BitBlock DQuoteDelim;
1343                DQuoteDelim = simd_or(lex.DQuote,lex.LAngle);
1344                BitBlock SQuoteDelim;
1345                SQuoteDelim = simd_or(lex.SQuote,lex.LAngle);
1346                BitBlock AttListDelim;
1347                AttListDelim = simd_or(lex.Slash,lex.RAngle);
1348                tag_Callouts.ElemName_starts = simd_andc(marker.LAngle_scope,lex.Slash);
1349                tag_Callouts.EndTag_marks = simd_and(marker.LAngle_scope,lex.Slash);
1350                carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_ScanThru(tag_Callouts.ElemName_starts,lex.NameScan,carry_set_0.getCarry(0),tag_Callouts.ElemName_ends));
1351                BitBlock ParseError;
1352                ParseError = simd_and(tag_Callouts.ElemName_starts,tag_Callouts.ElemName_ends);
1353                tag_Callouts.AttName_starts = simd<1>::constant<0>();
1354                tag_Callouts.AttName_ends = simd<1>::constant<0>();
1355                tag_Callouts.AttVal_starts = simd<1>::constant<0>();
1356                tag_Callouts.AttVal_ends = simd<1>::constant<0>();
1357                if (bitblock::any(simd_or(simd_and(tag_Callouts.ElemName_ends,lex.WS),carry_set_0.carryRange(0,8))))
1358                {
1359                        BitBlock AfterWS;
1360                        carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_ScanThru(tag_Callouts.ElemName_ends,lex.WS,carry_set_0.getCarry(1),AfterWS));
1361                        AttListEnd = simd_and(AfterWS,AttListDelim);
1362                        BitBlock AttNameStart;
1363                        AttNameStart = simd_andc(AfterWS,AttListDelim);
1364                        if (bitblock::any(simd_or(simd_and(AttNameStart,EOF_mask),carry_set_0.carryRange(0,7))))
1365                        {
1366                                ParseError = simd_or(ParseError,simd_andc(AttNameStart,lex.NameScan));
1367                                tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts,AttNameStart);
1368                                BitBlock AttNameFollow;
1369                                carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameStart,lex.NameScan,carry_set_0.getCarry(2),AttNameFollow));
1370                                tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends,AttNameFollow);
1371                                if (bitblock::any(simd_or(simd_and(AttNameFollow,lex.WS),carry_set_0.carryRange(0,1))))
1372                                {
1373                                        carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameFollow,lex.WS,carry_set_0.getCarry(3),EqExpected));
1374                                }
1375                                else
1376                                {
1377                                        EqExpected = AttNameFollow;
1378                                        carry_set_0.carryDequeueEnqueue(0,1);
1379                                }
1380                                ParseError = simd_or(ParseError,simd_andc(EqExpected,lex.Equals));
1381                                BitBlock AttValPos;
1382                                carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(EqExpected,lex.WS,carry_set_0.getCarry(4),AttValPos));
1383                                tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts,AttValPos);
1384                                BitBlock DQuoteAttVal;
1385                                DQuoteAttVal = simd_and(AttValPos,lex.DQuote);
1386                                BitBlock SQuoteAttVal;
1387                                SQuoteAttVal = simd_and(AttValPos,lex.SQuote);
1388                                BitBlock DQuoteAttEnd;
1389                                carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(DQuoteAttVal,DQuoteDelim,carry_set_0.getCarry(5),DQuoteAttEnd));
1390                                BitBlock SQuoteAttEnd;
1391                                carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(SQuoteAttVal,SQuoteDelim,carry_set_0.getCarry(6),SQuoteAttEnd));
1392                                BitBlock AttValEnd;
1393                                AttValEnd = simd_or(DQuoteAttEnd,SQuoteAttEnd);
1394                                ParseError = simd_or(ParseError,simd_andc(simd_or(AttValPos,AttValEnd),simd_or(lex.DQuote,lex.SQuote)));
1395                                BitBlock AttValFollow;
1396                                carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(AttValEnd,carry_set_0.getCarry(7),AttValFollow));
1397                                tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends,AttValFollow);
1398                                if (bitblock::any(simd_or(simd_and(AttValFollow,lex.WS),carry_set_0.carryRange(0,1))))
1399                                {
1400                                        carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_ScanThru(AttValFollow,lex.WS,carry_set_0.getCarry(8),AfterWS));
1401                                        AttListEnd = simd_or(AttListEnd,simd_and(AfterWS,AttListDelim));
1402                                        AttNameStart = simd_andc(AfterWS,AttListDelim);
1403                                }
1404                                else
1405                                {
1406                                        AttListEnd = simd_or(AttListEnd,simd_and(AttValFollow,AttListDelim));
1407                                        AttNameStart = simd_andc(AttValFollow,AttListDelim);
1408                                        carry_set_0.carryDequeueEnqueue(0,1);
1409                                }
1410                                ParseError = simd_or(ParseError,simd_and(AttValFollow,AttNameStart));
1411                                while (bitblock::any(simd_and(AttNameStart,EOF_mask)))
1412                                {
1413                                        CarryDeclare(carry_set_1,7,0);
1414                                        ParseError = simd_or(ParseError,simd_andc(AttNameStart,lex.NameScan));
1415                                        tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts,AttNameStart);
1416                                        BitBlock AttNameFollow;
1417                                        carry_set_0.getCarry(9) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameStart,lex.NameScan,carry_set_0.getCarry(9),AttNameFollow));
1418                                        tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends,AttNameFollow);
1419                                        if (bitblock::any(simd_and(AttNameFollow,lex.WS)))
1420                                        {
1421                                                carry_set_0.getCarry(10) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameFollow,lex.WS,carry_set_0.getCarry(10),EqExpected));
1422                                        }
1423                                        else
1424                                        {
1425                                                EqExpected = AttNameFollow;
1426                                        }
1427                                        ParseError = simd_or(ParseError,simd_andc(EqExpected,lex.Equals));
1428                                        BitBlock AttValPos;
1429                                        carry_set_0.getCarry(11) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(EqExpected,lex.WS,carry_set_0.getCarry(11),AttValPos));
1430                                        tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts,AttValPos);
1431                                        BitBlock DQuoteAttVal;
1432                                        DQuoteAttVal = simd_and(AttValPos,lex.DQuote);
1433                                        BitBlock SQuoteAttVal;
1434                                        SQuoteAttVal = simd_and(AttValPos,lex.SQuote);
1435                                        BitBlock DQuoteAttEnd;
1436                                        carry_set_0.getCarry(12) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(DQuoteAttVal,DQuoteDelim,carry_set_0.getCarry(12),DQuoteAttEnd));
1437                                        BitBlock SQuoteAttEnd;
1438                                        carry_set_0.getCarry(13) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(SQuoteAttVal,SQuoteDelim,carry_set_0.getCarry(13),SQuoteAttEnd));
1439                                        BitBlock AttValEnd;
1440                                        AttValEnd = simd_or(DQuoteAttEnd,SQuoteAttEnd);
1441                                        ParseError = simd_or(ParseError,simd_andc(simd_or(AttValPos,AttValEnd),simd_or(lex.DQuote,lex.SQuote)));
1442                                        BitBlock AttValFollow;
1443                                        carry_set_0.getCarry(14) = bitblock::srli<127>(pablo_blk_Advance(AttValEnd,carry_set_0.getCarry(14),AttValFollow));
1444                                        tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends,AttValFollow);
1445                                        if (bitblock::any(simd_and(AttValFollow,lex.WS)))
1446                                        {
1447                                                carry_set_0.getCarry(15) = bitblock::srli<127>(pablo_blk_ScanThru(AttValFollow,lex.WS,carry_set_0.getCarry(15),AfterWS));
1448                                                AttListEnd = simd_or(AttListEnd,simd_and(AfterWS,AttListDelim));
1449                                                AttNameStart = simd_andc(AfterWS,AttListDelim);
1450                                        }
1451                                        else
1452                                        {
1453                                                AttListEnd = simd_or(AttListEnd,simd_and(AttValFollow,AttListDelim));
1454                                                AttNameStart = simd_andc(AttValFollow,AttListDelim);
1455                                        }
1456                                        ParseError = simd_or(ParseError,simd_and(AttValFollow,AttNameStart));
1457                                        LocalCarryCombine(carry_set_0,carry_set_1,0,7);
1458                                }
1459                        }
1460                        else
1461                        {
1462                                carry_set_0.carryDequeueEnqueue(0,7);
1463                        }
1464                }
1465                else
1466                {
1467                        AttListEnd = simd_and(tag_Callouts.ElemName_ends,AttListDelim);
1468                        ParseError = simd_or(ParseError,simd_andc(tag_Callouts.ElemName_ends,AttListDelim));
1469                        carry_set_0.carryDequeueEnqueue(0,8);
1470                }
1471                BitBlock STagEnds;
1472                STagEnds = simd_and(AttListEnd,lex.RAngle);
1473                carry_set_0.getCarry(16) = bitblock::srli<127>(pablo_blk_Advance(simd_and(AttListEnd,lex.Slash),carry_set_0.getCarry(16),tag_Callouts.EmptyTag_marks));
1474                ParseError = simd_or(ParseError,simd_andc(tag_Callouts.EmptyTag_marks,lex.RAngle));
1475                BitBlock EndTagEnds;
1476                carry_set_0.getCarry(17) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(tag_Callouts.EndTag_marks,lex.NameScan,carry_set_0.getCarry(17),EndTagEnds));
1477                if (bitblock::any(simd_or(simd_and(EndTagEnds,lex.WS),carry_set_0.carryRange(0,1))))
1478                {
1479                        carry_set_0.getCarry(18) = bitblock::srli<127>(pablo_blk_ScanThru(EndTagEnds,lex.WS,carry_set_0.getCarry(18),EndTagEnds));
1480                }
1481                else
1482                {
1483                        carry_set_0.carryDequeueEnqueue(0,1);
1484                }
1485                ParseError = simd_or(ParseError,simd_andc(EndTagEnds,lex.RAngle));
1486                if (bitblock::any(ParseError))
1487                {
1488                        assert_0_error(ParseError,"Tag parsing error found");
1489                }
1490                carry_set_0.getCarry(19) = bitblock::srli<127>(pablo_blk_SpanUpTo(tag_Callouts.AttVal_starts,tag_Callouts.AttVal_ends,carry_set_0.getCarry(19),tag_Callouts.AttVal_spans));
1491        }
1492       
1493        CarryDeclare(carry_set_0,20,0);
1494};
1495 
1496struct Parse_refs
1497{
1498        Parse_refs()
1499        {
1500        }
1501       
1502        IDISA_INLINE void do_block(struct Lex & lex,struct Marker & marker,struct Ref_Callouts & ref_Callouts)
1503        {
1504                ref_Callouts.GenRef_starts = simd<1>::constant<0>();
1505                ref_Callouts.GenRef_ends = simd<1>::constant<0>();
1506                ref_Callouts.DecRef_starts = simd<1>::constant<0>();
1507                ref_Callouts.DecRef_ends = simd<1>::constant<0>();
1508                ref_Callouts.HexRef_starts = simd<1>::constant<0>();
1509                ref_Callouts.HexRef_ends = simd<1>::constant<0>();
1510                BitBlock ref_error;
1511                ref_error = simd<1>::constant<0>();
1512                if (bitblock::any(simd_or(marker.Ref_opener,carry_set_0.carryRange(0,6))))
1513                {
1514                        BitBlock Ref_scope;
1515                        carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(marker.Ref_opener,carry_set_0.getCarry(0),Ref_scope));
1516                        BitBlock NumRef2;
1517                        NumRef2 = simd_and(Ref_scope,lex.Hash);
1518                        ref_Callouts.GenRef_starts = simd_andc(Ref_scope,lex.Hash);
1519                        BitBlock NumRef3;
1520                        carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(NumRef2,carry_set_0.getCarry(1),NumRef3));
1521                        BitBlock HexRef3;
1522                        HexRef3 = simd_and(NumRef3,lex.x);
1523                        ref_Callouts.DecRef_starts = simd_andc(NumRef3,lex.x);
1524                        carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_Advance(HexRef3,carry_set_0.getCarry(2),ref_Callouts.HexRef_starts));
1525                        carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_ScanThru(ref_Callouts.GenRef_starts,lex.NameScan,carry_set_0.getCarry(3),ref_Callouts.GenRef_ends));
1526                        carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_ScanThru(ref_Callouts.DecRef_starts,lex.Digit,carry_set_0.getCarry(4),ref_Callouts.DecRef_ends));
1527                        carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_ScanThru(ref_Callouts.HexRef_starts,lex.Hex,carry_set_0.getCarry(5),ref_Callouts.HexRef_ends));
1528                        BitBlock ref_error1;
1529                        ref_error1 = simd_andc(ref_Callouts.DecRef_starts,lex.Digit);
1530                        BitBlock ref_error2;
1531                        ref_error2 = simd_andc(ref_Callouts.HexRef_starts,lex.Hex);
1532                        BitBlock ref_ends;
1533                        ref_ends = simd_or(simd_or(ref_Callouts.GenRef_ends,ref_Callouts.DecRef_ends),ref_Callouts.HexRef_ends);
1534                        BitBlock ref_error3;
1535                        ref_error3 = simd_andc(ref_ends,lex.Semicolon);
1536                        if (bitblock::any(simd_or(simd_or(ref_error1,ref_error2),ref_error3)))
1537                        {
1538                                assert_0_error(simd_or(simd_or(ref_error1,ref_error2),ref_error3),"Reference error found");
1539                        }
1540                }
1541                else
1542                {
1543                        carry_set_0.carryDequeueEnqueue(0,6);
1544                }
1545                carry_set_0.carryAdjust(6);
1546        }
1547       
1548        void do_final_block(struct Lex & lex,struct Marker & marker,struct Ref_Callouts & ref_Callouts,BitBlock & EOF_mask)
1549        {
1550                ref_Callouts.GenRef_starts = simd<1>::constant<0>();
1551                ref_Callouts.GenRef_ends = simd<1>::constant<0>();
1552                ref_Callouts.DecRef_starts = simd<1>::constant<0>();
1553                ref_Callouts.DecRef_ends = simd<1>::constant<0>();
1554                ref_Callouts.HexRef_starts = simd<1>::constant<0>();
1555                ref_Callouts.HexRef_ends = simd<1>::constant<0>();
1556                BitBlock ref_error;
1557                ref_error = simd<1>::constant<0>();
1558                if (bitblock::any(simd_or(marker.Ref_opener,carry_set_0.carryRange(0,6))))
1559                {
1560                        BitBlock Ref_scope;
1561                        carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(marker.Ref_opener,carry_set_0.getCarry(0),Ref_scope));
1562                        BitBlock NumRef2;
1563                        NumRef2 = simd_and(Ref_scope,lex.Hash);
1564                        ref_Callouts.GenRef_starts = simd_andc(Ref_scope,lex.Hash);
1565                        BitBlock NumRef3;
1566                        carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(NumRef2,carry_set_0.getCarry(1),NumRef3));
1567                        BitBlock HexRef3;
1568                        HexRef3 = simd_and(NumRef3,lex.x);
1569                        ref_Callouts.DecRef_starts = simd_andc(NumRef3,lex.x);
1570                        carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_Advance(HexRef3,carry_set_0.getCarry(2),ref_Callouts.HexRef_starts));
1571                        carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_ScanThru(ref_Callouts.GenRef_starts,lex.NameScan,carry_set_0.getCarry(3),ref_Callouts.GenRef_ends));
1572                        carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_ScanThru(ref_Callouts.DecRef_starts,lex.Digit,carry_set_0.getCarry(4),ref_Callouts.DecRef_ends));
1573                        carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_ScanThru(ref_Callouts.HexRef_starts,lex.Hex,carry_set_0.getCarry(5),ref_Callouts.HexRef_ends));
1574                        BitBlock ref_error1;
1575                        ref_error1 = simd_andc(ref_Callouts.DecRef_starts,lex.Digit);
1576                        BitBlock ref_error2;
1577                        ref_error2 = simd_andc(ref_Callouts.HexRef_starts,lex.Hex);
1578                        BitBlock ref_ends;
1579                        ref_ends = simd_or(simd_or(ref_Callouts.GenRef_ends,ref_Callouts.DecRef_ends),ref_Callouts.HexRef_ends);
1580                        BitBlock ref_error3;
1581                        ref_error3 = simd_andc(ref_ends,lex.Semicolon);
1582                        if (bitblock::any(simd_or(simd_or(ref_error1,ref_error2),ref_error3)))
1583                        {
1584                                assert_0_error(simd_or(simd_or(ref_error1,ref_error2),ref_error3),"Reference error found");
1585                        }
1586                }
1587                else
1588                {
1589                        carry_set_0.carryDequeueEnqueue(0,6);
1590                }
1591        }
1592       
1593        CarryDeclare(carry_set_0,6,0);
1594};
1595 
1596struct Validate_xml_names
1597{
1598        Validate_xml_names()
1599        {
1600        }
1601       
1602        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)
1603        {
1604                BitBlock PI_names;
1605                carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_SpanUpTo(ctCDPI_Callouts.PI_name_starts,ctCDPI_Callouts.PI_name_ends,carry_set_0.getCarry(0),PI_names));
1606                BitBlock GenRefs;
1607                carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_SpanUpTo(ref_Callouts.GenRef_starts,ref_Callouts.GenRef_ends,carry_set_0.getCarry(1),GenRefs));
1608                BitBlock ElemNames;
1609                carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_SpanUpTo(tag_Callouts.ElemName_starts,tag_Callouts.ElemName_ends,carry_set_0.getCarry(2),ElemNames));
1610                BitBlock AttNames;
1611                carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_SpanUpTo(tag_Callouts.AttName_starts,tag_Callouts.AttName_ends,carry_set_0.getCarry(3),AttNames));
1612                BitBlock qname_stream;
1613                qname_stream = simd_or(ElemNames,AttNames);
1614                BitBlock ncname_stream;
1615                ncname_stream = simd_or(PI_names,GenRefs);
1616                BitBlock name_stream;
1617                name_stream = simd_or(qname_stream,ncname_stream);
1618                BitBlock name_start;
1619                BitBlock _temp0;
1620                carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_Advance(name_stream,carry_set_0.getCarry(4),_temp0));
1621                name_start = simd_andc(name_stream,_temp0);
1622                BitBlock name_cursor;
1623                BitBlock _temp1;
1624                carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_Advance(name_stream,carry_set_0.getCarry(5),_temp1));
1625                name_cursor = simd_andc(name_stream,_temp1);
1626                BitBlock void_prefix_err;
1627                void_prefix_err = simd_and(name_cursor,lex.Colon);
1628                BitBlock namespace_sep;
1629                BitBlock _temp2;
1630                carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_ScanThru(name_cursor,simd_andc(lex.NameScan,lex.Colon),carry_set_0.getCarry(6),_temp2));
1631                namespace_sep = simd_and(_temp2,lex.Colon);
1632                BitBlock local_part_start;
1633                carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(namespace_sep,carry_set_0.getCarry(7),local_part_start));
1634                BitBlock local_part_err;
1635                local_part_err = simd_andc(local_part_start,lex.NameScan);
1636                BitBlock colon2_err;
1637                BitBlock _temp3;
1638                carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_ScanThru(local_part_start,simd_andc(lex.NameScan,lex.Colon),carry_set_0.getCarry(8),_temp3));
1639                colon2_err = simd_and(_temp3,lex.Colon);
1640                BitBlock ncname_err;
1641                ncname_err = simd_and(ncname_stream,lex.Colon);
1642                if (bitblock::any(simd_or(simd_or(simd_or(void_prefix_err,local_part_err),colon2_err),ncname_err)))
1643                {
1644                        assert_0_error(simd_or(simd_or(simd_or(void_prefix_err,local_part_err),colon2_err),ncname_err),"name syntax error");
1645                }
1646                check_streams.non_ascii_name_starts = simd_andc(name_start,lex.ASCII_name_start);
1647                check_streams.non_ascii_names = simd_andc(simd_andc(simd_andc(name_stream,name_start),lex.ASCII_name_char),u8.suffix);
1648                carry_set_0.carryAdjust(9);
1649        }
1650       
1651        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)
1652        {
1653                BitBlock PI_names;
1654                carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_SpanUpTo(ctCDPI_Callouts.PI_name_starts,ctCDPI_Callouts.PI_name_ends,carry_set_0.getCarry(0),PI_names));
1655                BitBlock GenRefs;
1656                carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_SpanUpTo(ref_Callouts.GenRef_starts,ref_Callouts.GenRef_ends,carry_set_0.getCarry(1),GenRefs));
1657                BitBlock ElemNames;
1658                carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_SpanUpTo(tag_Callouts.ElemName_starts,tag_Callouts.ElemName_ends,carry_set_0.getCarry(2),ElemNames));
1659                BitBlock AttNames;
1660                carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_SpanUpTo(tag_Callouts.AttName_starts,tag_Callouts.AttName_ends,carry_set_0.getCarry(3),AttNames));
1661                BitBlock qname_stream;
1662                qname_stream = simd_or(ElemNames,AttNames);
1663                BitBlock ncname_stream;
1664                ncname_stream = simd_or(PI_names,GenRefs);
1665                BitBlock name_stream;
1666                name_stream = simd_or(qname_stream,ncname_stream);
1667                BitBlock name_start;
1668                BitBlock _temp0;
1669                carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_Advance(name_stream,carry_set_0.getCarry(4),_temp0));
1670                name_start = simd_andc(name_stream,_temp0);
1671                BitBlock name_cursor;
1672                BitBlock _temp1;
1673                carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_Advance(name_stream,carry_set_0.getCarry(5),_temp1));
1674                name_cursor = simd_andc(name_stream,_temp1);
1675                BitBlock void_prefix_err;
1676                void_prefix_err = simd_and(name_cursor,lex.Colon);
1677                BitBlock namespace_sep;
1678                BitBlock _temp2;
1679                carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_ScanThru(name_cursor,simd_andc(lex.NameScan,lex.Colon),carry_set_0.getCarry(6),_temp2));
1680                namespace_sep = simd_and(_temp2,lex.Colon);
1681                BitBlock local_part_start;
1682                carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(namespace_sep,carry_set_0.getCarry(7),local_part_start));
1683                BitBlock local_part_err;
1684                local_part_err = simd_andc(local_part_start,lex.NameScan);
1685                BitBlock colon2_err;
1686                BitBlock _temp3;
1687                carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_ScanThru(local_part_start,simd_andc(lex.NameScan,lex.Colon),carry_set_0.getCarry(8),_temp3));
1688                colon2_err = simd_and(_temp3,lex.Colon);
1689                BitBlock ncname_err;
1690                ncname_err = simd_and(ncname_stream,lex.Colon);
1691                if (bitblock::any(simd_or(simd_or(simd_or(void_prefix_err,local_part_err),colon2_err),ncname_err)))
1692                {
1693                        assert_0_error(simd_or(simd_or(simd_or(void_prefix_err,local_part_err),colon2_err),ncname_err),"name syntax error");
1694                }
1695                check_streams.non_ascii_name_starts = simd_andc(name_start,lex.ASCII_name_start);
1696                check_streams.non_ascii_names = simd_andc(simd_andc(simd_andc(name_stream,name_start),lex.ASCII_name_char),u8.suffix);
1697        }
1698       
1699        CarryDeclare(carry_set_0,9,0);
1700};
1701 
1702struct Do_check_streams
1703{
1704        Do_check_streams()
1705        {
1706        }
1707       
1708        IDISA_INLINE void do_block(struct Marker & marker,struct Tag_Callouts & tag_Callouts,struct Check_streams & check_streams)
1709        {
1710                if (bitblock::any(simd_andc(marker.CD_closer,tag_Callouts.AttVal_spans)))
1711                {
1712                        assert_0_error(simd_andc(marker.CD_closer,tag_Callouts.AttVal_spans),"Error: ]]> in text");
1713                }
1714                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);
1715                check_streams.name_follows = simd_or(tag_Callouts.ElemName_ends,tag_Callouts.AttName_ends);
1716                check_streams.att_refs = simd_and(tag_Callouts.AttVal_spans,marker.Ref_opener);
1717        }
1718       
1719        void do_final_block(struct Marker & marker,struct Tag_Callouts & tag_Callouts,struct Check_streams & check_streams,BitBlock & EOF_mask)
1720        {
1721                if (bitblock::any(simd_andc(marker.CD_closer,tag_Callouts.AttVal_spans)))
1722                {
1723                        assert_0_error(simd_andc(marker.CD_closer,tag_Callouts.AttVal_spans),"Error: ]]> in text");
1724                }
1725                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);
1726                check_streams.name_follows = simd_or(tag_Callouts.ElemName_ends,tag_Callouts.AttName_ends);
1727                check_streams.att_refs = simd_and(tag_Callouts.AttVal_spans,marker.Ref_opener);
1728        }
1729       
1730        CarryDeclare(carry_set_0,0,0);
1731};
1732 
1733
1734// } // pablo namespace
1735
1736#endif // PABLO_DEFINITIONS_HPP
Note: See TracBrowser for help on using the repository browser.