R devel - Mar 2006 - multiple packages using the same native code.

This might fall under the purview of bundles, but I could not find any 
example bundles which demonstrated what I am after.

I would like to construct two packages (A, B) which utilize a number of 
common C functions. The most straightforward way to do this is just copy 
the relevant .c and .h files from one src directory to the next, but 
this is tedious especially in the face of multiple developers and changes.

If I declare in the depends field that package A needs to be present in 
order to install package B this only enforces that package A has been 
installed correct? Is there a way to check whether the src of a package 
is available and to be able to compile against it (the source of a 
package does not seem to be installed by default so this might, in 
general, be impossible)? Linking against installed packages seems to be 
easier in the sense that I know that if a package is installed that uses 
native code the .so is available, but is there a makevars variable which 
I can use to tell R to add to its linking command upon R CMD INSTALL?

Does anyone have examples of configure scripts which are doing this by 
hand? I could see this as being a relatively painless addition for 
linking by mapping any dependency specified in the depends field (in 
DESCRIPTION) to additional dependencies in the list of directories to 
link against, but in terms of compiling I don't see an obvious solution 
besides writing it myself in the configure, but then it might make it 
much harder for the user to install.

Sorry if this is in the help manual - I have looked at places where I 
thought it might naturally be, but did not see anything.

Thanks in advance, jim

Hi Jim,

James Bullard <bullard at berkeley.edu> writes:
> I would like to construct two packages (A, B) which utilize a number of 
> common C functions. The most straightforward way to do this is just copy 
> the relevant .c and .h files from one src directory to the next, but 
> this is tedious especially in the face of multiple developers and
> changes.
I'm not sure I understand what you are after.  One possible solution
would be to create a third package 'C' that contains the common C
code.  This would allow you to call C function defined in 'C' from the
C code in 'A' or 'B'.

Using a .onLoad hook and getNativeSymbolInfo(), you can pass C
function pointers to the code in packages A and B.

Suppose in 'C' you have a C function foo() that is registered in the
usual manner so that it can be called by .Call or .C.

Then in 'A' you could have (all untested, sorry, but hopefully it
sketches the idea for you):

A/src/A.c

   static DL_FUNC C_foo;

   void init_funcs_from_C(SEXP foo_info) {
       C_foo = R_ExternalPtrAddr(foo_info);
   }

   void bar(int *x) {
       ...
       z = C_foo();
       ...
   }


A/R/zzz.R

   .onLoad <- function(libname, pkgname) {
       foo_info <- getNativeSymbolInfo("foo",
PACKAGE="C")
       .Call("init_funcs_from_C", foo_info$address)
   }


+ seth