// ____ _ __ // / __ )____ _____ | | / /___ ___________ // / __ / __ \/ ___/ | | /| / / __ `/ ___/ ___/ // / /_/ / /_/ (__ ) | |/ |/ / /_/ / / (__ ) // /_____/\____/____/ |__/|__/\__,_/_/ /____/ // // A futuristic real-time strategy game. // This file is part of Bos Wars. // /**@name util.cpp - General utilites. */ // // (c) Copyright 1998-2006 by Lutz Sammer and Jimmy Salmon // // This program is free software; you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation; only version 2 of the License. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program; if not, write to the Free Software // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA // 02111-1307, USA. // #include #include #include #include #include #include #include "stratagus.h" #include "util.h" #ifdef USE_WIN32 #define WIN32_LEAN_AND_MEAN #undef NOUSER #include #elif defined(HAVE_X) #include #include #endif /*---------------------------------------------------------------------------- -- Random ----------------------------------------------------------------------------*/ unsigned SyncRandSeed; /// sync random seed value. /** ** Inititalize sync rand seed. */ void InitSyncRand(void) { SyncRandSeed = 0x87654321; } /** ** Synchronized random number. ** ** @note This random value must be same on all machines in network game. ** Very simple random generations, enough for us. */ int SyncRand(void) { int val; val = SyncRandSeed >> 16; SyncRandSeed = SyncRandSeed * (0x12345678 * 4 + 1) + 1; return val; } /** ** Synchronized random number. ** ** @param max Max value of random number to return */ int SyncRand(int max) { return SyncRand() % max; } /*---------------------------------------------------------------------------- -- Math ----------------------------------------------------------------------------*/ /** ** Compute a square root using ints ** ** Uses John Halleck's method, see ** http://www.cc.utah.edu/~nahaj/factoring/isqrt.legalize.c.html ** ** @param num Calculate the square root of this number ** ** @return The integer square root. */ long isqrt(long num) { long squaredbit; long remainder; long root; if (num < 1) { return 0; } // // Load the binary constant 01 00 00 ... 00, where the number // of zero bits to the right of the single one bit // is even, and the one bit is as far left as is consistant // with that condition.) // // This portable load replaces the loop that used to be // here, and was donated by legalize@xmission.com // squaredbit = (long)((((unsigned long)~0L) >> 1) & ~(((unsigned long)~0L) >> 2)); // Form bits of the answer. remainder = num; root = 0; while (squaredbit > 0) { if (remainder >= (squaredbit | root)) { remainder -= (squaredbit | root); root >>= 1; root |= squaredbit; } else { root >>= 1; } squaredbit >>= 2; } return root; } /*---------------------------------------------------------------------------- -- Strings ----------------------------------------------------------------------------*/ #if !defined(_MSC_VER) || _MSC_VER < 1400 unsigned int strcpy_s(char *dst, size_t dstsize, const char *src) { if (dst == NULL || src == NULL) { return EINVAL; } if (strlen(src) >= dstsize) { return ERANGE; } strcpy(dst, src); return 0; } #ifndef HAVE_STRNLEN size_t strnlen(const char *str, size_t strsize) { size_t len = 0; while (len < strsize) { if (*str == '\0') { break; } ++str; ++len; } return len; } #endif unsigned int strncpy_s(char *dst, size_t dstsize, const char *src, size_t count) { if (dst == NULL || src == NULL || dstsize == 0) { return EINVAL; } size_t mincount; if (count == _TRUNCATE) { mincount = strnlen(src, dstsize); } else { mincount = strnlen(src, count); } if (mincount >= dstsize) { if (count != _TRUNCATE) { dst[0] = '\0'; return EINVAL; } else { mincount = dstsize - 1; } } for (size_t i = 0; i < mincount; ++i) { *dst++ = *src++; } *dst = '\0'; return 0; } unsigned int strcat_s(char *dst, size_t dstsize, const char *src) { if (dst == NULL || src == NULL) { return EINVAL; } char *enddst = dst; size_t count = dstsize; while (count > 0 && *enddst != '\0') { ++enddst; count--; } if (count == 0) { return EINVAL; } if (strlen(src) >= count ) { return ERANGE; } strcpy(enddst, src); return 0; } int sprintf_s(char *dest, size_t destSize, const char *format, ...) { va_list args; int ret; if (dest == NULL || format == NULL) { errno = EINVAL; return -1; } va_start(args, format); ret = vsnprintf(dest, destSize, format, args); va_end(args); if (ret < 0 || (size_t)ret >= destSize) { dest[0] = '\0'; errno = EINVAL; ret = -1; } return ret; } #endif /** ** String duplicate/concatenate (two arguments) ** ** @param l Left string ** @param r Right string ** ** @return Allocated combined string (must be freed). */ char *strdcat(const char *l, const char *r) { int len = strlen(l) + strlen(r) + 1; char *res = new char[len]; if (res) { strcpy_s(res, len, l); strcat_s(res, len, r); } return res; } /** ** String duplicate/concatenate (three arguments) ** ** @param l Left string ** @param m Middle string ** @param r Right string ** ** @return Allocated combined string (must be freeded). */ char *strdcat3(const char *l, const char *m, const char *r) { int len = strlen(l) + strlen(m) + strlen(r) + 1; char *res = new char[len]; if (res) { strcpy_s(res, len, l); strcat_s(res, len, m); strcat_s(res, len, r); } return res; } #if !defined(HAVE_STRCASESTR) /** ** Case insensitive version of strstr ** ** @param a String to search in ** @param b Substring to search for ** ** @return Pointer to first occurence of b or NULL if not found. */ char *strcasestr(const char *a, const char *b) { int x; if (!a || !*a || !b || !*b || strlen(a) < strlen(b)) { return NULL; } x = 0; while (*a) { if (a[x] && (tolower(a[x]) == tolower(b[x]))) { ++x; } else if (b[x]) { ++a; x = 0; } else { return (char *)a; } } return NULL; } #endif // !HAVE_STRCASESTR /*---------------------------------------------------------------------------- -- Getopt ----------------------------------------------------------------------------*/ /** ** Standard implementation of getopt(3). ** ** One extension: If the first character of the optionsstring is a ':' ** the error return for 'argument required' is a ':' not a '?'. ** This makes it easier to differentiate between an 'illegal option' and ** an 'argument required' error. */ #if defined(_MSC_VER) #include #include int opterr = 1; int optind = 1; int optopt; char *optarg; static void getopt_err(char *argv0, char *str, char opt) { if (opterr) { char errbuf[2]; char *x; errbuf[0] = opt; errbuf[1] = '\n'; while ((x = strchr(argv0, '/'))) { argv0 = x + 1; } write(2, argv0, strlen(argv0)); write(2, str, strlen(str)); write(2, errbuf, 2); } } int getopt(int argc, char *const *argv, const char *opts) { static int sp = 1; register int c; register const char *cp; optarg = NULL; if (sp == 1) { if (optind >= argc || argv[optind][0] != '-' || argv[optind][1] == '\0') { return EOF; } else if (!strcmp(argv[optind], "--")) { optind++; return EOF; } } optopt = c = argv[optind][sp]; if (c == ':' || (cp = strchr(opts, c)) == NULL) { getopt_err(argv[0], ": illegal option -", (char)c); cp = "xx"; /* make the next if false */ c = '?'; } if (*++cp == ':') { if (argv[optind][++sp] != '\0') { optarg = &argv[optind++][sp]; } else if (++optind < argc) { optarg = argv[optind++]; } else { getopt_err(argv[0], ": option requires an argument -", (char)c); c = (*opts == ':') ? ':' : '?'; } sp = 1; } else if (argv[optind][++sp] == '\0') { optind++; sp = 1; } return c; } #endif /* _MSC_VER */ /*---------------------------------------------------------------------------- -- Clipboard ----------------------------------------------------------------------------*/ /** ** Paste text from the clipboard */ int GetClipboard(std::string &str) { #if defined(USE_WIN32) || defined(HAVE_X) int i; unsigned char *clipboard; #ifdef USE_WIN32 HGLOBAL handle; #elif defined(HAVE_X) Display *display; Window window; Atom rettype; unsigned long nitem; unsigned long dummy; int retform; XEvent event; #endif #ifdef USE_WIN32 if (!IsClipboardFormatAvailable(CF_TEXT) || !OpenClipboard(NULL)) { return -1; } handle = GetClipboardData(CF_TEXT); if (!handle) { CloseClipboard(); return -1; } clipboard = (unsigned char *)GlobalLock(handle); if (!clipboard) { CloseClipboard(); return -1; } #elif defined(HAVE_X) if (!(display = XOpenDisplay(NULL))) { return -1; } // Creates a non maped temporary X window to hold the selection if (!(window = XCreateSimpleWindow(display, DefaultRootWindow(display), 0, 0, 1, 1, 0, 0, 0))) { XCloseDisplay(display); return -1; } XConvertSelection(display, XA_PRIMARY, XA_STRING, XA_STRING, window, CurrentTime); XNextEvent(display, &event); if (event.type != SelectionNotify || event.xselection.property != XA_STRING) { return -1; } XGetWindowProperty(display, window, XA_STRING, 0, 1024, False, XA_STRING, &rettype, &retform, &nitem, &dummy, &clipboard); XDestroyWindow(display, window); XCloseDisplay(display); if (rettype != XA_STRING || retform != 8) { if (clipboard != NULL) { XFree(clipboard); } clipboard = NULL; } if (clipboard == NULL) { return -1; } #endif // Only allow ascii characters for (i = 0; clipboard[i] != '\0'; ++i) { if (clipboard[i] < 32 || clipboard[i] > 126) { return -1; } } str = (char *)clipboard; #ifdef USE_WIN32 GlobalUnlock(handle); CloseClipboard(); #elif defined(HAVE_X) if (clipboard != NULL) { XFree(clipboard); } #endif return 0; #else return -1; #endif } /*---------------------------------------------------------------------------- -- UTF8 ----------------------------------------------------------------------------*/ int UTF8GetPrev(const std::string &text, int curpos) { --curpos; if (curpos < 0) { return curpos; } while (curpos >= 0) { if ((text[curpos] & 0xC0) != 0x80) { return curpos; } --curpos; } if (curpos < 0) { fprintf(stderr, "Invalid UTF8.\n"); } return 0; } int UTF8GetNext(const std::string &text, int curpos) { if (curpos == (int)text.size()) { return curpos + 1; } char c = text[curpos]; if (!(c & 0x80)) { return curpos + 1; } if ((c & 0xE0) == 0xC0) { return curpos + 2; } if ((c & 0xF0) == 0xE0) { return curpos + 3; } fprintf(stderr, "Invalid UTF8.\n"); return text.size(); }