Changeset 267 for trunk/src/bitlex.c


Ignore:
Timestamp:
Mar 20, 2009, 12:18:53 PM (10 years ago)
Author:
ksherdy
Message:

Construct and pass string literals as read only (const char *) types.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/bitlex.c

    r262 r267  
    7373                        else EncodingError("8-bit", e->encoding, lgth);
    7474                case DoubleByte:
    75                         if (e->BOM_units == 1) 
     75                        if (e->BOM_units == 1)
    7676                                if ((lgth == 6) && at_UTF_16(e->encoding))
    7777                                        return new UTF_16_Lexer(e, l);
     
    9292                                else EncodingError("16LE", e->encoding, lgth);
    9393                case QuadByte:
    94                         if (e->BOM_units == 1) 
     94                        if (e->BOM_units == 1)
    9595                                if ((lgth == 6) && at_UTF_32(e->encoding))
    9696                                        return new UTF_32_Lexer(e, l);
     
    274274        BitBlock Control, WS;
    275275        for (int i = 0; i < buffer_blocks; i++) {
    276                 WS_Control_Blocks<C>(x8basis[i].bit, 
     276                WS_Control_Blocks<C>(x8basis[i].bit,
    277277                                     WS,
    278278                                     Control);
     
    287287static inline void ComputeLexicalItemBlocks(BitBlock bit[], BitBlock LexItem[]);
    288288
    289 /* Given the bit[] array of one BitBlock each for the 8 bits of 
     289/* Given the bit[] array of one BitBlock each for the 8 bits of
    290290   an ASCII-family character representation, compute the parallel
    291291   lexical item streams needed for XML parsing.
     
    382382        negated forms ensures that a potential CD_End is not ruled
    383383        out at the block boundary. */
    384         LexItem[CD_End_check] = simd_andc(RBracket, 
     384        LexItem[CD_End_check] = simd_andc(RBracket,
    385385                                          simd_or(sisd_sbli(simd_not(RBracket), 1),
    386386                                                  sisd_sbli(simd_not(RAngle), 2)));
     
    528528  BitBlock temp126 = simd_and(temp115, temp95);
    529529  BitBlock Hex = simd_or(temp125, temp126);
    530        
     530
    531531  LexItem[NonDigit] = simd_not(Digit);
    532532  LexItem[NonHex] = simd_not(Hex);
    533533
    534 #endif 
    535        
     534#endif
     535
    536536        /* Mark potential occurrences of ']]>'  These are all actual
    537537        occurrences of ]]> as well as occurrences of ]] or ] at
     
    539539        negated forms ensures that a potential CD_End is not ruled
    540540        out at the block boundary. */
    541         LexItem[CD_End_check] = simd_andc(RBracket, 
     541        LexItem[CD_End_check] = simd_andc(RBracket,
    542542                                          simd_or(sisd_sbli(simd_not(RBracket), 1),
    543543                                                  sisd_sbli(simd_not(RAngle), 2)));
     
    569569        }
    570570        for (int i = 0; i < buffer_blocks; i++) {
    571                 parsing_engine_data->item_stream[NameFollow][i] = 
     571                parsing_engine_data->item_stream[NameFollow][i] =
    572572                        simd_or(parsing_engine_data->item_stream[NameFollow][i],
    573573                                simd_not(parsing_engine_data->item_stream[NonWS][i]));
     
    581581        /*  UTF-8 sequences may cross block boundaries.  If a
    582582            prefix is found near the end of a block that requires
    583             one or more suffixes in the next block, then 
     583            one or more suffixes in the next block, then
    584584            prefix_pending is set to mark the positions.
    585585            However, at the beginning of the buffer, no suffixes
     
    587587#ifdef TEMPLATED_SIMD_LIB
    588588        BitBlock prefix_pending = simd<1>::constant<0>();
    589         /*  If a suffix is pending, then it may involve one of 
     589        /*  If a suffix is pending, then it may involve one of
    590590            the special case prefixes E0, ED. F0, F4, or the
    591591            EF prefix or EF_BF combination for FFFF/FFFE detection.*/
     
    598598#ifndef TEMPLATED_SIMD_LIB
    599599        BitBlock prefix_pending = simd_const_1(0);
    600         /*  If a suffix is pending, then it may involve one of 
     600        /*  If a suffix is pending, then it may involve one of
    601601            the special case prefixes E0, ED. F0, F4, or the
    602602            EF prefix or EF_BF combination for FFFF/FFFE detection.*/
     
    609609        /* Temporary variables used within the block. */
    610610        BitBlock suffix_required_scope;
    611         BitBlock prefix_E0ED, E0ED_scope, bit5_scope, E0ED_constraint; 
    612         BitBlock prefix_F5FF, prefix_F0F4, F0F4_scope, F0F4_constraint; 
     611        BitBlock prefix_E0ED, E0ED_scope, bit5_scope, E0ED_constraint;
     612        BitBlock prefix_F5FF, prefix_F0F4, F0F4_scope, F0F4_constraint;
    613613        BitBlock X111x, B111x, prefix_EF, BF, EF_BF, EF_scope, EF_BF_scope;
    614614
     
    633633
    634634                /*  Initiate validation for two-byte sequences. */
    635                 error_mask = simd_andc(u8prefix2, 
     635                error_mask = simd_andc(u8prefix2,
    636636                                        simd_or(simd_or(x8basis[i].bit[3], x8basis[i].bit[4]),
    637637                                                simd_or(x8basis[i].bit[5], x8basis[i].bit[6])));
     
    669669                if (bitblock_has_bit(u8prefix3or4)) {
    670670                        /*  Extend validation for errors in three-byte sequences. */
    671                         suffix_required_scope = simd_or(suffix_required_scope, 
     671                        suffix_required_scope = simd_or(suffix_required_scope,
    672672                                                        sisd_sfli(u8prefix3or4, 2));
    673673                        bit5_scope = simd_or(bit5_scope, sisd_sfli(x8basis[i].bit[5], 1));
    674674                        prefix_E0ED = simd_andc(u8prefix3,
    675                                                 simd_or(simd_or(x8basis[i].bit[6], 
     675                                                simd_or(simd_or(x8basis[i].bit[6],
    676676                                                                simd_xor(x8basis[i].bit[4], x8basis[i].bit[7])),
    677677                                                        simd_xor(x8basis[i].bit[4], x8basis[i].bit[5])));
     
    684684                        prefix_pending = simd_or(prefix_pending,
    685685                                                 sisd_sbli(u8prefix3or4, BLOCKSIZE - 2));
    686                         bit5_pending = sisd_sbli(x8basis[i].bit[5], BLOCKSIZE - 1); 
    687                         E0ED_pending = sisd_sbli(prefix_E0ED, BLOCKSIZE - 1); 
     686                        bit5_pending = sisd_sbli(x8basis[i].bit[5], BLOCKSIZE - 1);
     687                        E0ED_pending = sisd_sbli(prefix_E0ED, BLOCKSIZE - 1);
    688688                        EF_pending = sisd_sbli(prefix_EF, BLOCKSIZE - 1);
    689689                        EF_BF_pending = sisd_sbli(EF_BF, BLOCKSIZE - 2);
    690690                        if (bitblock_has_bit(u8prefix4)) {
    691691                                /*  Extend validation for errors in four-byte sequences. */
    692                                 suffix_required_scope = simd_or(suffix_required_scope, 
     692                                suffix_required_scope = simd_or(suffix_required_scope,
    693693                                                                sisd_sfli(u8prefix4, 3));
    694694                                prefix_pending = simd_or(prefix_pending,
    695695                                                         sisd_sbli(u8prefix4, BLOCKSIZE - 3));
    696                                 prefix_F5FF = simd_and(u8prefix4, 
     696                                prefix_F5FF = simd_and(u8prefix4,
    697697                                                       simd_or(x8basis[i].bit[4],
    698698                                                                simd_and(x8basis[i].bit[5],
    699699                                                                        simd_or(x8basis[i].bit[6], x8basis[i].bit[7]))));
    700700                                error_mask = simd_or(error_mask, prefix_F5FF);
    701                                 prefix_F0F4 = simd_andc(u8prefix4, 
    702                                                         simd_or(x8basis[i].bit[4], 
     701                                prefix_F0F4 = simd_andc(u8prefix4,
     702                                                        simd_or(x8basis[i].bit[4],
    703703                                                                simd_or(x8basis[i].bit[6], x8basis[i].bit[7])));
    704704                                F0F4_scope = simd_or(F0F4_scope, sisd_sfli(prefix_F0F4, 1));
     
    708708                E0ED_constraint = simd_xor(bit5_scope, x8basis[i].bit[2]);
    709709                error_mask = simd_or(error_mask, simd_andc(E0ED_scope, E0ED_constraint));
    710                 F0F4_constraint = simd_xor(bit5_scope, 
     710                F0F4_constraint = simd_xor(bit5_scope,
    711711                                           simd_or(x8basis[i].bit[2], x8basis[i].bit[3]));
    712712                error_mask = simd_or(error_mask, simd_andc(F0F4_scope, F0F4_constraint));
     
    985985//              print_bit_block("validation_stream[err_pos/128]", validation_stream[err_pos/128]);
    986986
    987                 CharSetValidationError((char *) entity_Info->encoding, lexer_base_pos + err_pos);
     987                CharSetValidationError((const char *) entity_Info->encoding, lexer_base_pos + err_pos);
    988988        }
    989989#if defined(PAPI) and defined(CODE_CLOCKING) and (CODE_CLOCKING == CHARSET_VALIDATION)
     
    10171017        if (buffer_units < BUFFER_SIZE) {
    10181018#ifdef TEMPLATED_SIMD_LIB
    1019                 BitBlock final_block_mask = 
     1019                BitBlock final_block_mask =
    10201020                        sisd_sfl(simd<1>::constant<1>(), sisd_from_int(buffer_units % BLOCKSIZE));
    10211021#endif
    10221022#ifndef TEMPLATED_SIMD_LIB
    1023                 BitBlock final_block_mask = 
     1023                BitBlock final_block_mask =
    10241024                        sisd_sfl(simd_const_1(1), sisd_from_int(buffer_units % BLOCKSIZE));
    10251025#endif
Note: See TracChangeset for help on using the changeset viewer.