____                _       __
    / __ )____  _____   | |     / /___ ___________
   / __  / __ \/ ___/   | | /| / / __ `/ ___/ ___/
  / /_/ / /_/ (__  )    | |/ |/ / /_/ / /  (__  )
 /_____/\____/____/     |__/|__/\__,_/_/  /____/

       A futuristic real-time strategy game.
          This file is part of Bos Wars.

(C) Copyright 2001-2007 by the Bos Wars and Stratagus Project. Distributed under the "GNU General Public License"

---

util.cpp

Go to the documentation of this file.

//     ____                _       __               
//    / __ )____  _____   | |     / /___ ___________
//   / __  / __ \/ ___/   | | /| / / __ `/ ___/ ___/
//  / /_/ / /_/ (__  )    | |/ |/ / /_/ / /  (__  ) 
// /_____/\____/____/     |__/|__/\__,_/_/  /____/  
//                                              
//       A futuristic real-time strategy game.
//          This file is part of Bos Wars.
//
//
//      (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 <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>

#include "stratagus.h"
#include "util.h"

#ifdef USE_WIN32
#define WIN32_LEAN_AND_MEAN
#undef NOUSER
#include <windows.h>
#elif defined(HAVE_X)
#include <X11/Xlib.h>
#include <X11/Xatom.h>
#endif

/*----------------------------------------------------------------------------
--  Random
----------------------------------------------------------------------------*/

unsigned SyncRandSeed;               

void InitSyncRand(void)
{
    SyncRandSeed = 0x87654321;
}

int SyncRand(void)
{
    int val;

    val = SyncRandSeed >> 16;

    SyncRandSeed = SyncRandSeed * (0x12345678 * 4 + 1) + 1;

    return val;
}

int SyncRand(int max)
{
    return SyncRand() % max;
}


/*----------------------------------------------------------------------------
--  Math
----------------------------------------------------------------------------*/

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

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;
}

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)

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
----------------------------------------------------------------------------*/

#if defined(_MSC_VER)

#include <io.h>
#include <string.h>

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
----------------------------------------------------------------------------*/

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();
}

---