/* * R : A Computer Language for Statistical Data Analysis * Copyright (C) 1999--2019 The R Core Team. * Copyright (C) 1995, 1996 Robert Gentleman and Ross Ihaka * * This header file 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 file is part of R. R is distributed under the terms of the * GNU General Public License, either Version 2, June 1991 or Version 3, * June 2007. See doc/COPYRIGHTS for details of the copyright status of R. * * 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/ */ /* This file is installed and available to packages, but only a small part of the contents is within the API. See chapter 6 of 'Writing R Extensions'. */ #ifndef R_INTERNALS_H_ #define R_INTERNALS_H_ #ifdef __cplusplus # include # include # include extern "C" { #else # include # include /* for INT_MAX */ # include /* for ptrdiff_t, which is required by C99 */ #endif #include #include #include #include // includes NORET macro #include #include #include #include // for DL_FUNC #include typedef unsigned char Rbyte; /* type for length of (standard, not long) vectors etc */ typedef int R_len_t; #define R_LEN_T_MAX INT_MAX /* both config.h and Rconfig.h set SIZEOF_SIZE_T, but Rconfig.h is skipped if config.h has already been included. */ #ifndef R_CONFIG_H # include #endif #if ( SIZEOF_SIZE_T > 4 ) # define LONG_VECTOR_SUPPORT #endif #ifdef LONG_VECTOR_SUPPORT typedef ptrdiff_t R_xlen_t; # define R_XLEN_T_MAX 4503599627370496 # define R_SHORT_LEN_MAX 2147483647 #else typedef int R_xlen_t; # define R_XLEN_T_MAX R_LEN_T_MAX #endif #ifndef TESTING_WRITE_BARRIER # define INLINE_PROTECT #endif /* Fundamental Data Types: These are largely Lisp * influenced structures, with the exception of LGLSXP, * INTSXP, REALSXP, CPLXSXP and STRSXP which are the * element types for S-like data objects. * * --> TypeTable[] in ../main/util.c for typeof() */ /* UUID identifying the internals version -- packages using compiled code should be re-installed when this changes */ #define R_INTERNALS_UUID "2fdf6c18-697a-4ba7-b8ef-11c0d92f1327" /* These exact numeric values are seldom used, but they are, e.g., in * ../main/subassign.c, and they are serialized. */ #ifndef enum_SEXPTYPE /* NOT YET using enum: * 1) The SEXPREC struct below has 'SEXPTYPE type : 5' * (making FUNSXP and CLOSXP equivalent in there), * giving (-Wall only ?) warnings all over the place * 2) Many switch(type) { case ... } statements need a final `default:' * added in order to avoid warnings like [e.g. l.170 of ../main/util.c] * "enumeration value `FUNSXP' not handled in switch" */ typedef unsigned int SEXPTYPE; #define NILSXP 0 /* nil = NULL */ #define SYMSXP 1 /* symbols */ #define LISTSXP 2 /* lists of dotted pairs */ #define CLOSXP 3 /* closures */ #define ENVSXP 4 /* environments */ #define PROMSXP 5 /* promises: [un]evaluated closure arguments */ #define LANGSXP 6 /* language constructs (special lists) */ #define SPECIALSXP 7 /* special forms */ #define BUILTINSXP 8 /* builtin non-special forms */ #define CHARSXP 9 /* "scalar" string type (internal only)*/ #define LGLSXP 10 /* logical vectors */ /* 11 and 12 were factors and ordered factors in the 1990s */ #define INTSXP 13 /* integer vectors */ #define REALSXP 14 /* real variables */ #define CPLXSXP 15 /* complex variables */ #define STRSXP 16 /* string vectors */ #define DOTSXP 17 /* dot-dot-dot object */ #define ANYSXP 18 /* make "any" args work. Used in specifying types for symbol registration to mean anything is okay */ #define VECSXP 19 /* generic vectors */ #define EXPRSXP 20 /* expressions vectors */ #define BCODESXP 21 /* byte code */ #define EXTPTRSXP 22 /* external pointer */ #define WEAKREFSXP 23 /* weak reference */ #define RAWSXP 24 /* raw bytes */ #define S4SXP 25 /* S4, non-vector */ /* used for detecting PROTECT issues in memory.c */ #define NEWSXP 30 /* fresh node created in new page */ #define FREESXP 31 /* node released by GC */ #define FUNSXP 99 /* Closure or Builtin or Special */ #else /* NOT YET */ /*------ enum_SEXPTYPE ----- */ typedef enum { NILSXP = 0, /* nil = NULL */ SYMSXP = 1, /* symbols */ LISTSXP = 2, /* lists of dotted pairs */ CLOSXP = 3, /* closures */ ENVSXP = 4, /* environments */ PROMSXP = 5, /* promises: [un]evaluated closure arguments */ LANGSXP = 6, /* language constructs (special lists) */ SPECIALSXP = 7, /* special forms */ BUILTINSXP = 8, /* builtin non-special forms */ CHARSXP = 9, /* "scalar" string type (internal only)*/ LGLSXP = 10, /* logical vectors */ INTSXP = 13, /* integer vectors */ REALSXP = 14, /* real variables */ CPLXSXP = 15, /* complex variables */ STRSXP = 16, /* string vectors */ DOTSXP = 17, /* dot-dot-dot object */ ANYSXP = 18, /* make "any" args work */ VECSXP = 19, /* generic vectors */ EXPRSXP = 20, /* expressions vectors */ BCODESXP = 21, /* byte code */ EXTPTRSXP = 22, /* external pointer */ WEAKREFSXP = 23, /* weak reference */ RAWSXP = 24, /* raw bytes */ S4SXP = 25, /* S4 non-vector */ NEWSXP = 30, /* fresh node creaed in new page */ FREESXP = 31, /* node released by GC */ FUNSXP = 99 /* Closure or Builtin */ } SEXPTYPE; #endif /* These are also used with the write barrier on, in attrib.c and util.c */ #define TYPE_BITS 5 #define MAX_NUM_SEXPTYPE (1< (FUNSXP == 99) %% 2^5 == 3 == CLOSXP * -> warning: `type' is narrower than values * of its type * when SEXPTYPE was an enum */ unsigned int scalar: 1; unsigned int obj : 1; unsigned int alt : 1; unsigned int gp : 16; unsigned int mark : 1; unsigned int debug : 1; unsigned int trace : 1; /* functions and memory tracing */ unsigned int spare : 1; /* used on closures and when REFCNT is defined */ unsigned int gcgen : 1; /* old generation number */ unsigned int gccls : 3; /* node class */ unsigned int named : NAMED_BITS; unsigned int extra : 32 - NAMED_BITS; /* used for immediate bindings */ }; /* Tot: 64 */ struct vecsxp_struct { R_xlen_t length; R_xlen_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. */ #ifdef SWITCH_TO_REFCNT # define REFCNTMAX ((1 << NAMED_BITS) - 1) #endif #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; /* 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 and the reduced version takes 6 words on most 64-bit systems. On most 32-bit systems, SEXPREC takes 8 words and the reduced version 7 words. */ 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)) #define ALTREP(x) ((x)->sxpinfo.alt) #define SETALTREP(x, v) (((x)->sxpinfo.alt) = (v)) #define SETSCALAR(x, v) (((x)->sxpinfo.scalar) = (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 #endif #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); \ } while (0) # 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) #endif #define ENABLE_REFCNT(x) SET_TRACKREFS(x, TRUE) #define DISABLE_REFCNT(x) SET_TRACKREFS(x, FALSE) /* To make complex assignments a bit safer, in particular with reference counting, a bit is set on the LHS binding cell or symbol at the beginning of the complex assignment process and unset at the end. - When the assignment bit is set and a new value is assigned to the binding then the reference count on the old value is not decremented. This prevents moving a single binding from the LHS variable of the assignment to another variable during the assignment process. - If a complex assignment tries to update a binding that already has its bit set then, the value of the binding is shallow-duplicated before proceeding. This ensures that the structure involved in the original complex assignment will not be mutated by further R level assignments during the original assignment process. For now, no attempt is made to unset the bit if the end of an assignment is not reached because of a jump. This may result in some unnecessary duplications. This could be prevented by maintaining a stack of pending assignments to resent the bits on jump, but that seems like overkill. It might also be useful to use this bit to communicate to functions when they are used in a getter/setter context. The bit used is bit 11 in the 'gp' field. An alternative would be to take a bit from the 'extra' field. LT */ #define ASSIGNMENT_PENDING_MASK (1 << 11) #define ASSIGNMENT_PENDING(x) ((x)->sxpinfo.gp & ASSIGNMENT_PENDING_MASK) #define SET_ASSIGNMENT_PENDING(x, v) do { \ if (v) (((x)->sxpinfo.gp) |= ASSIGNMENT_PENDING_MASK); \ else (((x)->sxpinfo.gp) &= ~ASSIGNMENT_PENDING_MASK); \ } while (0) /* The same bit can be used to mark calls used in complex assignments to allow replacement functions to determine when they are being called in an assignment context and can modify an object with one refrence */ #define MARK_ASSIGNMENT_CALL(call) SET_ASSIGNMENT_PENDING(call, TRUE) #define IS_ASSIGNMENT_CALL(call) ASSIGNMENT_PENDING(call) #ifdef SWITCH_TO_REFCNT # undef NAMED # undef SET_NAMED # define NAMED(x) REFCNT(x) /* no definition for SET_NAMED; any calls will use the one in memory.c */ # define ENSURE_NAMEDMAX(v) do { } while (0) # define ENSURE_NAMED(v) do { } while (0) #else # define ENSURE_NAMEDMAX(v) do { \ SEXP __enm_v__ = (v); \ if (NAMED(__enm_v__) < NAMEDMAX) \ SET_NAMED( __enm_v__, NAMEDMAX); \ } while (0) # define ENSURE_NAMED(v) do { if (NAMED(v) == 0) SET_NAMED(v, 1); } while (0) #endif #ifdef SWITCH_TO_REFCNT # define SETTER_CLEAR_NAMED(x) do { } while (0) # define RAISE_NAMED(x, n) do { } while (0) #else # define SETTER_CLEAR_NAMED(x) do { \ SEXP __x__ = (x); \ if (NAMED(__x__) == 1) SET_NAMED(__x__, 0); \ } while (0) # define RAISE_NAMED(x, n) do { \ SEXP __x__ = (x); \ int __n__ = (n); \ if (NAMED(__x__) < __n__) \ SET_NAMED(__x__, __n__); \ } 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) /* JIT optimization support */ #define NOJIT_MASK ((unsigned short)(1<<5)) #define NOJIT(x) ((x)->sxpinfo.gp & NOJIT_MASK) #define SET_NOJIT(x) (((x)->sxpinfo.gp) |= NOJIT_MASK) #define MAYBEJIT_MASK ((unsigned short)(1<<6)) #define MAYBEJIT(x) ((x)->sxpinfo.gp & MAYBEJIT_MASK) #define SET_MAYBEJIT(x) (((x)->sxpinfo.gp) |= MAYBEJIT_MASK) #define UNSET_MAYBEJIT(x) (((x)->sxpinfo.gp) &= ~MAYBEJIT_MASK) /* Growable vector support */ #define GROWABLE_MASK ((unsigned short)(1<<5)) #define GROWABLE_BIT_SET(x) ((x)->sxpinfo.gp & GROWABLE_MASK) #define SET_GROWABLE_BIT(x) (((x)->sxpinfo.gp) |= GROWABLE_MASK) #define IS_GROWABLE(x) (GROWABLE_BIT_SET(x) && XLENGTH(x) < XTRUELENGTH(x)) /* Vector Access Macros */ #ifdef LONG_VECTOR_SUPPORT # define IS_LONG_VEC(x) (XLENGTH(x) > R_SHORT_LEN_MAX) #else # define IS_LONG_VEC(x) 0 #endif #define STDVEC_LENGTH(x) (((VECSEXP) (x))->vecsxp.length) #define STDVEC_TRUELENGTH(x) (((VECSEXP) (x))->vecsxp.truelength) #define SET_STDVEC_TRUELENGTH(x, v) (STDVEC_TRUELENGTH(x)=(v)) #define SET_TRUELENGTH(x,v) do { \ SEXP sl__x__ = (x); \ R_xlen_t sl__v__ = (v); \ if (ALTREP(x)) error("can't set ALTREP truelength"); \ SET_STDVEC_TRUELENGTH(sl__x__, sl__v__); \ } while (0) #define IS_SCALAR(x, t) (((x)->sxpinfo.type == (t)) && (x)->sxpinfo.scalar) #define LENGTH(x) LENGTH_EX(x, __FILE__, __LINE__) #define TRUELENGTH(x) XTRUELENGTH(x) /* defined as a macro since fastmatch packages tests for it */ #define XLENGTH(x) XLENGTH_EX(x) /* THIS ABSOLUTELY MUST NOT BE USED IN PACKAGES !!! */ #define SET_STDVEC_LENGTH(x,v) do { \ SEXP __x__ = (x); \ R_xlen_t __v__ = (v); \ STDVEC_LENGTH(__x__) = __v__; \ SETSCALAR(__x__, __v__ == 1 ? 1 : 0); \ } while (0) /* 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 STDVEC_DATAPTR(x) ((void *) (((SEXPREC_ALIGN *) (x)) + 1)) #define CHAR(x) ((const char *) STDVEC_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 VECTOR_ELT(x,i) ((SEXP *) DATAPTR(x))[i] #define STRING_PTR(x) ((SEXP *) DATAPTR(x)) #define VECTOR_PTR(x) ((SEXP *) DATAPTR(x)) #define LOGICAL_RO(x) ((const int *) DATAPTR_RO(x)) #define INTEGER_RO(x) ((const int *) DATAPTR_RO(x)) #define RAW_RO(x) ((const Rbyte *) DATAPTR_RO(x)) #define COMPLEX_RO(x) ((const Rcomplex *) DATAPTR_RO(x)) #define REAL_RO(x) ((const double *) DATAPTR_RO(x)) #define STRING_PTR_RO(x)((const SEXP *) DATAPTR_RO(x)) /* List Access Macros */ /* These also work for ... objects */ #define LISTVAL(x) ((x)->u.listsxp) #define TAG(e) ((e)->u.listsxp.tagval) #define CAR0(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) #define BNDCELL_TAG(e) ((e)->sxpinfo.extra) #define SET_BNDCELL_TAG(e, v) ((e)->sxpinfo.extra = (v)) #if ( SIZEOF_SIZE_T < SIZEOF_DOUBLE ) # define BOXED_BINDING_CELLS 1 #else # define BOXED_BINDING_CELLS 0 #endif #if BOXED_BINDING_CELLS /* Use allocated scalars to hold immediate binding values. A little less efficient but does not change memory layout or use. These allocated scalars must not escape their bindings. */ #define BNDCELL_DVAL(v) SCALAR_DVAL(CAR0(v)) #define BNDCELL_IVAL(v) SCALAR_IVAL(CAR0(v)) #define BNDCELL_LVAL(v) SCALAR_LVAL(CAR0(v)) #define SET_BNDCELL_DVAL(cell, dval) SET_SCALAR_DVAL(CAR0(cell), dval) #define SET_BNDCELL_IVAL(cell, ival) SET_SCALAR_IVAL(CAR0(cell), ival) #define SET_BNDCELL_LVAL(cell, lval) SET_SCALAR_LVAL(CAR0(cell), lval) #define INIT_BNDCELL(cell, type) do { \ SEXP val = allocVector(type, 1); \ SETCAR(cell, val); \ INCREMENT_NAMED(val); \ SET_BNDCELL_TAG(cell, type); \ SET_MISSING(cell, 0); \ } while (0) #else /* Use a union in the CAR field to represent an SEXP or an immediate value. More efficient, but changes the menory layout on 32 bit platforms since the size of the union is larger than the size of a pointer. The layout should not change on 64 bit platforms. */ typedef union { SEXP sxpval; double dval; int ival; } R_bndval_t; #define BNDCELL_DVAL(v) ((R_bndval_t *) &CAR0(v))->dval #define BNDCELL_IVAL(v) ((R_bndval_t *) &CAR0(v))->ival #define BNDCELL_LVAL(v) ((R_bndval_t *) &CAR0(v))->ival #define SET_BNDCELL_DVAL(cell, dval) (BNDCELL_DVAL(cell) = (dval)) #define SET_BNDCELL_IVAL(cell, ival) (BNDCELL_IVAL(cell) = (ival)) #define SET_BNDCELL_LVAL(cell, lval) (BNDCELL_LVAL(cell) = (lval)) #define INIT_BNDCELL(cell, type) do { \ if (BNDCELL_TAG(cell) == 0) \ SETCAR(cell, R_NilValue); \ SET_BNDCELL_TAG(cell, type); \ SET_MISSING(cell, 0); \ } while (0) #endif /* 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 #define CHAR(x) R_CHAR(x) const char *(R_CHAR)(SEXP x); /* Various tests with macro versions in the second USE_RINTERNALS section */ Rboolean (Rf_isNull)(SEXP s); Rboolean (Rf_isSymbol)(SEXP s); Rboolean (Rf_isLogical)(SEXP s); Rboolean (Rf_isReal)(SEXP s); Rboolean (Rf_isComplex)(SEXP s); Rboolean (Rf_isExpression)(SEXP s); Rboolean (Rf_isEnvironment)(SEXP s); Rboolean (Rf_isString)(SEXP s); Rboolean (Rf_isObject)(SEXP s); #endif /* USE_RINTERNALS */ #define IS_SIMPLE_SCALAR(x, type) \ (IS_SCALAR(x, type) && ATTRIB(x) == R_NilValue) #define SIMPLE_SCALAR_TYPE(x) \ (((x)->sxpinfo.scalar && ATTRIB(x) == R_NilValue) ? TYPEOF(x) : 0) #define NAMEDMAX 7 #ifdef SWITCH_TO_REFCNT # define INCREMENT_NAMED(x) do { } while (0) # define DECREMENT_NAMED(x) do { } while (0) #else # define INCREMENT_NAMED(x) do { \ SEXP __x__ = (x); \ if (NAMED(__x__) != NAMEDMAX) \ SET_NAMED(__x__, NAMED(__x__) + 1); \ } while (0) # define DECREMENT_NAMED(x) do { \ SEXP __x__ = (x); \ int __n__ = NAMED(__x__); \ if (__n__ > 0 && __n__ < NAMEDMAX) \ SET_NAMED(__x__, __n__ - 1); \ } while (0) #endif #define INCREMENT_LINKS(x) do { \ SEXP il__x__ = (x); \ INCREMENT_NAMED(il__x__); \ INCREMENT_REFCNT(il__x__); \ } while (0) #define DECREMENT_LINKS(x) do { \ SEXP dl__x__ = (x); \ DECREMENT_NAMED(dl__x__); \ DECREMENT_REFCNT(dl__x__); \ } while (0) /* Macros for some common idioms. */ #ifdef SWITCH_TO_REFCNT # define MAYBE_SHARED(x) (REFCNT(x) > 1) # define NO_REFERENCES(x) (REFCNT(x) == 0) # ifdef USE_RINTERNALS # define MARK_NOT_MUTABLE(x) SET_REFCNT(x, REFCNTMAX) # endif #else # define MAYBE_SHARED(x) (NAMED(x) > 1) # define NO_REFERENCES(x) (NAMED(x) == 0) # ifdef USE_RINTERNALS # define MARK_NOT_MUTABLE(x) SET_NAMED(x, NAMEDMAX) # endif #endif #define MAYBE_REFERENCED(x) (! NO_REFERENCES(x)) #define NOT_SHARED(x) (! MAYBE_SHARED(x)) /* ALTREP sorting support */ enum {SORTED_DECR_NA_1ST = -2, SORTED_DECR = -1, UNKNOWN_SORTEDNESS = INT_MIN, /*INT_MIN is NA_INTEGER! */ SORTED_INCR = 1, SORTED_INCR_NA_1ST = 2, KNOWN_UNSORTED = 0}; #define KNOWN_SORTED(sorted) (sorted == SORTED_DECR || \ sorted == SORTED_INCR || \ sorted == SORTED_DECR_NA_1ST || \ sorted == SORTED_INCR_NA_1ST) #define KNOWN_NA_1ST(sorted) (sorted == SORTED_INCR_NA_1ST || \ sorted == SORTED_DECR_NA_1ST) #define KNOWN_INCR(sorted) (sorted == SORTED_INCR || \ sorted == SORTED_INCR_NA_1ST) #define KNOWN_DECR(sorted) (sorted == SORTED_DECR || \ sorted == SORTED_DECR_NA_1ST) /* 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) /* Accessor functions. Many are declared using () to avoid the macro definitions in the USE_RINTERNALS section. The function STRING_ELT is used as an argument to arrayAssign even if the macro version is in use. */ /* General Cons Cell Attributes */ SEXP (ATTRIB)(SEXP x); int (OBJECT)(SEXP x); int (MARK)(SEXP x); int (TYPEOF)(SEXP x); int (NAMED)(SEXP x); int (REFCNT)(SEXP x); int (TRACKREFS)(SEXP x); void (SET_OBJECT)(SEXP x, int v); void (SET_TYPEOF)(SEXP x, int v); void (SET_NAMED)(SEXP x, int v); void SET_ATTRIB(SEXP x, SEXP v); void DUPLICATE_ATTRIB(SEXP to, SEXP from); void SHALLOW_DUPLICATE_ATTRIB(SEXP to, SEXP from); void (ENSURE_NAMEDMAX)(SEXP x); void (ENSURE_NAMED)(SEXP x); void (SETTER_CLEAR_NAMED)(SEXP x); void (RAISE_NAMED)(SEXP x, int n); void (DECREMENT_REFCNT)(SEXP x); void (INCREMENT_REFCNT)(SEXP x); void (DISABLE_REFCNT)(SEXP x); void (ENABLE_REFCNT)(SEXP x); void (MARK_NOT_MUTABLE)(SEXP x); int (ASSIGNMENT_PENDING)(SEXP x); void (SET_ASSIGNMENT_PENDING)(SEXP x, int v); int (IS_ASSIGNMENT_CALL)(SEXP x); void (MARK_ASSIGNMENT_CALL)(SEXP x); /* S4 object testing */ int (IS_S4_OBJECT)(SEXP x); void (SET_S4_OBJECT)(SEXP x); void (UNSET_S4_OBJECT)(SEXP x); /* JIT optimization support */ int (NOJIT)(SEXP x); int (MAYBEJIT)(SEXP x); void (SET_NOJIT)(SEXP x); void (SET_MAYBEJIT)(SEXP x); void (UNSET_MAYBEJIT)(SEXP x); /* Growable vector support */ int (IS_GROWABLE)(SEXP x); void (SET_GROWABLE_BIT)(SEXP x); /* Vector Access Functions */ int (LENGTH)(SEXP x); R_xlen_t (XLENGTH)(SEXP x); R_xlen_t (TRUELENGTH)(SEXP x); void (SETLENGTH)(SEXP x, R_xlen_t v); void (SET_TRUELENGTH)(SEXP x, R_xlen_t v); int (IS_LONG_VEC)(SEXP x); int (LEVELS)(SEXP x); int (SETLEVELS)(SEXP x, int v); #ifdef TESTING_WRITE_BARRIER R_xlen_t (STDVEC_LENGTH)(SEXP); R_xlen_t (STDVEC_TRUELENGTH)(SEXP); void (SETALTREP)(SEXP, int); #endif int *(LOGICAL)(SEXP x); int *(INTEGER)(SEXP x); Rbyte *(RAW)(SEXP x); double *(REAL)(SEXP x); Rcomplex *(COMPLEX)(SEXP x); const int *(LOGICAL_RO)(SEXP x); const int *(INTEGER_RO)(SEXP x); const Rbyte *(RAW_RO)(SEXP x); const double *(REAL_RO)(SEXP x); const Rcomplex *(COMPLEX_RO)(SEXP x); //SEXP (STRING_ELT)(SEXP x, R_xlen_t i); SEXP (VECTOR_ELT)(SEXP x, R_xlen_t i); void SET_STRING_ELT(SEXP x, R_xlen_t i, SEXP v); SEXP SET_VECTOR_ELT(SEXP x, R_xlen_t i, SEXP v); SEXP *(STRING_PTR)(SEXP x); const SEXP *(STRING_PTR_RO)(SEXP x); SEXP * NORET (VECTOR_PTR)(SEXP x); /* ALTREP support */ void *(STDVEC_DATAPTR)(SEXP x); int (IS_SCALAR)(SEXP x, int type); int (ALTREP)(SEXP x); SEXP ALTREP_DUPLICATE_EX(SEXP x, Rboolean deep); SEXP ALTREP_COERCE(SEXP x, int type); Rboolean ALTREP_INSPECT(SEXP, int, int, int, void (*)(SEXP, int, int, int)); SEXP ALTREP_SERIALIZED_CLASS(SEXP); SEXP ALTREP_SERIALIZED_STATE(SEXP); SEXP ALTREP_UNSERIALIZE_EX(SEXP, SEXP, SEXP, int, int); R_xlen_t ALTREP_LENGTH(SEXP x); R_xlen_t ALTREP_TRUELENGTH(SEXP x); void *ALTVEC_DATAPTR(SEXP x); const void *ALTVEC_DATAPTR_RO(SEXP x); const void *ALTVEC_DATAPTR_OR_NULL(SEXP x); SEXP ALTVEC_EXTRACT_SUBSET(SEXP x, SEXP indx, SEXP call); /* data access */ int ALTINTEGER_ELT(SEXP x, R_xlen_t i); void ALTINTEGER_SET_ELT(SEXP x, R_xlen_t i, int v); int ALTLOGICAL_ELT(SEXP x, R_xlen_t i); void ALTLOGICAL_SET_ELT(SEXP x, R_xlen_t i, int v); double ALTREAL_ELT(SEXP x, R_xlen_t i); void ALTREAL_SET_ELT(SEXP x, R_xlen_t i, double v); SEXP ALTSTRING_ELT(SEXP, R_xlen_t); void ALTSTRING_SET_ELT(SEXP, R_xlen_t, SEXP); Rcomplex ALTCOMPLEX_ELT(SEXP x, R_xlen_t i); void ALTCOMPLEX_SET_ELT(SEXP x, R_xlen_t i, Rcomplex v); Rbyte ALTRAW_ELT(SEXP x, R_xlen_t i); void ALTRAW_SET_ELT(SEXP x, R_xlen_t i, Rbyte v); R_xlen_t INTEGER_GET_REGION(SEXP sx, R_xlen_t i, R_xlen_t n, int *buf); R_xlen_t REAL_GET_REGION(SEXP sx, R_xlen_t i, R_xlen_t n, double *buf); R_xlen_t LOGICAL_GET_REGION(SEXP sx, R_xlen_t i, R_xlen_t n, int *buf); R_xlen_t COMPLEX_GET_REGION(SEXP sx, R_xlen_t i, R_xlen_t n, Rcomplex *buf); R_xlen_t RAW_GET_REGION(SEXP sx, R_xlen_t i, R_xlen_t n, Rbyte *buf); /* metadata access */ int INTEGER_IS_SORTED(SEXP x); int INTEGER_NO_NA(SEXP x); int REAL_IS_SORTED(SEXP x); int REAL_NO_NA(SEXP x); int LOGICAL_IS_SORTED(SEXP x); int LOGICAL_NO_NA(SEXP x); int STRING_IS_SORTED(SEXP x); int STRING_NO_NA(SEXP x); /* invoking ALTREP class methods */ SEXP ALTINTEGER_SUM(SEXP x, Rboolean narm); SEXP ALTINTEGER_MIN(SEXP x, Rboolean narm); SEXP ALTINTEGER_MAX(SEXP x, Rboolean narm); SEXP INTEGER_MATCH(SEXP, SEXP, int, SEXP, SEXP, Rboolean); SEXP INTEGER_IS_NA(SEXP x); SEXP ALTREAL_SUM(SEXP x, Rboolean narm); SEXP ALTREAL_MIN(SEXP x, Rboolean narm); SEXP ALTREAL_MAX(SEXP x, Rboolean narm); SEXP REAL_MATCH(SEXP, SEXP, int, SEXP, SEXP, Rboolean); SEXP REAL_IS_NA(SEXP x); SEXP ALTLOGICAL_SUM(SEXP x, Rboolean narm); /* constructors for internal ALTREP classes */ SEXP R_compact_intrange(R_xlen_t n1, R_xlen_t n2); SEXP R_deferred_coerceToString(SEXP v, SEXP info); SEXP R_virtrep_vec(SEXP, SEXP); SEXP R_tryWrap(SEXP); SEXP R_tryUnwrap(SEXP); #ifdef LONG_VECTOR_SUPPORT R_len_t NORET R_BadLongVector(SEXP, const char *, int); #endif /* checking for mis-use of multi-threading */ #ifdef TESTING_WRITE_BARRIER # define THREADCHECK #endif #ifdef THREADCHECK void R_check_thread(const char *s); # define R_CHECK_THREAD R_check_thread(__func__) #else # define R_CHECK_THREAD do {} while (0) #endif /* List Access Functions */ /* These also work for ... objects */ #define CONS(a, b) cons((a), (b)) /* data lists */ #define LCONS(a, b) lcons((a), (b)) /* language lists */ int (BNDCELL_TAG)(SEXP e); void (SET_BNDCELL_TAG)(SEXP e, int v); double (BNDCELL_DVAL)(SEXP cell); int (BNDCELL_IVAL)(SEXP cell); int (BNDCELL_LVAL)(SEXP cell); void (SET_BNDCELL_DVAL)(SEXP cell, double v); void (SET_BNDCELL_IVAL)(SEXP cell, int v); void (SET_BNDCELL_LVAL)(SEXP cell, int v); void (INIT_BNDCELL)(SEXP cell, int type); void SET_BNDCELL(SEXP cell, SEXP val); SEXP (TAG)(SEXP e); SEXP (CAR0)(SEXP e); SEXP (CDR)(SEXP e); SEXP (CAAR)(SEXP e); SEXP (CDAR)(SEXP e); SEXP (CADR)(SEXP e); SEXP (CDDR)(SEXP e); SEXP (CDDDR)(SEXP e); SEXP (CADDR)(SEXP e); SEXP (CADDDR)(SEXP e); SEXP (CAD4R)(SEXP e); int (MISSING)(SEXP x); void (SET_MISSING)(SEXP x, int v); void SET_TAG(SEXP x, SEXP y); SEXP SETCAR(SEXP x, SEXP y); SEXP SETCDR(SEXP x, SEXP y); SEXP SETCADR(SEXP x, SEXP y); SEXP SETCADDR(SEXP x, SEXP y); SEXP SETCADDDR(SEXP x, SEXP y); SEXP SETCAD4R(SEXP e, SEXP y); SEXP CONS_NR(SEXP a, SEXP b); /* Closure Access Functions */ SEXP (FORMALS)(SEXP x); SEXP (BODY)(SEXP x); SEXP (CLOENV)(SEXP x); int (RDEBUG)(SEXP x); int (RSTEP)(SEXP x); int (RTRACE)(SEXP x); void (SET_RDEBUG)(SEXP x, int v); void (SET_RSTEP)(SEXP x, int v); void (SET_RTRACE)(SEXP x, int v); void SET_FORMALS(SEXP x, SEXP v); void SET_BODY(SEXP x, SEXP v); void SET_CLOENV(SEXP x, SEXP v); /* Symbol Access Functions */ SEXP (PRINTNAME)(SEXP x); SEXP (SYMVALUE)(SEXP x); SEXP (INTERNAL)(SEXP x); int (DDVAL)(SEXP x); 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); /* Environment Access Functions */ SEXP (FRAME)(SEXP x); SEXP (ENCLOS)(SEXP x); SEXP (HASHTAB)(SEXP x); int (ENVFLAGS)(SEXP x); 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); /* Promise Access Functions */ /* First five have macro versions in Defn.h */ SEXP (PRCODE)(SEXP x); SEXP (PRENV)(SEXP x); SEXP (PRVALUE)(SEXP x); int (PRSEEN)(SEXP x); 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); /* External pointer access macros */ #define EXTPTR_PTR(x) CAR0(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) /* Pointer Protection and Unprotection */ #define PROTECT(s) Rf_protect(s) #define UNPROTECT(n) Rf_unprotect(n) #define UNPROTECT_PTR(s) Rf_unprotect_ptr(s) /* We sometimes need to coerce a protected value and place the new coerced value under protection. For these cases PROTECT_WITH_INDEX saves an index of the protection location that can be used to replace the protected value using REPROTECT. */ typedef int PROTECT_INDEX; #define PROTECT_WITH_INDEX(x,i) R_ProtectWithIndex(x,i) #define REPROTECT(x,i) R_Reprotect(x,i) /* Evaluation Environment */ LibExtern SEXP R_GlobalEnv; /* The "global" environment */ LibExtern SEXP R_EmptyEnv; /* An empty environment at the root of the environment tree */ LibExtern SEXP R_BaseEnv; /* The base environment; formerly R_NilValue */ LibExtern SEXP R_BaseNamespace; /* The (fake) namespace for base */ LibExtern SEXP R_NamespaceRegistry;/* Registry for registered namespaces */ LibExtern SEXP R_Srcref; /* Current srcref, for debuggers */ /* Special Values */ LibExtern SEXP R_NilValue; /* The nil object */ LibExtern SEXP R_UnboundValue; /* Unbound marker */ LibExtern SEXP R_MissingArg; /* Missing argument marker */ LibExtern SEXP R_InBCInterpreter; /* To be found in BC interp. state (marker) */ LibExtern SEXP R_CurrentExpression; /* Use current expression (marker) */ #ifdef __MAIN__ attribute_hidden #else extern #endif SEXP R_RestartToken; /* Marker for restarted function calls */ /* Symbol Table Shortcuts */ LibExtern SEXP R_AsCharacterSymbol;/* "as.character" */ LibExtern SEXP R_baseSymbol; // <-- backcompatible version of: LibExtern SEXP R_BaseSymbol; // "base" LibExtern SEXP R_BraceSymbol; /* "{" */ LibExtern SEXP R_Bracket2Symbol; /* "[[" */ LibExtern SEXP R_BracketSymbol; /* "[" */ LibExtern SEXP R_ClassSymbol; /* "class" */ LibExtern SEXP R_DeviceSymbol; /* ".Device" */ LibExtern SEXP R_DimNamesSymbol; /* "dimnames" */ LibExtern SEXP R_DimSymbol; /* "dim" */ LibExtern SEXP R_DollarSymbol; /* "$" */ LibExtern SEXP R_DotsSymbol; /* "..." */ LibExtern SEXP R_DoubleColonSymbol;// "::" LibExtern SEXP R_DropSymbol; /* "drop" */ LibExtern SEXP R_LastvalueSymbol; /* ".Last.value" */ LibExtern SEXP R_LevelsSymbol; /* "levels" */ LibExtern SEXP R_ModeSymbol; /* "mode" */ LibExtern SEXP R_NaRmSymbol; /* "na.rm" */ LibExtern SEXP R_NameSymbol; /* "name" */ LibExtern SEXP R_NamesSymbol; /* "names" */ LibExtern SEXP R_NamespaceEnvSymbol;// ".__NAMESPACE__." LibExtern SEXP R_PackageSymbol; /* "package" */ LibExtern SEXP R_PreviousSymbol; /* "previous" */ LibExtern SEXP R_QuoteSymbol; /* "quote" */ LibExtern SEXP R_RowNamesSymbol; /* "row.names" */ LibExtern SEXP R_SeedsSymbol; /* ".Random.seed" */ LibExtern SEXP R_SortListSymbol; /* "sort.list" */ LibExtern SEXP R_SourceSymbol; /* "source" */ LibExtern SEXP R_SpecSymbol; // "spec" LibExtern SEXP R_TripleColonSymbol;// ":::" LibExtern SEXP R_TspSymbol; /* "tsp" */ LibExtern SEXP R_dot_defined; /* ".defined" */ LibExtern SEXP R_dot_Method; /* ".Method" */ LibExtern SEXP R_dot_packageName;// ".packageName" LibExtern SEXP R_dot_target; /* ".target" */ LibExtern SEXP R_dot_Generic; /* ".Generic" */ /* Missing Values - others from Arith.h */ #define NA_STRING R_NaString LibExtern SEXP R_NaString; /* NA_STRING as a CHARSXP */ LibExtern SEXP R_BlankString; /* "" as a CHARSXP */ LibExtern SEXP R_BlankScalarString;/* "" as a STRSXP */ /* srcref related functions */ SEXP R_GetCurrentSrcref(int); SEXP R_GetSrcFilename(SEXP); /*--- FUNCTIONS ------------------------------------------------------ */ /* Type Coercions of all kinds */ SEXP Rf_asChar(SEXP); SEXP Rf_coerceVector(SEXP, SEXPTYPE); SEXP Rf_PairToVectorList(SEXP x); SEXP Rf_VectorToPairList(SEXP x); SEXP Rf_asCharacterFactor(SEXP x); int Rf_asLogical(SEXP x); int Rf_asLogical2(SEXP x, int checking, SEXP call, SEXP rho); int Rf_asInteger(SEXP x); double Rf_asReal(SEXP x); Rcomplex Rf_asComplex(SEXP x); #ifndef R_ALLOCATOR_TYPE #define R_ALLOCATOR_TYPE typedef struct R_allocator R_allocator_t; #endif /* Other Internally Used Functions, excluding those which are inline-able*/ char * Rf_acopy_string(const char *); void Rf_addMissingVarsToNewEnv(SEXP, SEXP); SEXP Rf_alloc3DArray(SEXPTYPE, int, int, int); SEXP Rf_allocArray(SEXPTYPE, 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_allocMatrix(SEXPTYPE, int, int); SEXP Rf_allocList(int); SEXP Rf_allocS4Object(void); SEXP Rf_allocSExp(SEXPTYPE); SEXP Rf_allocVector3(SEXPTYPE, R_xlen_t, R_allocator_t*); R_xlen_t Rf_any_duplicated(SEXP x, Rboolean from_last); R_xlen_t Rf_any_duplicated3(SEXP x, SEXP incomp, Rboolean from_last); SEXP Rf_applyClosure(SEXP, SEXP, SEXP, SEXP, SEXP); SEXP Rf_arraySubscript(int, SEXP, SEXP, SEXP (*)(SEXP,SEXP), SEXP (*)(SEXP, int), SEXP); SEXP Rf_classgets(SEXP, SEXP); SEXP Rf_cons(SEXP, SEXP); SEXP Rf_fixSubset3Args(SEXP, SEXP, SEXP, SEXP*); void Rf_copyMatrix(SEXP, SEXP, Rboolean); void Rf_copyListMatrix(SEXP, SEXP, Rboolean); void Rf_copyMostAttrib(SEXP, SEXP); void Rf_copyVector(SEXP, SEXP); int Rf_countContexts(int, int); SEXP Rf_CreateTag(SEXP); void Rf_defineVar(SEXP, SEXP, SEXP); SEXP Rf_dimgets(SEXP, SEXP); SEXP Rf_dimnamesgets(SEXP, SEXP); SEXP Rf_DropDims(SEXP); SEXP Rf_duplicate(SEXP); SEXP Rf_shallow_duplicate(SEXP); SEXP R_duplicate_attr(SEXP); SEXP R_shallow_duplicate_attr(SEXP); SEXP Rf_lazy_duplicate(SEXP); /* the next really should not be here and is also in Defn.h */ SEXP Rf_duplicated(SEXP, Rboolean); Rboolean R_envHasNoSpecialSymbols(SEXP); SEXP Rf_eval(SEXP, SEXP); SEXP Rf_ExtractSubset(SEXP, SEXP, SEXP); SEXP Rf_findFun(SEXP, SEXP); SEXP Rf_findFun3(SEXP, SEXP, SEXP); void Rf_findFunctionForBody(SEXP); SEXP Rf_findVar(SEXP, SEXP); SEXP Rf_findVarInFrame(SEXP, SEXP); SEXP Rf_findVarInFrame3(SEXP, SEXP, Rboolean); SEXP Rf_getAttrib(SEXP, SEXP); SEXP Rf_GetArrayDimnames(SEXP); SEXP Rf_GetColNames(SEXP); void Rf_GetMatrixDimnames(SEXP, SEXP*, SEXP*, const char**, const char**); SEXP Rf_GetOption(SEXP, SEXP); /* pre-2.13.0 compatibility */ SEXP Rf_GetOption1(SEXP); int Rf_GetOptionDigits(void); int Rf_GetOptionWidth(void); SEXP Rf_GetRowNames(SEXP); void Rf_gsetVar(SEXP, SEXP, SEXP); SEXP Rf_install(const char *); SEXP Rf_installChar(SEXP); SEXP Rf_installNoTrChar(SEXP); SEXP Rf_installTrChar(SEXP); SEXP Rf_installDDVAL(int i); SEXP Rf_installS3Signature(const char *, const char *); Rboolean Rf_isFree(SEXP); Rboolean Rf_isOrdered(SEXP); Rboolean Rf_isUnmodifiedSpecSym(SEXP sym, SEXP env); Rboolean Rf_isUnordered(SEXP); Rboolean Rf_isUnsorted(SEXP, Rboolean); SEXP Rf_lengthgets(SEXP, R_len_t); SEXP Rf_xlengthgets(SEXP, R_xlen_t); SEXP R_lsInternal(SEXP, Rboolean); SEXP R_lsInternal3(SEXP, Rboolean, Rboolean); SEXP Rf_match(SEXP, SEXP, int); SEXP Rf_matchE(SEXP, SEXP, int, SEXP); SEXP Rf_namesgets(SEXP, SEXP); SEXP Rf_mkChar(const char *); SEXP Rf_mkCharLen(const char *, int); Rboolean Rf_NonNullStringMatch(SEXP, SEXP); int Rf_ncols(SEXP); int Rf_nrows(SEXP); SEXP Rf_nthcdr(SEXP, int); // ../main/character.c : typedef enum {Bytes, Chars, Width} nchar_type; int R_nchar(SEXP string, nchar_type type_, Rboolean allowNA, Rboolean keepNA, const char* msg_name); Rboolean Rf_pmatch(SEXP, SEXP, Rboolean); Rboolean Rf_psmatch(const char *, const char *, Rboolean); SEXP R_ParseEvalString(const char *, SEXP); void Rf_PrintValue(SEXP); void Rf_printwhere(void); #ifndef INLINE_PROTECT SEXP Rf_protect(SEXP); #endif void Rf_readS3VarsFromFrame(SEXP, SEXP*, SEXP*, SEXP*, SEXP*, SEXP*, SEXP*); SEXP Rf_setAttrib(SEXP, SEXP, SEXP); void Rf_setSVector(SEXP*, int, SEXP); void Rf_setVar(SEXP, SEXP, SEXP); SEXP Rf_stringSuffix(SEXP, int); SEXPTYPE Rf_str2type(const char *); Rboolean Rf_StringBlank(SEXP); SEXP Rf_substitute(SEXP,SEXP); SEXP Rf_topenv(SEXP, SEXP); const char * Rf_translateChar(SEXP); const char * Rf_translateChar0(SEXP); const char * Rf_translateCharUTF8(SEXP); const char * Rf_type2char(SEXPTYPE); SEXP Rf_type2rstr(SEXPTYPE); SEXP Rf_type2str(SEXPTYPE); SEXP Rf_type2str_nowarn(SEXPTYPE); #ifndef INLINE_PROTECT void Rf_unprotect(int); #endif void Rf_unprotect_ptr(SEXP); void NORET R_signal_protect_error(void); void NORET R_signal_unprotect_error(void); void NORET R_signal_reprotect_error(PROTECT_INDEX i); #ifndef INLINE_PROTECT void R_ProtectWithIndex(SEXP, PROTECT_INDEX *); void R_Reprotect(SEXP, PROTECT_INDEX); #endif SEXP R_tryEval(SEXP, SEXP, int *); SEXP R_tryEvalSilent(SEXP, SEXP, int *); SEXP R_GetCurrentEnv(); const char *R_curErrorBuf(); Rboolean Rf_isS4(SEXP); SEXP Rf_asS4(SEXP, Rboolean, int); SEXP Rf_S3Class(SEXP); int Rf_isBasicClass(const char *); Rboolean R_cycle_detected(SEXP s, SEXP child); typedef enum { CE_NATIVE = 0, CE_UTF8 = 1, CE_LATIN1 = 2, CE_BYTES = 3, CE_SYMBOL = 5, CE_ANY =99 } cetype_t; cetype_t Rf_getCharCE(SEXP); SEXP Rf_mkCharCE(const char *, cetype_t); SEXP Rf_mkCharLenCE(const char *, int, cetype_t); const char *Rf_reEnc(const char *x, cetype_t ce_in, cetype_t ce_out, int subst); /* match(.) 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; } #ifdef __MAIN__ #undef extern #undef LibExtern #endif /* Calling a function with arguments evaluated */ SEXP R_forceAndCall(SEXP e, int n, SEXP rho); /* External pointer interface */ SEXP R_MakeExternalPtr(void *p, SEXP tag, SEXP prot); void *R_ExternalPtrAddr(SEXP s); SEXP R_ExternalPtrTag(SEXP s); SEXP R_ExternalPtrProtected(SEXP s); void R_ClearExternalPtr(SEXP s); void R_SetExternalPtrAddr(SEXP s, void *p); void R_SetExternalPtrTag(SEXP s, SEXP tag); void R_SetExternalPtrProtected(SEXP s, SEXP p); // Added in R 3.4.0 SEXP R_MakeExternalPtrFn(DL_FUNC p, SEXP tag, SEXP prot); DL_FUNC R_ExternalPtrAddrFn(SEXP s); /* Finalization interface */ typedef void (*R_CFinalizer_t)(SEXP); void R_RegisterFinalizer(SEXP s, SEXP fun); void R_RegisterCFinalizer(SEXP s, R_CFinalizer_t fun); void R_RegisterFinalizerEx(SEXP s, SEXP fun, Rboolean onexit); void R_RegisterCFinalizerEx(SEXP s, R_CFinalizer_t fun, Rboolean onexit); void R_RunPendingFinalizers(void); /* Weak reference interface */ SEXP R_MakeWeakRef(SEXP key, SEXP val, SEXP fin, Rboolean onexit); SEXP R_MakeWeakRefC(SEXP key, SEXP val, R_CFinalizer_t fin, Rboolean onexit); SEXP R_WeakRefKey(SEXP w); SEXP R_WeakRefValue(SEXP w); void R_RunWeakRefFinalizer(SEXP w); SEXP R_PromiseExpr(SEXP); SEXP R_ClosureExpr(SEXP); SEXP R_BytecodeExpr(SEXP e); void R_initialize_bcode(void); SEXP R_bcEncode(SEXP); SEXP R_bcDecode(SEXP); void R_registerBC(SEXP, SEXP); Rboolean R_checkConstants(Rboolean); Rboolean R_BCVersionOK(SEXP); #define PREXPR(e) R_PromiseExpr(e) #define BODY_EXPR(e) R_ClosureExpr(e) void R_init_altrep(); void R_reinit_altrep_classes(DllInfo *); /* Protected evaluation */ Rboolean R_ToplevelExec(void (*fun)(void *), void *data); SEXP R_ExecWithCleanup(SEXP (*fun)(void *), void *data, void (*cleanfun)(void *), void *cleandata); SEXP R_tryCatch(SEXP (*)(void *), void *, /* body closure*/ SEXP, /* condition classes (STRSXP) */ SEXP (*)(SEXP, void *), void *, /* handler closure */ void (*)(void *), void *); /* finally closure */ SEXP R_tryCatchError(SEXP (*)(void *), void *, /* body closure*/ SEXP (*)(SEXP, void *), void *); /* handler closure */ SEXP R_MakeUnwindCont(); void NORET R_ContinueUnwind(SEXP cont); SEXP R_UnwindProtect(SEXP (*fun)(void *data), void *data, void (*cleanfun)(void *data, Rboolean jump), void *cleandata, SEXP cont); /* Environment and Binding Features */ void R_RestoreHashCount(SEXP rho); Rboolean R_IsPackageEnv(SEXP rho); SEXP R_PackageEnvName(SEXP rho); SEXP R_FindPackageEnv(SEXP info); Rboolean R_IsNamespaceEnv(SEXP rho); SEXP R_NamespaceEnvSpec(SEXP rho); SEXP R_FindNamespace(SEXP info); void R_LockEnvironment(SEXP env, Rboolean bindings); Rboolean R_EnvironmentIsLocked(SEXP env); void R_LockBinding(SEXP sym, SEXP env); void R_unLockBinding(SEXP sym, SEXP env); void R_MakeActiveBinding(SEXP sym, SEXP fun, SEXP env); Rboolean R_BindingIsLocked(SEXP sym, SEXP env); Rboolean R_BindingIsActive(SEXP sym, SEXP env); Rboolean R_HasFancyBindings(SEXP rho); /* ../main/errors.c : */ /* needed for R_load/savehistory handling in front ends */ #if defined(__GNUC__) && __GNUC__ >= 3 void Rf_errorcall(SEXP, const char *, ...) __attribute__((noreturn)); #else void Rf_errorcall(SEXP, const char *, ...); #endif void Rf_warningcall(SEXP, const char *, ...); void Rf_warningcall_immediate(SEXP, const char *, ...); /* Save/Load Interface */ #define R_XDR_DOUBLE_SIZE 8 #define R_XDR_INTEGER_SIZE 4 void R_XDREncodeDouble(double d, void *buf); double R_XDRDecodeDouble(void *buf); void R_XDREncodeInteger(int i, void *buf); int R_XDRDecodeInteger(void *buf); typedef void *R_pstream_data_t; typedef enum { R_pstream_any_format, R_pstream_ascii_format, R_pstream_binary_format, R_pstream_xdr_format, R_pstream_asciihex_format } R_pstream_format_t; typedef struct R_outpstream_st *R_outpstream_t; struct R_outpstream_st { R_pstream_data_t data; R_pstream_format_t type; int version; void (*OutChar)(R_outpstream_t, int); void (*OutBytes)(R_outpstream_t, void *, int); SEXP (*OutPersistHookFunc)(SEXP, SEXP); SEXP OutPersistHookData; }; typedef struct R_inpstream_st *R_inpstream_t; #define R_CODESET_MAX 63 struct R_inpstream_st { R_pstream_data_t data; R_pstream_format_t type; int (*InChar)(R_inpstream_t); void (*InBytes)(R_inpstream_t, void *, int); SEXP (*InPersistHookFunc)(SEXP, SEXP); SEXP InPersistHookData; char native_encoding[R_CODESET_MAX + 1]; void *nat2nat_obj; void *nat2utf8_obj; }; void R_InitInPStream(R_inpstream_t stream, R_pstream_data_t data, R_pstream_format_t type, int (*inchar)(R_inpstream_t), void (*inbytes)(R_inpstream_t, void *, int), SEXP (*phook)(SEXP, SEXP), SEXP pdata); void R_InitOutPStream(R_outpstream_t stream, R_pstream_data_t data, R_pstream_format_t type, int version, void (*outchar)(R_outpstream_t, int), void (*outbytes)(R_outpstream_t, void *, int), SEXP (*phook)(SEXP, SEXP), SEXP pdata); #ifdef __cplusplus void R_InitFileInPStream(R_inpstream_t stream, std::FILE *fp, R_pstream_format_t type, SEXP (*phook)(SEXP, SEXP), SEXP pdata); void R_InitFileOutPStream(R_outpstream_t stream, std::FILE *fp, R_pstream_format_t type, int version, SEXP (*phook)(SEXP, SEXP), SEXP pdata); #else void R_InitFileInPStream(R_inpstream_t stream, FILE *fp, R_pstream_format_t type, SEXP (*phook)(SEXP, SEXP), SEXP pdata); void R_InitFileOutPStream(R_outpstream_t stream, FILE *fp, R_pstream_format_t type, int version, SEXP (*phook)(SEXP, SEXP), SEXP pdata); #endif #ifdef NEED_CONNECTION_PSTREAMS /* The connection interface is not available to packages. To allow limited use of connection pointers this defines the opaque pointer type. */ #ifndef HAVE_RCONNECTION_TYPEDEF typedef struct Rconn *Rconnection; #define HAVE_RCONNECTION_TYPEDEF #endif void R_InitConnOutPStream(R_outpstream_t stream, Rconnection con, R_pstream_format_t type, int version, SEXP (*phook)(SEXP, SEXP), SEXP pdata); void R_InitConnInPStream(R_inpstream_t stream, Rconnection con, R_pstream_format_t type, SEXP (*phook)(SEXP, SEXP), SEXP pdata); #endif void R_Serialize(SEXP s, R_outpstream_t ops); SEXP R_Unserialize(R_inpstream_t ips); SEXP R_SerializeInfo(R_inpstream_t ips); /* slot management (in attrib.c) */ SEXP R_do_slot(SEXP obj, SEXP name); SEXP R_do_slot_assign(SEXP obj, SEXP name, SEXP value); int R_has_slot(SEXP obj, SEXP name); /* S3-S4 class (inheritance), attrib.c */ SEXP R_S4_extends(SEXP klass, SEXP useTable); /* class definition, new objects (objects.c) */ SEXP R_do_MAKE_CLASS(const char *what); SEXP R_getClassDef (const char *what); SEXP R_getClassDef_R(SEXP what); Rboolean R_has_methods_attached(void); Rboolean R_isVirtualClass(SEXP class_def, SEXP env); Rboolean R_extends (SEXP class1, SEXP class2, SEXP env); SEXP R_do_new_object(SEXP class_def); /* supporting a C-level version of is(., .) : */ int R_check_class_and_super(SEXP x, const char **valid, SEXP rho); int R_check_class_etc (SEXP x, const char **valid); /* preserve objects across GCs */ void R_PreserveObject(SEXP); void R_ReleaseObject(SEXP); SEXP R_NewPreciousMSet(int); void R_PreserveInMSet(SEXP x, SEXP mset); void R_ReleaseFromMSet(SEXP x, SEXP mset); void R_ReleaseMSet(SEXP mset, int keepSize); /* Shutdown actions */ void R_dot_Last(void); /* in main.c */ void R_RunExitFinalizers(void); /* in memory.c */ /* Replacements for popen and system */ #ifdef HAVE_POPEN # ifdef __cplusplus std::FILE *R_popen(const char *, const char *); # else FILE *R_popen(const char *, const char *); # endif #endif int R_system(const char *); /* R_compute_identical: C version of identical() function The third arg to R_compute_identical() consists of bitmapped flags for non-default options: currently the first 4 default to TRUE, so the flag is set for FALSE values: 1 = !NUM_EQ 2 = !SINGLE_NA 4 = !ATTR_AS_SET 8 = !IGNORE_BYTECODE 16 = !IGNORE_ENV Default from R's default: 16 */ Rboolean R_compute_identical(SEXP, SEXP, int); SEXP R_body_no_src(SEXP x); // body(x) without "srcref" etc, ../main/utils.c /* C version of R's indx <- order(..., na.last, decreasing) : e.g. arglist = Rf_lang2(x,y) or Rf_lang3(x,y,z) */ void R_orderVector (int *indx, int n, SEXP arglist, Rboolean nalast, Rboolean decreasing); // C version of R's indx <- order(x, na.last, decreasing) : void R_orderVector1(int *indx, int n, SEXP x, Rboolean nalast, Rboolean decreasing); #ifndef R_NO_REMAP #define acopy_string Rf_acopy_string #define addMissingVarsToNewEnv Rf_addMissingVarsToNewEnv #define alloc3DArray Rf_alloc3DArray #define allocArray Rf_allocArray #define allocFormalsList2 Rf_allocFormalsList2 #define allocFormalsList3 Rf_allocFormalsList3 #define allocFormalsList4 Rf_allocFormalsList4 #define allocFormalsList5 Rf_allocFormalsList5 #define allocFormalsList6 Rf_allocFormalsList6 #define allocList Rf_allocList #define allocMatrix Rf_allocMatrix #define allocS4Object Rf_allocS4Object #define allocSExp Rf_allocSExp #define allocVector Rf_allocVector #define allocVector3 Rf_allocVector3 #define any_duplicated Rf_any_duplicated #define any_duplicated3 Rf_any_duplicated3 #define applyClosure Rf_applyClosure #define arraySubscript Rf_arraySubscript #define asChar Rf_asChar #define asCharacterFactor Rf_asCharacterFactor #define asComplex Rf_asComplex #define asInteger Rf_asInteger #define asLogical Rf_asLogical #define asLogical2 Rf_asLogical2 #define asReal Rf_asReal #define asS4 Rf_asS4 #define classgets Rf_classgets #define coerceVector Rf_coerceVector #define conformable Rf_conformable #define cons Rf_cons #define fixSubset3Args Rf_fixSubset3Args #define copyListMatrix Rf_copyListMatrix #define copyMatrix Rf_copyMatrix #define copyMostAttrib Rf_copyMostAttrib #define copyVector Rf_copyVector #define countContexts Rf_countContexts #define CreateTag Rf_CreateTag #define defineVar Rf_defineVar #define dimgets Rf_dimgets #define dimnamesgets Rf_dimnamesgets #define DropDims Rf_DropDims #define duplicate Rf_duplicate #define duplicated Rf_duplicated #define elt Rf_elt #define errorcall Rf_errorcall #define eval Rf_eval #define ExtractSubset Rf_ExtractSubset #define findFun Rf_findFun #define findFun3 Rf_findFun3 #define findFunctionForBody Rf_findFunctionForBody #define findVar Rf_findVar #define findVarInFrame Rf_findVarInFrame #define findVarInFrame3 Rf_findVarInFrame3 #define GetArrayDimnames Rf_GetArrayDimnames #define getAttrib Rf_getAttrib #define getCharCE Rf_getCharCE #define GetColNames Rf_GetColNames #define GetMatrixDimnames Rf_GetMatrixDimnames #define GetOption1 Rf_GetOption1 #define GetOptionDigits Rf_GetOptionDigits #define GetOptionWidth Rf_GetOptionWidth #define GetOption Rf_GetOption #define GetRowNames Rf_GetRowNames #define gsetVar Rf_gsetVar #define inherits Rf_inherits #define install Rf_install #define installChar Rf_installTrChar #define installNoTrChar Rf_installNoTrChar #define installTrChar Rf_installTrChar #define installDDVAL Rf_installDDVAL #define installS3Signature Rf_installS3Signature #define isArray Rf_isArray #define isBasicClass Rf_isBasicClass #define isComplex Rf_isComplex #define isEnvironment Rf_isEnvironment #define isExpression Rf_isExpression #define isFactor Rf_isFactor #define isFrame Rf_isFrame #define isFree Rf_isFree #define isFunction Rf_isFunction #define isInteger Rf_isInteger #define isLanguage Rf_isLanguage #define isList Rf_isList #define isLogical Rf_isLogical #define isSymbol Rf_isSymbol #define isMatrix Rf_isMatrix #define isNewList Rf_isNewList #define isNull Rf_isNull #define isNumeric Rf_isNumeric #define isNumber Rf_isNumber #define isObject Rf_isObject #define isOrdered Rf_isOrdered #define isPairList Rf_isPairList #define isPrimitive Rf_isPrimitive #define isReal Rf_isReal #define isS4 Rf_isS4 #define isString Rf_isString #define isTs Rf_isTs #define isUnmodifiedSpecSym Rf_isUnmodifiedSpecSym #define isUnordered Rf_isUnordered #define isUnsorted Rf_isUnsorted #define isUserBinop Rf_isUserBinop #define isValidString Rf_isValidString #define isValidStringF Rf_isValidStringF #define isVector Rf_isVector #define isVectorAtomic Rf_isVectorAtomic #define isVectorizable Rf_isVectorizable #define isVectorList Rf_isVectorList #define lang1 Rf_lang1 #define lang2 Rf_lang2 #define lang3 Rf_lang3 #define lang4 Rf_lang4 #define lang5 Rf_lang5 #define lang6 Rf_lang6 #define lastElt Rf_lastElt #define lazy_duplicate Rf_lazy_duplicate #define lcons Rf_lcons #define length(x) Rf_length(x) #define lengthgets Rf_lengthgets #define list1 Rf_list1 #define list2 Rf_list2 #define list3 Rf_list3 #define list4 Rf_list4 #define list5 Rf_list5 #define list6 Rf_list6 #define listAppend Rf_listAppend #define match Rf_match #define matchE Rf_matchE #define mkChar Rf_mkChar #define mkCharCE Rf_mkCharCE #define mkCharLen Rf_mkCharLen #define mkCharLenCE Rf_mkCharLenCE #define mkNamed Rf_mkNamed #define mkString Rf_mkString #define namesgets Rf_namesgets #define ncols Rf_ncols #define nlevels Rf_nlevels #define NonNullStringMatch Rf_NonNullStringMatch #define nrows Rf_nrows #define nthcdr Rf_nthcdr #define PairToVectorList Rf_PairToVectorList #define pmatch Rf_pmatch #define psmatch Rf_psmatch #define PrintValue Rf_PrintValue #define printwhere Rf_printwhere #define protect Rf_protect #define readS3VarsFromFrame Rf_readS3VarsFromFrame #define reEnc Rf_reEnc #define rownamesgets Rf_rownamesgets #define S3Class Rf_S3Class #define ScalarComplex Rf_ScalarComplex #define ScalarInteger Rf_ScalarInteger #define ScalarLogical Rf_ScalarLogical #define ScalarReal Rf_ScalarReal #define ScalarString Rf_ScalarString #define ScalarRaw Rf_ScalarRaw #define setAttrib Rf_setAttrib #define setSVector Rf_setSVector #define setVar Rf_setVar #define shallow_duplicate Rf_shallow_duplicate #define str2type Rf_str2type #define stringSuffix Rf_stringSuffix #define stringPositionTr Rf_stringPositionTr #define StringBlank Rf_StringBlank #define substitute Rf_substitute #define topenv Rf_topenv #define translateChar Rf_translateChar #define translateChar0 Rf_translateChar0 #define translateCharUTF8 Rf_translateCharUTF8 #define type2char Rf_type2char #define type2rstr Rf_type2rstr #define type2str Rf_type2str #define type2str_nowarn Rf_type2str_nowarn #define unprotect Rf_unprotect #define unprotect_ptr Rf_unprotect_ptr #define VectorToPairList Rf_VectorToPairList #define warningcall Rf_warningcall #define warningcall_immediate Rf_warningcall_immediate #define xlength(x) Rf_xlength(x) #define xlengthgets Rf_xlengthgets #endif /* Defining NO_RINLINEDFUNS disables use to simulate platforms where this is not available */ #if defined(CALLED_FROM_DEFN_H) && !defined(__MAIN__) && (defined(COMPILING_R) || ( __GNUC__ && !defined(__INTEL_COMPILER) )) && (defined(COMPILING_R) || !defined(NO_RINLINEDFUNS)) #include "Rinlinedfuns.h" #else /* need remapped names here for use with R_NO_REMAP */ /* 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 Rf_allocVector(SEXPTYPE, R_xlen_t); Rboolean Rf_conformable(SEXP, SEXP); SEXP Rf_elt(SEXP, int); Rboolean Rf_inherits(SEXP, const char *); Rboolean Rf_isArray(SEXP); Rboolean Rf_isFactor(SEXP); Rboolean Rf_isFrame(SEXP); Rboolean Rf_isFunction(SEXP); Rboolean Rf_isInteger(SEXP); Rboolean Rf_isLanguage(SEXP); Rboolean Rf_isList(SEXP); Rboolean Rf_isMatrix(SEXP); Rboolean Rf_isNewList(SEXP); Rboolean Rf_isNumber(SEXP); Rboolean Rf_isNumeric(SEXP); Rboolean Rf_isPairList(SEXP); Rboolean Rf_isPrimitive(SEXP); Rboolean Rf_isTs(SEXP); Rboolean Rf_isUserBinop(SEXP); Rboolean Rf_isValidString(SEXP); Rboolean Rf_isValidStringF(SEXP); Rboolean Rf_isVector(SEXP); Rboolean Rf_isVectorAtomic(SEXP); Rboolean Rf_isVectorList(SEXP); Rboolean Rf_isVectorizable(SEXP); SEXP Rf_lang1(SEXP); SEXP Rf_lang2(SEXP, SEXP); SEXP Rf_lang3(SEXP, SEXP, SEXP); SEXP Rf_lang4(SEXP, SEXP, SEXP, SEXP); SEXP Rf_lang5(SEXP, SEXP, SEXP, SEXP, SEXP); SEXP Rf_lang6(SEXP, SEXP, SEXP, SEXP, SEXP, SEXP); SEXP Rf_lastElt(SEXP); SEXP Rf_lcons(SEXP, SEXP); R_len_t Rf_length(SEXP); SEXP Rf_list1(SEXP); SEXP Rf_list2(SEXP, SEXP); SEXP Rf_list3(SEXP, SEXP, SEXP); SEXP Rf_list4(SEXP, SEXP, SEXP, SEXP); SEXP Rf_list5(SEXP, SEXP, SEXP, SEXP, SEXP); SEXP Rf_list6(SEXP, SEXP, SEXP, SEXP, SEXP, SEXP); SEXP Rf_listAppend(SEXP, SEXP); SEXP Rf_mkNamed(SEXPTYPE, const char **); SEXP Rf_mkString(const char *); int Rf_nlevels(SEXP); void R_removeVarFromFrame(SEXP, SEXP); int Rf_stringPositionTr(SEXP, const char *); SEXP Rf_ScalarComplex(Rcomplex); SEXP Rf_ScalarInteger(int); SEXP Rf_ScalarLogical(int); SEXP Rf_ScalarRaw(Rbyte); SEXP Rf_ScalarReal(double); SEXP Rf_ScalarString(SEXP); R_xlen_t Rf_xlength(SEXP); R_xlen_t (XLENGTH)(SEXP x); R_xlen_t (XTRUELENGTH)(SEXP x); int LENGTH_EX(SEXP x, const char *file, int line); R_xlen_t XLENGTH_EX(SEXP x); # ifdef INLINE_PROTECT SEXP Rf_protect(SEXP); void Rf_unprotect(int); void R_ProtectWithIndex(SEXP, PROTECT_INDEX *); void R_Reprotect(SEXP, PROTECT_INDEX); # endif SEXP R_FixupRHS(SEXP x, SEXP y); SEXP (CAR)(SEXP e); void *(DATAPTR)(SEXP x); const void *(DATAPTR_RO)(SEXP x); const void *(DATAPTR_OR_NULL)(SEXP x); const int *(LOGICAL_OR_NULL)(SEXP x); const int *(INTEGER_OR_NULL)(SEXP x); const double *(REAL_OR_NULL)(SEXP x); const Rcomplex *(COMPLEX_OR_NULL)(SEXP x); const Rbyte *(RAW_OR_NULL)(SEXP x); void *(STDVEC_DATAPTR)(SEXP x); int (INTEGER_ELT)(SEXP x, R_xlen_t i); double (REAL_ELT)(SEXP x, R_xlen_t i); int (LOGICAL_ELT)(SEXP x, R_xlen_t i); Rcomplex (COMPLEX_ELT)(SEXP x, R_xlen_t i); Rbyte (RAW_ELT)(SEXP x, R_xlen_t i); SEXP (STRING_ELT)(SEXP x, R_xlen_t i); double SCALAR_DVAL(SEXP x); int SCALAR_LVAL(SEXP x); int SCALAR_IVAL(SEXP x); void SET_SCALAR_DVAL(SEXP x, double v); void SET_SCALAR_LVAL(SEXP x, int v); void SET_SCALAR_IVAL(SEXP x, int v); void SET_SCALAR_CVAL(SEXP x, Rcomplex v); void SET_SCALAR_BVAL(SEXP x, Rbyte v); SEXP R_altrep_data1(SEXP x); SEXP R_altrep_data2(SEXP x); void R_set_altrep_data1(SEXP x, SEXP v); void R_set_altrep_data2(SEXP x, SEXP v); SEXP ALTREP_CLASS(SEXP x); int *LOGICAL0(SEXP x); int *INTEGER0(SEXP x); double *REAL0(SEXP x); Rcomplex *COMPLEX0(SEXP x); Rbyte *RAW0(SEXP x); void SET_LOGICAL_ELT(SEXP x, R_xlen_t i, int v); void SET_INTEGER_ELT(SEXP x, R_xlen_t i, int v); void SET_REAL_ELT(SEXP x, R_xlen_t i, double v); #endif #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 != (uintptr_t)(-1) && usage > ((intptr_t) R_CStackLimit)) \ R_SignalCStackOverflow(usage); \ } while (FALSE) #endif void R_BadValueInRCode(SEXP value, SEXP call, SEXP rho, const char *rawmsg, const char *errmsg, const char *warnmsg, const char *varname, Rboolean warnByDefault); #ifdef __cplusplus } #endif #endif /* R_INTERNALS_H_ */