Remove -Wno-unused-but-set-variable
[xonotic/netradiant.git] / libs / splines / util_str.cpp
1 /*
2    Copyright (C) 1999-2006 Id Software, Inc. and contributors.
3    For a list of contributors, see the accompanying CONTRIBUTORS file.
4
5    This file is part of GtkRadiant.
6
7    GtkRadiant is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 2 of the License, or
10    (at your option) any later version.
11
12    GtkRadiant is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with GtkRadiant; if not, write to the Free Software
19    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
20  */
21
22 //need to rewrite this
23
24 #include "util_str.h"
25 #include <stdlib.h>
26 #include <ctype.h>
27 #include <stdio.h>
28 #include <stdarg.h>
29
30 #ifdef _WIN32
31 #pragma warning(disable : 4244)     // 'conversion' conversion from 'type1' to 'type2', possible loss of data
32 #pragma warning(disable : 4710)     // function 'blah' not inlined
33 #endif
34
35 static const int STR_ALLOC_GRAN = 20;
36
37 // screwy but intentional
38 #ifdef __APPLE_BUG__
39 char *idStr::__tolower
40 #else
41 char *idStr::tolower
42 #endif
43 (
44         char *s1
45 ){
46         char *s;
47
48         s = s1;
49         while ( *s )
50         {
51                 *s = ::tolower( *s );
52                 s++;
53         }
54
55         return s1;
56 }
57
58 // screwy but intentional
59 #ifdef __APPLE_BUG__
60 char *idStr::__toupper
61 #else
62 char *idStr::toupper
63 #endif
64 (
65         char *s1
66 ){
67         char *s;
68
69         s = s1;
70         while ( *s )
71         {
72                 *s = ::toupper( *s );
73                 s++;
74         }
75
76         return s1;
77 }
78
79 int idStr::icmpn
80 (
81         const char *s1,
82         const char *s2,
83         int n
84 ){
85         int c1;
86         int c2;
87
88         do
89         {
90                 c1 = *s1++;
91                 c2 = *s2++;
92
93                 if ( !n-- ) {
94                         // idStrings are equal until end point
95                         return 0;
96                 }
97
98                 if ( c1 != c2 ) {
99                         if ( c1 >= 'a' && c1 <= 'z' ) {
100                                 c1 -= ( 'a' - 'A' );
101                         }
102
103                         if ( c2 >= 'a' && c2 <= 'z' ) {
104                                 c2 -= ( 'a' - 'A' );
105                         }
106
107                         if ( c1 < c2 ) {
108                                 // strings less than
109                                 return -1;
110                         }
111                         else if ( c1 > c2 ) {
112                                 // strings greater than
113                                 return 1;
114                         }
115                 }
116         }
117         while ( c1 );
118
119         // strings are equal
120         return 0;
121 }
122
123 int idStr::icmp
124 (
125         const char *s1,
126         const char *s2
127 ){
128         int c1;
129         int c2;
130
131         do
132         {
133                 c1 = *s1++;
134                 c2 = *s2++;
135
136                 if ( c1 != c2 ) {
137                         if ( c1 >= 'a' && c1 <= 'z' ) {
138                                 c1 -= ( 'a' - 'A' );
139                         }
140
141                         if ( c2 >= 'a' && c2 <= 'z' ) {
142                                 c2 -= ( 'a' - 'A' );
143                         }
144
145                         if ( c1 < c2 ) {
146                                 // strings less than
147                                 return -1;
148                         }
149                         else if ( c1 > c2 ) {
150                                 // strings greater than
151                                 return 1;
152                         }
153                 }
154         }
155         while ( c1 );
156
157         // strings are equal
158         return 0;
159 }
160
161 int idStr::cmpn
162 (
163         const char *s1,
164         const char *s2,
165         int n
166 ){
167         int c1;
168         int c2;
169
170         do
171         {
172                 c1 = *s1++;
173                 c2 = *s2++;
174
175                 if ( !n-- ) {
176                         // strings are equal until end point
177                         return 0;
178                 }
179
180                 if ( c1 < c2 ) {
181                         // strings less than
182                         return -1;
183                 }
184                 else if ( c1 > c2 ) {
185                         // strings greater than
186                         return 1;
187                 }
188         }
189         while ( c1 );
190
191         // strings are equal
192         return 0;
193 }
194
195 int idStr::cmp
196 (
197         const char *s1,
198         const char *s2
199 ){
200         int c1;
201         int c2;
202
203         do
204         {
205                 c1 = *s1++;
206                 c2 = *s2++;
207
208                 if ( c1 < c2 ) {
209                         // strings less than
210                         return -1;
211                 }
212                 else if ( c1 > c2 ) {
213                         // strings greater than
214                         return 1;
215                 }
216         }
217         while ( c1 );
218
219         // strings are equal
220         return 0;
221 }
222
223 /*
224    ============
225    IsNumeric
226
227    Checks a string to see if it contains only numerical values.
228    ============
229  */
230 bool idStr::isNumeric
231 (
232         const char *str
233 ){
234         int len;
235         int i;
236         bool dot;
237
238         if ( *str == '-' ) {
239                 str++;
240         }
241
242         dot = false;
243         len = strlen( str );
244         for ( i = 0; i < len; i++ )
245         {
246                 if ( !isdigit( str[ i ] ) ) {
247                         if ( ( str[ i ] == '.' ) && !dot ) {
248                                 dot = true;
249                                 continue;
250                         }
251                         return false;
252                 }
253         }
254
255         return true;
256 }
257
258 idStr operator+
259 (
260         const idStr& a,
261         const float b
262 ){
263         char text[ 20 ];
264
265         idStr result( a );
266
267         sprintf( text, "%f", b );
268         result.append( text );
269
270         return result;
271 }
272
273 idStr operator+
274 (
275         const idStr& a,
276         const int b
277 ){
278         char text[ 20 ];
279
280         idStr result( a );
281
282         sprintf( text, "%d", b );
283         result.append( text );
284
285         return result;
286 }
287
288 idStr operator+
289 (
290         const idStr& a,
291         const unsigned b
292 ){
293         char text[ 20 ];
294
295         idStr result( a );
296
297         sprintf( text, "%u", b );
298         result.append( text );
299
300         return result;
301 }
302
303 idStr& idStr::operator+=
304 (
305         const float a
306 ){
307         char text[ 20 ];
308
309         sprintf( text, "%f", a );
310         append( text );
311
312         return *this;
313 }
314
315 idStr& idStr::operator+=
316 (
317         const int a
318 ){
319         char text[ 20 ];
320
321         sprintf( text, "%d", a );
322         append( text );
323
324         return *this;
325 }
326
327 idStr& idStr::operator+=
328 (
329         const unsigned a
330 ){
331         char text[ 20 ];
332
333         sprintf( text, "%u", a );
334         append( text );
335
336         return *this;
337 }
338
339 void idStr::CapLength
340 (
341         int newlen
342 ){
343         assert( m_data );
344
345         if ( length() <= newlen ) {
346                 return;
347         }
348
349         EnsureDataWritable();
350
351         m_data->data[newlen] = 0;
352         m_data->len = newlen;
353 }
354
355 void idStr::EnsureDataWritable
356 (
357         void
358 ){
359         assert( m_data );
360         strdata *olddata;
361         int len;
362
363         if ( !m_data->refcount ) {
364                 return;
365         }
366
367         olddata = m_data;
368         len = length();
369
370         m_data = new strdata;
371
372         EnsureAlloced( len + 1, false );
373         strncpy( m_data->data, olddata->data, len + 1 );
374         m_data->len = len;
375
376         olddata->DelRef();
377 }
378
379 void idStr::EnsureAlloced( int amount, bool keepold ) {
380
381         if ( !m_data ) {
382                 m_data = new strdata();
383         }
384
385         // Now, let's make sure it's writable
386         EnsureDataWritable();
387
388         char *newbuffer;
389         bool wasalloced = ( m_data->alloced != 0 );
390
391         if ( amount < m_data->alloced ) {
392                 return;
393         }
394
395         assert( amount );
396         if ( amount == 1 ) {
397                 m_data->alloced = 1;
398         }
399         else {
400                 int newsize, mod;
401                 mod = amount % STR_ALLOC_GRAN;
402                 if ( !mod ) {
403                         newsize = amount;
404                 }
405                 else {
406                         newsize = amount + STR_ALLOC_GRAN - mod;
407                 }
408                 m_data->alloced = newsize;
409         }
410
411         newbuffer = new char[m_data->alloced];
412         if ( wasalloced && keepold ) {
413                 strcpy( newbuffer, m_data->data );
414         }
415
416         if ( m_data->data ) {
417                 delete [] m_data->data;
418         }
419         m_data->data = newbuffer;
420 }
421
422 void idStr::BackSlashesToSlashes
423 (
424         void
425 ){
426         int i;
427
428         EnsureDataWritable();
429
430         for ( i = 0; i < m_data->len; i++ )
431         {
432                 if ( m_data->data[i] == '\\' ) {
433                         m_data->data[i] = '/';
434                 }
435         }
436 }
437
438 void idStr::snprintf
439 (
440         char *dst,
441         int size,
442         const char *fmt,
443         ...
444 ){
445         char buffer[0x10000];
446         int len;
447         va_list argptr;
448
449         va_start( argptr,fmt );
450         len = vsprintf( buffer,fmt,argptr );
451         va_end( argptr );
452
453         assert( len < size );
454
455         strncpy( dst, buffer, size - 1 );
456 }
457
458 #ifdef _WIN32
459 #pragma warning(disable : 4189)     // local variable is initialized but not referenced
460 #endif
461
462 /*
463    =================
464    TestStringClass
465
466    This is a fairly rigorous test of the idStr class's functionality.
467    Because of the fairly global and subtle ramifications of a bug occuring
468    in this class, it should be run after any changes to the class.
469    Add more tests as functionality is changed.  Tests should include
470    any possible bounds violation and NULL data tests.
471    =================
472  */
473 void TestStringClass
474 (
475         void
476 ){
477         char ch;                            // ch == ?
478         (void) ch;
479         idStr   *t;                         // t == ?
480         idStr a;                                // a.len == 0, a.data == "\0"
481         idStr b;                                // b.len == 0, b.data == "\0"
482         idStr c( "test" );                  // c.len == 4, c.data == "test\0"
483         idStr d( c );                       // d.len == 4, d.data == "test\0"
484         idStr e( reinterpret_cast<const char *>( NULL ) );
485         // e.len == 0, e.data == "\0"                                   ASSERT!
486         int i;                              // i == ?
487         (void) i;
488
489         i = a.length();                 // i == 0
490         i = c.length();                 // i == 4
491
492         t = new idStr();                        // t->len == 0, t->data == "\0"
493         delete t;                           // t == ?
494
495         b = "test";                         // b.len == 4, b.data == "test\0"
496         t = new idStr( "test" );            // t->len == 4, t->data == "test\0"
497         delete t;                           // t == ?
498
499         a = c;                              // a.len == 4, a.data == "test\0"
500 //   a = "";
501         a = NULL;                           // a.len == 0, a.data == "\0"                                       ASSERT!
502         a = c + d;                          // a.len == 8, a.data == "testtest\0"
503         a = c + "wow";                      // a.len == 7, a.data == "testwow\0"
504         a = c + reinterpret_cast<const char *>( NULL );
505         // a.len == 4, a.data == "test\0"                       ASSERT!
506         a = "this" + d;                 // a.len == 8, a.data == "thistest\0"
507         a = reinterpret_cast<const char *>( NULL ) + d;
508         // a.len == 4, a.data == "test\0"                       ASSERT!
509         a += c;                             // a.len == 8, a.data == "testtest\0"
510         a += "wow";                         // a.len == 11, a.data == "testtestwow\0"
511         a += reinterpret_cast<const char *>( NULL );
512         // a.len == 11, a.data == "testtestwow\0"       ASSERT!
513
514         a = "test";                         // a.len == 4, a.data == "test\0"
515         ch = a[ 0 ];                        // ch == 't'
516         ch = a[ -1 ];                       // ch == 0                                                                                  ASSERT!
517         ch = a[ 1000 ];                 // ch == 0                                                                                      ASSERT!
518         ch = a[ 0 ];                        // ch == 't'
519         ch = a[ 1 ];                        // ch == 'e'
520         ch = a[ 2 ];                        // ch == 's'
521         ch = a[ 3 ];                        // ch == 't'
522         ch = a[ 4 ];                        // ch == '\0'                                                                               ASSERT!
523         ch = a[ 5 ];                        // ch == '\0'                                                                               ASSERT!
524
525         a[ 1 ] = 'b';                       // a.len == 4, a.data == "tbst\0"
526         a[ -1 ] = 'b';                      // a.len == 4, a.data == "tbst\0"                   ASSERT!
527         a[ 0 ] = '0';                       // a.len == 4, a.data == "0bst\0"
528         a[ 1 ] = '1';                       // a.len == 4, a.data == "01st\0"
529         a[ 2 ] = '2';                       // a.len == 4, a.data == "012t\0"
530         a[ 3 ] = '3';                       // a.len == 4, a.data == "0123\0"
531         a[ 4 ] = '4';                       // a.len == 4, a.data == "0123\0"                   ASSERT!
532         a[ 5 ] = '5';                       // a.len == 4, a.data == "0123\0"                   ASSERT!
533         a[ 7 ] = '7';                       // a.len == 4, a.data == "0123\0"                   ASSERT!
534
535         a = "test";                         // a.len == 4, a.data == "test\0"
536         b = "no";                           // b.len == 2, b.data == "no\0"
537
538         i = ( a == b );                 // i == 0
539         i = ( a == c );                 // i == 1
540
541         i = ( a == "blow" );                // i == 0
542         i = ( a == "test" );                // i == 1
543         i = ( a == NULL );              // i == 0                                                                                       ASSERT!
544
545         i = ( "test" == b );                // i == 0
546         i = ( "test" == a );                // i == 1
547         i = ( NULL == a );              // i == 0                                                                                       ASSERT!
548
549         i = ( a != b );                 // i == 1
550         i = ( a != c );                 // i == 0
551
552         i = ( a != "blow" );                // i == 1
553         i = ( a != "test" );                // i == 0
554         i = ( a != NULL );              // i == 1                                                                                       ASSERT!
555
556         i = ( "test" != b );                // i == 1
557         i = ( "test" != a );                // i == 0
558         i = ( NULL != a );              // i == 1                                                                                       ASSERT!
559
560         a = "test";                  // a.data == "test"
561         b = a;                       // b.data == "test"
562
563         a = "not";                  // a.data == "not", b.data == "test"
564
565         a = b;                       // a.data == b.data == "test"
566
567         a += b;                      // a.data == "testtest", b.data = "test"
568
569         a = b;
570
571         a[1] = '1';                  // a.data = "t1st", b.data = "test"
572 }
573
574 #ifdef _WIN32
575 #pragma warning(default : 4189)     // local variable is initialized but not referenced
576 #pragma warning(disable : 4514)     // unreferenced inline function has been removed
577 #endif