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

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

Restructed PabloJ compile to provide clear separation between PabloS and PabloB.

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