/*
 * 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 */
/* ct 2006-11-20 implementation of NULL for FB 2.0 */
char * character (int *c)
{
  if (!c)
    return NULL;
  else
  {
    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;
}

/* ct 2006-11-20 implementation of NULL for FB 2.0 */
char * encryptmd5 (char *sz)
{
  if(!sz)
    return NULL;
  else
  {
    MD5_CTX context;
    unsigned char digest[16];
    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, (unsigned char*) sz, len);
    MD5Final (digest, &context);

    for (i = 0; i < 16; i++)
      sprintf (&sz_return[i*2], "%02x", digest[i]);
    return sz_return;
  }
}


/* ct 2006-11-20 implementation of NULL for FB 2.0 */
/* gh 2007-01-17 intercept negativ values for count */
char * left (char *sz, int *count)
{
  if(!sz || !count)
    return NULL;
  else
  {
    int i;
    int c = (*count > 0) ? *count : 0;
    int len = (strlen(sz) < c) ? strlen(sz) : c;
    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;
  }
}

/* ct 2006-11-20 implementation of NULL for FB 2.0 */
/* ct 2007-01-22 intercept negativ values for count */
char * right (char *sz, int *count)
{
  if(!sz || !count)
    return NULL;
  else
  {
    int c = (*count > 0) ? *count : 0;
    int len = strlen(sz);
    char * sz_result = (char *) MALLOC (c + 1);
    int i, j;

    for (j = 0, i = (c > len) ? 0 : len - c ;
        i < len ; i++, j++)
      sz_result[j] = sz[i];

    sz_result[j] = (char) 0;
    return sz_result;
  }
}

/* ct 2006-11-20 implementation of NULL for FB 2.0 */
/* gh 2007-01-17 intercept negativ values for count */
char * mid (char *sz, int *index, int *count)
{
  if(!sz || !index || !count)
    return NULL;
  else
  {
    int ind = (*index > 0) ? *index : 0;
    int c = (*count > 0 && *index >= 0) ? *count : 0;
    int len = strlen(sz);
    char * sz_result = (char *) MALLOC (c + 1);
    int i;

    for (i = ind ; (i < len) && (i - ind < c); i++)
      sz_result[i - ind] = sz[i];
    sz_result[i - ind] = (char) 0;

    return sz_result;
  }
}

// pm 03.10.05
// f_mid1 = f_copy = f_mid with turned parameters
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);
}

/*
 * 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.
 */
/* ct 2006-11-20 implementation of NULL for FB 2.0 */
char * linewrap (char *sz, int *index, int *col_width)
{
  if(!sz || !index || !col_width)
    return NULL;
  else
  {
    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;
  }
}

/* ct 2006-11-20 implementation of NULL for FB 2.0 */
char * ltrim (char *sz)
{
  if(!sz)
    return NULL;
  else
  {
    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;
  }
}

/* ct 2006-11-20 implementation of NULL for FB 2.0 */
char * rtrim (char *sz)
{
  if(!sz)
    return NULL;
  else
  {

    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;
  }
}

/* ct 2006-11-20 implementation of NULL for FB 2.0 */
char * lrtrim (char *sz)
{
  if(!sz)
    return NULL;
  else
  {
    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;
  }
}

/* ct 2006-11-20 implementation of NULL for FB 2.0 */
char * padleft (char *sz, char *sz_pad, int *size)
{
  if(!sz || !sz_pad || !size)
    return NULL;
  else
  {
    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;
  }
}

// ct 2007-02-03 swapped parameter 2 and 3
char * r_padleft (char *sz, int *size, char *sz_pad)
{
  if(!sz || !sz_pad || !size)
    return NULL;
  else
  {
    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;
  }
}

/* ct 2006-11-20 implementation of NULL for FB 2.0 */
char * padright (char *sz, char *sz_pad, int *size)
{
  if(!sz || !sz_pad || !size)
    return NULL;
  else
  {
    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;
  }
}

// ct 2007-02-03 swapped parameter 2 and 3
char * r_padright (char *sz, int *size, char *sz_pad)
{
  if(!sz || !sz_pad || !size)
    return NULL;
  else
  {
    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;
  }
}

// gh 2006-11-23
/* gh 2006-11-23 implementation of NULL for FB 2.0 */
char *padcenter(char *sz, char *sz_pad, int *size)
{
    if (!sz || !sz_pad || !size) {
	return NULL;
    } else {
	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);
	char *p = sz_result;
	int left, right;

	if (len_sz >= *size) {
	    /* nothing to pad at all */
	    strcpy(sz_result, sz);
	    return sz_result;
	}

	if (((*size - len_sz) % 2) == 0) {
	    /* even number of chars to pad */
	    left = (*size - len_sz) / 2;
	    right = left;
	} else {
	    /* odd: one more char on the left side */
	    left = (*size - len_sz + 1) / 2;
	    right = left - 1;
	}

	/* pad left */
	while (left > 0) {
	    int l = (len_sz_pad < left) ? len_sz_pad : left;
	    strncpy(p, sz_pad, l);
	    left -= l;
	    p += l;
	}

	/* copy string */
	strcpy(p, sz);
	p += len_sz;

	/* pad right */
	while (right > 0) {
	    int l = (len_sz_pad < right) ? len_sz_pad : right;
	    strncpy(p, sz_pad, l);
	    right -= l;
	    p += l;
	}
        *p = '\0';

	/* faedisch */
	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
 */
/* ct 2006-11-20 implementation of NULL for FB 2.0 */
char * replace (char *sz, char *sz_replace, char *sz_with)
{
  if(!sz || !sz_replace || !sz_with)
    return NULL;
  else
  {

    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[MAX_STRINGBUFFER_SIZE];
    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;
  }
}


/* ct 2006-11-20 implementation of NULL for FB 2.0 */
char * soundex (char *sz)
{
  if(!sz)
    return NULL;
  else
  {

    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
/* ct 2006-11-20 implementation of NULL for FB 2.0 */
char * gsoundex (char *sz)
{
  if(!sz)
    return NULL;
  else
  {

    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);

/* ct 2006-11-20 implementation of NULL for FB 2.0 */
int * stringlength (char *sz)
{
  if(!sz)
    return NULL;
  else
  {
    int *result = MALLOC(sizeof(int));
    *result = strlen(sz);
    return result;
  }
}

/* ct 2006-11-20 implementation of NULL for FB 2.0 */
char * stripstring (char *sz, char *sz_strip_chars)
{
  if(!sz || !sz_strip_chars)
    return NULL;
  else
  {

    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;
  }
}

/* ct 2006-11-20 implementation of NULL for FB 2.0 */
char * stripstringhold (char *sz, char *sz_strip_chars)
{
  if(!sz || !sz_strip_chars)
    return NULL;
  else
  {

    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
// ct 2006-11-20 implementation of NULL for FB 2.0
int * substr (char *sz_search, char *sz)
{
  if(!sz_search || !sz)
    return NULL;
  else
  {
    int *result = MALLOC(sizeof(int));
    char * pc = strstr(sz_search,sz);
    if (pc == NULL)
      *result = -1;
    else
      *result = pc - sz_search;
    return result;
  }
}


// ct 2006-11-30 version with NULL instead of -1
int *substrnull(char *sz_search, char *sz)
{
    if (!sz_search || !sz) {
	return NULL;
    } else {
	char *pc = strstr(sz_search, sz);
	if (pc == NULL) {
	    return NULL;
	} else {
	    int *result = MALLOC(sizeof(int));
	    *result = pc - sz_search;
	    return result;
	}
    }
}

// gh 2006-03-06 the same as above only swapped parameters
/* ct 2006-11-20 implementation of NULL for FB 2.0 */
int *strsub(char *sz, char *sz_search)
{
    if (!sz || !sz_search) {
	return NULL;
    } else {
	int *result = MALLOC(sizeof(int));
	char *pc = strstr(sz_search, sz);
	if (pc == NULL) {
	    *result = -1;
	} else {
	    *result = pc - sz_search;
	}
	return result;
    }
}

// ct 2007-02-03
int *strpos(char *sz, char *sz_search)
{
    if (!sz || !sz_search) {
	return NULL;
    } else {
	int *result = MALLOC(sizeof(int));
	char *pc = strstr(sz_search, sz);
	if (pc == NULL) {
	    *result = 0;
	} else {
	    *result = pc - sz_search + 1;
	}
	return result;
    }
}


/* ct 2006-11-30 version with NULL instead of -1 */
int *strsubnull(char *sz, char *sz_search)
{
    if (!sz || !sz_search) {
	return NULL;
    } else {
	char *pc = strstr(sz_search, sz);
	if (pc == NULL) {
	    return NULL;
	} else {
	    int *result = MALLOC(sizeof(int));
	    *result = pc - sz_search;
	    return result;
	}
    }
}


// only intern
int findchar (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-8859-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-8859-1 to lower 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
/* ct 2006-11-20 implementation of NULL for FB 2.0 */
char * lower (char *sz)
{
  if(!sz)
    return NULL;
  else
  {

    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
/* ct 2006-11-20 implementation of NULL for FB 2.0 */
char * upper (char *sz)
{
  if(!sz)
    return NULL;
  else
  {
    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
/* ct 2006-11-20 implementation of NULL for FB 2.0 */
/* ct 2007-01-18 bug with input upper characters */
char * propercase (char *sz)
{
  if(!sz)
    return NULL;
  else
  {

    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] = StringLoTab [(unsigned char)sz[i]];
      }
    }
    sz_result[len] = (char) 0;
    return sz_result;
  }
}

// pm 21.08.04  changed
/* ct 2006-11-20 implementation of NULL for FB 2.0 */
char * telefonnr (char *sz, int *asterisk)
{
  if(!sz || !asterisk)
    return NULL;
  else
  {
    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;
  }
}

/* ct 2006-11-20 implementation of NULL for FB 2.0 */
char * aif (char *p1, char *o, char *p2, char *t, char *e)
{
  if(!p1 || !o || !p2 || !t || !e)
    return NULL;
  else
  {

        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;
  }
}

/* ct 2006-11-20 implementation of NULL for FB 2.0 */
/* ct 2007-01-17 intercept negativ values for anz */
char * strcopy (char *sz, int *indx, int *anz)
{
  if(!sz || !indx || !anz)
    return NULL;
  else
  {

    int c = (*anz > 0) ? *anz : 0;
    int i;
    char * sz_result = (char *) MALLOC (c + 1);

    if (strlen(sz) < *indx + c)
      c = strlen(sz) - *indx;

    for (i=*indx; i < *indx + c; i++)
      sz_result[i-*indx] = sz[i];

    sz_result[c] = (char) 0;

    return sz_result;
  }
}

/* ct 2006-11-20 implementation of NULL for FB 2.0 */
char * strrm(char *sz, int *indx)
{
  if(!sz || !indx || *sz == 0)
    return NULL;
  else
  {
        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
// ct 2006-11-20 implementation of NULL for FB 2.0
int * equalstring (char *sz1, char *sz2)
{
  if(!sz1 || !sz2)
    return NULL;
  else
  {
    int *result = MALLOC(sizeof(int));
    *result = (strcmp(sz1,sz2) == 0);
    return result;
  }
}


// pm 03.10.05
// gh 02.03.06 edit for äöü
// ct 2006-11-20 implementation of NULL for FB 2.0
char * findword (char *sz, int *n)
{
  if(!sz || !n)
    return NULL;
  else {
    char *sz_result;
    char *last;

    if (*n < 0 || *n >= strlen(sz))
      return NULL;
    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
// only intern
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
/* ct 2006-11-20 implementation of NULL for FB 2.0 */
char *replacestring(char *s, char *subs, char *replby, int *all,
    int *case_insensitive)
{
  if(!s || !subs || !replby || !all || !case_insensitive)
    return NULL;
  else
    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
/* ct 2006-11-20 implementation of NULL for FB 2.0 */
char * dollarval (double *value)
{
  if(!value)
    return NULL;
  else
  {
    char * sz_result = (char *) MALLOC (35);
    sprintf(sz_result, "$%.2f", *value);
    return sz_result;
  }
}


// pm 03.10.05
/* ct 2006-11-20 implementation of NULL for FB 2.0 */
char * euroval (double *value)
{
  if(!value)
    return NULL;
  else
  {
    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 äöü
// ct 2006-11-20 implementation of NULL for FB 2.0
// ct 2006-11-30 returns NULL insted of 0 if not found
char *findnthword(char *sz, int *n)
{
    if (!sz || !n) {
	return NULL;
    } else {
	char *pw;
	int len;

	while (*sz && *n >= 0) {
	    while (*sz && *sz == ' ')
		sz++;
	    if (*n > 0)
		while (*sz && *sz != ' ')
		    sz++;
	    (*n)--;
	}

	pw = sz;
	while (*pw && *pw != ' ')
	    pw++;

	len = pw - sz;
	if (len == 0) {
	    return NULL;
	} else {
	    char *sz_result = (char *) MALLOC(len + 1);
	    strncpy(sz_result, sz, len);
	    sz_result[len] = 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] == '\'')))          \


// ct 2006-11-20 implementation of NULL for FB 2.0
int * findwordindex (char *sz, int *index)
{
  if(!sz || !index)
    return NULL;
  else
  {
    int *result = MALLOC(sizeof(int));
    int i = *index;
    int len = strlen(sz);

    while (i < len && !iswordchar(sz, i, *index))
      i++;

    *result = (i >= len) ? -1 : i;
    return result;
  }
}


// ct 2006-11-30 returns null instead of 0 if not found
int *findwordindexnull(char *sz, int *index)
{
    if (!sz || !index) {
	return NULL;
    } else {
	int i = *index;
	int len = strlen(sz);

	while (i < len && !iswordchar(sz, i, *index))
	    i++;

	if (i >= len) {
	    return NULL;
	} else {
	    int *result = MALLOC(sizeof(int));
	    *result = i;
	    return result;
	}
    }
}


// pm 03.10.05
/* ct 2006-11-20 implementation of NULL for FB 2.0 */
char * collatebr (char *sz)
{
  if(!sz)
    return NULL;
  else
  {

    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
// ct 2006-11-20 implementation of NULL for FB 2.0
// ct 2006-11-30 intercept negativ n
char * strofchar (char *sz, int *n)
{
  if(!sz || !n)
    return NULL;
  else
  {
    int c = (*n > 0) ? *n : 0;
    char * sz_return = (char*) MALLOC (c + 1);
    char * pd = sz_return;

    if(*n < 0) *n = 0;

    while ((*n)--)
      *pd++ = *sz;

    *pd = 0;

    return sz_return;
  }
}

// gh 21.02.06
// base on GrUDF in Delphi by Torsten Grundke / Gerd Kroll
/* ct 2006-11-20 implementation of NULL for FB 2.0 */
char *stringlistitem(char *stringlist, char *item)
{
    if (!stringlist || !item) {
	return NULL;
    } else {
	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 = NULL;
	}

	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);
}

/* ct 2006-11-20 implementation of NULL for FB 2.0 */
char *intern_excelstring(char *string, int do_MALLOC)
{
  if(!string)
    return NULL;
  else {
    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;
  }
}

// ct 2006-11-15
/* ct 2006-11-20 implementation of NULL for FB 2.0 */
char * predecessor (char *sz, int *n)
{
  if(!sz || !n)
    return NULL;
  else
  {

    char * sz_return = (char*) MALLOC (2);
    sz_return[0] = *sz + *n;
    sz_return[1] = '\0';
    return sz_return;
  }
}

// ct 2006-11-15
/* ct 2006-11-20 implementation of NULL for FB 2.0 */
char * successor (char *sz, int *n)
{
  if(!sz || !n)
    return NULL;
  else
  {
    char * sz_return = (char*) MALLOC (2);
    sz_return[0] = *sz - *n;
    sz_return[1] = '\0';
    return sz_return;
  }
}

// ct 2006-11-16
/* ct 2006-11-20 implementation of NULL for FB 2.0 */
char * reverse (char *sz)
{
  if(!sz)
    return NULL;
  else
  {
    int i;
    int j;
    int len = strlen(sz);
    char * sz_return = (char *) MALLOC (len + 1);

    for (i = len - 1, j = 0; i >= 0 ; i--, j++)
      sz_return[j] = sz[i];

    sz_return[len] = '\0';

    return sz_return;
  }
}

// ct 2006-11-17
/* ct 2006-11-20 implementation of NULL for FB 2.0 */
int * wordcount (char *sz)
{
  if(!sz)
    return NULL;
  else
  {
    int *result = MALLOC(sizeof(int));
    int wort = 0;
    int count = 0;
    while (*sz)
    {
      if(isspace(*sz))
        wort = 0;
      else
      {
        if(wort == 0)
        {
          wort = 1;
          count++;
        }
      }
      sz++;
    }
    *result = count;
    return result;
  }
}

// ct 2006-11-17
/* ct 2006-11-20 implementation of NULL for FB 2.0 */
short * ord(unsigned char *sz)
{
  if(!sz)
    return NULL;
  else
  {
    short *result = MALLOC(sizeof(short));
    *result = sz[0];
    return result;
  }
}

// ct 2006-11-17
/* ct 2006-11-20 implementation of NULL for FB 2.0 */
int * stringcount(char *sz, char *sz_in)
{
  if(!sz || !sz_in || *sz == 0 || *sz_in == 0)
    return NULL;
  else
  {
    int *result = MALLOC(sizeof(int));
    char *str = sz;
    int len = strlen(sz_in);
    int count = 0;
    while ((str = strstr(str, sz_in)) != NULL )
    {
      str +=len;
      count++;
    }
    *result = count;
    return result;
  }
}

// ct 2007-02-03 swapped parameters for rFunc
int * r_stringcount(char *sz_in, char *sz)
{
  if(!sz || !sz_in || *sz == 0 || *sz_in == 0)
    return NULL;
  else
  {
    int *result = MALLOC(sizeof(int));
    char *str = sz;
    int len = strlen(sz_in);
    int count = 0;
    while ((str = strstr(str, sz_in)) != NULL )
    {
      str +=len;
      count++;
    }
    *result = count;
    return result;
  }
}

// ct 2007-02-03
int * r_strcmp(char *s1, char *s2)
{
  if(!s1 || !s2)
    return NULL;
  else
  {
    int *result = MALLOC(sizeof(int));
    *result = strcmp(s1, s2);
    return result;
  }
}

// ct 2007-02-03
int * r_wordcount(char *s, char *delim, int *flag)
{
  if(!s || !delim || !flag)
    return NULL;
  else
  {
      int *result = MALLOC(sizeof(int));

      char *c = s;
      int r = 0;
      int d = 1;

      while (*c)
	 if (strchr(delim, *c++))
	    d++; // counting words
	 else {
	    while (*c && !strchr(delim, *c)) c++;
	       r++; // counting full words
	 }
	if (*flag)
		*result = d;
	else
		*result = r;
      return result;
  }
}

// ct 2007-02-03
char * wordnum(char *s, int *n, char *delim, int *flag)
{
  if(!s || !n || !delim || !flag)
    return NULL;
  else
  {
      int len = strlen(s);
      char * result = (char*) MALLOC (len + 1);

	char *c = s, *ptr;
	int r = 1;

	if (!*c) return c;
	while (*c && r!=*n)
		if (strchr(delim, *c++)) {
			if (*flag)
				r++;
			else
				while (*c && strchr(delim, *c)) c++;
		} else {
			while (*c && !strchr(delim, *c)) c++;
			if (!*flag) r++;
		}
	if (!*flag)
		while (*c && strchr(delim, *c)) c++;
	ptr = c;
	while (*ptr && !strchr(delim, *ptr)) ptr++;
	*ptr = '\0';

	strcpy(result, c);
        return result;
  }      
}


/* gh 2007-02-05: Convert to uppercase, but copy only alphanumeric characters,
   german umlauts and characters with accents. Convert umlauts and accents
   into their accordant "normal" character, for example ö into O. */
char *keyup(char *key, int *len)
{
    char *res, *pc1, *pc2;
    int i;
    char c;

    res = MALLOC(*len + 1);
    pc1 = key;
    pc2 = res;
    i = 0;
    while (*pc1 && i < *len) {
	c = StringUpTab[(unsigned char)*pc1++];
	if ((c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9')) {
	    *pc2++ = c;
	    i++;
	} else {
	    switch (c) {
	    case 'È': case 'É': case 'Ê': case 'Ë':
		*pc2++ = 'E';
		i++;
		break;
	    case 'À': case 'Á': case 'Â': case 'Ä': case 'Ã': case 'Å':
		*pc2++ = 'A';
		i++;
		break;
	    case 'Ù': case 'Ú': case 'Û': case 'Ü':
		*pc2++ = 'U';
		i++;
		break;
	    case 'Ò': case 'Ó': case 'Ô': case 'Õ': case 'Ö':
		*pc2++ = 'O';
		i++;
		break;
	    case 'Ì': case 'Í': case 'Î': case 'Ï':
		*pc2++ = 'I';
		i++;
		break;
	    case 'Ç':
		*pc2++ = 'C';
		i++;
		break;
	    case 'Ø':
		*pc2++ = 'O';
		i++;
		if (i < *len) {
		    *pc2++ = 'E';
		    i++;
		}
		break;
	    case 'ß':
		*pc2++ = 'S';
		i++;
		if (i < *len) {
		    *pc2++ = 'S';
		    i++;
		}
		break;
	    case 'Æ':
		*pc2++ = 'A';
		i++;
		if (i < *len) {
		    *pc2++ = 'E';
		    i++;
		}
		break;
	    case 'Ð':
		*pc2++ = 'D';
		i++;
		break;
	    case 'Ý' :
		*pc2++ = 'Y';
		i++;
		break;
	    case 'Ñ':
		*pc2++ = 'N';
		i++;
		break;
	    }
	}
    }
    *pc2 = 0;
    return res;
}

// ct 2007-02-05
char * r_c(char * s)
{
  return s;
}

// gh 2007-02-06
char *convertsymbols(char *s, char *source, char *target)
{
    if (!s || !source || !target || (strlen(source) > strlen(target))) {
	return NULL;
    } else {
	int len = strlen(s);
	char *result = (char *) MALLOC(len + 1);
	char *p1 = s, *p2 = result, *p;

	while (*p1) {
	    if ((p = strchr(source, *p1)) != NULL) {
		*p2++ = target[p - source];
		p1++;
	    } else {
		*p2++ = *p1++;
	    }
	}
	*p2 = '\0';
	return result;
    }
}

// pm 03.10.05
char * version ()
{
  char * sz_return = (char*) MALLOC (20);
  strcpy(sz_return,"adhoc 20070209");
  return sz_return;
}
