source: proto/pabloj/trunk/output/cpplang/parabix2_pablo_definitions.hpp @ 3699

Last change on this file since 3699 was 3699, checked in by ksherdy, 5 years ago

Updated PabloJ to s2k.

File size: 72.9 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(1,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(1,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(1,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(1,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                carry_set_0.setCarry(carry_set_0.carryFlip(2),2);
735        }
736       
737        IDISA_INLINE void do_block(struct Lex & lex,struct Marker & marker,struct CtCDPI_Callouts & ctCDPI_Callouts,struct Check_streams & check_streams)
738        {
739                ctCDPI_Callouts.Ct_starts = simd<1>::constant<0>();
740                ctCDPI_Callouts.Ct_ends = simd<1>::constant<0>();
741                ctCDPI_Callouts.CD_starts = simd<1>::constant<0>();
742                ctCDPI_Callouts.CD_ends = simd<1>::constant<0>();
743                ctCDPI_Callouts.PI_starts = simd<1>::constant<0>();
744                ctCDPI_Callouts.PI_name_starts = simd<1>::constant<0>();
745                ctCDPI_Callouts.PI_name_ends = simd<1>::constant<0>();
746                ctCDPI_Callouts.PI_ends = simd<1>::constant<0>();
747                BitBlock CtCDPI_starts;
748                CtCDPI_starts = simd<1>::constant<0>();
749                BitBlock CtCDPI_ends;
750                CtCDPI_ends = simd<1>::constant<0>();
751                BitBlock ctCDPI_mask;
752                ctCDPI_mask = simd<1>::constant<0>();
753                BitBlock v;
754                v = simd_or(lex.LAngle,lex.Hyphen);
755                BitBlock w;
756                w = simd_or(lex.Hyphen,lex.QMark);
757                BitBlock v1;
758                carry_set_0.getPending64(0) = bitblock::srli<127>(pablo_blk_Advance_n_<1>(v,carry_set_0.getPending64(0),v1));
759                BitBlock w1;
760                carry_set_0.getPending64(1) = bitblock::srli<127>(pablo_blk_Advance_n_<1>(w,carry_set_0.getPending64(1),w1));
761                BitBlock LAngle_scope;
762                LAngle_scope = simd_andc(v1,w1);
763                BitBlock PI_opener;
764                PI_opener = simd_and(LAngle_scope,lex.QMark);
765                BitBlock CtCD_opener;
766                CtCD_opener = simd_and(LAngle_scope,lex.Exclam);
767                BitBlock CtCDPI_opener;
768                CtCDPI_opener = simd_or(PI_opener,CtCD_opener);
769                BitBlock CD_closer;
770                CD_closer = simd<1>::constant<0>();
771                BitBlock DoubleHyphen;
772                DoubleHyphen = simd_and(simd_and(v1,w1),lex.Hyphen);
773                if (bitblock::any(simd_or(lex.RBracket,carry_set_0.carryRange(0,2))))
774                {
775                        BitBlock DoubleRBracket;
776                        BitBlock _temp0;
777                        carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(lex.RBracket,carry_set_0.getCarry(0),_temp0));
778                        DoubleRBracket = simd_and(_temp0,lex.RBracket);
779                        BitBlock _temp1;
780                        carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(DoubleRBracket,carry_set_0.getCarry(1),_temp1));
781                        CD_closer = simd_and(_temp1,lex.RAngle);
782                }
783                else
784                {
785                        carry_set_0.carryDequeueEnqueue(0,2);
786                }
787                BitBlock PI_closer;
788                PI_closer = simd_and(simd_andc(w1,v1),lex.RAngle);
789                BitBlock CtCDPI_Cursor;
790                carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_ScanToFirst(CtCDPI_opener,carry_set_0.getCarry(2),CtCDPI_Cursor));
791                if (bitblock::any(simd_or(CtCDPI_Cursor,carry_set_0.carryRange(3,13))))
792                {
793                        CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
794                        BitBlock PI_Cursor;
795                        PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
796                        BitBlock CD_Ct_Cursor;
797                        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));
798                        BitBlock CD_Cursor;
799                        CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
800                        BitBlock Ct_Cursor;
801                        Ct_Cursor = simd_and(CD_Ct_Cursor,lex.Hyphen);
802                        if (bitblock::any(simd_or(PI_Cursor,carry_set_0.carryRange(4,4))))
803                        {
804                                ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts,PI_Cursor);
805                                carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_Advance(PI_Cursor,carry_set_0.getCarry(4),PI_Cursor));
806                                ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts,PI_Cursor);
807                                BitBlock PI_name_end;
808                                carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_ScanThru(PI_Cursor,lex.NameScan,carry_set_0.getCarry(5),PI_name_end));
809                                BitBlock PI_error;
810                                PI_error = simd_and(PI_Cursor,PI_name_end);
811                                BitBlock PI_noWS;
812                                PI_noWS = simd_andc(PI_name_end,lex.WS);
813                                BitBlock _temp2;
814                                carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_Advance(PI_noWS,carry_set_0.getCarry(6),_temp2));
815                                PI_error = simd_or(PI_error,simd_or(simd_andc(PI_noWS,lex.QMark),simd_andc(_temp2,PI_closer)));
816                                if (bitblock::any(PI_error))
817                                {
818                                        assert_0_error(PI_error,"Error in PI syntax");
819                                }
820                                ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends,PI_name_end);
821                                carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_ScanThru(PI_name_end,simd_not(PI_closer),carry_set_0.getCarry(7),PI_Cursor));
822                                ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends,PI_Cursor);
823                                CtCDPI_ends = simd_or(CtCDPI_ends,PI_Cursor);
824                        }
825                        else
826                        {
827                                carry_set_0.carryDequeueEnqueue(4,4);
828                        }
829                        if (bitblock::any(simd_or(CD_Cursor,carry_set_0.carryRange(8,1))))
830                        {
831                                ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts,CD_Cursor);
832                                carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_ScanThru(CD_Cursor,simd_not(CD_closer),carry_set_0.getCarry(8),CD_Cursor));
833                                ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends,CD_Cursor);
834                                CtCDPI_ends = simd_or(CtCDPI_ends,CD_Cursor);
835                        }
836                        else
837                        {
838                                carry_set_0.carryDequeueEnqueue(8,1);
839                        }
840                        if (bitblock::any(simd_or(Ct_Cursor,carry_set_0.carryRange(9,5))))
841                        {
842                                ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts,Ct_Cursor);
843                                carry_set_0.getCarry(9) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_0.getCarry(9),Ct_Cursor));
844                                BitBlock Ct_error;
845                                Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
846                                BitBlock _temp3;
847                                carry_set_0.getCarry(10) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_0.getCarry(10),_temp3));
848                                carry_set_0.getCarry(11) = bitblock::srli<127>(pablo_blk_Advance(_temp3,carry_set_0.getCarry(11),Ct_Cursor));
849                                BitBlock _temp4;
850                                carry_set_0.getCarry(12) = bitblock::srli<127>(pablo_blk_ScanThru(Ct_Cursor,simd_not(DoubleHyphen),carry_set_0.getCarry(12),_temp4));
851                                carry_set_0.getCarry(13) = bitblock::srli<127>(pablo_blk_Advance(_temp4,carry_set_0.getCarry(13),Ct_Cursor));
852                                if (bitblock::any(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle))))
853                                {
854                                        assert_0_error(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle)),"Error in comment syntax");
855                                }
856                                ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends,Ct_Cursor);
857                                CtCDPI_ends = simd_or(CtCDPI_ends,Ct_Cursor);
858                        }
859                        else
860                        {
861                                carry_set_0.carryDequeueEnqueue(9,5);
862                        }
863                        CtCDPI_Cursor = simd_or(simd_or(PI_Cursor,CD_Cursor),Ct_Cursor);
864                        carry_set_0.getCarry(14) = bitblock::srli<127>(pablo_blk_InclusiveSpan(CtCDPI_starts,CtCDPI_ends,carry_set_0.getCarry(14),ctCDPI_mask));
865                        if (bitblock::any(simd<1>::constant<0>()))
866                        {
867                                assert_0_error(simd<1>::constant<0>(),"Error in comment, CDATA or processing instruction syntax");
868                        }
869                        carry_set_0.getCarry(15) = bitblock::srli<127>(pablo_blk_ScanThru(CtCDPI_Cursor,simd_not(CtCDPI_opener),carry_set_0.getCarry(15),CtCDPI_Cursor));
870                        while (bitblock::any(CtCDPI_Cursor))
871                        {
872                                CarryDeclare(carry_set_1,13,0);
873                                CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
874                                BitBlock PI_Cursor;
875                                PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
876                                BitBlock CD_Ct_Cursor;
877                                carry_set_1.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(simd_andc(CtCDPI_Cursor,PI_Cursor),carry_set_1.getCarry(0),CD_Ct_Cursor));
878                                BitBlock CD_Cursor;
879                                CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
880                                BitBlock Ct_Cursor;
881                                Ct_Cursor = simd_and(CD_Ct_Cursor,lex.Hyphen);
882                                if (bitblock::any(PI_Cursor))
883                                {
884                                        ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts,PI_Cursor);
885                                        carry_set_1.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(PI_Cursor,carry_set_1.getCarry(1),PI_Cursor));
886                                        ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts,PI_Cursor);
887                                        BitBlock PI_name_end;
888                                        carry_set_1.getCarry(2) = bitblock::srli<127>(pablo_blk_ScanThru(PI_Cursor,lex.NameScan,carry_set_1.getCarry(2),PI_name_end));
889                                        BitBlock PI_error;
890                                        PI_error = simd_and(PI_Cursor,PI_name_end);
891                                        BitBlock PI_noWS;
892                                        PI_noWS = simd_andc(PI_name_end,lex.WS);
893                                        BitBlock _temp2;
894                                        carry_set_1.getCarry(3) = bitblock::srli<127>(pablo_blk_Advance(PI_noWS,carry_set_1.getCarry(3),_temp2));
895                                        PI_error = simd_or(PI_error,simd_or(simd_andc(PI_noWS,lex.QMark),simd_andc(_temp2,PI_closer)));
896                                        if (bitblock::any(PI_error))
897                                        {
898                                                assert_0_error(PI_error,"Error in PI syntax");
899                                        }
900                                        ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends,PI_name_end);
901                                        carry_set_1.getCarry(4) = bitblock::srli<127>(pablo_blk_ScanThru(PI_name_end,simd_not(PI_closer),carry_set_1.getCarry(4),PI_Cursor));
902                                        ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends,PI_Cursor);
903                                        CtCDPI_ends = simd_or(CtCDPI_ends,PI_Cursor);
904                                }
905                                if (bitblock::any(CD_Cursor))
906                                {
907                                        ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts,CD_Cursor);
908                                        carry_set_1.getCarry(5) = bitblock::srli<127>(pablo_blk_ScanThru(CD_Cursor,simd_not(CD_closer),carry_set_1.getCarry(5),CD_Cursor));
909                                        ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends,CD_Cursor);
910                                        CtCDPI_ends = simd_or(CtCDPI_ends,CD_Cursor);
911                                }
912                                if (bitblock::any(Ct_Cursor))
913                                {
914                                        ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts,Ct_Cursor);
915                                        carry_set_1.getCarry(6) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_1.getCarry(6),Ct_Cursor));
916                                        BitBlock Ct_error;
917                                        Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
918                                        BitBlock _temp3;
919                                        carry_set_1.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_1.getCarry(7),_temp3));
920                                        carry_set_1.getCarry(8) = bitblock::srli<127>(pablo_blk_Advance(_temp3,carry_set_1.getCarry(8),Ct_Cursor));
921                                        BitBlock _temp4;
922                                        carry_set_1.getCarry(9) = bitblock::srli<127>(pablo_blk_ScanThru(Ct_Cursor,simd_not(DoubleHyphen),carry_set_1.getCarry(9),_temp4));
923                                        carry_set_1.getCarry(10) = bitblock::srli<127>(pablo_blk_Advance(_temp4,carry_set_1.getCarry(10),Ct_Cursor));
924                                        if (bitblock::any(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle))))
925                                        {
926                                                assert_0_error(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle)),"Error in comment syntax");
927                                        }
928                                        ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends,Ct_Cursor);
929                                        CtCDPI_ends = simd_or(CtCDPI_ends,Ct_Cursor);
930                                }
931                                CtCDPI_Cursor = simd_or(simd_or(PI_Cursor,CD_Cursor),Ct_Cursor);
932                                carry_set_1.getCarry(11) = bitblock::srli<127>(pablo_blk_InclusiveSpan(CtCDPI_starts,CtCDPI_ends,carry_set_1.getCarry(11),ctCDPI_mask));
933                                if (bitblock::any(simd<1>::constant<0>()))
934                                {
935                                        assert_0_error(simd<1>::constant<0>(),"Error in comment, CDATA or processing instruction syntax");
936                                }
937                                carry_set_1.getCarry(12) = bitblock::srli<127>(pablo_blk_ScanThru(CtCDPI_Cursor,simd_not(CtCDPI_opener),carry_set_1.getCarry(12),CtCDPI_Cursor));
938                                LocalCarryCombine(carry_set_0,carry_set_1,3,13);
939                        }
940                }
941                else
942                {
943                        carry_set_0.carryDequeueEnqueue(3,13);
944                }
945                BitBlock _temp5;
946                carry_set_0.getCarry(16) = 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(16),_temp5));
947                check_streams.misc_mask = simd_and(simd_or(simd_or(simd_or(lex.WS,lex.LAngle),_temp5),CtCDPI_starts),EOF_mask);
948                marker.LAngle_scope = simd_andc(LAngle_scope,ctCDPI_mask);
949                marker.Ref_opener = simd_andc(lex.RefStart,ctCDPI_mask);
950                marker.CD_closer = simd_andc(CD_closer,ctCDPI_mask);
951                carry_set_0.carryAdjust(17);
952        }
953       
954        void do_final_block(struct Lex & lex,struct Marker & marker,struct CtCDPI_Callouts & ctCDPI_Callouts,struct Check_streams & check_streams,BitBlock & EOF_mask)
955        {
956                ctCDPI_Callouts.Ct_starts = simd<1>::constant<0>();
957                ctCDPI_Callouts.Ct_ends = simd<1>::constant<0>();
958                ctCDPI_Callouts.CD_starts = simd<1>::constant<0>();
959                ctCDPI_Callouts.CD_ends = simd<1>::constant<0>();
960                ctCDPI_Callouts.PI_starts = simd<1>::constant<0>();
961                ctCDPI_Callouts.PI_name_starts = simd<1>::constant<0>();
962                ctCDPI_Callouts.PI_name_ends = simd<1>::constant<0>();
963                ctCDPI_Callouts.PI_ends = simd<1>::constant<0>();
964                BitBlock CtCDPI_starts;
965                CtCDPI_starts = simd<1>::constant<0>();
966                BitBlock CtCDPI_ends;
967                CtCDPI_ends = simd<1>::constant<0>();
968                BitBlock ctCDPI_mask;
969                ctCDPI_mask = simd<1>::constant<0>();
970                BitBlock v;
971                v = simd_or(lex.LAngle,lex.Hyphen);
972                BitBlock w;
973                w = simd_or(lex.Hyphen,lex.QMark);
974                BitBlock v1;
975                carry_set_0.getPending64(0) = bitblock::srli<127>(pablo_blk_Advance_n_<1>(v,carry_set_0.getPending64(0),v1));
976                BitBlock w1;
977                carry_set_0.getPending64(1) = bitblock::srli<127>(pablo_blk_Advance_n_<1>(w,carry_set_0.getPending64(1),w1));
978                BitBlock LAngle_scope;
979                LAngle_scope = simd_andc(v1,w1);
980                BitBlock PI_opener;
981                PI_opener = simd_and(LAngle_scope,lex.QMark);
982                BitBlock CtCD_opener;
983                CtCD_opener = simd_and(LAngle_scope,lex.Exclam);
984                BitBlock CtCDPI_opener;
985                CtCDPI_opener = simd_or(PI_opener,CtCD_opener);
986                BitBlock CD_closer;
987                CD_closer = simd<1>::constant<0>();
988                BitBlock DoubleHyphen;
989                DoubleHyphen = simd_and(simd_and(v1,w1),lex.Hyphen);
990                if (bitblock::any(simd_or(lex.RBracket,carry_set_0.carryRange(0,2))))
991                {
992                        BitBlock DoubleRBracket;
993                        BitBlock _temp0;
994                        carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(lex.RBracket,carry_set_0.getCarry(0),_temp0));
995                        DoubleRBracket = simd_and(_temp0,lex.RBracket);
996                        BitBlock _temp1;
997                        carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(DoubleRBracket,carry_set_0.getCarry(1),_temp1));
998                        CD_closer = simd_and(_temp1,lex.RAngle);
999                }
1000                else
1001                {
1002                        carry_set_0.carryDequeueEnqueue(0,2);
1003                }
1004                BitBlock PI_closer;
1005                PI_closer = simd_and(simd_andc(w1,v1),lex.RAngle);
1006                BitBlock CtCDPI_Cursor;
1007                carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_ScanToFirst(simd_or(CtCDPI_opener,simd_not(EOF_mask)),carry_set_0.getCarry(2),CtCDPI_Cursor));
1008                if (bitblock::any(simd_and(simd_or(CtCDPI_Cursor,carry_set_0.carryRange(3,13)),EOF_mask)))
1009                {
1010                        CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
1011                        BitBlock PI_Cursor;
1012                        PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
1013                        BitBlock CD_Ct_Cursor;
1014                        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));
1015                        BitBlock CD_Cursor;
1016                        CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
1017                        BitBlock Ct_Cursor;
1018                        Ct_Cursor = simd_and(CD_Ct_Cursor,lex.Hyphen);
1019                        if (bitblock::any(simd_or(PI_Cursor,carry_set_0.carryRange(4,4))))
1020                        {
1021                                ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts,PI_Cursor);
1022                                carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_Advance(PI_Cursor,carry_set_0.getCarry(4),PI_Cursor));
1023                                ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts,PI_Cursor);
1024                                BitBlock PI_name_end;
1025                                carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_ScanThru(PI_Cursor,lex.NameScan,carry_set_0.getCarry(5),PI_name_end));
1026                                BitBlock PI_error;
1027                                PI_error = simd_and(PI_Cursor,PI_name_end);
1028                                BitBlock PI_noWS;
1029                                PI_noWS = simd_andc(PI_name_end,lex.WS);
1030                                BitBlock _temp2;
1031                                carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_Advance(PI_noWS,carry_set_0.getCarry(6),_temp2));
1032                                PI_error = simd_or(PI_error,simd_or(simd_andc(PI_noWS,lex.QMark),simd_andc(_temp2,PI_closer)));
1033                                if (bitblock::any(PI_error))
1034                                {
1035                                        assert_0_error(PI_error,"Error in PI syntax");
1036                                }
1037                                ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends,PI_name_end);
1038                                carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_ScanThru(PI_name_end,simd_andc(EOF_mask,PI_closer),carry_set_0.getCarry(7),PI_Cursor));
1039                                ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends,PI_Cursor);
1040                                CtCDPI_ends = simd_or(CtCDPI_ends,PI_Cursor);
1041                        }
1042                        else
1043                        {
1044                                carry_set_0.carryDequeueEnqueue(4,4);
1045                        }
1046                        if (bitblock::any(simd_or(CD_Cursor,carry_set_0.carryRange(8,1))))
1047                        {
1048                                ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts,CD_Cursor);
1049                                carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_ScanThru(CD_Cursor,simd_andc(EOF_mask,CD_closer),carry_set_0.getCarry(8),CD_Cursor));
1050                                ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends,CD_Cursor);
1051                                CtCDPI_ends = simd_or(CtCDPI_ends,CD_Cursor);
1052                        }
1053                        else
1054                        {
1055                                carry_set_0.carryDequeueEnqueue(8,1);
1056                        }
1057                        if (bitblock::any(simd_or(Ct_Cursor,carry_set_0.carryRange(9,5))))
1058                        {
1059                                ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts,Ct_Cursor);
1060                                carry_set_0.getCarry(9) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_0.getCarry(9),Ct_Cursor));
1061                                BitBlock Ct_error;
1062                                Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
1063                                BitBlock _temp3;
1064                                carry_set_0.getCarry(10) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_0.getCarry(10),_temp3));
1065                                carry_set_0.getCarry(11) = bitblock::srli<127>(pablo_blk_Advance(_temp3,carry_set_0.getCarry(11),Ct_Cursor));
1066                                BitBlock _temp4;
1067                                carry_set_0.getCarry(12) = bitblock::srli<127>(pablo_blk_ScanThru(Ct_Cursor,simd_andc(EOF_mask,DoubleHyphen),carry_set_0.getCarry(12),_temp4));
1068                                carry_set_0.getCarry(13) = bitblock::srli<127>(pablo_blk_Advance(_temp4,carry_set_0.getCarry(13),Ct_Cursor));
1069                                if (bitblock::any(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle))))
1070                                {
1071                                        assert_0_error(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle)),"Error in comment syntax");
1072                                }
1073                                ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends,Ct_Cursor);
1074                                CtCDPI_ends = simd_or(CtCDPI_ends,Ct_Cursor);
1075                        }
1076                        else
1077                        {
1078                                carry_set_0.carryDequeueEnqueue(9,5);
1079                        }
1080                        CtCDPI_Cursor = simd_or(simd_or(PI_Cursor,CD_Cursor),Ct_Cursor);
1081                        carry_set_0.getCarry(14) = bitblock::srli<127>(pablo_blk_InclusiveSpan(CtCDPI_starts,CtCDPI_ends,carry_set_0.getCarry(14),ctCDPI_mask));
1082                        if (bitblock::any(simd_andc(ctCDPI_mask,EOF_mask)))
1083                        {
1084                                assert_0_error(simd_andc(ctCDPI_mask,EOF_mask),"Error in comment, CDATA or processing instruction syntax");
1085                        }
1086                        carry_set_0.getCarry(15) = bitblock::srli<127>(pablo_blk_ScanThru(CtCDPI_Cursor,simd_andc(EOF_mask,CtCDPI_opener),carry_set_0.getCarry(15),CtCDPI_Cursor));
1087                        while (bitblock::any(simd_and(CtCDPI_Cursor,EOF_mask)))
1088                        {
1089                                CarryDeclare(carry_set_1,13,0);
1090                                CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
1091                                BitBlock PI_Cursor;
1092                                PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
1093                                BitBlock CD_Ct_Cursor;
1094                                carry_set_1.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(simd_andc(CtCDPI_Cursor,PI_Cursor),carry_set_1.getCarry(0),CD_Ct_Cursor));
1095                                BitBlock CD_Cursor;
1096                                CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
1097                                BitBlock Ct_Cursor;
1098                                Ct_Cursor = simd_and(CD_Ct_Cursor,lex.Hyphen);
1099                                if (bitblock::any(PI_Cursor))
1100                                {
1101                                        ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts,PI_Cursor);
1102                                        carry_set_1.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(PI_Cursor,carry_set_1.getCarry(1),PI_Cursor));
1103                                        ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts,PI_Cursor);
1104                                        BitBlock PI_name_end;
1105                                        carry_set_1.getCarry(2) = bitblock::srli<127>(pablo_blk_ScanThru(PI_Cursor,lex.NameScan,carry_set_1.getCarry(2),PI_name_end));
1106                                        BitBlock PI_error;
1107                                        PI_error = simd_and(PI_Cursor,PI_name_end);
1108                                        BitBlock PI_noWS;
1109                                        PI_noWS = simd_andc(PI_name_end,lex.WS);
1110                                        BitBlock _temp2;
1111                                        carry_set_1.getCarry(3) = bitblock::srli<127>(pablo_blk_Advance(PI_noWS,carry_set_1.getCarry(3),_temp2));
1112                                        PI_error = simd_or(PI_error,simd_or(simd_andc(PI_noWS,lex.QMark),simd_andc(_temp2,PI_closer)));
1113                                        if (bitblock::any(PI_error))
1114                                        {
1115                                                assert_0_error(PI_error,"Error in PI syntax");
1116                                        }
1117                                        ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends,PI_name_end);
1118                                        carry_set_1.getCarry(4) = bitblock::srli<127>(pablo_blk_ScanThru(PI_name_end,simd_andc(EOF_mask,PI_closer),carry_set_1.getCarry(4),PI_Cursor));
1119                                        ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends,PI_Cursor);
1120                                        CtCDPI_ends = simd_or(CtCDPI_ends,PI_Cursor);
1121                                }
1122                                if (bitblock::any(CD_Cursor))
1123                                {
1124                                        ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts,CD_Cursor);
1125                                        carry_set_1.getCarry(5) = bitblock::srli<127>(pablo_blk_ScanThru(CD_Cursor,simd_andc(EOF_mask,CD_closer),carry_set_1.getCarry(5),CD_Cursor));
1126                                        ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends,CD_Cursor);
1127                                        CtCDPI_ends = simd_or(CtCDPI_ends,CD_Cursor);
1128                                }
1129                                if (bitblock::any(Ct_Cursor))
1130                                {
1131                                        ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts,Ct_Cursor);
1132                                        carry_set_1.getCarry(6) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_1.getCarry(6),Ct_Cursor));
1133                                        BitBlock Ct_error;
1134                                        Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
1135                                        BitBlock _temp3;
1136                                        carry_set_1.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_1.getCarry(7),_temp3));
1137                                        carry_set_1.getCarry(8) = bitblock::srli<127>(pablo_blk_Advance(_temp3,carry_set_1.getCarry(8),Ct_Cursor));
1138                                        BitBlock _temp4;
1139                                        carry_set_1.getCarry(9) = bitblock::srli<127>(pablo_blk_ScanThru(Ct_Cursor,simd_andc(EOF_mask,DoubleHyphen),carry_set_1.getCarry(9),_temp4));
1140                                        carry_set_1.getCarry(10) = bitblock::srli<127>(pablo_blk_Advance(_temp4,carry_set_1.getCarry(10),Ct_Cursor));
1141                                        if (bitblock::any(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle))))
1142                                        {
1143                                                assert_0_error(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle)),"Error in comment syntax");
1144                                        }
1145                                        ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends,Ct_Cursor);
1146                                        CtCDPI_ends = simd_or(CtCDPI_ends,Ct_Cursor);
1147                                }
1148                                CtCDPI_Cursor = simd_or(simd_or(PI_Cursor,CD_Cursor),Ct_Cursor);
1149                                carry_set_1.getCarry(11) = bitblock::srli<127>(pablo_blk_InclusiveSpan(CtCDPI_starts,CtCDPI_ends,carry_set_1.getCarry(11),ctCDPI_mask));
1150                                if (bitblock::any(simd_andc(ctCDPI_mask,EOF_mask)))
1151                                {
1152                                        assert_0_error(simd_andc(ctCDPI_mask,EOF_mask),"Error in comment, CDATA or processing instruction syntax");
1153                                }
1154                                carry_set_1.getCarry(12) = bitblock::srli<127>(pablo_blk_ScanThru(CtCDPI_Cursor,simd_andc(EOF_mask,CtCDPI_opener),carry_set_1.getCarry(12),CtCDPI_Cursor));
1155                                LocalCarryCombine(carry_set_0,carry_set_1,3,13);
1156                        }
1157                }
1158                else
1159                {
1160                        carry_set_0.carryDequeueEnqueue(3,13);
1161                }
1162                BitBlock _temp5;
1163                carry_set_0.getCarry(16) = 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(16),_temp5));
1164                check_streams.misc_mask = simd_and(simd_or(simd_or(simd_or(lex.WS,lex.LAngle),_temp5),CtCDPI_starts),EOF_mask);
1165                marker.LAngle_scope = simd_andc(LAngle_scope,ctCDPI_mask);
1166                marker.Ref_opener = simd_andc(lex.RefStart,ctCDPI_mask);
1167                marker.CD_closer = simd_andc(CD_closer,ctCDPI_mask);
1168        }
1169       
1170        CarryDeclare(carry_set_0,17,2);
1171};
1172 
1173struct Parse_tags
1174{
1175        Parse_tags()
1176        {
1177        }
1178       
1179        IDISA_INLINE void do_block(struct Lex & lex,struct Marker & marker,struct Tag_Callouts & tag_Callouts)
1180        {
1181                BitBlock EqExpected;
1182                EqExpected = simd<1>::constant<0>();
1183                BitBlock AttListEnd;
1184                AttListEnd = simd<1>::constant<0>();
1185                BitBlock DQuoteDelim;
1186                DQuoteDelim = simd_or(lex.DQuote,lex.LAngle);
1187                BitBlock SQuoteDelim;
1188                SQuoteDelim = simd_or(lex.SQuote,lex.LAngle);
1189                BitBlock AttListDelim;
1190                AttListDelim = simd_or(lex.Slash,lex.RAngle);
1191                tag_Callouts.ElemName_starts = simd_andc(marker.LAngle_scope,lex.Slash);
1192                tag_Callouts.EndTag_marks = simd_and(marker.LAngle_scope,lex.Slash);
1193                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));
1194                BitBlock ParseError;
1195                ParseError = simd_and(tag_Callouts.ElemName_starts,tag_Callouts.ElemName_ends);
1196                tag_Callouts.AttName_starts = simd<1>::constant<0>();
1197                tag_Callouts.AttName_ends = simd<1>::constant<0>();
1198                tag_Callouts.AttVal_starts = simd<1>::constant<0>();
1199                tag_Callouts.AttVal_ends = simd<1>::constant<0>();
1200                if (bitblock::any(simd_or(simd_and(tag_Callouts.ElemName_ends,lex.WS),carry_set_0.carryRange(1,8))))
1201                {
1202                        BitBlock AfterWS;
1203                        carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_ScanThru(tag_Callouts.ElemName_ends,lex.WS,carry_set_0.getCarry(1),AfterWS));
1204                        AttListEnd = simd_and(AfterWS,AttListDelim);
1205                        BitBlock AttNameStart;
1206                        AttNameStart = simd_andc(AfterWS,AttListDelim);
1207                        if (bitblock::any(simd_or(AttNameStart,carry_set_0.carryRange(2,7))))
1208                        {
1209                                ParseError = simd_or(ParseError,simd_andc(AttNameStart,lex.NameScan));
1210                                tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts,AttNameStart);
1211                                BitBlock AttNameFollow;
1212                                carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameStart,lex.NameScan,carry_set_0.getCarry(2),AttNameFollow));
1213                                tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends,AttNameFollow);
1214                                if (bitblock::any(simd_or(simd_and(AttNameFollow,lex.WS),carry_set_0.carryRange(3,1))))
1215                                {
1216                                        carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameFollow,lex.WS,carry_set_0.getCarry(3),EqExpected));
1217                                }
1218                                else
1219                                {
1220                                        EqExpected = AttNameFollow;
1221                                        carry_set_0.carryDequeueEnqueue(3,1);
1222                                }
1223                                ParseError = simd_or(ParseError,simd_andc(EqExpected,lex.Equals));
1224                                BitBlock AttValPos;
1225                                carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(EqExpected,lex.WS,carry_set_0.getCarry(4),AttValPos));
1226                                tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts,AttValPos);
1227                                BitBlock DQuoteAttVal;
1228                                DQuoteAttVal = simd_and(AttValPos,lex.DQuote);
1229                                BitBlock SQuoteAttVal;
1230                                SQuoteAttVal = simd_and(AttValPos,lex.SQuote);
1231                                BitBlock DQuoteAttEnd;
1232                                carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(DQuoteAttVal,simd_not(DQuoteDelim),carry_set_0.getCarry(5),DQuoteAttEnd));
1233                                BitBlock SQuoteAttEnd;
1234                                carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(SQuoteAttVal,simd_not(SQuoteDelim),carry_set_0.getCarry(6),SQuoteAttEnd));
1235                                BitBlock AttValEnd;
1236                                AttValEnd = simd_or(DQuoteAttEnd,SQuoteAttEnd);
1237                                ParseError = simd_or(ParseError,simd_andc(simd_or(AttValPos,AttValEnd),simd_or(lex.DQuote,lex.SQuote)));
1238                                BitBlock AttValFollow;
1239                                carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(AttValEnd,carry_set_0.getCarry(7),AttValFollow));
1240                                tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends,AttValFollow);
1241                                if (bitblock::any(simd_or(simd_and(AttValFollow,lex.WS),carry_set_0.carryRange(8,1))))
1242                                {
1243                                        carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_ScanThru(AttValFollow,lex.WS,carry_set_0.getCarry(8),AfterWS));
1244                                        AttListEnd = simd_or(AttListEnd,simd_and(AfterWS,AttListDelim));
1245                                        AttNameStart = simd_andc(AfterWS,AttListDelim);
1246                                }
1247                                else
1248                                {
1249                                        AttListEnd = simd_or(AttListEnd,simd_and(AttValFollow,AttListDelim));
1250                                        AttNameStart = simd_andc(AttValFollow,AttListDelim);
1251                                        carry_set_0.carryDequeueEnqueue(8,1);
1252                                }
1253                                ParseError = simd_or(ParseError,simd_and(AttValFollow,AttNameStart));
1254                                while (bitblock::any(AttNameStart))
1255                                {
1256                                        CarryDeclare(carry_set_1,7,0);
1257                                        ParseError = simd_or(ParseError,simd_andc(AttNameStart,lex.NameScan));
1258                                        tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts,AttNameStart);
1259                                        BitBlock AttNameFollow;
1260                                        carry_set_1.getCarry(0) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameStart,lex.NameScan,carry_set_1.getCarry(0),AttNameFollow));
1261                                        tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends,AttNameFollow);
1262                                        if (bitblock::any(simd_and(AttNameFollow,lex.WS)))
1263                                        {
1264                                                carry_set_1.getCarry(1) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameFollow,lex.WS,carry_set_1.getCarry(1),EqExpected));
1265                                        }
1266                                        else
1267                                        {
1268                                                EqExpected = AttNameFollow;
1269                                        }
1270                                        ParseError = simd_or(ParseError,simd_andc(EqExpected,lex.Equals));
1271                                        BitBlock AttValPos;
1272                                        carry_set_1.getCarry(2) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(EqExpected,lex.WS,carry_set_1.getCarry(2),AttValPos));
1273                                        tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts,AttValPos);
1274                                        BitBlock DQuoteAttVal;
1275                                        DQuoteAttVal = simd_and(AttValPos,lex.DQuote);
1276                                        BitBlock SQuoteAttVal;
1277                                        SQuoteAttVal = simd_and(AttValPos,lex.SQuote);
1278                                        BitBlock DQuoteAttEnd;
1279                                        carry_set_1.getCarry(3) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(DQuoteAttVal,simd_not(DQuoteDelim),carry_set_1.getCarry(3),DQuoteAttEnd));
1280                                        BitBlock SQuoteAttEnd;
1281                                        carry_set_1.getCarry(4) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(SQuoteAttVal,simd_not(SQuoteDelim),carry_set_1.getCarry(4),SQuoteAttEnd));
1282                                        BitBlock AttValEnd;
1283                                        AttValEnd = simd_or(DQuoteAttEnd,SQuoteAttEnd);
1284                                        ParseError = simd_or(ParseError,simd_andc(simd_or(AttValPos,AttValEnd),simd_or(lex.DQuote,lex.SQuote)));
1285                                        BitBlock AttValFollow;
1286                                        carry_set_1.getCarry(5) = bitblock::srli<127>(pablo_blk_Advance(AttValEnd,carry_set_1.getCarry(5),AttValFollow));
1287                                        tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends,AttValFollow);
1288                                        if (bitblock::any(simd_and(AttValFollow,lex.WS)))
1289                                        {
1290                                                carry_set_1.getCarry(6) = bitblock::srli<127>(pablo_blk_ScanThru(AttValFollow,lex.WS,carry_set_1.getCarry(6),AfterWS));
1291                                                AttListEnd = simd_or(AttListEnd,simd_and(AfterWS,AttListDelim));
1292                                                AttNameStart = simd_andc(AfterWS,AttListDelim);
1293                                        }
1294                                        else
1295                                        {
1296                                                AttListEnd = simd_or(AttListEnd,simd_and(AttValFollow,AttListDelim));
1297                                                AttNameStart = simd_andc(AttValFollow,AttListDelim);
1298                                        }
1299                                        ParseError = simd_or(ParseError,simd_and(AttValFollow,AttNameStart));
1300                                        LocalCarryCombine(carry_set_0,carry_set_1,2,7);
1301                                }
1302                        }
1303                        else
1304                        {
1305                                carry_set_0.carryDequeueEnqueue(2,7);
1306                        }
1307                }
1308                else
1309                {
1310                        AttListEnd = simd_and(tag_Callouts.ElemName_ends,AttListDelim);
1311                        ParseError = simd_or(ParseError,simd_andc(tag_Callouts.ElemName_ends,AttListDelim));
1312                        carry_set_0.carryDequeueEnqueue(1,8);
1313                }
1314                BitBlock STagEnds;
1315                STagEnds = simd_and(AttListEnd,lex.RAngle);
1316                carry_set_0.getCarry(9) = bitblock::srli<127>(pablo_blk_Advance(simd_and(AttListEnd,lex.Slash),carry_set_0.getCarry(9),tag_Callouts.EmptyTag_marks));
1317                ParseError = simd_or(ParseError,simd_andc(tag_Callouts.EmptyTag_marks,lex.RAngle));
1318                BitBlock EndTagEnds;
1319                carry_set_0.getCarry(10) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(tag_Callouts.EndTag_marks,lex.NameScan,carry_set_0.getCarry(10),EndTagEnds));
1320                if (bitblock::any(simd_or(simd_and(EndTagEnds,lex.WS),carry_set_0.carryRange(11,1))))
1321                {
1322                        carry_set_0.getCarry(11) = bitblock::srli<127>(pablo_blk_ScanThru(EndTagEnds,lex.WS,carry_set_0.getCarry(11),EndTagEnds));
1323                }
1324                else
1325                {
1326                        carry_set_0.carryDequeueEnqueue(11,1);
1327                }
1328                ParseError = simd_or(ParseError,simd_andc(EndTagEnds,lex.RAngle));
1329                if (bitblock::any(ParseError))
1330                {
1331                        assert_0_error(ParseError,"Tag parsing error found");
1332                }
1333                carry_set_0.getCarry(12) = bitblock::srli<127>(pablo_blk_SpanUpTo(tag_Callouts.AttVal_starts,tag_Callouts.AttVal_ends,carry_set_0.getCarry(12),tag_Callouts.AttVal_spans));
1334                carry_set_0.carryAdjust(13);
1335        }
1336       
1337        void do_final_block(struct Lex & lex,struct Marker & marker,struct Tag_Callouts & tag_Callouts,BitBlock & EOF_mask)
1338        {
1339                BitBlock EqExpected;
1340                EqExpected = simd<1>::constant<0>();
1341                BitBlock AttListEnd;
1342                AttListEnd = simd<1>::constant<0>();
1343                BitBlock DQuoteDelim;
1344                DQuoteDelim = simd_or(lex.DQuote,lex.LAngle);
1345                BitBlock SQuoteDelim;
1346                SQuoteDelim = simd_or(lex.SQuote,lex.LAngle);
1347                BitBlock AttListDelim;
1348                AttListDelim = simd_or(lex.Slash,lex.RAngle);
1349                tag_Callouts.ElemName_starts = simd_andc(marker.LAngle_scope,lex.Slash);
1350                tag_Callouts.EndTag_marks = simd_and(marker.LAngle_scope,lex.Slash);
1351                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));
1352                BitBlock ParseError;
1353                ParseError = simd_and(tag_Callouts.ElemName_starts,tag_Callouts.ElemName_ends);
1354                tag_Callouts.AttName_starts = simd<1>::constant<0>();
1355                tag_Callouts.AttName_ends = simd<1>::constant<0>();
1356                tag_Callouts.AttVal_starts = simd<1>::constant<0>();
1357                tag_Callouts.AttVal_ends = simd<1>::constant<0>();
1358                if (bitblock::any(simd_or(simd_and(tag_Callouts.ElemName_ends,lex.WS),carry_set_0.carryRange(1,8))))
1359                {
1360                        BitBlock AfterWS;
1361                        carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_ScanThru(tag_Callouts.ElemName_ends,lex.WS,carry_set_0.getCarry(1),AfterWS));
1362                        AttListEnd = simd_and(AfterWS,AttListDelim);
1363                        BitBlock AttNameStart;
1364                        AttNameStart = simd_andc(AfterWS,AttListDelim);
1365                        if (bitblock::any(simd_and(simd_or(AttNameStart,carry_set_0.carryRange(2,7)),EOF_mask)))
1366                        {
1367                                ParseError = simd_or(ParseError,simd_andc(AttNameStart,lex.NameScan));
1368                                tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts,AttNameStart);
1369                                BitBlock AttNameFollow;
1370                                carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameStart,lex.NameScan,carry_set_0.getCarry(2),AttNameFollow));
1371                                tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends,AttNameFollow);
1372                                if (bitblock::any(simd_or(simd_and(AttNameFollow,lex.WS),carry_set_0.carryRange(3,1))))
1373                                {
1374                                        carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameFollow,lex.WS,carry_set_0.getCarry(3),EqExpected));
1375                                }
1376                                else
1377                                {
1378                                        EqExpected = AttNameFollow;
1379                                        carry_set_0.carryDequeueEnqueue(3,1);
1380                                }
1381                                ParseError = simd_or(ParseError,simd_andc(EqExpected,lex.Equals));
1382                                BitBlock AttValPos;
1383                                carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(EqExpected,lex.WS,carry_set_0.getCarry(4),AttValPos));
1384                                tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts,AttValPos);
1385                                BitBlock DQuoteAttVal;
1386                                DQuoteAttVal = simd_and(AttValPos,lex.DQuote);
1387                                BitBlock SQuoteAttVal;
1388                                SQuoteAttVal = simd_and(AttValPos,lex.SQuote);
1389                                BitBlock DQuoteAttEnd;
1390                                carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(DQuoteAttVal,simd_andc(EOF_mask,DQuoteDelim),carry_set_0.getCarry(5),DQuoteAttEnd));
1391                                BitBlock SQuoteAttEnd;
1392                                carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(SQuoteAttVal,simd_andc(EOF_mask,SQuoteDelim),carry_set_0.getCarry(6),SQuoteAttEnd));
1393                                BitBlock AttValEnd;
1394                                AttValEnd = simd_or(DQuoteAttEnd,SQuoteAttEnd);
1395                                ParseError = simd_or(ParseError,simd_andc(simd_or(AttValPos,AttValEnd),simd_or(lex.DQuote,lex.SQuote)));
1396                                BitBlock AttValFollow;
1397                                carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(AttValEnd,carry_set_0.getCarry(7),AttValFollow));
1398                                tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends,AttValFollow);
1399                                if (bitblock::any(simd_or(simd_and(AttValFollow,lex.WS),carry_set_0.carryRange(8,1))))
1400                                {
1401                                        carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_ScanThru(AttValFollow,lex.WS,carry_set_0.getCarry(8),AfterWS));
1402                                        AttListEnd = simd_or(AttListEnd,simd_and(AfterWS,AttListDelim));
1403                                        AttNameStart = simd_andc(AfterWS,AttListDelim);
1404                                }
1405                                else
1406                                {
1407                                        AttListEnd = simd_or(AttListEnd,simd_and(AttValFollow,AttListDelim));
1408                                        AttNameStart = simd_andc(AttValFollow,AttListDelim);
1409                                        carry_set_0.carryDequeueEnqueue(8,1);
1410                                }
1411                                ParseError = simd_or(ParseError,simd_and(AttValFollow,AttNameStart));
1412                                while (bitblock::any(simd_and(AttNameStart,EOF_mask)))
1413                                {
1414                                        CarryDeclare(carry_set_1,7,0);
1415                                        ParseError = simd_or(ParseError,simd_andc(AttNameStart,lex.NameScan));
1416                                        tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts,AttNameStart);
1417                                        BitBlock AttNameFollow;
1418                                        carry_set_1.getCarry(0) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameStart,lex.NameScan,carry_set_1.getCarry(0),AttNameFollow));
1419                                        tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends,AttNameFollow);
1420                                        if (bitblock::any(simd_and(AttNameFollow,lex.WS)))
1421                                        {
1422                                                carry_set_1.getCarry(1) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameFollow,lex.WS,carry_set_1.getCarry(1),EqExpected));
1423                                        }
1424                                        else
1425                                        {
1426                                                EqExpected = AttNameFollow;
1427                                        }
1428                                        ParseError = simd_or(ParseError,simd_andc(EqExpected,lex.Equals));
1429                                        BitBlock AttValPos;
1430                                        carry_set_1.getCarry(2) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(EqExpected,lex.WS,carry_set_1.getCarry(2),AttValPos));
1431                                        tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts,AttValPos);
1432                                        BitBlock DQuoteAttVal;
1433                                        DQuoteAttVal = simd_and(AttValPos,lex.DQuote);
1434                                        BitBlock SQuoteAttVal;
1435                                        SQuoteAttVal = simd_and(AttValPos,lex.SQuote);
1436                                        BitBlock DQuoteAttEnd;
1437                                        carry_set_1.getCarry(3) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(DQuoteAttVal,simd_andc(EOF_mask,DQuoteDelim),carry_set_1.getCarry(3),DQuoteAttEnd));
1438                                        BitBlock SQuoteAttEnd;
1439                                        carry_set_1.getCarry(4) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(SQuoteAttVal,simd_andc(EOF_mask,SQuoteDelim),carry_set_1.getCarry(4),SQuoteAttEnd));
1440                                        BitBlock AttValEnd;
1441                                        AttValEnd = simd_or(DQuoteAttEnd,SQuoteAttEnd);
1442                                        ParseError = simd_or(ParseError,simd_andc(simd_or(AttValPos,AttValEnd),simd_or(lex.DQuote,lex.SQuote)));
1443                                        BitBlock AttValFollow;
1444                                        carry_set_1.getCarry(5) = bitblock::srli<127>(pablo_blk_Advance(AttValEnd,carry_set_1.getCarry(5),AttValFollow));
1445                                        tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends,AttValFollow);
1446                                        if (bitblock::any(simd_and(AttValFollow,lex.WS)))
1447                                        {
1448                                                carry_set_1.getCarry(6) = bitblock::srli<127>(pablo_blk_ScanThru(AttValFollow,lex.WS,carry_set_1.getCarry(6),AfterWS));
1449                                                AttListEnd = simd_or(AttListEnd,simd_and(AfterWS,AttListDelim));
1450                                                AttNameStart = simd_andc(AfterWS,AttListDelim);
1451                                        }
1452                                        else
1453                                        {
1454                                                AttListEnd = simd_or(AttListEnd,simd_and(AttValFollow,AttListDelim));
1455                                                AttNameStart = simd_andc(AttValFollow,AttListDelim);
1456                                        }
1457                                        ParseError = simd_or(ParseError,simd_and(AttValFollow,AttNameStart));
1458                                        LocalCarryCombine(carry_set_0,carry_set_1,2,7);
1459                                }
1460                        }
1461                        else
1462                        {
1463                                carry_set_0.carryDequeueEnqueue(2,7);
1464                        }
1465                }
1466                else
1467                {
1468                        AttListEnd = simd_and(tag_Callouts.ElemName_ends,AttListDelim);
1469                        ParseError = simd_or(ParseError,simd_andc(tag_Callouts.ElemName_ends,AttListDelim));
1470                        carry_set_0.carryDequeueEnqueue(1,8);
1471                }
1472                BitBlock STagEnds;
1473                STagEnds = simd_and(AttListEnd,lex.RAngle);
1474                carry_set_0.getCarry(9) = bitblock::srli<127>(pablo_blk_Advance(simd_and(AttListEnd,lex.Slash),carry_set_0.getCarry(9),tag_Callouts.EmptyTag_marks));
1475                ParseError = simd_or(ParseError,simd_andc(tag_Callouts.EmptyTag_marks,lex.RAngle));
1476                BitBlock EndTagEnds;
1477                carry_set_0.getCarry(10) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(tag_Callouts.EndTag_marks,lex.NameScan,carry_set_0.getCarry(10),EndTagEnds));
1478                if (bitblock::any(simd_or(simd_and(EndTagEnds,lex.WS),carry_set_0.carryRange(11,1))))
1479                {
1480                        carry_set_0.getCarry(11) = bitblock::srli<127>(pablo_blk_ScanThru(EndTagEnds,lex.WS,carry_set_0.getCarry(11),EndTagEnds));
1481                }
1482                else
1483                {
1484                        carry_set_0.carryDequeueEnqueue(11,1);
1485                }
1486                ParseError = simd_or(ParseError,simd_andc(EndTagEnds,lex.RAngle));
1487                if (bitblock::any(ParseError))
1488                {
1489                        assert_0_error(ParseError,"Tag parsing error found");
1490                }
1491                carry_set_0.getCarry(12) = bitblock::srli<127>(pablo_blk_SpanUpTo(tag_Callouts.AttVal_starts,tag_Callouts.AttVal_ends,carry_set_0.getCarry(12),tag_Callouts.AttVal_spans));
1492        }
1493       
1494        CarryDeclare(carry_set_0,13,0);
1495};
1496 
1497struct Parse_refs
1498{
1499        Parse_refs()
1500        {
1501        }
1502       
1503        IDISA_INLINE void do_block(struct Lex & lex,struct Marker & marker,struct Ref_Callouts & ref_Callouts)
1504        {
1505                ref_Callouts.GenRef_starts = simd<1>::constant<0>();
1506                ref_Callouts.GenRef_ends = simd<1>::constant<0>();
1507                ref_Callouts.DecRef_starts = simd<1>::constant<0>();
1508                ref_Callouts.DecRef_ends = simd<1>::constant<0>();
1509                ref_Callouts.HexRef_starts = simd<1>::constant<0>();
1510                ref_Callouts.HexRef_ends = simd<1>::constant<0>();
1511                BitBlock ref_error;
1512                ref_error = simd<1>::constant<0>();
1513                if (bitblock::any(simd_or(marker.Ref_opener,carry_set_0.carryRange(0,6))))
1514                {
1515                        BitBlock Ref_scope;
1516                        carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(marker.Ref_opener,carry_set_0.getCarry(0),Ref_scope));
1517                        BitBlock NumRef2;
1518                        NumRef2 = simd_and(Ref_scope,lex.Hash);
1519                        ref_Callouts.GenRef_starts = simd_andc(Ref_scope,lex.Hash);
1520                        BitBlock NumRef3;
1521                        carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(NumRef2,carry_set_0.getCarry(1),NumRef3));
1522                        BitBlock HexRef3;
1523                        HexRef3 = simd_and(NumRef3,lex.x);
1524                        ref_Callouts.DecRef_starts = simd_andc(NumRef3,lex.x);
1525                        carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_Advance(HexRef3,carry_set_0.getCarry(2),ref_Callouts.HexRef_starts));
1526                        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));
1527                        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));
1528                        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));
1529                        BitBlock ref_error1;
1530                        ref_error1 = simd_andc(ref_Callouts.DecRef_starts,lex.Digit);
1531                        BitBlock ref_error2;
1532                        ref_error2 = simd_andc(ref_Callouts.HexRef_starts,lex.Hex);
1533                        BitBlock ref_ends;
1534                        ref_ends = simd_or(simd_or(ref_Callouts.GenRef_ends,ref_Callouts.DecRef_ends),ref_Callouts.HexRef_ends);
1535                        BitBlock ref_error3;
1536                        ref_error3 = simd_andc(ref_ends,lex.Semicolon);
1537                        if (bitblock::any(simd_or(simd_or(ref_error1,ref_error2),ref_error3)))
1538                        {
1539                                assert_0_error(simd_or(simd_or(ref_error1,ref_error2),ref_error3),"Reference error found");
1540                        }
1541                }
1542                else
1543                {
1544                        carry_set_0.carryDequeueEnqueue(0,6);
1545                }
1546                carry_set_0.carryAdjust(6);
1547        }
1548       
1549        void do_final_block(struct Lex & lex,struct Marker & marker,struct Ref_Callouts & ref_Callouts,BitBlock & EOF_mask)
1550        {
1551                ref_Callouts.GenRef_starts = simd<1>::constant<0>();
1552                ref_Callouts.GenRef_ends = simd<1>::constant<0>();
1553                ref_Callouts.DecRef_starts = simd<1>::constant<0>();
1554                ref_Callouts.DecRef_ends = simd<1>::constant<0>();
1555                ref_Callouts.HexRef_starts = simd<1>::constant<0>();
1556                ref_Callouts.HexRef_ends = simd<1>::constant<0>();
1557                BitBlock ref_error;
1558                ref_error = simd<1>::constant<0>();
1559                if (bitblock::any(simd_or(marker.Ref_opener,carry_set_0.carryRange(0,6))))
1560                {
1561                        BitBlock Ref_scope;
1562                        carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(marker.Ref_opener,carry_set_0.getCarry(0),Ref_scope));
1563                        BitBlock NumRef2;
1564                        NumRef2 = simd_and(Ref_scope,lex.Hash);
1565                        ref_Callouts.GenRef_starts = simd_andc(Ref_scope,lex.Hash);
1566                        BitBlock NumRef3;
1567                        carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(NumRef2,carry_set_0.getCarry(1),NumRef3));
1568                        BitBlock HexRef3;
1569                        HexRef3 = simd_and(NumRef3,lex.x);
1570                        ref_Callouts.DecRef_starts = simd_andc(NumRef3,lex.x);
1571                        carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_Advance(HexRef3,carry_set_0.getCarry(2),ref_Callouts.HexRef_starts));
1572                        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));
1573                        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));
1574                        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));
1575                        BitBlock ref_error1;
1576                        ref_error1 = simd_andc(ref_Callouts.DecRef_starts,lex.Digit);
1577                        BitBlock ref_error2;
1578                        ref_error2 = simd_andc(ref_Callouts.HexRef_starts,lex.Hex);
1579                        BitBlock ref_ends;
1580                        ref_ends = simd_or(simd_or(ref_Callouts.GenRef_ends,ref_Callouts.DecRef_ends),ref_Callouts.HexRef_ends);
1581                        BitBlock ref_error3;
1582                        ref_error3 = simd_andc(ref_ends,lex.Semicolon);
1583                        if (bitblock::any(simd_or(simd_or(ref_error1,ref_error2),ref_error3)))
1584                        {
1585                                assert_0_error(simd_or(simd_or(ref_error1,ref_error2),ref_error3),"Reference error found");
1586                        }
1587                }
1588                else
1589                {
1590                        carry_set_0.carryDequeueEnqueue(0,6);
1591                }
1592        }
1593       
1594        CarryDeclare(carry_set_0,6,0);
1595};
1596 
1597struct Validate_xml_names
1598{
1599        Validate_xml_names()
1600        {
1601        }
1602       
1603        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)
1604        {
1605                BitBlock PI_names;
1606                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));
1607                BitBlock GenRefs;
1608                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));
1609                BitBlock ElemNames;
1610                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));
1611                BitBlock AttNames;
1612                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));
1613                BitBlock qname_stream;
1614                qname_stream = simd_or(ElemNames,AttNames);
1615                BitBlock ncname_stream;
1616                ncname_stream = simd_or(PI_names,GenRefs);
1617                BitBlock name_stream;
1618                name_stream = simd_or(qname_stream,ncname_stream);
1619                BitBlock name_start;
1620                BitBlock _temp0;
1621                carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_Advance(name_stream,carry_set_0.getCarry(4),_temp0));
1622                name_start = simd_andc(name_stream,_temp0);
1623                BitBlock name_cursor;
1624                BitBlock _temp1;
1625                carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_Advance(name_stream,carry_set_0.getCarry(5),_temp1));
1626                name_cursor = simd_andc(name_stream,_temp1);
1627                BitBlock void_prefix_err;
1628                void_prefix_err = simd_and(name_cursor,lex.Colon);
1629                BitBlock namespace_sep;
1630                BitBlock _temp2;
1631                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));
1632                namespace_sep = simd_and(_temp2,lex.Colon);
1633                BitBlock local_part_start;
1634                carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(namespace_sep,carry_set_0.getCarry(7),local_part_start));
1635                BitBlock local_part_err;
1636                local_part_err = simd_andc(local_part_start,lex.NameScan);
1637                BitBlock colon2_err;
1638                BitBlock _temp3;
1639                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));
1640                colon2_err = simd_and(_temp3,lex.Colon);
1641                BitBlock ncname_err;
1642                ncname_err = simd_and(ncname_stream,lex.Colon);
1643                if (bitblock::any(simd_or(simd_or(simd_or(void_prefix_err,local_part_err),colon2_err),ncname_err)))
1644                {
1645                        assert_0_error(simd_or(simd_or(simd_or(void_prefix_err,local_part_err),colon2_err),ncname_err),"name syntax error");
1646                }
1647                check_streams.non_ascii_name_starts = simd_andc(name_start,lex.ASCII_name_start);
1648                check_streams.non_ascii_names = simd_andc(simd_andc(simd_andc(name_stream,name_start),lex.ASCII_name_char),u8.suffix);
1649                carry_set_0.carryAdjust(9);
1650        }
1651       
1652        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)
1653        {
1654                BitBlock PI_names;
1655                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));
1656                BitBlock GenRefs;
1657                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));
1658                BitBlock ElemNames;
1659                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));
1660                BitBlock AttNames;
1661                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));
1662                BitBlock qname_stream;
1663                qname_stream = simd_or(ElemNames,AttNames);
1664                BitBlock ncname_stream;
1665                ncname_stream = simd_or(PI_names,GenRefs);
1666                BitBlock name_stream;
1667                name_stream = simd_or(qname_stream,ncname_stream);
1668                BitBlock name_start;
1669                BitBlock _temp0;
1670                carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_Advance(name_stream,carry_set_0.getCarry(4),_temp0));
1671                name_start = simd_andc(name_stream,_temp0);
1672                BitBlock name_cursor;
1673                BitBlock _temp1;
1674                carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_Advance(name_stream,carry_set_0.getCarry(5),_temp1));
1675                name_cursor = simd_andc(name_stream,_temp1);
1676                BitBlock void_prefix_err;
1677                void_prefix_err = simd_and(name_cursor,lex.Colon);
1678                BitBlock namespace_sep;
1679                BitBlock _temp2;
1680                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));
1681                namespace_sep = simd_and(_temp2,lex.Colon);
1682                BitBlock local_part_start;
1683                carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(namespace_sep,carry_set_0.getCarry(7),local_part_start));
1684                BitBlock local_part_err;
1685                local_part_err = simd_andc(local_part_start,lex.NameScan);
1686                BitBlock colon2_err;
1687                BitBlock _temp3;
1688                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));
1689                colon2_err = simd_and(_temp3,lex.Colon);
1690                BitBlock ncname_err;
1691                ncname_err = simd_and(ncname_stream,lex.Colon);
1692                if (bitblock::any(simd_or(simd_or(simd_or(void_prefix_err,local_part_err),colon2_err),ncname_err)))
1693                {
1694                        assert_0_error(simd_or(simd_or(simd_or(void_prefix_err,local_part_err),colon2_err),ncname_err),"name syntax error");
1695                }
1696                check_streams.non_ascii_name_starts = simd_andc(name_start,lex.ASCII_name_start);
1697                check_streams.non_ascii_names = simd_andc(simd_andc(simd_andc(name_stream,name_start),lex.ASCII_name_char),u8.suffix);
1698        }
1699       
1700        CarryDeclare(carry_set_0,9,0);
1701};
1702 
1703struct Do_check_streams
1704{
1705        Do_check_streams()
1706        {
1707        }
1708       
1709        IDISA_INLINE void do_block(struct Marker & marker,struct Tag_Callouts & tag_Callouts,struct Check_streams & check_streams)
1710        {
1711                if (bitblock::any(simd_andc(marker.CD_closer,tag_Callouts.AttVal_spans)))
1712                {
1713                        assert_0_error(simd_andc(marker.CD_closer,tag_Callouts.AttVal_spans),"Error: ]]> in text");
1714                }
1715                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);
1716                check_streams.name_follows = simd_or(tag_Callouts.ElemName_ends,tag_Callouts.AttName_ends);
1717                check_streams.att_refs = simd_and(tag_Callouts.AttVal_spans,marker.Ref_opener);
1718        }
1719       
1720        void do_final_block(struct Marker & marker,struct Tag_Callouts & tag_Callouts,struct Check_streams & check_streams,BitBlock & EOF_mask)
1721        {
1722                if (bitblock::any(simd_andc(marker.CD_closer,tag_Callouts.AttVal_spans)))
1723                {
1724                        assert_0_error(simd_andc(marker.CD_closer,tag_Callouts.AttVal_spans),"Error: ]]> in text");
1725                }
1726                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);
1727                check_streams.name_follows = simd_or(tag_Callouts.ElemName_ends,tag_Callouts.AttName_ends);
1728                check_streams.att_refs = simd_and(tag_Callouts.AttVal_spans,marker.Ref_opener);
1729        }
1730       
1731        CarryDeclare(carry_set_0,0,0);
1732};
1733 
1734
1735// } // pablo namespace
1736
1737#endif // PABLO_DEFINITIONS_HPP
Note: See TracBrowser for help on using the repository browser.