symbols.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) 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_SYMBOLS_HH
#define UTAP_SYMBOLS_HH

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

#include <cinttypes>
#include <exception>

namespace UTAP
{
    class frame_t;
    class expression_t;
    
    class NoParentException : public std::exception {};

    class range_t 
    {
    public:
        int lower, upper;

        range_t();

        range_t(int);

        range_t(int,int);

        range_t(const std::pair<int,int> &);

        range_t intersect(const range_t &) const;

        range_t join(const range_t &) const;

        bool contains(const range_t &) const;

        bool contains(int32_t) const;

        bool operator == (const range_t &) const;

        bool operator != (const range_t &) const;

        range_t operator| (const range_t &) const;

        range_t operator& (const range_t &) const;

        bool isEmpty() const;

        uint32_t size() const;
    };

    class symbol_t
    {
    private:
        struct symbol_data;
        symbol_data *data;
    protected:
        friend class frame_t;
        symbol_t(void *frame, type_t type, const std::string& name, void *user);
    public:
        symbol_t() : data(nullptr) {}

        symbol_t(const symbol_t &);

        ~symbol_t();

        const symbol_t &operator = (const symbol_t &);

        bool operator == (const symbol_t &) const;

        bool operator != (const symbol_t &) const;

        bool operator < (const symbol_t &) const;
        
        frame_t getFrame();

        type_t getType() const;

        void setType(type_t);
        
        void *getData();

        const void *getData() const;

        std::string getName() const;

        void setName(const std::string&);

        void setData(void *);
    };

    class frame_t
    {
    private:
        struct frame_data;
        frame_data *data;
    protected:
        friend class symbol_t;
        frame_t(void *);
    public:
        frame_t();

        frame_t(const frame_t &);

        ~frame_t();

        const frame_t &operator = (const frame_t &);

        bool operator == (const frame_t &) const;

        bool operator != (const frame_t &) const;
        
        uint32_t getSize() const;

        symbol_t getSymbol(int32_t);

        int32_t getIndexOf(const std::string& name) const;

        int32_t getIndexOf(symbol_t) const;

        symbol_t operator[] (int32_t);

        const symbol_t operator[] (int32_t) const;

        symbol_t addSymbol(const std::string& name, type_t, void *user = NULL);

        void add(symbol_t);

        void add(frame_t);

        void moveTo(frame_t);

        void remove(symbol_t s);

        bool resolve(const std::string& name, symbol_t &symbol);

        frame_t getParent(); // throw (NoParentException);

        bool hasParent() const;

        static frame_t createFrame();

        static frame_t createFrame(const frame_t &parent);

        std::string toString();

        bool empty();
    };
}

std::ostream &operator << (std::ostream &o, UTAP::symbol_t t);
std::ostream &operator << (std::ostream &o, UTAP::frame_t t);

#endif