/Users/theraven/Documents/Work/Teaching/Compilers ACS Module/Coursework/Resources/Pegmatite/parser.hh

/*-
 * Copyright (c) 2012, Achilleas Margaritis
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * * Redistributions of source code must retain the above copyright notice,
 *   this list of conditions and the following disclaimer.
 *
 * * Redistributions in binary form must reproduce the above copyright notice,
 *   this list of conditions and the following disclaimer in the documentation
 *   and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */
#ifndef PEGMATITE_PARSER_HPP
#define PEGMATITE_PARSER_HPP


#include <vector>
#include <string>
#include <list>
#include <functional>
#include <memory>


namespace pegmatite {


class Expr;
class Context;
class Rule;


class Input
{
    protected:
    static const std::size_t static_buffer_size = 512;
    public:
    typedef size_t Index;
    static const Index npos = static_cast<Index>(-1);
    class iterator : public std::iterator<std::bidirectional_iterator_tag, char32_t>
    {
        friend Input;
        Input    *buffer;
        Index     idx;
        inline iterator(Input *b, Index i) : buffer(b), idx(i) {}
        public:
        inline iterator() : buffer(0), idx(npos) {}
        const std::string& filename() const;
        inline char32_t  operator*() const { return (*buffer)[idx]; }
        inline iterator &operator++()
        {
            idx++;
            return *this;
        }
            inline iterator operator++(int /* dummy */)
        {
            iterator copy = *this;
            idx++;
            return copy;
        }
        inline iterator &operator+=(size_t amount)
        {
            idx += amount;
            return *this;
        }
        inline iterator &operator--()
        {
            idx--;
            return *this;
        }
        inline bool operator==(const iterator &other) const
        {
            return (buffer == other.buffer) && (idx == other.idx);
        }
        inline bool operator!=(const iterator &other) const
        {
            return !(*this == other);
        }
        inline bool operator>(const iterator &other) const
        {
            return (idx > other.idx);
        }
        inline bool operator<(const iterator &other) const
        {
            return (idx < other.idx);
        }
        inline Index operator-(const iterator &other) const
        {
            return idx-other.idx;
        }
        Index index() const { return idx; }
    };
    inline iterator begin()
    {
        return iterator(this, 0);
    }
    inline iterator end()
    {
        return iterator(this, size());
    }
    const std::string& name() const
    {
        return user_name;
    }
    inline char32_t operator[](Index n)
    {
        // If the local buffer can satisfy the request, fetch the value
        if ((n >= buffer_start) && (n < buffer_end))
        {
            return buffer[n - buffer_start];
        }
        return slowCharacterLookup(n);
    }
    Input(const std::string& name)
        : user_name(name), buffer(0), buffer_start(1), buffer_end(0) {}
    private:
    const std::string   user_name;
    char32_t *buffer;
    Index    buffer_start;
    Index    buffer_end;
    char32_t  local_buffer[static_buffer_size];
    char32_t  slowCharacterLookup(Index n);
    protected:
    virtual bool  fillBuffer(Index start, Index &length, char32_t *&b) = 0;
    virtual Index size() const = 0;
    virtual ~Input();
    Input(const Input&);
};

class UnicodeVectorInput : public Input
{
    const std::vector<char32_t> vector;
    public:
    const std::vector<char32_t> &getVector() { return vector; }
    UnicodeVectorInput(std::vector<char32_t> &&v, const std::string& name = "")
        : Input(name), vector(v) {}
    bool  fillBuffer(Index start, Index &length, char32_t *&b) override;
    Index size() const override;
};

struct AsciiFileInput : public Input
{
    AsciiFileInput(int file, const std::string& name = "");
    bool  fillBuffer(Index start, Index &length, char32_t *&b) override;
    Index size() const override;
    private:
    int fd;
    size_t file_size;
};

struct StreamInput : public Input
{
    public:
    static StreamInput Create(const std::string& name, std::istream&);

    bool fillBuffer(Index start, Index &length, char32_t*&) override;
    Index size() const override;

    private:
    StreamInput(const std::string& name, std::istream&, size_t len);

    const size_t length;
    std::istream& stream;
};

class StringInput : public Input
{
    const std::string str;
    public:
    const std::string &getString() { return str; }
    StringInput(std::string &&s, const std::string& name = "")
        : Input(name), str(s) {}
    StringInput(const std::string& s, const std::string& name = "")
        : Input(name), str(s) {}
    bool  fillBuffer(Index start, Index &length, char32_t *&b) override;
    Index size() const override;
};

template<class T>
class IteratorInput : public Input
{
    T begin;
    T end;
    public:
    IteratorInput(T b, T e, const std::string& name = "")
        : Input(name), begin(b), end(e) {}
    bool fillBuffer(Index start, Index &length, char32_t *&b) override
    {
        if (start > std::distance(begin, end))
        {
            length = 0;
            return false;
        }
        Index copied = 0;
        for (T i=std::advance(begin, start) ; (i != end) && (copied < length) ; ++i)
        {
            b[copied++] = static_cast<char32_t>(*i);
        }
        length = copied;
        return true;
    }
    Index size() const override { return std::distance(begin, end); }
};


struct ParserPosition
{
    Input::iterator it;

    const std::string& filename() const { return it.filename(); }

    int line;

    int col;

    ParserPosition() {}

    ParserPosition(Input &i);
};

class InputRange
{
public:
    ParserPosition start;

    ParserPosition finish;

    InputRange() {}

    InputRange(const ParserPosition &b, const ParserPosition &e);
    Input::iterator begin() const { return start.it; }
    Input::iterator end() const { return finish.it; }
    std::string str() const;
};

typedef std::function<bool(const InputRange&, void*)> parse_proc;


typedef std::function<void (const InputRange&, const std::string&)> ErrorReporter;

class CharacterExpr;
typedef std::shared_ptr<CharacterExpr> CharacterExprPtr;

struct ExprPtr : public std::shared_ptr<Expr>
{
    ExprPtr(Expr *e) : std::shared_ptr<Expr>(e) {}
    ExprPtr(const Rule &e);
    ExprPtr(const CharacterExprPtr &e);
    ExprPtr(const char *);
    ExprPtr(const char32_t);
};


class Rule
{
public:
    Rule(const ExprPtr e);
    Rule(const CharacterExprPtr e) : Rule(ExprPtr(e)) {}
    Rule(const Rule &r) : Rule(ExprPtr(r)) {}
    Rule(const Rule &&r);
    Rule& operator=(Rule &&);
private:
    ExprPtr expr;

    friend class Context;
};

class Expr
{
public:
    virtual ~Expr();

    virtual bool parse_non_term(Context &con) const = 0;

    virtual bool parse_term(Context &con) const = 0;

    virtual void dump() const = 0;

};
ExprPtr operator *(const ExprPtr &e);
inline ExprPtr operator *(const Rule &r)
{
    return *ExprPtr(r);
}

ExprPtr operator +(const ExprPtr &e);
inline ExprPtr operator +(const Rule &r)
{
    return +ExprPtr(r);
}

ExprPtr operator -(const ExprPtr &e);
inline ExprPtr operator -(const Rule &r)
{
    return -ExprPtr(r);
}

ExprPtr operator &(const ExprPtr &e);
inline ExprPtr operator &(const Rule &r)
{
    return &ExprPtr(r);
}

ExprPtr operator !(const ExprPtr &e);
inline ExprPtr operator !(const Rule &r)
{
    return !ExprPtr(r);
}


CharacterExprPtr operator "" _E(const char x);
CharacterExprPtr operator "" _E(const char32_t x);
ExprPtr operator "" _S(const char *x, std::size_t len);
ExprPtr operator "" _E(const char *x, std::size_t len);
ExprPtr operator "" _R(const char *x, std::size_t len);
ExprPtr operator-(const CharacterExprPtr &left, const CharacterExprPtr &right);
ExprPtr operator-(const CharacterExprPtr &left, char32_t right);


#ifdef DEBUG_PARSING
ExprPtr trace_debug(const char *msg, const ExprPtr e);
inline ExprPtr trace(const char *msg, const ExprPtr e)
{
    return trace_debug(msg, e);
}
#else
inline ExprPtr trace(const char *, const ExprPtr e)
{
    return e;
}
#endif


ExprPtr operator >> (const ExprPtr &left, const ExprPtr &right);

ExprPtr operator | (const ExprPtr &left, const ExprPtr &right);

ExprPtr term(const ExprPtr &e);


ExprPtr set(const char *s);

ExprPtr regex(const char *s);

ExprPtr regex(const wchar_t *s);


ExprPtr set(const wchar_t *s);


ExprPtr range(char32_t min, char32_t max);


ExprPtr nl(const ExprPtr &e);


ExprPtr eof();


ExprPtr any();

ExprPtr debug(std::function<void()> fn);

struct ParserDelegate
{
    virtual parse_proc get_parse_proc(const Rule &) const = 0;
    virtual ~ParserDelegate();
};

bool parse(Input &i, const Rule &g, const Rule &ws, ErrorReporter &err,
           const ParserDelegate &delegate, void *d);


template <class T> T &operator << (T &stream, const InputRange &ir)
{
    for(auto c : ir)
    {
        stream << static_cast<typename T::char_type>(c);
    }
    return stream;
}



} //namespace pegmatite


#endif //PEGMATITE_PARSER_HPP