expression_parser.h

Go to the documentation of this file.

#ifndef EXPRESSION_PARSER_H
#define EXPRESSION_PARSER_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 "evaluation.h"
#include <string>
#include <vector>

// Forward decl
struct diagnostic_base;
struct reference;

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

    using sequence_type = CharSeq;
        enum deletion_code {
                not_deleted,
                non_paren = 1,
                paren
        };

        enum precedence {
                max = 10,
                ternary_either_or = 10,
                ternary_if = 10,
                comma = 9,
                boolean_or = 8,
                boolean_and = 7,
                bit_or = 6,
                bit_xor = 6,
                bit_and = 6,
                eq = 5,
                neq = 5,
                le = 4,
                ge = 4,
                lt = 4,
                gt = 4,
                lshift = 3,
                rshift = 3,
                add = 2,
                subtract = 2,
                mult = 1,
                divide = 1,
                mod = 1,
        };

    expression_parser(
        chewer<sequence_type> & chew,
        reference const * ref = nullptr)
    :   _ternary_cond_stack(0),_seq(chew.buf()),
        _start(chew),_cuts(0),_last_deletion(-1),_ref(ref) {
        parse(chew);
    }

        expression_parser(
                sequence_type & seq,
                reference const * ref = nullptr,
                size_t start = 0);

        evaluation result() const {
                return _eval;
        }

        explicit operator evaluation () const {
                return result();
        }

        std::string simplified() const;

        bool is_simplified() const {
                return _cuts != 0;
        }

private:

    using infix_operation =
    evaluation  (expression_parser::*)(evaluation const &, evaluation const &);

        evaluation op_lt(evaluation const & lhs, evaluation const & rhs) {
                return evaluation(lhs.value() < rhs.value());
        }

        evaluation op_gt(evaluation const & lhs, evaluation const & rhs) {
                return evaluation(lhs.value() > rhs.value());
        }

        evaluation op_le(evaluation const & lhs, evaluation const & rhs) {
                return evaluation(lhs.value() <= rhs.value());
        }

        evaluation op_ge(evaluation const & lhs, evaluation const & rhs) {
                return evaluation(lhs.value() >= rhs.value());
        }

        evaluation op_eq(evaluation const & lhs, evaluation const & rhs) {
                return evaluation(lhs.value() == rhs.value());
        }

        evaluation op_ne(evaluation const & lhs, evaluation const & rhs) {
                return evaluation(lhs.value() != rhs.value());
        }

        evaluation op_or(evaluation const & lhs, evaluation const & rhs);

        evaluation op_and(evaluation const & lhs, evaluation const & rhs);

        evaluation
        op_ternary_if(evaluation const & lhs, evaluation const & rhs) {
                _ternary_cond_stack.push_back(lhs);
                return rhs;
        }

        evaluation op_ternary_either_or(evaluation const & lhs,
                                                                                        evaluation const & rhs);

        evaluation
        op_bit_and(evaluation const & lhs, evaluation const & rhs) {
                return evaluation(lhs.value() & rhs.value());
        }

        evaluation
        op_bit_or(evaluation const & lhs, evaluation const & rhs) {
                return evaluation(lhs.value() | rhs.value());
        }

        evaluation
        op_bit_xor(evaluation const & lhs, evaluation const & rhs) {
                return evaluation(lhs.value() ^ rhs.value());
        }

        evaluation
        op_lshift(evaluation const & lhs, evaluation const & rhs) {
                return evaluation(lhs.value() << rhs.value());
        }

        evaluation
        op_rshift(evaluation const & lhs, evaluation const & rhs) {
                return evaluation(lhs.value() >> rhs.value());
        }

        evaluation op_add(evaluation const & lhs, evaluation const & rhs) {
                return evaluation(lhs.value() + rhs.value());
        }

        evaluation
        op_subtract(evaluation const & lhs, evaluation const & rhs) {
                return evaluation(lhs.value() - rhs.value());
        }

        evaluation
        op_comma(evaluation const & lhs, evaluation const & rhs) {
                return rhs;
        }

        evaluation op_mult(evaluation const & lhs, evaluation const & rhs) {
                return evaluation(lhs.value() * rhs.value());
        }

        evaluation op_divide(evaluation const & lhs, evaluation const & rhs);

        evaluation op_mod(evaluation const & lhs, evaluation const & rhs);

        void parse(chewer<sequence_type> & chew);

        evaluation
        unary_op(chewer<sequence_type> & chew, size_t end);

        template<unsigned Precedence>
        evaluation
        infix_op(chewer<sequence_type> & chew, size_t end);


        template<unsigned Precedence>
        typename std::enable_if<(Precedence == 0),evaluation>::type
        next_evaluator(chewer<sequence_type> & chew, size_t end) {
                return unary_op(chew,end);
        }

        template<unsigned Precedence>
        typename std::enable_if<(Precedence > 0),evaluation>::type
        next_evaluator(chewer<sequence_type> & chew, size_t end) {
                return infix_op<Precedence>(chew,end);
        }


        evaluation apply(infix_operation op, evaluation & lhs, evaluation &rhs);

        template<unsigned Precedence>
        std::pair<expression_parser::infix_operation,bool>
        seek_rightmost_infix(   chewer<sequence_type> & chew,
                                                        size_t end,
                                                        size_t & op_start,
                                                        size_t & op_end);

        void delete_paren(size_t loff, size_t roff) {
                _deletions.resize(_seq.size(), deletion_code::not_deleted);
                _deletions[loff] = deletion_code::paren;
                _deletions[roff] = deletion_code::paren;
                if (ptrdiff_t(roff) > _last_deletion) {
                        _last_deletion = roff;
                }
        }

        void restore_paren(size_t loff, size_t roff) {
                if (_deletions.size() > roff) {
                        _deletions[loff] = deletion_code::not_deleted;
                        _deletions[roff] = deletion_code::not_deleted;
                }
                for(    ;_last_deletion >= 0 &&
                                _deletions[_last_deletion] == deletion_code::not_deleted;
                                --_last_deletion){}
        }

        void restore_paren() {
                for (ptrdiff_t i = _start; i <= _last_deletion; ++i) {
                        if (_deletions[i] == deletion_code::paren) {
                                _deletions[i] = deletion_code::not_deleted;
                        }
                }
        }

        void cut(size_t start, size_t end) {
                _deletions.resize(_seq.size(),deletion_code::not_deleted);
                for (   ;start < end; ++start) {
                        _deletions[start] = deletion_code::non_paren;
                }
                if (ptrdiff_t(end) > _last_deletion) {
                        _last_deletion = end;
                }
                ++_cuts;
        }

        void defer_diagnostic(diagnostic_base & gripe);

        evaluation _eval;
        std::vector<evaluation> _ternary_cond_stack;
        sequence_type & _seq;
        std::vector<deletion_code> _deletions;
        size_t _start;
        size_t _cuts;
        ptrdiff_t _last_deletion;
        reference const * _ref;
};

#endif /* EOF*/