Changeset 169 for trunk/src/byteplex.c


Ignore:
Timestamp:
Jun 24, 2008, 5:30:22 PM (11 years ago)
Author:
lindanl
Message:

UTF-16/32 validation.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/byteplex.c

    r160 r169  
    290290}
    291291
     292void U16_Buffer::Validate_UTF16() {
     293        BytePack surrogate_select;
     294        BytePack hi_surrogate;
     295        BytePack lo_surrogate;
     296        BytePack hi_surrogate_pending = simd_const_8(0);
     297        BytePack surrogate_scope;
     298        BytePack u16_surrogate_error;
     299//      BytePack u16_surrogate_accum = simd_const_8(0);
     300//      BytePack u16_FFFE_FFFF_accum = simd_const_8(0);
     301        BytePack u16_FFFE_FFFF;
     302        for (int pk = 0; pk < packs_in_buffer; pk++) {
     303                /* UTF-16 code units in the range D800-DBFF and DC00-DFFF are
     304                   reserved for the first and second elements, respectively
     305                   of surrogate pairs.  Validation requires that these values
     306                   only occur in well-formed pairs. */
     307                surrogate_select = simd_and(x16hi[pk], simd_const_8(0xDC));
     308                hi_surrogate = simd_eq_8(surrogate_select, simd_const_8(0xD8));
     309                lo_surrogate = simd_eq_8(surrogate_select, simd_const_8(0xDC));
     310                surrogate_scope = simd_or(hi_surrogate_pending,
     311                                          sisd_sfli(hi_surrogate, 8));
     312                                         
     313                u16_surrogate_error = simd_xor(surrogate_scope, lo_surrogate);
     314                hi_surrogate_pending = sisd_sbli(hi_surrogate, 8 * (PACKSIZE-1));
     315                /* The values FFFE and FFFF are excluded. */
     316                u16_FFFE_FFFF = simd_eq_8(simd_and(x16hi[pk],
     317                                                   simd_or(x16lo[pk], simd_const_8(1))),
     318                                          simd_const_8(0xFF));
     319//              u16_FFFE_FFFF_accum = simd_or(u16_FFFE_FFFF_accum, u16_FFFE_FFFF);
     320                if (bitblock_has_bit(simd_or(u16_surrogate_error, u16_FFFE_FFFF))) {
     321                        CharSetValidationError("UTF-16 (relative position reported)",
     322                                                                        pk * PACKSIZE +
     323                                                                        count_forward_zeroes(simd_or(u16_surrogate_error, u16_FFFE_FFFF))/8);
     324                }
     325        }
     326        if (bitblock_has_bit(hi_surrogate_pending)) {
     327                CharSetValidationError("UTF-16", PACKSIZE * packs_in_buffer);
     328        }
     329};
     330
     331
     332void U16_Buffer::Validate_UCS2() {
     333#ifdef X16HILO_ACCESS
     334        int packs = (buffer_units - 1)/PACKSIZE + 1;
     335        BytePack u16_surrogate_accum = simd_const_8(0);
     336        BytePack u16_FFFE_FFFF_accum = simd_const_8(0);
     337        BytePack u16_FFFE_FFFF;
     338        for (int pk = 0; pk < packs; pk++) {
     339                /* The high byte of UCS-2 code units cannot be in the range D8-DF.
     340                   This corresponds to the D800-DFFF range of illegal codepoints
     341                   reserved for UTF-16 surrogate pairs. Accumulate the results.
     342                   To check, 0x20 is added to each such octet, mapping the D8-DF
     343                   range to F8-FF and wrapping E0-FF values around.  The max value
     344                   is then accumulated.  */
     345                u16_surrogate_accum =
     346                        simd_max_8(u16_surrogate_accum,
     347                                   simd_add_8(x16hi[pk], simd_const_8(0x20)));
     348                /* The values FFFE and FFFF are excluded. */
     349                u16_FFFE_FFFF = simd_eq_8(simd_and(x16hi[pk],
     350                                                   simd_or(x16lo[pk], simd_const_8(1))),
     351                                          simd_const_8(0xFF));
     352                u16_FFFE_FFFF_accum = simd_or(u16_FFFE_FFFF_accum, u16_FFFE_FFFF);
     353        }
     354        u16_surrogate_accum = simd_eq_8(simd_or(u16_surrogate_accum, simd_const_8(0x07)),
     355                                        simd_const_8(0xFF));
     356        if (bitblock_has_bit(simd_or(u16_surrogate_accum, u16_FFFE_FFFF_accum)))
     357                CharSetValidationError("UCS-2");
     358        }
     359#endif
     360#ifndef X16HILO_ACCESS
     361        printf("UCS_2_Lexer::Do_CharsetValidation not yet complete; assuming OK.\n");
     362#endif
     363};
     364
     365
     366void U32_Buffer::Validate_UTF32() {
     367#ifdef X32BYTEPLEX_ACCESS
     368        int packs = (buffer_units - 1)/PACKSIZE + 1;
     369        BytePack u32hh_accum = simd_const_8(0);
     370        BytePack u32hl_accum = simd_const_8(0);
     371        BytePack u32_surrogate_accum = simd_const_8(0);
     372        BytePack u32_FFFE_FFFF_accum = simd_const_8(0);
     373        BytePack u32_BMP_select;
     374        BytePack u32l_FFFE_FFFF;
     375        for (int pk = 0; pk < packs; pk++) {
     376                /* There can be no bits set in the high octet; "or" together
     377                   all octet values to check for any bit set. */
     378                u32hh_accum = simd_or(u32hh_accum, x32hh[pk]);
     379                /* The second octet has a max value of 0x10, corresponding to the
     380                   maximum Unicode code point value of 0x10FFFF.  Accumulate the
     381                   maximum of all u32hl values observed. */
     382                u32hl_accum = simd_max_8(u32hl_accum, x32hl[pk]);
     383                /* The third octet cannot be in the range D8-DF if the second octet
     384                   is 0.  This corresponds to the D800-DFFF range of illegal codepoints
     385                   reserved for UTF-16 surrogate pairs. Accumulate the results.
     386                   To check, 0x20 is added to each such octet, mapping the D8-DF
     387                   range to F8-FF and wrapping E0-FF values around.  The max value
     388                   is then accumulated.  */
     389                u32_BMP_select = simd_eq_8(x32hl[pk], simd_const_8(0));
     390                u32_surrogate_accum =
     391                        simd_max_8(u32_surrogate_accum,
     392                                   simd_and(u32_BMP_select,
     393                                            simd_add_8(x32lh[pk], simd_const_8(0x20))));
     394                /* The low two octets cannot have the value FFFE or FFFF if
     395                   we're in the BMP (second octet is 0). */
     396                u32l_FFFE_FFFF = simd_eq_8(simd_and(x32lh[pk],
     397                                                    simd_or(x32ll[pk], simd_const_8(1))),
     398                                           simd_const_8(0xFF));
     399                u32_FFFE_FFFF_accum = simd_or(u32_FFFE_FFFF_accum,
     400                                              simd_and(u32_BMP_select, u32l_FFFE_FFFF));
     401        }
     402        u32hl_accum = simd_gt_8(u32hl_accum, simd_const_8(0x10));
     403        u32_surrogate_accum = simd_eq_8(simd_or(u32_surrogate_accum, simd_const_8(0x07)),
     404                                        simd_const_8(0xFF));
     405        if (bitblock_has_bit(simd_or(simd_or(u32hh_accum, u32hl_accum),
     406                                         simd_or(u32_surrogate_accum, u32_FFFE_FFFF_accum)))) {
     407                CharSetValidationError("UTF-32");
     408        }
     409#endif
     410#ifndef X32BYTEPLEX_ACCESS
     411        printf("UTF_32_Lexer::Do_CharsetValidation not yet complete; assuming OK.\n");
     412#endif
     413};
     414
    292415Byteplex * Byteplex::ByteplexFactory(Entity_Info * e) {
    293416        Byteplex * b;
Note: See TracChangeset for help on using the changeset viewer.