Moved the util string functions to one place.

Added Util_StrSep - same functionality as strsep.
Renamed CCTK_StrDup as Util_Strdup.

Tom


git-svn-id: http://svn.cactuscode.org/flesh/trunk@1621 17b73243-c579-4c4c-a9d2-2d5706c11dac

1 files changed, 261 insertions, 0 deletions

diff --git a/src/util/String.c b/src/util/String.c
new file mode 100644
index 00000000..4c61b8e9
--- /dev/null
+++ b/src/util/String.c
@@ -0,0 +1,261 @@
+ /*@@
+   @file      String.c
+   @date      Tue May  2 10:44:19 2000
+   @author    Tom Goodale
+   @desc 
+   Routines dealing with strings.
+   @enddesc
+   @version $Header$
+ @@*/
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "util_String.h"
+
+#include "cctk_Flesh.h"
+static char *rcsid = "$Header$";
+
+CCTK_FILEVERSION(util_String_c)
+
+ /*@@
+   @routine    CCTK_StrSep
+   @date       Tue May  2 10:29:07 2000
+   @author     Tom Goodale
+   @desc 
+     The strsep() function returns the next token from the string stringp which is delimited by delim.  The token
+     is terminated with a `\0' character and stringp is updated to point past the token.
+
+     RETURN VALUE
+     The strsep() function returns a pointer to the token, or NULL if delim is not found in stringp.
+
+   @enddesc 
+   @calls     
+   @calledby   
+   @history 
+ 
+   @endhistory 
+
+@@*/
+const char *Util_StrSep(const char **stringp, const char *delim)
+{
+  int retlength = 0;
+  static char *retval = NULL;
+  char *temp;
+  const char *start;
+  const char *end;
+
+  start = *stringp;
+
+  end = strstr(start, delim);
+
+  /* Is the delimiter part of the string */
+  if(end)
+  {
+    if(retlength < (end-start)+1)
+    {
+      temp = realloc(retval, (end-start+1));
+
+      if(temp)
+      {
+        retval = temp;
+        retlength = end-start+1;
+      }
+      else
+      {
+        free(retval);
+        retval = NULL;
+        retlength = 0;
+      }
+    }
+
+    if(retval)
+    {
+      strncpy(retval, start, end-start);
+      retval[end-start] = '\0';
+
+      *stringp = end+strlen(delim);
+    }
+
+  }
+  else
+  {
+    free(retval);
+    retval = NULL;
+    retlength = 0;
+  }
+  
+  return retval;
+}
+
+ /*@@
+   @routine    Util_SplitString
+   @date       Wed Jan 20 10:14:00 1999
+   @author     Tom Goodale
+   @desc 
+   Splits a string into two parts at the given seperator.
+   Assigns memory for the two resulting strings, so this should be freed 
+   when no longer needed.
+   @enddesc 
+   @calls     
+   @calledby   
+   @history 
+ 
+   @endhistory 
+
+@@*/
+int Util_SplitString(char **before, char **after, const char *string, const char *sep)
+{
+  int retval=0;
+  char *position;
+
+  /* Find location of the seperator */
+  position = strstr(string, sep);
+
+  if(position)
+  {
+    /*Allocate memory for return strings. */
+    *before = (char *)malloc((size_t)((position-string+1)*sizeof(char)));
+    *after  = (char *)malloc((size_t)((strlen(string)-(position-string)-strlen(sep)+1)*sizeof(char)));
+
+    /* Check that the allocation succeeded. */
+    if(!*before || !*after)
+    {
+      free(*before);
+      *before = NULL;
+      free(*after);
+      *after = NULL;
+      retval = 2;
+    }
+    else
+    {
+      retval = 3;
+    }
+  }
+  else
+  {
+    *before = NULL;
+    *after = NULL;
+    retval = 1;
+  }
+
+  if(position && *before && *after)
+  {
+    /* Copy the data */
+    strncpy(*before, string, (int)(position-string));
+    (*before)[(int)(position-string)] = '\0';
+  
+    strncpy(*after, position+strlen(sep), strlen(string)-(int)(position-string)-strlen(sep));
+    (*after)[strlen(string)-(position-string)-strlen(sep)] = '\0';
+    
+    retval = 0;
+  }
+
+  return retval;
+}
+
+ /*@@
+   @routine    Util_Strdup
+   @date       Thu Mar 28 11:20:27 2000
+   @author     Gerd Lanfermann
+   @desc 
+   Homegrown ersion of strdup, since it's not guaranteed to be there.
+   @enddesc 
+   @calls     
+   @calledby   
+   @history 
+ 
+   @endhistory 
+
+@@*/
+char *Util_Strdup(const char *s) 
+{
+  char *retstr;
+  
+  retstr = (char*) malloc((strlen(s)+1)*sizeof(char));
+
+  strcpy(retstr,s);
+
+  return retstr;
+}
+
+ /*@@
+   @routine    Util_StrCmpi
+   @date       Mon Jul  5 01:19:00 1999
+   @author     Tom Goodale
+   @desc 
+   Case independent strcmp
+   @enddesc 
+   @calls     
+   @calledby   
+   @history 
+   @hdate Wed Oct 13 15:30:57 1999 @hauthor Tom Goodale
+   @hdesc Checks the length of the two string first. 
+   @endhistory 
+
+@@*/
+int Util_StrCmpi(const char *string1, const char *string2)
+{
+  int retval;
+  int position;
+
+  retval = 0;
+
+  if(! retval)
+  {
+    for(position = 0; 
+        string1[position] && string2[position];
+        position++)
+    {
+      if((retval = (tolower(string1[position]) - tolower(string2[position]))))
+      {
+        break;
+      }
+    }
+  }
+
+  if(! retval)
+  {
+    retval = strlen(string1) - strlen(string2);
+  }
+
+
+  return retval;
+}
+
+
+#ifdef TEST_Util_STRSEP
+
+#include <stdio.h>
+
+int main(int argc, char *argv[])
+{
+  const char *argument;
+  char *delim;
+  const char *token;
+
+  if(argc < 3)
+  {
+    printf("Usage: %s <string> <delim>\n", argv[0]);
+    exit(1);
+  }
+
+  argument = argv[1];
+  delim = argv[2];
+
+  while((token = Util_StrSep(&argument, delim)))
+  {
+    printf("Token is     '%s'\n", token);
+  }
+
+  if(argument - argv[1] < strlen(argv[1]))
+  {
+    printf("Remainder is '%s'\n", argument);
+  }
+
+  return 0;
+
+}
+
+#endif /*TEST_CCTK_STRSEP */
+