source: cpp/frams/util/sstringutils.cpp @ 257

// This file is a part of the Framsticks GDK.
// Copyright (C) 1999-2014  Maciej Komosinski and Szymon Ulatowski.  See LICENSE.txt for details.
// Refer to http://www.framsticks.com/ for further information.

#include "sstringutils.h"
#include <frams/virtfile/virtfile.h>
#include <common/framsg.h>
#include <common/nonstd.h>

int loadSString(const char* filename, SString& s, const char* framsgmodule, const char* error)
{
        VirtFILE *f;
        int ret = 0;
        if (f = Vfopen(filename, FOPEN_READ_BINARY))
        {
                loadSString(f, s);
                ret = 1;
                fclose(f);
        }
        else if (framsgmodule)
                FMprintf(framsgmodule, "loadSString", FMLV_WARN, error ? error : "can't open file \"%s\"", filename);
        return ret;
}

void loadSString(VirtFILE *f, SString& s)
{
        char buf[1024];
        int len;
        while (!f->Veof())
        {
                len = fread(buf, 1, sizeof(buf), f);
                s.append(buf, len);
        }
        removeCR(s);
}

//load single line, discarding any \r or \n found at the end, return false if nothing could be loaded (error or eof)
bool loadSStringLine(VirtFILE* f, SString& s)
{
        char buf[100];
        bool eolfound = false;
        bool ret = false;
        s = SString::empty();
        while (!eolfound)
        {
                char *r = fgets(buf, sizeof(buf), f);
                if (r == NULL) break;
                ret = true;
                int d = strlen(r);
                if (d > 0)
                {
                        if (r[d - 1] == '\n') { d--; eolfound = true; }
                        if (d > 0) if (r[d - 1] == '\r') d--;
                        s += SString(r, d);
                }
        }
        return ret;
}

//////////////////////////

/** "x~xx~xxx" -> "x\~xx\~xxx"  */
int quoteTilde(SString &target)
{
        const char* x = target;
        SString tmp;
        char *f;
        while (1)
        {
                f = strchr((char*)x, '~');
                if (f)
                {
                        tmp.append(x, f - x);
                        tmp += "\\~";
                        x = f + 1;
                }
                else
                {
                        if (tmp.len() == 0) return 0; // nothing was changed!
                        tmp += x;
                        target = tmp;
                        return 1;
                }
        }
}

/** "x\~xx\~xxx" -> "x~xx~xxx"  */
int unquoteTilde(SString &target)
{
        const char* x = target;
        SString tmp;
        char *f;
        while (1)
        {
                f = strchr((char*)x, '\\');
                if (f)
                {
                        tmp.append(x, f - x);
                        if (f[1] == '~')
                        {
                                tmp += '~';
                                x = f + 2;
                        }
                        else
                        {
                                tmp += "\\";
                                x = f + 1;
                        }
                }
                else
                {
                        if (tmp.len() == 0) return 0; // nothing was changed!
                        tmp += x;
                        target = tmp;
                        return 1;
                }
        }
}

/////////////////

bool strContainsOneOf(const char* str, const char* chars)
{
        while (*str)
        {
                if (strchr(chars, *str)) return 1;
                str++;
        }
        return 0;
}

//////////////

bool sstringQuote(SString& target)
{
        const char* x = target;
        bool changed = 0;
        SString tmp;
        tmp.memoryHint(target.len());
        while (*x)
        {
                switch (*x)
                {
                case '\n': tmp += "\\n"; changed = 1; break;
                case '\r': tmp += "\\r"; changed = 1; break;
                case '\t': tmp += "\\t"; changed = 1; break;
                case '\"': tmp += "\\\""; changed = 1; break;
                case '\\': tmp += "\\\\"; changed = 1; break;
                default: tmp += *x;
                }
                x++;
        }
        if (changed) target = tmp;
        return changed;
}

const char* skipQuoteString(const char* txt, const char* limit)
{
        while (*txt)
        {
                if (*txt == '\"') return txt;
                if (*txt == '\\') txt++;
                txt++;
                if (txt == limit) break;
        }
        return txt;
}

int sstringUnquote(SString &target)
{
        const char* x = target;
        SString tmp;
        char *f;
        while (1)
        {
                f = strchr((char*)x, '\\');
                if (f)
                {
                        tmp.append(x, f - x);
                        switch (f[1])
                        {
                        case 'n': tmp += '\n'; break;
                        case 'r': tmp += '\r'; break;
                        case 't': tmp += '\t'; break;
                        case '\"': tmp += '\"'; break;
                        default: tmp += f[1];
                        }
                        x = f + 2;
                }
                else
                {
                        if (tmp.len() == 0) return 0; // nothing was changed!
                        tmp += x;
                        target = tmp;
                        return 1;
                }
        }
}

int strFindField(const SString& txt, const SString& name, int &end)
{
        const char* t = txt, *n;
        int pos = 0;
        while (1)
        {
                n = strchr(t + pos, ',');
                if ((!strncmp(t + pos, name, name.len())) && (t[pos + name.len()] == '='))
                {
                        if (n) end = n - t; else end = txt.len();
                        return pos;
                }
                if (n) pos = n - t + 1; else break;
        }
        return -1;
}

SString strGetField(const SString& txt, const SString& name)
{
        int p, e;
        p = strFindField(txt, name, e);
        if (p < 0) return SString();
        p += name.len() + 1;
        return SString(txt.substr(p, e - p));
}

void strSetField(SString& txt, const SString& name, const SString& value)
{
        int p, e;
        p = strFindField(txt, name, e);
        if (p < 0)
        {
                if (!value.len()) return;
                char *t = txt.directAppend(1 + name.len() + value.len());
                char *b = t;
                if (txt.len()) *(t++) = ',';
                strcpy(t, name); t += name.len();
                *(t++) = '=';
                strcpy(t, value); t += value.len();
                txt.endAppend(t - b);
        }
        else
        {
                if (!value.len())
                {
                        if (p > 0) p--; else if (e < txt.len()) e++;
                        char *t = txt.directWrite(0);
                        memmove(t + p, t + e, txt.len() - e);
                        txt.endWrite(txt.len() + value.len() - (e - p));
                }
                else
                {
                        p += name.len() + 1;
                        char *t = txt.directWrite(txt.len() + value.len() - (e - p));
                        memmove(t + p + value.len(), t + e, txt.len() - e);
                        memmove(t + p, value, value.len());
                        txt.endWrite(txt.len() + value.len() - (e - p));
                }
        }
}

SString trim(SString& s)
{
        const unsigned char*b = (const unsigned char*)(const char*)s;
        const unsigned char*e = b + s.len();
        while ((b < e) && (*b <= ' ')) b++;
        while ((b < e) && (e[-1] <= ' ')) e--;
        if ((e - b) == s.len()) return s;
        SString newstring;
        char* t = newstring.directWrite(e - b);
        memmove(t, b, e - b);
        newstring.endWrite(e - b);
        return newstring;
}

bool removeCR(SString& s)
{
        const char* p = (const char*)s;
        const char* cr = strchr(p, '\r');
        if (!cr) return false;
        char* begin = s.directWrite();
        char* src = begin + (cr - p), *dst = src;
        while (*src)
                if (*src == '\r')
                        src++;
                else
                        *(dst++) = *(src++);
        s.endWrite(dst - begin);
        return true;
}

bool matchWildcard(const SString& word, const SString& pattern)
{
        if (pattern.len() == 0)
                return word.len() == 0;
        int aster = pattern.indexOf('*');
        if (aster >= 0)
        {
                SString before = pattern.substr(0, aster);
                SString after = pattern.substr(aster + 1);
                int pos = 0;
                if (!word.len()) return false;
                if (before.len()) if (!word.startsWith(before)) return false;
                if (after.len())
                        if ((word.len() < after.len())
                                || (strcmp((const char*)after, ((const char*)word) + word.len() - after.len())))
                                return false;
                return true;
        }
        else
                return word == pattern;
}

bool matchWildcardList(const SString& word, const SString& patterns)
{
        if (patterns.len() == 0)
                return word.len() == 0;
        int pos = 0;
        SString pattern;
        while (patterns.getNextToken(pos, pattern, ','))
                if (matchWildcard(word, pattern))
                        return true;
        return false;
}