Ignore:
Timestamp:
Jul 12, 2013, 6:26:50 PM (6 years ago)
Author:
ksherdy
Message:

Restructured for S2S, S2B, B2B phased translation.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • proto/pabloj/trunk/output/cpplang/pablo_definitions.hpp

    r3387 r3401  
    789789                BitBlock CtCDPI_Cursor;
    790790                carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_ScanToFirst(CtCDPI_opener,carry_set_0.getCarry(2),CtCDPI_Cursor));
    791                 while (bitblock::any(CtCDPI_Cursor))
     791                if (bitblock::any(simd_or(CtCDPI_Cursor,carry_set_0.carryRange(3,13))))
    792792                {
    793793                        CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
     
    868868                        }
    869869                        carry_set_0.getCarry(15) = bitblock::srli<127>(pablo_blk_ScanThru(CtCDPI_Cursor,simd_not(CtCDPI_opener),carry_set_0.getCarry(15),CtCDPI_Cursor));
     870                        while (bitblock::any(CtCDPI_Cursor))
     871                        {
     872                                CarryDeclare(carry_set_1,13,0);
     873                                CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
     874                                BitBlock PI_Cursor;
     875                                PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
     876                                BitBlock CD_Ct_Cursor;
     877                                carry_set_1.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(simd_andc(CtCDPI_Cursor,PI_Cursor),carry_set_1.getCarry(0),CD_Ct_Cursor));
     878                                BitBlock CD_Cursor;
     879                                CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
     880                                BitBlock Ct_Cursor;
     881                                Ct_Cursor = simd_and(CD_Ct_Cursor,lex.Hyphen);
     882                                if (bitblock::any(PI_Cursor))
     883                                {
     884                                        ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts,PI_Cursor);
     885                                        carry_set_1.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(PI_Cursor,carry_set_1.getCarry(1),PI_Cursor));
     886                                        ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts,PI_Cursor);
     887                                        BitBlock PI_name_end;
     888                                        carry_set_1.getCarry(2) = bitblock::srli<127>(pablo_blk_ScanThru(PI_Cursor,lex.NameScan,carry_set_1.getCarry(2),PI_name_end));
     889                                        BitBlock PI_error;
     890                                        PI_error = simd_and(PI_Cursor,PI_name_end);
     891                                        BitBlock PI_noWS;
     892                                        PI_noWS = simd_andc(PI_name_end,lex.WS);
     893                                        BitBlock _temp2;
     894                                        carry_set_1.getCarry(3) = bitblock::srli<127>(pablo_blk_Advance(PI_noWS,carry_set_1.getCarry(3),_temp2));
     895                                        PI_error = simd_or(PI_error,simd_or(simd_andc(PI_noWS,lex.QMark),simd_andc(_temp2,PI_closer)));
     896                                        if (bitblock::any(PI_error))
     897                                        {
     898                                                assert_0_error(PI_error,"Error in PI syntax");
     899                                        }
     900                                        ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends,PI_name_end);
     901                                        carry_set_1.getCarry(4) = bitblock::srli<127>(pablo_blk_ScanThru(PI_name_end,simd_not(PI_closer),carry_set_1.getCarry(4),PI_Cursor));
     902                                        ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends,PI_Cursor);
     903                                        CtCDPI_ends = simd_or(CtCDPI_ends,PI_Cursor);
     904                                }
     905                                if (bitblock::any(CD_Cursor))
     906                                {
     907                                        ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts,CD_Cursor);
     908                                        carry_set_1.getCarry(5) = bitblock::srli<127>(pablo_blk_ScanThru(CD_Cursor,simd_not(CD_closer),carry_set_1.getCarry(5),CD_Cursor));
     909                                        ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends,CD_Cursor);
     910                                        CtCDPI_ends = simd_or(CtCDPI_ends,CD_Cursor);
     911                                }
     912                                if (bitblock::any(Ct_Cursor))
     913                                {
     914                                        ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts,Ct_Cursor);
     915                                        carry_set_1.getCarry(6) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_1.getCarry(6),Ct_Cursor));
     916                                        BitBlock Ct_error;
     917                                        Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
     918                                        BitBlock _temp3;
     919                                        carry_set_1.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_1.getCarry(7),_temp3));
     920                                        carry_set_1.getCarry(8) = bitblock::srli<127>(pablo_blk_Advance(_temp3,carry_set_1.getCarry(8),Ct_Cursor));
     921                                        BitBlock _temp4;
     922                                        carry_set_1.getCarry(9) = bitblock::srli<127>(pablo_blk_ScanThru(Ct_Cursor,simd_not(DoubleHyphen),carry_set_1.getCarry(9),_temp4));
     923                                        carry_set_1.getCarry(10) = bitblock::srli<127>(pablo_blk_Advance(_temp4,carry_set_1.getCarry(10),Ct_Cursor));
     924                                        if (bitblock::any(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle))))
     925                                        {
     926                                                assert_0_error(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle)),"Error in comment syntax");
     927                                        }
     928                                        ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends,Ct_Cursor);
     929                                        CtCDPI_ends = simd_or(CtCDPI_ends,Ct_Cursor);
     930                                }
     931                                CtCDPI_Cursor = simd_or(simd_or(PI_Cursor,CD_Cursor),Ct_Cursor);
     932                                carry_set_1.getCarry(11) = bitblock::srli<127>(pablo_blk_InclusiveSpan(CtCDPI_starts,CtCDPI_ends,carry_set_1.getCarry(11),ctCDPI_mask));
     933                                if (bitblock::any(simd<1>::constant<0>()))
     934                                {
     935                                        assert_0_error(simd<1>::constant<0>(),"Error in comment, CDATA or processing instruction syntax");
     936                                }
     937                                carry_set_1.getCarry(12) = bitblock::srli<127>(pablo_blk_ScanThru(CtCDPI_Cursor,simd_not(CtCDPI_opener),carry_set_1.getCarry(12),CtCDPI_Cursor));
     938                                LocalCarryCombine(carry_set_0,carry_set_1,3,13);
     939                        }
     940                }
     941                else
     942                {
     943                        carry_set_0.carryDequeueEnqueue(3,13);
    870944                }
    871945                BitBlock _temp5;
     
    9311005                PI_closer = simd_and(simd_andc(w1,v1),lex.RAngle);
    9321006                BitBlock CtCDPI_Cursor;
    933                 carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_ScanToFirst(CtCDPI_opener,carry_set_0.getCarry(2),CtCDPI_Cursor));
    934                 while (bitblock::any(CtCDPI_Cursor))
     1007                carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_ScanToFirst(simd_or(CtCDPI_opener,simd_not(EOF_mask)),carry_set_0.getCarry(2),CtCDPI_Cursor));
     1008                if (bitblock::any(simd_and(simd_or(CtCDPI_Cursor,carry_set_0.carryRange(3,13)),EOF_mask)))
    9351009                {
    9361010                        CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
     
    9621036                                }
    9631037                                ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends,PI_name_end);
    964                                 carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_ScanThru(PI_name_end,simd_not(PI_closer),carry_set_0.getCarry(7),PI_Cursor));
     1038                                carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_ScanThru(PI_name_end,simd_andc(EOF_mask,PI_closer),carry_set_0.getCarry(7),PI_Cursor));
    9651039                                ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends,PI_Cursor);
    9661040                                CtCDPI_ends = simd_or(CtCDPI_ends,PI_Cursor);
     
    9731047                        {
    9741048                                ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts,CD_Cursor);
    975                                 carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_ScanThru(CD_Cursor,simd_not(CD_closer),carry_set_0.getCarry(8),CD_Cursor));
     1049                                carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_ScanThru(CD_Cursor,simd_andc(EOF_mask,CD_closer),carry_set_0.getCarry(8),CD_Cursor));
    9761050                                ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends,CD_Cursor);
    9771051                                CtCDPI_ends = simd_or(CtCDPI_ends,CD_Cursor);
     
    9911065                                carry_set_0.getCarry(11) = bitblock::srli<127>(pablo_blk_Advance(_temp3,carry_set_0.getCarry(11),Ct_Cursor));
    9921066                                BitBlock _temp4;
    993                                 carry_set_0.getCarry(12) = bitblock::srli<127>(pablo_blk_ScanThru(Ct_Cursor,simd_not(DoubleHyphen),carry_set_0.getCarry(12),_temp4));
     1067                                carry_set_0.getCarry(12) = bitblock::srli<127>(pablo_blk_ScanThru(Ct_Cursor,simd_andc(EOF_mask,DoubleHyphen),carry_set_0.getCarry(12),_temp4));
    9941068                                carry_set_0.getCarry(13) = bitblock::srli<127>(pablo_blk_Advance(_temp4,carry_set_0.getCarry(13),Ct_Cursor));
    9951069                                if (bitblock::any(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle))))
     
    10101084                                assert_0_error(simd_andc(ctCDPI_mask,EOF_mask),"Error in comment, CDATA or processing instruction syntax");
    10111085                        }
    1012                         carry_set_0.getCarry(15) = bitblock::srli<127>(pablo_blk_ScanThru(CtCDPI_Cursor,simd_not(CtCDPI_opener),carry_set_0.getCarry(15),CtCDPI_Cursor));
     1086                        carry_set_0.getCarry(15) = bitblock::srli<127>(pablo_blk_ScanThru(CtCDPI_Cursor,simd_andc(EOF_mask,CtCDPI_opener),carry_set_0.getCarry(15),CtCDPI_Cursor));
     1087                        while (bitblock::any(simd_and(CtCDPI_Cursor,EOF_mask)))
     1088                        {
     1089                                CarryDeclare(carry_set_1,13,0);
     1090                                CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
     1091                                BitBlock PI_Cursor;
     1092                                PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
     1093                                BitBlock CD_Ct_Cursor;
     1094                                carry_set_1.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(simd_andc(CtCDPI_Cursor,PI_Cursor),carry_set_1.getCarry(0),CD_Ct_Cursor));
     1095                                BitBlock CD_Cursor;
     1096                                CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
     1097                                BitBlock Ct_Cursor;
     1098                                Ct_Cursor = simd_and(CD_Ct_Cursor,lex.Hyphen);
     1099                                if (bitblock::any(PI_Cursor))
     1100                                {
     1101                                        ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts,PI_Cursor);
     1102                                        carry_set_1.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(PI_Cursor,carry_set_1.getCarry(1),PI_Cursor));
     1103                                        ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts,PI_Cursor);
     1104                                        BitBlock PI_name_end;
     1105                                        carry_set_1.getCarry(2) = bitblock::srli<127>(pablo_blk_ScanThru(PI_Cursor,lex.NameScan,carry_set_1.getCarry(2),PI_name_end));
     1106                                        BitBlock PI_error;
     1107                                        PI_error = simd_and(PI_Cursor,PI_name_end);
     1108                                        BitBlock PI_noWS;
     1109                                        PI_noWS = simd_andc(PI_name_end,lex.WS);
     1110                                        BitBlock _temp2;
     1111                                        carry_set_1.getCarry(3) = bitblock::srli<127>(pablo_blk_Advance(PI_noWS,carry_set_1.getCarry(3),_temp2));
     1112                                        PI_error = simd_or(PI_error,simd_or(simd_andc(PI_noWS,lex.QMark),simd_andc(_temp2,PI_closer)));
     1113                                        if (bitblock::any(PI_error))
     1114                                        {
     1115                                                assert_0_error(PI_error,"Error in PI syntax");
     1116                                        }
     1117                                        ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends,PI_name_end);
     1118                                        carry_set_1.getCarry(4) = bitblock::srli<127>(pablo_blk_ScanThru(PI_name_end,simd_andc(EOF_mask,PI_closer),carry_set_1.getCarry(4),PI_Cursor));
     1119                                        ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends,PI_Cursor);
     1120                                        CtCDPI_ends = simd_or(CtCDPI_ends,PI_Cursor);
     1121                                }
     1122                                if (bitblock::any(CD_Cursor))
     1123                                {
     1124                                        ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts,CD_Cursor);
     1125                                        carry_set_1.getCarry(5) = bitblock::srli<127>(pablo_blk_ScanThru(CD_Cursor,simd_andc(EOF_mask,CD_closer),carry_set_1.getCarry(5),CD_Cursor));
     1126                                        ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends,CD_Cursor);
     1127                                        CtCDPI_ends = simd_or(CtCDPI_ends,CD_Cursor);
     1128                                }
     1129                                if (bitblock::any(Ct_Cursor))
     1130                                {
     1131                                        ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts,Ct_Cursor);
     1132                                        carry_set_1.getCarry(6) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_1.getCarry(6),Ct_Cursor));
     1133                                        BitBlock Ct_error;
     1134                                        Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
     1135                                        BitBlock _temp3;
     1136                                        carry_set_1.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_1.getCarry(7),_temp3));
     1137                                        carry_set_1.getCarry(8) = bitblock::srli<127>(pablo_blk_Advance(_temp3,carry_set_1.getCarry(8),Ct_Cursor));
     1138                                        BitBlock _temp4;
     1139                                        carry_set_1.getCarry(9) = bitblock::srli<127>(pablo_blk_ScanThru(Ct_Cursor,simd_andc(EOF_mask,DoubleHyphen),carry_set_1.getCarry(9),_temp4));
     1140                                        carry_set_1.getCarry(10) = bitblock::srli<127>(pablo_blk_Advance(_temp4,carry_set_1.getCarry(10),Ct_Cursor));
     1141                                        if (bitblock::any(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle))))
     1142                                        {
     1143                                                assert_0_error(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle)),"Error in comment syntax");
     1144                                        }
     1145                                        ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends,Ct_Cursor);
     1146                                        CtCDPI_ends = simd_or(CtCDPI_ends,Ct_Cursor);
     1147                                }
     1148                                CtCDPI_Cursor = simd_or(simd_or(PI_Cursor,CD_Cursor),Ct_Cursor);
     1149                                carry_set_1.getCarry(11) = bitblock::srli<127>(pablo_blk_InclusiveSpan(CtCDPI_starts,CtCDPI_ends,carry_set_1.getCarry(11),ctCDPI_mask));
     1150                                if (bitblock::any(simd_andc(ctCDPI_mask,EOF_mask)))
     1151                                {
     1152                                        assert_0_error(simd_andc(ctCDPI_mask,EOF_mask),"Error in comment, CDATA or processing instruction syntax");
     1153                                }
     1154                                carry_set_1.getCarry(12) = bitblock::srli<127>(pablo_blk_ScanThru(CtCDPI_Cursor,simd_andc(EOF_mask,CtCDPI_opener),carry_set_1.getCarry(12),CtCDPI_Cursor));
     1155                                LocalCarryCombine(carry_set_0,carry_set_1,3,13);
     1156                        }
     1157                }
     1158                else
     1159                {
     1160                        carry_set_0.carryDequeueEnqueue(3,13);
    10131161                }
    10141162                BitBlock _temp5;
     
    10571205                        BitBlock AttNameStart;
    10581206                        AttNameStart = simd_andc(AfterWS,AttListDelim);
    1059                         while (bitblock::any(AttNameStart))
     1207                        if (bitblock::any(simd_or(AttNameStart,carry_set_0.carryRange(2,7))))
    10601208                        {
    10611209                                ParseError = simd_or(ParseError,simd_andc(AttNameStart,lex.NameScan));
     
    11041252                                }
    11051253                                ParseError = simd_or(ParseError,simd_and(AttValFollow,AttNameStart));
     1254                                while (bitblock::any(AttNameStart))
     1255                                {
     1256                                        CarryDeclare(carry_set_1,7,0);
     1257                                        ParseError = simd_or(ParseError,simd_andc(AttNameStart,lex.NameScan));
     1258                                        tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts,AttNameStart);
     1259                                        BitBlock AttNameFollow;
     1260                                        carry_set_1.getCarry(0) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameStart,lex.NameScan,carry_set_1.getCarry(0),AttNameFollow));
     1261                                        tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends,AttNameFollow);
     1262                                        if (bitblock::any(simd_and(AttNameFollow,lex.WS)))
     1263                                        {
     1264                                                carry_set_1.getCarry(1) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameFollow,lex.WS,carry_set_1.getCarry(1),EqExpected));
     1265                                        }
     1266                                        else
     1267                                        {
     1268                                                EqExpected = AttNameFollow;
     1269                                        }
     1270                                        ParseError = simd_or(ParseError,simd_andc(EqExpected,lex.Equals));
     1271                                        BitBlock AttValPos;
     1272                                        carry_set_1.getCarry(2) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(EqExpected,lex.WS,carry_set_1.getCarry(2),AttValPos));
     1273                                        tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts,AttValPos);
     1274                                        BitBlock DQuoteAttVal;
     1275                                        DQuoteAttVal = simd_and(AttValPos,lex.DQuote);
     1276                                        BitBlock SQuoteAttVal;
     1277                                        SQuoteAttVal = simd_and(AttValPos,lex.SQuote);
     1278                                        BitBlock DQuoteAttEnd;
     1279                                        carry_set_1.getCarry(3) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(DQuoteAttVal,simd_not(DQuoteDelim),carry_set_1.getCarry(3),DQuoteAttEnd));
     1280                                        BitBlock SQuoteAttEnd;
     1281                                        carry_set_1.getCarry(4) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(SQuoteAttVal,simd_not(SQuoteDelim),carry_set_1.getCarry(4),SQuoteAttEnd));
     1282                                        BitBlock AttValEnd;
     1283                                        AttValEnd = simd_or(DQuoteAttEnd,SQuoteAttEnd);
     1284                                        ParseError = simd_or(ParseError,simd_andc(simd_or(AttValPos,AttValEnd),simd_or(lex.DQuote,lex.SQuote)));
     1285                                        BitBlock AttValFollow;
     1286                                        carry_set_1.getCarry(5) = bitblock::srli<127>(pablo_blk_Advance(AttValEnd,carry_set_1.getCarry(5),AttValFollow));
     1287                                        tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends,AttValFollow);
     1288                                        if (bitblock::any(simd_and(AttValFollow,lex.WS)))
     1289                                        {
     1290                                                carry_set_1.getCarry(6) = bitblock::srli<127>(pablo_blk_ScanThru(AttValFollow,lex.WS,carry_set_1.getCarry(6),AfterWS));
     1291                                                AttListEnd = simd_or(AttListEnd,simd_and(AfterWS,AttListDelim));
     1292                                                AttNameStart = simd_andc(AfterWS,AttListDelim);
     1293                                        }
     1294                                        else
     1295                                        {
     1296                                                AttListEnd = simd_or(AttListEnd,simd_and(AttValFollow,AttListDelim));
     1297                                                AttNameStart = simd_andc(AttValFollow,AttListDelim);
     1298                                        }
     1299                                        ParseError = simd_or(ParseError,simd_and(AttValFollow,AttNameStart));
     1300                                        LocalCarryCombine(carry_set_0,carry_set_1,2,7);
     1301                                }
     1302                        }
     1303                        else
     1304                        {
     1305                                carry_set_0.carryDequeueEnqueue(2,7);
    11061306                        }
    11071307                }
     
    11631363                        BitBlock AttNameStart;
    11641364                        AttNameStart = simd_andc(AfterWS,AttListDelim);
    1165                         while (bitblock::any(AttNameStart))
     1365                        if (bitblock::any(simd_and(simd_or(AttNameStart,carry_set_0.carryRange(2,7)),EOF_mask)))
    11661366                        {
    11671367                                ParseError = simd_or(ParseError,simd_andc(AttNameStart,lex.NameScan));
     
    11881388                                SQuoteAttVal = simd_and(AttValPos,lex.SQuote);
    11891389                                BitBlock DQuoteAttEnd;
    1190                                 carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(DQuoteAttVal,simd_not(DQuoteDelim),carry_set_0.getCarry(5),DQuoteAttEnd));
     1390                                carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(DQuoteAttVal,simd_andc(EOF_mask,DQuoteDelim),carry_set_0.getCarry(5),DQuoteAttEnd));
    11911391                                BitBlock SQuoteAttEnd;
    1192                                 carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(SQuoteAttVal,simd_not(SQuoteDelim),carry_set_0.getCarry(6),SQuoteAttEnd));
     1392                                carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(SQuoteAttVal,simd_andc(EOF_mask,SQuoteDelim),carry_set_0.getCarry(6),SQuoteAttEnd));
    11931393                                BitBlock AttValEnd;
    11941394                                AttValEnd = simd_or(DQuoteAttEnd,SQuoteAttEnd);
     
    12101410                                }
    12111411                                ParseError = simd_or(ParseError,simd_and(AttValFollow,AttNameStart));
     1412                                while (bitblock::any(simd_and(AttNameStart,EOF_mask)))
     1413                                {
     1414                                        CarryDeclare(carry_set_1,7,0);
     1415                                        ParseError = simd_or(ParseError,simd_andc(AttNameStart,lex.NameScan));
     1416                                        tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts,AttNameStart);
     1417                                        BitBlock AttNameFollow;
     1418                                        carry_set_1.getCarry(0) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameStart,lex.NameScan,carry_set_1.getCarry(0),AttNameFollow));
     1419                                        tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends,AttNameFollow);
     1420                                        if (bitblock::any(simd_and(AttNameFollow,lex.WS)))
     1421                                        {
     1422                                                carry_set_1.getCarry(1) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameFollow,lex.WS,carry_set_1.getCarry(1),EqExpected));
     1423                                        }
     1424                                        else
     1425                                        {
     1426                                                EqExpected = AttNameFollow;
     1427                                        }
     1428                                        ParseError = simd_or(ParseError,simd_andc(EqExpected,lex.Equals));
     1429                                        BitBlock AttValPos;
     1430                                        carry_set_1.getCarry(2) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(EqExpected,lex.WS,carry_set_1.getCarry(2),AttValPos));
     1431                                        tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts,AttValPos);
     1432                                        BitBlock DQuoteAttVal;
     1433                                        DQuoteAttVal = simd_and(AttValPos,lex.DQuote);
     1434                                        BitBlock SQuoteAttVal;
     1435                                        SQuoteAttVal = simd_and(AttValPos,lex.SQuote);
     1436                                        BitBlock DQuoteAttEnd;
     1437                                        carry_set_1.getCarry(3) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(DQuoteAttVal,simd_andc(EOF_mask,DQuoteDelim),carry_set_1.getCarry(3),DQuoteAttEnd));
     1438                                        BitBlock SQuoteAttEnd;
     1439                                        carry_set_1.getCarry(4) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(SQuoteAttVal,simd_andc(EOF_mask,SQuoteDelim),carry_set_1.getCarry(4),SQuoteAttEnd));
     1440                                        BitBlock AttValEnd;
     1441                                        AttValEnd = simd_or(DQuoteAttEnd,SQuoteAttEnd);
     1442                                        ParseError = simd_or(ParseError,simd_andc(simd_or(AttValPos,AttValEnd),simd_or(lex.DQuote,lex.SQuote)));
     1443                                        BitBlock AttValFollow;
     1444                                        carry_set_1.getCarry(5) = bitblock::srli<127>(pablo_blk_Advance(AttValEnd,carry_set_1.getCarry(5),AttValFollow));
     1445                                        tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends,AttValFollow);
     1446                                        if (bitblock::any(simd_and(AttValFollow,lex.WS)))
     1447                                        {
     1448                                                carry_set_1.getCarry(6) = bitblock::srli<127>(pablo_blk_ScanThru(AttValFollow,lex.WS,carry_set_1.getCarry(6),AfterWS));
     1449                                                AttListEnd = simd_or(AttListEnd,simd_and(AfterWS,AttListDelim));
     1450                                                AttNameStart = simd_andc(AfterWS,AttListDelim);
     1451                                        }
     1452                                        else
     1453                                        {
     1454                                                AttListEnd = simd_or(AttListEnd,simd_and(AttValFollow,AttListDelim));
     1455                                                AttNameStart = simd_andc(AttValFollow,AttListDelim);
     1456                                        }
     1457                                        ParseError = simd_or(ParseError,simd_and(AttValFollow,AttNameStart));
     1458                                        LocalCarryCombine(carry_set_0,carry_set_1,2,7);
     1459                                }
     1460                        }
     1461                        else
     1462                        {
     1463                                carry_set_0.carryDequeueEnqueue(2,7);
    12121464                        }
    12131465                }
Note: See TracChangeset for help on using the changeset viewer.