GCStackRoot.hpp

Go to the documentation of this file.

/*CXXR $Id: GCStackRoot.hpp 1397 2013-08-16 18:25:59Z arr $
 *CXXR
 *CXXR This file is part of CXXR, a project to refactor the R interpreter
 *CXXR into C++.  It may consist in whole or in part of program code and
 *CXXR documentation taken from the R project itself, incorporated into
 *CXXR CXXR (and possibly MODIFIED) under the terms of the GNU General Public
 *CXXR Licence.
 *CXXR 
 *CXXR CXXR is Copyright (C) 2008-13 Andrew R. Runnalls, subject to such other
 *CXXR copyrights and copyright restrictions as may be stated below.
 *CXXR 
 *CXXR CXXR is not part of the R project, and bugs and other issues should
 *CXXR not be reported via r-bugs or other R project channels; instead refer
 *CXXR to the CXXR website.
 *CXXR */

/*
 *  R : A Computer Language for Statistical Data Analysis
 *
 *  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 2.1 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 Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, a copy is available at
 *  http://www.r-project.org/Licenses/
 */

#ifndef GCSTACKROOT_HPP
#define GCSTACKROOT_HPP 1

#include "CXXR/GCNode.hpp"

namespace CXXR {
    class RObject;

    class GCStackRootBase {
    public:
        static void visitRoots(GCNode::const_visitor* v);
    protected:
        GCStackRootBase(const GCNode* node)
            : m_next(s_roots), m_target(node), m_protecting(false)
        {
            s_roots = this;
            GCNode::maybeCheckExposed(node);
        }

        GCStackRootBase(const GCStackRootBase& source)
            : m_next(s_roots), m_target(source.m_target), m_protecting(false)
        {
            s_roots = this;
        }

        ~GCStackRootBase()
        {
#ifndef NDEBUG
            if (this != s_roots)
                seq_error();
#endif
            if (m_protecting)
                destruct_aux();
            s_roots = m_next;
        }

        GCStackRootBase& operator=(const GCStackRootBase& source)
        {
            retarget(source.m_target);
            return *this;
        }

        void retarget(const GCNode* node)
        {
            GCNode::maybeCheckExposed(node);
            if (m_protecting)
                retarget_aux(node);
            m_target = node;
        }

        const GCNode* ptr() const
        {
            return m_target;
        }
    private:
        friend class GCNode;

        static GCStackRootBase* s_roots;

        GCStackRootBase* m_next;
        const GCNode* m_target;
        bool m_protecting;  // If this is set, it signifies that this
          // GCStackRootBase object will have incremented the
          // reference count of its target (if any).  In the interests
          // of efficiency, initially m_protecting is false; it is set
          // by call to protectAll().
          //
          // m_protecting && m_next implies m_next->m_protecting .

        // Helper function for destructor:
#ifdef __GNUC__
        __attribute__((hot, fastcall))
#endif
        void destruct_aux();

        // Put all GCStackRootBase objects into the protecting state:
#ifdef __GNUC__
        __attribute__((hot, fastcall))
#endif
        static void protectAll();

        // Helper function for retarget():
#ifdef __GNUC__
        __attribute__((hot, fastcall))
#endif
            void retarget_aux(const GCNode* node);

        // Report out-of-sequence destructor call and abort program.
        // (We can't use an exception here because it's called from a
        // destructor.)
#ifdef __GNUC__
        __attribute__((cold))
#endif
        static void seq_error();
    };

    template <class T = RObject>
    class GCStackRoot : public GCStackRootBase {
    public:
        typedef T type;

        explicit GCStackRoot(T* node = 0)
            : GCStackRootBase(node) {}

        GCStackRoot(const GCStackRoot& source) : GCStackRootBase(source) {}

        GCStackRoot& operator=(const GCStackRoot& source)
        {
            GCStackRootBase::operator=(source);
            return *this;
        }

        GCStackRoot& operator=(T* node)
        {
            GCStackRootBase::retarget(node);
            return *this;
        }

        T* operator->() const
        {
            return get();
        }

        T& operator*() const
        {
            return *get();
        }

        operator T*() const
        {
            return get();
        }

        T* get() const
        {
            return static_cast<T*>(const_cast<GCNode*>(ptr()));
        }
    };
}  // namespace CXXR

#endif  // GCSTACKROOT_HPP