implement removeext, use it in dsload instead of splitpath
[btb/d2x.git] / misc / strutil.c
1 /* $Id: strutil.c,v 1.15 2004-12-20 07:12:25 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
115 // remove extension from filename, doesn't work with paths.
116 void removeext(const char *filename, char *out)
117 {
118         char *p;
119
120         if ((p = strrchr(filename, '.')))
121         {
122                 strncpy(out, filename, p - filename);
123                 out[p - filename] = 0;
124         }
125         else
126                 strcpy(out, filename);
127 }
128
129
130 #if !defined(__MSDOS__) && !(defined(_WIN32) && !defined(_WIN32_WCE))
131 void _splitpath(char *name, char *drive, char *path, char *base, char *ext)
132 {
133         char *s, *p;
134
135         p = name;
136         s = strchr(p, ':');
137         if ( s != NULL ) {
138                 if (drive) {
139                         *s = '\0';
140                         strcpy(drive, p);
141                         *s = ':';
142                 }
143                 p = s+1;
144                 if (!p)
145                         return;
146         } else if (drive)
147                 *drive = '\0';
148         
149         s = strrchr(p, '\\');
150         if ( s != NULL) {
151                 if (path) {
152                         char c;
153                         
154                         c = *(s+1);
155                         *(s+1) = '\0';
156                         strcpy(path, p);
157                         *(s+1) = c;
158                 }
159                 p = s+1;
160                 if (!p)
161                         return;
162         } else if (path)
163                 *path = '\0';
164
165         s = strchr(p, '.');
166         if ( s != NULL) {
167                 if (base) {
168                         *s = '\0';
169                         strcpy(base, p);
170                         *s = '.';
171                 }
172                 p = s+1;
173                 if (!p)
174                         return;
175         } else if (base)
176                 *base = '\0';
177                 
178         if (ext)
179                 strcpy(ext, p);         
180 }
181 #endif
182
183 #if 0
184 void main()
185 {
186         char drive[10], path[50], name[16], ext[5];
187         
188         drive[0] = path[0] = name[0] = ext[0] = '\0';
189         _splitpath("f:\\tmp\\x.out", drive, path, name, ext);
190         drive[0] = path[0] = name[0] = ext[0] = '\0';
191         _splitpath("tmp\\x.out", drive, path, name, ext);
192         drive[0] = path[0] = name[0] = ext[0] = '\0';
193         _splitpath("f:\\tmp\\a.out", NULL, NULL, name, NULL);
194         drive[0] = path[0] = name[0] = ext[0] = '\0';
195         _splitpath("tmp\\*.dem", drive, path, NULL, NULL);
196         drive[0] = path[0] = name[0] = ext[0] = '\0';
197         _splitpath(".\\tmp\\*.dem", drive, path, NULL, NULL);
198 }
199 #endif