format.c

Go to the documentation of this file.

/*****************************************************************************
* Copyright (C) 2002,  F. Hoffmann-La Roche & Co., AG, Basel, Switzerland.   *
*                                                                            *
* This file is part of "Roche Bioinformatics Software Objects and Services"  *
*                                                                            *
* This file is free software; you can redistribute it and/or                 *
* modify it under the terms of the GNU Lesser General Public                 *
* License as published by the Free Software Foundation; either               *
* version 2.1 of the License, or (at your option) any later version.         *
*                                                                            *
* This file is distributed in the hope that it will be useful,               *
* but WITHOUT ANY WARRANTY; without even the implied warranty of             *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU          * 
* Lesser General Public License for more details.                            *
*                                                                            *
* To obtain a copy of the GNU Lesser General Public License                  *
* please write to the Free Software                                          *
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA  *
* or visit the WWW site http://www.gnu.org/copyleft/lesser.txt               *
*                                                                            *
* SCOPE: this licence applies to this file. Other files of the               *
*        "Roche Bioinformatics Software Objects and Services" may be         *
*        subject to other licences.                                          *
*                                                                            *
* CONTACT: clemens.broger@roche.com                                          *
*                                                                            *
*****************************************************************************/

/* technical comments:

the functions collected here belong into x groups:

1. string handling, where string is Array of char
2. str handling, where str is a '\0'-terminated char[]
3. text handling, where text is an Array of char*
4. line and word handling
   (reading a line of arbitrary length,
    reading quotes strings,
    nestable strtok(),
    dissecting strings of the form dbname:seqname)

a note on terminolgy:
"Array" has a special meaning here: it denotes the dynamic array datatype,
see #include "array.h"
*/

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>

#include "hlrmisc.h"
#include "log.h"
#include "format.h"

/* ---------- part 1: String = Array of char with 
                      arru(string,arrayMax(string)-1,char) == '\0' ----- */ 


Array stringCreate(int initialSize) 
{
  Array a = arrayCreate(initialSize, char) ;
  array(a, 0, char) = '\0' ;
  return a ;
}



void stringTerminate(Array s /* of char */)
{
  if (!s || !arrayMax(s))
    die("stringTerminate: not a Stringa") ;
  if (!arru(s, arrayMax(s)-1, char))
    die("stringTerminate: already terminated") ;
  array(s, arrayMax(s), char) = '\0' ;
}



void stringTerminateP(Array s /* of char */, char *cp) 
{ 
  stringTerminateI(s, cp-string(s)) ;
}



void stringTerminateI(Array s /* of char */, int i) 
{ 
  if (i<0 || i>stringLen(s))
    die("stringTerminateI: s='%s', i=%d", string(s), i) ;
  arru(s, i, char) = '\0' ;
  arraySetMax(s, i+1) ;
}



void stringAdjust(Array s1) { 
  /*  
      after having messed around in a string array by interting
      a '\0', the invariant arru(s1, arrayMax(s1)-1, char) == '\0'
      is violated.
      this function cures it.
      input : s1  -- an Array of char
      output: s1  -- up to first '\0'
  */
  int l ;
  if (!s1) die("stringAdjust: null") ;
  if (!arrayMax(s1)) {
    stringClear(s1) ;
    return ;
  }
  l = strlen(string(s1)) ;
  if (l >= arrayMax(s1))
    die("stringAdjust: memory allocation error? actual string length is %d, but array knows only about %d chars", l, arrayMax(s1)-1) ;
  arraySetMax(s1, l+1) ;
}



void stringChop(Stringa s, int n) 
{
  int l = arrayMax(s) ;
  if (n >= l) {
    stringClear(s) ;
    return ;
  }
  arru(s, l-n-1, char) = '\0' ;
  arraySetMax(s, l-n) ;
  return ;
}



char *stringCut(Array s, int pos, int len) 
{
  static Array r = NULL ;
  int l = arrayMax(s) - 1 ;  /* don't count the terminating '\0' */
  char *from ;
  char *to ;
  char c ;

  if (l < 0 || arru(s, l, char))
    die("stringCut: not a proper string") ;

  if (pos >= l)
    return NULL ;
  if (len < 0 || len > l - pos)
    len = l - pos ;

  stringCreateClear(r, len+1) ;

  if (len > 0) {
    stringNCpy(r, arrp(s,pos,char), len) ;
    to = arrp(s,pos,char) ;
    from = to + len - 1 ;
    while (c = *++from)
      *to++ = c ;
    *to = '\0' ;
    arraySetMax(s, to - string(s) + 1) ;
  }

  return string(r) ;
}



void stringInsert(Stringa s, int p, char *i) 
{
  int il = strlen(i) ;
  int k = arrayMax(s) - p ; /* number of chars to move */
  int oldlen = arrayMax(s)-1 ;
  int maxnew = oldlen+il ;
  char *to ;
  char *from ;
  if (!il) 
    return ;
  array(s, maxnew, char) = '\0' ;  /* allocate */
  to = arrp(s, maxnew, char) ;            
  from = arrp(s, oldlen, char) ;
  if (k < 0) 
    die("stringInsert: k=%d", k) ;
  while (k--)
    *to-- = *from-- ;               /* shuffle up to make room */
  memcpy(arrp(s,p,char), i, il) ;   /* fill the room */
  /* if (strlen(string(s)) != arrayMax(s)-1) die("oops") ; */
}



void stringCat(Array s1, char *s2) 
{ 
  int i = arrayMax(s1) - 1 ; /* index of the trailing \0 */
  int l = strlen(s2) ;
  if (arru(s1, i, char)) 
    die("stringCat: s1 is not null-terminated (i=%d)", i) ;
  array(s1, i + l, char) = '\0' ;   /* allocate */
  memcpy(arrp(s1, i, char), s2, l) ;
}  



void stringCatInt(Array s, int i) {
  char c[30] ;
  hlr_itoa(c, i) ;
  stringCat(s, c) ;
}



void stringCatChar (Stringa s,char c)
{ 
  arru(s, arrayMax(s)-1, char) = c ;
  array(s, arrayMax(s), char) = '\0';
}



void stringNCpy(Stringa s1, char *s2, int n) 
{ 
  stringClear(s1) ;
  stringNCat(s1, s2, n) ;
}



void stringNCat(Stringa s1, char *s2, int n) 
{
  int i ;
  int l = 0 ;         /* length of s2 --> number of chars to copy */
  char *cp = s2 - 1 ;
  if (n <= 0) 
    return ;
  while (*++cp)
    if (++l >= n) break ;
  /* now l holds number of chars to copy */
  i = arrayMax(s1) - 1 ; /* index of the trailing \0 */
  if (arru(s1, i, char)) 
    die("stringNCat: s1 is not null-terminated (i=%d)", i) ;
  array(s1, i + l, char) = '\0' ;     /* allocate and terminate string */
  memcpy(arrp(s1, i, char), s2, l) ;  /* as fast as possible */
  /* this is the same functionality, but slower: 
     strncpy(arrp(s1, i, char), s2, l) ; */
}  



void stringCpy(Array s1, char *s2) 
{ 
  arraySetMax (s1,0) ;
  array(s1, strlen(s2), char) = '\0' ;   /* allocate */
  strcpy(arrp(s1, 0, char), s2) ;
}  



void stringClear(Array s1) 
{ 
  arraySetMax (s1,0) ;
  array(s1, 0, char) = '\0' ;
}



int stringTrim(Array s /* of char */, char *left, char *right)
{ 
  int len = strTrim(string(s), left, right) ;
  arraySetMax(s, len+1) ;  
  return len ;
}



static int strTranslate_resultLen = 0 ;  /* set by strTranslate */



int stringTranslate(Array s, char *fromChars, char *toChars)
{ 
  int cnt = strTranslate(string(s), fromChars, toChars) ;
  arraySetMax(s, strTranslate_resultLen+1) ;  
  return cnt ;
}



static int computeResultLength(char *format, va_list args) 
{ /*
  -- for use in stringPrintf() and stringAppendf() --
  function estimates maximum length of output by looking at
  format string and arguments and extends string before printing
  into it
  */
  int deflength = 18; /* default size for int/float/pointer types */
  int maxlength = 0; /* estimated maximum string length */
  char *cp = format;
  int isPercent = 0; /* flag for inside/outside conversion specification */

  /* parse format string to estimate maximum length */
  while (*cp) {
    /* toggle percent flag to handle escaped '%'s correctly */
    if (*cp == '%')
      isPercent = (isPercent) ? 0 : 1;
    else if (isPercent) {
      /* handle one conversion specification e.g. %20.10s, %5.2f, etc */
      int width = 0;
      int prec = 0;
      int dot = 0; /* flag for dot found */
      int asteriskCnt = 0; /* flag/counter for value substitution by '*' */
      long int intConv = 0;
      char *intConvEnd = NULL;
      char *arg = NULL;
      int arglength = 0;

      for (;;) {
        /* try to read an integer */
        intConv = strtol(cp, &intConvEnd, 10);

        /* if an integer was found */
        if (intConvEnd != cp) {
          /* step over integer found */
          cp = intConvEnd;

          /* assign to width or prec depending on dot-found flag */
          if (dot)
            prec = intConv;
          else
            width = intConv;
        }
        /* if substitution count asterisks to avoid crash */
        else if (*cp == '*')
          asteriskCnt ++;

        /* skip potential extensions of conversion specifier */
        if (strchr("lLh", *cp))
          cp ++;
          
        if (*cp == 'l')
          cp ++;
          
        /* if conversion type specifier found */
        if (strchr("pdinouxXeEfgGcCsS", *cp)) {
          /* reset flags  and get pointer to current argument */
          isPercent = 0;
          if (strchr("eEfgG", *cp)) {
            /* on IRIX 6.5 using the O32 ABI there is a bug in
               va_arg(x,t): it always sizeof(t) from the arg list
               instead of the actual argument size; obviously this
               leads to garbarge with 8byte types like float when
               using va_arg(x,char*).
               The problem has been fixed by SGI in the N32 ABI.
               The workaround for O32 is this code:
            */
            va_arg(args, double);
            arg = NULL ;
          }
          else
            arg = va_arg(args, char *);

          if (asteriskCnt) {
            if (asteriskCnt == 2) {
              width = (int) arg;
              arg = va_arg(args, char *);
              prec = (int) arg;
              arg = va_arg(args, char *);
            }
            else if (asteriskCnt == 1) {
              if (dot)
                prec = (int) arg;
              else
                width = (int) arg;
              
              arg = va_arg(args, char *);
            }
            else
              die("stringPrintf(): cannot handle format string %s", format);
          }

          if (*cp == 's') {
            /* estimate max length for strings */
            if (prec)
              arglength = prec;
            else 
              arglength = arg ? strlen(arg) : 6 /* (null) */ ;

            maxlength += MAX(arglength, width);
          }
          else if (*cp == 'S') {
            /* do we need that? it's not tested. #include <widec.h>
               if (prec)
                 arglength = prec * sizeof(wchar_t);
               else
                 arglength = wssize((wchar_t *) arg) * sizeof(wchar_t);

               maxlength += MAX(arglength, width * sizeof(wchar_t));
               */

            die("stringPrintf()/Appendf(): wide character strings not handled");
          }
          else if (*cp == 'c') {
            maxlength ++;
          }
          else if (*cp == 'C') {
            /* see above
               maxlength += sizeof(wchar_t);
               */

            die("stringPrintf(): wide characters not handled");
          }
          else {
            /* estimate max length for all other types */
            maxlength += (deflength + MAX(width, prec));
          }

          /* end of conversion type specification, exit loop */
          break;
        }
        else {
          /* if stopped on a dot set flag */
          if (*cp == '.')
            dot = 1;

          /* if stopped on a dollar complain */
          if (*cp == '$')
            warn("stringPrintf(): argument position manipulation not supported");

          cp ++;
        }
      }
    }

    maxlength ++;
    cp ++;
  }
  return maxlength ;
}



int stringPrintf(Stringa str, char *format, ...) 
{ 
  va_list args ;
  int maxlength ;
  int resultLen ;

  va_start(args, format) ;
  maxlength = computeResultLength(format, args) ;
  va_end(args);

  array(str, maxlength + 1, char) ;  /* allocate space */

  va_start(args, format);
  resultLen = vsprintf(string(str), format, args);
  va_end(args);

  if (resultLen > maxlength || resultLen < 0)
    die("stringPrintf(): oops") ;

  arraySetMax(str, resultLen+1) ; 

  return resultLen ;
}



int stringAppendf(Stringa str, char *format, ...) 
{ 
  va_list args ;
  int maxlength ;
  int len = stringLen(str) ;
  int resultLen ;

  va_start(args, format) ;
  maxlength = computeResultLength(format, args) ;
  va_end(args);

  array(str, len + maxlength + 1, char) ; /* allocate space */

  va_start(args, format);
  resultLen = vsprintf(string(str)+len, format, args);
  va_end(args);
  if (resultLen > maxlength || resultLen < 0)
    die("stringAppend(): oops") ;

  arraySetMax(str, len+resultLen+1) ;  /* turn into Stringa */
  return resultLen ;
}



char *stringPrintBuf(char *format, ...) 
{
  static Stringa str = NULL ;
  va_list args ;
  int maxlength ;
  int resultLen ;
  stringCreateOnce(str, 100) ;

  va_start(args, format) ;
  maxlength = computeResultLength(format, args) ;
  va_end(args);

  array(str, maxlength + 1, char) ;  /* allocate space */

  va_start(args, format);
  resultLen = vsprintf(string(str), format, args);
  va_end(args);

  if (resultLen > maxlength || resultLen < 0)
    die("stringPrintBuf(): oops") ;

  arraySetMax(str, resultLen+1) ;  /* turn into Stringa */
  return string(str) ;
}
  


/* ------------- part 2: char str[], '\0'-terminated --------- */ 


void toupperStr(char *s) 
{ 
  register char *cp = s - 1 ;
  while (*++cp) 
    *cp = toupper(*cp) ;
}



void tolowerStr(char *s) 
{
  register char *cp = s - 1 ;
  while (*++cp) 
    *cp = tolower(*cp) ;
}



char *strCaseStr (char *s, char *t) 
{ 
  char *p , *r ;
  if (*t == '\0') 
    return s ;
  for ( ; *s != '\0'; s++) {
    for (p = s, r = t; *r != '\0' && tolower(*p) == tolower(*r); p++, r++) ;
    if (r > t && *r == '\0')
      return s ;
  }
  return NULL ;
}


void strReplace(char **s1, char *s2) 
{ 
  if (!s1) 
    die("strReplace: NULL") ;
  hlr_free(*s1) ;
  if (s2)
    *s1 = hlr_strdup(s2) ;
}



char *strCopySubstr(char *string, char begin, char end, 
                    Array substr /* of char */) 
{ 
  char *pbegin = NULL ;
  char *pend = NULL ;
  char *nextPos = NULL ;
  stringClear(substr) ;

  if(pbegin = strchr(string, begin)) {
    pbegin ++;

    if(pend = strchr(pbegin, end)) {
      nextPos = pend + 1;
      pend --;
      stringNCpy(substr, pbegin, pend - pbegin + 1) ;
    }
  }
  return nextPos ;
}



int strTranslate(char *s, char *fromChars, char *toChars)
{ 
  char *from = s - 1 ;
  char *to = s ;
  char c ;
  int toLen = strlen(toChars) ;
  char *hit ;
  int cnt = 0 ;

  while (c = *++from) {
    if (hit = strchr(fromChars, c)) {
      ++cnt ;
      if (hit - fromChars < toLen) 
        *to++ = toChars[hit - fromChars] ;
    }
    else
      *to++ = c ;
  }
  *to = '\0' ;
  strTranslate_resultLen = to - s ;
  return cnt ;
}



int strTrim(char *s, char *left, char *right)
{ 
  /* tried to keep this efficent:
     - don't use strlen() unless unavoidable
     - first remove right side, because then there is less
     to be shifted left
  */ 
  int len ;
  char *cp ;
  if (!s)
    return 0 ;
  len = strlen(s) ;

  if (len && right) {
    /* move to last char of sequence, then run as long as
       there are only chars from 'right' or we bump into the
       beginning of the string */
    cp = s + len - 1 ;  
    while( cp >= s && strchr(right, *cp))
      *cp-- = '\0' ;
    len = cp - s + 1 ;
  }

  if (len && left) {
    /* move cp to the first char not in 'left'; then start
       shuffling chars from this position onward down to the beginning
       of the string */
    cp = s ;
    while (*cp && strchr(left, *cp))
      ++cp ;
    len = len - (cp - s) ;
    while (*cp)
      *s++ = *cp++ ;
    *s = '\0' ;
  }
  return len ;
}



void strScramble(char *s) 
{ 
  char *cp = s - 1 ;
  while (*++cp) {
    if ((unsigned char)*cp == 255)
      die("clsv_scramble: cannot scramble 0xFF") ;
    *cp = *cp ^ 255 ;
  }
}



void strUnscramble(char *s) 
{ 
  strScramble(s) ;  /* scramble + scramble = unscramble */
}



int isBlankStr(char *s) {
  
  char *cp = s-1 ;
  while (*++cp && isspace(*cp)) ;
  return *cp == '\0' ;
}



int isEmptyString(Array s) {
  if (!s || arrayMax(s)<1) 
    die("isEmptyString: NULL or corrupt string") ;
  return !arru(s,0,char) ;
}




/* -------- part 3: text handling, where text is an Array of char[] ----- */ 

/* a Texta is an Array of char*, where the memory referenced by
   the char pointers belongs to the Texta;
#define Texta Array */
/* #define textCreate(initialSize) arrayCreate(initialSize,char*) */



void textClear(Texta a /*of char* */)
{
  int i = arrayMax(a) ;
  while (i--) 
    hlr_free(arru(a, i ,char*)) ;
  arrayClear(a) ;
}




void textDestroyFunc(Texta a) 
{ 
  if (!a) 
    return ;
  textClear(a) ;
  arrayDestroy(a) ;
}



Texta textClone(Array a /* of char* */)
{ 
  int i ;
  Texta b ;
  char *s ;
  if (!a) 
    return NULL ;
  i = arrayMax(a) ;
  b = textCreate(i) ;    /* original size */
  if (i == 0)
    return b ;
  array(b, i-1, char*) = NULL ;  /* access to make arru() work */
  while (i--) {
    s = arru(a,i,char*) ;
    arru(b,i,char*) = (s ? hlr_strdup(s) : NULL) ;
  }
  return b ;
}  



Texta textStrtok(char *s, char *sep)
{ 
  WordIter wi=wordIterCreate(s,sep,1) ;
  char *pos ;
  Texta a=textCreate(10) ;
  while (pos=wordNext(wi))
    array(a,arrayMax(a),char*)=hlr_strdup(pos) ;
  wordIterDestroy(wi) ;
  return a ;
}



Texta textStrtokP(char *s, char *sep)
{ 
  char *cp = hlr_strdup(s) ;
  Texta t = textStrtok(cp, sep) ;
  hlr_free(cp) ;
  return t ;
}



Texta textFieldtok(char *s, char *sep)
{ 
  WordIter wi=wordIterCreate(s,sep,0) ;
  char *pos ;
  Texta a=textCreate(10) ;
  while (pos=wordNext(wi))
    array(a,arrayMax(a),char*)=hlr_strdup(pos) ;
  wordIterDestroy(wi) ;
  return a ;
}



Texta textFieldtokP(char *s, char *sep)
{
  char *cp = hlr_strdup(s) ;
  Texta t = textFieldtok(cp, sep) ;
  hlr_free(cp) ;
  return t ;
}



void textJoin(Stringa s, char *sep, Array a /*of char* */)
{ 
  int i ;
  stringClear(s) ;
  if (! arrayMax(a))
    return ;
  stringCpy(s, arru(a,0,char*)) ;
  for (i=1; i<arrayMax(a); ++i) {
    stringCat(s, sep) ;
    stringCat(s, arru(a,i,char*)) ;
  }
}



void textUniqKeepOrder(Texta t)
{ 
  Texta b = textCreate(arrayMax(t)) ;  /* index of elements seen */
  int from = -1 ;
  int to = -1 ;
  char *cp ;
  while (++from < arrayMax(t)) {
    cp = arru(t, from, char*) ;
    if (arrayFindInsert(b, &cp, NULL, (ARRAYORDERF) arrayStrcmp)) {
      ++to ;         /* new */
      arru(t, to, char*) = cp ;
    }
    else
      hlr_free(cp) ; /* already present */
  }
  arraySetMax(t, to + 1) ;
  arrayDestroy(b) ;
}


/*
Add a string to the end of a Texta
#define textAdd(t,s) (array((t),arrayMax(t),char*)=hlr_strdup(s))
*/

/*
get a pointer to the i the line in a Texta (i=0..arrayMax-1)
#define textItem(text, i)  arru((text),(i),char*)
*/


/* --------------- part 4: line and word handling -------------- */


#define GETLINE_MIN 80
#define GETLINE_INC 1024


int getLine(FILE *stream, char **buffer, int *buflen) 
{ 
  int buffree ;
  char *startp ;
  char *bufp ;
  int c ;

  if (!buffer) die("getLine() without buffer");
  if (! *buffer) {
    *buflen = GETLINE_MIN ;
    *buffer = hlr_malloc(*buflen) ;
  }
  buffree = (*buflen) -1 ;
  bufp = *buffer ;
  startp = bufp ;

  while ((c = getc(stream)) != EOF) {

    if (! --buffree) {
      *buflen = *buflen + GETLINE_INC ;
      buffree += GETLINE_INC ;
      *buffer = realloc(*buffer, *buflen) ;
      if (! *buffer) die("getLine: realloc") ;
      bufp = *buffer + (bufp - startp) ;  /* adjust to new location */
      startp = *buffer ;
    }

    if (!c) warn("getLine: read a NULL character") ; /* warn on binary data */
    *(bufp++) = c ;          /* append char to buffer */
    if (c == '\n') break ;
  }

  *bufp = '\0' ;
  return bufp - startp ;
}




int stripNlGetLength(char *line) 
{ 
  /*
  implementation note: since strlen() is a slow function if
    lines are long, I try to use it only when unavoidable.
    Since stripNlGetLength() has to find the end of the string
    I pass its finding back, so programs using this function
    would not need to call strlen() again.
  */
  int len = strlen(line) ;
  if (!len)
    return 0 ;
  --len ;
  if (line[len] == '\n') 
    line[len] = '\0' ;
  else
    ++len ;
  return len ;
}




/* ------------------ module word parser 2 ---------- begin 
analogous to strtok() from the standard C library,
but a bit more flexible and allows multiple independent
interleaved scans in different strings.

usage:
  WordIter wi = wordTokIterCreate("hallo welt", " \n\t") ;
  char *w ;
  while (w = wordNext(wi)) 
    printf("w='%s'\n", w) ;
  wordIterDestroy(wi) ;

#define wordTokIterCreate(s,seps) wordIterCreate(s,seps,1)
#define wordFldIterCreate(s,seps) wordIterCreate(s,seps,0)
#define wordIterDestroy(this) (wordIterDestroy_func(this), this=0)
*/


void wordIterDestroy_func(WordIter this1) 
{ 
  if (!this1) 
    die("wordIterDestroy: null") ;
  hlr_free(this1) ;
}


WordIter wordIterCreate(char *s, char *seps, int manySepsAreOne) 
{ 
  WordIter this1 ;
  if (!s || !seps || !*seps)
    die("wordIterCreate: some null/empty input") ;
  this1 = (WordIter) hlr_malloc(sizeof(struct wordIterStruct)) ;
  this1->seps = seps ;
  this1->cp = s ;
  this1->manySepsAreOne = manySepsAreOne ;
  this1->atEnd = 0 ;
  return this1 ;
}


/*
from format.h
#define wordNext(this1) (wordNextG(this1,NULL))
*/



char *wordNextG(WordIter this1, int *lenP) 
{ 
  char *cp ;
  char *word ;
  if (!this1) 
    die("wordNext: null") ;
  if (lenP)
    *lenP = 0 ;
  if (this1->atEnd) 
    return NULL ;
  cp = this1->cp ;
  if (this1->manySepsAreOne) { /* skip to first non-sep */
    --cp ;
    while (*++cp && strchr(this1->seps, *cp)) ;
  }
  else {
    if (! *cp) {
      this1->atEnd = 1 ;
      return cp ;
    }
    if (strchr(this1->seps, *cp)) {
      ++this1->cp ;
      *cp = '\0' ;
      return cp ;
    }
  }
  if (! *cp) {
    this1->atEnd = 1 ;
    return NULL ;
  }

  /* here holds: we are on the beginning of a word, on a non-separator char */
  /* now run until end of this word */
  word = cp ;
  --cp ;
  while (*++cp && !strchr(this1->seps, *cp)) ;
  if (lenP)
    *lenP = cp - word ;

  if (! *cp ) 
    this1->atEnd = 1 ;
  else {
    *cp = '\0' ;        /* mark end of word */
    this1->cp = cp + 1 ; /* next time we start after the end of this separator */
  }
  return word ;
}

/* does s1 start with s2?
   strStartsWith() always works, but is slower than strStartsWithC()
                   s2 must not be an expression with side effects
                   since it is evaluated twice
   strStartsWithC() same as strStartsWith, but can only be used 
                    if s2 is a string constant, e.g.
                    if (strStartsWithC(s, "CC   ")) ...
#define strStartsWith(s1,s2) (strncmp((s1),(s2),strlen(s2)) == 0)
#define strStartsWithC(s1,s2) (strncmp((s1),(s2),sizeof(s2)-1) == 0)
*/


int strEndsWith(char *s, char *suffix)
{ 
  int len = strlen(s) ;
  int slen = strlen(suffix) ;
  if (slen > len)
    return 0 ;
  return strEqual(s + len - slen, suffix) ;
}

---