propset.cxx

robocup rcssserver 运行防真机器人足球比赛所用的服务器端

// SciTE - Scintilla based Text Editor
/** @file PropSet.cxx
 ** A Java style properties file module.
 **/
// Copyright 1998-2003 by Neil Hodgson <[e-mail]>
// The License.txt file describes the conditions under which this software may be distributed.

// Maintain a dictionary of properties

#include <stdlib.h>
#include <string.h>
#include <stdio.h>

#include "Platform.h"

#include "PropSet.h"

// The comparison and case changing functions here assume ASCII
// or extended ASCII such as the normal Windows code page.

static inline char MakeUpperCase(char ch) {
        if (ch < 'a' || ch > 'z')
                return ch;
        else
                return static_cast<char>(ch - 'a' + 'A');
}

static inline bool IsLetter(char ch) {
        return ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z'));
}

inline bool IsASpace(unsigned int ch) {
    return (ch == ' ') || ((ch >= 0x09) && (ch <= 0x0d));
}

int CompareCaseInsensitive(const char *a, const char *b) {
        while (*a && *b) {
                if (*a != *b) {
                        char upperA = MakeUpperCase(*a);
                        char upperB = MakeUpperCase(*b);
                        if (upperA != upperB)
                                return upperA - upperB;
                }
                a++;
                b++;
        }
        // Either *a or *b is nul
        return *a - *b;
}

int CompareNCaseInsensitive(const char *a, const char *b, size_t len) {
        while (*a && *b && len) {
                if (*a != *b) {
                        char upperA = MakeUpperCase(*a);
                        char upperB = MakeUpperCase(*b);
                        if (upperA != upperB)
                                return upperA - upperB;
                }
                a++;
                b++;
                len--;
        }
        if (len == 0)
                return 0;
        else
                // Either *a or *b is nul
                return *a - *b;
}

bool EqualCaseInsensitive(const char *a, const char *b) {
        return 0 == CompareCaseInsensitive(a, b);
}

// Since the CaseInsensitive functions declared in SString
// are implemented here, I will for now put the non-inline
// implementations of the SString members here as well, so
// that I can quickly see what effect this has.

SString::SString(int i) : sizeGrowth(sizeGrowthDefault) {
        char number[32];
        sprintf(number, "%0d", i);
        s = StringAllocate(number);
        sSize = sLen = (s) ? strlen(s) : 0;
}

SString::SString(double d, int precision) : sizeGrowth(sizeGrowthDefault) {
        char number[32];
        sprintf(number, "%.*f", precision, d);
        s = StringAllocate(number);
        sSize = sLen = (s) ? strlen(s) : 0;
}

bool SString::grow(lenpos_t lenNew) {
        while (sizeGrowth * 6 < lenNew) {
                sizeGrowth *= 2;
        }
        char *sNew = new char[lenNew + sizeGrowth + 1];
        if (sNew) {
                if (s) {
                        memcpy(sNew, s, sLen);
                        delete []s;
                }
                s = sNew;
                s[sLen] = '\0';
                sSize = lenNew + sizeGrowth;
        }
        return sNew != 0;
}

SString &SString::assign(const char *sOther, lenpos_t sSize_) {
        if (!sOther) {
                sSize_ = 0;
        } else if (sSize_ == measure_length) {
                sSize_ = strlen(sOther);
        }
        if (sSize > 0 && sSize_ <= sSize) {     // Does not allocate new buffer if the current is big enough
                if (s && sSize_) {
                        memcpy(s, sOther, sSize_);
                }
                s[sSize_] = '\0';
                sLen = sSize_;
        } else {
                delete []s;
                s = StringAllocate(sOther, sSize_);
                if (s) {
                        sSize = sSize_; // Allow buffer bigger than real string, thus providing space to grow
                        sLen = sSize_;
                } else {
                        sSize = sLen = 0;
                }
        }
        return *this;
}

bool SString::operator==(const SString &sOther) const {
        if ((s == 0) && (sOther.s == 0))
                return true;
        if ((s == 0) || (sOther.s == 0))
                return false;
        return strcmp(s, sOther.s) == 0;
}

bool SString::operator==(const char *sOther) const {
        if ((s == 0) && (sOther == 0))
                return true;
        if ((s == 0) || (sOther == 0))
                return false;
        return strcmp(s, sOther) == 0;
}

SString SString::substr(lenpos_t subPos, lenpos_t subLen) const {
        if (subPos >= sLen) {
                return SString();                                       // return a null string if start index is out of bounds
        }
        if ((subLen == measure_length) || (subPos + subLen > sLen)) {
                subLen = sLen - subPos;         // can't substr past end of source string
        }
        return SString(s, subPos, subPos + subLen);
}

SString &SString::lowercase(lenpos_t subPos, lenpos_t subLen) {
        if ((subLen == measure_length) || (subPos + subLen > sLen)) {
                subLen = sLen - subPos;         // don't apply past end of string
        }
        for (lenpos_t i = subPos; i < subPos + subLen; i++) {
                if (s[i] < 'A' || s[i] > 'Z')
                        continue;
                else
                        s[i] = static_cast<char>(s[i] - 'A' + 'a');
        }
        return *this;
}

SString &SString::uppercase(lenpos_t subPos, lenpos_t subLen) {
        if ((subLen == measure_length) || (subPos + subLen > sLen)) {
                subLen = sLen - subPos;         // don't apply past end of string
        }
        for (lenpos_t i = subPos; i < subPos + subLen; i++) {
                if (s[i] < 'a' || s[i] > 'z')
                        continue;
                else
                        s[i] = static_cast<char>(s[i] - 'a' + 'A');
        }
        return *this;
}

SString &SString::append(const char *sOther, lenpos_t sLenOther, char sep) {
        if (!sOther) {
                return *this;
        }
        if (sLenOther == measure_length) {
                sLenOther = strlen(sOther);
        }
        int lenSep = 0;
        if (sLen && sep) {      // Only add a separator if not empty
                lenSep = 1;
        }
        lenpos_t lenNew = sLen + sLenOther + lenSep;
        // Conservative about growing the buffer: don't do it, unless really needed
        if ((lenNew < sSize) || (grow(lenNew))) {
                if (lenSep) {
                        s[sLen] = sep;
                        sLen++;
                }
                memcpy(&s[sLen], sOther, sLenOther);
                sLen += sLenOther;
                s[sLen] = '\0';
        }
        return *this;
}

SString &SString::insert(lenpos_t pos, const char *sOther, lenpos_t sLenOther) {
        if (!sOther || pos > sLen) {
                return *this;
        }
        if (sLenOther == measure_length) {
                sLenOther = strlen(sOther);
        }
        lenpos_t lenNew = sLen + sLenOther;
        // Conservative about growing the buffer: don't do it, unless really needed
        if ((lenNew < sSize) || grow(lenNew)) {
                lenpos_t moveChars = sLen - pos + 1;
                for (lenpos_t i = moveChars; i > 0; i--) {
                        s[pos + sLenOther + i - 1] = s[pos + i - 1];
                }
                memcpy(s + pos, sOther, sLenOther);
                sLen = lenNew;
        }
        return *this;
}

/**
 * Remove @a len characters from the @a pos position, included.
 * Characters at pos + len and beyond replace characters at pos.
 * If @a len is 0, or greater than the length of the string
 * starting at @a pos, the string is just truncated at @a pos.
 */
void SString::remove(lenpos_t pos, lenpos_t len) {
        if (pos >= sLen) {
                return;
        }
        if (len < 1 || pos + len >= sLen) {
                s[pos] = '\0';
                sLen = pos;
        } else {
                for (lenpos_t i = pos; i < sLen - len + 1; i++) {
                        s[i] = s[i+len];
                }
                sLen -= len;
        }
}

bool SString::startswith(const char *prefix) {
        lenpos_t lenPrefix = strlen(prefix);
        if (lenPrefix > sLen) {
                return false;
        }
        return strncmp(s, prefix, lenPrefix) == 0;
}

bool SString::endswith(const char *suffix) {
        lenpos_t lenSuffix = strlen(suffix);
        if (lenSuffix > sLen) {
                return false;
        }
        return strncmp(s + sLen - lenSuffix, suffix, lenSuffix) == 0;
}

int SString::search(const char *sFind, lenpos_t start) const {
        if (start < sLen) {
                const char *sFound = strstr(s + start, sFind);
                if (sFound) {
                        return sFound - s;
                }
        }
        return -1;
}

int SString::substitute(char chFind, char chReplace) {
        int c = 0;
        char *t = s;
        while (t) {
                t = strchr(t, chFind);
                if (t) {
                        *t = chReplace;
                        t++;
                        c++;
                }
        }
        return c;
}

int SString::substitute(const char *sFind, const char *sReplace) {
        int c = 0;
        lenpos_t lenFind = strlen(sFind);
        lenpos_t lenReplace = strlen(sReplace);
        int posFound = search(sFind);
        while (posFound >= 0) {
                remove(posFound, lenFind);
                insert(posFound, sReplace, lenReplace);
                posFound = search(sFind, posFound + lenReplace);
                c++;
        }
        return c;
}

char *SContainer::StringAllocate(lenpos_t len) {
        if (len != measure_length) {
                return new char[len + 1];
        } else {
                return 0;
        }
}

char *SContainer::StringAllocate(const char *s, lenpos_t len) {
        if (s == 0) {
                return 0;
        }
        if (len == measure_length) {
                len = strlen(s);
        }
        char *sNew = new char[len + 1];
        if (sNew) {
                memcpy(sNew, s, len);
                sNew[len] = '\0';
        }
        return sNew;
}

// End SString functions

bool PropSet::caseSensitiveFilenames = false;

PropSet::PropSet() {
        superPS = 0;
        for (int root = 0; root < hashRoots; root++)
                props[root] = 0;
}

PropSet::~PropSet() {
        superPS = 0;
        Clear();
}

void PropSet::Set(const char *key, const char *val, int lenKey, int lenVal) {
        if (!*key)      // Empty keys are not supported
                return;
        if (lenKey == -1)
                lenKey = static_cast<int>(strlen(key));
        if (lenVal == -1)
                lenVal = static_cast<int>(strlen(val));
        unsigned int hash = HashString(key, lenKey);
        for (ScProperty *p = props[hash % hashRoots]; p; p = p->next) {
                if ((hash == p->hash) &&
                        ((strlen(p->key) == static_cast<unsigned int>(lenKey)) &&
                                (0 == strncmp(p->key, key, lenKey)))) {
                        // Replace current value
                        delete [](p->val);
                        p->val = StringDup(val, lenVal);
                        return;
                }
        }
        // Not found
        ScProperty *pNew = new ScProperty;
        if (pNew) {
                pNew->hash = hash;
                pNew->key = StringDup(key, lenKey);
                pNew->val = StringDup(val, lenVal);
                pNew->next = props[hash % hashRoots];
                props[hash % hashRoots] = pNew;
        }
}

void PropSet::Set(const char *keyVal) {
        while (IsASpace(*keyVal))
                keyVal++;
        const char *endVal = keyVal;
        while (*endVal && (*endVal != '\n'))
                endVal++;
        const char *eqAt = strchr(keyVal, '=');
        if (eqAt) {
                Set(keyVal, eqAt + 1, eqAt-keyVal, endVal - eqAt - 1);
        } else if (*keyVal) {   // No '=' so assume '=1'
                Set(keyVal, "1", endVal-keyVal, 1);
        }
}

void PropSet::Unset(const char *key, int lenKey) {
        if (!*key)      // Empty keys are not supported
                return;
        if (lenKey == -1)