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

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

PabloS to PabloB translation. 'while' translation and code clean up remains.

File size: 59.4 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                while (bitblock::any(CtCDPI_Cursor))
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                }
871                BitBlock _temp5;
872                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));
873                check_streams.misc_mask = simd_and(simd_or(simd_or(simd_or(lex.WS,lex.LAngle),_temp5),CtCDPI_starts),EOF_mask);
874                marker.LAngle_scope = simd_andc(LAngle_scope,ctCDPI_mask);
875                marker.Ref_opener = simd_andc(lex.RefStart,ctCDPI_mask);
876                marker.CD_closer = simd_andc(CD_closer,ctCDPI_mask);
877                carry_set_0.carryAdjust(17);
878        }
879       
880        void do_final_block(struct Lex & lex,struct Marker & marker,struct CtCDPI_Callouts & ctCDPI_Callouts,struct Check_streams & check_streams,BitBlock & EOF_mask)
881        {
882                ctCDPI_Callouts.Ct_starts = simd<1>::constant<0>();
883                ctCDPI_Callouts.Ct_ends = simd<1>::constant<0>();
884                ctCDPI_Callouts.CD_starts = simd<1>::constant<0>();
885                ctCDPI_Callouts.CD_ends = simd<1>::constant<0>();
886                ctCDPI_Callouts.PI_starts = simd<1>::constant<0>();
887                ctCDPI_Callouts.PI_name_starts = simd<1>::constant<0>();
888                ctCDPI_Callouts.PI_name_ends = simd<1>::constant<0>();
889                ctCDPI_Callouts.PI_ends = simd<1>::constant<0>();
890                BitBlock CtCDPI_starts;
891                CtCDPI_starts = simd<1>::constant<0>();
892                BitBlock CtCDPI_ends;
893                CtCDPI_ends = simd<1>::constant<0>();
894                BitBlock ctCDPI_mask;
895                ctCDPI_mask = simd<1>::constant<0>();
896                BitBlock v;
897                v = simd_or(lex.LAngle,lex.Hyphen);
898                BitBlock w;
899                w = simd_or(lex.Hyphen,lex.QMark);
900                BitBlock v1;
901                carry_set_0.getPending64(0) = bitblock::srli<127>(pablo_blk_Advance_n_<1>(v,carry_set_0.getPending64(0),v1));
902                BitBlock w1;
903                carry_set_0.getPending64(1) = bitblock::srli<127>(pablo_blk_Advance_n_<1>(w,carry_set_0.getPending64(1),w1));
904                BitBlock LAngle_scope;
905                LAngle_scope = simd_andc(v1,w1);
906                BitBlock PI_opener;
907                PI_opener = simd_and(LAngle_scope,lex.QMark);
908                BitBlock CtCD_opener;
909                CtCD_opener = simd_and(LAngle_scope,lex.Exclam);
910                BitBlock CtCDPI_opener;
911                CtCDPI_opener = simd_or(PI_opener,CtCD_opener);
912                BitBlock CD_closer;
913                CD_closer = simd<1>::constant<0>();
914                BitBlock DoubleHyphen;
915                DoubleHyphen = simd_and(simd_and(v1,w1),lex.Hyphen);
916                if (bitblock::any(simd_or(lex.RBracket,carry_set_0.carryRange(0,2))))
917                {
918                        BitBlock DoubleRBracket;
919                        BitBlock _temp0;
920                        carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(lex.RBracket,carry_set_0.getCarry(0),_temp0));
921                        DoubleRBracket = simd_and(_temp0,lex.RBracket);
922                        BitBlock _temp1;
923                        carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(DoubleRBracket,carry_set_0.getCarry(1),_temp1));
924                        CD_closer = simd_and(_temp1,lex.RAngle);
925                }
926                else
927                {
928                        carry_set_0.carryDequeueEnqueue(0,2);
929                }
930                BitBlock PI_closer;
931                PI_closer = simd_and(simd_andc(w1,v1),lex.RAngle);
932                BitBlock CtCDPI_Cursor;
933                carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_ScanToFirst(CtCDPI_opener,carry_set_0.getCarry(2),CtCDPI_Cursor));
934                while (bitblock::any(CtCDPI_Cursor))
935                {
936                        CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
937                        BitBlock PI_Cursor;
938                        PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
939                        BitBlock CD_Ct_Cursor;
940                        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));
941                        BitBlock CD_Cursor;
942                        CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
943                        BitBlock Ct_Cursor;
944                        Ct_Cursor = simd_and(CD_Ct_Cursor,lex.Hyphen);
945                        if (bitblock::any(simd_or(PI_Cursor,carry_set_0.carryRange(4,4))))
946                        {
947                                ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts,PI_Cursor);
948                                carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_Advance(PI_Cursor,carry_set_0.getCarry(4),PI_Cursor));
949                                ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts,PI_Cursor);
950                                BitBlock PI_name_end;
951                                carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_ScanThru(PI_Cursor,lex.NameScan,carry_set_0.getCarry(5),PI_name_end));
952                                BitBlock PI_error;
953                                PI_error = simd_and(PI_Cursor,PI_name_end);
954                                BitBlock PI_noWS;
955                                PI_noWS = simd_andc(PI_name_end,lex.WS);
956                                BitBlock _temp2;
957                                carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_Advance(PI_noWS,carry_set_0.getCarry(6),_temp2));
958                                PI_error = simd_or(PI_error,simd_or(simd_andc(PI_noWS,lex.QMark),simd_andc(_temp2,PI_closer)));
959                                if (bitblock::any(PI_error))
960                                {
961                                        assert_0_error(PI_error,"Error in PI syntax");
962                                }
963                                ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends,PI_name_end);
964                                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));
965                                ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends,PI_Cursor);
966                                CtCDPI_ends = simd_or(CtCDPI_ends,PI_Cursor);
967                        }
968                        else
969                        {
970                                carry_set_0.carryDequeueEnqueue(4,4);
971                        }
972                        if (bitblock::any(simd_or(CD_Cursor,carry_set_0.carryRange(8,1))))
973                        {
974                                ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts,CD_Cursor);
975                                carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_ScanThru(CD_Cursor,simd_not(CD_closer),carry_set_0.getCarry(8),CD_Cursor));
976                                ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends,CD_Cursor);
977                                CtCDPI_ends = simd_or(CtCDPI_ends,CD_Cursor);
978                        }
979                        else
980                        {
981                                carry_set_0.carryDequeueEnqueue(8,1);
982                        }
983                        if (bitblock::any(simd_or(Ct_Cursor,carry_set_0.carryRange(9,5))))
984                        {
985                                ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts,Ct_Cursor);
986                                carry_set_0.getCarry(9) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_0.getCarry(9),Ct_Cursor));
987                                BitBlock Ct_error;
988                                Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
989                                BitBlock _temp3;
990                                carry_set_0.getCarry(10) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_0.getCarry(10),_temp3));
991                                carry_set_0.getCarry(11) = bitblock::srli<127>(pablo_blk_Advance(_temp3,carry_set_0.getCarry(11),Ct_Cursor));
992                                BitBlock _temp4;
993                                carry_set_0.getCarry(12) = bitblock::srli<127>(pablo_blk_ScanThru(Ct_Cursor,simd_not(DoubleHyphen),carry_set_0.getCarry(12),_temp4));
994                                carry_set_0.getCarry(13) = bitblock::srli<127>(pablo_blk_Advance(_temp4,carry_set_0.getCarry(13),Ct_Cursor));
995                                if (bitblock::any(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle))))
996                                {
997                                        assert_0_error(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle)),"Error in comment syntax");
998                                }
999                                ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends,Ct_Cursor);
1000                                CtCDPI_ends = simd_or(CtCDPI_ends,Ct_Cursor);
1001                        }
1002                        else
1003                        {
1004                                carry_set_0.carryDequeueEnqueue(9,5);
1005                        }
1006                        CtCDPI_Cursor = simd_or(simd_or(PI_Cursor,CD_Cursor),Ct_Cursor);
1007                        carry_set_0.getCarry(14) = bitblock::srli<127>(pablo_blk_InclusiveSpan(CtCDPI_starts,CtCDPI_ends,carry_set_0.getCarry(14),ctCDPI_mask));
1008                        if (bitblock::any(simd_andc(ctCDPI_mask,EOF_mask)))
1009                        {
1010                                assert_0_error(simd_andc(ctCDPI_mask,EOF_mask),"Error in comment, CDATA or processing instruction syntax");
1011                        }
1012                        carry_set_0.getCarry(15) = bitblock::srli<127>(pablo_blk_ScanThru(CtCDPI_Cursor,simd_not(CtCDPI_opener),carry_set_0.getCarry(15),CtCDPI_Cursor));
1013                }
1014                BitBlock _temp5;
1015                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));
1016                check_streams.misc_mask = simd_and(simd_or(simd_or(simd_or(lex.WS,lex.LAngle),_temp5),CtCDPI_starts),EOF_mask);
1017                marker.LAngle_scope = simd_andc(LAngle_scope,ctCDPI_mask);
1018                marker.Ref_opener = simd_andc(lex.RefStart,ctCDPI_mask);
1019                marker.CD_closer = simd_andc(CD_closer,ctCDPI_mask);
1020        }
1021       
1022        CarryDeclare(carry_set_0,17,2);
1023};
1024 
1025struct Parse_tags
1026{
1027        Parse_tags()
1028        {
1029        }
1030       
1031        IDISA_INLINE void do_block(struct Lex & lex,struct Marker & marker,struct Tag_Callouts & tag_Callouts)
1032        {
1033                BitBlock EqExpected;
1034                EqExpected = simd<1>::constant<0>();
1035                BitBlock AttListEnd;
1036                AttListEnd = simd<1>::constant<0>();
1037                BitBlock DQuoteDelim;
1038                DQuoteDelim = simd_or(lex.DQuote,lex.LAngle);
1039                BitBlock SQuoteDelim;
1040                SQuoteDelim = simd_or(lex.SQuote,lex.LAngle);
1041                BitBlock AttListDelim;
1042                AttListDelim = simd_or(lex.Slash,lex.RAngle);
1043                tag_Callouts.ElemName_starts = simd_andc(marker.LAngle_scope,lex.Slash);
1044                tag_Callouts.EndTag_marks = simd_and(marker.LAngle_scope,lex.Slash);
1045                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));
1046                BitBlock ParseError;
1047                ParseError = simd_and(tag_Callouts.ElemName_starts,tag_Callouts.ElemName_ends);
1048                tag_Callouts.AttName_starts = simd<1>::constant<0>();
1049                tag_Callouts.AttName_ends = simd<1>::constant<0>();
1050                tag_Callouts.AttVal_starts = simd<1>::constant<0>();
1051                tag_Callouts.AttVal_ends = simd<1>::constant<0>();
1052                if (bitblock::any(simd_or(simd_and(tag_Callouts.ElemName_ends,lex.WS),carry_set_0.carryRange(1,8))))
1053                {
1054                        BitBlock AfterWS;
1055                        carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_ScanThru(tag_Callouts.ElemName_ends,lex.WS,carry_set_0.getCarry(1),AfterWS));
1056                        AttListEnd = simd_and(AfterWS,AttListDelim);
1057                        BitBlock AttNameStart;
1058                        AttNameStart = simd_andc(AfterWS,AttListDelim);
1059                        while (bitblock::any(AttNameStart))
1060                        {
1061                                ParseError = simd_or(ParseError,simd_andc(AttNameStart,lex.NameScan));
1062                                tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts,AttNameStart);
1063                                BitBlock AttNameFollow;
1064                                carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameStart,lex.NameScan,carry_set_0.getCarry(2),AttNameFollow));
1065                                tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends,AttNameFollow);
1066                                if (bitblock::any(simd_or(simd_and(AttNameFollow,lex.WS),carry_set_0.carryRange(3,1))))
1067                                {
1068                                        carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameFollow,lex.WS,carry_set_0.getCarry(3),EqExpected));
1069                                }
1070                                else
1071                                {
1072                                        EqExpected = AttNameFollow;
1073                                        carry_set_0.carryDequeueEnqueue(3,1);
1074                                }
1075                                ParseError = simd_or(ParseError,simd_andc(EqExpected,lex.Equals));
1076                                BitBlock AttValPos;
1077                                carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(EqExpected,lex.WS,carry_set_0.getCarry(4),AttValPos));
1078                                tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts,AttValPos);
1079                                BitBlock DQuoteAttVal;
1080                                DQuoteAttVal = simd_and(AttValPos,lex.DQuote);
1081                                BitBlock SQuoteAttVal;
1082                                SQuoteAttVal = simd_and(AttValPos,lex.SQuote);
1083                                BitBlock DQuoteAttEnd;
1084                                carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(DQuoteAttVal,simd_not(DQuoteDelim),carry_set_0.getCarry(5),DQuoteAttEnd));
1085                                BitBlock SQuoteAttEnd;
1086                                carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(SQuoteAttVal,simd_not(SQuoteDelim),carry_set_0.getCarry(6),SQuoteAttEnd));
1087                                BitBlock AttValEnd;
1088                                AttValEnd = simd_or(DQuoteAttEnd,SQuoteAttEnd);
1089                                ParseError = simd_or(ParseError,simd_andc(simd_or(AttValPos,AttValEnd),simd_or(lex.DQuote,lex.SQuote)));
1090                                BitBlock AttValFollow;
1091                                carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(AttValEnd,carry_set_0.getCarry(7),AttValFollow));
1092                                tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends,AttValFollow);
1093                                if (bitblock::any(simd_or(simd_and(AttValFollow,lex.WS),carry_set_0.carryRange(8,1))))
1094                                {
1095                                        carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_ScanThru(AttValFollow,lex.WS,carry_set_0.getCarry(8),AfterWS));
1096                                        AttListEnd = simd_or(AttListEnd,simd_and(AfterWS,AttListDelim));
1097                                        AttNameStart = simd_andc(AfterWS,AttListDelim);
1098                                }
1099                                else
1100                                {
1101                                        AttListEnd = simd_or(AttListEnd,simd_and(AttValFollow,AttListDelim));
1102                                        AttNameStart = simd_andc(AttValFollow,AttListDelim);
1103                                        carry_set_0.carryDequeueEnqueue(8,1);
1104                                }
1105                                ParseError = simd_or(ParseError,simd_and(AttValFollow,AttNameStart));
1106                        }
1107                }
1108                else
1109                {
1110                        AttListEnd = simd_and(tag_Callouts.ElemName_ends,AttListDelim);
1111                        ParseError = simd_or(ParseError,simd_andc(tag_Callouts.ElemName_ends,AttListDelim));
1112                        carry_set_0.carryDequeueEnqueue(1,8);
1113                }
1114                BitBlock STagEnds;
1115                STagEnds = simd_and(AttListEnd,lex.RAngle);
1116                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));
1117                ParseError = simd_or(ParseError,simd_andc(tag_Callouts.EmptyTag_marks,lex.RAngle));
1118                BitBlock EndTagEnds;
1119                carry_set_0.getCarry(10) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(tag_Callouts.EndTag_marks,lex.NameScan,carry_set_0.getCarry(10),EndTagEnds));
1120                if (bitblock::any(simd_or(simd_and(EndTagEnds,lex.WS),carry_set_0.carryRange(11,1))))
1121                {
1122                        carry_set_0.getCarry(11) = bitblock::srli<127>(pablo_blk_ScanThru(EndTagEnds,lex.WS,carry_set_0.getCarry(11),EndTagEnds));
1123                }
1124                else
1125                {
1126                        carry_set_0.carryDequeueEnqueue(11,1);
1127                }
1128                ParseError = simd_or(ParseError,simd_andc(EndTagEnds,lex.RAngle));
1129                if (bitblock::any(ParseError))
1130                {
1131                        assert_0_error(ParseError,"Tag parsing error found");
1132                }
1133                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));
1134                carry_set_0.carryAdjust(13);
1135        }
1136       
1137        void do_final_block(struct Lex & lex,struct Marker & marker,struct Tag_Callouts & tag_Callouts,BitBlock & EOF_mask)
1138        {
1139                BitBlock EqExpected;
1140                EqExpected = simd<1>::constant<0>();
1141                BitBlock AttListEnd;
1142                AttListEnd = simd<1>::constant<0>();
1143                BitBlock DQuoteDelim;
1144                DQuoteDelim = simd_or(lex.DQuote,lex.LAngle);
1145                BitBlock SQuoteDelim;
1146                SQuoteDelim = simd_or(lex.SQuote,lex.LAngle);
1147                BitBlock AttListDelim;
1148                AttListDelim = simd_or(lex.Slash,lex.RAngle);
1149                tag_Callouts.ElemName_starts = simd_andc(marker.LAngle_scope,lex.Slash);
1150                tag_Callouts.EndTag_marks = simd_and(marker.LAngle_scope,lex.Slash);
1151                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));
1152                BitBlock ParseError;
1153                ParseError = simd_and(tag_Callouts.ElemName_starts,tag_Callouts.ElemName_ends);
1154                tag_Callouts.AttName_starts = simd<1>::constant<0>();
1155                tag_Callouts.AttName_ends = simd<1>::constant<0>();
1156                tag_Callouts.AttVal_starts = simd<1>::constant<0>();
1157                tag_Callouts.AttVal_ends = simd<1>::constant<0>();
1158                if (bitblock::any(simd_or(simd_and(tag_Callouts.ElemName_ends,lex.WS),carry_set_0.carryRange(1,8))))
1159                {
1160                        BitBlock AfterWS;
1161                        carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_ScanThru(tag_Callouts.ElemName_ends,lex.WS,carry_set_0.getCarry(1),AfterWS));
1162                        AttListEnd = simd_and(AfterWS,AttListDelim);
1163                        BitBlock AttNameStart;
1164                        AttNameStart = simd_andc(AfterWS,AttListDelim);
1165                        while (bitblock::any(AttNameStart))
1166                        {
1167                                ParseError = simd_or(ParseError,simd_andc(AttNameStart,lex.NameScan));
1168                                tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts,AttNameStart);
1169                                BitBlock AttNameFollow;
1170                                carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameStart,lex.NameScan,carry_set_0.getCarry(2),AttNameFollow));
1171                                tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends,AttNameFollow);
1172                                if (bitblock::any(simd_or(simd_and(AttNameFollow,lex.WS),carry_set_0.carryRange(3,1))))
1173                                {
1174                                        carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameFollow,lex.WS,carry_set_0.getCarry(3),EqExpected));
1175                                }
1176                                else
1177                                {
1178                                        EqExpected = AttNameFollow;
1179                                        carry_set_0.carryDequeueEnqueue(3,1);
1180                                }
1181                                ParseError = simd_or(ParseError,simd_andc(EqExpected,lex.Equals));
1182                                BitBlock AttValPos;
1183                                carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(EqExpected,lex.WS,carry_set_0.getCarry(4),AttValPos));
1184                                tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts,AttValPos);
1185                                BitBlock DQuoteAttVal;
1186                                DQuoteAttVal = simd_and(AttValPos,lex.DQuote);
1187                                BitBlock SQuoteAttVal;
1188                                SQuoteAttVal = simd_and(AttValPos,lex.SQuote);
1189                                BitBlock DQuoteAttEnd;
1190                                carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(DQuoteAttVal,simd_not(DQuoteDelim),carry_set_0.getCarry(5),DQuoteAttEnd));
1191                                BitBlock SQuoteAttEnd;
1192                                carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(SQuoteAttVal,simd_not(SQuoteDelim),carry_set_0.getCarry(6),SQuoteAttEnd));
1193                                BitBlock AttValEnd;
1194                                AttValEnd = simd_or(DQuoteAttEnd,SQuoteAttEnd);
1195                                ParseError = simd_or(ParseError,simd_andc(simd_or(AttValPos,AttValEnd),simd_or(lex.DQuote,lex.SQuote)));
1196                                BitBlock AttValFollow;
1197                                carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(AttValEnd,carry_set_0.getCarry(7),AttValFollow));
1198                                tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends,AttValFollow);
1199                                if (bitblock::any(simd_or(simd_and(AttValFollow,lex.WS),carry_set_0.carryRange(8,1))))
1200                                {
1201                                        carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_ScanThru(AttValFollow,lex.WS,carry_set_0.getCarry(8),AfterWS));
1202                                        AttListEnd = simd_or(AttListEnd,simd_and(AfterWS,AttListDelim));
1203                                        AttNameStart = simd_andc(AfterWS,AttListDelim);
1204                                }
1205                                else
1206                                {
1207                                        AttListEnd = simd_or(AttListEnd,simd_and(AttValFollow,AttListDelim));
1208                                        AttNameStart = simd_andc(AttValFollow,AttListDelim);
1209                                        carry_set_0.carryDequeueEnqueue(8,1);
1210                                }
1211                                ParseError = simd_or(ParseError,simd_and(AttValFollow,AttNameStart));
1212                        }
1213                }
1214                else
1215                {
1216                        AttListEnd = simd_and(tag_Callouts.ElemName_ends,AttListDelim);
1217                        ParseError = simd_or(ParseError,simd_andc(tag_Callouts.ElemName_ends,AttListDelim));
1218                        carry_set_0.carryDequeueEnqueue(1,8);
1219                }
1220                BitBlock STagEnds;
1221                STagEnds = simd_and(AttListEnd,lex.RAngle);
1222                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));
1223                ParseError = simd_or(ParseError,simd_andc(tag_Callouts.EmptyTag_marks,lex.RAngle));
1224                BitBlock EndTagEnds;
1225                carry_set_0.getCarry(10) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(tag_Callouts.EndTag_marks,lex.NameScan,carry_set_0.getCarry(10),EndTagEnds));
1226                if (bitblock::any(simd_or(simd_and(EndTagEnds,lex.WS),carry_set_0.carryRange(11,1))))
1227                {
1228                        carry_set_0.getCarry(11) = bitblock::srli<127>(pablo_blk_ScanThru(EndTagEnds,lex.WS,carry_set_0.getCarry(11),EndTagEnds));
1229                }
1230                else
1231                {
1232                        carry_set_0.carryDequeueEnqueue(11,1);
1233                }
1234                ParseError = simd_or(ParseError,simd_andc(EndTagEnds,lex.RAngle));
1235                if (bitblock::any(ParseError))
1236                {
1237                        assert_0_error(ParseError,"Tag parsing error found");
1238                }
1239                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));
1240        }
1241       
1242        CarryDeclare(carry_set_0,13,0);
1243};
1244 
1245struct Parse_refs
1246{
1247        Parse_refs()
1248        {
1249        }
1250       
1251        IDISA_INLINE void do_block(struct Lex & lex,struct Marker & marker,struct Ref_Callouts & ref_Callouts)
1252        {
1253                ref_Callouts.GenRef_starts = simd<1>::constant<0>();
1254                ref_Callouts.GenRef_ends = simd<1>::constant<0>();
1255                ref_Callouts.DecRef_starts = simd<1>::constant<0>();
1256                ref_Callouts.DecRef_ends = simd<1>::constant<0>();
1257                ref_Callouts.HexRef_starts = simd<1>::constant<0>();
1258                ref_Callouts.HexRef_ends = simd<1>::constant<0>();
1259                BitBlock ref_error;
1260                ref_error = simd<1>::constant<0>();
1261                if (bitblock::any(simd_or(marker.Ref_opener,carry_set_0.carryRange(0,6))))
1262                {
1263                        BitBlock Ref_scope;
1264                        carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(marker.Ref_opener,carry_set_0.getCarry(0),Ref_scope));
1265                        BitBlock NumRef2;
1266                        NumRef2 = simd_and(Ref_scope,lex.Hash);
1267                        ref_Callouts.GenRef_starts = simd_andc(Ref_scope,lex.Hash);
1268                        BitBlock NumRef3;
1269                        carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(NumRef2,carry_set_0.getCarry(1),NumRef3));
1270                        BitBlock HexRef3;
1271                        HexRef3 = simd_and(NumRef3,lex.x);
1272                        ref_Callouts.DecRef_starts = simd_andc(NumRef3,lex.x);
1273                        carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_Advance(HexRef3,carry_set_0.getCarry(2),ref_Callouts.HexRef_starts));
1274                        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));
1275                        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));
1276                        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));
1277                        BitBlock ref_error1;
1278                        ref_error1 = simd_andc(ref_Callouts.DecRef_starts,lex.Digit);
1279                        BitBlock ref_error2;
1280                        ref_error2 = simd_andc(ref_Callouts.HexRef_starts,lex.Hex);
1281                        BitBlock ref_ends;
1282                        ref_ends = simd_or(simd_or(ref_Callouts.GenRef_ends,ref_Callouts.DecRef_ends),ref_Callouts.HexRef_ends);
1283                        BitBlock ref_error3;
1284                        ref_error3 = simd_andc(ref_ends,lex.Semicolon);
1285                        if (bitblock::any(simd_or(simd_or(ref_error1,ref_error2),ref_error3)))
1286                        {
1287                                assert_0_error(simd_or(simd_or(ref_error1,ref_error2),ref_error3),"Reference error found");
1288                        }
1289                }
1290                else
1291                {
1292                        carry_set_0.carryDequeueEnqueue(0,6);
1293                }
1294                carry_set_0.carryAdjust(6);
1295        }
1296       
1297        void do_final_block(struct Lex & lex,struct Marker & marker,struct Ref_Callouts & ref_Callouts,BitBlock & EOF_mask)
1298        {
1299                ref_Callouts.GenRef_starts = simd<1>::constant<0>();
1300                ref_Callouts.GenRef_ends = simd<1>::constant<0>();
1301                ref_Callouts.DecRef_starts = simd<1>::constant<0>();
1302                ref_Callouts.DecRef_ends = simd<1>::constant<0>();
1303                ref_Callouts.HexRef_starts = simd<1>::constant<0>();
1304                ref_Callouts.HexRef_ends = simd<1>::constant<0>();
1305                BitBlock ref_error;
1306                ref_error = simd<1>::constant<0>();
1307                if (bitblock::any(simd_or(marker.Ref_opener,carry_set_0.carryRange(0,6))))
1308                {
1309                        BitBlock Ref_scope;
1310                        carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(marker.Ref_opener,carry_set_0.getCarry(0),Ref_scope));
1311                        BitBlock NumRef2;
1312                        NumRef2 = simd_and(Ref_scope,lex.Hash);
1313                        ref_Callouts.GenRef_starts = simd_andc(Ref_scope,lex.Hash);
1314                        BitBlock NumRef3;
1315                        carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(NumRef2,carry_set_0.getCarry(1),NumRef3));
1316                        BitBlock HexRef3;
1317                        HexRef3 = simd_and(NumRef3,lex.x);
1318                        ref_Callouts.DecRef_starts = simd_andc(NumRef3,lex.x);
1319                        carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_Advance(HexRef3,carry_set_0.getCarry(2),ref_Callouts.HexRef_starts));
1320                        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));
1321                        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));
1322                        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));
1323                        BitBlock ref_error1;
1324                        ref_error1 = simd_andc(ref_Callouts.DecRef_starts,lex.Digit);
1325                        BitBlock ref_error2;
1326                        ref_error2 = simd_andc(ref_Callouts.HexRef_starts,lex.Hex);
1327                        BitBlock ref_ends;
1328                        ref_ends = simd_or(simd_or(ref_Callouts.GenRef_ends,ref_Callouts.DecRef_ends),ref_Callouts.HexRef_ends);
1329                        BitBlock ref_error3;
1330                        ref_error3 = simd_andc(ref_ends,lex.Semicolon);
1331                        if (bitblock::any(simd_or(simd_or(ref_error1,ref_error2),ref_error3)))
1332                        {
1333                                assert_0_error(simd_or(simd_or(ref_error1,ref_error2),ref_error3),"Reference error found");
1334                        }
1335                }
1336                else
1337                {
1338                        carry_set_0.carryDequeueEnqueue(0,6);
1339                }
1340        }
1341       
1342        CarryDeclare(carry_set_0,6,0);
1343};
1344 
1345struct Validate_xml_names
1346{
1347        Validate_xml_names()
1348        {
1349        }
1350       
1351        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)
1352        {
1353                BitBlock PI_names;
1354                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));
1355                BitBlock GenRefs;
1356                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));
1357                BitBlock ElemNames;
1358                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));
1359                BitBlock AttNames;
1360                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));
1361                BitBlock qname_stream;
1362                qname_stream = simd_or(ElemNames,AttNames);
1363                BitBlock ncname_stream;
1364                ncname_stream = simd_or(PI_names,GenRefs);
1365                BitBlock name_stream;
1366                name_stream = simd_or(qname_stream,ncname_stream);
1367                BitBlock name_start;
1368                BitBlock _temp0;
1369                carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_Advance(name_stream,carry_set_0.getCarry(4),_temp0));
1370                name_start = simd_andc(name_stream,_temp0);
1371                BitBlock name_cursor;
1372                BitBlock _temp1;
1373                carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_Advance(name_stream,carry_set_0.getCarry(5),_temp1));
1374                name_cursor = simd_andc(name_stream,_temp1);
1375                BitBlock void_prefix_err;
1376                void_prefix_err = simd_and(name_cursor,lex.Colon);
1377                BitBlock namespace_sep;
1378                BitBlock _temp2;
1379                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));
1380                namespace_sep = simd_and(_temp2,lex.Colon);
1381                BitBlock local_part_start;
1382                carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(namespace_sep,carry_set_0.getCarry(7),local_part_start));
1383                BitBlock local_part_err;
1384                local_part_err = simd_andc(local_part_start,lex.NameScan);
1385                BitBlock colon2_err;
1386                BitBlock _temp3;
1387                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));
1388                colon2_err = simd_and(_temp3,lex.Colon);
1389                BitBlock ncname_err;
1390                ncname_err = simd_and(ncname_stream,lex.Colon);
1391                if (bitblock::any(simd_or(simd_or(simd_or(void_prefix_err,local_part_err),colon2_err),ncname_err)))
1392                {
1393                        assert_0_error(simd_or(simd_or(simd_or(void_prefix_err,local_part_err),colon2_err),ncname_err),"name syntax error");
1394                }
1395                check_streams.non_ascii_name_starts = simd_andc(name_start,lex.ASCII_name_start);
1396                check_streams.non_ascii_names = simd_andc(simd_andc(simd_andc(name_stream,name_start),lex.ASCII_name_char),u8.suffix);
1397                carry_set_0.carryAdjust(9);
1398        }
1399       
1400        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)
1401        {
1402                BitBlock PI_names;
1403                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));
1404                BitBlock GenRefs;
1405                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));
1406                BitBlock ElemNames;
1407                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));
1408                BitBlock AttNames;
1409                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));
1410                BitBlock qname_stream;
1411                qname_stream = simd_or(ElemNames,AttNames);
1412                BitBlock ncname_stream;
1413                ncname_stream = simd_or(PI_names,GenRefs);
1414                BitBlock name_stream;
1415                name_stream = simd_or(qname_stream,ncname_stream);
1416                BitBlock name_start;
1417                BitBlock _temp0;
1418                carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_Advance(name_stream,carry_set_0.getCarry(4),_temp0));
1419                name_start = simd_andc(name_stream,_temp0);
1420                BitBlock name_cursor;
1421                BitBlock _temp1;
1422                carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_Advance(name_stream,carry_set_0.getCarry(5),_temp1));
1423                name_cursor = simd_andc(name_stream,_temp1);
1424                BitBlock void_prefix_err;
1425                void_prefix_err = simd_and(name_cursor,lex.Colon);
1426                BitBlock namespace_sep;
1427                BitBlock _temp2;
1428                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));
1429                namespace_sep = simd_and(_temp2,lex.Colon);
1430                BitBlock local_part_start;
1431                carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(namespace_sep,carry_set_0.getCarry(7),local_part_start));
1432                BitBlock local_part_err;
1433                local_part_err = simd_andc(local_part_start,lex.NameScan);
1434                BitBlock colon2_err;
1435                BitBlock _temp3;
1436                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));
1437                colon2_err = simd_and(_temp3,lex.Colon);
1438                BitBlock ncname_err;
1439                ncname_err = simd_and(ncname_stream,lex.Colon);
1440                if (bitblock::any(simd_or(simd_or(simd_or(void_prefix_err,local_part_err),colon2_err),ncname_err)))
1441                {
1442                        assert_0_error(simd_or(simd_or(simd_or(void_prefix_err,local_part_err),colon2_err),ncname_err),"name syntax error");
1443                }
1444                check_streams.non_ascii_name_starts = simd_andc(name_start,lex.ASCII_name_start);
1445                check_streams.non_ascii_names = simd_andc(simd_andc(simd_andc(name_stream,name_start),lex.ASCII_name_char),u8.suffix);
1446        }
1447       
1448        CarryDeclare(carry_set_0,9,0);
1449};
1450 
1451struct Do_check_streams
1452{
1453        Do_check_streams()
1454        {
1455        }
1456       
1457        IDISA_INLINE void do_block(struct Marker & marker,struct Tag_Callouts & tag_Callouts,struct Check_streams & check_streams)
1458        {
1459                if (bitblock::any(simd_andc(marker.CD_closer,tag_Callouts.AttVal_spans)))
1460                {
1461                        assert_0_error(simd_andc(marker.CD_closer,tag_Callouts.AttVal_spans),"Error: ]]> in text");
1462                }
1463                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);
1464                check_streams.name_follows = simd_or(tag_Callouts.ElemName_ends,tag_Callouts.AttName_ends);
1465                check_streams.att_refs = simd_and(tag_Callouts.AttVal_spans,marker.Ref_opener);
1466        }
1467       
1468        void do_final_block(struct Marker & marker,struct Tag_Callouts & tag_Callouts,struct Check_streams & check_streams,BitBlock & EOF_mask)
1469        {
1470                if (bitblock::any(simd_andc(marker.CD_closer,tag_Callouts.AttVal_spans)))
1471                {
1472                        assert_0_error(simd_andc(marker.CD_closer,tag_Callouts.AttVal_spans),"Error: ]]> in text");
1473                }
1474                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);
1475                check_streams.name_follows = simd_or(tag_Callouts.ElemName_ends,tag_Callouts.AttName_ends);
1476                check_streams.att_refs = simd_and(tag_Callouts.AttVal_spans,marker.Ref_opener);
1477        }
1478       
1479        CarryDeclare(carry_set_0,0,0);
1480};
1481 
1482
1483// } // pablo namespace
1484
1485#endif // PABLO_DEFINITIONS_HPP
Note: See TracBrowser for help on using the repository browser.