strext.c

Go to the documentation of this file.

 
/*****************************************************************************/
#include "libtpcmisc.h"
#include <string.h>
/*****************************************************************************/
 
/*****************************************************************************/
int strTokenNr(
  const char *str1,
  const char *str2
) {
  int i=0, n=0;
  char *cptr;
  if(str1==NULL || str2==NULL || strlen(str1)==0 || strlen(str2)==0) return(0);
 
  cptr=(char*)str1;
  do {
    // pass delimiter characters
    i=strspn(cptr, str2); cptr+=i;
    // pass characters between delimiters
    i=strcspn(cptr, str2); cptr+=i; if(i>0) n++; 
  } while(i>0);
  return(n);
}
/*****************************************************************************/
 
/*****************************************************************************/
int strTokenNCpy(
  const char *str1,
  const char *str2,
  int i,
  char *str3,
  int count
) {
  int j=0, n=0;
  char *cptr;
  if(str1==NULL || str2==NULL || strlen(str1)==0 || strlen(str2)==0) return(0);
  if(i<1 || str3==NULL || count<2) return(0);
 
  cptr=(char*)str1;
  do {
    // pass delimiter characters
    j=strspn(cptr, str2); cptr+=j;
    // pass characters between delimiters
    j=strcspn(cptr, str2); 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(str3, cptr, j+1); //strncpy(str3, cptr, j); str3[j]=(char)0;
      break;
    }
    cptr+=j;
  } while(j>0);
  if(n>i) {str3[0]=(char)0; return(0);}
  return(j);
}
/*****************************************************************************/
 
/*****************************************************************************/
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 strChrCount(
  const char *str1,
  const char *str2
) {
  unsigned int n=0, i, j;
  if(str1==NULL || str2==NULL || strlen(str1)==0 || strlen(str2)==0) return n;
  for(i=0; i<strlen(str1); i++)
    for(j=0; j<strlen(str2); j++)
      if(str1[i]==str2[j]) n++;
  return 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 *str,
  char c1,
  char c2
) {
  char *cptr;
  if(strlen(str)==0) return;
  while((cptr=strchr(str, c1))!=NULL) *cptr=c2;
  return;
}
/*****************************************************************************/
 
/*****************************************************************************/
#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
/*****************************************************************************/
 
/*****************************************************************************/
// This function is currently found in Linux gcc and macOS clang, but not in MinGW gcc
#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
/*****************************************************************************/
 
/*****************************************************************************/
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;
}
/*****************************************************************************/
 
/*****************************************************************************/
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;
}
/*****************************************************************************/
 
/*****************************************************************************/