parameter_substitution.h

Go to the documentation of this file.

#ifndef PARAMETER_SUBSTUTION_H
#define PARAMETER_SUBSTUTION_H
#pragma once
/***************************************************************************
 *   Copyright (C) 2007-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 "chew.h"
#include <string>
#include <vector>

// Forward decl
struct symbol;
struct parameter_list;

namespace parameter_substitution {

enum class demarcator : char
{
        soh = '\001',
        stx = '\002',
        etx = '\003',
        ack = '\006',
        nak = '\025',
        sub = '\032',
        esc = '\033'
};


enum class handling : char
{
        substitute_arg = char(demarcator::etx),
        substitute_expanded_arg = char(demarcator::sub),
        substitute_quoted_arg = char(demarcator::esc),
};

struct specifier
{
        static const size_t serialized_size = 4;

        specifier()
        : _bytes{0}{}

        specifier(unsigned short param_i, handling h) {
                _bytes[0] = char(demarcator::stx);
                set_param_index(param_i);
                set_handling(h);
        }

        bool operator==(specifier const & other) const {
                return _bytes[0] == other._bytes[0] &&
                        _bytes[1] == other._bytes[1] &&
                        _bytes[2] == other._bytes[2] &&
                        _bytes[3] == other._bytes[3];
        }

        bool operator!=(specifier const & other) const {
                return !(*this == other);
        }

        void append_to(std::string & s) {
                for (size_t i = 0; i < sizeof(_bytes); ++i) {
                        s += _bytes[i];
                }
        }

        void set_param_index(unsigned short i) {
                _bytes[1] = i >> 8;
                _bytes[2] = (char)i;
        }

        unsigned short get_param_index() const {
                return (_bytes[1] << 8) | _bytes[2];
        }

        void set_handling(handling h) {
                _bytes[3] = (char)h;
        }

        handling get_handling() const {
                return handling(_bytes[3]);
        }

        bool null() const {
                return _bytes[0] == 0;
        }

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

        static specifier read(chewer<std::string> & chew) {
                if (chew && *chew == char(demarcator::stx) && !chew.overshoot(3)) {
                        char h = chew[3];
                        if (h == char(handling::substitute_arg) ||
                                h == char(handling::substitute_expanded_arg) ||
                                h == char(handling::substitute_quoted_arg)) {
                                unsigned short param_i = (chew[1] << 8) | chew[2];
                                chew += serialized_size;
                                return specifier(param_i,handling(h));
                        }
                }
                return specifier();
        }

        static size_t get_at(
                std::string const & str,
                size_t off,
                size_t & i_off,
                size_t & h_off)  {
                if (str[off] == char(demarcator::stx) && off + 3 < str.size()) {
                        char h = str[off + 3];
                        if (h == char(handling::substitute_arg) ||
                                        h == char(handling::substitute_expanded_arg) ||
                                                h == char(handling::substitute_quoted_arg) ) {
                                i_off = off + 1;
                                h_off = off + 3;
                                return off;
                        }
                }
                return std::string::npos;
        }

        static size_t get_ending_at(
                std::string const & str,
                size_t off,
                size_t & i_off,
                size_t & h_off)  {
                ptrdiff_t start = off - 3;
                if (start >= 0 && str[start] == char(demarcator::stx)) {
                        char h = str[off];
                        if (h == char(handling::substitute_arg) ||
                                        h == char(handling::substitute_expanded_arg) ||
                                                h == char(handling::substitute_quoted_arg) ) {
                                i_off = off - 2;
                                h_off = off;
                                return start;
                        }
                }
                return std::string::npos;
        }

        std::string legible() const;

private:

        char _bytes[serialized_size];

};

struct format
{
        explicit format(symbol & sym);

        std::string const & str() const {
                return _fmt;
        }

        std::string legible() const;

        static std::string legible(std::string const & pb);

private:

        void build_format(symbol & sym);

        void do_stringify_adjustments(size_t nparams);

        void do_token_paste_adjustments();

        ptrdiff_t adjust_for_stringify_op(size_t pos, size_t nparams);

        ptrdiff_t adjust_for_token_paste_op(size_t pos);

        std::string _fmt;
        std::vector<size_t> _stringify_offs;
        std::vector<size_t> _token_paste_offs;
};

} // namespace parameter_substitution

#endif // EOF