stringUtil.c

Go to the documentation of this file.

#include <ctype.h>
#include "log.h"
#include "format.h"
#include "common.h"
#include "stringUtil.h"

char* subString (char *str, int start, int end) 
{
  static Stringa buffer = NULL;
  int i;

  stringCreateClear (buffer,100);
  i = start;
  while (i <= end) {
    stringCatChar (buffer,str[i]);
    i++;
  }
  return string (buffer);
}



char *rStringIn(char *needle, char *haystack)
{
  int nSize = strlen(needle);
  char *pos;
  for (pos = haystack + strlen(haystack) - nSize; pos >= haystack; pos -= 1)
    {
      if (memcmp(needle, pos, nSize) == 0)
        return pos;
    }
  return NULL;
}



char *stringBetween(char *start, char *end, char *haystack)

{
  char *pos, *p;
  int len;
  if ((p = stringIn(start, haystack)) != NULL)
    {
      pos = p + strlen(start);
      if ((p = stringIn(end, pos)) != NULL)
        {
          len = p - pos;
          pos = cloneMem(pos, len + 1);
          pos[len] = 0;
          return pos;
        }
    }
  return NULL;
}



char lastChar(char *s)
{
  if (s == NULL || s[0] == 0)
    return 0;
  return s[strlen(s)-1];
}



void toggleCase(char *s, int size)
{
  char c;
  int i;
 
  for (i=0; i<size; ++i)
    {
      c = s[i];
      if (isupper(c))
        c = tolower(c);
      else if (islower(c))
        c = toupper(c);
      s[i] = c;
    }
}



void subChar(char *s, char oldChar, char newChar)
{
  char c;
  for (;;)
    {
      c = *s;
      if (c == 0)
        break;
      if (c == oldChar)
        *s = newChar;
      ++s;
    }
}



void stripChar(char *s, char c)
{
  char *in = s, *out = s;
  char b;
  
  for (;;)
    {
      b = *out = *in++;
      if (b == 0)
        break;
      if (b != c)
        ++out;
    }
}



int countChars(char *s, char c)
{
  char a;
  int count = 0;
  while ((a = *s++) != 0)
    if (a == c)
      ++count;
  return count;
}



int countSame(char *a, char *b)
{
  char c;
  int i;
  int count = 0;
  for (i=0; ; ++i)
    {
      c = a[i];
      if (b[i] != c)
        break;
      if (c == 0)
        break;
      ++count;
    }
  return count;
}



char *skipLeadingSpaces(char *s)
{
  char c;
  if (s == NULL) return NULL;
  for (;;)
    {
      c = *s;
      if (!isspace(c))
        return s;
      ++s;
    }
}



char *skipToSpaces(char *s)
{
  char c;
  if (s == NULL)
    return NULL;
  for (;;)
    {
      c = *s;
      if (c == 0)
        return NULL;
      if (isspace(c))
        return s;
      ++s;
    }
}



void eraseTrailingSpaces(char *s)
{
  int len = strlen(s);
  int i;
  char c;
  
  for (i=len-1; i>=0; --i)
    {
      c = s[i];
    if (isspace(c))
      s[i] = 0;
    else
      break;
    }
}



void eraseWhiteSpace(char *s)

{
  char *in, *out;
  char c;
  
  in = out = s;
  for (;;)
    {
      c = *in++;
      if (c == 0) 
        break;
      if (!isspace(c))
        *out++ = c;
    }
  *out++ = 0;
}



char *trimSpaces(char *s)
{
  if (s != NULL)
    {
      s = skipLeadingSpaces(s);
      eraseTrailingSpaces(s);
    }
  return s;
}



int hasWhiteSpace(char *s)
{
  char c;
  while ((c = *s++) != 0)
    if (isspace(c))
      return 1;
  return 0;
}



char *firstWordInLine(char *line)
{
  char *e;
  line = skipLeadingSpaces(line);
  if ((e = skipToSpaces(line)) != NULL)
    *e = 0;
  return line;
}



char *lastWordInLine(char *line)
{
  char *s = line;
  char *word = NULL, *wordEnd = NULL;
  for (;;)
    {
      s = skipLeadingSpaces(s);
      if (s == NULL || s[0] == 0)
        break;
      word = s;
      s = wordEnd = skipToSpaces(s);
      if (s == NULL)
        break;
    }
  if (wordEnd != NULL)
    *wordEnd = 0;
  return word;
}



char *addSuffix(char *head, char *suffix)
{
  static Stringa buffer = NULL;

  stringCreateClear (buffer,100);
  stringPrintf (buffer,"%s%s",head,suffix);
  return string (buffer);
}

    

void chopSuffixAt(char *s, char c)
{
  char *e = strrchr(s, c);
  if (e != NULL)
    *e = 0;
}



void chopSuffix(char *s)
{
  chopSuffixAt(s,'.');
}



char *chopPrefixAt(char *s, char c)
{
  char *e = strchr(s, c);
  if (e == NULL) return s;
  *e++ = 0;
  return e;
}



char *chopPrefix(char *s)
{
  return chopPrefixAt(s, '.');
}



static char *naStr = "N/A";
static char *emptyStr = "";



char *naForNull(char *s)
{
  if (s == NULL) 
    s = naStr;
  return s;
}



char *naForEmpty(char *s)
{
  if (s == NULL || s[0] == 0)
    s = naStr;
  return s;
}



char *emptyForNull(char *s)
{
  if (s == NULL)
    s = emptyStr;
  return s;
}



char *nullIfAllSpace(char *s)
{
  s = skipLeadingSpaces(s);
  if (s != NULL)
    if (s[0] == 0)
      s = NULL;
  return s;
}



char *trueFalseString(int b)
{
  return (b ? "true" : "false");
}



char *skipNumeric(char *s)
{
  while (isdigit(*s))
    ++s;
  return s;
}



char *skipToNumeric(char *s)
{
  while (*s != 0 && !isdigit(*s))
    ++s;
  return s;
}



char *insertWordEveryNthPosition (char *string, char *word, int n)
{
  static Stringa buffer = NULL;
  int i,len; 

  stringCreateClear (buffer,100);
  len = strlen (string);
  i = 0;
  while (i < len) {
    stringCatChar (buffer,string[i]);
    i++;
    if ((i % n) == 0 && i != len) {
      stringCat (buffer,word);
    }  
  }
  return string (buffer);
}

---