GCStackRoot.h

Go to the documentation of this file.

/*CXXR $Id: GCStackRoot.h 799 2010-02-19 14:12:57Z 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-10 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_H
#define GCSTACKROOT_H 1

#include "CXXR/RObject.h"

#ifdef __cplusplus

#include <vector>
#include "CXXR/GCNode.hpp"

namespace CXXR {
    class Context;
    class RObject;

    class GCStackRootBase {
    public:
        static void ppsRestoreSize(size_t new_size);

#ifdef DEBUG_PPS
        static size_t ppsSize();
#else
        static size_t ppsSize()
        {
            return s_pps->size();
        }
#endif

#ifndef NDEBUG
        static unsigned int protect(RObject* node);
#else
        static unsigned int protect(RObject* node)
        {
            GCNode::maybeCheckExposed(node);
            unsigned int index = s_pps->size();
            if (node)
                node->incRefCount();
            s_pps->push_back(node);
            return index;
        }
#endif

        static void reprotect(RObject* node, unsigned int index);

        static void unprotect(unsigned int count = 1);

        static void unprotectPtr(RObject* node);

        static void visitRoots(GCNode::const_visitor* v);
    protected:
        GCStackRootBase(const GCNode* node)
            : m_next(s_roots), m_target(node)
        {
            s_roots = this;
            GCNode::maybeCheckExposed(node);
            if (m_target)
                m_target->incRefCount();
        }

        GCStackRootBase(const GCStackRootBase& source)
            : m_next(s_roots), m_target(source.m_target)
        {
            s_roots = this;
            if (m_target)
                m_target->incRefCount();
        }

        ~GCStackRootBase()
        {
#ifndef NDEBUG
            if (this != s_roots)
                seq_error();
#endif
            if (m_target && m_target->decRefCount() == 0)
                m_target->makeMoribund();
            s_roots = m_next;
        }

        GCStackRootBase& operator=(const GCStackRootBase& source)
        {
            if (source.m_target)
                source.m_target->incRefCount();
            if (m_target && m_target->decRefCount() == 0)
                m_target->makeMoribund();
            m_target = source.m_target;
            return *this;
        }

        void redirect(const GCNode* node)
        {
            GCNode::maybeCheckExposed(node);
            if (node)
                node->incRefCount();
            if (m_target && m_target->decRefCount() == 0)
                m_target->makeMoribund();
            m_target = node;
        }

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

        // Ye olde pointer protection stack:
#ifdef NDEBUG
        static std::vector<RObject*>* s_pps;
#else
        static std::vector<std::pair<RObject*, Context*> >* s_pps;
#endif

        static GCStackRootBase* s_roots;

        GCStackRootBase* m_next;
        const GCNode* m_target;

        // Clean up static data at end of run (called by
        // GCNode::SchwarzCtr destructor:
        static void cleanup()
        {
            delete s_pps;
        }

        // Initialize static data (called by GCNode::SchwarzCtr
        // constructor):
        static void initialize();

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

    template <class T = RObject>
    class GCStackRoot : public GCStackRootBase {
    public:
    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::redirect(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()));
        }
    };
}

extern "C" {
#endif /* __cplusplus */

    /* ***** C interface ***** */

    typedef unsigned int PROTECT_INDEX;

#ifndef __cplusplus
    void R_ProtectWithIndex(SEXP node, PROTECT_INDEX *iptr);
#else
    inline void R_ProtectWithIndex(SEXP node, PROTECT_INDEX *iptr)
    {
        *iptr = CXXR::GCStackRootBase::protect(node);
    }
#endif

#ifndef __cplusplus
    void R_Reprotect(SEXP node, PROTECT_INDEX index);
#else
    inline void R_Reprotect(SEXP node, PROTECT_INDEX index)
    {
        CXXR::GCStackRootBase::reprotect(node, index);
    }
#endif

    void Rf_ppsRestoreSize(size_t new_size);
    
    size_t Rf_ppsSize();

#ifndef __cplusplus
    SEXP Rf_protect(SEXP node);
#else
    inline SEXP Rf_protect(SEXP node)
    {
        CXXR::GCStackRootBase::protect(node);
        return node;
    }
#endif

#ifndef __cplusplus
    void Rf_unprotect(int count);
#else
    inline void Rf_unprotect(int count)
    {
        CXXR::GCStackRootBase::unprotect(count);
    }
#endif  

#ifndef __cplusplus
    void Rf_unprotect_ptr(SEXP node);
#else
    inline void Rf_unprotect_ptr(SEXP node)
    {
        CXXR::GCStackRootBase::unprotectPtr(node);
    }
#endif

#ifdef __cplusplus
}  /* extern "C" */
#endif

#endif  // GCSTACKROOT_H