expression.h

Go to the documentation of this file.

// -*- mode: C++; c-file-style: "stroustrup"; c-basic-offset: 4; indent-tabs-mode: nil; -*-

/* libutap - Uppaal Timed Automata Parser.
   Copyright (C) 2011-2018 Aalborg University.
   Copyright (C) 2002-2006 Uppsala University and Aalborg University.

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public License
   as published by the Free Software Foundation; either version 2.1 of
   the License, or (at your option) any later version.

   This library is distributed in the hope that it will be useful, but
   WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with this library; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
   USA
*/

#ifndef UTAP_EXPRESSION_HH
#define UTAP_EXPRESSION_HH

#include "utap/common.h"
#include "utap/symbols.h"
#include "utap/position.h"

#include <vector>
#include <set>
#include <map>
#include <memory>

namespace UTAP
{
    class expression_t
    {
    private:
        expression_t(Constants::kind_t, const position_t &);
    public:
        expression_t(){};

        expression_t(const expression_t &);

        expression_t& operator=(const expression_t &);

        ~expression_t();

        bool usesFP() const;
        bool usesClock() const;
        bool isDynamic() const;
        bool hasDynamicSub() const;
        expression_t clone() const;

        expression_t deeperClone() const;

        expression_t deeperClone(symbol_t from, symbol_t to) const;

        expression_t deeperClone(frame_t frame, frame_t select = frame_t()) const;

        Constants::kind_t getKind() const;

        size_t getSize() const;

        const position_t &getPosition() const;

        type_t getType() const;

        void setType(type_t);

        int32_t getValue() const;

        int32_t getIndex() const;

        double getDoubleValue() const;

        bool empty() const;

        Constants::synchronisation_t getSync() const;

        std::string toString(bool old = false) const;

        expression_t &operator[](uint32_t);

        const expression_t operator[](uint32_t) const;

        expression_t &get(uint32_t);

        const expression_t &get(uint32_t) const;

        bool equal(const expression_t &) const;

        symbol_t getSymbol();

        void getSymbols(std::set<symbol_t> &symbols) const;

        const symbol_t getSymbol() const;

        bool isReferenceTo(const std::set<symbol_t> &) const;

        bool changesVariable(const std::set<symbol_t> &) const;

        bool changesAnyVariable() const;

        bool dependsOn(const std::set<symbol_t> &) const;

        void collectPossibleWrites(std::set<symbol_t> &) const;
        void collectPossibleReads(std::set<symbol_t> &, bool collectRandom = false) const;

         bool operator < (const expression_t) const;

         bool operator == (const expression_t) const;

        expression_t subst(symbol_t, expression_t) const;

        static int getPrecedence(Constants::kind_t);

        static expression_t createConstant(int32_t, position_t = position_t());

        static expression_t createDouble(double, position_t = position_t());

        static expression_t createIdentifier(symbol_t, position_t = position_t());

        static expression_t createUnary(Constants::kind_t, expression_t,
                                        position_t = position_t(),
                                        type_t = type_t());

        static expression_t createBinary(Constants::kind_t,
                                         expression_t, expression_t,
                                         position_t = position_t(),
                                         type_t = type_t());

        static expression_t createTernary(Constants::kind_t, expression_t,
                                          expression_t, expression_t,
                                          position_t = position_t(),
                                          type_t = type_t());

        static expression_t createNary(Constants::kind_t,
                                       const std::vector<expression_t> &,
                                       position_t = position_t(),
                                       type_t = type_t());

        static expression_t createDot(expression_t, int32_t = -1,
                                      position_t = position_t(),
                                      type_t = type_t());

        static expression_t createSync(expression_t,
                                       Constants::synchronisation_t,
                                       position_t = position_t());

        static expression_t createDeadlock(position_t = position_t());

        static expression_t createExit(position_t = position_t());

        // true if empty or equal to 1.
        bool isTrue() const;

    private:
        struct expression_data;
        std::shared_ptr<expression_data> data;
        int getPrecedence() const;
        void toString(bool, char *&str, char *&end, int &size) const;
        void appendBoundType(char *&str, char*&end, int &size, expression_t e) const;
    };
}

std::ostream &operator<< (std::ostream &o, const UTAP::expression_t &e);

#endif