diff -r 000000000000 -r e82968c21606 sourcemm/util.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/sourcemm/util.cpp Tue Sep 18 20:03:47 2007 +0000 @@ -0,0 +1,408 @@ +/* ======== SourceMM ======== + * Copyright (C) 2004-2007 Metamod:Source Development Team + * No warranties of any kind + * + * License: zlib/libpng + * + * Author(s): David "BAILOPAN" Anderson + * ============================ + */ + +#include +#include +#include +#include "util.h" +#include "oslink.h" + +/** + * @brief Utility functions + * @file util.cpp + */ + +const char *UTIL_GetExtension(const char *file) +{ + int len = strlen(file); + int i = 0; + + for (i = len - 1; i >= 0; i--) + { + if (file[i] == '/' || file[i] == '\\') + { + return NULL; + } + + if ((file[i] == '.') && (i != len - 1)) + { + return (const char *)&(file[i + 1]); + } + } + + return NULL; +} + +void UTIL_TrimLeft(char *buffer) +{ + /* Let's think of this as our iterator */ + char *i = buffer; + + /* Make sure the buffer isn't null */ + if (i && *i) + { + /* Add up number of whitespace characters */ + while(isspace((unsigned char) *i)) + { + i++; + } + + /* If whitespace chars in buffer then adjust string so first non-whitespace char is at start of buffer */ + if (i != buffer) + { + memmove(buffer, i, (strlen(i) + 1) * sizeof(char)); + } + } +} + +void UTIL_TrimRight(char *buffer) +{ + /* Make sure buffer isn't null */ + if (buffer) + { + size_t len = strlen(buffer); + + /* Loop through buffer backwards while replacing whitespace chars with null chars */ + for (size_t i = len - 1; i >= 0; i--) + { + if (isspace((unsigned char) buffer[i])) + { + buffer[i] = '\0'; + } else { + break; + } + } + } +} + +/* :TODO: this should skip string literals */ +void UTIL_TrimComments(char *buffer) +{ + int num_sc = 0; + size_t len = strlen(buffer); + if (buffer) + { + for (int i = len - 1; i >= 0; i--) + { + if (buffer[i] == '/') + { + if (++num_sc >= 2 && i==0) + { + buffer[i] = '\0'; + return; + } + } else { + if (num_sc >= 2) + { + buffer[i] = '\0'; + return; + } + num_sc = 0; + } + /* size_t won't go below 0, manually break out */ + if (i == 0) + { + break; + } + } + } +} + +void UTIL_KeySplit(const char *str, char *buf1, size_t len1, char *buf2, size_t len2) +{ + size_t start; + size_t len = strlen(str); + + for (start = 0; start < len; start++) + { + if (!isspace(str[start])) + { + break; + } + } + + size_t end; + for (end = start; end < len; end++) + { + if (isspace(str[end])) + { + break; + } + } + + size_t i, c = 0; + for (i = start; i < end; i++, c++) + { + if (c >= len1) + { + break; + } + buf1[c] = str[i]; + } + buf1[c] = '\0'; + + for (start = end; start < len; start++) + { + if (!isspace(str[start])) + { + break; + } + } + + for (c = 0; start < len; start++, c++) + { + if (c >= len2) + { + break; + } + buf2[c] = str[start]; + } + buf2[c] = '\0'; +} + +bool UTIL_PathCmp(const char *path1, const char *path2) +{ + size_t pos1 = 0, pos2 = 0; + + while (true) + { + if (path1[pos1] == '\0' || path2[pos2] == '\0') + { + return (path1[pos1] == path2[pos2]); + } + + if (path1[pos1] == PATH_SEP_CHAR) + { + if (path2[pos2] != PATH_SEP_CHAR) + { + return false; + } + + /* Look for extra path chars */ + while (path1[++pos1]) + { + if (path1[pos1] != PATH_SEP_CHAR) + { + break; + } + } + while (path2[++pos2]) + { + if (path2[pos2] != PATH_SEP_CHAR) + { + break; + } + } + continue; + } + + /* If we're at a different non-alphanumeric, the next character MUST match */ + if (!isalpha(path1[pos1]) && (path1[pos1] != path2[pos2])) + { + return false; + } + + #ifdef WIN32 + if (toupper(path1[pos1]) != toupper(path2[pos2])) + #else + if (path1[pos1] != path2[pos2]) + #endif + { + return false; + } + + pos1++; + pos2++; + } +} + +size_t UTIL_Format(char *buffer, size_t maxlength, const char *fmt, ...) +{ + va_list ap; + + va_start(ap, fmt); + size_t len = vsnprintf(buffer, maxlength, fmt, ap); + va_end(ap); + + if (len >= maxlength) + { + len = maxlength - 1; + buffer[len] = '\0'; + } + + return len; +} + +inline bool pathchar_isalpha(char a) +{ + return (((a & 1<<7) == 0) && isalpha(a)); +} + +inline bool pathchar_sep(char a) +{ +#if defined WIN32 + return (a == '/' || a == '\\'); +#elif defined __linux__ + return (a == '/'); +#endif +} + +inline bool pathstr_isabsolute(const char *str) +{ +#if defined WIN32 + return (pathchar_isalpha(str[0]) + && str[1] == ':' + && pathchar_sep(str[2])); +#elif defined __linux__ + return (str[0] == '/'); +#endif +} + +inline bool pathchar_cmp(char a, char b) +{ +#if defined WIN32 + if (pathchar_isalpha(a) && pathchar_isalpha(b)) + { + return (tolower(a) == tolower(b)); + } + /* Either path separator is acceptable */ + if (pathchar_sep(a)) + { + return pathchar_sep(b); + } +#endif + return (a == b); +} + +/** + * @brief Forms a relative path given two absolute paths. + * + * @param buffer Buffer to store relative path in. + * @param maxlength Maximum length of the output buffer. + * @param relTo Destination folder to use as a working directory. + * Final folder name should not be pathchar-terminated. + * @param relFrom Source file or folder to use as a target. + * @return True on success, false on failure. + */ +bool UTIL_Relatize(char buffer[], + size_t maxlength, + const char *relTo, + const char *relFrom) +{ + /* We don't allow relative paths in here, force + * the user to resolve these himself! + */ + if (!pathstr_isabsolute(relTo) + || !pathstr_isabsolute(relFrom)) + { + return false; + } + +#if defined WIN32 + /* Relative paths across drives are not possible */ + if (!pathchar_cmp(relTo[0], relFrom[0])) + { + return false; + } + /* Get rid of the drive and semicolon part */ + relTo = &relTo[2]; + relFrom = &relFrom[2]; +#endif + + /* Eliminate the common root between the paths */ + const char *rootTo = NULL; + const char *rootFrom = NULL; + while (*relTo != '\0' && *relFrom != '\0') + { + /* If we get to a new path sequence, start over */ + if (pathchar_sep(*relTo) + && pathchar_sep(*relFrom)) + { + rootTo = relTo; + rootFrom = relFrom; + /* If the paths don't compare, stop looking for a common root */ + } else if (!pathchar_cmp(*relTo, *relFrom)) { + break; + } + relTo++; + relFrom++; + } + + /* NULLs shouldn't happen! */ + if (rootTo == NULL + || rootFrom == NULL) + { + return false; + } + + size_t numLevels = 0; + + /* The root case is special! + * Don't count anything from it. + */ + if (*(rootTo + 1) != '\0') + { + /* Search for how many levels we need to go up. + * Since the root pointer points to a '/', we increment + * the initial pointer by one. + */ + while (*rootTo != '\0') + { + if (pathchar_sep(*rootTo)) + { + /* Check for an improper trailing slash, + * just to be nice even though the user + * should NOT have done this! + */ + if (*(rootTo + 1) == '\0') + { + break; + } + numLevels++; + } + rootTo++; + } + } + + /* Now build the new relative path. */ + size_t len, total = 0; + while (numLevels--) + { + len = _snprintf(&buffer[total], maxlength - total, ".." PATH_SEP_STR); + if (len >= maxlength - total) + { + /* Not enough space in the buffer */ + return false; + } + total += len; + } + + /* Add the absolute path. */ + len = _snprintf(&buffer[total], maxlength - total, "%s", &rootFrom[1]); + if (len >= maxlength - total) + { + return false; + } + + return true; +} + +size_t UTIL_FormatArgs(char *buffer, size_t maxlength, const char *fmt, va_list params) +{ + size_t len = vsnprintf(buffer, maxlength, fmt, params); + + if (len >= maxlength) + { + len = maxlength - 1; + buffer[len] = '\0'; + } + + return len; +}