frame.hh

// This file is a part of Aurelia.
// Copyright (C) 2010  Valentin David
// Copyright (C) 2010  University of Bergen
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program 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 General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

#ifndef FRAME_HH
# define FRAME_HH

# include "../memory/pool_allocator.hh"

namespace aurelia {
  namespace llstack {

struct real_frame {
  virtual real_frame* clone() const = 0;
  virtual unsigned hash() const = 0;
  virtual bool operator==(const real_frame& other) const = 0;
  virtual ~real_frame() {
  }
  virtual std::string toString() const = 0;
};

template <typename T>
struct real_frame_helper: public real_frame {
  void* operator new
#ifdef NDEBUG
  (size_t) {
#else
  (size_t t) {
#endif
    assert(t == sizeof(T));
    return chunk_alloc<T>::alloc();
  }

  void operator delete(void *p) {
    chunk_alloc<T>::del((T*) p);
  }

  virtual real_frame* clone() const {
    return new T(*static_cast<const T*>(this));
  }

  virtual bool operator==(const real_frame& other) const {
    const T* rother = dynamic_cast<const T*>(&other);
    if (rother == NULL)
      return false;
    return static_cast<const T*>(this)->opeq_impl(*rother);
  }
};

struct empty_frame: real_frame_helper<empty_frame> {
  virtual unsigned hash() const {
    return 4182910;
  }
  bool opeq_impl(const empty_frame&) const {
    return true;
  }
  virtual std::string toString() const {
    return "empty_frame";
  }
};

struct frame {
private:
  std::shared_ptr<real_frame> rf;
  unsigned _hash;

public:
  std::string toString() const {
    return rf->toString();
  }

  frame(const real_frame& rf): rf(rf.clone()), _hash(rf.hash()) {}
  frame(const frame& other): rf(other.rf), _hash(other._hash) {}
  frame(frame&& other): rf(std::move(other.rf)), _hash(std::move(other._hash)) {
  }

  frame(): rf(), _hash(0) {
  }

  frame& operator=(const frame& other) {
    return *this = frame(other);
  }

  frame& operator=(frame&& other) {
    std::swap(rf, other.rf);
    std::swap(_hash, other._hash);
    return *this;
  }

  struct hash_op {
    unsigned operator()(const frame& a) const {
      return a._hash;
    }
  };

  struct eq {
    unsigned operator()(const frame& a, const frame& b) const {
      return *(a.rf) == *(b.rf);
    }
  };

  unsigned hash() const {
    return _hash;
  }

  bool operator==(const frame& other) const {
    if (&*rf == &*other.rf)
      return true;
    return *rf == *(other.rf);
  }

  template <typename T>
  const T& as() const {
#if NDEBUG
    return *static_cast<const T*>(&*rf);
#else
    const T* ret = dynamic_cast<const T*>(&*rf);
    assert(ret != NULL);
    return *ret;
#endif
  }
};

template <typename T>
struct ret_frame: real_frame_helper<ret_frame<T> > {
  frame parent;
  T t;
  ret_frame(const frame& f, const T& t): parent(f), t(t) {}
  ret_frame(const ret_frame& other): parent(other.parent), t(other.t) {}
  bool opeq_impl(const ret_frame& other) const {
    return (parent == other.parent) && (other.t == t);
  }
  virtual unsigned hash() const {
    unsigned h = parent.hash();
    h = (h << 1) | (h >> 31);
    h ^= t.hash();
    return h;
  }
  virtual std::string toString() const {
    std::stringstream ss;
    ss << t;
    return "ret_frame(" + parent.toString() + "," + ss.str() + ")";
  }
};

struct void_return {
  unsigned hash() const {
    return 201293;
  }
  bool operator==(const void_return&) const {
    return true;
  }
};

template <typename Stream>
Stream& operator<<(Stream& s, const void_return&) {
  s << "Void";
  return s;
}

  }
}

#endif