parsed_line.h

Go to the documentation of this file.

#ifndef PARSED_LINE_H
#define PARSED_LINE_H
#pragma once
/***************************************************************************
 *   Copyright (C) 2013 Mike Kinghan, imk@burroingroingjoing.com           *
 *   All rights reserved.                                                  *
 *                                                                         *
 *   Contributed originally by Mike Kinghan, imk@burroingroingjoing.com    *
 *                                                                         *
 *   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 "parse_buffer.h"
#include "directive_type.h"

struct parsed_line : parse_buffer
{
        using base_type = parse_buffer;

        explicit parsed_line(std::istream * in, std::ostream * out)
    :   _in(in),
        _out(out){}

        ~parsed_line() override {}

        std::istream * file() {
                return _in;
        }

        unsigned num() const {
                return _lineno;
        }

        unsigned extensions() const {
                return _extensions;
        }

        void mark_keyword(size_t off, size_t len) {
                _keyword_posn = off;
                _keyword_len = len;
        }

        bool get();

        void replace(std::string const & replacement) {
                _text = replacement;
        }

        template<directive_type DirectiveType>
        void keyword_edit();

        void set_simplified(bool value = true) {
                _simplified = value;
        }

        bool is_simplified() const {
                return _simplified;
        }

        bool reportable() {
                return _reportable;
        }

        void set_directive_type(directive_type dtype) {
                _dtype = dtype;
                set_reportable();
        }

        directive_type get_directive_type() const {
                return _dtype;
        }

        void set_dropping();

        bool dropping() const {
                return _dropping;
        }

        void output();

        void drop();

        unsigned & indent() {
                return _indent;
        }

protected:

        size_t extension_pending(size_t off) const override {
                if (at(off) == '\\') {
                        auto advance = eol(++off);
                        if (advance && overshoot(advance + off)) {
                                return ++advance;
                        }
                }
                return 0;
        }

        size_t extend(size_t skip) override;

        size_t extend() override;

        void keyword_lop(std::string const & keyword);

        void keyword_swap(std::string const & directive);

        void write();
        void write_commented_out();
        void write_fast();
        void write_slow();
        void write(bool keep);

        void set_reportable();

        unsigned _extensions = 0;
        unsigned _lineno = 0;
        std::istream * _in;
        std::ostream * _out;
        size_t  _keyword_posn = 0;
        size_t _keyword_len = 0;
        directive_type _dtype = HASH_UNKNOWN;
        bool _reportable = false;
        bool _dropping = false;
        bool _simplified = false;
        unsigned _drop_run_length = 0;
        unsigned _indent = 0;
};

#endif //EOF