Embedding R in C++: access elements of a VECSXP - r

Question

So I'm calling some R code from C++, and I'm calling directly into R.dll for that (I know about about Rcpp and I have the book here on my desk, but I can't use it for this specific thing). I have an R script that sets a variable and I want to access the contents of that variable.
The variable is a list of strings; in C++, when I do TYPEOF(my_sexp), I get VECSXP; so far so good. Now I want to read the contents of that list into a std::vector. I have tried many permutations of the following idea:
SEXP vector_exp = VECTOR_ELT(my_sexp, 0);
int element_count = TRUELENGTH(vector_exp);
for (int i = 0 ; i < element_count ; i++) {
SEXP elem_sexp = VECTOR_ELT(my_sexp, i);
std::string element_string = R_CHAR(elem_sexp);
}
My problems:
- Using TRUELENGTH, I can an access violation. Using LENGTH, I get a wrong value.
- Accessing elements of the list using VECTOR_ELT() causes an access violation.
- I've tried manually inspecting the memory layout of my_sexp according to the struct definitions in the R headers, but I can't seem to get the casting right to get a meaningful value from it.
So, is there anyone who can tell me roughly how to access the elements of a list; or point me to an example; or point me to the location in Rcpp where a conversion like this is done? I tried finding the last point myself, but didn't get far - it seems like Rcpp's wrap() handles it 'magically' (as in, generically) somehow.
Thanks in advance.

Answer 1

I haven't spent very much time working with R's C interface, as I usually stick to Rcpp, but the following seems to work:
#include <Rcpp.h>
// [[Rcpp::export]]
void print_list_as_vector(SEXP lst) {
PROTECT(lst);
R_xlen_t n_list = XLENGTH(lst);
R_xlen_t n_elem = 0;
for (R_xlen_t i = 0; i < n_list; i++) {
n_elem += XLENGTH(VECTOR_ELT(lst, i));
}
std::vector<std::string> vs;
vs.reserve(n_elem);
for (R_xlen_t i = 0; i < n_list; i++) {
R_xlen_t nj = XLENGTH(VECTOR_ELT(lst, i));
for (R_xlen_t j = 0; j < nj; j++) {
vs.push_back(CHAR(STRING_ELT(VECTOR_ELT(lst, i), j)));
}
}
for (std::size_t i = 0; i < vs.size(); i++) {
Rcpp::Rcout <<
vs[i] << std::endl;
}
UNPROTECT(1);
}
/*** R
clist <- list(c("a", "b", "c"), c("l", "m", "n", "o", "p"), c("xyz1", "xyz2"))
print_list_as_vector(clist)
#a
#b
#c
#l
#m
#n
#o
#p
#xyz1
#xyz2
unlist(clist)
# [1] "a" "b" "c" "l" "m" "n" "o" "p" "xyz1" "xyz2"
*/
This was tested within R / using Rcpp attributes as you can see, but in the actual meat of code I tried to stick to the C interface to replicate your situation.
But to address your questions (as best I can) -
I have always used XLENGTH to get the length of SEXPs, and although I can't really speak to the differences between XLENGTH, LENGTH and TRUELENGTH, the first method always seems to produce the expected result.
I'm using VECTOR_ELT(lst, i) to access the ith element in the VECSXP lst.
Given the context of the data / function, I know that VECTOR_ELT(lst, i) is returning a STRSXP - i.e. a character vector. The jth element of this STRSXP is accessed with STRING_ELT(..., j), and since this returns a CHARSXP, we wrap it in CHAR to get a const char*, which is added to the std::vector<std::string>.
Unfortunately there doesn't seem to be that much documentation for R's C internals, but Hadley has a useful reference page here, and if all else fails, you can dig through the source itself.