Laboratoire ICAR » Plateforme TXM

/*

 *  R : A Computer Language for Statistical Data Analysis

 *  Copyright (C) 1995, 1996  Robert Gentleman and Ross Ihaka

 *  Copyright (C) 1997--2016 The R Core Team.

 *

 *  This program is free software; you can redistribute it and/or modify

 *  it under the terms of the GNU Lesser 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 Lesser General Public License

 *  along with this program; if not, a copy is available at

 *  https://www.R-project.org/Licenses/

 *

 *  Much of this is from Doug Bates.

 */

/* 

   This is a legacy header and no longer documented.

   Code using it should be converted to use R.h

*/

/* This header includes C headers and so is not safe for inclusion

   from C++: use R.h instead. */

#ifndef R_S_H

#define R_S_H

#ifndef USING_R

# define USING_R

/* is this a good idea? - conflicts with many versions of f2c.h */

# define longint int

#endif

#ifdef __cplusplus

# error S.h can not be used from C++ code: use R.h instead

#endif

#include <stddef.h>

#include <stdlib.h>

#include <stdio.h>

#include <limits.h>

#include <float.h>

#include <math.h>

#include <Rconfig.h>

#include <R_ext/Constants.h>

#include <R_ext/Memory.h>	/* S_alloc */

/* subset of those in Random.h */

extern void seed_in(long *);

extern void seed_out(long *);

extern double unif_rand(void);

extern double norm_rand(void);

/* Macros for S/R Compatibility */

#include <R_ext/RS.h>

/* for PROBLEM ... Calloc, Realloc, Free, Memcpy, F77_xxxx */

/* S4 uses macros equivalent to */

#define Salloc(n,t) (t*)S_alloc(n, sizeof(t))

#define Srealloc(p,n,old,t) (t*)S_realloc(p,n,old,sizeof(t))

/* S's complex is different, and is a define to S_complex now */

typedef struct {

	double re;

	double im;

} S_complex;

#ifdef S_OLD_COMPLEX

# define complex S_complex

#endif

#ifndef NO_CALL_R

/* Not quite full compatibility: beware! */

/* void	call_R(char*, long, void**, char**, long*, char**, long, char**);*/

#define call_S call_R

#endif

#endif /* !R_S_H */

 *  Copyright (C) 1999-2016 The R Core Team.

 *  This program is free software; you can redistribute it and/or modify

   'these are not kept up to date and are not recommended for new projects.'

   As from R 3.3.0 they have been adjusted to work when R_NO_REMAP is defined.

#ifdef USE_RINTERNALS

// This is not documented to be supported, and may not be in future

# define IS_LOGICAL(x)		isLogical(x)

# define IS_INTEGER(x)		isInteger(x)

# define IS_NUMERIC(x)		isReal(x)

# define IS_CHARACTER(x)	isString(x)

# define IS_COMPLEX(x)		isComplex(x)

#else

#endif

/* Use of VECTOR_PTR will fail unless USE_RINTERNALS is in use

   This is probably unused.

*/

/* Use of VECTOR_PTR will fail unless USE_RINTERNALS is in use

#define s_object                SEXPREC

 *  Copyright (C) 2000-2016 The R Core Team.

 *  This program is free software; you can redistribute it and/or modify

#ifndef NO_C_HEADERS

# ifndef __STDC_WANT_IEC_60559_FUNCS_EXT__

#  define __STDC_WANT_IEC_60559_FUNCS_EXT__ 1

# endif

/* The C++ headers in Solaris Studio are strict C++98, and many 

   packages fail because of not using e.g. std::round 

   or using C99 functions such as snprintf. 

# ifdef __SUNPRO_CC

#  define DO_NOT_USE_CXX_HEADERS

# endif

# if defined(__cplusplus) && !defined(DO_NOT_USE_CXX_HEADERS)

#  include <cstdlib>

#  include <cstdio>

#  include <climits>

#  include <cmath>

# else

#  include <stdlib.h> /* Not used by R itself, but widely assumed in packages */

#  include <stdio.h>  /* Used by ca 200 packages, but not in R itself */

#  include <limits.h> /* for INT_MAX */

#  include <math.h>

# endif 

# if defined(__sun)

#  undef CS

#  undef DO

#  undef DS

#  undef ES

#  undef FS

#  undef GS

#  undef SO

#  undef SS

# endif

#else

#warning "use of NO_C_HEADERS is deprecated"

#include <R_ext/Constants.h>  /* PI, DOUBLE_EPS, etc */

/* for PROBLEM ... Calloc, Realloc, Free, Memcpy, F77_xxxx */

typedef double Sfloat;

typedef int Sint;

#define SINT_MAX INT_MAX

#define SINT_MIN INT_MIN

 *  Copyright (C) 1999-2016   The R Core Team.

 *  This program is free software; you can redistribute it and/or modify

// Support for NO_C_HEADERS added in R 3.3.0

# ifndef NO_C_HEADERS

#  include <cstdio>

#  include <climits>

#  include <cstddef>

# else

#warning "use of NO_C_HEADERS is deprecated"

# endif

# ifndef NO_C_HEADERS

#  include <stdio.h>

#  include <limits.h> /* for INT_MAX */

#  include <stddef.h> /* for ptrdiff_t */

# else

#warning "use of NO_C_HEADERS is deprecated"

# endif

    typedef struct { R_xlen_t lv_length, lv_truelength; } R_long_vec_hdr_t;

# define R_LONG_VEC_TOKEN -1

 *  1)	The SEXPREC struct below has 'SEXPTYPE type : 5'

// ======================= USE_RINTERNALS section

#ifdef USE_RINTERNALS

/* This is intended for use only within R itself.

 * It defines internal structures that are otherwise only accessible

 * via SEXP, and macros to replace many (but not all) of accessor functions

 * (which are always defined).

 */

/* Flags */

struct sxpinfo_struct {

    SEXPTYPE type      :  TYPE_BITS;/* ==> (FUNSXP == 99) %% 2^5 == 3 == CLOSXP

			     * -> warning: `type' is narrower than values

			     *              of its type

			     * when SEXPTYPE was an enum */

    unsigned int obj   :  1;

    unsigned int named :  2;

    unsigned int gp    : 16;

    unsigned int mark  :  1;

    unsigned int debug :  1;

    unsigned int trace :  1;  /* functions and memory tracing */

    unsigned int spare :  1;  /* currently unused */

    unsigned int gcgen :  1;  /* old generation number */

    unsigned int gccls :  3;  /* node class */

}; /*		    Tot: 32 */

struct vecsxp_struct {

    R_len_t	length;

    R_len_t	truelength;

};

struct primsxp_struct {

    int offset;

};

struct symsxp_struct {

    struct SEXPREC *pname;

    struct SEXPREC *value;

    struct SEXPREC *internal;

};

struct listsxp_struct {

    struct SEXPREC *carval;

    struct SEXPREC *cdrval;

    struct SEXPREC *tagval;

};

struct envsxp_struct {

    struct SEXPREC *frame;

    struct SEXPREC *enclos;

    struct SEXPREC *hashtab;

};

struct closxp_struct {

    struct SEXPREC *formals;

    struct SEXPREC *body;

    struct SEXPREC *env;

};

struct promsxp_struct {

    struct SEXPREC *value;

    struct SEXPREC *expr;

    struct SEXPREC *env;

};

/* Every node must start with a set of sxpinfo flags and an attribute

   field. Under the generational collector these are followed by the

   fields used to maintain the collector's linked list structures. */

/* Define SWITH_TO_REFCNT to use reference counting instead of the

   'NAMED' mechanism. This uses the R-devel binary layout. The two

   'named' field bits are used for the REFCNT, so REFCNTMAX is 3. */

//#define SWITCH_TO_REFCNT

#define REFCNTMAX (4 - 1)

#define SEXPREC_HEADER \

    struct sxpinfo_struct sxpinfo; \

    struct SEXPREC *attrib; \

    struct SEXPREC *gengc_next_node, *gengc_prev_node

/* The standard node structure consists of a header followed by the

   node data. */

typedef struct SEXPREC {

    SEXPREC_HEADER;

    union {

	struct primsxp_struct primsxp;

	struct symsxp_struct symsxp;

	struct listsxp_struct listsxp;

	struct envsxp_struct envsxp;

	struct closxp_struct closxp;

	struct promsxp_struct promsxp;

    } u;

} SEXPREC, *SEXP;

/* The generational collector uses a reduced version of SEXPREC as a

   header in vector nodes.  The layout MUST be kept consistent with

   the SEXPREC definition.  The standard SEXPREC takes up 7 words on

   most hardware; this reduced version should take up only 6 words.

   In addition to slightly reducing memory use, this can lead to more

   favorable data alignment on 32-bit architectures like the Intel

   Pentium III where odd word alignment of doubles is allowed but much

   less efficient than even word alignment. */

typedef struct VECTOR_SEXPREC {

    SEXPREC_HEADER;

    struct vecsxp_struct vecsxp;

} VECTOR_SEXPREC, *VECSEXP;

typedef union { VECTOR_SEXPREC s; double align; } SEXPREC_ALIGN;

/* General Cons Cell Attributes */

#define ATTRIB(x)	((x)->attrib)

#define OBJECT(x)	((x)->sxpinfo.obj)

#define MARK(x)		((x)->sxpinfo.mark)

#define TYPEOF(x)	((x)->sxpinfo.type)

#define NAMED(x)	((x)->sxpinfo.named)

#define RTRACE(x)	((x)->sxpinfo.trace)

#define LEVELS(x)	((x)->sxpinfo.gp)

#define SET_OBJECT(x,v)	(((x)->sxpinfo.obj)=(v))

#define SET_TYPEOF(x,v)	(((x)->sxpinfo.type)=(v))

#define SET_NAMED(x,v)	(((x)->sxpinfo.named)=(v))

#define SET_RTRACE(x,v)	(((x)->sxpinfo.trace)=(v))

#define SETLEVELS(x,v)	(((x)->sxpinfo.gp)=((unsigned short)v))

#if defined(COMPUTE_REFCNT_VALUES)

# define REFCNT(x) ((x)->sxpinfo.named)

# define TRACKREFS(x) (TYPEOF(x) == CLOSXP ? TRUE : ! (x)->sxpinfo.spare)

#else

# define REFCNT(x) 0

# define TRACKREFS(x) FALSE

#ifdef SWITCH_TO_REFCNT

# undef NAMED

# undef SET_NAMED

# define NAMED(x) REFCNT(x)

# define SET_NAMED(x, v) do {} while (0)

#endif

/* S4 object bit, set by R_do_new_object for all new() calls */

#define S4_OBJECT_MASK ((unsigned short)(1<<4))

#define IS_S4_OBJECT(x) ((x)->sxpinfo.gp & S4_OBJECT_MASK)

#define SET_S4_OBJECT(x) (((x)->sxpinfo.gp) |= S4_OBJECT_MASK)

#define UNSET_S4_OBJECT(x) (((x)->sxpinfo.gp) &= ~S4_OBJECT_MASK)

/* Vector Access Macros */

#ifdef LONG_VECTOR_SUPPORT

    R_len_t NORET R_BadLongVector(SEXP, const char *, int);

# define IS_LONG_VEC(x) (SHORT_VEC_LENGTH(x) == R_LONG_VEC_TOKEN)

# define SHORT_VEC_LENGTH(x) (((VECSEXP) (x))->vecsxp.length)

# define SHORT_VEC_TRUELENGTH(x) (((VECSEXP) (x))->vecsxp.truelength)

# define LONG_VEC_LENGTH(x) ((R_long_vec_hdr_t *) (x))[-1].lv_length

# define LONG_VEC_TRUELENGTH(x) ((R_long_vec_hdr_t *) (x))[-1].lv_truelength

# define XLENGTH(x) (IS_LONG_VEC(x) ? LONG_VEC_LENGTH(x) : SHORT_VEC_LENGTH(x))

# define XTRUELENGTH(x)	(IS_LONG_VEC(x) ? LONG_VEC_TRUELENGTH(x) : SHORT_VEC_TRUELENGTH(x))

# define LENGTH(x) (IS_LONG_VEC(x) ? R_BadLongVector(x, __FILE__, __LINE__) : SHORT_VEC_LENGTH(x))

# define TRUELENGTH(x) (IS_LONG_VEC(x) ? R_BadLongVector(x, __FILE__, __LINE__) : SHORT_VEC_TRUELENGTH(x))

# define SET_SHORT_VEC_LENGTH(x,v) (SHORT_VEC_LENGTH(x) = (v))

# define SET_SHORT_VEC_TRUELENGTH(x,v) (SHORT_VEC_TRUELENGTH(x) = (v))

# define SET_LONG_VEC_LENGTH(x,v) (LONG_VEC_LENGTH(x) = (v))

# define SET_LONG_VEC_TRUELENGTH(x,v) (LONG_VEC_TRUELENGTH(x) = (v))

# define SETLENGTH(x,v) do { \

      SEXP sl__x__ = (x); \

      R_xlen_t sl__v__ = (v); \

      if (IS_LONG_VEC(sl__x__)) \

	  SET_LONG_VEC_LENGTH(sl__x__,  sl__v__); \

      else SET_SHORT_VEC_LENGTH(sl__x__, (R_len_t) sl__v__); \

  } while (0)

# define SET_TRUELENGTH(x,v) do { \

      SEXP sl__x__ = (x); \

      R_xlen_t sl__v__ = (v); \

      if (IS_LONG_VEC(sl__x__)) \

	  SET_LONG_VEC_TRUELENGTH(sl__x__, sl__v__); \

      else SET_SHORT_VEC_TRUELENGTH(sl__x__, (R_len_t) sl__v__); \

  } while (0)

# define IS_SCALAR(x, type) (TYPEOF(x) == (type) && SHORT_VEC_LENGTH(x) == 1)

#else

# define SHORT_VEC_LENGTH(x) (((VECSEXP) (x))->vecsxp.length)

# define LENGTH(x)	(((VECSEXP) (x))->vecsxp.length)

# define TRUELENGTH(x)	(((VECSEXP) (x))->vecsxp.truelength)

# define XLENGTH(x) LENGTH(x)

# define XTRUELENGTH(x) TRUELENGTH(x)

# define SETLENGTH(x,v)		((((VECSEXP) (x))->vecsxp.length)=(v))

# define SET_TRUELENGTH(x,v)	((((VECSEXP) (x))->vecsxp.truelength)=(v))

# define SET_SHORT_VEC_LENGTH SETLENGTH

# define SET_SHORT_VEC_TRUELENGTH SET_TRUELENGTH

# define IS_LONG_VEC(x) 0

# define IS_SCALAR(x, type) (TYPEOF(x) == (type) && LENGTH(x) == 1)

#endif

/* Under the generational allocator the data for vector nodes comes

   immediately after the node structure, so the data address is a

   known offset from the node SEXP. */

#define DATAPTR(x)	(((SEXPREC_ALIGN *) (x)) + 1)

#define CHAR(x)		((const char *) DATAPTR(x))

#define LOGICAL(x)	((int *) DATAPTR(x))

#define INTEGER(x)	((int *) DATAPTR(x))

#define RAW(x)		((Rbyte *) DATAPTR(x))

#define COMPLEX(x)	((Rcomplex *) DATAPTR(x))

#define REAL(x)		((double *) DATAPTR(x))

#define STRING_ELT(x,i)	((SEXP *) DATAPTR(x))[i]

#define VECTOR_ELT(x,i)	((SEXP *) DATAPTR(x))[i]

#define STRING_PTR(x)	((SEXP *) DATAPTR(x))

#define VECTOR_PTR(x)	((SEXP *) DATAPTR(x))

/* List Access Macros */

/* These also work for ... objects */

#define LISTVAL(x)	((x)->u.listsxp)

#define TAG(e)		((e)->u.listsxp.tagval)

#define CAR(e)		((e)->u.listsxp.carval)

#define CDR(e)		((e)->u.listsxp.cdrval)

#define CAAR(e)		CAR(CAR(e))

#define CDAR(e)		CDR(CAR(e))

#define CADR(e)		CAR(CDR(e))

#define CDDR(e)		CDR(CDR(e))

#define CDDDR(e)	CDR(CDR(CDR(e)))

#define CADDR(e)	CAR(CDR(CDR(e)))

#define CADDDR(e)	CAR(CDR(CDR(CDR(e))))

#define CAD4R(e)	CAR(CDR(CDR(CDR(CDR(e)))))

#define MISSING_MASK	15 /* reserve 4 bits--only 2 uses now */

#define MISSING(x)	((x)->sxpinfo.gp & MISSING_MASK)/* for closure calls */

#define SET_MISSING(x,v) do { \

  SEXP __x__ = (x); \

  int __v__ = (v); \

  int __other_flags__ = __x__->sxpinfo.gp & ~MISSING_MASK; \

  __x__->sxpinfo.gp = __other_flags__ | __v__; \

} while (0)

/* Closure Access Macros */

#define FORMALS(x)	((x)->u.closxp.formals)

#define BODY(x)		((x)->u.closxp.body)

#define CLOENV(x)	((x)->u.closxp.env)

#define RDEBUG(x)	((x)->sxpinfo.debug)

#define SET_RDEBUG(x,v)	(((x)->sxpinfo.debug)=(v))

#define RSTEP(x)	((x)->sxpinfo.spare)

#define SET_RSTEP(x,v)	(((x)->sxpinfo.spare)=(v))

/* Symbol Access Macros */

#define PRINTNAME(x)	((x)->u.symsxp.pname)

#define SYMVALUE(x)	((x)->u.symsxp.value)

#define INTERNAL(x)	((x)->u.symsxp.internal)

#define DDVAL_MASK	1

#define DDVAL(x)	((x)->sxpinfo.gp & DDVAL_MASK) /* for ..1, ..2 etc */

#define SET_DDVAL_BIT(x) (((x)->sxpinfo.gp) |= DDVAL_MASK)

#define UNSET_DDVAL_BIT(x) (((x)->sxpinfo.gp) &= ~DDVAL_MASK)

#define SET_DDVAL(x,v) ((v) ? SET_DDVAL_BIT(x) : UNSET_DDVAL_BIT(x)) /* for ..1, ..2 etc */

/* Environment Access Macros */

#define FRAME(x)	((x)->u.envsxp.frame)

#define ENCLOS(x)	((x)->u.envsxp.enclos)

#define HASHTAB(x)	((x)->u.envsxp.hashtab)

#define ENVFLAGS(x)	((x)->sxpinfo.gp)	/* for environments */

#define SET_ENVFLAGS(x,v)	(((x)->sxpinfo.gp)=(v))

#else /* not USE_RINTERNALS */

// ======================= not USE_RINTERNALS section

typedef struct SEXPREC *SEXP;

#define CHAR(x)		R_CHAR(x)

/* Various tests with macro versions in the second USE_RINTERNALS section */

# define IS_SCALAR(x, type) (TYPEOF(x) == (type) && XLENGTH(x) == 1)

#endif /* USE_RINTERNALS */

#define NAMEDMAX 2

#define INCREMENT_NAMED(x) do {				\

#if defined(COMPUTE_REFCNT_VALUES)

# define SET_REFCNT(x,v) (REFCNT(x) = (v))

# if defined(EXTRA_REFCNT_FIELDS)

#  define SET_TRACKREFS(x,v) (TRACKREFS(x) = (v))

# else

#  define SET_TRACKREFS(x,v) ((x)->sxpinfo.spare = ! (v))

# endif

# define DECREMENT_REFCNT(x) do {					\

	SEXP drc__x__ = (x);						\

	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\

	    SET_REFCNT(drc__x__, REFCNT(drc__x__) - 1);			\

# define INCREMENT_REFCNT(x) do {			      \

	SEXP irc__x__ = (x);				      \

	if (REFCNT(irc__x__) < REFCNTMAX)		      \

	    SET_REFCNT(irc__x__, REFCNT(irc__x__) + 1);	      \

    } while (0)

#else

# define SET_REFCNT(x,v) do {} while(0)

# define SET_TRACKREFS(x,v) do {} while(0)

# define DECREMENT_REFCNT(x) do {} while(0)

# define INCREMENT_REFCNT(x) do {} while(0)

#define ENABLE_REFCNT(x) SET_TRACKREFS(x, TRUE)

#define DISABLE_REFCNT(x) SET_TRACKREFS(x, FALSE)

# define MARK_NOT_MUTABLE(x) SET_REFCNT(x, REFCNTMAX)

# define MARK_NOT_MUTABLE(x) SET_NAMED(x, NAMEDMAX)

/* Complex assignment support */

/* temporary definition that will need to be refined to distinguish

   getter from setter calls */

#define IS_GETTER_CALL(call) (CADR(call) == R_TmpvalSymbol)

   definitions in the USE_RINTERNALS section.

void (SET_OBJECT)(SEXP x, int v);

void (SET_TYPEOF)(SEXP x, int v);

void (SET_NAMED)(SEXP x, int v);

void (SET_S4_OBJECT)(SEXP x);

void (UNSET_S4_OBJECT)(SEXP x);

int  (TRUELENGTH)(SEXP x);

void (SETLENGTH)(SEXP x, int v);

void (SET_TRUELENGTH)(SEXP x, int v);

R_xlen_t  (XLENGTH)(SEXP x);

R_xlen_t  (XTRUELENGTH)(SEXP x);

int  (SETLEVELS)(SEXP x, int v);

SEXP (STRING_ELT)(SEXP x, R_xlen_t i);

SEXP * NORET (VECTOR_PTR)(SEXP x);

SEXP (CAR)(SEXP e);

void (SET_MISSING)(SEXP x, int v);

SEXP CONS_NR(SEXP a, SEXP b);

void (SET_DDVAL)(SEXP x, int v);

void SET_PRINTNAME(SEXP x, SEXP v);

void SET_SYMVALUE(SEXP x, SEXP v);

void SET_INTERNAL(SEXP x, SEXP v);

void (SET_ENVFLAGS)(SEXP x, int v);

void SET_FRAME(SEXP x, SEXP v);

void SET_ENCLOS(SEXP x, SEXP v);

void SET_HASHTAB(SEXP x, SEXP v);

/* First five have macro versions in Defn.h */

void (SET_PRSEEN)(SEXP x, int v);

void SET_PRENV(SEXP x, SEXP v);

void SET_PRVALUE(SEXP x, SEXP v);

void SET_PRCODE(SEXP x, SEXP v);

void SET_PRSEEN(SEXP x, int v);

/* Hashing Functions */

/* There are macro versions in Defn.h */

int  (HASHASH)(SEXP x);

int  (HASHVALUE)(SEXP x);

void (SET_HASHASH)(SEXP x, int v);

void (SET_HASHVALUE)(SEXP x, int v);

#define EXTPTR_PTR(x)	CAR(x)

#define EXTPTR_PROT(x)	CDR(x)

#define EXTPTR_TAG(x)	TAG(x)

/* Bytecode access macros */

#define BCODE_CODE(x)	CAR(x)

#define BCODE_CONSTS(x) CDR(x)

#define BCODE_EXPR(x)	TAG(x)

#define isByteCode(x)	(TYPEOF(x)==BCODESXP)

LibExtern SEXP	R_BlankScalarString;	    /* "" as a STRSXP */

void Rf_addMissingVarsToNewEnv(SEXP, SEXP);

SEXP Rf_allocFormalsList2(SEXP sym1, SEXP sym2);

SEXP Rf_allocFormalsList3(SEXP sym1, SEXP sym2, SEXP sym3);

SEXP Rf_allocFormalsList4(SEXP sym1, SEXP sym2, SEXP sym3, SEXP sym4);

SEXP Rf_allocFormalsList5(SEXP sym1, SEXP sym2, SEXP sym3, SEXP sym4, SEXP sym5);

SEXP Rf_allocFormalsList6(SEXP sym1, SEXP sym2, SEXP sym3, SEXP sym4, SEXP sym5, SEXP sym6);

SEXP Rf_arraySubscript(int, SEXP, SEXP, SEXP (*)(SEXP,SEXP),

                       SEXP (*)(SEXP, int), SEXP);

int Rf_countContexts(int, int);

SEXP Rf_CreateTag(SEXP);

SEXP Rf_DropDims(SEXP);

Rboolean R_envHasNoSpecialSymbols(SEXP);

SEXP Rf_installDDVAL(int i);

SEXP Rf_installS3Signature(const char *, const char *);

Rboolean Rf_isFree(SEXP);

Rboolean Rf_isUnmodifiedSpecSym(SEXP sym, SEXP env);

SEXP Rf_matchE(SEXP, SEXP, int, SEXP);

Rboolean Rf_pmatch(SEXP, SEXP, Rboolean);

Rboolean Rf_psmatch(const char *, const char *, Rboolean);

void Rf_readS3VarsFromFrame(SEXP, SEXP*, SEXP*, SEXP*, SEXP*, SEXP*, SEXP*);

void Rf_setSVector(SEXP*, int, SEXP);

SEXP Rf_stringSuffix(SEXP, int);

const char * Rf_translateChar0(SEXP);

void NORET R_signal_protect_error(void);

void NORET R_signal_unprotect_error(void);

void NORET R_signal_reprotect_error(PROTECT_INDEX i);

const char *R_curErrorBuf();

Rboolean R_cycle_detected(SEXP s, SEXP child);

				/* return(.) NOT reached : for -Wall */

#define error_return(msg)	{ Rf_error(msg);	   return R_NilValue; }

#define errorcall_return(cl,msg){ Rf_errorcall(cl, msg);   return R_NilValue; }

void R_initialize_bcode(void);

SEXP R_bcEncode(SEXP);

SEXP R_bcDecode(SEXP);

#define PREXPR(e) R_PromiseExpr(e)

#define BODY_EXPR(e) R_ClosureExpr(e)

void R_RestoreHashCount(SEXP rho);

#if defined(__GNUC__) && __GNUC__ >= 3

void Rf_errorcall(SEXP, const char *, ...) __attribute__((noreturn));

#else

void Rf_errorcall(SEXP, const char *, ...);

#endif

   1 = !NUM_EQ

   2 = !SINGLE_NA

   4 = !ATTR_AS_SET

   8 = !IGNORE_BYTECODE

  16 = !IGNORE_ENV

  Default from R's default: 15

#define installChar		Rf_installChar

#if defined(CALLED_FROM_DEFN_H) && !defined(__MAIN__) && (defined(COMPILING_R) || ( __GNUC__ && !defined(__INTEL_COMPILER) ))

#include "Rinlinedfuns.h"

#else

   These are the inlinable functions that are provided in Rinlinedfuns.h

   It is *essential* that these do not appear in any other header file,

   with or without the Rf_ prefix.

SEXP R_FixupRHS(SEXP x, SEXP y);

#ifdef USE_RINTERNALS

/* Test macros with function versions above */

#undef isNull

#define isNull(s)	(TYPEOF(s) == NILSXP)

#undef isSymbol

#define isSymbol(s)	(TYPEOF(s) == SYMSXP)

#undef isLogical

#define isLogical(s)	(TYPEOF(s) == LGLSXP)

#undef isReal

#define isReal(s)	(TYPEOF(s) == REALSXP)

#undef isComplex

#define isComplex(s)	(TYPEOF(s) == CPLXSXP)

#undef isExpression

#define isExpression(s) (TYPEOF(s) == EXPRSXP)

#undef isEnvironment

#define isEnvironment(s) (TYPEOF(s) == ENVSXP)

#undef isString

#define isString(s)	(TYPEOF(s) == STRSXP)

#undef isObject

#define isObject(s)	(OBJECT(s) != 0)

/* macro version of R_CheckStack */

#define R_CheckStack() do {						\

	void NORET R_SignalCStackOverflow(intptr_t);				\

	int dummy;							\

	intptr_t usage = R_CStackDir * (R_CStackStart - (uintptr_t)&dummy); \

	if(R_CStackLimit != -1 && usage > ((intptr_t) R_CStackLimit))	\

	    R_SignalCStackOverflow(usage);				\

    } while (FALSE)

#endif

 *  Copyright (C) 1998--2016  The R Core Team.