sourcemm/util.cpp
author David Anderson <dvander@alliedmods.net>
Wed May 02 14:18:20 2007 +0000 (2007-05-02)
changeset 321 0ebefd20aad7
parent 320 c955cb69efe3
child 338 3f8caf9ea756
permissions -rw-r--r--
added linux support to UTIL_Relatize()
dvander@7
     1
/* ======== SourceMM ========
dvander@282
     2
 * Copyright (C) 2004-2007 Metamod:Source Development Team
dvander@282
     3
 * No warranties of any kind
dvander@282
     4
 *
dvander@282
     5
 * License: zlib/libpng
dvander@282
     6
 *
dvander@282
     7
 * Author(s): David "BAILOPAN" Anderson
dvander@282
     8
 * ============================
dvander@282
     9
 */
dvander@7
    10
ds@84
    11
#include <ctype.h>
dvander@7
    12
#include <string.h>
dvander@122
    13
#include <stdio.h>
dvander@7
    14
#include "util.h"
dvander@122
    15
#include "oslink.h"
dvander@7
    16
dvander@7
    17
/**
ds@296
    18
 * @brief Utility functions
dvander@7
    19
 * @file util.cpp
dvander@7
    20
 */
dvander@7
    21
dvander@7
    22
const char *UTIL_GetExtension(const char *file)
dvander@7
    23
{
dvander@7
    24
	int len = strlen(file);
dvander@7
    25
	int i = 0;
dvander@7
    26
ds@296
    27
	for (i = len - 1; i >= 0; i--)
dvander@7
    28
	{
dvander@7
    29
		if (file[i] == '/' || file[i] == '\\')
ds@296
    30
		{
dvander@7
    31
			return NULL;
ds@296
    32
		}
dvander@7
    33
ds@296
    34
		if ((file[i] == '.') && (i != len - 1))
dvander@7
    35
		{
ds@296
    36
			return (const char *)&(file[i + 1]);
dvander@7
    37
		}
dvander@7
    38
	}
dvander@7
    39
dvander@7
    40
	return NULL;
dvander@33
    41
}
dvander@33
    42
ds@84
    43
void UTIL_TrimLeft(char *buffer)
ds@84
    44
{
ds@296
    45
	/* Let's think of this as our iterator */
ds@84
    46
	char *i = buffer;
ds@84
    47
ds@296
    48
	/* Make sure the buffer isn't null */
ds@84
    49
	if (i && *i)
ds@84
    50
	{
ds@296
    51
		/* Add up number of whitespace characters */
ds@296
    52
		while(isspace((unsigned char) *i))
ds@296
    53
		{
ds@84
    54
			i++;
ds@296
    55
		}
ds@84
    56
ds@296
    57
		/* If whitespace chars in buffer then adjust string so first non-whitespace char is at start of buffer */
ds@84
    58
		if (i != buffer)
ds@296
    59
		{
ds@255
    60
			memmove(buffer, i, (strlen(i) + 1) * sizeof(char));
ds@296
    61
		}
ds@84
    62
	}
ds@84
    63
}
ds@84
    64
ds@296
    65
void UTIL_TrimRight(char *buffer)
ds@296
    66
{
ds@296
    67
	/* Make sure buffer isn't null */
ds@296
    68
	if (buffer)
ds@296
    69
	{
ds@296
    70
		size_t len = strlen(buffer);
ds@296
    71
ds@296
    72
		/* Loop through buffer backwards while replacing whitespace chars with null chars */
ds@296
    73
		for (size_t i = len - 1; i >= 0; i--)
ds@296
    74
		{
ds@296
    75
			if (isspace((unsigned char) buffer[i]))
ds@296
    76
			{
ds@296
    77
				buffer[i] = '\0';
ds@296
    78
			} else {
ds@296
    79
				break;
ds@296
    80
			}
ds@296
    81
		}
ds@296
    82
	}
ds@296
    83
}
ds@296
    84
ds@296
    85
/* :TODO: this should skip string literals */
dvander@122
    86
void UTIL_TrimComments(char *buffer)
dvander@122
    87
{
dvander@122
    88
	int num_sc = 0;
dvander@122
    89
	size_t len = strlen(buffer);
dvander@122
    90
	if (buffer)
dvander@122
    91
	{
ds@296
    92
		for (int i = len - 1; i >= 0; i--)
dvander@122
    93
		{
dvander@122
    94
			if (buffer[i] == '/')
dvander@122
    95
			{
dvander@122
    96
				if (++num_sc >= 2 && i==0)
dvander@122
    97
				{
dvander@122
    98
					buffer[i] = '\0';
dvander@122
    99
					return;
dvander@122
   100
				}
dvander@122
   101
			} else {
dvander@122
   102
				if (num_sc >= 2)
dvander@122
   103
				{
dvander@122
   104
					buffer[i] = '\0';
dvander@122
   105
					return;
dvander@122
   106
				}
dvander@122
   107
				num_sc = 0;
dvander@122
   108
			}
ds@296
   109
			/* size_t won't go below 0, manually break out */
dvander@122
   110
			if (i == 0)
ds@296
   111
			{
dvander@122
   112
				break;
ds@296
   113
			}
dvander@122
   114
		}
dvander@122
   115
	}
dvander@122
   116
}
dvander@122
   117
dvander@122
   118
void UTIL_KeySplit(const char *str, char *buf1, size_t len1, char *buf2, size_t len2)
dvander@122
   119
{
dvander@122
   120
	size_t start;
dvander@122
   121
	size_t len = strlen(str);
dvander@122
   122
ds@296
   123
	for (start = 0; start < len; start++)
dvander@122
   124
	{
dvander@122
   125
		if (!isspace(str[start]))
ds@296
   126
		{
dvander@122
   127
			break;
ds@296
   128
		}
dvander@122
   129
	}
dvander@122
   130
dvander@122
   131
	size_t end;
ds@296
   132
	for (end = start; end < len; end++)
dvander@122
   133
	{
dvander@122
   134
		if (isspace(str[end]))
ds@296
   135
		{
dvander@122
   136
			break;
ds@296
   137
		}
dvander@122
   138
	}
dvander@122
   139
	
ds@296
   140
	size_t i, c = 0;
ds@296
   141
	for (i = start; i < end; i++, c++)
dvander@122
   142
	{
dvander@122
   143
		if (c >= len1)
ds@296
   144
		{
dvander@122
   145
			break;
ds@296
   146
		}
dvander@122
   147
		buf1[c] = str[i];
dvander@122
   148
	}
dvander@122
   149
	buf1[c] = '\0';
dvander@122
   150
ds@296
   151
	for (start = end; start < len; start++)
dvander@122
   152
	{
dvander@122
   153
		if (!isspace(str[start]))
ds@296
   154
		{
dvander@122
   155
			break;
ds@296
   156
		}
dvander@122
   157
	}
dvander@122
   158
ds@296
   159
	for (c = 0; start < len; start++, c++)
dvander@122
   160
	{
dvander@122
   161
		if (c >= len2)
ds@296
   162
		{
dvander@122
   163
			break;
ds@296
   164
		}
dvander@122
   165
		buf2[c] = str[start];
dvander@122
   166
	}
dvander@122
   167
	buf2[c] = '\0';
dvander@122
   168
}
dvander@122
   169
dvander@122
   170
bool UTIL_PathCmp(const char *path1, const char *path2)
dvander@122
   171
{
ds@238
   172
	size_t pos1 = 0, pos2 = 0;
dvander@122
   173
dvander@122
   174
	while (true)
dvander@122
   175
	{
dvander@122
   176
		if (path1[pos1] == '\0' || path2[pos2] == '\0')
dvander@122
   177
		{
dvander@122
   178
			return (path1[pos1] == path2[pos2]);
dvander@122
   179
		}
dvander@122
   180
dvander@122
   181
		if (path1[pos1] == PATH_SEP_CHAR)
dvander@122
   182
		{
dvander@122
   183
			if (path2[pos2] != PATH_SEP_CHAR)
ds@296
   184
			{
dvander@122
   185
				return false;
ds@296
   186
			}
ds@296
   187
ds@296
   188
			/* Look for extra path chars */
dvander@122
   189
			while (path1[++pos1])
dvander@122
   190
			{
dvander@122
   191
				if (path1[pos1] != PATH_SEP_CHAR)
ds@296
   192
				{
dvander@122
   193
					break;
ds@296
   194
				}
dvander@122
   195
			}
dvander@122
   196
			while (path2[++pos2])
dvander@122
   197
			{
dvander@122
   198
				if (path2[pos2] != PATH_SEP_CHAR)
ds@296
   199
				{
dvander@122
   200
					break;
ds@296
   201
				}
dvander@122
   202
			}
dvander@122
   203
			continue;
dvander@122
   204
		}
dvander@122
   205
ds@296
   206
		/* If we're at a different non-alphanumeric, the next character MUST match */
dvander@122
   207
		if (!isalpha(path1[pos1]) && (path1[pos1] != path2[pos2]))
ds@296
   208
		{
dvander@122
   209
			return false;
ds@296
   210
		}
dvander@122
   211
ds@296
   212
	#ifdef WIN32
dvander@122
   213
		if (toupper(path1[pos1]) != toupper(path2[pos2]))
ds@296
   214
	#else
dvander@122
   215
		if (path1[pos1] != path2[pos2])
ds@296
   216
	#endif
ds@296
   217
		{
dvander@122
   218
			return false;
ds@296
   219
		}
ds@296
   220
dvander@122
   221
		pos1++;
dvander@122
   222
		pos2++;
dvander@122
   223
	}
dvander@122
   224
}
ds@296
   225
ds@296
   226
size_t UTIL_Format(char *buffer, size_t maxlength, const char *fmt, ...)
ds@296
   227
{
ds@296
   228
	va_list ap;
ds@296
   229
ds@296
   230
	va_start(ap, fmt);
ds@296
   231
	size_t len = vsnprintf(buffer, maxlength, fmt, ap);
ds@296
   232
	va_end(ap);
ds@296
   233
ds@296
   234
	if (len >= maxlength)
ds@296
   235
	{
ds@296
   236
		len = maxlength - 1;
ds@296
   237
		buffer[len] = '\0';
ds@296
   238
	}
ds@296
   239
ds@296
   240
	return len;
ds@296
   241
}
dvander@320
   242
dvander@320
   243
inline bool pathchar_isalpha(char a)
dvander@320
   244
{
dvander@320
   245
	return (((a & 1<<7) == 0) && isalpha(a));
dvander@320
   246
}
dvander@320
   247
dvander@320
   248
inline bool pathchar_sep(char a)
dvander@320
   249
{
dvander@320
   250
#if defined WIN32
dvander@320
   251
	return (a == '/' || a == '\\');
dvander@320
   252
#elif defined __linux__
dvander@320
   253
	return (a == '/');
dvander@320
   254
#endif
dvander@320
   255
}
dvander@320
   256
dvander@320
   257
inline bool pathstr_isabsolute(const char *str)
dvander@320
   258
{
dvander@320
   259
#if defined WIN32
dvander@320
   260
	return (pathchar_isalpha(str[0]) 
dvander@320
   261
		&& str[1] == ':' 
dvander@320
   262
		&& pathchar_sep(str[2]));
dvander@320
   263
#elif defined __linux__
dvander@320
   264
	return (str[0] == '/');
dvander@320
   265
#endif
dvander@320
   266
}
dvander@320
   267
dvander@320
   268
inline bool pathchar_cmp(char a, char b)
dvander@320
   269
{
dvander@320
   270
#if defined WIN32
dvander@320
   271
	if (pathchar_isalpha(a) && pathchar_isalpha(b))
dvander@320
   272
	{
dvander@320
   273
		return (tolower(a) == tolower(b));
dvander@320
   274
	}
dvander@320
   275
	/* Either path separator is acceptable */
dvander@320
   276
	if (pathchar_sep(a))
dvander@320
   277
	{
dvander@320
   278
		return pathchar_sep(b);
dvander@320
   279
	}
dvander@320
   280
#endif
dvander@320
   281
	return (a == b);
dvander@320
   282
}
dvander@320
   283
dvander@320
   284
/**
dvander@320
   285
 * @brief Forms a relative path given two absolute paths.
dvander@320
   286
 *
dvander@320
   287
 * @param buffer		Buffer to store relative path in.
dvander@320
   288
 * @param maxlength		Maximum length of the output buffer.
dvander@320
   289
 * @param relTo			Destination folder to use as a working directory.
dvander@320
   290
 *						Final folder name should not be pathchar-terminated.
dvander@320
   291
 * @param relFrom		Source file or folder to use as a target.
dvander@320
   292
 * @return				True on success, false on failure.
dvander@320
   293
 */
dvander@320
   294
bool UTIL_Relatize(char buffer[],
dvander@320
   295
				   size_t maxlength,
dvander@320
   296
				   const char *relTo,
dvander@320
   297
				   const char *relFrom)
dvander@320
   298
{
dvander@320
   299
	/* We don't allow relative paths in here, force
dvander@320
   300
	 * the user to resolve these himself!
dvander@320
   301
	 */
dvander@320
   302
	if (!pathstr_isabsolute(relTo)
dvander@320
   303
		|| !pathstr_isabsolute(relFrom))
dvander@320
   304
	{
dvander@320
   305
		return false;
dvander@320
   306
	}
dvander@320
   307
dvander@320
   308
#if defined WIN32
dvander@320
   309
	/* Relative paths across drives are not possible */
dvander@320
   310
	if (!pathchar_cmp(relTo[0], relFrom[0]))
dvander@320
   311
	{
dvander@320
   312
		return false;
dvander@320
   313
	}
dvander@320
   314
	/* Get rid of the drive and semicolon part */
dvander@320
   315
	relTo = &relTo[2];
dvander@320
   316
	relFrom = &relFrom[2];
dvander@320
   317
#endif
dvander@320
   318
dvander@320
   319
	/* Eliminate the common root between the paths */
dvander@320
   320
	const char *rootTo = NULL;
dvander@320
   321
	const char *rootFrom = NULL;
dvander@320
   322
	while (*relTo != '\0' && *relFrom != '\0')
dvander@320
   323
	{
dvander@320
   324
		/* If we get to a new path sequence, start over */
dvander@320
   325
		if (pathchar_sep(*relTo)
dvander@320
   326
			&& pathchar_sep(*relFrom))
dvander@320
   327
		{
dvander@320
   328
			rootTo = relTo;
dvander@320
   329
			rootFrom = relFrom;
dvander@320
   330
		/* If the paths don't compare, stop looking for a common root */
dvander@320
   331
		} else if (!pathchar_cmp(*relTo, *relFrom)) {
dvander@320
   332
			break;
dvander@320
   333
		}
dvander@320
   334
		relTo++;
dvander@320
   335
		relFrom++;
dvander@320
   336
	}
dvander@320
   337
dvander@320
   338
	/* NULLs shouldn't happen! */
dvander@320
   339
	if (rootTo == NULL
dvander@320
   340
		|| rootFrom == NULL)
dvander@320
   341
	{
dvander@320
   342
		return false;
dvander@320
   343
	}
dvander@320
   344
dvander@320
   345
	size_t numLevels = 0;
dvander@320
   346
dvander@320
   347
	/* The root case is special! 
dvander@320
   348
	 * Don't count anything from it.
dvander@320
   349
	 */
dvander@320
   350
	if (*(rootTo + 1) != '\0')
dvander@320
   351
	{
dvander@320
   352
		/* Search for how many levels we need to go up.
dvander@320
   353
	 	 * Since the root pointer points to a '/', we increment
dvander@320
   354
		 * the initial pointer by one.
dvander@320
   355
		 */
dvander@320
   356
		while (*rootTo != '\0')
dvander@320
   357
		{
dvander@320
   358
			if (pathchar_sep(*rootTo))
dvander@320
   359
			{
dvander@320
   360
				/* Check for an improper trailing slash,
dvander@320
   361
				 * just to be nice even though the user 
dvander@320
   362
				 * should NOT have done this!
dvander@320
   363
				 */
dvander@320
   364
				if (*(rootTo + 1) == '\0')
dvander@320
   365
				{
dvander@320
   366
					break;
dvander@320
   367
				}
dvander@320
   368
				numLevels++;
dvander@320
   369
			}
dvander@320
   370
			rootTo++;
dvander@320
   371
		}
dvander@320
   372
	}
dvander@320
   373
dvander@320
   374
	/* Now build the new relative path. */
dvander@320
   375
	size_t len, total = 0;
dvander@320
   376
	while (numLevels--)
dvander@320
   377
	{
dvander@321
   378
		len = _snprintf(&buffer[total], maxlength - total, ".." PATH_SEP_STR);
dvander@320
   379
		if (len >= maxlength - total)
dvander@320
   380
		{
dvander@320
   381
			/* Not enough space in the buffer */
dvander@320
   382
			return false;
dvander@320
   383
		}
dvander@320
   384
		total += len;
dvander@320
   385
	}
dvander@320
   386
dvander@320
   387
	/* Add the absolute path. */
dvander@320
   388
	len = _snprintf(&buffer[total], maxlength - total, "%s", &rootFrom[1]);
dvander@320
   389
	if (len >= maxlength - total)
dvander@320
   390
	{
dvander@320
   391
		return false;
dvander@320
   392
	}
dvander@320
   393
dvander@320
   394
	return true;
dvander@320
   395
}
dvander@320
   396
dvander@320
   397
size_t UTIL_FormatArgs(char *buffer, size_t maxlength, const char *fmt, va_list params)
dvander@320
   398
{
dvander@320
   399
	size_t len = vsnprintf(buffer, maxlength, fmt, params);
dvander@320
   400
dvander@320
   401
	if (len >= maxlength)
dvander@320
   402
	{
dvander@320
   403
		len = maxlength - 1;
dvander@320
   404
		buffer[len] = '\0';
dvander@320
   405
	}
dvander@320
   406
dvander@320
   407
	return len;
dvander@320
   408
}