Changeset 40


Ignore:
Timestamp:
Feb 10, 2008, 9:28:05 PM (11 years ago)
Author:
cameron
Message:

fixes

Location:
trunk
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/lib/altivec_simd.h

    r34 r40  
    11/*  Idealized SIMD Operations with Altivec, SSE and MMX versions
    2     Copyright (C) 2006, 2007, 2008, Robert D. Cameron
     2    Copyright (C) 2006, Robert D. Cameron
    33    Licensed to International Characters Inc.
    44       under the Academic Free License version 3.0.
    5 */
     5       October 30, 2006 */
    66
    77/*------------------------------------------------------------*/
     
    171171#define simd_himask_8 vec_splat_u8(-16)
    172172
    173 
    174 
    175173#define simd_const_8(n) \
    176174  ((n) >= -16 && (n) < 15 ? vec_splat_u8(n):\
    177    vec_or(vec_sl(vec_splat_u8((n)>>4), vec_splat_u8(4), vec_splat_u8((n)&15))))
     175   vec_or(vec_sl(vec_splat_u8(((n)>>4)&15), vec_splat_u8(4)), vec_splat_u8((n)&15)))
     176
    178177
    179178#define simd_const_16(n) \
  • trunk/src/bitlex.c

    r39 r40  
    11/*  bitlex - Parabix lexical analysis common routines.
    2     Copyright (c) 2007, Robert D. Cameron.
     2    Copyright (c) 2007, 2008, Robert D. Cameron.
    33    Licensed to the public under the Open Software License 3.0.
    44    Licensed to International Characters, Inc., under the Academic
    55    Free License 3.0.
    66
    7     These are common routines for all ASCII-family character sets.
    8     They are used by the character-set specific Lexer objects
    9     found in the charsets directory.
    107*/
    118
     
    267264        BitBlock Control = simd_const_1(0);
    268265        BitBlock WS = simd_const_1(0);
    269         for (int i = 0; i < data_blocks; i++) {
     266        BitBlock final_block_mask;
     267        for (int i = 0; i < buffer_blocks; i++) {
    270268                Restricted = simd_or(Restricted, simd_andc(Control, WS));
    271269                WS_Control_Blocks<C>(x8basis[i].bit,
     
    274272                parsing_engine_data->item_stream[NonWS][i] = simd_not(WS);
    275273        }
    276         if ((code_units % BLOCKSIZE) != 0)
    277                 Control = simd_andc(Control,
    278                                     sisd_sfl(simd_const_1(1),
    279                                              sisd_from_int(code_units % BLOCKSIZE)));
     274        if ((buffer_units % BLOCKSIZE) != 0) {
     275                final_block_mask = sisd_sfl(simd_const_1(1),
     276                                            sisd_from_int(buffer_units % BLOCKSIZE));
     277                Control = simd_andc(Control, final_block_mask);
     278        }
    280279        Restricted = simd_or(Restricted, simd_andc(Control, WS));
    281280        if (bitblock_has_bit(Restricted)) {
    282                 printf("***Restricted control character in input.\n");
    283                 //exit(-1);
     281                printf("Restricted control character in input.\n");
     282                exit(-1);
    284283        }
    285284};
     
    424423void Lexer<C>::Do_MarkupStreams() {
    425424        LexicalItemBlock lx_blk[BUFFER_BLOCKS];
    426         for (int i = 0; i < data_blocks; i++) {
     425        for (int i = 0; i < buffer_blocks; i++) {
    427426                ComputeLexicalItemBlocks<C>(x8basis[i].bit, lx_blk[i].LexicalItems);
    428427        }
     
    432431#endif
    433432        for (int j = MarkupStart; j < LexicalItemCount; j++) {
    434                 for (int i = 0; i < data_blocks; i++) {
     433                for (int i = 0; i < buffer_blocks; i++) {
    435434                        parsing_engine_data->item_stream[j][i] = lx_blk[i].LexicalItems[j];
    436435                }
    437436        }
    438         for (int i = 0; i < data_blocks; i++) {
     437        for (int i = 0; i < buffer_blocks; i++) {
    439438                parsing_engine_data->item_stream[NameFollow][i] =
    440439                        simd_or(parsing_engine_data->item_stream[NameFollow][i],
     
    457456void ASCII_7_Lexer::Do_CharsetValidation() {
    458457        BitBlock Restricted = simd_const_1(0);
    459         for (int blk = 0; blk < data_blocks; blk++) {
     458        for (int blk = 0; blk < buffer_blocks; blk++) {
    460459                Restricted = simd_or(Restricted, x8basis[blk].bit[0]);
    461460        }
     
    474473void UTF_16_Lexer::Do_CharsetValidation() {
    475474#ifdef X16HILO_ACCESS
    476         int packs = (code_units - 1)/PACKSIZE + 1;
     475        int packs = (buffer_units - 1)/PACKSIZE + 1;
    477476        BytePack surrogate_select;
    478477        BytePack hi_surrogate;
     
    516515void UCS_2_Lexer::Do_CharsetValidation() {
    517516#ifdef X16HILO_ACCESS
    518         int packs = (code_units - 1)/PACKSIZE + 1;
     517        int packs = (buffer_units - 1)/PACKSIZE + 1;
    519518        BytePack u16_surrogate_accum = simd_const_8(0);
    520519        BytePack u16_FFFE_FFFF_accum = simd_const_8(0);
     
    551550void UTF_32_Lexer::Do_CharsetValidation() {
    552551#ifdef X32BYTEPLEX_ACCESS
    553         int packs = (code_units - 1)/PACKSIZE + 1;
     552        int packs = (buffer_units - 1)/PACKSIZE + 1;
    554553        BytePack u32hh_accum = simd_const_8(0);
    555554        BytePack u32hl_accum = simd_const_8(0);
     
    653652        BitBlock Control = simd_const_1(0);
    654653        BitBlock WS = simd_const_1(0);
    655         for (int i = 0; i < data_blocks; i++) {
     654        for (int i = 0; i < buffer_blocks; i++) {
    656655                Restricted = simd_or(Restricted, simd_andc(Control, WS));
    657656                ASCII_7_WS_Control_Blocks_11(x8basis[i].bit, WS, Control);
    658657                parsing_engine_data->item_stream[NonWS][i] = simd_not(WS);
    659658        }
    660         if ((code_units % BLOCKSIZE) != 0)
     659        if ((buffer_units % BLOCKSIZE) != 0)
    661660                Control = simd_andc(Control,
    662661                                    sisd_sfl(simd_const_1(1),
    663                                              sisd_from_int(code_units % BLOCKSIZE)));
     662                                             sisd_from_int(buffer_units % BLOCKSIZE)));
    664663        Restricted = simd_or(Restricted, simd_andc(Control, WS));
    665664        if (bitblock_has_bit(Restricted)) {
     
    712711        BitBlock Control = simd_const_1(0);
    713712        BitBlock WS = simd_const_1(0);
    714         for (int i = 0; i < data_blocks; i++) {
     713        for (int i = 0; i < buffer_blocks; i++) {
    715714                Restricted = simd_or(Restricted, simd_andc(Control, WS));
    716715                EASCII_8_WS_Control_Blocks_11(x8basis[i].bit, WS, Control);
    717716                parsing_engine_data->item_stream[NonWS][i] = simd_not(WS);
    718717        }
    719         if ((code_units % BLOCKSIZE) != 0)
     718        if ((buffer_units % BLOCKSIZE) != 0)
    720719                Control = simd_andc(Control,
    721720                                    sisd_sfl(simd_const_1(1),
    722                                              sisd_from_int(code_units % BLOCKSIZE)));
     721                                             sisd_from_int(buffer_units % BLOCKSIZE)));
    723722        Restricted = simd_or(Restricted, simd_andc(Control, WS));
    724723        if (bitblock_has_bit(Restricted)) {
     
    778777        BitBlock Control = simd_const_1(0);
    779778        BitBlock WS = simd_const_1(0);
    780         for (int i = 0; i < data_blocks; i++) {
     779        for (int i = 0; i < buffer_blocks; i++) {
    781780                Restricted = simd_or(Restricted, simd_andc(Control, WS));
    782781                EBCDIC_WS_Control_Blocks_11(x8basis[i].bit, WS, Control);
    783782                parsing_engine_data->item_stream[NonWS][i] = simd_not(WS);
    784783        }
    785         if ((code_units % BLOCKSIZE) != 0)
     784        if ((buffer_units % BLOCKSIZE) != 0)
    786785                Control = simd_andc(Control,
    787786                                    sisd_sfl(simd_const_1(1),
    788                                              sisd_from_int(code_units % BLOCKSIZE)));
     787                                             sisd_from_int(buffer_units % BLOCKSIZE)));
    789788        Restricted = simd_or(Restricted, simd_andc(Control, WS));
    790789        if (bitblock_has_bit(Restricted)) {
     
    800799void Lexer_Interface::TransposeToBitStreams() {
    801800        BytePack * pseudoASCII_src = &(xml_buf->x8data[lexer_base_pos/PACKSIZE]);
    802         for (int blk = 0; blk < data_blocks; blk++) {
     801        for (int blk = 0; blk < buffer_blocks; blk++) {
    803802                s2p_bytepack(&pseudoASCII_src[blk*8], x8basis[blk].bit);
    804803        }
     
    812811        int abspos = base_pos + rel_pos;
    813812        lexer_base_pos = abspos & (-PACKSIZE); /* align the base_position for lexer*/
    814         int code_units = xml_buf->AvailableUnits(lexer_base_pos);
     813        buffer_units = xml_buf->AvailableUnits(lexer_base_pos);
    815814#ifdef DEBUG
    816         printf("code_units = %i.\n", code_units);
    817 #endif
    818         if (code_units >= BUFFER_SIZE) {
    819                 code_units = BUFFER_SIZE;
     815        printf("buffer_units = %i.\n", buffer_units);
     816#endif
     817        if (buffer_units >= BUFFER_SIZE) {
     818                buffer_units = BUFFER_SIZE;
    820819                final_block_mask = simd_const_1(0);
    821820        }
    822821        else {
    823822                final_block_mask =
    824                         sisd_sfl(simd_const_1(1), sisd_from_int(code_units % BLOCKSIZE));
    825         }
    826         data_blocks = (code_units -1)/BLOCKSIZE + 1;
     823                        sisd_sfl(simd_const_1(1), sisd_from_int(buffer_units % BLOCKSIZE));
     824        }
     825        buffer_blocks = (buffer_units -1)/BLOCKSIZE + 1;
    827826#ifdef DEBUG
    828         printf("Transpose for abspos = %i, lexer_base_pos= %i, data_blocks = %i.\n", abspos, lexer_base_pos, data_blocks);
     827        printf("Transpose for abspos = %i, lexer_base_pos= %i, buffer_blocks = %i.\n", abspos, lexer_base_pos, buffer_blocks);
    829828#endif
    830829
     
    843842        printf("Validation complete.\n");
    844843#endif
    845         if (code_units < BUFFER_SIZE) {
    846                 int lastblk = code_units/BLOCKSIZE;
     844        if (buffer_units < BUFFER_SIZE) {
     845                int lastblk = buffer_units/BLOCKSIZE;
    847846                for (int j = minLexicalItem; j < LexicalItemCount; j++) {
    848847                        parsing_engine_data->item_stream[j][lastblk] =
     
    854853        base_pos = lexer_base_pos;
    855854        rel_pos = abspos - lexer_base_pos;
    856         limit_pos = code_units;
    857 }
    858 
     855        limit_pos = buffer_units;
     856}
     857
  • trunk/src/bitlex.h

    r36 r40  
    7373        BitBlockBasis * x8basis;
    7474        LexicalStreamSet * parsing_engine_data;
    75         int code_units;
    76         int data_blocks;
     75        int buffer_units;
     76        int buffer_blocks;
    7777};
    7878
Note: See TracChangeset for help on using the changeset viewer.