NodeStack.hpp

Go to the documentation of this file.

/*CXXR $Id: NodeStack.hpp 1348 2013-02-25 17:49:03Z 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 NODESTACK_H
#define NODESTACK_H 1

#include <vector>
#include "CXXR/RObject.h"

namespace CXXR {
    class NodeStack {
    public:
        class ElementProxy {
        public:
            ElementProxy& operator=(const ElementProxy& rhs)
            {
                m_stack->retarget((*rhs.m_stack)[rhs.m_index], m_index);
                return *this;
            }

            ElementProxy& operator=(RObject* node)
            {
                m_stack->retarget(node, m_index);
                return *this;
            }

            operator RObject* const() const
            {
                return m_stack->m_vector[m_index];
            }
        private:
            friend class NodeStack;

            NodeStack* m_stack;
            unsigned int m_index;

            ElementProxy(NodeStack* stack, unsigned int index)
                : m_stack(stack), m_index(index)
            {}
        };

        class Scope {
        public:
            Scope(NodeStack* stack)
                : m_nodestack(stack),
#ifndef NDEBUG
                  m_next_scope(stack->m_innermost_scope),
#endif
                  m_saved_size(m_nodestack->size())
            {
#ifndef NDEBUG
                stack->m_innermost_scope = this;
#endif
            }

            ~Scope()
            {
#ifndef NDEBUG
                if (this != m_nodestack->m_innermost_scope)
                    nestingError();
#endif
                m_nodestack->resize(m_saved_size);
#ifndef NDEBUG
                m_nodestack->m_innermost_scope = m_next_scope;
#endif
            }
        private:
            friend class NodeStack;

            NodeStack* m_nodestack;
#ifndef NDEBUG
            Scope* m_next_scope;
#endif
            size_t m_saved_size;

            size_t startSize() const
            {
                return m_saved_size;
            }

            static void nestingError();
        };

        NodeStack(size_t initial_capacity);

        ~NodeStack()
        {
            resize(0);
        }

        ElementProxy operator[](unsigned int index)
        {
            return ElementProxy(this, index);
        }

        RObject* const operator[](unsigned int index) const
        {
            return m_vector[index];
        }

        void eraseTopmost(RObject* node);

        ElementProxy fromEnd(unsigned int count)
        {
            return operator[](size() - count);
        }

#ifndef NDEBUG
        void pop(unsigned int count = 1);
#else
        void pop(unsigned int count = 1)
        {
            resize(size() - count);
        }
#endif

        void protectAll();

        unsigned int push(RObject* node)
        {
            GCNode::maybeCheckExposed(node);
            unsigned int index = m_vector.size();
            m_vector.push_back(node);
            return index;
        }

#ifndef NDEBUG
        void retarget(RObject* node, unsigned int index);
#else
        void retarget(RObject* node, unsigned int index)
        {
            GCNode::maybeCheckExposed(node);
            if (index < m_protected_count)
                retarget_aux(m_vector[index], node);
            m_vector[index] = node;
        }
#endif

        void resize(size_t new_size)
        {
            if (new_size >= m_protected_count)
                m_vector.resize(new_size, 0);
            else resize_aux(new_size);
        }

        size_t size() const
        {
            return m_vector.size();
        }

        RObject* topnpop() {
            RObject* ans = operator[](size() - 1);
            pop();
            return ans;
        }

        void visitRoots(GCNode::const_visitor* v);
    private:
        std::vector<RObject*> m_vector;
        size_t m_protected_count;  // The nodes (if any) pointed to
          // (*m_vector)[0] through (*m_vector)[m_protected_count - 1]
          // will have had their reference counts increased by this
          // class.  Stack entries beyond this (if any) will not yet
          // have had this protection applied.
 
#ifndef NDEBUG
        Scope* m_innermost_scope;
#endif

        // Helper function for retarget(), handling the case where
        // 'index' is within the protected range:
#ifdef __GNUC__
        __attribute__((hot,fastcall))
#endif
        static void retarget_aux(RObject* oldnode, RObject* newnode);

        // Helper function for trim(), handling the case where the trim
        // cuts down into protected nodes:
#ifdef __GNUC__
        __attribute__((hot,fastcall))
#endif
        void resize_aux(size_t new_size);
    };
}  // namespace CXXR

#endif  // NODESTACK_H