Evaluator.h

Go to the documentation of this file.

/*CXXR $Id: Evaluator.h 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 EVALUATOR_H
#define EVALUATOR_H

#include "R_ext/Boolean.h"
#include "CXXR/Environment.h"
#include "CXXR/PairList.h"

// Move this to ByteCode.hpp in due course:
#define BYTECODE

#ifdef __cplusplus
#include <utility>

extern "C" {
#endif

    extern Rboolean R_Visible;

    extern int R_interrupts_pending;

    extern Rboolean R_interrupts_suspended;

    int R_isMissing(SEXP symbol, SEXP rho);

#ifdef __cplusplus
} // extern "C"

namespace CXXR {
    class RObject;
    class Expression;

    class Evaluator {
    public:
        class Context;

        Evaluator()
            : m_next(s_current), m_innermost_context(0)
        {
            s_current = this;
        }

        ~Evaluator()
        {
            s_current = m_next;
        }

        static Evaluator* current()
        {
            return s_current;
        }

        static unsigned int depth()
        {
            return s_depth;
        }

        static unsigned int depthLimit()
        {
            return s_depth_limit;
        }

        static void enableExtraDepth(bool on)
        {
            s_depth_threshold = s_depth_limit + (on ? 500 : 0);
        }

        static void enableProfiling(bool on)
        {
            s_profiling = on;
        }

        static void enableResultPrinting(bool on)
        {
            R_Visible = Rboolean(on);
        }

#ifdef __GNUC__
        __attribute__((hot,fastcall))
#endif
        static RObject* evaluate(RObject* object, Environment* env);

        Context* innermostContext() const
        {
            return m_innermost_context;
        }

        static bool profiling()
        {
            return s_profiling;
        }

        static bool resultPrinted()
        {
            return R_Visible;
        }

        static void setDepth(unsigned int depth)
        {
            s_depth = depth;
        }

        static void setDepthLimit(int depth);
   private:
        friend class Context;  // Unnecessary in C++ 0x

        static unsigned int s_depth;  // Current depth of expression evaluation 
        static unsigned int s_depth_threshold;  // An error will be
                              // reported if s_depth exceeds this
                              // value.  s_depth_threshold is normally
                              // equal to s_depth_limit, but may be
                              // temporarily increased above s_depth_limit
                              // to allow error reporting.
        static unsigned int s_depth_limit;  // The value (controlled
                              // by the 'expressions' R option) to
                              // which s_depth_threshold is set except
                              // during error reporting.
        static unsigned int s_countdown;  // Number of calls of
                              // Evaluator::evaluate() to go before a
                              // check is made for user interrupts.
        static unsigned int s_countdown_start;  // Value from which
                              // s_countdown starts counting down
        static Evaluator* s_current;  // The current (innermost) Evaluator
        static bool s_profiling;  // True iff profiling enabled

        Evaluator* m_next;  // Next Evaluator down the stack
        Context* m_innermost_context;  // Innermost Context belonging
                   // to this Evaluator
    };

    inline RObject* evaluate(RObject* object, Environment* env)
    {
        return Evaluator::evaluate(object, env);
    }
}

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

#ifndef __cplusplus
    SEXP Rf_eval(SEXP e, SEXP rho);
#else
    inline SEXP Rf_eval(SEXP e, SEXP rho)
    {
        using namespace CXXR;
        Environment* env = 0;
        if (e)
            env = SEXP_downcast<Environment*>(rho);     
        return evaluate(e, env);
    }
#endif
 
#ifdef __cplusplus
}
#endif

#endif /* EVALUATOR_H */