C++ R_registerRoutines函数代码示例

void R_init_Biostrings(DllInfo *info)
{
    /* Lots of code around assumes that sizeof(Rbyte) == sizeof(char) */
    if (sizeof(Rbyte) != sizeof(char))
        error("sizeof(Rbyte) != sizeof(char)");
    _init_bytewise_match_tables();
    R_registerRoutines(info, cMethods, NULL, NULL, NULL);
    R_registerRoutines(info, NULL, callMethods, NULL, NULL);

    /* XString_class.c */
    REGISTER_CCALLABLE(_DNAencode);
    REGISTER_CCALLABLE(_DNAdecode);
    REGISTER_CCALLABLE(_RNAencode);
    REGISTER_CCALLABLE(_RNAdecode);

    /* XStringSet_class.c */
    REGISTER_CCALLABLE(_get_XStringSet_length);
    REGISTER_CCALLABLE(_get_XStringSet_xsbaseclassname);
    REGISTER_CCALLABLE(_hold_XStringSet);
    REGISTER_CCALLABLE(_get_length_from_XStringSet_holder);
    REGISTER_CCALLABLE(_get_elt_from_XStringSet_holder);
    REGISTER_CCALLABLE(_get_linear_subset_from_XStringSet_holder);
    REGISTER_CCALLABLE(_set_XStringSet_names);

    /* XStringSetList_class.c */
    REGISTER_CCALLABLE(_hold_XStringSetList);
    REGISTER_CCALLABLE(_get_length_from_XStringSetList_holder);
    REGISTER_CCALLABLE(_get_elt_from_XStringSetList_holder);

    /* match_reporting.c */
    REGISTER_CCALLABLE(_init_match_reporting);
    REGISTER_CCALLABLE(_set_active_PSpair);
    REGISTER_CCALLABLE(_set_match_shift);
    REGISTER_CCALLABLE(_report_match);
    REGISTER_CCALLABLE(_drop_reported_matches);
    REGISTER_CCALLABLE(_get_match_count);
    REGISTER_CCALLABLE(_reported_matches_asSEXP);

    /* MIndex_class.c */
    REGISTER_CCALLABLE(_hold_MIndex);
    REGISTER_CCALLABLE(_get_length_from_MIndex_holder);
    REGISTER_CCALLABLE(_get_width0_elt_from_MIndex_holder);
    REGISTER_CCALLABLE(_get_elt_from_MIndex_holder);

    /* match_pattern_boyermoore.c */
    REGISTER_CCALLABLE(_match_pattern_boyermoore);

    return;
}

/**
 * Library initialization.
 *
 * R calls this automatically on lib load/attach.
 */
extern "C" void R_init_stringi(DllInfo* dll)
{
   R_registerRoutines(dll, NULL, cCallMethods, NULL, NULL);
//   R_useDynamicSymbols(dll, Rboolean(FALSE)); // slower

   if (!SUPPORT_UTF8) {
      /* Rconfig.h states that all R platforms supports that */
      Rf_error("R does not support UTF-8 encoding.");
   }

   stri_set_icu_data_directory((char*)*(char**)(dll) /* dll->path */);


#ifndef NDEBUG
   fprintf(stdout, "!NDEBUG: ************************************************\n");
   fprintf(stdout, "!NDEBUG: Dynamic library `stringi` loaded\n");
   fprintf(stdout, "!NDEBUG: Check out http://stringi.rexamine.com\n");
   fprintf(stdout, "!NDEBUG: \n");
   fprintf(stdout, "!NDEBUG: Please send bug reports to [email protected] \n");
   fprintf(stdout, "!NDEBUG: or at https://github.com/Rexamine/stringi/issues\n");
   fprintf(stdout, "!NDEBUG: \n");
   fprintf(stdout, "!NDEBUG: Have fun testing! :-)\n");
   fprintf(stdout, "!NDEBUG: ************************************************\n");

// /* u_init: It is OK to simply use ICU services and functions without
// first having initialized ICU by calling u_init(). */
//    UErrorCode status;
//    u_init(&status);
//    if (U_FAILURE(status))
//      error("ICU init failed: %s", u_errorName(status));
#endif
}

R_init_graphics(DllInfo *dll)
{
    R_registerRoutines(dll, NULL, CallEntries, NULL, ExtEntries);
    R_useDynamicSymbols(dll, FALSE);
    R_forceSymbols(dll, TRUE);
    registerBase();
}

void R_init_xlsReadWrite(DllInfo *dll)
{
    R_registerRoutines(dll, NULL, R_CallDef, NULL, NULL);
    R_useDynamicSymbols(dll, FALSE);
    Rprintf(crmsg);
    Rprintf(cranmsg);
}

void
R_init_splines(DllInfo *dll)
{
    R_registerRoutines(dll, NULL, R_CallDef, NULL, NULL);
    R_useDynamicSymbols(dll, FALSE);
//    R_forceSymbols(dll, TRUE); // too few to worry about, used in cobs*
}

void R_init_xts(DllInfo *info)
{
  SymbolShortcuts();
  R_registerRoutines(info,
                     NULL,
                     callMethods,
                     NULL,
                     externalMethods);

  R_useDynamicSymbols(info, TRUE);

  /* used by external packages linking to internal xts code from C */
  R_RegisterCCallable("xts","do_is_ordered",(DL_FUNC) &do_is_ordered);
  R_RegisterCCallable("xts","coredata_xts", (DL_FUNC) &coredata_xts);
  R_RegisterCCallable("xts","isXts",        (DL_FUNC) &isXts);
  R_RegisterCCallable("xts","tryXts",       (DL_FUNC) &tryXts);
  R_RegisterCCallable("xts","do_rbind_xts", (DL_FUNC) &do_rbind_xts);
  R_RegisterCCallable("xts","naCheck",      (DL_FUNC) &naCheck);
  R_RegisterCCallable("xts","lagXts",       (DL_FUNC) &lagXts);

  R_RegisterCCallable("xts","make_index_unique", (DL_FUNC) &make_index_unique);
  R_RegisterCCallable("xts","make_unique",       (DL_FUNC) &make_unique);
  R_RegisterCCallable("xts","endpoints",         (DL_FUNC) &endpoints);
  R_RegisterCCallable("xts","do_merge_xts",      (DL_FUNC) &do_merge_xts);
  R_RegisterCCallable("xts","na_omit_xts",       (DL_FUNC) &na_omit_xts);
  R_RegisterCCallable("xts","na_locf",           (DL_FUNC) &na_locf);

  /* used by xts (functions moved from xts to zoo) */
  zoo_lag      = (SEXP(*)(SEXP,SEXP,SEXP)) R_GetCCallable("zoo","zoo_lag");
  zoo_coredata = (SEXP(*)(SEXP,SEXP))      R_GetCCallable("zoo","zoo_coredata");
}

void R_init_gtools(DllInfo *info)
{
  /* Register C routines */
  R_registerRoutines (info, cMethods, NULL, NULL, NULL);
  R_useDynamicSymbols(info, FALSE);
  R_forceSymbols     (info, TRUE);
}

void R_init_grid(DllInfo *dll) 
{
    /* No .C, .Fortran, or .External routines => NULL
     */
    R_registerRoutines(dll, NULL, callMethods, NULL, NULL);
    R_useDynamicSymbols(dll, FALSE);
}

void R_init_sg(DllInfo *info)
#endif
{
   /* There are four different external language call mechanisms available in R, namely:
    *    .C
    *    .Call
    *    .Fortran
    *    .External
    *
    * Currently shogun uses only the .External interface. */

   R_CMethodDef cMethods[] = { {NULL, NULL, 0} };
   R_FortranMethodDef fortranMethods[] = { {NULL, NULL, 0} };
   
#ifdef HAVE_ELWMS
   R_ExternalMethodDef externalMethods[] = { {"elwms", (void*(*)()) &Rsg, 1}, {NULL, NULL, 0} };
#else
   R_ExternalMethodDef externalMethods[] = { {"sg", (void*(*)()) &Rsg, 1}, {NULL, NULL, 0} };
#endif
   R_CallMethodDef callMethods[] = { {NULL, NULL, 0} };

   /* Register the routines saved in the callMethods structure so that they are available under R. */
   R_registerRoutines(info, cMethods, callMethods, (R_FortranMethodDef*) fortranMethods, (R_ExternalMethodDef*) externalMethods);

}

void
R_init_lcd(DllInfo *info)
{
  /* Register routines, allocate resources. */
  R_registerRoutines(info, NULL, callEntries /*CallEntries*/,
		     NULL, NULL /*ExternEntries*/);
}

void registerAll()
{
   // c methods
   R_CMethodDef* pCMethods = NULL;
   if (s_cMethods.size() > 0)
   {
      R_CMethodDef nullMethodDef ;
      nullMethodDef.name = NULL ;
      nullMethodDef.fun = NULL ;
      nullMethodDef.numArgs = 0 ;
      nullMethodDef.types = NULL;
      nullMethodDef.styles = NULL;
      s_cMethods.push_back(nullMethodDef);
      pCMethods = &s_cMethods[0];
   }
   
   // call methods
   R_CallMethodDef* pCallMethods = NULL;
   if (s_callMethods.size() > 0)
   {
      R_CallMethodDef nullMethodDef ;
      nullMethodDef.name = NULL ;
      nullMethodDef.fun = NULL ;
      nullMethodDef.numArgs = 0 ;
      s_callMethods.push_back(nullMethodDef);
      pCallMethods = &s_callMethods[0];
   }
   
   DllInfo *info = R_getEmbeddingDllInfo() ;
   R_registerRoutines(info, pCMethods, pCallMethods, NULL, NULL) ;
}

/**************************************************************
 *
 *      Register entry points...
 *
 **************************************************************/
void R_init_dREG(DllInfo *info) {
     R_CallMethodDef callMethods[]  = {
       {"get_genomic_data_R", (DL_FUNC)&get_genomic_data_R, 5},
       {NULL, NULL, 0}
     };

        R_registerRoutines(info, NULL, callMethods, NULL, NULL);
}

void R_init_foreign(DllInfo *dll)
{
    R_registerRoutines(dll, CEntries, CallEntries, NULL, ExtEntries);
    R_useDynamicSymbols(dll, FALSE);
#if defined(R_VERSION) && R_VERSION >= R_Version(3, 0, 0)
    R_forceSymbols(dll, TRUE);
#endif
}

void R_init_lme4a(DllInfo *dll)
{
    R_registerRoutines(dll, NULL, CallEntries, NULL, NULL);
    R_useDynamicSymbols(dll, (Rboolean)FALSE);

    M_R_cholmod_start(&c);
    c.final_ll = 1;	    /* LL' form of simplicial factorization */
}

void 
attribute_visible 
R_init_frailtypack(DllInfo *dll)
{
    R_registerRoutines(dll, NULL, NULL, FortEntries, NULL);
    R_useDynamicSymbols(dll, FALSE);
	  R_forceSymbols(dll, TRUE);
}