str.h

// Copyright (c) 2014 Yasser Asmi
// Released under the MIT License (http://opensource.org/licenses/MIT)

#ifndef _STR_H
#define _STR_H

#include "util.h"

#define PUNC_CHARS   "&!|/:;=+*-.$@^%?`,\\"

#define BRAC_CHARS "<([{}])>"

#define ESCAPE_CODES  "nrtbf\\\"/"

#define ESCAPE_CHARS  "\n\r\t\b\f\\\"/"

namespace jvar
{

std::string format(const char* fmt, ...);

void format(std::string& outstr, const char* fmt, ...);

bool vformat(std::string& outstr, const char* fmt, va_list varg);

void upperCase(std::string& str);

void lowerCase(std::string& str);

uint makeUnicode(const char* s, int maxlen, int* lenused = NULL);

std::string makeUTF8(uint charcode);

bool equal(const char* s1, const char* s2, bool ignorecase = false);
inline bool strfind(const char* s, char c, int* pos = NULL)
{
    const char* foundp = strchr(s, c);
    if (foundp)
    {
        if (pos)
        {
            *pos = (foundp - s);
        }
        return true;
    }
    return false;
}

std::string int2str(longint n);

inline void int2str(std::string& s, longint n)
{
    format(s, "%ld", n);
}

std::string dbl2str(double d);

inline void dbl2str(std::string& s, double d)
{
    format(s, "%lf", d);
}

longint str2baseint(const std::string& str, int base, bool* valid = NULL);

inline longint str2int(const std::string& str, bool* valid = NULL)
{
    return str2baseint(str, 10, valid);
}

double str2dbl(const std::string& str, bool* valid  = NULL);

inline std::string pathParent(const std::string p, const char* delim)
{
    return p.substr(0, p.find_last_of(delim));
}

inline std::string pathChild(const std::string p, const char* delim)
{
    return p.substr(p.find_last_of(delim) + 1);
}

template <int MAXFIXED>
class FixedStr
{
public:
    inline FixedStr()
    {
        mFixed[0] = '\0';
    }
    ~FixedStr()
    {
        if (mFixed[0] == '\1')
        {
            if (mDyn.ptr)
            {
                free(mDyn.ptr);
            }
        }
    }
    inline FixedStr(const FixedStr& src)
    {
        mFixed[0] = '\0';
        set(src.get());
    }
    inline FixedStr(FixedStr& src)
    {
        mFixed[0] = '\0';
        set(src.get());
    }
    inline FixedStr& operator=(const FixedStr& src)
    {
        set(src.get());
        return *this;
    }
    inline FixedStr& operator=(const FixedStr* src)
    {
        set(src.get());
        return *this;
    }

    void set(const char* val)
    {
        int len = strlen(val);
        char* dest;

        if (mFixed[0] == '\2')
        {
            mFixed[0] = '\0';
        }

        if (len > (MAXFIXED - 2))
        {
            // Cannot fit in fixed

            if (isFixed())
            {
                mFixed[0] = '\1';

                mDyn.ptr = NULL;
                mDyn.size = 0;
            }
            ensureDyn(len + 1);
            dest = mDyn.ptr;
        }
        else
        {
            // Can fit in fixed

            if (isFixed())
            {
                dest = &(mFixed[1]);
            }
            else
            {
                ensureDyn(len + 1);
                dest = mDyn.ptr;
            }
        }

        memcpy(dest, val, len + 1);
    }

    void setExt(const char* val)
    {
        // Stores an external pointer and doesn't try to free it.
        // Can only be called once.  Can call set() after this, however.

        mFixed[0] = '\2';

        mDyn.ptr = (char*)val;
        mDyn.size = 0;
    }

    const char* get() const
    {
        if (isFixed())
        {
            return &(mFixed[1]);
        }
        else
        {
            return mDyn.ptr;
        }
    }

    void clear()
    {
        if (mFixed[0] == '\1')
        {
            if (mDyn.ptr)
            {
                free(mDyn.ptr);
            }
        }
        mFixed[0] = '\0';
    }

private:
    union
    {
        struct
        {
            int tag;
            char* ptr;
            int size;
        } mDyn;
        char mFixed[MAXFIXED];
    };

    inline bool isFixed() const
    {
        return mFixed[0] == '\0';
    }

    void ensureDyn(int size)
    {
        if (mDyn.ptr != NULL && mDyn.size >= size)
        {
            return;
        }

        void* p = ::realloc(mDyn.ptr, size);
        if (p == NULL)
        {
            dbgerr("FixedStr failed to allocate %d bytes\n", size);
            return;
        }
        mDyn.ptr = (char*)p;
        mDyn.size = size;
   }
};

class Parser
{
public:
    Parser(const char* txt);

    inline bool eof()
    {
        return (mPos >= mTxtLen) || mErr;
    }

    inline bool failed()
    {
        return mErr;
    }

    inline const std::string& errMsg()
    {
        return mErrMsg;
    }

    inline const char* c_str()
    {
        return token().c_str();
    }

    inline const std::string& token()
    {
        parseToken();
        return mToken;
    }

    inline bool tokenEquals(const char* val)
    {
        return token().compare(val) == 0;
    }

    inline void advance()
    {
        mTokParsed = false;
    }

    void advance(const char* match);

    void setError(const char* msg);

    void stripQuotes(bool allowsingle);

    void captureDelim(const char* delim);

private:
    enum TokenStateEnum
    {
        NullTok, WordTok, PuncTok, BracTok, QuoteTok
    };

    const char* mTxt;
    std::string mToken;
    bool mTokParsed;
    int mPos;
    int mLineNum;
    bool mErr;
    int mTxtLen;
    std::string mErrMsg;

protected:
    inline bool charWord(char c)
    {
        return (isalnum(c) || (c == '_') || (c == '\''));
    }
    inline bool charPunc(char c)
    {
        return (strchr(PUNC_CHARS, c) != NULL);
    }
    inline bool charBrac(char c)
    {
        return (strchr(BRAC_CHARS, c) != NULL);
    }

private:
    void parseToken();

    inline void append(char c)
    {
        mToken += c;
    }
    inline void append(const std::string& s)
    {
        mToken += s;
    }
    inline void replaceLast(char c)
    {
        int l = mToken.length();
        if (l > 0)
        {
            mToken[l - 1] = c;
        }
    }
    inline void eraseLast()
    {
        int l = mToken.length();
        if (l >= 1)
        {
            mToken.erase(l - 1, 1);
        }
    }
    inline TokenStateEnum detState(char c)
    {
        if (c == '"' || c == '\'')
        {
            return QuoteTok;
        }
        if (charWord(c))
        {
            return WordTok;
        }
        if (charBrac(c))
        {
            return BracTok;
        }
        //TODO: Should this call charPunc?

        return PuncTok;
    }

};

} // jvar


#endif // _STR_H