stringext.c

Go to the documentation of this file.

 
/*****************************************************************************/
#include "tpcclibConfig.h"
/*****************************************************************************/
#include "tpcextensions.h"
/*****************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>
#include <string.h>
#include <strings.h>
#include <ctype.h>
/*****************************************************************************/
 
/*****************************************************************************/
int strTokenNr(
  const char *s1,
  const char *s2
) {
  int i=0, n=0;
  char *cptr;
  if(s1==NULL || s2==NULL || strnlen(s1, 1)==0 || strnlen(s2, 1)==0) return(0);
 
  cptr=(char*)s1;
  do {
    // pass delimiter characters
    i=strspn(cptr, s2); cptr+=i;
    // pass characters between delimiters
    i=strcspn(cptr, s2); cptr+=i; if(i>0) n++; 
  } while(i>0);
  return(n);
}
/*****************************************************************************/
 
/*****************************************************************************/
int strTokenNCpy(
  const char *s1,
  const char *s2,
  int i,
  char *s3,
  int count
) {
  int j=0, n=0;
  char *cptr;
  if(s3!=NULL && count>0) s3[0]=(char)0;
  if(s1==NULL || s2==NULL || strlen(s1)==0 || strlen(s2)==0) return(0);
  if(i<1 || s3==NULL || count<2) return(0);
 
  cptr=(char*)s1;
  do {
    // pass delimiter characters
    j=strspn(cptr, s2); cptr+=j;
    // pass characters between delimiters
    j=strcspn(cptr, s2); if(j>0) n++;
    // if this is the required token nr, then stop here
    if(n==i) {
      if(j>count-1) j=count-1;
      strlcpy(s3, cptr, j+1); //strncpy(s3, cptr, j); s3[j]=(char)0;
      break;
    }
    cptr+=j;
  } while(j>0);
  if(n>i) {s3[0]=(char)0; return(0);}
  return(j);
}
/*****************************************************************************/
 
/*****************************************************************************/
int strChrCount(
  const char *s1,
  const char *s2
) {
  unsigned int n=0, i, j;
  if(s1==NULL || s2==NULL || strlen(s1)==0 || strlen(s2)==0) return (int)n;
  for(i=0; i<strlen(s1); i++)
    for(j=0; j<strlen(s2); j++)
      if(s1[i]==s2[j]) n++;
  return (int)n;
}
/*****************************************************************************/
 
/*****************************************************************************/
int strUppercaseCount(
  const char *s
) {
  unsigned int n=0, i;
  if(s==NULL || strlen(s)==0) return (int)n;
  for(i=0; i<strlen(s); i++) if(isupper(s[i])) n++;
  return (int)n;
}
/*****************************************************************************/
 
/*****************************************************************************/
void strReplaceChar(
  char *s,
  char c1,
  char c2
) {
  char *cptr;
  if(s==NULL || strlen(s)==0) return;
  while((cptr=strchr(s, c1))!=NULL) *cptr=c2;
  return;
}
/*****************************************************************************/
 
/*****************************************************************************/
#ifndef HAVE_STRCASESTR
char *strcasestr(
  const char *haystack,
  const char *needle
) {
  if(!haystack || !*haystack || !needle || !*needle) return 0;
 
  const char *s=haystack, *p=needle;
  do {
    if(!*p) return(char*)haystack;
    if((*p==*s) || (tolower(*p)==tolower(*s))) {
      p++; s++;
    } else {
      p=needle; if(!*s) return(NULL);
      s=++haystack;
    }
  } while(1);
  return *p ? NULL : (char*)haystack;
}
#endif // HAVE_STRCASESTR
/*****************************************************************************/
 
/*****************************************************************************/
#ifndef HAVE_STRDUP
char *strdup(
  const char *s
) {
  if(s==NULL) return NULL;
  size_t length=strlen(s)+1;
  void *r;
  r=calloc(length, sizeof(char)); if(r==NULL) return NULL;
  return (char*)memcpy(r, s, length);
}
#endif // HAVE_STRDUP
/*****************************************************************************/
 
/*****************************************************************************/
#ifndef HAVE_STRNDUP
char *strndup(
  const char *s,
  size_t n
) {
  size_t length=strnlen(s, n);
  void *r; r=calloc(length+1, sizeof(char)); if(r==NULL) return NULL;
  return (char*)memcpy(r, s, length);
}
#endif // HAVE_STRNDUP
/*****************************************************************************/
 
/*****************************************************************************/
char *strstrNoQuotation(
  const char *haystack,
  const char *needle
) {
  if(haystack==NULL) return((char*)NULL);
  if(needle==NULL) return((char*)haystack);
 
  size_t i, test_len;
  int single_quotation=0;
  int double_quotation=0;
  char *cptr;
  
  test_len=strlen(needle); if(test_len<1) return((char*)haystack);
  for(i=0, cptr=(char*)haystack; i<strlen(haystack); i++, cptr++) {
    if(*cptr=='\'') {
      if(single_quotation==0 && strchr(cptr+1, '\'')!=NULL) single_quotation=1;
      else single_quotation=0;
      continue;
    }
    if(*cptr=='\"') {
      if(double_quotation==0 && strchr(cptr+1, '\"')!=NULL) double_quotation=1;
      else double_quotation=0;
      continue;
    }
    if(single_quotation==1 || double_quotation==1) continue;
    if(strncmp(cptr, needle, test_len)==0) return(cptr);
  }
  return((char*)NULL);
}
/*****************************************************************************/
 
/*****************************************************************************/
int strncpyCleanSpaces(
  char *s1,
  const char *s2,
  int maxlen
) {
  if(s1==NULL) return(0);
  s1[0]=(char)0; if(maxlen<1) return(0);
  if(maxlen<2) {strcpy(s1, ""); return(0);}
  if(s2==NULL || strlen(s2)<1) return(0);
 
  char *cptr;
  int i;
 
  cptr=(char*)s2; cptr+=strspn(s2, "\t\n\r ");
  strlcpy(s1, cptr, maxlen); i=strlen(s1); if(i<1) return(0);
  cptr=s1+(i-1);
  while(i>0) {
    if(*cptr!='\t' && *cptr!='\n' && *cptr!='\r' && *cptr!=' ') break;
    i--; s1[i]=(char)0; cptr--;
  }
  return(i);
}
/*****************************************************************************/
 
/*****************************************************************************/
int strCleanSpaces(
  char *s
) {
  if(s==NULL) return 0;
  int len=strlen(s); if(len<0) return 0;
  char *s2; s2=strdup(s); if(s2==NULL) return(1);
  int n=strncpyCleanSpaces(s2, s, len+1);
  if(n<1) strcpy(s, ""); else strcpy(s, s2);
  free(s2);
  return 0;
}
/*****************************************************************************/
 
/*****************************************************************************/
int strncpyClean(
  char *s1,
  const char *s2,
  int maxlen
) {
  if(s1==NULL) return(0);
  s1[0]=(char)0; if(maxlen<1) return(0);
  if(maxlen<2) {strcpy(s1, ""); return(0);}
  if(s2==NULL || strlen(s2)<1) return(0);
 
  char *tmp;
  int i, sqn, dqn, m;
 
  /* Allocate temp string */
  tmp=calloc(strlen(s2)+1, sizeof(char));
 
  /* Trim space characters */
  i=strncpyCleanSpaces(tmp, s2, strlen(s2)+1);
  if(i<1) {strcpy(s1, ""); free(tmp); return(0);}
 
  /* Loop as long as there is something to trim */
  i=1;
  while(i) {
    m=0; // nothing modified so far  
    /* Count quotes */
    sqn=strChrCount(tmp, "\'");
    dqn=strChrCount(tmp, "\"");
    if(sqn==0 && dqn==0) {i=0; break;}
    /* Trim matching quotation marks */
    if(dqn>=2 && tmp[0]=='\"' && tmp[strlen(tmp)-1]=='\"') {
      tmp[0]=' '; tmp[strlen(tmp)-1]=(char)0; dqn-=2; m+=2;
    }
    if(sqn>=2 && tmp[0]=='\'' && tmp[strlen(tmp)-1]=='\'') {
      tmp[0]=' '; tmp[strlen(tmp)-1]=(char)0; sqn-=2; m+=2;
    }
    /* Trim orphan quotation marks */
    if(sqn%2) {
      if(tmp[0]=='\'') {tmp[0]=' '; sqn--; m++;}
      else if(tmp[strlen(tmp)-1]=='\'') {tmp[strlen(tmp)-1]=(char)0; sqn--; m++;}
    }
    if(dqn%2) {
      if(tmp[0]=='\"') {tmp[0]=' '; dqn--; m++;}
      else if(tmp[strlen(tmp)-1]=='\"') {tmp[strlen(tmp)-1]=(char)0; dqn--; m++;}
    }
    /* If nothing was modified, then do not continue */
    if(m==0) {i=0; break;}
    /* Trim spaces, quit if error encountered */
    if(strCleanSpaces(tmp)) i=0;
  }
 
  strlcpy(s1, tmp, maxlen);
  free(tmp);
  return(strlen(s1));
}
/*****************************************************************************/
 
/*****************************************************************************/
int strClean(
  char *s
) {
  if(s==NULL) return 0;
  int len=strlen(s); if(len<0) return 0;
  char *s2; s2=calloc(len+1, sizeof(char)); if(s2==NULL) return(1);
  int n=strncpyClean(s2, s, len+1);
  if(n<1) strcpy(s, ""); else strcpy(s, s2);
  free(s2);
  return 0;
}
/*****************************************************************************/
 
/*****************************************************************************/
char *strTokenDup(
  const char *s1,
  const char *s2,
  int *next
) {
  if(next!=NULL) *next=0;
  if(s1==NULL) return NULL;
 
  char *s3=NULL, *cptr;
  size_t j;
  
  /* If no delimiters, then return copy of s1 */
  if(s2==NULL || strlen(s2)<1) {
    s3=strdup(s1); if(next!=NULL) *next=strlen(s1);
    return s3;
  } 
  /* Pass initial delimiter characters */
  cptr=(char*)s1; j=strspn(cptr, s2); cptr+=j; if(next!=NULL) *next=j;
  /* calculate characters between delimiters */
  j=strcspn(cptr, s2); if(j==0) {return NULL;}
  if(next!=NULL) *next+=j;
  /* Allocate space for token */
  s3=calloc(j+1, sizeof(char)); if(s3==NULL) return NULL;
  strlcpy(s3, cptr, j+1);
  return s3;
}
/*****************************************************************************/
 
/*****************************************************************************/
int strInPars(
  char *s
) {
  if(s==NULL) return 0;
  int len=strlen(s); if(len<2) return 0;
  if(s[0]=='(' && s[len-1]==')') return 1;
  if(s[0]=='{' && s[len-1]=='}') return 1;
  if(s[0]=='[' && s[len-1]==']') return 1;
  return 0;
}
/*****************************************************************************/
 
/*****************************************************************************/
void strCleanPars(
  char *s
) {
  if(s==NULL || strInPars(s)==0) return;
  int len=strlen(s);
  s[--len]=(char)0;
  for(int i=1; i<=len; i++) s[i-1]=s[i];
  return;
}
/*****************************************************************************/
 
/*****************************************************************************/
char *strncatInt(
  char *str1,
  const int n,
  size_t count
) {
  char tmp[128]; sprintf(tmp, "%d", n);
  return strncat(str1, tmp, count);
}
/*****************************************************************************/
 
/*****************************************************************************/
char *strncatDouble(
  char *str1,
  const double d,
  size_t count
) {
  char tmp[128]; sprintf(tmp, "%g", d);
  return strncat(str1, tmp, count);
}
/*****************************************************************************/
 
/*****************************************************************************/
char *strncatIntZ(
  char *str1,
  const int n,
  const int maxn,
  size_t count
) {
  if(n<0) strncat(str1, "-", count);
  char tmp[128]; sprintf(tmp, "%d", abs(maxn));
  int len=strlen(tmp);
  sprintf(tmp, "%0*d", len, abs(n));
  return strncat(str1, tmp, count);
}
/*****************************************************************************/
 
/*****************************************************************************/
#ifndef HAVE_STRNLEN
size_t strnlen(
  const char *s,
  size_t n
) {
  if(s==NULL) return(0);
  char *ps=(char*)s;
  size_t i=0;
  while(i<n && *ps!='\0') {i++; ps++;}
  return(i);
}
#endif // HAVE_STRNLEN
/*****************************************************************************/
 
/*****************************************************************************/
#ifndef HAVE_STRLCAT
size_t strlcat(
  char *dst,
  const char *src,
  size_t dstsize
) {
  char *d;
  const char *s=src;
  size_t dlen, n;
 
  /* Find the current length of dst */
  dlen=strnlen(dst, dstsize);
  if(s==NULL) return(dlen);
  n=dstsize-dlen;
  if(n==0) return(dlen+strlen(s));
  d=dst+dlen;
  while(*s!='\0') {
    if(n!=1) {*d=*s; d++; n--;}
    s++;
  }
  *d='\0';
  return(dlen+(s-src));
}
#endif // HAVE_STRLCAT
/*****************************************************************************/
 
/*****************************************************************************/
#ifndef HAVE_STRLCPY
size_t strlcpy(
  char *dst,
  const char *src,
  size_t dstsize
) {
  if(dstsize>0) dst[0]='\0';
  if(strlen(src)==0) return(0);
 
  char *d=dst;
  const char *s=src;
  size_t n;
 
  /* Copy as many chars as allowed */
  n=dstsize;
  if(n!=0) while(--n!=0) {*d=*s; if(*d=='\0') {d++; s++; break;} d++; s++;}
  if(n==0) { // not enough space, add NUL, and check how much space were needed
    if(dstsize!=0) *d='\0';
    while(*s++) {}
  }
  return(s-src-1);
}
#endif // HAVE_STRLCPY
/*****************************************************************************/
 
/*****************************************************************************/
int strIsSpaceOnly(
  char *s
) {
  if(s==NULL) return(1);
  int len=strlen(s); if(len<1) return(1);
  for(int i=0; i<len; i++) if(!isspace(s[i])) return(0);
  return 1;
}
/*****************************************************************************/
 
/*****************************************************************************/
char *strdelstr(
  char *s1,
  const char *s2
) {
  if(s1==NULL || s2==NULL) return(s1); //printf("strdelstr('%s', '%s')\n", s1, s2);
  int n=strlen(s2); if(n<1) return(s1);
  char *cptr, *rptr;
  cptr=strcasestr(s1, s2);
  if(cptr==NULL || *cptr==(char)0) return(s1);
  rptr=cptr;
  while(*cptr) {*cptr=cptr[n]; cptr++;}
  return(rptr);
}
/*****************************************************************************/
 
/*****************************************************************************/
char *strTrimLeft(
  char *s,
  const size_t t
) {
  if(s==NULL || t==0) return(s);
  size_t len=strlen(s); if(len<1) return(s);
  if(t>=len) {s[0]=(char)0; return(s);}
  memmove(s, s+t, 1+len-t);
  return(s);
}
/*****************************************************************************/
 
/*****************************************************************************/
char *strEncodeForXML(
  const char *s
) {
  if(s==NULL) return(NULL);
  /* Count the characters needing encoding */
  int n=0;
  for(size_t i=0; i<strlen(s); i++) {
    if(s[i]=='&') {n++; continue;}
    if(s[i]=='\'') {n++; continue;}
    if(s[i]=='\"') {n++; continue;}
    if(s[i]=='<') {n++; continue;}
    if(s[i]=='>') {n++; continue;}
  }
  if(n==0) return(NULL);
  /* Allocate memory for new string (one char to max 6 chars) */
  n*=5; n+=strlen(s)+1;
  char *ns=(char*)malloc(n*sizeof(char));
  if(ns==NULL) return(NULL);
  /* Process the string */
  for(int i=0; i<n; i++) ns[i]=(char)0;
  for(size_t i=0; i<strlen(s); i++) {
    if(s[i]=='&') {strcat(ns, "&amp;"); continue;}
    if(s[i]=='\'') {strcat(ns, "&apos;"); continue;}
    if(s[i]=='\"') {strcat(ns, "&quot;"); continue;}
    if(s[i]=='<') {strcat(ns, "&lt;"); continue;}
    if(s[i]=='>') {strcat(ns, "&gt;"); continue;}
    ns[strlen(ns)]=s[i];
  }
  return(ns);
}
/*****************************************************************************/
 
/*****************************************************************************/
void strCleanForXML(
  char *s
) {
  if(s==NULL || *s=='\0') return;
  strReplaceChar(s, '&', '-');
  strReplaceChar(s, '\'', '-');
  strReplaceChar(s, '\"', '-');
  strReplaceChar(s, '<', '-');
  strReplaceChar(s, '>', '-');
  return;
}
/*****************************************************************************/
 
/*****************************************************************************/