]> de.git.xonotic.org Git - xonotic/netradiant.git/blob - tools/quake2/extra/qe4/cmdlib.c
Merge commit '0d5ebb17b29d4263ec4f1634af24a27620ab47a4' into garux-merge
[xonotic/netradiant.git] / tools / quake2 / extra / qe4 / cmdlib.c
1 /*
2 ===========================================================================
3 Copyright (C) 1997-2006 Id Software, Inc.
4
5 This file is part of Quake 2 Tools source code.
6
7 Quake 2 Tools source code is free software; you can redistribute it
8 and/or modify it under the terms of the GNU General Public License as
9 published by the Free Software Foundation; either version 2 of the License,
10 or (at your option) any later version.
11
12 Quake 2 Tools source code is distributed in the hope that it will be
13 useful, 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 Quake 2 Tools source code; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
20 ===========================================================================
21 */
22
23 // cmdlib.c
24
25 #include "cmdlib.h"
26 #include "globaldefs.h"
27
28 #define PATHSEPERATOR   '/'
29
30 char            com_token[1024];
31 qboolean        com_eof;
32
33 /*
34 ================
35 I_FloatTime
36 ================
37 */
38 double I_FloatTime (void)
39 {
40         time_t  t;
41
42         time (&t);
43
44         return t;
45 #if 0
46 // more precise, less portable
47         struct timeval tp;
48         struct timezone tzp;
49         static int              secbase;
50
51         gettimeofday(&tp, &tzp);
52
53         if (!secbase)
54         {
55                 secbase = tp.tv_sec;
56                 return tp.tv_usec/1000000.0;
57         }
58
59         return (tp.tv_sec - secbase) + tp.tv_usec/1000000.0;
60 #endif
61 }
62
63
64 /*
65 ==============
66 COM_Parse
67
68 Parse a token out of a string
69 ==============
70 */
71 char *COM_Parse (char *data)
72 {
73         int             c;
74         int             len;
75
76         len = 0;
77         com_token[0] = 0;
78
79         if (!data)
80                 return NULL;
81
82 // skip whitespace
83 skipwhite:
84         while ( (c = *data) <= ' ')
85         {
86                 if (c == 0)
87                 {
88                         com_eof = true;
89                         return NULL;                    // end of file;
90                 }
91                 data++;
92         }
93
94 // skip // comments
95         if (c=='/' && data[1] == '/')
96         {
97                 while (*data && *data != '\n')
98                         data++;
99                 goto skipwhite;
100         }
101
102
103 // handle quoted strings specially
104         if (c == '\"')
105         {
106                 data++;
107                 do
108                 {
109                         c = *data++;
110                         if (c=='\"')
111                         {
112                                 com_token[len] = 0;
113                                 return data;
114                         }
115                         com_token[len] = c;
116                         len++;
117                 } while (1);
118         }
119
120 // parse single characters
121         if (c=='{' || c=='}'|| c==')'|| c=='(' || c=='\'' || c==':')
122         {
123                 com_token[len] = c;
124                 len++;
125                 com_token[len] = 0;
126                 return data+1;
127         }
128
129 // parse a regular word
130         do
131         {
132                 com_token[len] = c;
133                 data++;
134                 len++;
135                 c = *data;
136         if (c=='{' || c=='}'|| c==')'|| c=='(' || c=='\'' || c==':')
137                         break;
138         } while (c>32);
139
140         com_token[len] = 0;
141         return data;
142 }
143
144
145 int Q_strncasecmp (char *s1, char *s2, int n)
146 {
147         int             c1, c2;
148
149         while (1)
150         {
151                 c1 = *s1++;
152                 c2 = *s2++;
153
154                 if (!n--)
155                         return 0;               // strings are equal until end point
156
157                 if (c1 != c2)
158                 {
159                         if (c1 >= 'a' && c1 <= 'z')
160                                 c1 -= ('a' - 'A');
161                         if (c2 >= 'a' && c2 <= 'z')
162                                 c2 -= ('a' - 'A');
163                         if (c1 != c2)
164                                 return -1;              // strings not equal
165                 }
166                 if (!c1)
167                         return 0;               // strings are equal
168         }
169
170         return -1;
171 }
172
173 int Q_strcasecmp (char *s1, char *s2)
174 {
175         return Q_strncasecmp (s1, s2, 99999);
176 }
177
178
179
180 /*
181 =============================================================================
182
183                                                 MISC FUNCTIONS
184
185 =============================================================================
186 */
187
188
189 int             argc;
190 char    *argv[MAX_NUM_ARGVS];
191
192 /*
193 ============
194 ParseCommandLine
195 ============
196 */
197 void ParseCommandLine (char *lpCmdLine)
198 {
199         argc = 1;
200         argv[0] = "programname";
201
202         while (*lpCmdLine && (argc < MAX_NUM_ARGVS))
203         {
204                 while (*lpCmdLine && ((*lpCmdLine <= 32) || (*lpCmdLine > 126)))
205                         lpCmdLine++;
206
207                 if (*lpCmdLine)
208                 {
209                         argv[argc] = lpCmdLine;
210                         argc++;
211
212                         while (*lpCmdLine && ((*lpCmdLine > 32) && (*lpCmdLine <= 126)))
213                                 lpCmdLine++;
214
215                         if (*lpCmdLine)
216                         {
217                                 *lpCmdLine = 0;
218                                 lpCmdLine++;
219                         }
220
221                 }
222         }
223 }
224
225
226
227 /*
228 =================
229 CheckParm
230
231 Checks for the given parameter in the program's command line arguments
232 Returns the argument number (1 to argc-1) or 0 if not present
233 =================
234 */
235 int CheckParm (char *check)
236 {
237         int             i;
238
239         for (i = 1;i<argc;i++)
240         {
241                 if ( !Q_strcasecmp(check, argv[i]) )
242                         return i;
243         }
244
245         return 0;
246 }
247
248
249
250 /*
251 ================
252 Q_filelength
253 ================
254 */
255 int Q_filelength (FILE *f)
256 {
257         int             pos;
258         int             end;
259
260         pos = ftell (f);
261         fseek (f, 0, SEEK_END);
262         end = ftell (f);
263         fseek (f, pos, SEEK_SET);
264
265         return end;
266 }
267
268
269 FILE *SafeOpenWrite (char *filename)
270 {
271         FILE    *f;
272
273         f = fopen(filename, "wb");
274
275         if (!f)
276                 Error ("Error opening %s: %s",filename,strerror(errno));
277
278         return f;
279 }
280
281 FILE *SafeOpenRead (char *filename)
282 {
283         FILE    *f;
284
285         f = fopen(filename, "rb");
286
287         if (!f)
288                 Error ("Error opening %s: %s",filename,strerror(errno));
289
290         return f;
291 }
292
293
294 void SafeRead (FILE *f, void *buffer, int count)
295 {
296         if ( (int)fread (buffer, 1, count, f) != count)
297                 Error ("File read failure");
298 }
299
300
301 void SafeWrite (FILE *f, void *buffer, int count)
302 {
303         if ( (int)fwrite (buffer, 1, count, f) != count)
304                 Error ("File read failure");
305 }
306
307
308
309 /*
310 ==============
311 LoadFile
312 ==============
313 */
314 int    LoadFile (char *filename, void **bufferptr)
315 {
316         FILE    *f;
317         int    length;
318         void    *buffer;
319         extern void *qmalloc( size_t size );
320
321         f = fopen (filename, "rb");
322         if (!f)
323         {
324                 *bufferptr = NULL;
325                 return -1;
326         }
327         length = Q_filelength (f);
328         buffer = qmalloc (length+1);
329         ((char *)buffer)[length] = 0;
330         SafeRead (f, buffer, length);
331         fclose (f);
332
333         *bufferptr = buffer;
334         return length;
335 }
336
337
338 /*
339 ==============
340 LoadFileNoCrash
341
342 returns -1 length if not present
343 ==============
344 */
345 int    LoadFileNoCrash (char *filename, void **bufferptr)
346 {
347         FILE    *f;
348         int    length;
349         void    *buffer;
350
351         f = fopen (filename, "rb");
352         if (!f)
353                 return -1;
354         length = Q_filelength (f);
355         buffer = qmalloc (length+1);
356         ((char *)buffer)[length] = 0;
357         SafeRead (f, buffer, length);
358         fclose (f);
359
360         *bufferptr = buffer;
361         return length;
362 }
363
364
365 /*
366 ==============
367 SaveFile
368 ==============
369 */
370 void    SaveFile (char *filename, void *buffer, int count)
371 {
372         FILE    *f;
373
374         f = SafeOpenWrite (filename);
375         SafeWrite (f, buffer, count);
376         fclose (f);
377 }
378
379
380
381 void DefaultExtension (char *path, char *extension)
382 {
383         char    *src;
384 //
385 // if path doesn't have a .EXT, append extension
386 // (extension should include the .)
387 //
388         src = path + strlen(path) - 1;
389
390         while (*src != PATHSEPERATOR && src != path)
391         {
392                 if (*src == '.')
393                         return;                 // it has an extension
394                 src--;
395         }
396
397         strcat (path, extension);
398 }
399
400
401 void DefaultPath (char *path, char *basepath)
402 {
403         char    temp[128];
404
405         if (path[0] == PATHSEPERATOR)
406                 return;                   // absolute path location
407         strcpy (temp,path);
408         strcpy (path,basepath);
409         strcat (path,temp);
410 }
411
412
413 void    StripFilename (char *path)
414 {
415         int             length;
416
417         length = strlen(path)-1;
418         while (length > 0 && path[length] != PATHSEPERATOR)
419                 length--;
420         path[length] = 0;
421 }
422
423 void    StripExtension (char *path)
424 {
425         int             length;
426
427         length = strlen(path)-1;
428         while (length > 0 && path[length] != '.')
429         {
430                 length--;
431                 if (path[length] == '/')
432                         return;         // no extension
433         }
434         if (length)
435                 path[length] = 0;
436 }
437
438
439 /*
440 ====================
441 Extract file parts
442 ====================
443 */
444 void ExtractFilePath (char *path, char *dest)
445 {
446         char    *src;
447
448         src = path + strlen(path) - 1;
449
450 //
451 // back up until a \ or the start
452 //
453         while (src != path && *(src-1) != PATHSEPERATOR)
454                 src--;
455
456         memcpy (dest, path, src-path);
457         dest[src-path] = 0;
458 }
459
460 void ExtractFileName (char *path, char *dest)
461 {
462         char    *src;
463
464         src = path + strlen(path) - 1;
465
466 //
467 // back up until a \ or the start
468 //
469         while (src != path && *(src-1) != '/'
470                  && *(src-1) != '\\' )
471                 src--;
472
473         while (*src)
474         {
475                 *dest++ = *src++;
476         }
477         *dest = 0;
478 }
479
480 void ExtractFileBase (char *path, char *dest)
481 {
482         char    *src;
483
484         src = path + strlen(path) - 1;
485
486 //
487 // back up until a \ or the start
488 //
489         while (src != path && *(src-1) != '/'
490                  && *(src-1) != '\\' )
491                 src--;
492
493         while (*src && *src != '.')
494         {
495                 *dest++ = *src++;
496         }
497         *dest = 0;
498 }
499
500 void ExtractFileExtension (char *path, char *dest)
501 {
502         char    *src;
503
504         src = path + strlen(path) - 1;
505
506 //
507 // back up until a . or the start
508 //
509         while (src != path && *(src-1) != '.')
510                 src--;
511         if (src == path)
512         {
513                 *dest = 0;      // no extension
514                 return;
515         }
516
517         strcpy (dest,src);
518 }
519
520
521 /*
522 ==============
523 ParseNum / ParseHex
524 ==============
525 */
526 int ParseHex (char *hex)
527 {
528         char    *str;
529         int    num;
530
531         num = 0;
532         str = hex;
533
534         while (*str)
535         {
536                 num <<= 4;
537                 if (*str >= '0' && *str <= '9')
538                         num += *str-'0';
539                 else if (*str >= 'a' && *str <= 'f')
540                         num += 10 + *str-'a';
541                 else if (*str >= 'A' && *str <= 'F')
542                         num += 10 + *str-'A';
543                 else
544                         Error ("Bad hex number: %s",hex);
545                 str++;
546         }
547
548         return num;
549 }
550
551
552 int ParseNum (char *str)
553 {
554         if (str[0] == '$')
555                 return ParseHex (str+1);
556         if (str[0] == '0' && str[1] == 'x')
557                 return ParseHex (str+2);
558         return atol (str);
559 }
560
561
562
563 /*
564 ============================================================================
565
566                                         BYTE ORDER FUNCTIONS
567
568 ============================================================================
569 */
570
571 #if GDEF_ARCH_ENDIAN_BIG
572
573 short   LittleShort (short l)
574 {
575         byte    b1,b2;
576
577         b1 = l&255;
578         b2 = (l>>8)&255;
579
580         return (b1<<8) + b2;
581 }
582
583 short   BigShort (short l)
584 {
585         return l;
586 }
587
588
589 int    LittleLong (int l)
590 {
591         byte    b1,b2,b3,b4;
592
593         b1 = l&255;
594         b2 = (l>>8)&255;
595         b3 = (l>>16)&255;
596         b4 = (l>>24)&255;
597
598         return ((int)b1<<24) + ((int)b2<<16) + ((int)b3<<8) + b4;
599 }
600
601 int    BigLong (int l)
602 {
603         return l;
604 }
605
606
607 float   LittleFloat (float l)
608 {
609         union {byte b[4]; float f;} in, out;
610
611         in.f = l;
612         out.b[0] = in.b[3];
613         out.b[1] = in.b[2];
614         out.b[2] = in.b[1];
615         out.b[3] = in.b[0];
616
617         return out.f;
618 }
619
620 float   BigFloat (float l)
621 {
622         return l;
623 }
624
625
626 #else
627
628
629 short   BigShort (short l)
630 {
631         byte    b1,b2;
632
633         b1 = l&255;
634         b2 = (l>>8)&255;
635
636         return (b1<<8) + b2;
637 }
638
639 short   LittleShort (short l)
640 {
641         return l;
642 }
643
644
645 int    BigLong (int l)
646 {
647         byte    b1,b2,b3,b4;
648
649         b1 = l&255;
650         b2 = (l>>8)&255;
651         b3 = (l>>16)&255;
652         b4 = (l>>24)&255;
653
654         return ((int)b1<<24) + ((int)b2<<16) + ((int)b3<<8) + b4;
655 }
656
657 int    LittleLong (int l)
658 {
659         return l;
660 }
661
662 float   BigFloat (float l)
663 {
664         union {byte b[4]; float f;} in, out;
665
666         in.f = l;
667         out.b[0] = in.b[3];
668         out.b[1] = in.b[2];
669         out.b[2] = in.b[1];
670         out.b[3] = in.b[0];
671
672         return out.f;
673 }
674
675 float   LittleFloat (float l)
676 {
677         return l;
678 }
679
680
681
682 #endif
683