Changeset 3798


Ignore:
Timestamp:
Apr 5, 2014, 6:48:18 PM (3 years ago)
Author:
ksherdy
Message:

Minor edit.

Location:
proto/s2k/trunk/framework
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • proto/s2k/trunk/framework/output/cpplang/parabix2/parabix2.hpp

    r3788 r3798  
    192192        }
    193193       
    194         IDISA_INLINE void do_block(struct Basis_bits & basis_bits,struct Lex & lex,struct U8 & u8)
     194        IDISA_INLINE void do_block(struct Basis_bits & basis_bits, struct Lex & lex, struct U8 & u8)
    195195        {
    196196                BitBlock temp1;
     
    356356                if (bitblock::any(lex_error))
    357357                {
    358                         assert_0_error(lex_error,"Error: illegal character");
     358                        assert_0_error(lex_error, "Error: illegal character");
    359359                }
    360360                u8.unibyte = simd_not(basis_bits.bit_0);
     
    443443                        else
    444444                        {
    445                                 carry_set_0.carryDequeueEnqueue(1,9);
     445                                carry_set_0.carryDequeueEnqueue(1, 9);
    446446                        }
    447447                        BitBlock u8mismatch;
     
    449449                        if (bitblock::any(simd_or(simd_or(u8_error,u8mismatch),u8_FFFE_FFFF)))
    450450                        {
    451                                 assert_0_error(simd_or(simd_or(u8_error,u8mismatch),u8_FFFE_FFFF),"UTF-8 error found");
     451                                assert_0_error(simd_or(simd_or(u8_error,u8mismatch),u8_FFFE_FFFF), "UTF-8 error found");
    452452                        }
    453453                }
    454454                else
    455455                {
    456                         carry_set_0.carryDequeueEnqueue(0,10);
     456                        carry_set_0.carryDequeueEnqueue(0, 10);
    457457                }
    458458                carry_set_0.carryAdjust(10);
    459459        }
    460460       
    461         void do_final_block(struct Basis_bits & basis_bits,struct Lex & lex,struct U8 & u8,BitBlock & EOF_mask)
     461        void do_final_block(struct Basis_bits & basis_bits, struct Lex & lex, struct U8 & u8, BitBlock & EOF_mask)
    462462        {
    463463                BitBlock temp1;
     
    623623                if (bitblock::any(simd_and(lex_error,EOF_mask)))
    624624                {
    625                         assert_0_error(simd_and(lex_error,EOF_mask),"Error: illegal character");
     625                        assert_0_error(simd_and(lex_error,EOF_mask), "Error: illegal character");
    626626                }
    627627                u8.unibyte = simd_not(basis_bits.bit_0);
     
    710710                        else
    711711                        {
    712                                 carry_set_0.carryDequeueEnqueue(1,9);
     712                                carry_set_0.carryDequeueEnqueue(1, 9);
    713713                        }
    714714                        BitBlock u8mismatch;
     
    716716                        if (bitblock::any(simd_or(simd_or(u8_error,u8mismatch),u8_FFFE_FFFF)))
    717717                        {
    718                                 assert_0_error(simd_or(simd_or(u8_error,u8mismatch),u8_FFFE_FFFF),"UTF-8 error found");
     718                                assert_0_error(simd_or(simd_or(u8_error,u8mismatch),u8_FFFE_FFFF), "UTF-8 error found");
    719719                        }
    720720                }
    721721                else
    722722                {
    723                         carry_set_0.carryDequeueEnqueue(0,10);
     723                        carry_set_0.carryDequeueEnqueue(0, 10);
    724724                }
    725725        }
     
    730730        }
    731731       
    732         CarryDeclare(carry_set_0,10,0);
     732        CarryDeclare(carry_set_0, 10, 0);
    733733};
    734734 
     
    737737        Parse_CtCDPI()
    738738        {
    739                 carry_set_0.setCarry(carry_set_0.carryFlip(2),2);
    740         }
    741        
    742         IDISA_INLINE void do_block(struct Lex & lex,struct Marker & marker,struct CtCDPI_Callouts & ctCDPI_Callouts,struct Check_streams & check_streams)
     739                carry_set_0.setCarry(carry_set_0.carryFlip(2), 2);
     740        }
     741       
     742        IDISA_INLINE void do_block(struct Lex & lex, struct Marker & marker, struct CtCDPI_Callouts & ctCDPI_Callouts, struct Check_streams & check_streams)
    743743        {
    744744                ctCDPI_Callouts.Ct_starts = simd<1>::constant<0>();
     
    788788                else
    789789                {
    790                         carry_set_0.carryDequeueEnqueue(0,2);
     790                        carry_set_0.carryDequeueEnqueue(0, 2);
    791791                }
    792792                BitBlock PI_closer;
     
    821821                                if (bitblock::any(PI_error))
    822822                                {
    823                                         assert_0_error(PI_error,"Error in PI syntax");
     823                                        assert_0_error(PI_error, "Error in PI syntax");
    824824                                }
    825825                                ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends,PI_name_end);
     
    830830                        else
    831831                        {
    832                                 carry_set_0.carryDequeueEnqueue(4,4);
     832                                carry_set_0.carryDequeueEnqueue(4, 4);
    833833                        }
    834834                        if (bitblock::any(simd_or(CD_Cursor,carry_set_0.carryRange(8,1))))
     
    841841                        else
    842842                        {
    843                                 carry_set_0.carryDequeueEnqueue(8,1);
     843                                carry_set_0.carryDequeueEnqueue(8, 1);
    844844                        }
    845845                        if (bitblock::any(simd_or(Ct_Cursor,carry_set_0.carryRange(9,5))))
     
    857857                                if (bitblock::any(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle))))
    858858                                {
    859                                         assert_0_error(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle)),"Error in comment syntax");
     859                                        assert_0_error(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle)), "Error in comment syntax");
    860860                                }
    861861                                ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends,Ct_Cursor);
     
    864864                        else
    865865                        {
    866                                 carry_set_0.carryDequeueEnqueue(9,5);
     866                                carry_set_0.carryDequeueEnqueue(9, 5);
    867867                        }
    868868                        CtCDPI_Cursor = simd_or(simd_or(PI_Cursor,CD_Cursor),Ct_Cursor);
     
    870870                        if (bitblock::any(simd<1>::constant<0>()))
    871871                        {
    872                                 assert_0_error(simd<1>::constant<0>(),"Error in comment, CDATA or processing instruction syntax");
     872                                assert_0_error(simd<1>::constant<0>(), "Error in comment, CDATA or processing instruction syntax");
    873873                        }
    874874                        carry_set_0.getCarry(15) = bitblock::srli<127>(pablo_blk_ScanThru(CtCDPI_Cursor,simd_not(CtCDPI_opener),carry_set_0.getCarry(15),CtCDPI_Cursor));
    875875                        while (bitblock::any(CtCDPI_Cursor))
    876876                        {
    877                                 CarryDeclare(carry_set_1,13,0);
     877                                CarryDeclare(carry_set_1, 13, 0);
    878878                                CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
    879879                                BitBlock PI_Cursor;
     
    901901                                        if (bitblock::any(PI_error))
    902902                                        {
    903                                                 assert_0_error(PI_error,"Error in PI syntax");
     903                                                assert_0_error(PI_error, "Error in PI syntax");
    904904                                        }
    905905                                        ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends,PI_name_end);
     
    929929                                        if (bitblock::any(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle))))
    930930                                        {
    931                                                 assert_0_error(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle)),"Error in comment syntax");
     931                                                assert_0_error(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle)), "Error in comment syntax");
    932932                                        }
    933933                                        ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends,Ct_Cursor);
     
    938938                                if (bitblock::any(simd<1>::constant<0>()))
    939939                                {
    940                                         assert_0_error(simd<1>::constant<0>(),"Error in comment, CDATA or processing instruction syntax");
     940                                        assert_0_error(simd<1>::constant<0>(), "Error in comment, CDATA or processing instruction syntax");
    941941                                }
    942942                                carry_set_1.getCarry(12) = bitblock::srli<127>(pablo_blk_ScanThru(CtCDPI_Cursor,simd_not(CtCDPI_opener),carry_set_1.getCarry(12),CtCDPI_Cursor));
    943                                 LocalCarryCombine(carry_set_0,carry_set_1,3,13);
     943                                LocalCarryCombine(carry_set_0, carry_set_1, 3, 13);
    944944                        }
    945945                }
    946946                else
    947947                {
    948                         carry_set_0.carryDequeueEnqueue(3,13);
     948                        carry_set_0.carryDequeueEnqueue(3, 13);
    949949                }
    950950                BitBlock _temp5;
     
    957957        }
    958958       
    959         void do_final_block(struct Lex & lex,struct Marker & marker,struct CtCDPI_Callouts & ctCDPI_Callouts,struct Check_streams & check_streams,BitBlock & EOF_mask)
     959        void do_final_block(struct Lex & lex, struct Marker & marker, struct CtCDPI_Callouts & ctCDPI_Callouts, struct Check_streams & check_streams, BitBlock & EOF_mask)
    960960        {
    961961                ctCDPI_Callouts.Ct_starts = simd<1>::constant<0>();
     
    10051005                else
    10061006                {
    1007                         carry_set_0.carryDequeueEnqueue(0,2);
     1007                        carry_set_0.carryDequeueEnqueue(0, 2);
    10081008                }
    10091009                BitBlock PI_closer;
     
    10381038                                if (bitblock::any(PI_error))
    10391039                                {
    1040                                         assert_0_error(PI_error,"Error in PI syntax");
     1040                                        assert_0_error(PI_error, "Error in PI syntax");
    10411041                                }
    10421042                                ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends,PI_name_end);
     
    10471047                        else
    10481048                        {
    1049                                 carry_set_0.carryDequeueEnqueue(4,4);
     1049                                carry_set_0.carryDequeueEnqueue(4, 4);
    10501050                        }
    10511051                        if (bitblock::any(simd_or(CD_Cursor,carry_set_0.carryRange(8,1))))
     
    10581058                        else
    10591059                        {
    1060                                 carry_set_0.carryDequeueEnqueue(8,1);
     1060                                carry_set_0.carryDequeueEnqueue(8, 1);
    10611061                        }
    10621062                        if (bitblock::any(simd_or(Ct_Cursor,carry_set_0.carryRange(9,5))))
     
    10741074                                if (bitblock::any(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle))))
    10751075                                {
    1076                                         assert_0_error(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle)),"Error in comment syntax");
     1076                                        assert_0_error(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle)), "Error in comment syntax");
    10771077                                }
    10781078                                ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends,Ct_Cursor);
     
    10811081                        else
    10821082                        {
    1083                                 carry_set_0.carryDequeueEnqueue(9,5);
     1083                                carry_set_0.carryDequeueEnqueue(9, 5);
    10841084                        }
    10851085                        CtCDPI_Cursor = simd_or(simd_or(PI_Cursor,CD_Cursor),Ct_Cursor);
     
    10871087                        if (bitblock::any(simd_andc(ctCDPI_mask,EOF_mask)))
    10881088                        {
    1089                                 assert_0_error(simd_andc(ctCDPI_mask,EOF_mask),"Error in comment, CDATA or processing instruction syntax");
     1089                                assert_0_error(simd_andc(ctCDPI_mask,EOF_mask), "Error in comment, CDATA or processing instruction syntax");
    10901090                        }
    10911091                        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));
    10921092                        while (bitblock::any(simd_and(CtCDPI_Cursor,EOF_mask)))
    10931093                        {
    1094                                 CarryDeclare(carry_set_1,13,0);
     1094                                CarryDeclare(carry_set_1, 13, 0);
    10951095                                CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
    10961096                                BitBlock PI_Cursor;
     
    11181118                                        if (bitblock::any(PI_error))
    11191119                                        {
    1120                                                 assert_0_error(PI_error,"Error in PI syntax");
     1120                                                assert_0_error(PI_error, "Error in PI syntax");
    11211121                                        }
    11221122                                        ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends,PI_name_end);
     
    11461146                                        if (bitblock::any(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle))))
    11471147                                        {
    1148                                                 assert_0_error(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle)),"Error in comment syntax");
     1148                                                assert_0_error(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle)), "Error in comment syntax");
    11491149                                        }
    11501150                                        ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends,Ct_Cursor);
     
    11551155                                if (bitblock::any(simd_andc(ctCDPI_mask,EOF_mask)))
    11561156                                {
    1157                                         assert_0_error(simd_andc(ctCDPI_mask,EOF_mask),"Error in comment, CDATA or processing instruction syntax");
     1157                                        assert_0_error(simd_andc(ctCDPI_mask,EOF_mask), "Error in comment, CDATA or processing instruction syntax");
    11581158                                }
    11591159                                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));
    1160                                 LocalCarryCombine(carry_set_0,carry_set_1,3,13);
     1160                                LocalCarryCombine(carry_set_0, carry_set_1, 3, 13);
    11611161                        }
    11621162                }
    11631163                else
    11641164                {
    1165                         carry_set_0.carryDequeueEnqueue(3,13);
     1165                        carry_set_0.carryDequeueEnqueue(3, 13);
    11661166                }
    11671167                BitBlock _temp5;
     
    11751175        void clear()
    11761176        {
    1177                 carry_set_0.setCarry(carry_set_0.carryFlip(2),2);
    1178         }
    1179        
    1180         CarryDeclare(carry_set_0,17,2);
     1177                carry_set_0.setCarry(carry_set_0.carryFlip(2), 2);
     1178        }
     1179       
     1180        CarryDeclare(carry_set_0, 17, 2);
    11811181};
    11821182 
     
    11871187        }
    11881188       
    1189         IDISA_INLINE void do_block(struct Lex & lex,struct Marker & marker,struct Tag_Callouts & tag_Callouts)
     1189        IDISA_INLINE void do_block(struct Lex & lex, struct Marker & marker, struct Tag_Callouts & tag_Callouts)
    11901190        {
    11911191                BitBlock EqExpected;
     
    12291229                                {
    12301230                                        EqExpected = AttNameFollow;
    1231                                         carry_set_0.carryDequeueEnqueue(3,1);
     1231                                        carry_set_0.carryDequeueEnqueue(3, 1);
    12321232                                }
    12331233                                ParseError = simd_or(ParseError,simd_andc(EqExpected,lex.Equals));
     
    12591259                                        AttListEnd = simd_or(AttListEnd,simd_and(AttValFollow,AttListDelim));
    12601260                                        AttNameStart = simd_andc(AttValFollow,AttListDelim);
    1261                                         carry_set_0.carryDequeueEnqueue(8,1);
     1261                                        carry_set_0.carryDequeueEnqueue(8, 1);
    12621262                                }
    12631263                                ParseError = simd_or(ParseError,simd_and(AttValFollow,AttNameStart));
    12641264                                while (bitblock::any(AttNameStart))
    12651265                                {
    1266                                         CarryDeclare(carry_set_1,7,0);
     1266                                        CarryDeclare(carry_set_1, 7, 0);
    12671267                                        ParseError = simd_or(ParseError,simd_andc(AttNameStart,lex.NameScan));
    12681268                                        tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts,AttNameStart);
     
    13081308                                        }
    13091309                                        ParseError = simd_or(ParseError,simd_and(AttValFollow,AttNameStart));
    1310                                         LocalCarryCombine(carry_set_0,carry_set_1,2,7);
     1310                                        LocalCarryCombine(carry_set_0, carry_set_1, 2, 7);
    13111311                                }
    13121312                        }
    13131313                        else
    13141314                        {
    1315                                 carry_set_0.carryDequeueEnqueue(2,7);
     1315                                carry_set_0.carryDequeueEnqueue(2, 7);
    13161316                        }
    13171317                }
     
    13201320                        AttListEnd = simd_and(tag_Callouts.ElemName_ends,AttListDelim);
    13211321                        ParseError = simd_or(ParseError,simd_andc(tag_Callouts.ElemName_ends,AttListDelim));
    1322                         carry_set_0.carryDequeueEnqueue(1,8);
     1322                        carry_set_0.carryDequeueEnqueue(1, 8);
    13231323                }
    13241324                BitBlock STagEnds;
     
    13341334                else
    13351335                {
    1336                         carry_set_0.carryDequeueEnqueue(11,1);
     1336                        carry_set_0.carryDequeueEnqueue(11, 1);
    13371337                }
    13381338                ParseError = simd_or(ParseError,simd_andc(EndTagEnds,lex.RAngle));
    13391339                if (bitblock::any(ParseError))
    13401340                {
    1341                         assert_0_error(ParseError,"Tag parsing error found");
     1341                        assert_0_error(ParseError, "Tag parsing error found");
    13421342                }
    13431343                carry_set_0.getCarry(12) = bitblock::srli<127>(pablo_blk_SpanUpTo(tag_Callouts.AttVal_starts,tag_Callouts.AttVal_ends,carry_set_0.getCarry(12),tag_Callouts.AttVal_spans));
     
    13451345        }
    13461346       
    1347         void do_final_block(struct Lex & lex,struct Marker & marker,struct Tag_Callouts & tag_Callouts,BitBlock & EOF_mask)
     1347        void do_final_block(struct Lex & lex, struct Marker & marker, struct Tag_Callouts & tag_Callouts, BitBlock & EOF_mask)
    13481348        {
    13491349                BitBlock EqExpected;
     
    13871387                                {
    13881388                                        EqExpected = AttNameFollow;
    1389                                         carry_set_0.carryDequeueEnqueue(3,1);
     1389                                        carry_set_0.carryDequeueEnqueue(3, 1);
    13901390                                }
    13911391                                ParseError = simd_or(ParseError,simd_andc(EqExpected,lex.Equals));
     
    14171417                                        AttListEnd = simd_or(AttListEnd,simd_and(AttValFollow,AttListDelim));
    14181418                                        AttNameStart = simd_andc(AttValFollow,AttListDelim);
    1419                                         carry_set_0.carryDequeueEnqueue(8,1);
     1419                                        carry_set_0.carryDequeueEnqueue(8, 1);
    14201420                                }
    14211421                                ParseError = simd_or(ParseError,simd_and(AttValFollow,AttNameStart));
    14221422                                while (bitblock::any(simd_and(AttNameStart,EOF_mask)))
    14231423                                {
    1424                                         CarryDeclare(carry_set_1,7,0);
     1424                                        CarryDeclare(carry_set_1, 7, 0);
    14251425                                        ParseError = simd_or(ParseError,simd_andc(AttNameStart,lex.NameScan));
    14261426                                        tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts,AttNameStart);
     
    14661466                                        }
    14671467                                        ParseError = simd_or(ParseError,simd_and(AttValFollow,AttNameStart));
    1468                                         LocalCarryCombine(carry_set_0,carry_set_1,2,7);
     1468                                        LocalCarryCombine(carry_set_0, carry_set_1, 2, 7);
    14691469                                }
    14701470                        }
    14711471                        else
    14721472                        {
    1473                                 carry_set_0.carryDequeueEnqueue(2,7);
     1473                                carry_set_0.carryDequeueEnqueue(2, 7);
    14741474                        }
    14751475                }
     
    14781478                        AttListEnd = simd_and(tag_Callouts.ElemName_ends,AttListDelim);
    14791479                        ParseError = simd_or(ParseError,simd_andc(tag_Callouts.ElemName_ends,AttListDelim));
    1480                         carry_set_0.carryDequeueEnqueue(1,8);
     1480                        carry_set_0.carryDequeueEnqueue(1, 8);
    14811481                }
    14821482                BitBlock STagEnds;
     
    14921492                else
    14931493                {
    1494                         carry_set_0.carryDequeueEnqueue(11,1);
     1494                        carry_set_0.carryDequeueEnqueue(11, 1);
    14951495                }
    14961496                ParseError = simd_or(ParseError,simd_andc(EndTagEnds,lex.RAngle));
    14971497                if (bitblock::any(ParseError))
    14981498                {
    1499                         assert_0_error(ParseError,"Tag parsing error found");
     1499                        assert_0_error(ParseError, "Tag parsing error found");
    15001500                }
    15011501                carry_set_0.getCarry(12) = bitblock::srli<127>(pablo_blk_SpanUpTo(tag_Callouts.AttVal_starts,tag_Callouts.AttVal_ends,carry_set_0.getCarry(12),tag_Callouts.AttVal_spans));
     
    15071507        }
    15081508       
    1509         CarryDeclare(carry_set_0,13,0);
     1509        CarryDeclare(carry_set_0, 13, 0);
    15101510};
    15111511 
     
    15161516        }
    15171517       
    1518         IDISA_INLINE void do_block(struct Lex & lex,struct Marker & marker,struct Ref_Callouts & ref_Callouts)
     1518        IDISA_INLINE void do_block(struct Lex & lex, struct Marker & marker, struct Ref_Callouts & ref_Callouts)
    15191519        {
    15201520                ref_Callouts.GenRef_starts = simd<1>::constant<0>();
     
    15521552                        if (bitblock::any(simd_or(simd_or(ref_error1,ref_error2),ref_error3)))
    15531553                        {
    1554                                 assert_0_error(simd_or(simd_or(ref_error1,ref_error2),ref_error3),"Reference error found");
     1554                                assert_0_error(simd_or(simd_or(ref_error1,ref_error2),ref_error3), "Reference error found");
    15551555                        }
    15561556                }
    15571557                else
    15581558                {
    1559                         carry_set_0.carryDequeueEnqueue(0,6);
     1559                        carry_set_0.carryDequeueEnqueue(0, 6);
    15601560                }
    15611561                carry_set_0.carryAdjust(6);
    15621562        }
    15631563       
    1564         void do_final_block(struct Lex & lex,struct Marker & marker,struct Ref_Callouts & ref_Callouts,BitBlock & EOF_mask)
     1564        void do_final_block(struct Lex & lex, struct Marker & marker, struct Ref_Callouts & ref_Callouts, BitBlock & EOF_mask)
    15651565        {
    15661566                ref_Callouts.GenRef_starts = simd<1>::constant<0>();
     
    15981598                        if (bitblock::any(simd_or(simd_or(ref_error1,ref_error2),ref_error3)))
    15991599                        {
    1600                                 assert_0_error(simd_or(simd_or(ref_error1,ref_error2),ref_error3),"Reference error found");
     1600                                assert_0_error(simd_or(simd_or(ref_error1,ref_error2),ref_error3), "Reference error found");
    16011601                        }
    16021602                }
    16031603                else
    16041604                {
    1605                         carry_set_0.carryDequeueEnqueue(0,6);
     1605                        carry_set_0.carryDequeueEnqueue(0, 6);
    16061606                }
    16071607        }
     
    16121612        }
    16131613       
    1614         CarryDeclare(carry_set_0,6,0);
     1614        CarryDeclare(carry_set_0, 6, 0);
    16151615};
    16161616 
     
    16211621        }
    16221622       
    1623         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)
     1623        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)
    16241624        {
    16251625                BitBlock PI_names;
     
    16631663                if (bitblock::any(simd_or(simd_or(simd_or(void_prefix_err,local_part_err),colon2_err),ncname_err)))
    16641664                {
    1665                         assert_0_error(simd_or(simd_or(simd_or(void_prefix_err,local_part_err),colon2_err),ncname_err),"name syntax error");
     1665                        assert_0_error(simd_or(simd_or(simd_or(void_prefix_err,local_part_err),colon2_err),ncname_err), "name syntax error");
    16661666                }
    16671667                check_streams.non_ascii_name_starts = simd_andc(name_start,lex.ASCII_name_start);
     
    16701670        }
    16711671       
    1672         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)
     1672        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)
    16731673        {
    16741674                BitBlock PI_names;
     
    17121712                if (bitblock::any(simd_or(simd_or(simd_or(void_prefix_err,local_part_err),colon2_err),ncname_err)))
    17131713                {
    1714                         assert_0_error(simd_or(simd_or(simd_or(void_prefix_err,local_part_err),colon2_err),ncname_err),"name syntax error");
     1714                        assert_0_error(simd_or(simd_or(simd_or(void_prefix_err,local_part_err),colon2_err),ncname_err), "name syntax error");
    17151715                }
    17161716                check_streams.non_ascii_name_starts = simd_andc(name_start,lex.ASCII_name_start);
     
    17231723        }
    17241724       
    1725         CarryDeclare(carry_set_0,9,0);
     1725        CarryDeclare(carry_set_0, 9, 0);
    17261726};
    17271727 
     
    17321732        }
    17331733       
    1734         IDISA_INLINE void do_block(struct Marker & marker,struct Tag_Callouts & tag_Callouts,struct Check_streams & check_streams)
     1734        IDISA_INLINE void do_block(struct Marker & marker, struct Tag_Callouts & tag_Callouts, struct Check_streams & check_streams)
    17351735        {
    17361736                if (bitblock::any(simd_andc(marker.CD_closer,tag_Callouts.AttVal_spans)))
    17371737                {
    1738                         assert_0_error(simd_andc(marker.CD_closer,tag_Callouts.AttVal_spans),"Error: ]]> in text");
     1738                        assert_0_error(simd_andc(marker.CD_closer,tag_Callouts.AttVal_spans), "Error: ]]> in text");
    17391739                }
    17401740                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);
     
    17431743        }
    17441744       
    1745         void do_final_block(struct Marker & marker,struct Tag_Callouts & tag_Callouts,struct Check_streams & check_streams,BitBlock & EOF_mask)
     1745        void do_final_block(struct Marker & marker, struct Tag_Callouts & tag_Callouts, struct Check_streams & check_streams, BitBlock & EOF_mask)
    17461746        {
    17471747                if (bitblock::any(simd_andc(marker.CD_closer,tag_Callouts.AttVal_spans)))
    17481748                {
    1749                         assert_0_error(simd_andc(marker.CD_closer,tag_Callouts.AttVal_spans),"Error: ]]> in text");
     1749                        assert_0_error(simd_andc(marker.CD_closer,tag_Callouts.AttVal_spans), "Error: ]]> in text");
    17501750                }
    17511751                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);
     
    17591759        }
    17601760       
    1761         CarryDeclare(carry_set_0,0,0);
     1761        CarryDeclare(carry_set_0, 0, 0);
    17621762};
    17631763 
  • proto/s2k/trunk/framework/src/toolchain/b2k/lang/B2KBuiltin.java

    r3761 r3798  
    22
    33  import java.util.ArrayList;
    4 import java.util.List;
    5 
    6 import toolchain.b2k.lang.B2KBuiltin;
     4  import java.util.List;
     5  import toolchain.b2k.lang.B2KBuiltin;
    76
    87  public enum B2KBuiltin {
Note: See TracChangeset for help on using the changeset viewer.