Changeset 169


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

UTF-16/32 validation.

Location:
trunk/src
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/bitlex.c

    r133 r169  
    699699
    700700void UTF_16_Lexer::Do_CharsetValidation() {
    701 #ifdef X16HILO_ACCESS
    702         int packs = (buffer_units - 1)/PACKSIZE + 1;
    703         BytePack surrogate_select;
    704         BytePack hi_surrogate;
    705         BytePack lo_surrogate;
    706         BytePack hi_surrogate_pending = simd_const_8(0);
    707         BytePack surrogate_scope;
    708         BytePack u16_surrogate_accum = simd_const_8(0);
    709         BytePack u16_FFFE_FFFF_accum = simd_const_8(0);
    710         BytePack u16_FFFE_FFFF;
    711         for (int pk = 0; pk < packs; pk++) {
    712                 /* UTF-16 code units in the range D800-DBFF and DC00-DFFF are
    713                    reserved for the first and second elements, respectively
    714                    of surrogate pairs.  Validation requires that these values
    715                    only occur in well-formed pairs. */
    716                 surrogate_select = simd_and(x16hi[pk], simd_const_8(0xDC));
    717                 hi_surrogate = simd_eq_8(surrogate_select, simd_const_8(0xD8));
    718                 lo_surrogate = simd_eq_8(surrogate_select, simd_const_8(0xDC));
    719                 surrogate_scope = simd_or(hi_surrogate_pending,
    720                                           sisd_sfli(hi_surrogate, 8));
    721                 u16_surrogate_accum = simd_or(u16_surrogate_accum,
    722                                               simd_xor(surrogate_scope, lo_surrogate));
    723                 hi_surrogate_pending = sisd_sbli(hi_surrogate, 8 * (PACKSIZE-1));
    724                 /* The values FFFE and FFFF are excluded. */
    725                 u16_FFFE_FFFF = simd_eq_8(simd_and(x16hi[pk],
    726                                                    simd_or(x16lo[pk], simd_const_8(1))),
    727                                           simd_const_8(0xFF));
    728                 u16_FFFE_FFFF_accum = simd_or(u16_FFFE_FFFF_accum, u16_FFFE_FFFF);
    729         }
    730         u16_surrogate_accum = simd_or(u16_surrogate_accum, hi_surrogate_pending);
    731         if (bitblock_has_bit(simd_or(u16_surrogate_accum, u16_FFFE_FFFF_accum))) {
    732                 CharSetValidationError("UTF-16");
    733         }
    734 #endif
    735 #ifndef X16HILO_ACCESS
    736         printf("UTF_16_Lexer::Do_CharsetValidation not yet complete; assuming OK.\n");
    737 #endif
    738701};
    739702
    740703
    741704void UCS_2_Lexer::Do_CharsetValidation() {
    742 #ifdef X16HILO_ACCESS
    743         int packs = (buffer_units - 1)/PACKSIZE + 1;
    744         BytePack u16_surrogate_accum = simd_const_8(0);
    745         BytePack u16_FFFE_FFFF_accum = simd_const_8(0);
    746         BytePack u16_FFFE_FFFF;
    747         for (int pk = 0; pk < packs; pk++) {
    748                 /* The high byte of UCS-2 code units cannot be in the range D8-DF.
    749                    This corresponds to the D800-DFFF range of illegal codepoints
    750                    reserved for UTF-16 surrogate pairs. Accumulate the results.
    751                    To check, 0x20 is added to each such octet, mapping the D8-DF
    752                    range to F8-FF and wrapping E0-FF values around.  The max value
    753                    is then accumulated.  */
    754                 u16_surrogate_accum =
    755                         simd_max_8(u16_surrogate_accum,
    756                                    simd_add_8(x16hi[pk], simd_const_8(0x20)));
    757                 /* The values FFFE and FFFF are excluded. */
    758                 u16_FFFE_FFFF = simd_eq_8(simd_and(x16hi[pk],
    759                                                    simd_or(x16lo[pk], simd_const_8(1))),
    760                                           simd_const_8(0xFF));
    761                 u16_FFFE_FFFF_accum = simd_or(u16_FFFE_FFFF_accum, u16_FFFE_FFFF);
    762         }
    763         u16_surrogate_accum = simd_eq_8(simd_or(u16_surrogate_accum, simd_const_8(0x07)),
    764                                         simd_const_8(0xFF));
    765         if (bitblock_has_bit(simd_or(u16_surrogate_accum, u16_FFFE_FFFF_accum)))
    766                 CharSetValidationError("UCS-2");
    767         }
    768 #endif
    769 #ifndef X16HILO_ACCESS
    770         printf("UCS_2_Lexer::Do_CharsetValidation not yet complete; assuming OK.\n");
    771 #endif
    772705};
    773706
    774707
    775708void UTF_32_Lexer::Do_CharsetValidation() {
    776 #ifdef X32BYTEPLEX_ACCESS
    777         int packs = (buffer_units - 1)/PACKSIZE + 1;
    778         BytePack u32hh_accum = simd_const_8(0);
    779         BytePack u32hl_accum = simd_const_8(0);
    780         BytePack u32_surrogate_accum = simd_const_8(0);
    781         BytePack u32_FFFE_FFFF_accum = simd_const_8(0);
    782         BytePack u32_BMP_select;
    783         BytePack u32l_FFFE_FFFF;
    784         for (int pk = 0; pk < packs; pk++) {
    785                 /* There can be no bits set in the high octet; "or" together
    786                    all octet values to check for any bit set. */
    787                 u32hh_accum = simd_or(u32hh_accum, x32hh[pk]);
    788                 /* The second octet has a max value of 0x10, corresponding to the
    789                    maximum Unicode code point value of 0x10FFFF.  Accumulate the
    790                    maximum of all u32hl values observed. */
    791                 u32hl_accum = simd_max_8(u32hl_accum, x32hl[pk]);
    792                 /* The third octet cannot be in the range D8-DF if the second octet
    793                    is 0.  This corresponds to the D800-DFFF range of illegal codepoints
    794                    reserved for UTF-16 surrogate pairs. Accumulate the results.
    795                    To check, 0x20 is added to each such octet, mapping the D8-DF
    796                    range to F8-FF and wrapping E0-FF values around.  The max value
    797                    is then accumulated.  */
    798                 u32_BMP_select = simd_eq_8(x32hl[pk], simd_const_8(0));
    799                 u32_surrogate_accum =
    800                         simd_max_8(u32_surrogate_accum,
    801                                    simd_and(u32_BMP_select,
    802                                             simd_add_8(x32lh[pk], simd_const_8(0x20))));
    803                 /* The low two octets cannot have the value FFFE or FFFF if
    804                    we're in the BMP (second octet is 0). */
    805                 u32l_FFFE_FFFF = simd_eq_8(simd_and(x32lh[pk],
    806                                                     simd_or(x32ll[pk], simd_const_8(1))),
    807                                            simd_const_8(0xFF));
    808                 u32_FFFE_FFFF_accum = simd_or(u32_FFFE_FFFF_accum,
    809                                               simd_and(u32_BMP_select, u32l_FFFE_FFFF));
    810         }
    811         u32hl_accum = simd_gt_8(u32hl_accum, simd_const_8(0x10));
    812         u32_surrogate_accum = simd_eq_8(simd_or(u32_surrogate_accum, simd_const_8(0x07)),
    813                                         simd_const_8(0xFF));
    814         if (bitblock_has_bit(simd_or(simd_or(u32hh_accum, u32hl_accum),
    815                                          simd_or(u32_surrogate_accum, u32_FFFE_FFFF_accum)))) {
    816                 CharSetValidationError("UTF-32");
    817         }
    818 #endif
    819 #ifndef X32BYTEPLEX_ACCESS
    820         printf("UTF_32_Lexer::Do_CharsetValidation not yet complete; assuming OK.\n");
    821 #endif
    822709};
    823710
  • 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;
  • trunk/src/byteplex.h

    r163 r169  
    154154        void PreparePseudoASCII_Stream();
    155155        void AdvanceInputBuffer(int advance_amt);
     156        void Validate_UTF16();
     157        void Validate_UCS2();
    156158        void InitializeBuffer(unsigned char * src, int lgth);
    157159        int UTF8_Length(int name_pos, int lgth);
     
    189191        void PreparePseudoASCII_Stream();
    190192        void AdvanceInputBuffer(int advance_amt);
     193        void Validate_UTF32();
    191194        void InitializeBuffer(unsigned char * src, int lgth);
    192195        int UTF8_Length(int name_pos, int lgth);
  • trunk/src/engine.c

    r168 r169  
    195195        m->SimpleEntity("quot", "\"");
    196196        m->SimpleEntity("apos", "'");   
    197 
     197        m->symbol_table->version = e->version;
    198198
    199199        StrictWellFormedness=false;
     
    252252#endif
    253253        byteplex->DoByteplex();
     254        byteplex->PreparePseudoASCII_Stream();
     255#if defined(PAPI) and defined(CODE_CLOCKING) and (CODE_CLOCKING == BYTEPLEX)
     256        code_clocker->cc_end_interval(buffer_limit_pos);
     257#endif
     258#if defined(PAPI) and defined(CODE_CLOCKING) and (CODE_CLOCKING == BITPLEX)
     259        code_clocker->cc_start_interval();
     260#endif
     261        bitplex->TransposeToBitStreams(byteplex->x8data, blocks_in_buffer);
     262#if defined(PAPI) and defined(CODE_CLOCKING) and (CODE_CLOCKING == BITPLEX)
     263        code_clocker->cc_end_interval(buffer_limit_pos);
     264#endif
     265        lexer->AnalyzeBuffer(bitplex->x8basis, buffer_base_pos, buffer_rel_pos, buffer_limit_pos);
     266#if defined(PAPI) and defined(CODE_CLOCKING) and (CODE_CLOCKING == ADVANCE_BUFFERS)
     267        code_clocker->cc_end_interval(buffer_limit_pos);
     268#endif
     269
     270}
     271
     272template <>
     273inline void ParsingEngine<U16_Buffer>::AdvanceBuffers(){
     274        printf("U16_Buffer validation attempted.\n");
     275#if defined(PAPI) and defined(CODE_CLOCKING) and (CODE_CLOCKING == ADVANCE_BUFFERS)
     276        code_clocker->cc_start_interval();
     277#endif
     278
     279        int advance_amt = text_or_markup_start - buffer_base_pos;
     280        advance_amt &= -PACKSIZE; // maintain alignment
     281        byteplex->AdvanceInputBuffer(advance_amt);
     282        buffer_base_pos += advance_amt;
     283        buffer_rel_pos -= advance_amt;
     284        buffer_limit_pos = min(BUFFER_SIZE, byteplex->units_in_buffer);
     285        int blocks_in_buffer = (buffer_limit_pos + BLOCKSIZE - 1)/BLOCKSIZE;
     286#if defined(PAPI) and defined(CODE_CLOCKING) and (CODE_CLOCKING == BYTEPLEX)
     287        code_clocker->cc_start_interval();
     288#endif
     289        byteplex->DoByteplex();
     290        if (at_UTF_16(entity_Info->encoding)) ((U16_Buffer *) byteplex)->Validate_UTF16();
    254291        byteplex->PreparePseudoASCII_Stream();
    255292#if defined(PAPI) and defined(CODE_CLOCKING) and (CODE_CLOCKING == BYTEPLEX)
  • trunk/src/symtab.c

    r160 r169  
    229229
    230230inline int Symbol_Table::ASCII_Lookup_or_Insert(char * name_ptr, int name_lgth) {
     231
    231232        if (Verify_ASCII(name_ptr, name_lgth)) {
    232233                return UTF8_Lookup_or_Insert(name_ptr, name_lgth);
     
    238239
    239240int Symbol_Table::UTF8_Lookup_or_Insert(char * name, int lgth) {
     241               
    240242        char delim = name[lgth];
    241243        name[lgth] = '\0';
     
    245247        if(nameID == 0){
    246248        #if (not defined(OMISSION)) or (OMISSION != NAME_VALIDATION)
    247                 if (!is_XML11_UTF8_Name(name,lgth))  {
    248                         ShowSyntaxError(NT_Name);
    249                         exit(-1);
     249                if (!is_XML10_UTF8_Name(name,lgth))  {
     250                        if (version == XML_1_1) {
     251                                if (!is_XML11_UTF8_Name(name,lgth))  {
     252                                        ShowSyntaxError(NT_Name);
     253                                        exit(-1);
     254                                }
     255                        }
     256                        else {
     257                                ShowSyntaxError(NT_Name);
     258                                exit(-1);
     259                        }
    250260                }
    251261        #endif
  • trunk/src/symtab.h

    r160 r169  
    6161        int LookupOrInsertReserved();
    6262       
     63        XML_version version;
     64       
    6365private:
    6466        hash_map<const char *, int, hash<const char *>, eqstr > UTF8NameMap;
Note: See TracChangeset for help on using the changeset viewer.