pike.git / src / stralloc.c

version» Context lines:

pike.git/src/stralloc.c:123:    tmp += (1 << 24) - 1;    s_max = tmp;    break;    }    }    }    else    {    switch( str->size_shift )    { -  case 2: s_min = MIN_INT32; s_max=MAX_INT32; break; -  case 1: s_min = 0; s_max = 65535; break; -  case 0: s_min = 0; s_max = 255; break; +  case thirtytwobit: s_min = MIN_INT32; s_max = MAX_INT32; break; +  case sixteenbit: s_min = 0; s_max = 65535; break; +  case eightbit: s_min = 0; s_max = 255; break;    }    }    }    else    {    str->flags |= STRING_CONTENT_CHECKED;       switch( str->size_shift )    { -  case 0: +  case eightbit:    {    p_wchar0 *p = (p_wchar0*)str->str;    int upper = 0, lower = 0;    for( i=0; i<str->len; i++,p++ )    {    /* For 7-bit strings it's easy to check for    * lower/uppercase, so do that here as well.    */    if( *p >= 'A' && *p <= 'Z') upper++;    if( *p >= 'a' && *p <= 'z') lower++;
pike.git/src/stralloc.c:163:    if( !lower )    str->flags |= STRING_IS_UPPERCASE;    if( !upper )    str->flags |= STRING_IS_LOWERCASE;    }    }    str->min = s_min;    str->max = s_max;    break;    -  case 1: +  case sixteenbit:    {    p_wchar1 *p = (p_wchar1*)str->str;    for( i=0; i<str->len; i++,p++ )    {    if( *p > s_max ) s_max = *p;    if( *p < s_min ) s_min = *p;    }    }    str->min = s_min / 256;    str->max = s_max / 256;    break;    -  case 2: +  case thirtytwobit:    {    p_wchar2 *p = (p_wchar2*)str->str;    for( i=0; i<str->len; i++,p++ )    {    if( *p > s_max ) s_max = *p;    if( *p < s_min ) s_min = *p;    }    }    str->min = (unsigned INT32)s_min / (1 << 24);    str->max = (unsigned INT32)s_max / (1 << 24);
pike.git/src/stralloc.c:319:    "range 0..%"PRINTPTRDIFFT"d.\n",    pos, s->len-1);    } else {    Pike_fatal("Attempt to index the empty string with %"PRINTPTRDIFFT"d.\n",    pos);    }    }    return generic_extract(s->str,s->size_shift,pos);   }    - PMOD_EXPORT p_wchar2 generic_extract (const void *str, int size, ptrdiff_t pos) + PMOD_EXPORT p_wchar2 generic_extract(const void *str, enum size_shift size, +  ptrdiff_t pos)   {    switch(size)    { -  case 0: return ((p_wchar0 *)str)[pos]; -  case 1: return ((p_wchar1 *)str)[pos]; -  case 2: return ((p_wchar2 *)str)[pos]; +  case eightbit: return ((p_wchar0 *)str)[pos]; +  case sixteenbit: return ((p_wchar1 *)str)[pos]; +  case thirtytwobit: return ((p_wchar2 *)str)[pos];    }    UNREACHABLE(return 0);   }      static void locate_problem(int (*isproblem)(const struct pike_string *))   {    unsigned INT32 e;    struct pike_string *s;    DM(struct memhdr *yes=alloc_memhdr());    DM(struct memhdr *no=alloc_memhdr());
pike.git/src/stralloc.c:763:    */   struct pike_string *low_end_shared_string(struct pike_string *s)   {    ptrdiff_t len;    size_t h=0;    struct pike_string *s2;      #ifdef PIKE_DEBUG    if (d_flag) {    switch (s->size_shift) { -  case 0: +  case eightbit:    break;    -  case 1: +  case sixteenbit:    if(!find_magnitude1(STR1(s),s->len))    Pike_fatal ("String %p that should have shift 1 really got 0.\n", s);    break;    -  case 2: { +  case thirtytwobit: {    int m = find_magnitude2 (STR2 (s), s->len);    if (m != 2)    Pike_fatal ("String %p that should have shift 2 really got %d.\n",    s, m);    break;    }       default:    Pike_fatal("ARGHEL! size_shift:%d\n", s->size_shift);    }
pike.git/src/stralloc.c:818:   /*    * This function checks if the shift size can be decreased before    * entering the string in the shared string table    */   PMOD_EXPORT struct pike_string *end_shared_string(struct pike_string *s)   {    struct pike_string *s2;       switch(UNLIKELY(s->size_shift))    { -  case 2: +  case thirtytwobit:    switch(find_magnitude2(STR2(s),s->len))    { -  case 0: +  case eightbit:    s2=begin_shared_string(s->len);    convert_2_to_0(STR0(s2),STR2(s),s->len);    free_string(s);    s=s2;    break;    -  case 1: +  case sixteenbit:    s2=begin_wide_shared_string(s->len,1);    convert_2_to_1(STR1(s2),STR2(s),s->len);    free_string(s);    s=s2;    /* Fall though */    }    break;    -  case 1: +  case sixteenbit:    if(!find_magnitude1(STR1(s),s->len))    {    s2=begin_shared_string(s->len);    convert_1_to_0(STR0(s2),STR1(s),s->len);    free_string(s);    s=s2;    }    break;    -  case 0: break; +  case eightbit: break;    }       return low_end_shared_string(s);   }      PMOD_EXPORT struct pike_string *end_and_resize_shared_string(struct pike_string *str, ptrdiff_t len)   {    struct pike_string *tmp;   #ifdef PIKE_DEBUG    if(len > str->len)
pike.git/src/stralloc.c:890:    add_ref(s);    }       return s;   }      PMOD_EXPORT struct pike_string * debug_make_shared_binary_pcharp(const PCHARP str,size_t len)   {    switch(str.shift)    { -  case 0: +  case eightbit:    return make_shared_binary_string((char *)(str.ptr), len); -  case 1: +  case sixteenbit:    return make_shared_binary_string1((p_wchar1 *)(str.ptr), len); -  case 2: +  case thirtytwobit:    return make_shared_binary_string2((p_wchar2 *)(str.ptr), len);    }    UNREACHABLE(return NULL);   }      PMOD_EXPORT struct pike_string * debug_make_shared_pcharp(const PCHARP str)   {    return debug_make_shared_binary_pcharp(str, pcharp_strlen(str));   }   
pike.git/src/stralloc.c:1204:      PMOD_EXPORT void check_string(struct pike_string *s)   {    if(current_do_debug_cycle == last_stralloc_verify)    {    if(debug_findstring(s) != s)    Pike_fatal("Shared string not shared.\n");    }else{       switch (s->size_shift) { -  case 0: +  case eightbit:    break; -  case 1: { +  case sixteenbit: {    ptrdiff_t i;    p_wchar1 *str = STR1 (s);    for (i = 0; i < s->len; i++)    if (str[i] > 0xff)    goto size_shift_check_done;    Pike_fatal ("Shared string is too wide.\n");    } -  case 2: { +  case thirtytwobit: {    ptrdiff_t i;    p_wchar2 *str = STR2 (s);    for (i = 0; i < s->len; i++)    if ((str[i] > 0xffff) || (str[i] < 0))    goto size_shift_check_done;    Pike_fatal ("Shared string is too wide.\n");    }    default:    Pike_fatal ("Invalid size shift %d.\n", s->size_shift);    }
pike.git/src/stralloc.c:1654:       if(min_magnitude(old_value) == a->size_shift &&    min_magnitude(c) < min_magnitude(old_value))    {    /* We *might* need to shrink the string */    struct pike_string *b;    unsigned int size,tmp;       switch(a->size_shift)    { -  case 0: +  case eightbit:    Pike_fatal("Unshrinkable!\n");    -  case 1: +  case sixteenbit:    /* Test if we *actually* can shrink it.. */    if(find_magnitude1(STR1(a),index)) break;    if(find_magnitude1(STR1(a)+index+1,a->len-index-1))    break;       b=begin_shared_string(a->len);    convert_1_to_0((p_wchar0 *)b->str,STR1(a),a->len);    b->str[index]=c;    free_string(a);    return end_shared_string(b);    -  case 2: +  case thirtytwobit:    /* Test if we *actually* can shrink it.. */    size=find_magnitude2(STR2(a),index);    if(size==2) break; /* nope */    tmp=find_magnitude2(STR2(a)+index+1,a->len-index-1);    if(tmp==2) break; /* nope */    size=MAXIMUM(MAXIMUM(size,tmp),min_magnitude(c));       switch(size)    { -  case 0: +  case eightbit:    b=begin_shared_string(a->len);    convert_2_to_0((p_wchar0 *)b->str,STR2(a),a->len);    b->str[index]=c;    free_string(a);    return end_shared_string(b);    -  case 1: +  case sixteenbit:    b=begin_wide_shared_string(a->len,1);    convert_2_to_1((p_wchar1 *)b->str,STR2(a),a->len);    STR1(b)[index]=c;    free_string(a);    return end_shared_string(b);    }    }    }      
pike.git/src/stralloc.c:1946:    find_magnitude1(((p_wchar1*)s->str)+start,len)==1)    || (s->size_shift==2 &&    find_magnitude2(((p_wchar2*)s->str)+start,len)==2)))    {    /* If there is no change of maginute, make a substring. */    return make_shared_substring( s, start, len, s->size_shift );    }       switch(s->size_shift)    { -  case 0: +  case eightbit:    return make_shared_binary_string((char *)STR0(s)+start,len);    -  case 1: +  case sixteenbit:    return make_shared_binary_string1(STR1(s)+start,len);    -  case 2: +  case thirtytwobit:    return make_shared_binary_string2(STR2(s)+start,len);    }    UNREACHABLE(return 0);   }      /*** replace function ***/   typedef char *(* replace_searchfunc)(void *,void *,size_t);   PMOD_EXPORT struct pike_string *string_replace(struct pike_string *str,    struct pike_string *del,    struct pike_string *to)
pike.git/src/stralloc.c:2008:    {    mojt=compile_memsearcher(MKPCHARP_STR(del),    del->len,    str->len,    del);    SET_ONERROR (mojt_uwp, do_free_object, mojt.container);       ret=begin_wide_shared_string(str->len,shift);    switch(str->size_shift)    { -  case 0: f=(replace_searchfunc)mojt.vtab->func0; break; -  case 1: f=(replace_searchfunc)mojt.vtab->func1; break; -  case 2: f=(replace_searchfunc)mojt.vtab->func2; break; +  case eightbit: f=(replace_searchfunc)mojt.vtab->func0; break; +  case sixteenbit: f=(replace_searchfunc)mojt.vtab->func1; break; +  case thirtytwobit: f=(replace_searchfunc)mojt.vtab->func2; break;    }       }else{    INT32 delimeters=0;    mojt=compile_memsearcher(MKPCHARP_STR(del),    del->len,    str->len*2,    del);    SET_ONERROR (mojt_uwp, do_free_object, mojt.container);       switch(str->size_shift)    { -  case 0: f=(replace_searchfunc)mojt.vtab->func0; break; -  case 1: f=(replace_searchfunc)mojt.vtab->func1; break; -  case 2: f=(replace_searchfunc)mojt.vtab->func2; break; +  case eightbit: f=(replace_searchfunc)mojt.vtab->func0; break; +  case sixteenbit: f=(replace_searchfunc)mojt.vtab->func1; break; +  case thirtytwobit: f=(replace_searchfunc)mojt.vtab->func2; break;    }       while((s = f(mojt.data, s, (end-s)>>str->size_shift)))    {    delimeters++;    s+=del->len << str->size_shift;    }       if(!delimeters)    {
pike.git/src/stralloc.c:2267:    } while (!next);    }    return next;   }         PMOD_EXPORT PCHARP MEMCHR_PCHARP(const PCHARP ptr, int chr, ptrdiff_t len)   {    switch(ptr.shift)    { -  case 0: return MKPCHARP(memchr(ptr.ptr,chr,len),0); -  case 1: return MKPCHARP(MEMCHR1((p_wchar1 *)ptr.ptr,chr,len),1); -  case 2: return MKPCHARP(MEMCHR2((p_wchar2 *)ptr.ptr,chr,len),2); +  case eightbit: return MKPCHARP(memchr(ptr.ptr,chr,len),0); +  case sixteenbit: return MKPCHARP(MEMCHR1((p_wchar1 *)ptr.ptr,chr,len),1); +  case thirtytwobit: return MKPCHARP(MEMCHR2((p_wchar2 *)ptr.ptr,chr,len),2);    }    UNREACHABLE(MKPCHARP(0,0));   }      #define DIGIT(x) ( (x)<256 ? hexdecode[x] : 16 )   #define MBASE ('z' - 'a' + 1 + 10)      PMOD_EXPORT long STRTOL_PCHARP(PCHARP str, PCHARP *ptr, int base)   {    /* Note: Code duplication in pcharp_to_svalue_inumber. */
pike.git/src/stralloc.c:2711:    *endptr = nptr;    return 0.0;   }         PMOD_EXPORT p_wchar0 *require_wstring0(const struct pike_string *s,    char **to_free)   {    switch(s->size_shift)    { -  case 0: +  case eightbit:    *to_free=0;    return STR0(s); -  case 1: -  case 2: +  case sixteenbit: +  case thirtytwobit:    return 0;    }    UNREACHABLE(return 0);   }      PMOD_EXPORT p_wchar1 *require_wstring1(const struct pike_string *s,    char **to_free)   {    switch(s->size_shift)    { -  case 0: +  case eightbit:    *to_free=xalloc((s->len+1)*2);    convert_0_to_1((p_wchar1 *)*to_free, STR0(s),s->len+1);    return (p_wchar1 *)*to_free;    -  case 1: +  case sixteenbit:    *to_free=0;    return STR1(s);    -  case 2: +  case thirtytwobit:    return 0;    }    UNREACHABLE(return 0);   }         PMOD_EXPORT p_wchar2 *require_wstring2(const struct pike_string *s,    char **to_free)   {    switch(s->size_shift)    { -  case 0: +  case eightbit:    *to_free=xalloc((s->len+1)*4);    convert_0_to_2((p_wchar2 *)*to_free, STR0(s),s->len+1);    return (p_wchar2 *)*to_free;    -  case 1: +  case sixteenbit:    *to_free=xalloc((s->len+1)*4);    convert_1_to_2((p_wchar2 *)*to_free, STR1(s),s->len+1);    return (p_wchar2 *)*to_free;    -  case 2: +  case thirtytwobit:    *to_free=0;    return STR2(s);    }    UNREACHABLE(return 0);   }      PMOD_EXPORT int wide_isspace(int c)   {    switch(c)    {