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

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

Moved files to test CPP compilation.

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