propset.cxx

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

                keywords[words] = &wordlist[slen];
                *len = words;
        } else {
                *len = 0;
        }
        return keywords;
}

void WordList::Clear() {
        if (words) {
                delete []list;
                delete []words;
                delete []wordsNoCase;
        }
        words = 0;
        wordsNoCase = 0;
        list = 0;
        len = 0;
        sorted = false;
        sortedNoCase = false;
}

void WordList::Set(const char *s) {
        list = StringDup(s);
        sorted = false;
        sortedNoCase = false;
        words = ArrayFromWordList(list, &len, onlyLineEnds);
        wordsNoCase = new char * [len + 1];
        memcpy(wordsNoCase, words, (len + 1) * sizeof (*words));
}

char *WordList::Allocate(int size) {
        list = new char[size + 1];
        list[size] = '\0';
        return list;
}

void WordList::SetFromAllocated() {
        sorted = false;
        sortedNoCase = false;
        words = ArrayFromWordList(list, &len, onlyLineEnds);
        wordsNoCase = new char * [len + 1];
        memcpy(wordsNoCase, words, (len + 1) * sizeof (*words));
}

int cmpString(const void *a1, const void *a2) {
        // Can't work out the correct incantation to use modern casts here
        return strcmp(*(char**)(a1), *(char**)(a2));
}

int cmpStringNoCase(const void *a1, const void *a2) {
        // Can't work out the correct incantation to use modern casts here
        return CompareCaseInsensitive(*(char**)(a1), *(char**)(a2));
}

static void SortWordList(char **words, unsigned int len) {
        qsort(reinterpret_cast<void*>(words), len, sizeof(*words),
              cmpString);
}

static void SortWordListNoCase(char **wordsNoCase, unsigned int len) {
        qsort(reinterpret_cast<void*>(wordsNoCase), len, sizeof(*wordsNoCase),
              cmpStringNoCase);
}

bool WordList::InList(const char *s) {
        if (0 == words)
                return false;
        if (!sorted) {
                sorted = true;
                SortWordList(words, len);
                for (unsigned int k = 0; k < (sizeof(starts) / sizeof(starts[0])); k++)
                        starts[k] = -1;
                for (int l = len - 1; l >= 0; l--) {
                        unsigned char indexChar = words[l][0];
                        starts[indexChar] = l;
                }
        }
        unsigned char firstChar = s[0];
        int j = starts[firstChar];
        if (j >= 0) {
                while (words[j][0] == firstChar) {
                        if (s[1] == words[j][1]) {
                                const char *a = words[j] + 1;
                                const char *b = s + 1;
                                while (*a && *a == *b) {
                                        a++;
                                        b++;
                                }
                                if (!*a && !*b)
                                        return true;
                        }
                        j++;
                }
        }
        j = starts['^'];
        if (j >= 0) {
                while (words[j][0] == '^') {
                        const char *a = words[j] + 1;
                        const char *b = s;
                        while (*a && *a == *b) {
                                a++;
                                b++;
                        }
                        if (!*a)
                                return true;
                        j++;
                }
        }
        return false;
}

/** similar to InList, but word s can be a substring of keyword.
 * eg. the keyword define is defined as def~ine. This means the word must start
 * with def to be a keyword, but also defi, defin and define are valid.
 * The marker is ~ in this case.
 */
bool WordList::InListAbbreviated(const char *s, const char marker) {
        if (0 == words)
                return false;
        if (!sorted) {
                sorted = true;
                SortWordList(words, len);
                for (unsigned int k = 0; k < (sizeof(starts) / sizeof(starts[0])); k++)
                        starts[k] = -1;
                for (int l = len - 1; l >= 0; l--) {
                        unsigned char indexChar = words[l][0];
                        starts[indexChar] = l;
                }
        }
        unsigned char firstChar = s[0];
        int j = starts[firstChar];
        if (j >= 0) {
                while (words[j][0] == firstChar) {
                        bool isSubword = false;
                        int start = 1;
                        if (words[j][1] == marker) {
                                isSubword = true;
                                start++;
                        }
                        if (s[1] == words[j][start]) {
                                const char *a = words[j] + start;
                                const char *b = s + 1;
                                while (*a && *a == *b) {
                                        a++;
                                        if (*a == marker) {
                                                isSubword = true;
                                                a++;
                                        }
                                        b++;
                                }
                                if ((!*a || isSubword) && !*b)
                                        return true;
                        }
                        j++;
                }
        }
        j = starts['^'];
        if (j >= 0) {
                while (words[j][0] == '^') {
                        const char *a = words[j] + 1;
                        const char *b = s;
                        while (*a && *a == *b) {
                                a++;
                                b++;
                        }
                        if (!*a)
                                return true;
                        j++;
                }
        }
        return false;
}

/**
 * Returns an element (complete) of the wordlist array which has
 * the same beginning as the passed string.
 * The length of the word to compare is passed too.
 * Letter case can be ignored or preserved (default).
 */
const char *WordList::GetNearestWord(const char *wordStart, int searchLen, bool ignoreCase /*= false*/, SString wordCharacters /*='/0' */, int wordIndex /*= -1 */) {
        int start = 0; // lower bound of the api array block to search
        int end = len - 1; // upper bound of the api array block to search
        int pivot; // index of api array element just being compared
        int cond; // comparison result (in the sense of strcmp() result)
        const char *word; // api array element just being compared

        if (0 == words)
                return NULL;
        if (ignoreCase) {
                if (!sortedNoCase) {
                        sortedNoCase = true;
                        SortWordListNoCase(wordsNoCase, len);
                }
                while (start <= end) { // binary searching loop
                        pivot = (start + end) >> 1;
                        word = wordsNoCase[pivot];
                        cond = CompareNCaseInsensitive(wordStart, word, searchLen);
                        if (!cond) {
                                // find first word
                                start = pivot;
                                while (start > 0 && !CompareNCaseInsensitive(wordStart, wordsNoCase[start-1], searchLen)) {
                                        start--;
                                }
                                // find last word
                                end = pivot;
                                while (end < len-1 && !CompareNCaseInsensitive(wordStart, wordsNoCase[end+1], searchLen)) {
                                        end++;
                                }

                                // Finds first word in a series of equal words
                                for (pivot = start; pivot <= end; pivot++) {
                                        word = wordsNoCase[pivot];
                                        if (!wordCharacters.contains(word[searchLen])) {
                                                if (wordIndex <= 0) // Checks if a specific index was requested
                                                        return word; // result must not be freed with free()
                                                wordIndex--;
                                        }
                                }
                                return NULL;
                        }
                        else if (cond > 0)
                                start = pivot + 1;
                        else if (cond < 0)
                                end = pivot - 1;
                }
        } else { // preserve the letter case
                if (!sorted) {
                        sorted = true;
                        SortWordList(words, len);
                }
                while (start <= end) { // binary searching loop
                        pivot = (start + end) >> 1;
                        word = words[pivot];
                        cond = strncmp(wordStart, word, searchLen);
                        if (!cond) {
                                // find first word
                                start = pivot;
                                while (start > 0 && !strncmp(wordStart, words[start-1], searchLen)) {
                                        start--;
                                }
                                // find last word
                                end = pivot;
                                while (end < len-1 && !strncmp(wordStart, words[end+1], searchLen)) {
                                        end++;
                                }

                                // Finds first word in a series of equal words
                                pivot = start;
                                while (pivot <= end) {
                                        word = words[pivot];
                                        if (!wordCharacters.contains(word[searchLen])) {
                                                if (wordIndex <= 0) // Checks if a specific index was requested
                                                        return word; // result must not be freed with free()
                                                wordIndex--;
                                        }
                                        pivot++;
                                }
                                return NULL;
                        }
                        else if (cond > 0)
                                start = pivot + 1;
                        else if (cond < 0)
                                end = pivot - 1;
                }
        }
        return NULL;
}

/**
 * Find the length of a 'word' which is actually an identifier in a string
 * which looks like "identifier(..." or "identifier" and where
 * there may be extra spaces after the identifier that should not be
 * counted in the length.
 */
static unsigned int LengthWord(const char *word, char otherSeparator) {
        // Find a '('. If that fails go to the end of the string.
        const char *endWord = strchr(word, '(');
        if (!endWord && otherSeparator)
                endWord = strchr(word, otherSeparator);
        if (!endWord)
                endWord = word + strlen(word);
        // Last case always succeeds so endWord != 0

        // Drop any space characters.
        if (endWord > word) {
                endWord--;      // Back from the '(', otherSeparator, or '\0'
                // Move backwards over any spaces
                while ((endWord > word) && (IsASpace(*endWord))) {
                        endWord--;
                }
        }
        return endWord - word;
}

/**
 * Returns elements (first words of them) of the wordlist array which have
 * the same beginning as the passed string.
 * The length of the word to compare is passed too.
 * Letter case can be ignored or preserved (default).
 * If there are more words meeting the condition they are returned all of
 * them in the ascending order separated with spaces.
 *
 * NOTE: returned buffer has to be freed with delete[].
 */
char *WordList::GetNearestWords(
    const char *wordStart,
    int searchLen,
    bool ignoreCase /*= false*/,
    char otherSeparator /*= '\0'*/,
    bool exactLen /*=false*/) {
        unsigned int wordlen; // length of the word part (before the '(' brace) of the api array element
        SString wordsNear;
        wordsNear.setsizegrowth(1000);
        int start = 0; // lower bound of the api array block to search
        int end = len - 1; // upper bound of the api array block to search
        int pivot; // index of api array element just being compared
        int cond; // comparison result (in the sense of strcmp() result)

        if (0 == words)
                return NULL;
        if (ignoreCase) {
                if (!sortedNoCase) {
                        sortedNoCase = true;
                        SortWordListNoCase(wordsNoCase, len);
                }
                while (start <= end) { // Binary searching loop
                        pivot = (start + end) / 2;
                        cond = CompareNCaseInsensitive(wordStart, wordsNoCase[pivot], searchLen);
                        if (!cond) {
                                // Find first match
                                while ((pivot > start) &&
                                        (0 == CompareNCaseInsensitive(wordStart,
                                                wordsNoCase[pivot-1], searchLen))) {
                                        --pivot;
                                }
                                // Grab each match
                                while ((pivot <= end) &&
                                        (0 == CompareNCaseInsensitive(wordStart,
                                                wordsNoCase[pivot], searchLen))) {
                                        wordlen = LengthWord(wordsNoCase[pivot], otherSeparator) + 1;
                                        ++pivot;
                                        if (exactLen && wordlen != LengthWord(wordStart, otherSeparator) + 1)
                                                continue;
                                        wordsNear.append(wordsNoCase[pivot-1], wordlen, ' ');
                                }
                                return wordsNear.detach();
                        } else if (cond < 0) {
                                end = pivot - 1;
                        } else if (cond > 0) {
                                start = pivot + 1;
                        }
                }
        } else {        // Preserve the letter case
                if (!sorted) {
                        sorted = true;
                        SortWordList(words, len);
                }
                while (start <= end) { // Binary searching loop
                        pivot = (start + end) / 2;
                        cond = strncmp(wordStart, words[pivot], searchLen);
                        if (!cond) {
                                // Find first match
                                while ((pivot > start) &&
                                        (0 == strncmp(wordStart,
                                                words[pivot-1], searchLen))) {
                                        --pivot;
                                }
                                // Grab each match
                                while ((pivot <= end) &&
                                        (0 == strncmp(wordStart,
                                                words[pivot], searchLen))) {
                                        wordlen = LengthWord(words[pivot], otherSeparator) + 1;
                                        ++pivot;
                                        if (exactLen && wordlen != LengthWord(wordStart, otherSeparator) + 1)
                                                continue;
                                        wordsNear.append(words[pivot-1], wordlen, ' ');
                                }
                                return wordsNear.detach();
                        } else if (cond < 0) {
                                end = pivot - 1;
                        } else if (cond > 0) {
                                start = pivot + 1;
                        }
                }
        }
        return NULL;
}