int Rf_initEmbeddedR(int argc, char **argv)
{
Rf_initialize_R(argc, argv);
R_Interactive = TRUE; /* Rf_initialize_R set this based on isatty */
setup_Rmainloop();
return(1);
}
int main(int ac, char **av)
{
R_running_as_main_program = 1;
Rf_initialize_R(ac, av);
Rf_mainloop(); /* does not return */
return 0;
}
static char *RAPIinitialize(void) {
// TODO: check for header/library version mismatch?
char *e;
// set R_HOME for packages etc. We know this from our configure script
setenv("R_HOME", RHOME, TRUE);
// set some command line arguments
{
structRstart rp;
Rstart Rp = &rp;
char *rargv[] = { "R", "--slave", "--vanilla" };
int stat = 0;
R_DefParams(Rp);
Rp->R_Slave = (Rboolean) TRUE;
Rp->R_Quiet = (Rboolean) TRUE;
Rp->R_Interactive = (Rboolean) FALSE;
Rp->R_Verbose = (Rboolean) FALSE;
Rp->LoadSiteFile = (Rboolean) FALSE;
Rp->LoadInitFile = (Rboolean) FALSE;
Rp->RestoreAction = SA_NORESTORE;
Rp->SaveAction = SA_NOSAVE;
Rp->NoRenviron = TRUE;
stat = Rf_initialize_R(2, rargv);
if (stat < 0) {
return "Rf_initialize failed";
}
R_SetParams(Rp);
}
/* disable stack checking, because threads will throw it off */
R_CStackLimit = (uintptr_t) -1;
/* redirect input/output and set error handler */
R_Outputfile = NULL;
R_Consolefile = NULL;
/* we do not want R to handle any signal, will interfere with monetdbd */
R_SignalHandlers = 0;
/* we want control R's output and input */
ptr_R_WriteConsoleEx = writeConsoleEx;
ptr_R_WriteConsole = writeConsole;
ptr_R_ReadConsole = NULL;
ptr_R_ClearerrConsole = clearRErrConsole;
// big boy here
setup_Rmainloop();
if ((e = RAPIinstalladdons()) != 0) {
return e;
}
// patch R internals to disallow quit and system. Setting them to NULL produces an error.
SET_INTERNAL(install("quit"), R_NilValue);
// install.packages() uses system2 to call gcc etc., so we cannot disable it (perhaps store the pointer somewhere just for that?)
//SET_INTERNAL(install("system"), R_NilValue);
rapiInitialized = true;
return NULL;
}
/*
* Initialises the R interpreter.
*/
void init_R(int argc, char **argv){
if (RSRUBY_R_HOME) {
setenv("R_HOME", RSRUBY_R_HOME, 0);
}
Rf_initialize_R(argc, argv);
R_Interactive = TRUE;
R_CStackLimit = (uintptr_t)-1; //disable stack limit checking
setup_Rmainloop();
R_Interactive = FALSE; //Remove crash menu (and other interactive R features)
}
int main(int argc, char **argv) {
char *r_home = getenv("R_HOME");
if (r_home == NULL) {
printf("R_HOME must be set\n");
exit(1);
}
Rf_initialize_R(argc, argv);
structRstart rp;
Rstart Rp = &rp;
R_DefParams(Rp);
Rp->SaveAction = SA_SAVEASK;
R_SetParams(Rp);
ptr_stdR_CleanUp = ptr_R_CleanUp;
ptr_R_CleanUp = &testR_CleanUp;
ptr_stdR_Suicide = ptr_R_Suicide;
ptr_R_Suicide = &testR_Suicide;
ptr_R_ReadConsole = &testR_ReadConsole;
ptr_R_WriteConsole = &testR_WriteConsole;
DllInfo *eDllInfo = R_getEmbeddingDllInfo();
Rf_mainloop();
Rf_endEmbeddedR(0);
}
void runEmbeddedR(const core::FilePath& /*rHome*/, // ignored on posix
const core::FilePath& /*userHome*/, // ignored on posix
bool newSession,
SA_TYPE defaultSaveAction,
const Callbacks& callbacks,
InternalCallbacks* pInternal)
{
// disable R signal handlers. see src/main/main.c for the default
// implementations. in our case ignore them for the following reasons:
//
// INT - no concept of Ctrl-C based interruption (use flag directly)
//
// SEGV, ILL, & BUS: unsupported due to prompt invoking networking
// code (unsupported from within a signal handler)
//
// USR1 & USR2: same as above SEGV, etc. + we use them for other purposes
//
// PIPE: we ignore this globally in SessionMain. before doing this we
// confirmed that asio wasn't in some way manipulating it -- on linux
// boost passes MSG_NOSIGNAL to sendmsg and on OSX sets the SO_NOSIGPIPE
// option on all sockets created. note that on other platforms including
// solaris, hpux, etc. boost uses detail/signal_init to ignore SIGPIPE
// globally (this is done in io_service.hpp).
R_SignalHandlers = 0;
// set message callback early so we can see initialization error messages
ptr_R_ShowMessage = callbacks.showMessage ;
// running as main program (affects location of R_CStackStart on platforms
// without HAVE_LIBC_STACK_END or HAVE_KERN_USRSTACK). see also discussion
// on R_CStackStart in 8.1.5 Threading issues
R_running_as_main_program = 1;
// initialize R
const char *args[]= {"RStudio", "--interactive"};
Rf_initialize_R(sizeof(args)/sizeof(args[0]), (char**)args);
// For newSession = false we need to do a few things:
//
// 1) set R_Quiet so we startup without a banner
//
// 2) set LoadInitFile to supress execution of .Rprofile
//
// 3) we also need to make sure that .First is not executed. this is
// taken care of via the fact that we set RestoreAction to SA_NORESTORE
// which means that when setup_Rmainloop there is no .First function
// available to it because we haven't restored the environment yet.
// Note that .First is executed in the case of new sessions because
// it is read from .Rprofile as part of setup_Rmainloop. This implies
// that in our version of R the .First function must be defined in
// .Rprofile rather than simply saved into the global environment
// of the default workspace
//
structRstart rp;
Rstart Rp = &rp;
R_DefParams(Rp) ;
Rp->R_Slave = FALSE ;
Rp->R_Quiet = newSession ? FALSE : TRUE;
Rp->R_Interactive = TRUE ;
Rp->SaveAction = defaultSaveAction ;
Rp->RestoreAction = SA_NORESTORE; // handled within initialize()
Rp->LoadInitFile = newSession ? TRUE : FALSE;
R_SetParams(Rp) ;
// redirect console
R_Interactive = TRUE; // should have also been set by call to Rf_initialize_R
R_Consolefile = NULL;
R_Outputfile = NULL;
ptr_R_ReadConsole = callbacks.readConsole ;
ptr_R_WriteConsole = NULL; // must set this to NULL for Ex to be called
ptr_R_WriteConsoleEx = callbacks.writeConsoleEx ;
ptr_R_EditFile = callbacks.editFile ;
ptr_R_Busy = callbacks.busy;
// hook messages (in case Rf_initialize_R overwrites previously set hook)
ptr_R_ShowMessage = callbacks.showMessage ;
// hook file handling
ptr_R_ChooseFile = callbacks.chooseFile ;
ptr_R_ShowFiles = callbacks.showFiles ;
// hook history
ptr_R_loadhistory = callbacks.loadhistory;
ptr_R_savehistory = callbacks.savehistory;
ptr_R_addhistory = callbacks.addhistory;
// hook suicide, but save reference to internal suicide so we can forward
pInternal->suicide = ptr_R_Suicide;
ptr_R_Suicide = callbacks.suicide;
// hook clean up, but save reference to internal clean up so can forward
pInternal->cleanUp = ptr_R_CleanUp;
ptr_R_CleanUp = callbacks.cleanUp ;
// NOTE: we do not hook the following callbacks because they are targeted
// at clients that have a stdio-based console
// ptr_R_ResetConsole
// ptr_R_FlushConsole
// ptr_R_ClearerrConsole
// run main loop (does not return)
Rf_mainloop();
}
int initR(int argc, char **argv) {
structRstart rp;
Rstart Rp = &rp;
/* getenv("R_HOME","/Library/Frameworks/R.framework/Resources",1); */
if (!getenv("R_HOME")) {
fprintf(stderr, "R_HOME is not set. Please set all required environment variables before running this program.\n");
return -1;
}
/* this is probably unnecessary, but we could set any other parameters here */
R_DefParams(Rp);
Rp->NoRenviron = 0;
R_SetParams(Rp);
#ifdef RIF_HAS_RSIGHAND
R_SignalHandlers=0;
#endif
{
int stat=Rf_initialize_R(argc, argv);
if (stat<0) {
fprintf(stderr,"Failed to initialize embedded R! (stat=%d)\n",stat);
return -1;
}
}
#ifdef RIF_HAS_RSIGHAND
R_SignalHandlers=0;
#endif
#if (R_VERSION >= R_Version(2,3,0))
/* disable stack checking, because threads will thow it off */
R_CStackLimit = (uintptr_t) -1;
#endif
#ifdef JGR_DEBUG
fprintf(stderr,"R primary initialization done. Setting up parameters.\n");
#endif
R_Outputfile = NULL;
R_Consolefile = NULL;
R_Interactive = 1;
SaveAction = SA_SAVEASK;
/* ptr_R_Suicide = Re_Suicide; */
/* ptr_R_CleanUp = Re_CleanUp; */
ptr_R_ShowMessage = Re_ShowMessage;
ptr_R_ReadConsole = Re_ReadConsole;
#if (R_VERSION >=R_Version(2,5,0))
ptr_R_WriteConsole = NULL;
ptr_R_WriteConsoleEx = Re_WriteConsoleEx;
#else
ptr_R_WriteConsole = Re_WriteConsole;
#endif
ptr_R_ResetConsole = Re_ResetConsole;
ptr_R_FlushConsole = Re_FlushConsole;
ptr_R_ClearerrConsole = Re_ClearerrConsole;
ptr_R_Busy = Re_Busy;
ptr_R_ShowFiles = Re_ShowFiles;
ptr_R_ChooseFile = Re_ChooseFile;
ptr_R_loadhistory = Re_loadhistory;
ptr_R_savehistory = Re_savehistory;
#ifdef JGR_DEBUG
fprintf(stderr,"Setting up R event loop\n");
#endif
setup_Rmainloop();
#ifdef JGR_DEBUG
fprintf(stderr,"R initialized.\n");
#endif
return 0;
}
int Rf_initEmbeddedR(int argc, char **argv)
{
Rf_initialize_R(argc, argv);
setup_Rmainloop();
return(1);
}
