/*
 * FreeAdhocUDF - copyright (c) 2004 - 2006 adhoc dataservice GmbH
 * Christoph Theuring / Peter Mandrella / Georg Horn
 * based on FreeUDFLibC - copyright (c) 1999 Gregory Deatz
 *
 * File Name:	string_functions.c
 * Description: this module contains UDFs to generate and manipulate strings.
 *
 * for exported functions list see string_functions.h
 *
 * Software distributed under the License is distributed on an
 * "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express
 * or implied. See the License for the specific language governing
 * rights and limitations under the License.
 *
*****************************************************************/

#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>
#include <string.h>
#include "md5_global.h"
#include "global.h"
#include "md5.h"
#include "string_functions.h"


/* Implementations */
char * character (c)
     int * c;
{
  char *sz = (char *) MALLOC (2);
  sz[0] = (char) *c;
  sz[1] = (char) 0;

  return sz;
}

char * crlf ()
{
  char * sz = (char *) MALLOC (3);
  sz[0] = (char) 13;
  sz[1] = (char) 10;
  sz[2] = (char) 0;
  return sz;
}

/* ct 2006-02-22 */
char * lf ()
{
  char * sz = (char *) MALLOC (2);
  sz[0] = (char) 10;
  sz[1] = (char) 0;
  return sz;
}

/* ct 2006-10-05 */
char * tab ()
{
  char * sz = (char *) MALLOC (2);
  sz[0] = (char) 9;
  sz[1] = (char) 0;
  return sz;
}

/* ct 2006-10-05 */
char * nbsp ()
{
  char * sz = (char *) MALLOC (2);
  sz[0] = (char) 160;
  sz[1] = (char) 0;
  return sz;
}

/* ct 2006-10-05 */
char * dqm ()
{
  char * sz = (char *) MALLOC (2);
  sz[0] = (char) 34;
  sz[1] = (char) 0;
  return sz;
}

/* ct 2006-10-05 */
char * sqm ()
{
  char * sz = (char *) MALLOC (2);
  sz[0] = (char) 39;
  sz[1] = (char) 0;
  return sz;
}

char * encryptmd5 (sz)
     char * sz;
{
  MD5_CTX context;
  unsigned char digest[16];
  unsigned int len = strlen (sz);
  unsigned int i;
  char * sz_return = (char *) MALLOC (33);

  sz_return[32] = (char) 0;

  /* Compute the hash */
  MD5Init (&context);
  MD5Update (&context, sz, len);
  MD5Final (digest, &context);

  for (i = 0; i < 16; i++)
    sprintf (&sz_return[i*2], "%02x", digest[i]);
  return sz_return;
}

char * left (sz, count)
     char * sz;
     int * count;
{
  int i;
  int len = (strlen(sz) < *count) ? strlen(sz) : *count;
  char * sz_result = (char *) MALLOC (len + 1);
  
  for (i = 0 ; i < len ; i++)
    sz_result[i] = sz[i];
  sz_result[i] = (char) 0;
  
  return sz_result;
}

/*
 * line_wrap algorithm
 * 1. Get the length of the string.
 * 2. If "the rest" of the string is smaller than col_width, just return
 *    it.
 * 3. Otherwise, let 'j' be the end of the column, and decrement j to
 *    a word boundary.
 *    a. Find a word boundary.
 *    b. If j = i (meaning the word is too long), then the word has
 *       has to be chopped.
 */
char * linewrap (sz, index, col_width)
     char * sz;
     int *index, *col_width;
{
  int len = strlen(sz); /* (1) */
  int i = *index;
  int j;
  char * sz_result;
  
  if ((len - i) <= *col_width) /* (2) */
    j = len - i;
  else {
    j = i + *col_width - 1;
    while (j > i && !isspace(sz[j]))
      j--; /* (2a) */
    if (j == i)
      j = *col_width;
    else
      j = j - i + 1;
  }

  sz_result = (char *) MALLOC(j + 1);
  for (i = 0 ; i < j ; i++)
    sz_result[i] = sz[i + *index];
  sz_result[j] = '\0';
  return sz_result;
}

char * ltrim (sz)
     char * sz;
{
  int len = strlen(sz);
  char * sz_result = (char *) MALLOC (len + 1);
  int i;
  
  for (i = 0 ; 
       (i < len) && isspace(sz[i]) ;
       i++) ;

  sprintf(sz_result, "%s", &sz[i]);
  return sz_result;
}

char * lrtrim (sz)
     char * sz;
{
  int len = strlen(sz);
  char * sz_result = (char *) MALLOC (len + 1);
  int i, j, k;

  for (i = 0 ;
       (i < len) && isspace(sz[i]) ;
       i++) ;

  for (j = len - 1 ;
       (j >= 0) && isspace(sz[j]) ;
       j--) ;

  for (k = i ; k <= j ; k++)
    sz_result[k - i] = sz[k];
  sz_result[k - i] = (char) 0;

  return sz_result;
}

char * mid (sz, index, count)
     char * sz;
     int * index;
     int * count;
{
  int len = strlen(sz);
  char * sz_result = (char *) MALLOC (*count + 1);
  int i;

  for (i = *index ; (i < len) && (i - *index < *count) ; i++)
    sz_result[i - *index] = sz[i];
  sz_result[i - *index] = (char) 0;
  
  return sz_result;
}

char * padleft (sz, sz_pad, size)
     char * sz;
     char * sz_pad;
     int * size;
{
  int len_sz = strlen(sz);
  int len_sz_pad = strlen(sz_pad);
  int len_sz_result = *size > len_sz ? *size : len_sz;
  char * sz_result = (char *) MALLOC (len_sz_result + 1);
  int i, j;
  
  sz_result[len_sz_result] = (char) 0;
  
  for (i = len_sz - 1 ; i >= 0 ; i--)
    sz_result[len_sz_result - (len_sz - i - 1) - 1] = sz[i];

  for (i = len_sz_result - (len_sz - i - 1) - 1 ;
       i >= 0 ;
       ) {
    for (j = len_sz_pad - 1 ;
	 (j >= 0) && (i >= 0) ;
	 j--, i--)
      sz_result[i] = sz_pad[j];
  }

  return sz_result;
}

char * padright (sz, sz_pad, size)
     char * sz;
     char * sz_pad;
     int * size;
{
  int len_sz = strlen(sz);
  int len_sz_pad = strlen(sz_pad);
  int len_sz_result = *size > len_sz ? *size : len_sz;
  char * sz_result = (char *) MALLOC (len_sz_result + 1);
  int i, j;
  
  sz_result[len_sz_result] = (char) 0;
  
  for (i = 0 ; i < len_sz ; i++)
    sz_result[i] = sz[i];

  while (i < len_sz_result)
    for (j = 0 ;
	 (j < len_sz_pad) && (i < len_sz_result) ;
	 j++, i++)
      sz_result[i] = sz_pad[j];

  return sz_result;
}

/*
 * replace -
 *   I'm sure there is a *much* more efficient way to do this, but
 *   I don't really care that much because this should be fast enough.
 *   If anybody cares to provide me with some faster/more efficient code,
 *   I'd be glad to include it here.
 *   ct/gh 2006-04-26
 */
char * replace (sz, sz_replace, sz_with)
     char * sz;
     char * sz_replace;
     char * sz_with;
{

  int len_sz = strlen(sz);
  int len_sz_replace = strlen(sz_replace);
  int len_sz_with = strlen(sz_with);
  int i, j;
  int k = 0;
/*  char sz_res[LOC_STRING_SIZE + 1];  */
  char sz_res[32763];
  char * sz_result;

  for (i = 0 ; i < len_sz ; ) {
    if (strncmp(&sz[i], sz_replace, len_sz_replace) == 0) {
      for (j = 0 ; j < len_sz_with ; j++, k++)
	sz_res[k] = sz_with[j];
      i += len_sz_replace;
    }
    else {
      sz_res[k++] = sz[i];
      i++;
    }
  }
  sz_res[k] = (char) 0;
  sz_result = (char *) MALLOC (strlen(sz_res) + 1);
  sprintf(sz_result, "%s", sz_res);
  return sz_result;
}

char * right (sz, count)
     char * sz;
     int * count;
{
  int len = strlen(sz);
  char * sz_result = (char *) MALLOC (*count + 1);
  int i, j;

  for (j = 0, i = (*count > len) ? 0 : len - *count ;
       i < len ; i++, j++)
    sz_result[j] = sz[i];

  sz_result[j] = (char) 0;
  return sz_result;
}

char * rtrim (sz)
     char * sz;
{
  int len = strlen(sz);
  char * sz_result = (char *) MALLOC (len + 1);
  int i, j;
  
  for (i = len - 1 ;
       (i >= 0) && isspace(sz[i]) ;
       i--) ;
  
  for (j = 0 ; j <= i ; j++)
    sz_result[j] = sz[j];
  sz_result[j] = (char) 0;

  return sz_result;
}

char * soundex (sz)
     char * sz;
{
  int i, j;
  char code;
  int len = strlen(sz);
  char * sz_result = (char *) MALLOC (6);
  sz_result[0] = ' ';
  sz_result[1] = '0';
  sz_result[2] = '0';
  sz_result[3] = '0';
  sz_result[4] = '0';
  sz_result[5] = (char) 0;

  if (strlen(sz) != 0) {
    sz_result[0] = toupper(sz[0]);

    j = 1;
    i = 1;
    while (i < len && j < 5) {
      switch(sz[i]) {
      case 'B':
      case 'F':
      case 'P':
      case 'V':
      case 'b':
      case 'f':
      case 'p':
      case 'v':
	code = '1'; break;
      case 'C':
      case 'G':
      case 'J':
      case 'K':
      case 'Q':
      case 'S':
      case 'X':
      case 'Z':
      case 'c':
      case 'g':
      case 'j':
      case 'k':
      case 'q':
      case 's':
      case 'x':
      case 'z':
	code = '2'; break;
      case 'D':
      case 'T':
      case 'd':
      case 't':
	code = '3'; break;
      case 'L':
      case 'l':
	code = '4'; break;
      case 'M':
      case 'N':
      case 'm':
      case 'n':
	code = '5'; break;
      case 'R':
      case 'r':
	code = '6'; break;
      default:
	code = '0';
      }

      if (code != '0' && code != sz_result[j - 1])
	sz_result[j++] = code;
      i++;
    }
  }
  return sz_result;
}


// pm 22.10.05   fixed memory leaks    

char * gsoundex (sz)
     char * sz;
{
  char  TabGruppenVon[37],
        TabGruppenNach[37],
        TabErsVon[25],
        TabErsNach[25],
        GueltigeZeichen1[17],
        GueltigeZeichen2[30];

  int i, j, len;
  char * sz_result;
  char * ps, *pd;
  char sz_subs[3];

  strcpy(TabGruppenVon, "SCSZCZTZTSDSKSQUPFPHUEAEOEEIEYEUAUOU");
  strcpy(TabGruppenNach, "C C C C C C X KVV V Y E Ö AYAYOYA@@ ");
  strcpy(TabErsVon, "ZKGQÄÜIJßFWPT@ÁÀÈÉÚÙÒÓÍÌ");
  strcpy(TabErsNach,"CCCCEYYYSVVBDUAAEEUUOOYY");
  strcpy(GueltigeZeichen1, "ABCDLMNORSUVWXYÖ");
  strcpy(GueltigeZeichen2,"ABCDEFGHIJKLMNOPQRSTUVWXYZÄÖÜ");

  sz_result = upper(sz);

  // ---> folgende Zeilen ersetzen stripstringhold:
  ps = sz_result;
  pd = sz_result;
  while (*ps)
  {
    if (strchr(GueltigeZeichen2,*ps) != NULL)
      *pd++ = *ps;
    ps++;
  }
  *pd = 0;
  // <---

  len = strlen(sz_result);
  for (i=0; i < len; i++)
  {
    strncpy(sz_subs, sz_result + i, 2);  sz_subs[2] = 0;
    j = substr(TabGruppenVon,sz_subs);
    if (j % 2 == 0 && strlen(sz_subs) == 2)
    {
      sz_result[i] = TabGruppenNach[j];
      sz_result[i+1] = TabGruppenNach[j+1];
    }
  }

  len = strlen(sz_result);
  for (i=0; i < len; i++)
  {
    sz_subs[0] = sz_result[i];   sz_subs[1] = 0;
    j = substr(TabErsVon,sz_subs);
    if (j != -1)
      sz_result[i] = TabErsNach[j];
  }

  // ---> folgende Zeilen ersetzen stripstringhold:
  ps = sz_result;
  pd = sz_result;
  while (*ps)
  {
    if (strchr(GueltigeZeichen1,*ps) != NULL)
      *pd++ = *ps;
    ps++;
  }
  *pd = 0;
  // <---

  // ---> folgende Zeilen ersetzen die nachfolgende Schleife
  ps = sz_result;
  pd = sz_result;
  while (*ps)
  {
    if (*ps != *(ps+1))
      *pd++ = *ps;
    ps++;
  }
  *pd = 0;
  // <---

  /*
  for (i= 0; i< strlen(sz_result)-1;i++){
        if (sz_result[i] == sz_result[i+1])
                sz_result = strrm(sz_result,&i);
  }
  */

  return sz_result;
}


int findchar (char c, char *sz);


int stringlength (sz)
     char * sz;
{
    return strlen(sz);
}

char * stripstring (sz, sz_strip_chars)
     char * sz;
     char * sz_strip_chars;
{
  int i;
  int j = 0;
  int len = strlen(sz);
  char * sz_result = (char *) MALLOC (len + 1);

  for (i = 0 ; i < len ; i++)
    if (!findchar(sz[i], sz_strip_chars)) {
      sz_result[j] = sz[i];
      j++;
    }
  sz_result[j] = (char) 0;
  return sz_result;
}

char * stripstringhold (sz, sz_strip_chars)
     char * sz;
     char * sz_strip_chars;
{
  int i;
  int j = 0;
  int len = strlen(sz);
  char * sz_result = (char *) MALLOC (len + 1);

  for (i = 0 ; i < len ; i++)
    if (findchar(sz[i], sz_strip_chars)){
        sz_result[j] = sz[i];
        j++;
    }
  sz_result[j] = (char) 0;
  return sz_result;
}

// pm 16.10.05
char * digits(char *sz)
{
  return stripstringhold(sz,"0123456789");
}


// pm 2004-08-21  rewritten; swapped parameters
int substr (char *sz_search, char *sz)
{
  char * pc = strstr(sz_search,sz);
  if (pc == NULL)
    return -1;
  else
    return pc - sz_search;
}

// gh 2006-03-06 the same as above only swapped parameters
int strsub(char *sz, char *sz_search)
{
    return substr(sz_search, sz);
}


int findchar (c, sz)
     char c;
     char * sz;
{
  int i;
  int len = strlen(sz);

  for (i = 0 ;
       (i < len) && (c != sz[i]) ;
       i++) ;

  if (i == len)
    return 0;
  else
    return -1;
}


static unsigned char StringUpTab [256] =    // ISO-8851-1 to upper case table
           {  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
             16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
             32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
             48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
             64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
             80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
             96,'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O',
            'P','Q','R','S','T','U','V','W','X','Y','Z',123,124,125,126,127,
            128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,
            144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,
            160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,
            176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,
            192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,
            208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,
            192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,
            240,209,210,211,212,213,214,247,216,217,218,219,220,221,222,255 };

static unsigned char StringLoTab [256] =    // ISO-8851-1 to upper case table
           {  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
             16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
             32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
             48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
             64,'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o',
            'p','q','r','s','t','u','v','w','x','y','z', 91, 92, 93, 94, 95,
             96, 97, 98, 99,100,101,102,103,104,105,106,107,108,109,110,111,
            112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,
            128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,
            144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,
            160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,
            176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,
            224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,
            208,241,242,243,244,245,246,215,248,249,250,251,252,253,254,223,
            224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,
            240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255 };


// pm 23.08.04   rewritten
char * lower (char *sz)
{
  int len = strlen(sz);
  char * sz_result = (char *) MALLOC (len + 1);
  int i;

  for (i=0; i <= len; i++)
    sz_result[i] = StringLoTab[(unsigned char)sz[i]];

  return sz_result;
}


// pm 23.08.04   rewritten
char * upper (char *sz)
{
  int len = strlen(sz);
  char * sz_result = (char *) MALLOC (len + 1);
  int i;

  for (i=0; i <= len; i++)
    sz_result[i] = StringUpTab[(unsigned char)sz[i]];

  return sz_result;
}

// pm 21.08.04  special characters enabled
char * propercase (sz)
     char * sz;
{
  int len = strlen(sz);
  char * sz_result = (char *) MALLOC (len + 1);
  int i;
  int word_begin = 1;

  for (i = 0 ; i < len ; i++)
    if ((isalnum(sz[i]) || (unsigned char)(sz[i])>=192) && word_begin) {
      word_begin = 0;
      sz_result[i] = StringUpTab [(unsigned char)sz[i]];
    }
    else if (!isalnum(sz[i]) && (unsigned char)(sz[i])<192) {
      word_begin = 1;
      sz_result[i] = sz[i];
    } else
      sz_result[i] = sz[i];
  sz_result[len] = (char) 0;
  return sz_result;
}

// pm 21.08.04  changed
char * telefonnr (char *sz, int *asterisk)
{
  int len = strlen(sz);
  char * sz_result = (char *) MALLOC (len + 1);
  int m = 0;
  int i;
  int a = *asterisk;
  for (i = 0; i < len; i++)
  {
    if ((sz[i] >= '0' && sz[i] <= '9') || (sz[i] == '+' && m==0))
    {
      sz_result[m] = sz[i];
      m++;
    }
  }

  if (m < a) m = a;
  while (a)
  {
    sz_result[m-a] = '*';
    a--;
  }

  sz_result[m] = (char) 0;
  return sz_result;
}


char * aif (p1, o, p2, t, e)
        char * p1;
        char * o;
        char * p2;
        char * t;
        char * e;
{
        int len = (strlen(t) > strlen(e)) ? strlen(t) : strlen(e);
        char * sz_result = (char *) MALLOC (len+1);
        float w1, w2;
        int erg;
        int ergebnis = 0;

        if (o[0] == 'n'){

                w1 = atof(p1);
                w2 = atof(p2);

                if (strcmp(o,"n=") == 0){
                        if (w1 == w2)
                                ergebnis = 1;
                }
                else if (strcmp(o, "n<>") == 0){
                        if (w1 != w2)
                                ergebnis = 1;
                }
                else if (strcmp(o, "n<") == 0){
                        if (w1 < w2)
                                ergebnis = 1;
                }
                else if (strcmp(o, "n>") == 0){
                        if (w1 > w2)
                                ergebnis = 1;
                }
                else if (strcmp(o, "n<=") == 0){
                        if (w1 <= w2)
                                ergebnis = 1;
                }
                else if (strcmp(o, "n>=") == 0){
                        if (w1 >= w2)
                                ergebnis = 1;
                }
        }
        else{
                erg = strcmp(p1, p2);

                if (strcmp(o,"=") == 0){
                        if (erg == 0)
                                ergebnis = 1;
                }
                else if (strcmp(o, "<>") == 0){
                        if (erg != 0)
                                ergebnis = 1;
                }
                else if (strcmp(o, ">") == 0){
                        if (erg > 0)
                                ergebnis = 1;
                }
                else if (strcmp(o, "<") == 0){
                        if (erg < 0)
                                ergebnis = 1;
                }
                else if (strcmp(o, ">=") == 0){
                        if (erg >= 0)
                                ergebnis = 1;
                }
                else if (strcmp(o, "<=") == 0){
                        if (erg <= 0)
                                ergebnis = 1;
                }
        }


        if (ergebnis == 1){
                strcpy(sz_result,t);
                len = strlen(t);
        }
        else{
                strcpy(sz_result,e);
                len = strlen(e);
        }

        sz_result[len] = (char) 0;

        return sz_result;
}

char * strcopy (sz, indx, anz)
        char * sz;
        int  * indx;
        int  * anz;
{
        int i;


        char * sz_result = (char *) MALLOC (*anz+1);

        if (strlen(sz) < *indx + *anz)
                *anz = strlen(sz) - *indx;

        for (i=*indx; i < *indx + *anz; i++)
                        sz_result[i-*indx] = sz[i];

        sz_result[*anz] = (char) 0;


        return sz_result;
}


char * strrm(sz, indx)
        char * sz;
        int * indx;
{
        int i,j;
        char * sz_result = (char *) MALLOC (strlen(sz));
        j=0;

        for (i=0; i<strlen(sz);i++){
                if (i != *indx){
                        sz_result[j] = sz[i];
                        j++;
                }
        }

        sz_result[strlen(sz)-1] = (char) 0;

        return sz_result;
}



// pm 03.10.05

int equalstring (char *sz1, char *sz2)
{
  return (strcmp(sz1,sz2) == 0);
}


// pm 03.10.05
// gh 02.03.06 edit for äöü

char * findword (char *sz, int *n)
{
  char *sz_result;
  char *last;

  if (*n < 0 || *n >= strlen(sz))
  {
    sz_result = (char *) MALLOC (1);
    *sz_result = 0;
  }
  else
  {
    sz += *n;
    while (*sz != 0 && *sz == ' ')
      sz++;
    last = sz;
    while (*last != 0 && *last != ' ')
      last++;

    sz_result = (char*) MALLOC(last - sz + 1);
    strncpy(sz_result, sz, last-sz);
    sz_result[last-sz] = 0;
  }

  return sz_result;
}


// pm 03.10.05

static int strincomp(char *s1, char *s2, int nmax)
{
    while (*s1 && StringUpTab[(int) *s1] == StringUpTab[(int) *s2] && nmax)
	s1++, s2++, nmax--;

    if (nmax == 0)
	return 0;
    else
	return (StringUpTab[(int) *s1] - StringUpTab[(int) *s2]);
}


// pm 03.10.05
// gh 01.03.06 added do_MALLOC

char *replacestring(char *s, char *subs, char *replby, int *all,
    int *case_insensitive)
{
    return intern_replacestring(s, subs, replby, all, case_insensitive, 1);
}

char *intern_replacestring (char *s, char *subs, char *replby, int *all,
    int *case_insensitive, int do_MALLOC)
{
  char *sz_result;
  char *pd;

  int sl = strlen(s);
  int ssl = strlen(subs);
  int rl = strlen(replby);
  int done = 0;

  if (ssl == 0) {
    sz_result = do_MALLOC ? MALLOC(1) : malloc(1);
    *sz_result = 0;
  } else {
    int len = (sl / ssl + 1) * (rl + 1) + 1;
    sz_result = do_MALLOC ? MALLOC(len) : malloc(len);

    pd = sz_result;
    while (*s)
      if ( (!done || *all) &&
           ((!*case_insensitive && strncmp(s, subs, ssl) == 0) ||
            (*case_insensitive && strincomp(s, subs, ssl) == 0)) ) {
        strcpy(pd, replby);
        pd += rl;
        s += ssl;
        done = 1;
      } else {
        *pd++ = *s++;
      }
    *pd = 0;
  }
  return sz_result;
}


// pm 03.10.05

char * dollarval (double *value)
{
  char * sz_result = (char *) MALLOC (35);

  sprintf(sz_result, "$%.2f", *value);

  return sz_result;
}


// pm 03.10.05

char * euroval (double *value)
{
  char * sz_result = (char *) MALLOC (35);

  sprintf(sz_result, "%.2f EUR", *value);

  return sz_result;
}


// pm 03.10.05
// gh 02.03.06 edit for äöü

char * findnthword (char *sz, int *n)
{
  char * sz_result;
  char * pw;

  while (*sz && *n >= 0)
  {
    while (*sz && *sz == ' ')
      sz++;
    if (*n > 0)
      while (*sz && *sz != ' ')
        sz++;
    (*n)--;
  }

  pw = sz;
  while (*pw && *pw != ' ')
    pw++;

  sz_result = (char *) MALLOC (pw - sz + 1);
  strncpy(sz_result, sz, pw-sz);
  sz_result[pw-sz] = 0;

  return sz_result;
}


// 1999 Gregory Deatz
// pm 03.10.05

#define iswordchar(sz, i, start)       \
          (isalnum(sz[i]) ||           \
	   ((i > start) &&             \
	    !isspace(sz[i-1]) &&       \
	    (sz[i] == '\'')))          \

int findwordindex (char *sz, int *index)
{
  int i = *index;
  int len = strlen(sz);

  while (i < len && !iswordchar(sz, i, *index))
    i++;

  return (i >= len) ? -1 : i;
}



// pm 03.10.05

char * collatebr (char *sz)
{
  char *sz_return = (char*) MALLOC (strlen(sz) + 1);
  char *pd = sz_return;

  while (*sz)
  {
    switch (*sz)
    {
      case 'á': case 'â': case 'ã': case 'à': case 'ä': case 'å': case 'Á': case 'Â': case 'Ã': case 'À': case 'Ä': case 'Å':
        *pd++ = 'A'; break;
      case 'é': case 'ê': case 'è': case 'ë': case 'É': case 'Ê': case 'È': case 'Ë':
        *pd++ = 'E'; break;
      case 'í': case 'î': case 'ì': case 'ï': case 'Í': case 'Î': case 'Ì': case 'Ï':
        *pd++ = 'I'; break;
      case 'ó': case 'ô': case 'õ': case 'ò': case 'ö': case 'Ó': case 'Ô': case 'Õ': case 'Ò': case 'Ö':
        *pd++ = 'O'; break;
      case 'ú': case 'û': case 'ù': case 'ü': case 'Ú': case 'Û': case 'Ù': case 'Ü':
        *pd++ = 'U'; break;
      case 'ç': case 'Ç':
        *pd++ = 'C'; break;
      case 'ñ': case 'Ñ':
        *pd++ = 'N'; break;
      case 'ý': case 'ÿ': case 'Ý':
        *pd++ = 'Y'; break;
      default:
        *pd++ = *sz;
    }
    sz++;
  }

  *pd = 0;
  return sz_return;
}


// pm 03.10.05

char * mid1 (char *sz, int *from, int *count)
{
  int f = *from - 1;
  return mid(sz, &f, count);
}


// pm 03.10.05

char * space (int *n)
{
  return strofchar(" ", n);
}


// pm 03.10.05

char * strofchar (char *sz, int *n)
{
  char * sz_return = (char*) MALLOC (*n+1);
  char * pd = sz_return;

  while ((*n)--)
    *pd++ = *sz;

  *pd = 0;

  return sz_return;
}


// gh 21.02.06
// base on GrUDF in Delphi by Torsten Grundke / Gerd Kroll

char *stringlistitem(char *stringlist, char *item)
{
    char *search = malloc(strlen(item) + 3);
    char *pos, *end, *result;

    sprintf(search, "\"%s=", item);
    pos = strstr(stringlist, search);
    if (pos) {
	pos++;
	end = strchr(pos, '"');
	if (end) {
	    *end = '\0';
	}
	result = MALLOC(strlen(pos) + 1);
	strcpy(result, pos);
	if (end) {
	    *end = '"';
	}
    } else {
	result = MALLOC(1);
	*result = '\0';
    }

    free(search);
    return result;
}

// gh 21.02.06
// gh 28.02.06 added MAXSTRLEN
// gh 01.03.06 added do_MALLOC

#define MAXSTRLEN 32758

char *excelstring(char *string)
{
    return intern_excelstring(string, 1);
}

char *intern_excelstring(char *string, int do_MALLOC)
{
    char *p = string, *q, *result;
    int len = 0;

    /* Count length of string, double count quotes */
    while (*p && len < MAXSTRLEN) {
	if (*p == '"') {
	    len++;
	}
	if (len < MAXSTRLEN) {
	    len++;
	    p++;
	}
    }
    result = do_MALLOC ? MALLOC(len + 3) : malloc(len + 3);
    p = string;
    q = result;

    /* Start with double quote */
    *q++ = '"';
    len = 0;

    /* Copy the string, omitting CRs and doubling double quotes */
    while (*p && len < MAXSTRLEN) {
	if (*p != 13) {
	    if (*p == '"') {
		*q++ = '"';
		len++;
	    }
	    if (len < MAXSTRLEN) {
		*q++ = *p++;
		len++;
	    }
	} else {
	    p++;
	}
    }
    *q++ = '"';
    *q = '\0';
    return result;
}

// pm 03.10.05

char * version ()
{
  char * sz_return = (char*) MALLOC (20);
  strcpy(sz_return,"adhoc 20061031");
  return sz_return;
}
