chew.h

Go to the documentation of this file.

#ifndef CHEW_H
#define CHEW_H
#pragma once
/***************************************************************************
 *   Copyright (C) 2007-2013 Mike Kinghan, imk@burroingroingjoing.com      *
 *   All rights reserved.                                                  *
 *                                                                         *
 *   Contributed by Mike Kinghan, imk@burroingroingjoing.com,              *
 *   derived from the code of Tony Finch                                   *
 *                                                                         *
 *   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.  *
 *                                                                         *
 *   Neither the name of Mike Kinghan nor the names of its contributors    *
 *   may be used to endorse or promote products derived from this software *
 *   without specific prior written permission.                            *
 *                                                                         *
 *   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 OWNER 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.                                                               *
 *                                                                         *
 **************************************************************************/
#include "prohibit.h"
#include "eol.h"
#include <type_traits>
#include <cctype>

namespace chew_mode
{

static bool const plaintext = false;
static bool const cxxtext = true;

enum class text_type
{
        none,
        whitespace,
        greyspace,
        continuation,
        cxx_comment,
        c_comment,
        string_literal,
        character_literal,
        raw_string_literal,
        header_name,
        code,
        name,
        literal_space,
        punctuation,
        number_space,
        stringify,
        token_paste
};
struct whitespace
{
        static text_type const id = text_type::whitespace;
        whitespace() {}
};
struct greyspace
{
        static text_type const id = text_type::greyspace;
        greyspace() {}
};
struct continuation
{
        static text_type const id = text_type::continuation;
        continuation() {}
};
struct cxx_comment
{
        static text_type const id = text_type::cxx_comment;
        cxx_comment() {}
};

struct c_comment
{
        static text_type const id = text_type::c_comment;
        c_comment() {}
};

struct string_literal
{
        static text_type const id = text_type::string_literal;
        string_literal() {}
};

struct character_literal
{
        static text_type const id = text_type::character_literal;
        character_literal() {}
};

struct raw_string_literal
{
        static text_type const id = text_type::raw_string_literal;
        raw_string_literal() {}
};

struct header_name
{
        static text_type const id = text_type::header_name;
        header_name() {}
};

struct code
{
        static text_type const id = text_type::code;
        code() {}
};

struct name
{
        static text_type const id = text_type::name;
        name() {}
};

struct literal_space
{
        static text_type const id = text_type::literal_space;
        literal_space() {}
};

struct punctuation
{
        static text_type const id = text_type::punctuation;
        punctuation() {}
};

struct number_space
{
        static text_type const id = text_type::number_space;
        number_space() {}
};

struct stringify
{
        static text_type const id = text_type::stringify;
        stringify() {}
};

struct token_paste
{
        static text_type const id = text_type::token_paste;
        token_paste() {}
};


} // namespace chew_mode

chew_mode::whitespace const whitespace;
chew_mode::greyspace const greyspace;
chew_mode::continuation const continuation;
chew_mode::cxx_comment const cxx_comment;
chew_mode::c_comment const c_comment;
chew_mode::string_literal const string_literal;
chew_mode::character_literal const character_literal;
chew_mode::raw_string_literal const raw_string_literal;
chew_mode::header_name const header_name;
chew_mode::code const code;
chew_mode::name const name;
chew_mode::literal_space const literal_space;
chew_mode::punctuation const punctuation;
chew_mode::number_space const number_space;
chew_mode::stringify const stringify;
chew_mode::token_paste const token_paste;

template<class CharSeq>
struct chewer : private no_assign
{
    static_assert(traits::is_random_access_char_sequence<CharSeq>::value,">:[");

    using sequence_type = CharSeq;
    using char_type = typename sequence_type::value_type;
    template<class Mode1, class Mode2>
    using void_if  =
    typename std::enable_if<std::is_same<Mode1,Mode2>::value>::type;

        explicit chewer(bool cxx, sequence_type & seq, size_t off = 0)
                : _cxx(cxx),_seq(seq),_buf(nullptr),_cur(off),_len(0) {
                sync();
        }

        template<class Mode>
        explicit chewer(bool cxx, Mode mode, sequence_type & seq, size_t off = 0)
                : _cxx(cxx), _seq(seq),_buf(nullptr),_cur(off),_len(0) {
                scan<Mode>();
        }

        bool cxx() const {
                return _cxx;
        }

        void sync() {
                _buf = const_cast<char_type *>(_seq.data());
                _len = _seq.size();
        }

        template<class Mode>
        void scan(Mode mode, size_t off) {
                cursor(off);
                scan<Mode>();
        }

        template<class FirstMode, class ...OtherModes>
        void scan(      ptrdiff_t adjust,
                                FirstMode first_mode, OtherModes... other_modes) {
                adjust >= 0 ? on(adjust) : back(-adjust);
                scan<FirstMode,OtherModes...>();
        }

        template<class FirstMode, class ...OtherModes>
        void scan() {
                sync();
                consume<FirstMode,OtherModes...>();
        }

        bool overshoot(size_t off = 0) const {
                return _cur + off >= _len;
        }

        char_type atoff(ptrdiff_t off) const {
                return _buf[_cur + off];
        }

        char_type & atoff(size_t off) {
                return _buf[_cur + off];
        }

        char_type operator[](size_t off) const {
                return atoff(off);
        }

        char_type & operator[](size_t off) {
                return atoff(off);
        }

        size_t cursor() const {
                return _cur;
        }

        size_t remaining() const {
                return _len - _cur;
        }

        void cursor(size_t off) {
                sync();
                _cur = off;
        }

        char_type curch() const {
                return _buf[_cur];
        }

        char_type & curch() {
                return _buf[_cur];
        }

        chewer & operator=(size_t off) {
                cursor(off);
                return *this;
        }

        explicit operator size_t () const {
                return cursor();
        }

        sequence_type & buf() {
                return _seq;
        }
        sequence_type const & buf() const {
                return _seq;
        }

        char_type operator *() const {
                return curch();
        }
        char_type & operator *() {
                return curch();
        }

        explicit operator bool () const {
                return !overshoot();
        }

        void on(size_t n) {
                _cur += n;
        }

        void back(size_t n) {
                _cur -= n;
        }

        chewer & operator++() {
                ++_cur;
                return *this;
        }

    chewer & operator--() {
                --_cur;
                return *this;
        }

        chewer & operator+=(size_t n) {
                on(n);
                return *this;
        }

        chewer & operator-=(size_t n) {
                back(n);
                return *this;
        }

        template<class Mode>
        chewer & operator()(ptrdiff_t move, Mode mode) {
                scan(move,mode);
                return *this;
        }

        template<class FirstMode, class ...OtherModes>
        typename
        std::enable_if<!std::is_arithmetic<FirstMode>::value,chewer &>::type
        operator()(FirstMode first_mode, OtherModes... other_modes) {
                scan<FirstMode,OtherModes...>();
                return *this;
        }

private:

    template<typename U>
    using if_sequence_is_extensible =
        typename
        std::enable_if<traits::has_extend_method<U>::value>::type;

    template<typename U>
    using if_sequence_is_not_extensible =
        typename
        std::enable_if<!traits::has_extend_method<U>::value>::type;

        template<typename U = sequence_type>
        void extend(if_sequence_is_extensible<U> * = nullptr) {
                _seq.extend();
                sync();
        }
        template<typename U = sequence_type>
        void extend(if_sequence_is_not_extensible<U> * = nullptr) {}


        template<typename U = sequence_type>
        void extend(size_t skip, if_sequence_is_extensible<U> * = nullptr) {
                _seq.extend(skip);
                sync();
        }
        template<typename U = sequence_type>
        void
        extend(
        size_t skip,
        if_sequence_is_not_extensible<U> * = nullptr) {}

        unsigned eol(size_t off = 0) {
                return ::eol(_seq,_cur + off);
        }

        bool line_continues(size_t off = 0) {
                return atoff(off) == '\\' && eol(off + 1);
        }

        template<class Mode>
    void_if<Mode,chew_mode::continuation> consume() {
        size_t nl_len;
        for (   ; curch() == '\\' && (nl_len = eol(1)); on(nl_len + 1)) {
            if (overshoot(nl_len + 1)) {
                extend(nl_len);
            }
        }
        }

    template<class Mode>
    void_if<Mode,chew_mode::whitespace> consume() {
        consume<chew_mode::continuation>();
        for (   ;!overshoot() && isspace(curch());
                ++_cur,consume<chew_mode::continuation>()) {}
    }

    template<class Mode>
    void_if<Mode,chew_mode::number_space> consume() {
        consume<chew_mode::continuation>();
        size_t mark = _cur;
        if (!overshoot() && curch() == '.') {
            ++_cur;
        }
        if (overshoot() || !isdigit(curch())) {
            _cur = mark;
            return;
        }
        for (++_cur     ;!overshoot() && (
                        isalnum(curch()) || curch() == '_' || curch() == '+' ||
                            curch() == '-' || curch() == '.');
                ++_cur,consume<chew_mode::continuation>()) {}
    }

    template<class Mode>
    void_if<Mode,chew_mode::name> consume() {
       consume<chew_mode::continuation>();
       if (!overshoot() && (isalpha(curch()) || curch() == '_')) {
           for (++_cur; !overshoot() && (isalnum(curch()) || curch() == '_');
                ++_cur,consume<chew_mode::continuation>()){}
        }
    }


    template<class Mode>
    void_if<Mode,chew_mode::punctuation> consume() {
        consume<chew_mode::continuation>();
        for (   ;!overshoot() && ispunct(curch()) &&
            (curch() != '_' && curch() != '\'' && curch() != '\"');
                ++_cur,consume<chew_mode::continuation>()) {}
    }

    template<class Mode>
    void_if<Mode,chew_mode::stringify> consume() {
        consume<chew_mode::continuation>();
        _cur += !overshoot() && curch() == '#';
    }

    template<class Mode>
    void_if<Mode,chew_mode::token_paste> consume() {
        size_t mark = _cur;
        consume<chew_mode::continuation>();
        if ((_cur += !overshoot() && curch() == '#') > mark) {
            consume<chew_mode::continuation>();
            if (!overshoot() && curch() == '#') {
                ++_cur;
            } else {
                _cur = mark;
            }
        }
    }

    template<class Mode>
    void_if<Mode,chew_mode::cxx_comment> consume() {
        consume<chew_mode::continuation>();
        size_t mark = _cur;
        if (!overshoot() && curch() == '/') {
            ++_cur;
            consume<chew_mode::continuation>();
            if (overshoot() || curch() != '/') {
                _cur = mark;
                return;
            }
            for(++_cur;
                !overshoot();
                    ++_cur,consume<chew_mode::continuation>()){};
        }
    }

    template<class Mode>
    void_if<Mode,chew_mode::c_comment> consume() {
        consume<chew_mode::continuation>();
        size_t mark = _cur;
        if (overshoot() || curch() != '/') {
            return;
        }
        ++_cur;
        consume<chew_mode::continuation>();
        if (overshoot() || curch() != '*') {
            _cur = mark;
            return;
        }
        bool closing = false;
        ++_cur;
        consume<chew_mode::continuation>();
        for (   ; !overshoot();
                closing = (curch() == '*'),
                ++_cur,consume<chew_mode::continuation>()) {
            if (curch() == '/') {
                if (closing) {
                    ++_cur;
                    return;
                }
            } else {
                size_t nl_len = eol();
                if (nl_len && overshoot(nl_len + 1)) {
                    extend(nl_len);
                }
            }
        }
        eof_in_comment();
    }

    template<class Mode>
    void_if<Mode,chew_mode::string_literal> consume() {
        consume<chew_mode::continuation>();
        consume_enclosed_string<'\"','\"'>();
    }

    template<class Mode>
    void_if<Mode,chew_mode::header_name> consume() {
        consume<chew_mode::continuation>();
        size_t mark = _cur;
        consume_enclosed_string<'<','>'>();
        if (_cur == mark) {
            consume_enclosed_string<'\"','\"'>();
        }
    }

    template<class Mode>
    void_if<Mode,chew_mode::character_literal> consume() {
        consume<chew_mode::continuation>();
        if (overshoot() || curch() != '\'') {
            return;
        }
        size_t mark = _cur;
        ++_cur;
        consume<chew_mode::continuation>();
        bool escape = false;
        for (   ; !overshoot(); ++_cur,consume<chew_mode::continuation>()) {
            if (curch() == '\'') {
                if (!escape) {
                    ++_cur;
                    return;
                }
                escape = false;
            } else if (curch() == '\\') {
                escape = !escape;
            } else {
                escape = false;
            }
        }
        _cur = mark;
    }

    template<class Mode>
    void_if<Mode,chew_mode::raw_string_literal> consume() {
        consume<chew_mode::continuation>();
        if (overshoot() || curch() != 'R') {
            return;
        }
        size_t mark = _cur;
        ++_cur;
        consume<chew_mode::continuation>();
        if (overshoot() || curch() != '\"') {
            _cur = mark;
            return;
        }
        ++_cur;
        consume<chew_mode::continuation>();
        for (   ; !overshoot(); ++_cur,consume<chew_mode::continuation>()) {
            if (!isgraph(curch()) || curch() == '\\') {
                _cur = mark;
                return;
            }
            if (curch() == '(') {
                break;
            }
        }
        ++_cur;
        consume<chew_mode::continuation>();
        for (   ; !overshoot(); ++_cur,consume<chew_mode::continuation>()) {
            if (curch() == ')') {
                break;
            }
            size_t nl_len = eol();
            if (nl_len != 0) {
                extend(nl_len);
            }
        }
        ++_cur;
        consume<chew_mode::continuation>();
        for (; !overshoot(); ++_cur,consume<chew_mode::continuation>()) {
            if (!isgraph(curch()) || curch() == '\\') {
                break;
            }
            if (curch() == '\"') {
                ++_cur;
                return;
            }
        }
        missing_terminator(mark,'\"');
    }

    template<class Mode>
    void_if<Mode,chew_mode::greyspace> consume() {
        if (!_cxx) {
            consume<chew_mode::whitespace>();
            return;
        }
        for (   ;!overshoot(); ) {
            consume<chew_mode::whitespace>();
            size_t mark = _cur;
            consume<chew_mode::cxx_comment>();
            if (_cur != mark) {
                break;
            }
            consume<chew_mode::c_comment>();
            if (_cur == mark) {
                break;
            }
        }
    }

    template<class Mode>
    void_if<Mode,chew_mode::code> consume() {
        for (   ;!overshoot(); ++_cur) {
            consume<chew_mode::greyspace>();
            consume<chew_mode::character_literal>();
            consume<chew_mode::string_literal>();
            consume<chew_mode::raw_string_literal>();
        }
    }

    template<class Mode>
    void_if<Mode,chew_mode::literal_space> consume() {
        consume<chew_mode::character_literal,
                chew_mode::string_literal,
                chew_mode::raw_string_literal>();
    }

        template<class First, class Next, class ...Rest>
        typename std::enable_if<sizeof ...(Rest) == 0>::type
        consume();

        template<class First, class Next, class ...Rest>
        typename std::enable_if<sizeof ...(Rest) != 0>::type
        consume();


        template<char_type Opener, char_type Closer>
        void consume_enclosed_string();

        void missing_terminator(size_t off, char_type missing);
        void eof_in_comment();

        bool _cxx;
        sequence_type & _seq;
        char_type *_buf;
        size_t _cur;
        size_t _len;

};

template<class CharSeq>
template<
    typename chewer<CharSeq>::char_type Opener,
    typename chewer<CharSeq>::char_type Closer
>
void chewer<CharSeq>::consume_enclosed_string()
{
        if (overshoot() || curch() != Opener) {
                return;
        }
        size_t mark = _cur++;
        consume<chew_mode::continuation>();
        bool escape = false;
        for (   ; !overshoot(); ++_cur,consume<chew_mode::continuation>()) {
                if (curch() == Closer) {
                        if (!escape) {
                                ++_cur;
                                return;
                        }
                        escape = false;
                } else if (curch() == '\\') {
                        escape = !escape;
                } else {
                        escape = false;
                }
        }
        if (overshoot()) {
                missing_terminator(mark,Closer);
        }
}

template<class CharSeq>
template<class First, class Next, class ...Rest>
typename std::enable_if<sizeof ...(Rest) == 0>::type
chewer<CharSeq>::consume() {
        for (   ;!overshoot(); ) {
                size_t mark = _cur;
                consume<First>();
                consume<Next>();
                if (_cur == mark) {
                        break;
                }
        }
}

template<class CharSeq>
template<class First, class Next, class ...Rest>
typename std::enable_if<sizeof ...(Rest) != 0>::type
chewer<CharSeq>::consume() {
        for (   ;!overshoot(); ) {
                size_t mark = _cur;
                consume<First>();
                consume<Next,Rest...>();
                if (_cur == mark) {
                        break;
                }
        }
}

#endif /* EOF*/