libs/Strings.c

   1 /* -*-c-*- */
   2 /* This program is free software; you can redistribute it and/or modify
   3  * it under the terms of the GNU General Public License as published by
   4  * the Free Software Foundation; either version 2 of the License, or
   5  * (at your option) any later version.
   6  *
   7  * This program is distributed in the hope that it will be useful,
   8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  * GNU General Public License for more details.
  11  *
  12  * You should have received a copy of the GNU General Public License
  13  * along with this program; if not, write to the Free Software
  14  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  15  */
  16
  17 /*
  18 ** Strings.c: various routines for dealing with strings
  19 */
  20 #include "config.h"
  21
  22 #include <ctype.h>
  23
  24 #include "safemalloc.h"
  25 #include "Strings.h"
  26
  27
  28 #define CHUNK_SIZE 256
  29 char *CatString3(const char *a, const char *b, const char *c)
  30 {
  31         static char* buffer = NULL;
  32         static int buffer_len = 0;
  33         int len = 1;
  34
  35         if (a != NULL)
  36         {
  37                 len += strlen(a);
  38         }
  39         if (b != NULL)
  40         {
  41                 len += strlen(b);
  42         }
  43         if (c != NULL)
  44         {
  45                 len += strlen(c);
  46         }
  47
  48         /* Expand buffer to fit string, to a multiple of CHUNK_SIZE */
  49         if (len > buffer_len)
  50         {
  51                 buffer_len = CHUNK_SIZE * (1 + ((len - 1) / CHUNK_SIZE));
  52                 buffer = saferealloc(buffer, buffer_len);
  53         }
  54         buffer[0] = 0;
  55         if (a != NULL)
  56         {
  57                 strcat(buffer, a);
  58         }
  59         if (b != NULL)
  60         {
  61                 strcat(buffer, b);
  62         }
  63         if (c != NULL)
  64         {
  65                 strcat(buffer, c);
  66         }
  67
  68         return buffer;
  69 }
  70 #undef CHUNK_SIZE
  71
  72
  73 void CopyString(char **dest, const char *source)
  74 {
  75         int len;
  76         const char *start;
  77
  78         if (source == NULL)
  79         {
  80                 *dest = NULL;
  81                 return;
  82         }
  83
  84         /* set 'start' to the first character of the string,
  85            skipping over spaces, but not newlines
  86            (newline terminates the string) */
  87
  88         while ( isspace((unsigned char)*source) && (*source != '\n') )
  89         {
  90                 source++;
  91         }
  92         start = source;
  93
  94         /* set 'len' to the length of the string, ignoring
  95            trailing spaces */
  96
  97         len = 0;
  98         while ( (*source != '\n') && (*source != 0) )
  99         {
 100                 len++;
 101                 source++;
 102         }
 103         source--;
 104
 105         while( len > 0 && isspace((unsigned char)*source) )
 106         {
 107                 len--;
 108                 source--;
 109         }
 110
 111         *dest = safemalloc(len+1);
 112         strncpy(*dest,start,len);
 113         (*dest)[len]=0;
 114 }
 115
 116
 117 void CopyStringWithQuotes(char **dest, const char *src)
 118 {
 119         while (src && src[0] == ' ')
 120         {
 121                 src++;
 122         }
 123         if (src && src[0] == '"')
 124         {
 125                 int len;
 126
 127                 src++;
 128                 CopyString(dest, src);
 129                 len = strlen(*dest);
 130                 if (len > 0 && (*dest)[len - 1] == '"')
 131                 {
 132                         (*dest)[len - 1] = '\0';
 133                 }
 134         }
 135         else
 136         {
 137                 CopyString(dest, src);
 138         }
 139 }
 140
 141
 142 /*
 143  *
 144  * Copies a string into a new, malloc'ed string
 145  * Strips leading spaces and trailing spaces and new lines
 146  *
 147  */
 148 char *stripcpy( const char *source )
 149 {
 150         const char* tmp;
 151         char* ptr;
 152         int len;
 153
 154         if(source == NULL)
 155         {
 156                 return NULL;
 157         }
 158
 159         while(isspace((unsigned char)*source))
 160         {
 161                 source++;
 162         }
 163         len = strlen(source);
 164         tmp = source + len -1;
 165
 166         while( (tmp >= source) && ((isspace((unsigned char)*tmp)) ||
 167                                    (*tmp == '\n')) )
 168         {
 169                 tmp--;
 170                 len--;
 171         }
 172         ptr = safemalloc(len+1);
 173         if (len)
 174         {
 175                 strncpy(ptr,source,len);
 176         }
 177         ptr[len]=0;
 178
 179         return ptr;
 180 }
 181
 182
 183 int StrEquals( const char *s1, const char *s2 )
 184 {
 185         if (s1 == NULL && s2 == NULL)
 186         {
 187                 return 1;
 188         }
 189         if (s1 == NULL || s2 == NULL)
 190         {
 191                 return 0;
 192         }
 193
 194         return strcasecmp(s1,s2) == 0;
 195 }
 196
 197
 198 int StrHasPrefix( const char* string, const char* prefix )
 199 {
 200         if ( prefix == NULL )
 201         {
 202                 return 1;
 203         }
 204         if ( string == NULL )
 205         {
 206                 return 0;
 207         }
 208
 209         return strncasecmp( string, prefix, strlen(prefix) ) == 0;
 210 }
 211
 212
 213 /*
 214  *
 215  * Adds single quotes arround the string and escapes single quotes with
 216  * backslashes.  The result is placed in the given dest, not allocated.
 217  * The end of destination, i.e. pointer to '\0' is returned.
 218  * You should allocate dest yourself, at least strlen(source) * 2 + 3.
 219  *
 220  */
 221 char *QuoteString(char *dest, const char *source)
 222 {
 223         int i = 0;
 224         *dest++ = '\'';
 225         for(i = 0; source[i]; i++)
 226         {
 227                 if (source[i] == '\'')
 228                 {
 229                         *dest++ = '\\';
 230                 }
 231                 *dest++ = source[i];
 232         }
 233         *dest++ = '\'';
 234         *dest = '\0';
 235
 236         return dest;
 237 }
 238
 239 /*
 240  * Adds delim around the source and escapes all characters in escape with
 241  * the corresponding escaper. The dest string must be preallocated.
 242  * delim should be included in escape with a proper escaper.
 243  * Returns a pointer to the end of dest.
 244  */
 245
 246 char *QuoteEscapeString(char *dest, const char *source, char delim,
 247                         const char *escape, const char *escaper)
 248 {
 249         *dest++ = delim;
 250         while (*source)
 251         {
 252                 char *esc;
 253                 esc = strchr(escape, *source);
 254                 if (esc != NULL)
 255                 {
 256                         *dest++ = escaper[(int)(esc-escape)];
 257                 }
 258                 *dest++ = *source++;
 259         }
 260         *dest++ = delim;
 261         *dest = '\0';
 262
 263         return dest;
 264 }
 265
 266 /*
 267  * Calculates the lenght needed by a escaped by QuoteEscapeString
 268  * the corresponding escaper.
 269  */
 270
 271 unsigned int QuoteEscapeStringLength(const char *source, const char *escape)
 272 {
 273         unsigned int len = 2;
 274
 275         while (*source)
 276         {
 277                 if (strchr(escape, *source) != NULL)
 278                 {
 279                         len++;
 280                 }
 281                 len++;
 282                 source++;
 283         }
 284
 285         return len;
 286 }