ff18ecef2e5bc91440a8d20538d183447f4c46b6
[btb/d2x.git] / 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