misc/strutil.c

   1 /* $Id: strutil.c,v 1.14 2004-12-17 14:17:03 btb Exp $ */
   2 /*
   3 THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
   4 SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
   5 END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
   6 ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
   7 IN USING, DISPLAYING,  AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
   8 SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
   9 FREE PURPOSES.  IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
  10 CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES.  THE END-USER UNDERSTANDS
  11 AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.
  12 COPYRIGHT 1993-1999 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
  13 */
  14
  15 #ifdef HAVE_CONFIG_H
  16 #include <conf.h>
  17 #endif
  18
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <ctype.h>
  22 #include <string.h>
  23
  24 #include "u_mem.h"
  25 #include "error.h"
  26
  27 #ifdef macintosh
  28 # if defined(NDEBUG)
  29 char *strdup(const char *str)
  30 {
  31         char *newstr;
  32
  33         newstr = malloc(strlen(str) + 1);
  34         strcpy(newstr, str);
  35
  36         return newstr;
  37 }
  38 # endif // NDEBUG
  39
  40 // string compare without regard to case
  41
  42 int stricmp( const char *s1, const char *s2 )
  43 {
  44         int u1;
  45         int u2;
  46
  47         do {
  48                 u1 = toupper((int) *s1);
  49                 u2 = toupper((int) *s2);
  50                 if (u1 != u2)
  51                         return (u1 > u2) ? 1 : -1;
  52
  53                 s1++;
  54                 s2++;
  55         } while (u1 && u2);
  56
  57         return 0;
  58 }
  59
  60 int strnicmp( const char *s1, const char *s2, int n )
  61 {
  62         int u1;
  63         int u2;
  64
  65         do {
  66                 u1 = toupper((int) *s1);
  67                 u2 = toupper((int) *s2);
  68                 if (u1 != u2)
  69                         return (u1 > u2) ? 1 : -1;
  70
  71                 s1++;
  72                 s2++;
  73                 n--;
  74         } while (u1 && u2 && n);
  75
  76         return 0;
  77 }
  78 #endif
  79
  80 #ifndef _WIN32
  81 #ifndef __DJGPP__
  82 void strlwr( char *s1 )
  83 {
  84         while( *s1 )    {
  85                 *s1 = tolower(*s1);
  86                 s1++;
  87         }
  88 }
  89
  90 void strupr( char *s1 )
  91 {
  92         while( *s1 )    {
  93                 *s1 = toupper(*s1);
  94                 s1++;
  95         }
  96 }
  97
  98 #endif
  99
 100 void strrev( char *s1 )
 101 {
 102         char *h, *t;
 103         h = s1;
 104         t = s1 + strlen(s1) - 1;
 105         while (h < t) {
 106                 char c;
 107                 c = *h;
 108                 *h++ = *t;
 109                 *t-- = c;
 110         }
 111 }
 112 #endif
 113
 114 #if !defined(__MSDOS__) && !(defined(_WIN32) && !defined(_WIN32_WCE))
 115 void _splitpath(char *name, char *drive, char *path, char *base, char *ext)
 116 {
 117         char *s, *p;
 118
 119         p = name;
 120         s = strchr(p, ':');
 121         if ( s != NULL ) {
 122                 if (drive) {
 123                         *s = '\0';
 124                         strcpy(drive, p);
 125                         *s = ':';
 126                 }
 127                 p = s+1;
 128                 if (!p)
 129                         return;
 130         } else if (drive)
 131                 *drive = '\0';
 132
 133         s = strrchr(p, '\\');
 134         if ( s != NULL) {
 135                 if (path) {
 136                         char c;
 137
 138                         c = *(s+1);
 139                         *(s+1) = '\0';
 140                         strcpy(path, p);
 141                         *(s+1) = c;
 142                 }
 143                 p = s+1;
 144                 if (!p)
 145                         return;
 146         } else if (path)
 147                 *path = '\0';
 148
 149         s = strchr(p, '.');
 150         if ( s != NULL) {
 151                 if (base) {
 152                         *s = '\0';
 153                         strcpy(base, p);
 154                         *s = '.';
 155                 }
 156                 p = s+1;
 157                 if (!p)
 158                         return;
 159         } else if (base)
 160                 *base = '\0';
 161
 162         if (ext)
 163                 strcpy(ext, p);
 164 }
 165 #endif
 166
 167 #if 0
 168 void main()
 169 {
 170         char drive[10], path[50], name[16], ext[5];
 171
 172         drive[0] = path[0] = name[0] = ext[0] = '\0';
 173         _splitpath("f:\\tmp\\x.out", drive, path, name, ext);
 174         drive[0] = path[0] = name[0] = ext[0] = '\0';
 175         _splitpath("tmp\\x.out", drive, path, name, ext);
 176         drive[0] = path[0] = name[0] = ext[0] = '\0';
 177         _splitpath("f:\\tmp\\a.out", NULL, NULL, name, NULL);
 178         drive[0] = path[0] = name[0] = ext[0] = '\0';
 179         _splitpath("tmp\\*.dem", drive, path, NULL, NULL);
 180         drive[0] = path[0] = name[0] = ext[0] = '\0';
 181         _splitpath(".\\tmp\\*.dem", drive, path, NULL, NULL);
 182 }
 183 #endif