pike.git / src / stralloc.c

version» Context lines:

pike.git/src/stralloc.c:18:      #include <errno.h>   #include <float.h>   #include <ctype.h>   #include <math.h>      #ifndef HUGE   #define HUGE HUGE_VAL   #endif /*!HUGE*/    - RCSID("$Id: stralloc.c,v 1.84 2000/07/06 23:25:26 mast Exp $"); + RCSID("$Id: stralloc.c,v 1.85 2000/07/28 17:16:55 hubbe Exp $");      #define BEGIN_HASH_SIZE 997   #define MAX_AVG_LINK_LENGTH 3      /* Experimental dynamic hash length */   #ifndef HASH_PREFIX   static unsigned int HASH_PREFIX=64;   static unsigned int need_more_hash_prefix=0;   #endif   
pike.git/src/stralloc.c:96:    switch(size)    {    case 0: return ((unsigned char *)str)[pos];    case 1: return ((unsigned INT16 *)str)[pos];    case 2: return ((unsigned INT32 *)str)[pos];    }    fatal("Illegal shift size!\n");    return 0;   }    - INLINE unsigned INT32 index_shared_string(struct pike_string *s, int pos) + PMOD_EXPORT INLINE unsigned INT32 index_shared_string(struct pike_string *s, int pos)   {   #ifdef PIKE_DEBUG    if(pos > s->len || pos<0) {    if (s->len) {    fatal("String index %d is out of range [0 - %d]!\n", pos, s->len-1);    } else {    fatal("Attempt to index the empty string with %d!\n", pos);    }    }   #endif    return generic_extract(s->str,s->size_shift,pos);   }    - INLINE void low_set_index(struct pike_string *s, int pos, int value) + PMOD_EXPORT INLINE void low_set_index(struct pike_string *s, int pos, int value)   {   #ifdef PIKE_DEBUG    if(pos > s->len || pos<0)    fatal("string index out of range!\n");       if(pos == s->len && value)    fatal("string zero termination foul!\n");   #endif    switch(s->size_shift)    {    case 0: STR0(s)[pos]=value; break;    case 1: STR1(s)[pos]=value; break;    case 2: STR2(s)[pos]=value; break;    default:    fatal("Illegal shift size!\n");    }   }      #ifdef PIKE_DEBUG - INLINE struct pike_string *debug_check_size_shift(struct pike_string *a,int shift) + PMOD_EXPORT INLINE struct pike_string *debug_check_size_shift(struct pike_string *a,int shift)   {    if(a->size_shift != shift)    fatal("Wrong STRX macro used!\n");    return a;   }   #endif      #define CONVERT(FROM,TO) \   INLINE void PIKE_CONCAT4(convert_,FROM,_to_,TO)(PIKE_CONCAT(p_wchar,TO) *to, const PIKE_CONCAT(p_wchar,FROM) *from, int len) \   { while(--len>=0) *(to++)=*(from++); } \
pike.git/src/stralloc.c:153:         CONVERT(0,1)   CONVERT(0,2)   CONVERT(1,0)   CONVERT(1,2)   CONVERT(2,0)   CONVERT(2,1)       - int generic_compare_strings(const void *a,int alen, int asize, + PMOD_EXPORT int generic_compare_strings(const void *a,int alen, int asize,    const void *b,int blen, int bsize)   {   #define TWO_SIZES(X,Y) (((X)<<2)+(Y))    if(alen != blen) return 0;    if(asize==bsize)    {    return !MEMCMP(a,b,alen<<asize);    }else{    INT32 pos;    for(pos=0;pos< alen ;pos++)    if(generic_extract(a,asize,pos) != generic_extract(b,bsize,pos))    return 0;    return 1;    }   }       - void generic_memcpy(PCHARP to, + PMOD_EXPORT void generic_memcpy(PCHARP to,    PCHARP from,    int len)   {   #ifdef PIKE_DEBUG    if(len<0)    fatal("Cannot copy %d bytes!\n",len);   #endif       switch(TWO_SIZES(from.shift,to.shift))    {
pike.git/src/stralloc.c:214:    break;    case TWO_SIZES(2,1):    convert_2_to_1((p_wchar1 *)to.ptr,(p_wchar2 *)from.ptr,len);    break;    case TWO_SIZES(2,2):    convert_2_to_2((p_wchar2 *)to.ptr,(p_wchar2 *)from.ptr,len);    break;    }   }    - INLINE void pike_string_cpy(PCHARP to, + PMOD_EXPORT INLINE void pike_string_cpy(PCHARP to,    struct pike_string *from)   {    generic_memcpy(to,MKPCHARP_STR(from),from->len);   }         #ifdef PIKE_DEBUG   #ifdef DEBUG_MALLOC   #define DM(X) X   #else
pike.git/src/stralloc.c:327: Inside #if undefined(HASH_PREFIX)
   need_more_hash_prefix++;   /* fprintf(stderr,"depth=%d num_strings=%d need_more_hash_prefix=%d HASH_PREFIX=%d\n",depth,num_strings,need_more_hash_prefix,HASH_PREFIX); */    }else{    if(need_more_hash_prefix)    need_more_hash_prefix--;    }   #endif    return 0; /* not found */   }    - struct pike_string *binary_findstring(const char *foo, INT32 l) + PMOD_EXPORT struct pike_string *binary_findstring(const char *foo, INT32 l)   {    return internal_findstring(foo, l, 0, StrHash(foo,l));   }    - struct pike_string *findstring(const char *foo) + PMOD_EXPORT struct pike_string *findstring(const char *foo)   {    return binary_findstring(foo, strlen(foo));   }      /*    * find a string that is already shared and move it to the head    * of that list in the hastable    */   static struct pike_string *propagate_shared_string(const struct pike_string *s,    int h)
pike.git/src/stralloc.c:404:    if(old_base)    free((char *)old_base);   }         /*** Make new strings ***/      /* note that begin_shared_string expects the _exact_ size of the string,    * not the maximum size    */ - struct pike_string *debug_begin_shared_string(int len) + PMOD_EXPORT struct pike_string *debug_begin_shared_string(int len)   {    struct pike_string *t;   #ifdef PIKE_DEBUG    extern int d_flag;    if(d_flag>10)    verify_shared_strings_tables();   #endif    t=(struct pike_string *)xalloc(len + sizeof(struct pike_string));    t->str[len]=0;    t->len=len;
pike.git/src/stralloc.c:464: Inside #if undefined(HASH_PREFIX)
      tmp2->next=base_table[h2]; /* and re-hash */    base_table[h2]=tmp2;    }    }    full_hash_value=save_full_hash_value;    }   #endif   }    - struct pike_string *debug_begin_wide_shared_string(int len, int shift) + PMOD_EXPORT struct pike_string *debug_begin_wide_shared_string(int len, int shift)   {    struct pike_string *t;   #ifdef PIKE_DEBUG    extern int d_flag;    if(d_flag>10)    verify_shared_strings_tables();   #endif    t=(struct pike_string *)xalloc((len<<shift) + sizeof(struct pike_string));    t->len=len;    t->size_shift=shift;    low_set_index(t,len,0);    return t;   }      /*    * This function assumes that the shift size is already the minimum it    * can be.    */ - struct pike_string *low_end_shared_string(struct pike_string *s) + PMOD_EXPORT struct pike_string *low_end_shared_string(struct pike_string *s)   {    int len,h;    struct pike_string *s2;       len=s->len;    h=do_hash(s);    s2=internal_findstring(s->str,len,s->size_shift,h);   #ifdef PIKE_DEBUG    if(s2==s)    fatal("end_shared_string called twice! (or something like that)\n");
pike.git/src/stralloc.c:513:    add_ref(s);       return s;      }      /*    * This function checks if the shift size can be decreased before    * entering the string in the shared string table    */ - struct pike_string *end_shared_string(struct pike_string *s) + PMOD_EXPORT struct pike_string *end_shared_string(struct pike_string *s)   {    struct pike_string *s2;       switch(s->size_shift)    {    default:    fatal("ARGHEL! size_shift:%d\n", s->size_shift);       case 2:    switch(find_magnitude2(STR2(s),s->len))
pike.git/src/stralloc.c:558:    }    break;       case 0: break;    }       return low_end_shared_string(s);   }       - struct pike_string * debug_make_shared_binary_string(const char *str,int len) + PMOD_EXPORT struct pike_string * debug_make_shared_binary_string(const char *str,int len)   {    struct pike_string *s;    int h=StrHash(str,len);       s = internal_findstring(str,len,0,h);    if (!s)    {    s=begin_shared_string(len);    MEMCPY(s->str, str, len);    link_pike_string(s, h);    }       add_ref(s);       return s;   }    - struct pike_string * debug_make_shared_binary_pcharp(const PCHARP str,int len) + PMOD_EXPORT struct pike_string * debug_make_shared_binary_pcharp(const PCHARP str,int len)   {    switch(str.shift)    {    case 0:    return make_shared_binary_string((char *)(str.ptr), len);    case 1:    return make_shared_binary_string1((p_wchar1 *)(str.ptr), len);    case 2:    return make_shared_binary_string2((p_wchar2 *)(str.ptr), len);    default:    fatal("Unknown string width!\n");    }    /* NOT REACHED */    return NULL; /* Keep the compiler happy */   }    - struct pike_string * debug_make_shared_pcharp(const PCHARP str) + PMOD_EXPORT struct pike_string * debug_make_shared_pcharp(const PCHARP str)   {    return debug_make_shared_binary_pcharp(str, pcharp_strlen(str));   }    - struct pike_string * debug_make_shared_binary_string0(const p_wchar0 *str,int len) + PMOD_EXPORT struct pike_string * debug_make_shared_binary_string0(const p_wchar0 *str,int len)   {    return debug_make_shared_binary_string((const char *)str, len);   }    - struct pike_string * debug_make_shared_binary_string1(const p_wchar1 *str,int len) + PMOD_EXPORT struct pike_string * debug_make_shared_binary_string1(const p_wchar1 *str,int len)   {    struct pike_string *s;    int h;       if(!find_magnitude1(str,len))    {    /* Wrong size, convert */    s=begin_shared_string(len);    convert_1_to_0(STR0(s),str,len);    return end_shared_string(s);
pike.git/src/stralloc.c:631:    s=begin_wide_shared_string(len,1);    MEMCPY(s->str, str, len<<1);    link_pike_string(s, h);    }       add_ref(s);       return s;   }    - struct pike_string * debug_make_shared_binary_string2(const p_wchar2 *str,int len) + PMOD_EXPORT struct pike_string * debug_make_shared_binary_string2(const p_wchar2 *str,int len)   {    struct pike_string *s;    int h;       switch(find_magnitude2(str,len))    {    case 0:    /* Wrong size, convert */    s=begin_shared_string(len);    convert_2_to_0(STR0(s),str,len);
pike.git/src/stralloc.c:666:    s=begin_wide_shared_string(len,2);    MEMCPY(s->str, str, len<<2);    link_pike_string(s, h);    }       add_ref(s);       return s;   }    - struct pike_string *debug_make_shared_string(const char *str) + PMOD_EXPORT struct pike_string *debug_make_shared_string(const char *str)   {    return make_shared_binary_string(str, strlen(str));   }    - struct pike_string *debug_make_shared_string0(const p_wchar0 *str) + PMOD_EXPORT struct pike_string *debug_make_shared_string0(const p_wchar0 *str)   {    return debug_make_shared_string((const char *)str);   }    - struct pike_string *debug_make_shared_string1(const p_wchar1 *str) + PMOD_EXPORT struct pike_string *debug_make_shared_string1(const p_wchar1 *str)   {    INT32 len;    for(len=0;str[len];len++);    return debug_make_shared_binary_string1(str,len);   }    - struct pike_string *debug_make_shared_string2(const p_wchar2 *str) + PMOD_EXPORT struct pike_string *debug_make_shared_string2(const p_wchar2 *str)   {    INT32 len;    for(len=0;str[len];len++);    return debug_make_shared_binary_string2(str,len);   }      /*** Free strings ***/    - void unlink_pike_string(struct pike_string *s) + PMOD_EXPORT void unlink_pike_string(struct pike_string *s)   {    unsigned int h=s->hval % htable_size;    propagate_shared_string(s,h);    base_table[h]=s->next;   #ifdef PIKE_DEBUG    s->next=(struct pike_string *)-1;   #endif    num_strings--;   }    - void do_free_string(struct pike_string *s) + PMOD_EXPORT void do_free_string(struct pike_string *s)   {    if (s)    free_string(s);   }    - void really_free_string(struct pike_string *s) + PMOD_EXPORT void really_free_string(struct pike_string *s)   {   #ifdef PIKE_DEBUG    extern int d_flag;    if (d_flag) {    if (s->refs) {    fatal("Freeing string with references!\n");    }    if(d_flag > 2)    {    if(s->next == (struct pike_string *)-1)
pike.git/src/stralloc.c:731: Inside #if defined(PIKE_DEBUG)
      if(((long)s->next) & 1)    fatal("Freeing shared string again, memory corrupt or other bug!\n");    }    }   #endif    unlink_pike_string(s);    debug_free((char *)s,DMALLOC_LOCATION(),1);   }    - void debug_free_string(struct pike_string *s) + PMOD_EXPORT void debug_free_string(struct pike_string *s)   {    if(--s->refs<=0)    really_free_string(s);   }         /*    * String table status    */   struct pike_string *add_string_status(int verbose)
pike.git/src/stralloc.c:794:    sprintf(b,"Searches: %ld Average search length: %6.3f\n",    (long)num_str_searches, (double)search_len / num_str_searches);    my_strcat(b);   */    return free_buf();   }      /*** PIKE_DEBUG ***/   #ifdef PIKE_DEBUG    - void check_string(struct pike_string *s) + PMOD_EXPORT void check_string(struct pike_string *s)   {    do_hash(s);    if(full_hash_value != s->hval)    {    locate_problem(wrong_hash);    fatal("Hash value changed?\n");    }       if(debug_findstring(s) !=s)    fatal("Shared string not shared.\n");       if(index_shared_string(s,s->len))    {    locate_problem(improper_zero_termination);    fatal("Shared string is not zero terminated properly.\n");    }   }    - void verify_shared_strings_tables(void) + PMOD_EXPORT void verify_shared_strings_tables(void)   {    unsigned INT32 e, h, num=0;    unsigned INT32 orig_full_hash = full_hash_value;    struct pike_string *s;       for(e=0;e<htable_size;e++)    {    h=0;    for(s=base_table[e];s;s=s->next)    {
pike.git/src/stralloc.c:865: Inside #if defined(PIKE_DEBUG)
   fatal("Shared string table is cyclic.\n");    h=0;    }    }    }    if(num != num_strings)    fatal("Num strings is wrong %d!=%d\n",num,num_strings);    full_hash_value = orig_full_hash;   }    - int safe_debug_findstring(struct pike_string *foo) + PMOD_EXPORT int safe_debug_findstring(struct pike_string *foo)   {    unsigned INT32 e;    if(!base_table) return 0;    for(e=0;e<htable_size;e++)    {    struct pike_string *p;    for(p=base_table[e];p;p=p->next)    if(p==foo) return 1;    }    return 0;   }    - struct pike_string *debug_findstring(const struct pike_string *foo) + PMOD_EXPORT struct pike_string *debug_findstring(const struct pike_string *foo)   {    struct pike_string *tmp;    tmp=propagate_shared_string(foo, foo->hval % htable_size);      #if 0    if(!tmp)    {    unsigned INT32 e;    struct pike_string *tmp2;    fprintf(stderr,"String %p %ld %ld %s\n",
pike.git/src/stralloc.c:921: Inside #if defined(PIKE_DEBUG) and #if 0
   fprintf(stderr,"String found in hashbin %ld (not %ld)\n",    (long)e,    (long)(foo->hval % htable_size));    }    }    }   #endif    return tmp;   }    - void debug_dump_pike_string(struct pike_string *s, INT32 max) + PMOD_EXPORT void debug_dump_pike_string(struct pike_string *s, INT32 max)   {    INT32 e;    fprintf(stderr,"0x%p: %ld refs, len=%ld, size_shift=%d, hval=%lux (%lx)\n",    s,    (long)s->refs,    (long)s->len,    s->size_shift,    (unsigned long)s->hval,    (unsigned long)StrHash(s->str, s->len));    fprintf(stderr," \"");
pike.git/src/stralloc.c:974: Inside #if defined(PIKE_DEBUG)
   for(p=base_table[e];p;p=p->next)    debug_dump_pike_string(p, 70);   }      #endif         /*** String compare functions ***/      /* does not take locale into account */ - int low_quick_binary_strcmp(char *a,INT32 alen, + PMOD_EXPORT int low_quick_binary_strcmp(char *a,INT32 alen,    char *b,INT32 blen)   {    int tmp;    if(alen > blen)    {    tmp=MEMCMP(a, b, blen);    if(tmp) return tmp;    return 1;    }else if(alen < blen){    tmp=MEMCMP(a, b, alen);    if(tmp) return tmp;    return -1;    }else{    return MEMCMP(a, b, alen);    }   }         /* does not take locale into account */ - int generic_quick_binary_strcmp(const char *a,INT32 alen, int asize, + PMOD_EXPORT int generic_quick_binary_strcmp(const char *a,INT32 alen, int asize,    const char *b,INT32 blen, int bsize)   {    if(!asize && !bsize)    {    int tmp;    if(alen > blen)    {    tmp=MEMCMP(a, b, blen);    if(tmp) return tmp;    return 1;
pike.git/src/stralloc.c:1024:    for(pos=0;pos< MINIMUM(alen,blen) ;pos++)    {    INT32 ac=generic_extract(a,asize,pos);    INT32 bc=generic_extract(b,bsize,pos);    if(ac-bc) return ac-bc;    }    return alen-blen;    }   }    - int c_compare_string(struct pike_string *s, char *foo, int len) + PMOD_EXPORT int c_compare_string(struct pike_string *s, char *foo, int len)   {    return s->len == len && s->size_shift == 0 && !MEMCMP(s->str,foo,len);   }      #ifndef HAVE_STRCOLL   /* No locale function available */ - static int low_binary_strcmp(char *a,INT32 alen, + int low_binary_strcmp(char *a,INT32 alen,    char *b,INT32 blen)   {    low_quick_binary_strcmp(a,alen,b,blen);   }   #else      /* takes locale into account */   static int low_binary_strcmp(char *a,INT32 alen,    char *b,INT32 blen)   {
pike.git/src/stralloc.c:1061:    blen-=tmp;    }    if(alen==blen) return 0;    if(alen > blen) return 1;    return -1;   }   #endif      /* Does not take locale into account */    - int my_quick_strcmp(struct pike_string *a,struct pike_string *b) + PMOD_EXPORT int my_quick_strcmp(struct pike_string *a,struct pike_string *b)   {    if(a==b) return 0;       return generic_quick_binary_strcmp(a->str, a->len, a->size_shift,    b->str, b->len, b->size_shift);   }      /* Does take locale into account */ - int my_strcmp(struct pike_string *a,struct pike_string *b) + PMOD_EXPORT int my_strcmp(struct pike_string *a,struct pike_string *b)   {    if(a==b) return 0;       switch(TWO_SIZES(a->size_shift,b->size_shift))    {    case TWO_SIZES(0,0):    return low_binary_strcmp(a->str,a->len,b->str,b->len);       default:    {
pike.git/src/stralloc.c:1107: Inside #if defined(HAVE_STRCOLL)
   return tmp;    }else   #endif    if(ac-bc) return ac-bc;    }    return a->len - b->len;    }    }   }    - struct pike_string *realloc_unlinked_string(struct pike_string *a, INT32 size) + PMOD_EXPORT struct pike_string *realloc_unlinked_string(struct pike_string *a, INT32 size)   {    struct pike_string *r;    r=(struct pike_string *)realloc((char *)a,    sizeof(struct pike_string)+    ((size+1)<<a->size_shift)); /* FIXME !! */       if(!r)    {    r=begin_shared_string(size);    MEMCPY(r->str, a->str, a->len<<a->size_shift);    free((char *)a);    }       r->len=size;    low_set_index(r,size,0);    return r;   }      /* Returns an unlinked string ready for end_shared_string */ - struct pike_string *realloc_shared_string(struct pike_string *a, INT32 size) + PMOD_EXPORT struct pike_string *realloc_shared_string(struct pike_string *a, INT32 size)   {    struct pike_string *r;    if(a->refs==1)    {    unlink_pike_string(a);    return realloc_unlinked_string(a, size);    }else{    r=begin_wide_shared_string(size,a->size_shift);    MEMCPY(r->str, a->str, a->len<<a->size_shift);    free_string(a);    return r;    }   }    - struct pike_string *new_realloc_shared_string(struct pike_string *a, INT32 size, int shift) + PMOD_EXPORT struct pike_string *new_realloc_shared_string(struct pike_string *a, INT32 size, int shift)   {    struct pike_string *r;    if(shift == a->size_shift) return realloc_shared_string(a,size);       r=begin_wide_shared_string(size,shift);    pike_string_cpy(MKPCHARP_STR(r),a);    free_string(a);    return r;   }         /* Modify one index in a shared string    * Not suitable for building new strings or changing multiple characters    * within a string!    *    * Phew, this function become complicated when I inserted magic for wide    * characters...    */ - struct pike_string *modify_shared_string(struct pike_string *a, + PMOD_EXPORT struct pike_string *modify_shared_string(struct pike_string *a,    INT32 index,    INT32 c)   {    INT32 old_value;   #ifdef PIKE_DEBUG    if(index<0 || index>=a->len)    fatal("Index out of range in modify_shared_string()\n");   #endif      
pike.git/src/stralloc.c:1297:    struct pike_string *r;    r=begin_wide_shared_string(a->len,a->size_shift);    MEMCPY(r->str, a->str, a->len << a->size_shift);    low_set_index(r,index,c);    free_string(a);    return end_shared_string(r);    }   }      /*** Add strings ***/ - struct pike_string *add_shared_strings(struct pike_string *a, + PMOD_EXPORT struct pike_string *add_shared_strings(struct pike_string *a,    struct pike_string *b)   {    struct pike_string *ret;    PCHARP tmp;    int target_size=MAXIMUM(a->size_shift,b->size_shift);       ret=begin_wide_shared_string(a->len+b->len,target_size);    tmp=MKPCHARP_STR(ret);    pike_string_cpy(tmp,a);    INC_PCHARP(tmp,a->len);    pike_string_cpy(tmp,b);    return end_shared_string(ret);   }    - struct pike_string *add_and_free_shared_strings(struct pike_string *a, + PMOD_EXPORT struct pike_string *add_and_free_shared_strings(struct pike_string *a,    struct pike_string *b)   {    INT32 alen=a->len;    if(a->size_shift == b->size_shift)    {    a=realloc_shared_string(a,alen + b->len);    MEMCPY(a->str+(alen<<a->size_shift),b->str,b->len<<b->size_shift);    free_string(b);    return end_shared_string(a);    }else{    struct pike_string *ret=add_shared_strings(a,b);    free_string(a);    free_string(b);    return ret;    }   }       - int string_search(struct pike_string *haystack, + PMOD_EXPORT int string_search(struct pike_string *haystack,    struct pike_string *needle,    int start)   {    struct generic_mem_searcher s;    char *r;       if(needle->size_shift > haystack->size_shift)    return -1;       init_generic_memsearcher(&s,
pike.git/src/stralloc.c:1358:       r=(char *)generic_memory_search(&s,    haystack->str+(start<<haystack->size_shift),    haystack->len-start,    haystack->size_shift);       if(!r) return -1;    return (r-haystack->str)>>haystack->size_shift;   }    - struct pike_string *string_slice(struct pike_string *s, + PMOD_EXPORT struct pike_string *string_slice(struct pike_string *s,    INT32 start,    INT32 len)   {   #ifdef PIKE_DEBUG    if(start < 0 || len<0 || start+len>s->len )    {    fatal("string_slice, start = %d, len = %d, s->len = %d\n",start,len,s->len);    }   #endif   
pike.git/src/stralloc.c:1391:    return make_shared_binary_string1(STR1(s)+start,len);       case 2:    return make_shared_binary_string2(STR2(s)+start,len);    }    fatal("Illegal shift size!\n");    return 0;   }      /*** replace function ***/ - struct pike_string *string_replace(struct pike_string *str, + PMOD_EXPORT struct pike_string *string_replace(struct pike_string *str,    struct pike_string *del,    struct pike_string *to)   {    struct pike_string *ret;    char *s,*tmp,*end;    PCHARP r;    int shift;    struct generic_mem_searcher searcher;       if(!str->len)
pike.git/src/stralloc.c:1578:   {    unsigned INT32 e;    if(!base_table) return;    for(e=0;e<htable_size;e++)    {    struct pike_string *p;    for(p=base_table[e];p;p=p->next) gc_is_referenced(p);    }   }    - void init_string_builder(struct string_builder *s, int mag) + PMOD_EXPORT void init_string_builder(struct string_builder *s, int mag)   {    s->malloced=256;    s->s=begin_wide_shared_string(256,mag);    s->s->len=0;    s->known_shift=0;   }      static void string_build_mkspace(struct string_builder *s, int chars, int mag)   {    if(mag > s->s->size_shift)
pike.git/src/stralloc.c:1612:       s->s=(struct pike_string *)realloc((char *)s->s,    sizeof(struct pike_string)+    ((newlen+1)<<s->s->size_shift));    if(!s->s)    fatal("Out of memory.\n");    s->malloced=newlen;    }   }    - void *string_builder_allocate(struct string_builder *s, int chars, int mag) + PMOD_EXPORT void *string_builder_allocate(struct string_builder *s, int chars, int mag)   {    void *ret;    string_build_mkspace(s,chars,mag);    if(chars<0) s->known_shift=0;    ret=s->s->str + (s->s->len<<s->s->size_shift);    s->s->len+=chars;    return ret;   }    - void string_builder_putchar(struct string_builder *s, int ch) + PMOD_EXPORT void string_builder_putchar(struct string_builder *s, int ch)   {    INT32 i;    string_build_mkspace(s,1,min_magnitude(ch));    s->known_shift=MAXIMUM(min_magnitude(ch),s->known_shift);    i=s->s->len++;    low_set_index(s->s,i,ch);   }       - void string_builder_binary_strcat(struct string_builder *s, char *str, INT32 len) + PMOD_EXPORT void string_builder_binary_strcat(struct string_builder *s, char *str, INT32 len)   {    string_build_mkspace(s,len,0);    switch(s->s->size_shift)    {    case 0: convert_0_to_0(STR0(s->s)+s->s->len,(p_wchar0 *)str,len); break;    case 1: convert_0_to_1(STR1(s->s)+s->s->len,(p_wchar0 *)str,len); break;    case 2: convert_0_to_2(STR2(s->s)+s->s->len,(p_wchar0 *)str,len); break;    default:    fatal("Illegal magnitude!\n");    }    s->s->len+=len;   }       - void string_builder_append(struct string_builder *s, + PMOD_EXPORT void string_builder_append(struct string_builder *s,    PCHARP from,    INT32 len)   {    string_build_mkspace(s,len,from.shift);    generic_memcpy(MKPCHARP_STR_OFF(s->s,s->s->len), from, len);    s->s->len+=len;   }    - void string_builder_fill(struct string_builder *s, + PMOD_EXPORT void string_builder_fill(struct string_builder *s,    int howmany,    PCHARP from,    INT32 len,    INT32 offset)   {    INT32 tmp;   #ifdef PIKE_DEBUG    if(len<=0)    fatal("Cannot fill with zero length strings!\n");   #endif
pike.git/src/stralloc.c:1710:    MEMCPY(s->s->str + (s->s->len << s->s->size_shift),    to.ptr,    tmp << s->s->size_shift);    len+=tmp;    howmany-=tmp;    s->s->len+=tmp;    }    }   }    - void string_builder_strcat(struct string_builder *s, char *str) + PMOD_EXPORT void string_builder_strcat(struct string_builder *s, char *str)   {    string_builder_binary_strcat(s,str,strlen(str));   }    - void string_builder_shared_strcat(struct string_builder *s, struct pike_string *str) + PMOD_EXPORT void string_builder_shared_strcat(struct string_builder *s, struct pike_string *str)   {    string_build_mkspace(s,str->len,str->size_shift);       pike_string_cpy(MKPCHARP_STR_OFF(s->s,s->s->len), str);    s->known_shift=MAXIMUM(s->known_shift,str->size_shift);    s->s->len+=str->len;   }       - void reset_string_builder(struct string_builder *s) + PMOD_EXPORT void reset_string_builder(struct string_builder *s)   {    s->known_shift=0;    s->s->len=0;   }    - void free_string_builder(struct string_builder *s) + PMOD_EXPORT void free_string_builder(struct string_builder *s)   {    free((char *)s->s);   }    - struct pike_string *finish_string_builder(struct string_builder *s) + PMOD_EXPORT struct pike_string *finish_string_builder(struct string_builder *s)   {    low_set_index(s->s,s->s->len,0);    if(s->known_shift == s->s->size_shift)    return low_end_shared_string(s->s);    return end_shared_string(s->s);   }    - PCHARP MEMCHR_PCHARP(PCHARP ptr, int chr, int len) + PMOD_EXPORT PCHARP MEMCHR_PCHARP(PCHARP ptr, int chr, int len)   {    switch(ptr.shift)    {    case 0: return MKPCHARP(MEMCHR0(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);    }    fatal("Illegal shift in MEMCHR_PCHARP.\n");    return MKPCHARP(0,0); /* make wcc happy */   }      #define DIGIT(x) (WIDE_ISDIGIT(x) ? (x) - '0' : \    WIDE_ISLOWER(x) ? (x) + 10 - 'a' : (x) + 10 - 'A')   #define MBASE ('z' - 'a' + 1 + 10)    - long STRTOL_PCHARP(PCHARP str, PCHARP *ptr, int base) + PMOD_EXPORT long STRTOL_PCHARP(PCHARP str, PCHARP *ptr, int base)   {    register long val;    register int c;    int xx, neg = 0;       if (ptr) *ptr = str;    if (base < 0 || base > MBASE) return 0;    if (!WIDE_ISALNUM(c = EXTRACT_PCHARP(str)))    {    while (ISSPACE(c))
pike.git/src/stralloc.c:1815:    {    INC_PCHARP(str,1);    c=EXTRACT_PCHARP(str);    if(!(WIDE_ISALNUM(c) && (xx=DIGIT(c)) < base)) break;    val = base * val - xx;    }    if (ptr) *ptr = str;    return (neg ? val : -val);   }    - int string_to_svalue_inumber(struct svalue *r, + PMOD_EXPORT int string_to_svalue_inumber(struct svalue *r,    char * str,    char **ptr,    int base,    int maxlength)   {    PCHARP tmp;    int ret=pcharp_to_svalue_inumber(r,    MKPCHARP(str,0),    &tmp,    base,    maxlength);    if(ptr) *ptr=(char *)tmp.ptr;    return ret;   }    - int wide_string_to_svalue_inumber(struct svalue *r, + PMOD_EXPORT int wide_string_to_svalue_inumber(struct svalue *r,    void * str,    void **ptr,    int base,    int maxlength,    int shift)   {    PCHARP tmp;    int ret=pcharp_to_svalue_inumber(r,    MKPCHARP(str,shift),    &tmp,    base,    maxlength);    if(ptr) *ptr=(char *)tmp.ptr;    return ret;   }    - int pcharp_to_svalue_inumber(struct svalue *r, + PMOD_EXPORT int pcharp_to_svalue_inumber(struct svalue *r,    PCHARP str,    PCHARP *ptr,    int base,    int maxlength)   {    PCHARP str_start;       INT_TYPE xx, neg = 0, is_bignum = 0, implicit_base = 0;    INT_TYPE val;    INT_TYPE c;
pike.git/src/stralloc.c:1983: Inside #if defined(AUTO_BIGNUM)
   convert_stack_top_with_base_to_bignum();    }       *r = *--sp;    }   #endif /* AUTO_BIGNUM */       return 1;   }    - int convert_stack_top_string_to_inumber(int base) + PMOD_EXPORT int convert_stack_top_string_to_inumber(int base)   {    struct svalue r;    int i;       if(sp[-1].type != T_STRING)    error("Cannot convert stack top to integer number.\n");       i=pcharp_to_svalue_inumber(&r, MKPCHARP_STR(sp[-1].u.string), 0, base, 0);       free_string(sp[-1].u.string);    sp[-1] = r;       return i;   }      /* Convert PCHARP to a double. If ENDPTR is not NULL, a pointer to the    character after the last one used in the number is put in *ENDPTR. */ - double STRTOD_PCHARP(PCHARP nptr, PCHARP *endptr) + PMOD_EXPORT double STRTOD_PCHARP(PCHARP nptr, PCHARP *endptr)   {    register PCHARP s;    short int sign;       /* The number so far. */    double num;       int got_dot; /* Found a decimal point. */    int got_digit; /* Seen any digits. */   
pike.git/src/stralloc.c:2149:    return 0.0;       noconv:    /* There was no number. */    if (endptr != NULL)    *endptr = nptr;    return 0.0;   }       - p_wchar0 *require_wstring0(struct pike_string *s, + PMOD_EXPORT p_wchar0 *require_wstring0(struct pike_string *s,    char **to_free)   {    switch(s->size_shift)    {    case 0:    *to_free=0;    return STR0(s);    case 1:    case 2:    return 0;       default:    fatal("Illegal shift size in string.\n");    }    return 0;   }    - p_wchar1 *require_wstring1(struct pike_string *s, + PMOD_EXPORT p_wchar1 *require_wstring1(struct pike_string *s,    char **to_free)   {    switch(s->size_shift)    {    case 0:    *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:
pike.git/src/stralloc.c:2191:    case 2:    return 0;       default:    fatal("Illegal shift size in string.\n");    }    return 0;   }       - p_wchar2 *require_wstring2(struct pike_string *s, + PMOD_EXPORT p_wchar2 *require_wstring2(struct pike_string *s,    char **to_free)   {    switch(s->size_shift)    {    case 0:    *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: