rcpp-0.11.0/ 0000755 0000000 0000000 00000000000 12273705472 007434 5 ustar rcpp-0.11.0/cleanup 0000755 0000000 0000000 00000002503 12253723677 011016 0 ustar
#cd inst/doc && rm -f index.html *.tex *.bbl *.blg *.aux *.out *.log && cd -
rm -f confdefs.h config.log config.status \
src/*.o src/*.so src/*.a src/*.d src/*.dll src/*.rc \
RcppSrc/*.o RcppSrc/*.a inst/Rcpp-version.txt \
inst/lib/libRcpp.so inst/lib/Rcpp*.h inst/lib/libRcpp.a \
inst/doc/*.cpp inst/doc/*.hpp \
inst/doc/*.out \
inst/doc/.build.timestamp \
inst/doc/*.Rd inst/doc/*.aux inst/doc/*.log inst/doc/*.tex \
inst/doc/latex/*.aux inst/doc/latex/*.log \
inst/examples/ConvolveBenchmarks/*.o \
inst/examples/ConvolveBenchmarks/*.so \
inst/examples/functionCallback/*.so \
inst/examples/functionCallback/*.o \
inst/examples/OpenMP/piWithInterrupts.o \
inst/examples/OpenMP/piWithInterrupts.so \
inst/discovery/cxx0x.Rout \
inst/unitTests/testRcppModule/src/*.o \
inst/unitTests/testRcppModule/src/*.so \
inst/unitTests/testRcppClass/src/*.o \
inst/unitTests/testRcppClass/src/*.so \
src/Makedeps libRcpp.a \
build/Rcpp.pdf \
src/symbols.rds \
inst/unitTests/testRcppClass/src/symbols.rds \
vignettes/*.aux vignettes/*.log vignettes/*.out \
vignettes/*.tex vignettes/*.bbl vignettes/*.blg
rm -rf autom4te.cache inst/lib/ inst/doc/man/ inst/doc/html/ inst/doc/latex/ \
inst/doc/auto inst/doc/Rcpp-*/auto/ src-* vignettes/auto
find . -name \*~ -exec rm {} \;
find . -name \*.flc -exec rm {} \;
rcpp-0.11.0/R/ 0000755 0000000 0000000 00000000000 12273452010 007620 5 ustar rcpp-0.11.0/R/00_classes.R 0000644 0000000 0000000 00000006325 12253723677 011727 0 ustar # Copyright (C) 2010 - 2012 John Chambers, Dirk Eddelbuettel and Romain Francois
#
# This file is part of Rcpp.
#
# Rcpp is free software: you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 2 of the License, or
# (at your option) any later version.
#
# Rcpp 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Rcpp. If not, see .
# anticipating a change in R 2.16.0
setClass( "refClassGeneratorFunction" )
setClassUnion("refGenerator", c("refObjectGenerator", "refClassGeneratorFunction"))
## "Module" class as an environment with "pointer", "moduleName",
## "packageName" and "refClassGenerators"
## Stands in for a reference class with those fields.
setClass( "Module", contains = "environment" )
setRefClass( "C++Field",
fields = list(
pointer = "externalptr",
cpp_class = "character",
read_only = "logical",
class_pointer = "externalptr",
docstring = "character"
)
)
setRefClass( "C++OverloadedMethods",
fields = list(
pointer = "externalptr",
class_pointer = "externalptr",
size = "integer",
void = "logical",
const = "logical",
docstrings = "character",
signatures = "character",
nargs = "integer"
),
methods = list(
info = function(prefix = " " ){
paste(
paste( prefix, signatures, ifelse(const, " const", "" ), "\n", prefix, prefix,
ifelse( nchar(docstrings), paste( "docstring :", docstrings) , "" )
) , collapse = "\n" )
}
)
)
setRefClass( "C++Constructor",
fields = list(
pointer = "externalptr",
class_pointer = "externalptr",
nargs = "integer",
signature = "character",
docstring = "character"
)
)
setClass( "C++Class",
representation(
pointer = "externalptr",
module = "externalptr",
fields = "list",
methods = "list",
constructors = "list",
generator = "refGenerator",
docstring = "character",
typeid = "character",
enums = "list",
parents = "character"
),
contains = "character"
)
setClass( "C++Object")
setClass( "C++Function",
representation(
pointer = "externalptr",
docstring = "character",
signature = "character"
),
contains = "function"
)
.cppfunction_formals_gets <- function (fun, envir = environment(fun), value) {
bd <- body(fun)
b2 <- bd[[2L]]
for( i in seq_along(value) ){
b2[[3L+i]] <- as.name( names(value)[i] )
}
bd[[2]] <- b2
f <- fun@.Data
formals(f) <- value
body(f) <- bd
fun@.Data <- f
fun
}
setGeneric( "formals<-" )
setMethod( "formals<-", "C++Function", .cppfunction_formals_gets )
rcpp-0.11.0/R/populate.R 0000644 0000000 0000000 00000002056 12253723677 011621 0 ustar # Copyright (C) 2010 - 2011 John Chambers, Dirk Eddelbuettel and Romain Francois
#
# This file is part of Rcpp.
#
# Rcpp is free software: you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 2 of the License, or
# (at your option) any later version.
#
# Rcpp 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Rcpp. If not, see .
populate <- function( module, env ){
# make sure the module is loaded
module <- Module( module, mustStart = TRUE )
storage <- get( "storage", as.environment(module ) )
symbols <- ls( storage )
is_ns <- isNamespace( env )
for( x in symbols ){
forceAssignInNamespace( x, storage[[x]], env )
}
}
rcpp-0.11.0/R/loadModule.R 0000644 0000000 0000000 00000010603 12253723677 012052 0 ustar # Copyright (C) 2010 - 2012 John Chambers, Dirk Eddelbuettel and Romain Francois
#
# This file is part of Rcpp.
#
# Rcpp is free software: you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 2 of the License, or
# (at your option) any later version.
#
# Rcpp 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Rcpp. If not, see .
## the following items are to get around some insanity in the
## CMD check of packages using Rcpp that dies in loadModule()
## because some code somewhere can't find the methods package
isBotchedSession <- function()
! ("package:methods" %in% search())
.moduleNames <- function(what) {
assignAs <- allNames(what)
sameNames <- !nzchar(assignAs)
assignAs[sameNames] <- what[sameNames]
assignAs
}
.DummyModule <- function(name, what) {
value <- new.env()
storage <- new.env()
assign("storage", storage, envir = value)
assign("moduleName", name, envir = value)
allNames <- names(.moduleNames(what))
for(el in allNames)
assign(el, NULL, envir = storage)
value
}
.moduleMetaName <- function(name)
methods::methodsPackageMetaName("Mod",name)
moduleIsLoaded <- function(name, env)
exists(.moduleMetaName(name), envir = env, inherits = FALSE)
loadModule <- function( module, what = character(), loadNow,
env = topenv(parent.frame())) {
if(is(module, "character")) {
loadM <- NULL
metaName <- .moduleMetaName(module)
if(exists(metaName, envir = env, inherits = FALSE))
loadM <- get(metaName, envir = env)
}
else if(is(module, "Module")) {
loadM <- as.environment(module)
module <- get(loadM, "moduleName")
}
else
stop(gettextf("Argument \"module\" should be a module or the name of a module: got an object of class \"%s\"", class(module)))
if(missing(loadNow)) { # test it
if(is.null(loadM))
loadM <- tryCatch(Module( module, mustStart = TRUE, where = env ),
error = function(e)e)
loadNow <- !is(loadM, "error")
}
if(loadNow) {
.botched <- isBotchedSession()
if(is.null(loadM))
loadM <- tryCatch(Module( module, mustStart = TRUE, where = env ),
error = function(e)e)
if(is(loadM, "error")) {
if(.botched)
return(.DummyModule(module, what))
stop(gettextf("Unable to load module \"%s\": %s",
as(module, "character"), loadM$message))
}
if(!exists(metaName, envir = env, inherits =FALSE))
assign(metaName, loadM, envir = env)
if(!length(what)) # no assignments
return(loadM)
env <- as.environment(env)
## get the storage environment, for what=TRUE
storage <- as.environment(get( "storage", as.environment(loadM ) ))
if(identical(what, TRUE))
what <- objects(storage)
missingObjs <- !sapply(what, function(symb) exists(symb, envir = storage, inherits = FALSE))
if(any(missingObjs)) {
if(.botched) {
for(el in what[missingObjs])
assign(el, NULL, envir = storage)
}
else {
warning(gettextf("%s not found in module \"%s\"",
paste0('"', what[missingObjs], '"', collapse = ", "),
as.character(module)))
what <- what[!missingObjs]
}
}
assignAs <- .moduleNames(what)
for( i in seq_along(what) ) {
if(.botched)
assign(assignAs[[i]], NULL, envir = storage)
else
assign(assignAs[[i]], get(what[[i]], envir = storage), envir = env)
}
loadM
}
else { # create a load action to recall this function
myCall <- match.call()
f <- function(ns) NULL
myCall$env <- as.name("ns")
myCall$loadNow <- TRUE
body(f, envir = env) <- myCall
setLoadAction(f, where = env)
invisible(myCall)
}
}
rcpp-0.11.0/R/RcppLdpath.R 0000644 0000000 0000000 00000005434 12266347221 012023 0 ustar # Copyright (C) 2010 - 2013 Dirk Eddelbuettel and Romain Francois
#
# This file is part of Rcpp.
#
# Rcpp is free software: you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 2 of the License, or
# (at your option) any later version.
#
# Rcpp 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Rcpp. If not, see .
## make sure system.file returns an absolute path
Rcpp.system.file <- function(...){
tools::file_path_as_absolute( base::system.file( ..., package = "Rcpp" ) )
}
## Use R's internal knowledge of path settings to find the lib/ directory
## plus optinally an arch-specific directory on system building multi-arch
RcppLdPath <- function() {
""
}
## Provide linker flags -- i.e. -L/path/to/libRcpp -- as well as an
## optional rpath call needed to tell the Linux dynamic linker about the
## location. This is not needed on OS X where we encode this as library
## built time (see src/Makevars) or Windows where we use a static library
## Updated Jan 2010: We now default to static linking but allow the use
## of rpath on Linux if static==FALSE has been chosen
## Note that this is probably being called from LdFlags()
## Updated Nov 2013: We no longer build a library. This should be deprecated.
RcppLdFlags <- function() { "" }
# indicates if Rcpp was compiled with GCC >= 4.3
canUseCXX0X <- function() .Call( "canUseCXX0X", PACKAGE = "Rcpp" )
## Provide compiler flags -- i.e. -I/path/to/Rcpp.h
RcppCxxFlags <- function(cxx0x=FALSE) {
# path <- RcppLdPath()
path <- Rcpp.system.file( "include" )
if (.Platform$OS.type=="windows") {
path <- asBuildPath(path)
}
paste("-I", path, if (cxx0x && canUseCXX0X()) " -std=c++0x" else "", sep="")
}
## Shorter names, and call cat() directly
## CxxFlags defaults to no using c++0x extensions are these are considered non-portable
CxxFlags <- function(cxx0x=FALSE) {
cat(RcppCxxFlags(cxx0x=cxx0x))
}
## LdFlags defaults to static linking on the non-Linux platforms Windows and OS X
LdFlags <- function() {
cat(RcppLdFlags())
}
# capabilities
RcppCapabilities <- capabilities <- function() .Call( rcpp_capabilities )
# compile, load and call the cxx0x.c script to identify whether
# the compiler is GCC >= 4.3
RcppCxx0xFlags <- function(){
script <- Rcpp.system.file( "discovery", "cxx0x.R" )
flag <- capture.output( source( script ) )
flag
}
Cxx0xFlags <- function() cat( RcppCxx0xFlags() )
rcpp-0.11.0/R/RcppClass.R 0000644 0000000 0000000 00000014507 12253723677 011666 0 ustar # Copyright (C) 2010 - 2012 John Chambers, Dirk Eddelbuettel and Romain Francois
#
# This file is part of Rcpp.
#
# Rcpp is free software: you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 2 of the License, or
# (at your option) any later version.
#
# Rcpp 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Rcpp. If not, see .
setRcppClass <- function(Class, CppClass,
module,
fields = list(),
contains = character(),
methods = list(),
saveAs = Class,
where = topenv(parent.frame()),
...) {
myCall <- match.call()
myCall[[1]] <- quote(Rcpp::loadRcppClass)
if(!missing(module) && moduleIsLoaded(module, where)) # eval now
eval.parent(myCall)
else {
f <- function(NS)NULL
myCall$where = as.name("NS")
body(f, where) <- myCall
setLoadAction(f, where = where)
}
}
loadRcppClass <- function(Class, CppClass = Class,
module = paste0("class_",Class),
fields = character(),
contains = character(),
methods = list(),
saveAs = Class,
where = topenv(parent.frame()),
...) {
if(isBotchedSession()) {
value <- setRefClass(Class, fields = fields, methods = methods, contains = contains, where = where, ...) # kludge -- see loadModule.R
if(is.character(saveAs) && length(saveAs) == 1)
assign(saveAs, value, envir = where)
return(value)
}
mod <- loadModule(module, NULL, env = where, loadNow = TRUE)
storage <- get("storage", envir = as.environment(mod))
if(exists(CppClass, envir = storage, inherits = FALSE)) {
cppclassinfo <- get(CppClass, envir = storage)
if(!is(cppclassinfo, "C++Class"))
stop(gettextf("Object \"%s\" in module \"%s\" is not a C++ class description", CppClass, module))
}
else
stop(gettextf("No object \"%s\" in module \"%s\"", CppClass, module))
allmethods <- .makeCppMethods(methods, cppclassinfo, where)
allfields <- .makeCppFields(fields, cppclassinfo, where)
value <- setRefClass(Class, fields = allfields,
contains = c(contains, "RcppClass"),
methods = allmethods, where=where, ...)
## declare the fields and methods to shut up codetools
## the R level fields and methods were declared by setRefClass
## but we declare them again; globalVariables() applies unique()
if(exists("globalVariables", envir = asNamespace("utils"))) # >=2.15.1
utils::globalVariables(c(names(allfields), names(allmethods)),
where)
if(is.character(saveAs) && length(saveAs) == 1)
assign(saveAs, value, envir = where)
value
}
.makeCppMethods <- function(methods, cppclassinfo, env) {
cppMethods <- names(cppclassinfo@methods)
newMethods <- names(methods)
for(what in cppMethods[! cppMethods %in% newMethods])
methods[[what]] <- eval(substitute(
function(...) .CppObject$WHAT(...), list(WHAT = as.name(what))),
env)
methods
}
.makeFieldsList <- function(fields) {
fnames <- allNames(fields)
any_s <- !nzchar(fnames)
fnames[any_s] <- fields[any_s]
fields[any_s] <- "ANY"
fields <- as.list(fields)
names(fields) <- fnames
fields
}
.makeCppFields <- function(fields, cppclassinfo, env) {
if(is.character(fields))
fields <- .makeFieldsList(fields)
cppFields <- names(cppclassinfo@fields)
newFields <- names(fields)
for(what in cppFields[! cppFields %in% newFields])
fields[[what]] <- eval(substitute(
function(value) if(missing(value)) .CppObject$WHAT else .CppObject$WHAT <- value,
list(WHAT = as.name(what))), env)
## insert the generator and cppclass def as constants
cppgenerator <- getRefClass(cppclassinfo)
fields[[".CppClassDef"]] <- eval(substitute(
function(value) if(missing(value)) DEF else stop("this field is a constant"),
list(DEF = cppclassinfo)), env)
fields[[".CppGenerator"]] <- eval(substitute(
function(value) if(missing(value)) DEF else stop("this field is a constant"),
list(DEF = cppgenerator)), env)
fields
}
.RcppClass <- setRefClass("RcppClass",
methods = list(
initialize = function(...){
args <- list(...)
argNames <- allNames(args)
cppArgs <- !nzchar(argNames)
.CppObject <<- do.call(.CppGenerator$new, args[cppArgs])
for(i in seq_along(args)[!cppArgs])
field(argNames[[i]], args[[i]])
}
),
fields = list(
.CppObject = "C++Object"
),
contains = "VIRTUAL"
)
.RcppClass$methods(show = function ()
{
cat("Rcpp class object of class ", classLabel(class(.self)),
"\n", sep = "")
fields <- names(.refClassDef@fieldClasses)
if(".CppObject" %in% fields) {
cat("\n")
methods::show(field(".CppObject"))
cat("\n")
}
fields <- fields[ ! fields %in% c(".CppObject", ".CppClassDef", ".CppGenerator")]
for (fi in fields) {
cat("Field \"", fi, "\":\n", sep = "")
methods::show(field(fi))
}
},
objectPointer = function()
.CppObject$.pointer
)
rcpp-0.11.0/R/Rcpp.package.skeleton.R 0000644 0000000 0000000 00000016572 12270352603 014103 0 ustar # -*- tab-width: 4; -*-
# Copyright (C) 2009 - 2014 Dirk Eddelbuettel and Romain Francois
#
# This file is part of Rcpp.
#
# Rcpp is free software: you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 2 of the License, or
# (at your option) any later version.
#
# Rcpp 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Rcpp. If not, see .
Rcpp.package.skeleton <- function(name = "anRpackage", list = character(),
environment = .GlobalEnv,
path = ".", force = FALSE,
code_files = character(), cpp_files = character(),
example_code = TRUE, attributes = TRUE, module = FALSE,
author = "Who wrote it",
maintainer = if (missing(author)) "Who to complain to"
else author,
email = "yourfault@somewhere.net",
license = "What Licence is it under ?") {
call <- match.call()
call[[1]] <- as.name("package.skeleton")
env <- parent.frame(1)
if (!is.character(cpp_files))
stop("'cpp_files' must be a character vector")
if (!length(list)) {
fake <- TRUE
assign("Rcpp.fake.fun", function() {}, envir = env)
if (example_code && !isTRUE(attributes)) {
assign("rcpp_hello_world", function() {}, envir = env)
remove_hello_world <- TRUE
} else {
remove_hello_world <- FALSE
}
} else {
if (example_code && !isTRUE(attributes)) {
if (!"rcpp_hello_world" %in% list) {
assign( "rcpp_hello_world", function() {}, envir = env)
call[["list"]] <- as.call(c(as.name("c"),
as.list(c("rcpp_hello_world", list))))
}
remove_hello_world <- TRUE
} else {
remove_hello_world <- FALSE
}
fake <- FALSE
}
## first let the traditional version do its business
## remove Rcpp specific arguments
call <- call[ c(1L, which(names(call) %in% names(formals(package.skeleton)))) ]
if (fake) {
call[["list"]] <- c(if(isTRUE(example_code)
&& !isTRUE(attributes)) "rcpp_hello_world", "Rcpp.fake.fun")
}
tryCatch(eval(call, envir = env), error = function(e){
stop(sprintf("error while calling `package.skeleton` : %s", conditionMessage(e)))
})
message("\nAdding Rcpp settings")
## now pick things up
root <- file.path(path, name)
# Add Rcpp to the DESCRIPTION
DESCRIPTION <- file.path(root, "DESCRIPTION")
if (file.exists(DESCRIPTION)) {
imports <- c(if (isTRUE(module)) "methods",
sprintf("Rcpp (>= %s)", packageDescription("Rcpp")[["Version"]]))
x <- cbind(read.dcf(DESCRIPTION),
"Imports" = paste(imports, collapse = ", "),
"LinkingTo" = "Rcpp")
if (isTRUE(module)) {
x <- cbind(x, "RcppModules" = "yada, stdVector, NumEx")
message(" >> added RcppModules: yada, stdVector, NumEx")
}
x[, "Author"] <- author
x[, "Maintainer"] <- sprintf("%s <%s>", maintainer, email)
x[, "License"] <- license
message( " >> added Imports: Rcpp" )
message( " >> added LinkingTo: Rcpp" )
write.dcf(x, file = DESCRIPTION)
}
## add useDynLib and importFrom to NAMESPACE
NAMESPACE <- file.path(root, "NAMESPACE")
lines <- readLines(NAMESPACE)
ns <- file(NAMESPACE, open="w")
if (! grepl("useDynLib", lines)) {
lines <- c(sprintf( "useDynLib(%s)", name), lines)
writeLines(lines, con = ns)
message(" >> added useDynLib directive to NAMESPACE" )
}
if (isTRUE(module)) {
writeLines('import(methods)', ns)
}
writeLines('importFrom(Rcpp, evalCpp)', ns)
message(" >> added importFrom(Rcpp, evalCpp) directive to NAMESPACE" )
close( ns )
## update the package description help page
package_help_page <- file.path(root, "man", sprintf( "%s-package.Rd", name))
if (file.exists(package_help_page)) {
lines <- readLines(package_help_page)
lines <- gsub("What license is it under?", license, lines, fixed = TRUE)
lines <- gsub("Who to complain to ",
sprintf( "%s <%s>", maintainer, email),
lines, fixed = TRUE)
lines <- gsub( "Who wrote it", author, lines, fixed = TRUE)
writeLines(lines, package_help_page)
}
## lay things out in the src directory
src <- file.path(root, "src")
if (!file.exists(src)) {
dir.create(src)
}
skeleton <- system.file("skeleton", package = "Rcpp")
if (length(cpp_files) > 0L) {
for (file in cpp_files) {
file.copy(file, src)
message(" >> copied ", file, " to src directory" )
}
compileAttributes(root)
}
if (example_code) {
if (isTRUE(attributes)) {
file.copy(file.path( skeleton, "rcpp_hello_world_attributes.cpp"),
file.path( src, "rcpp_hello_world.cpp"))
message(" >> added example src file using Rcpp attributes")
compileAttributes(root)
message(" >> compiled Rcpp attributes")
} else {
header <- readLines(file.path(skeleton, "rcpp_hello_world.h"))
header <- gsub("@PKG@", name, header, fixed = TRUE)
writeLines(header , file.path(src, "rcpp_hello_world.h"))
message(" >> added example header file using Rcpp classes")
file.copy(file.path(skeleton, "rcpp_hello_world.cpp"), src)
message(" >> added example src file using Rcpp classes")
rcode <- readLines(file.path( skeleton, "rcpp_hello_world.R"))
rcode <- gsub("@PKG@", name, rcode, fixed = TRUE)
writeLines( rcode , file.path( root, "R", "rcpp_hello_world.R"))
message(" >> added example R file calling the C++ example")
}
hello.Rd <- file.path(root, "man", "rcpp_hello_world.Rd")
unlink(hello.Rd)
file.copy(system.file("skeleton", "rcpp_hello_world.Rd", package = "Rcpp"), hello.Rd)
message( " >> added Rd file for rcpp_hello_world")
}
if (isTRUE( module)) {
file.copy(system.file("skeleton", "rcpp_module.cpp", package="Rcpp"),
file.path(root, "src"))
file.copy(system.file("skeleton", "Num.cpp", package="Rcpp"),
file.path(root, "src"))
file.copy(system.file("skeleton", "stdVector.cpp", package="Rcpp"),
file.path(root, "src"))
file.copy(system.file( "skeleton", "zzz.R", package ="Rcpp"),
file.path(root, "R"))
message(" >> copied the example module file ")
}
lines <- readLines(package.doc <- file.path( root, "man", sprintf("%s-package.Rd", name)))
lines <- sub("~~ simple examples", "%% ~~ simple examples", lines)
lines <- lines[! grepl("~~ package title", lines)]
lines <- lines[! grepl("~~ The author and", lines)]
lines <- sub("Who wrote it", author, lines )
lines <- sub("Who to complain to.*", sprintf("%s <%s>", maintainer, email), lines)
writeLines(lines, package.doc)
if (fake) {
rm("Rcpp.fake.fun", envir = env)
unlink(file.path(root, "R" , "Rcpp.fake.fun.R"))
unlink(file.path(root, "man", "Rcpp.fake.fun.Rd"))
}
if (isTRUE(remove_hello_world)) {
rm("rcpp_hello_world", envir = env)
}
invisible(NULL)
}
rcpp-0.11.0/R/zzz.R 0000644 0000000 0000000 00000001567 12253723677 010633 0 ustar # Copyright (C) 2009 - 2013 Dirk Eddelbuettel and Romain Francois
#
# This file is part of Rcpp.
#
# Rcpp is free software: you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 2 of the License, or
# (at your option) any later version.
#
# Rcpp 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Rcpp. If not, see .
.dummyInstancePointer <- new.env() # just something permanent
.classes_map <- new.env()
.onLoad <- function(libname, pkgname){
new_dummyObject(.dummyInstancePointer);
}
rcpp-0.11.0/R/Module.R 0000644 0000000 0000000 00000037051 12273307750 011210 0 ustar # Copyright (C) 2010 - 2012 John Chambers, Dirk Eddelbuettel and Romain Francois
#
# This file is part of Rcpp.
#
# Rcpp is free software: you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 2 of the License, or
# (at your option) any later version.
#
# Rcpp 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Rcpp. If not, see .
internal_function <- function(pointer){
f <- function(xp){
force(xp)
function(...){
.External( InternalFunction_invoke, xp, ... )
}
}
o <- new( "C++Function", f(pointer) )
o@pointer <- pointer
o
}
setMethod("$", "C++Class", function(x, name) {
x <- x@generator
eval.parent(substitute(x$name))
})
.badModulePointer <- NULL
.setModulePointer <- function(module, value) {
assign("pointer", value, envir = as.environment(module))
value
}
.getModulePointer <- function(module, mustStart = TRUE) {
pointer <- get("pointer", envir = as.environment(module))
if(is.null(pointer) && mustStart) {
## should be (except for bug noted in identical())
## if(identical(pointer, .badModulePointer) && mustStart) {
Module(module, mustStart = TRUE) # will either initialize pointer or throw error
pointer <- get("pointer", envir = as.environment(module))
}
pointer
}
setMethod("initialize", "Module",
function(.Object,
moduleName = "UNKNOWN",
packageName = "",
pointer = .badModulePointer, ...) {
env <- new.env(TRUE, emptyenv())
as(.Object, "environment") <- env
assign("pointer", pointer, envir = env)
assign("packageName", packageName, envir = env)
assign("moduleName", moduleName, envir = env)
if(length(list(...)) > 0) {
.Object <- callNextMethod(.Object, ...)
}
.Object
})
.get_Module_function <- function(x, name, pointer = .getModulePointer(x) ){
pointer <- .getModulePointer(x)
info <- .Call( Module__get_function, pointer, name )
fun_ptr <- info[[1L]]
is_void <- info[[2L]]
doc <- info[[3L]]
sign <- info[[4L]]
formal_args <- info[[5L]]
nargs <- info[[6L]]
f <- function(...) NULL
if( nargs == 0L ) formals(f) <- NULL
stuff <- list( fun_pointer = fun_ptr, InternalFunction_invoke = InternalFunction_invoke )
body(f) <- if( nargs == 0L ){
if( is_void ) {
substitute( {
.External( InternalFunction_invoke, fun_pointer)
invisible(NULL)
}, stuff )
} else {
substitute( {
.External( InternalFunction_invoke, fun_pointer)
}, stuff )
}
} else {
if( is_void ) {
substitute( {
.External( InternalFunction_invoke, fun_pointer, ... )
invisible(NULL)
}, stuff )
} else {
substitute( {
.External( InternalFunction_invoke, fun_pointer, ... )
}, stuff )
}
}
out <- new( "C++Function", f, pointer = fun_ptr, docstring = doc, signature = sign )
if( ! is.null( formal_args ) ){
formals( out ) <- formal_args
}
out
}
.get_Module_Class <- function( x, name, pointer = .getModulePointer(x) ){
value <- .Call( Module__get_class, pointer, name )
value@generator <- get("refClassGenerators",envir=x)[[as.character(value)]]
value
}
setMethod( "$", "Module", function(x, name){
pointer <- .getModulePointer(x)
storage <- get( "storage", envir = as.environment(x) )
storage[[ name ]]
} )
new_CppObject_xp <- function(module, pointer, ...) {
.External( class__newInstance, module, pointer, ... )
}
new_dummyObject <- function(...)
.External( "class__dummyInstance", ...)
# class method for $initialize
cpp_object_initializer <- function(.self, .refClassDef, ..., .object_pointer){
selfEnv <- as.environment(.self)
## generate the C++-side object and store its pointer, etc.
## access the private fields in the fieldPrototypes env.
fields <- .refClassDef@fieldPrototypes
pointer <- if(missing(.object_pointer)) new_CppObject_xp(fields$.module, fields$.pointer, ...) else .object_pointer
assign(".module", fields$.module, envir = selfEnv)
assign(".pointer", pointer, envir = selfEnv)
assign(".cppclass", fields$.pointer, envir = selfEnv)
.self
}
cpp_object_dummy <- function(.self, .refClassDef) {
selfEnv <- as.environment(.self)
## like initializer but a dummy for the case of no default
## constructor. Will throw an error if the object is used.
fields <- .refClassDef@fieldPrototypes
pointer <- new_dummyObject()
assign(".module", fields$.module, envir = selfEnv)
assign(".pointer", pointer, envir = selfEnv)
assign(".cppclass", fields$.pointer, envir = selfEnv)
.self
}
cpp_object_maker <- function(typeid, pointer){
Class <- .classes_map[[ typeid ]]
new( Class, .object_pointer = pointer )
}
Module <- function( module, PACKAGE = methods::getPackageName(where), where = topenv(parent.frame()), mustStart = FALSE ) {
if(inherits(module, "DLLInfo") && missing(mustStart)) mustStart <- TRUE
if(inherits(module, "Module")) {
xp <- .getModulePointer(module, FALSE)
if(!missing(PACKAGE))
warning("ignoring PACKAGE argument in favor of internal package from Module object")
env <- as.environment(module) # not needed from R 2.12.0
PACKAGE <- get("packageName", envir = env)
moduleName <- get("moduleName", envir = env)
}
else if( identical( typeof( module ), "externalptr" ) ){
## [john] Should Module() ever be called with a pointer as argument?
## If so, we need a safe check of the pointer's validity
## [romain] I don't think we actually can, external pointers
## are stored as void*, they don't know what they are. Or we could
## perhaps keep a vector of all known module pointers
## [John] One technique is to initialize the pointer to a known value
## and just check whether it's been reset from that (bad) value
xp <- module
moduleName <- .Call( Module__name, xp )
module <- methods::new("Module", pointer = xp, packageName = PACKAGE,
moduleName = moduleName)
} else if(is.character(module)) {
moduleName <- module
xp <- .badModulePointer
module <- methods::new("Module", pointer = xp, packageName = PACKAGE,
moduleName = moduleName)
}
if(identical(xp, .badModulePointer)) {
if(mustStart) {
name <- sprintf( "_rcpp_module_boot_%s", moduleName )
symbol <- tryCatch(getNativeSymbolInfo( name, PACKAGE ),
error = function(e)e)
if(inherits(symbol, "error"))
stop(gettextf("Failed to initialize module pointer: %s",
symbol), domain = NA)
xp <- .Call( symbol )
.setModulePointer(module, xp)
}
else
return(module)
}
classes <- .Call( Module__classes_info, xp )
## We need a general strategy for assigning class defintions
## since delaying the initialization of the module causes
## where to be the Rcpp namespace:
if(environmentIsLocked(where))
where <- .GlobalEnv # or???
generators <- list()
storage <- new.env()
for( i in seq_along(classes) ){
CLASS <- classes[[i]]
clname <- as.character(CLASS)
fields <- cpp_fields( CLASS, where )
methods <- cpp_refMethods(CLASS, where)
generator <- methods::setRefClass( clname,
fields = fields,
contains = "C++Object",
methods = methods,
where = where
)
# just to make codetools happy
.self <- .refClassDef <- NULL
generator$methods(initialize =
if(cpp_hasDefaultConstructor(CLASS))
function(...) cpp_object_initializer(.self,.refClassDef, ...)
else
function(...) {
if(nargs()) cpp_object_initializer(.self,.refClassDef, ...)
else cpp_object_dummy(.self, .refClassDef)
}
)
rm( .self, .refClassDef )
classDef <- methods::getClass(clname)
## non-public (static) fields in class representation
## Should these become real fields?
fields <- classDef@fieldPrototypes
assign(".pointer", CLASS@pointer, envir = fields)
assign(".module", xp, envir = fields)
assign(".CppClassName", clname, envir = fields)
generators[[clname]] <- generator
# [romain] : should this be promoted to reference classes
# perhaps with better handling of j and ... arguments
if( any( grepl( "^[[]", names(CLASS@methods) ) ) ){
if( "[[" %in% names( CLASS@methods ) ){
methods::setMethod( "[[", clname, function(x, i, j, ..., exact = TRUE){
x$`[[`( i )
}, where = where )
}
if( "[[<-" %in% names( CLASS@methods ) ){
methods::setReplaceMethod( "[[", clname, function(x, i, j, ..., exact = TRUE, value){
x$`[[<-`( i, value )
x
} , where = where )
}
}
# promoting show to S4
if( any( grepl( "show", names(CLASS@methods) ) ) ){
setMethod( "show", clname, function(object) object$show(), where = where )
}
}
if(length(classes)) {
module$refClassGenerators <- generators
}
for( i in seq_along(classes) ){
CLASS <- classes[[i]]
clname <- as.character(CLASS)
demangled_name <- sub( "^Rcpp_", "", clname )
.classes_map[[ CLASS@typeid ]] <- storage[[ demangled_name ]] <- .get_Module_Class( module, demangled_name, xp )
# exposing enums values as CLASS.VALUE
# (should really be CLASS$value but I don't know how to do it)
if( length( CLASS@enums ) ){
for( enum in CLASS@enums ){
for( i in 1:length(enum) ){
storage[[ paste( demangled_name, ".", names(enum)[i], sep = "" ) ]] <- enum[i]
}
}
}
}
# functions
functions <- .Call( Module__functions_names, xp )
for( fun in functions ){
storage[[ fun ]] <- .get_Module_function( module, fun, xp )
# register as(FROM, TO) methods
converter_rx <- "^[.]___converter___(.*)___(.*)$"
if( length( matches <- grep( converter_rx, functions ) ) ){
for( i in matches ){
fun <- functions[i]
from <- sub( converter_rx, "\\1", fun )
to <- sub( converter_rx, "\\2", fun )
converter <- function( from ){}
body( converter ) <- substitute( { CONVERT(from) },
list( CONVERT = storage[[fun]] )
)
setAs( from, to, converter, where = where )
}
}
}
assign( "storage", storage, envir = as.environment(module) )
module
}
dealWith <- function( x ) if(isTRUE(x[[1]])) invisible(NULL) else x[[2]]
method_wrapper <- function( METHOD, where ){
noargs <- all( METHOD$nargs == 0 )
stuff <- list(
class_pointer = METHOD$class_pointer,
pointer = METHOD$pointer,
CppMethod__invoke = CppMethod__invoke,
CppMethod__invoke_void = CppMethod__invoke_void,
CppMethod__invoke_notvoid = CppMethod__invoke_notvoid,
dealWith = dealWith,
docstring = METHOD$info("")
)
f <- function(...) NULL
if( noargs ){
formals(f) <- NULL
}
extCall <- if( noargs ) {
if( all( METHOD$void ) ){
# all methods are void, so we know we want to return invisible(NULL)
substitute(
{
docstring
.External(CppMethod__invoke_void, class_pointer, pointer, .pointer )
invisible(NULL)
} , stuff )
} else if( all( ! METHOD$void ) ){
# none of the methods are void so we always return the result of
# .External
substitute(
{
docstring
.External(CppMethod__invoke_notvoid, class_pointer, pointer, .pointer )
} , stuff )
} else {
# some are void, some are not, so the voidness is part of the result
# we get from internally and we need to deal with it
substitute(
{
docstring
dealWith( .External(CppMethod__invoke, class_pointer, pointer, .pointer ) )
} , stuff )
}
} else {
if( all( METHOD$void ) ){
# all methods are void, so we know we want to return invisible(NULL)
substitute(
{
docstring
.External(CppMethod__invoke_void, class_pointer, pointer, .pointer, ...)
invisible(NULL)
} , stuff )
} else if( all( ! METHOD$void ) ){
# none of the methods are void so we always return the result of
# .External
substitute(
{
docstring
.External(CppMethod__invoke_notvoid, class_pointer, pointer, .pointer, ...)
} , stuff )
} else {
# some are void, some are not, so the voidness is part of the result
# we get from internally and we need to deal with it
substitute(
{
docstring
dealWith( .External(CppMethod__invoke, class_pointer, pointer, .pointer, ...) )
} , stuff )
}
}
body(f, where) <- extCall
f
}
## create a named list of the R methods to invoke C++ methods
## from the C++ class with pointer xp
cpp_refMethods <- function(CLASS, where) {
finalizer <- eval( substitute(
function(){
.Call( CppObject__finalize, class_pointer , .pointer )
},
list(
CLASS = CLASS@pointer,
CppObject__finalize = CppObject__finalize,
class_pointer = CLASS@pointer
)
) )
mets <- c(
sapply( CLASS@methods, method_wrapper, where = where ),
"finalize" = finalizer
)
mets
}
cpp_hasDefaultConstructor <- function(CLASS) {
.Call( Class__has_default_constructor, CLASS@pointer )
}
binding_maker <- function( FIELD, where ){
f <- function( x ) NULL
body(f) <- substitute({
if( missing( x ) )
.Call( CppField__get, class_pointer, pointer, .pointer)
else
.Call( CppField__set, class_pointer, pointer, .pointer, x)
}, list(class_pointer = FIELD$class_pointer,
pointer = FIELD$pointer,
CppField__get = CppField__get,
CppField__set = CppField__set ))
environment(f) <- where
f
}
cpp_fields <- function( CLASS, where){
sapply( CLASS@fields, binding_maker, where = where )
}
.CppClassName <- function(name)
paste0("Rcpp_",name)
rcpp-0.11.0/R/02_completion.R 0000644 0000000 0000000 00000003234 12253723677 012441 0 ustar # Copyright (C) 2010 - 2011 John Chambers, Dirk Eddelbuettel and Romain Francois
#
# This file is part of Rcpp.
#
# Rcpp is free software: you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 2 of the License, or
# (at your option) any later version.
#
# Rcpp 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Rcpp. If not, see .
setGeneric( ".DollarNames" )
.DollarNames.Module <- function(x, pattern){
pointer <- .getModulePointer( x )
if(identical(pointer, .badModulePointer)) {
stop( "unitialized module" )
}
grep( pattern , .Call( Module__complete, pointer), value = TRUE )
}
setMethod( ".DollarNames", "Module", .DollarNames.Module )
# completion for C++ objects
# do we actually need this or do we get it for free via setRefClass, etc ...
setGeneric( "complete", function(x) standardGeneric("complete") )
setMethod( "complete", "C++Object", function(x){
xp <- get(".cppclass", envir = as.environment(x))
# FIXME: implement another test
# if(identical(xp, .emptyPointer))
# stop("C++ object with unset pointer to C++ class")
.Call( CppClass__complete , xp )
} )
".DollarNames.C++Object" <- function( x, pattern ){
grep( pattern, complete(x), value = TRUE )
}
setMethod( ".DollarNames", "C++Object", `.DollarNames.C++Object` )
rcpp-0.11.0/R/unit.tests.R 0000644 0000000 0000000 00000003303 12273213514 012066 0 ustar # Copyright (C) 2010 - 2014 Dirk Eddelbuettel and Romain Francois
#
# This file is part of Rcpp.
#
# Rcpp is free software: you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 2 of the License, or
# (at your option) any later version.
#
# Rcpp 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Rcpp. If not, see .
test <- function(output=if(file.exists("/tmp")) "/tmp" else getwd()) {
if (require(RUnit)) {
testSuite <- defineTestSuite(name="Rcpp Unit Tests",
dirs=system.file("unitTests", package = "Rcpp"),
testFuncRegexp = "^[Tt]est.+")
## if someoone calls Rcpp::test(), he/she wants all tests
Sys.setenv("RunAllRcppTests"="yes")
## Run tests
tests <- runTestSuite(testSuite)
## Print results
printTextProtocol(tests)
return(tests)
}
stop("Running unit tests requires the 'RUnit' package.")
}
unitTestSetup <- function(file, packages=NULL,
pathToRcppTests=system.file("unitTests", package = "Rcpp")) {
function() {
if (! is.null(packages)) {
for (p in packages) {
suppressMessages(require(p, character.only=TRUE))
}
}
sourceCpp(file.path(pathToRcppTests, "cpp", file))
}
}
rcpp-0.11.0/R/loadRcppModules.R 0000644 0000000 0000000 00000004257 12253723677 013072 0 ustar # Copyright (C) 2010 - 2012 John Chambers, Dirk Eddelbuettel and Romain Francois
#
# This file is part of Rcpp.
#
# Rcpp is free software: you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 2 of the License, or
# (at your option) any later version.
#
# Rcpp 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Rcpp. If not, see .
loadRcppModules <- function(direct=TRUE){
## hunt for the namespace of the package that calls this
calls <- sys.calls()
w <- which( sapply( calls, function(call){
identical( call[[1L]], as.name( "runHook" ) )
} ) )
if( !length(w) )
stop( "loadRcppModules can only be used within a .onLoad function" )
w <- w[ length(w) ]
call <- calls[[w]]
if( !identical( call[[2L]], ".onLoad" ) )
stop( "loadRcppModules can only be used within a .onLoad function" )
f <- sys.frame( w )
ns <- get("env", f )
if( !isNamespace( ns ) )
stop( "loadRcppModules not called from a namespace" )
pkg <- get( "pkgname", f )
lib <- get( "libname", f )
## look for declared modules in the DESCRIPTION fields
description <- packageDescription(pkg, lib.loc=lib)
modules <- description[["RcppModules"]]
if( !is.null( modules ) ){
modules <- strsplit( modules, "[[:space:]]*,[[:space:]]*")[[1L]]
for( m in modules ){
tryCatch( {
mod <- Module( m, pkg, mustStart = TRUE)
if(isTRUE(direct)){
populate( mod, ns )
} else {
forceAssignInNamespace( m, mod, ns )
}
assign(.moduleMetaName(m), mod, envir = ns)
}, error = function(e){
stop( sprintf( "failed to load module %s from package %s\n%s", m, pkg, conditionMessage(e) ) )
})
}
}
}
rcpp-0.11.0/R/bib.R 0000644 0000000 0000000 00000001451 12253723677 010522 0 ustar # Copyright (C) 2010 - 2012 Dirk Eddelbuettel and Romain Francois
#
# This file is part of Rcpp.
#
# Rcpp is free software: you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 2 of the License, or
# (at your option) any later version.
#
# Rcpp 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Rcpp. If not, see .
bib <- function() {
sub("\\.bib$", "", system.file( "doc", "Rcpp.bib", package = "Rcpp" ) )
}
rcpp-0.11.0/R/03_prompt.R 0000644 0000000 0000000 00000004471 12253723677 011616 0 ustar # Copyright (C) 2010 - 2011 John Chambers, Dirk Eddelbuettel and Romain Francois
#
# This file is part of Rcpp.
#
# Rcpp is free software: you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 2 of the License, or
# (at your option) any later version.
#
# Rcpp 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Rcpp. If not, see .
setGeneric( "functions", function(object, ...) standardGeneric( "functions" ) )
setMethod( "functions", "Module", function(object, ...){
pointer <- .getModulePointer(object)
if(identical(pointer, .badModulePointer))
stop(gettextf("Module \"%s\" has not been intialized: try Module(object)",
get("moduleName", envir = as.environment(object))), domain = NA)
else
.Call( Module__functions_arity, pointer )
} )
setGeneric( "prompt" )
setMethod( "prompt", "Module", function(object, filename = NULL, name = NULL, ...){
lines <- readLines( system.file( "prompt", "module.Rd", package = "Rcpp" ) )
pointer <- .getModulePointer(object)
if( is.null(name) )
name <- .Call( Module__name, pointer )
if( is.null(filename) ) filename <- sprintf( "%s-module.Rd", name )
lines <- gsub( "NAME", name, lines )
info <- functions( object )
f.txt <- if( length( info ) ){
sprintf( "functions: \\\\describe{
%s
}", paste( sprintf( " \\\\item{%s}{ ~~ description of function %s ~~ }", names(info), names(info) ), collapse = "\n" ) )
} else {
""
}
lines <- sub( "FUNCTIONS", f.txt, lines )
## at this point functions() would have failed if the
## pointer in object was not valid
classes <- .Call( Module__classes_info, pointer )
c.txt <- if( length( classes ) ){
sprintf( "classes: \\\\describe{
%s
}", paste( sprintf( " \\\\item{%s}{ ~~ description of class %s ~~ }", names(classes), names(classes) ), collapse = "\n" ) )
} else {
""
}
lines <- sub( "CLASSES", c.txt, lines )
writeLines( lines, filename )
invisible(NULL)
} )
rcpp-0.11.0/R/Attributes.R 0000644 0000000 0000000 00000076363 12273452010 012110 0 ustar # Copyright (C) 2012 JJ Allaire, Dirk Eddelbuettel and Romain Francois
#
# This file is part of Rcpp.
#
# Rcpp is free software: you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 2 of the License, or
# (at your option) any later version.
#
# Rcpp 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Rcpp. If not, see .
# Source C++ code from a file
sourceCpp <- function(file = "",
code = NULL,
env = globalenv(),
embeddedR = TRUE,
rebuild = FALSE,
showOutput = verbose,
verbose = getOption("verbose")) {
# resolve code into a file if necessary. also track the working
# directory to source the R embedded code chunk within
if (!missing(code)) {
rWorkingDir <- getwd()
file <- tempfile(fileext = ".cpp")
con <- file(file, open = "w")
writeLines(code, con)
close(con)
} else {
rWorkingDir <- dirname(file)
}
# resolve the file path
file <- normalizePath(file, winslash = "/")
# error if the file extension isn't one supported by R CMD SHLIB
if (! tools::file_ext(file) %in% c("cc", "cpp")) {
stop("The filename '", basename(file), "' does not have an ",
"extension of .cc or .cpp so cannot be compiled.")
}
# validate that there are no spaces in the path on windows
if (.Platform$OS.type == "windows") {
if (grepl(' ', basename(file), fixed=TRUE)) {
stop("The filename '", basename(file), "' contains spaces. This ",
"is not permitted.")
}
}
# get the context (does code generation as necessary)
context <- .Call("sourceCppContext", PACKAGE="Rcpp",
file, code, rebuild, .Platform)
# perform a build if necessary
if (context$buildRequired || rebuild) {
# print output for verbose mode
if (verbose)
.printVerboseOutput(context)
# variables used to hold completed state (passed to completed hook)
succeeded <- FALSE
output <- NULL
# build dependency list
depends <- .getSourceCppDependencies(context$depends, file)
# validate packages (error if package not found)
.validatePackages(depends, context$cppSourceFilename)
# temporarily modify environment for the build
envRestore <- .setupBuildEnvironment(depends, context$plugins, file)
# temporarily setwd to build directory
cwd <- getwd()
setwd(context$buildDirectory)
# call the onBuild hook. note that this hook should always be called
# after .setupBuildEnvironment so subscribers are able to examine
# the build environment
fromCode <- !missing(code)
if (!.callBuildHook(context$cppSourcePath, fromCode, showOutput)) {
.restoreEnvironment(envRestore)
setwd(cwd)
return (invisible(NULL))
}
# on.exit handler calls hook and restores environment and working dir
on.exit({
if (!succeeded)
.showBuildFailureDiagnostics()
.callBuildCompleteHook(succeeded, output)
setwd(cwd)
.restoreEnvironment(envRestore)
})
# unload and delete existing dylib if necessary
if (file.exists(context$previousDynlibPath)) {
try(silent=T, dyn.unload(context$previousDynlibPath))
file.remove(context$previousDynlibPath)
}
# prepare the command (output if we are in showOutput mode)
cmd <- paste(R.home(component="bin"), .Platform$file.sep, "R ",
"CMD SHLIB ",
"-o ", shQuote(context$dynlibFilename), " ",
ifelse(rebuild, "--preclean ", ""),
shQuote(context$cppSourceFilename), sep="")
if (showOutput)
cat(cmd, "\n")
# execute the build -- suppressWarnings b/c when showOutput = FALSE
# we are going to explicitly check for an error and print the output
result <- suppressWarnings(system(cmd, intern = !showOutput))
# check build results
if(!showOutput) {
# capture output
output <- result
attributes(output) <- NULL
# examine status
status <- attr(result, "status")
if (!is.null(status)) {
cat(result, "\n")
succeeded <- FALSE
stop("Error ", status, " occurred building shared library.")
} else if (!file.exists(context$dynlibFilename)) {
cat(result, "\n")
succeeded <- FALSE
stop("Error occurred building shared library.")
} else {
succeeded <- TRUE
}
}
else if (!identical(as.character(result), "0")) {
succeeded <- FALSE
stop("Error ", result, " occurred building shared library.")
} else {
succeeded <- TRUE
}
}
else {
if (verbose)
cat("\nNo rebuild required (use rebuild = TRUE to ",
"force a rebuild)\n\n", sep="")
}
# load the module if we have exported symbols
if (length(context$exportedFunctions) > 0 || length(context$modules) > 0) {
# remove existing objects of the same name from the environment
exports <- c(context$exportedFunctions, context$modules)
removeObjs <- exports[exports %in% ls(envir = env, all.names = T)]
remove(list = removeObjs, envir = env)
# source the R script
scriptPath <- file.path(context$buildDirectory, context$rSourceFilename)
source(scriptPath, local = env)
} else if (getOption("rcpp.warnNoExports", default=TRUE)) {
warning("No Rcpp::export attributes or RCPP_MODULE declarations ",
"found in source")
}
# source the embeddedR
if (embeddedR && (length(context$embeddedR) > 0)) {
srcConn <- textConnection(context$embeddedR)
setwd(rWorkingDir) # will be reset by previous on.exit handler
source(file=srcConn, echo=TRUE)
}
# return (invisibly) a list containing exported functions and modules
invisible(list(functions = context$exportedFunctions,
modules = context$modules))
}
# Define a single C++ function
cppFunction <- function(code,
depends = character(),
plugins = character(),
includes = character(),
env = parent.frame(),
rebuild = FALSE,
showOutput = verbose,
verbose = getOption("verbose")) {
# process depends
if (!is.null(depends) && length(depends) > 0) {
depends <- paste(depends, sep=", ")
scaffolding <- paste("// [[Rcpp::depends(", depends, ")]]", sep="")
scaffolding <- c(scaffolding, "", .linkingToIncludes(depends, FALSE),
recursive=TRUE)
}
else {
scaffolding <- "#include "
}
# process plugins
if (!is.null(plugins) && length(plugins) > 0) {
plugins <- paste(plugins, sep=", ")
pluginsAttrib <- paste("// [[Rcpp::plugins(", plugins, ")]]", sep="")
scaffolding <- c(scaffolding, pluginsAttrib)
# append plugin includes
for (pluginName in plugins) {
plugin <- .findPlugin(pluginName)
settings <- plugin()
scaffolding <- c(scaffolding, settings$includes, recursive=TRUE)
}
}
# remainder of scaffolding
scaffolding <- c(scaffolding,
"",
"using namespace Rcpp;",
"",
includes,
"// [[Rcpp::export]]",
recursive = T)
# prepend scaffolding to code
code <- paste(c(scaffolding, code, recursive = T), collapse="\n")
# print the generated code if we are in verbose mode
if (verbose) {
cat("\nGenerated code for function definition:",
"\n--------------------------------------------------------\n\n")
cat(code)
cat("\n")
}
# source cpp into specified environment. if env is set to NULL
# then create a new one (the caller can get a hold of the function
# via the return value)
if (is.null(env))
env <- new.env()
exported <- sourceCpp(code = code,
env = env,
rebuild = rebuild,
showOutput = showOutput,
verbose = verbose)
# verify that a single function was exported and return it
if (length(exported$functions) == 0)
stop("No function definition found")
else if (length(exported$functions) > 1)
stop("More than one function definition")
else {
functionName <- exported$functions[[1]]
invisible(get(functionName, env))
}
}
.type_manipulate <- function( what = "DEMANGLE", class = NULL ) {
function( type = "int", ... ){
code <- sprintf( '
SEXP manipulate_this_type(){
typedef %s type ;
return wrap( %s(type) ) ;
}', type, what )
dots <- list( code, ... )
dots[["env"]] <- environment()
manipulate_this_type <- do.call( cppFunction, dots )
res <- manipulate_this_type()
if( ! is.null(class) ){
class(res) <- class
}
res
}
}
demangle <- .type_manipulate( "DEMANGLE" )
sizeof <- .type_manipulate( "sizeof", "bytes" )
print.bytes <- function( x, ...){
writeLines( sprintf( "%d bytes (%d bits)", x, 8 * x ) )
invisible( x )
}
# Evaluate a simple c++ expression
evalCpp <- function(code,
depends = character(),
includes = character(),
rebuild = FALSE,
showOutput = verbose,
verbose = getOption( "verbose" ) ){
code <- sprintf( "SEXP get_value(){ return wrap( %s ) ; }", code )
env <- new.env()
cppFunction(code, depends = depends, includes = includes, env = env,
rebuild = rebuild, showOutput = showOutput, verbose = verbose )
fun <- env[["get_value"]]
fun()
}
areMacrosDefined <- function(names,
depends = character(),
includes = character(),
rebuild = FALSE,
showOutput = verbose,
verbose = getOption( "verbose" ) ){
code <- sprintf( '
LogicalVector get_value(){
return LogicalVector::create(
%s
) ;
}',
paste( sprintf( ' _["%s"] =
#if defined(%s)
true
#else
false
#endif
', names, names ), collapse = ",\n" )
)
env <- new.env()
cppFunction(code, depends = depends, includes = includes, env = env,
rebuild = rebuild, showOutput = showOutput, verbose = verbose )
fun <- env[["get_value"]]
fun()
}
# Scan the source files within a package for attributes and generate code
# based on the attributes.
compileAttributes <- function(pkgdir = ".", verbose = getOption("verbose")) {
# verify this is a package and read the DESCRIPTION to get it's name
pkgdir <- normalizePath(pkgdir, winslash = "/")
descFile <- file.path(pkgdir,"DESCRIPTION")
if (!file.exists(descFile))
stop("pkgdir must refer to the directory containing an R package")
pkgDesc <- read.dcf(descFile)[1,]
pkgname = .readPkgDescField(pkgDesc, "Package")
depends <- .readPkgDescField(pkgDesc, "Depends", character())
depends <- unique(.splitDepends(depends))
depends <- depends[depends != "R"]
# determine source directory
srcDir <- file.path(pkgdir, "src")
if (!file.exists(srcDir))
return (FALSE)
# create R directory if it doesn't already exist
rDir <- file.path(pkgdir, "R")
if (!file.exists(rDir))
dir.create(rDir)
# get a list of all source files
cppFiles <- list.files(srcDir, pattern="\\.c(c|pp)$")
# derive base names (will be used for modules)
cppFileBasenames <- tools::file_path_sans_ext(cppFiles)
# expend them to their full paths
cppFiles <- file.path(srcDir, cppFiles)
cppFiles <- normalizePath(cppFiles, winslash = "/")
# generate the includes list based on LinkingTo. Specify plugins-only
# because we only need as/wrap declarations
linkingTo <- .readPkgDescField(pkgDesc, "LinkingTo")
includes <- .linkingToIncludes(linkingTo, TRUE)
# if a master include file is defined for the package then include it
pkgHeader <- paste(pkgname, ".h", sep="")
pkgHeaderPath <- file.path(pkgdir, "inst", "include", pkgHeader)
if (file.exists(pkgHeaderPath)) {
pkgInclude <- paste("#include \"../inst/include/",
pkgHeader, "\"", sep="")
includes <- c(pkgInclude, includes)
}
# generate exports
invisible(.Call("compileAttributes", PACKAGE="Rcpp",
pkgdir, pkgname, depends, cppFiles, cppFileBasenames,
includes, verbose, .Platform))
}
# setup plugins environment
.plugins <- new.env()
# built-in C++11 plugin
.plugins[["cpp11"]] <- function() {
list(env = list(PKG_CXXFLAGS ="-std=c++11"))
}
## built-in OpenMP++11 plugin
.plugins[["openmp"]] <- function() {
list(env = list(PKG_CXXFLAGS="-fopenmp",
PKG_LIBS="-fopenmp"))
}
# register a plugin
registerPlugin <- function(name, plugin) {
.plugins[[name]] <- plugin
}
# Take an empty function body and connect it to the specified external symbol
sourceCppFunction <- function(func, isVoid, dll, symbol) {
args <- names(formals(func))
body <- quote( CALL_PLACEHOLDER ( EXTERNALNAME, ARG ) )[ c(1:2, rep(3, length(args))) ]
for (i in seq(along = args))
body[[i+2]] <- as.symbol(args[i])
body[[1L]] <- .Call
body[[2L]] <- getNativeSymbolInfo(symbol, dll)$address
if (isVoid)
body <- call("invisible", body)
body(func) <- body
func
}
# Print verbose output
.printVerboseOutput <- function(context) {
cat("\nGenerated extern \"C\" functions",
"\n--------------------------------------------------------\n")
cat(context$generatedCpp, sep="")
cat("\nGenerated R functions",
"\n-------------------------------------------------------\n\n")
cat(readLines(file.path(context$buildDirectory,
context$rSourceFilename)),
sep="\n")
cat("\nBuilding shared library",
"\n--------------------------------------------------------\n",
"\nDIR: ", context$buildDirectory, "\n\n", sep="")
}
# Add LinkingTo dependencies if the sourceFile is in a package
.getSourceCppDependencies <- function(depends, sourceFile) {
# If the source file is in a package then simulate it being built
# within the package by including it's LinkingTo dependencies,
# the src directory (.), and the inst/include directory
if (.isPackageSourceFile(sourceFile)) {
descFile <- file.path(dirname(sourceFile), "..", "DESCRIPTION")
DESCRIPTION <- read.dcf(descFile, all = TRUE)
linkingTo <- .parseLinkingTo(DESCRIPTION$LinkingTo)
unique(c(depends, linkingTo))
} else {
depends
}
}
# Check whether a source file is in a package
.isPackageSourceFile <- function(sourceFile) {
file.exists(file.path(dirname(sourceFile), "..", "DESCRIPTION"))
}
# Error if a package is not currently available
.validatePackages <- function(depends, sourceFilename) {
unavailable <- depends[!depends %in% .packages(all.available=TRUE)]
if (length(unavailable) > 0) {
stop(paste("Package '", unavailable[[1]], "' referenced from ",
"Rcpp::depends in source file ",
sourceFilename, " is not available.",
sep=""),
call. = FALSE)
}
}
# Split the depends field of a package description
.splitDepends <- function(x) {
if (!length(x))
return(character())
x <- unlist(strsplit(x, ","))
x <- sub("[[:space:]]+$", "", x)
x <- unique(sub("^[[:space:]]*(.*)", "\\1", x))
sub("^([[:alnum:].]+).*$", "\\1", x)
}
# read a field from a named package description character vector
.readPkgDescField <- function(pkgDesc, name, default = NULL) {
if (name %in% names(pkgDesc))
pkgDesc[[name]]
else
default
}
# Get the inline plugin for the specified package (return NULL if none found)
.getInlinePlugin <- function(package) {
tryCatch(get("inlineCxxPlugin", asNamespace(package)),
error = function(e) NULL)
}
# Lookup a plugin
.findPlugin <- function(pluginName) {
plugin <- .plugins[[pluginName]]
if (is.null(plugin))
stop("Inline plugin '", pluginName, "' could not be found ",
"within the Rcpp package. You should be ",
"sure to call registerPlugin before using a plugin.")
return(plugin)
}
# Setup the build environment based on the specified dependencies. Returns an
# opaque object that can be passed to .restoreEnvironment to reverse whatever
# changes that were made
.setupBuildEnvironment <- function(depends, plugins, sourceFile) {
# setup
buildEnv <- list()
linkingToPackages <- c("Rcpp")
# merge values into the buildEnv
mergeIntoBuildEnv <- function(name, value) {
# protect against null or empty string
if (is.null(value) || !nzchar(value))
return;
# if it doesn't exist already just set it
if (is.null(buildEnv[[name]])) {
buildEnv[[name]] <<- value
}
# if it's not identical then append
else if (!identical(buildEnv[[name]], value)) {
buildEnv[[name]] <<- paste(buildEnv[[name]], value);
}
else {
# it already exists and it's the same value, this
# likely means it's a flag-type variable so we
# do nothing rather than appending it
}
}
# update dependencies from a plugin
setDependenciesFromPlugin <- function(plugin) {
# get the plugin settings
settings <- plugin()
# merge environment variables
pluginEnv <- settings$env
for (name in names(pluginEnv)) {
mergeIntoBuildEnv(name, pluginEnv[[name]])
}
# capture any LinkingTo elements defined by the plugin
linkingToPackages <<- unique(c(linkingToPackages,
settings$LinkingTo))
}
# add packages to linkingTo and introspect for plugins
for (package in depends) {
# add a LinkingTo for this package
linkingToPackages <- unique(c(linkingToPackages, package))
# see if the package exports a plugin
plugin <- .getInlinePlugin(package)
if (!is.null(plugin))
setDependenciesFromPlugin(plugin)
}
# process plugins
for (pluginName in plugins) {
plugin <- .findPlugin(pluginName)
setDependenciesFromPlugin(plugin)
}
# if there is no buildEnv from a plugin then use the Rcpp plugin
if (length(buildEnv) == 0) {
buildEnv <- inlineCxxPlugin()$env
}
# set CLINK_CPPFLAGS based on the LinkingTo dependencies
buildEnv$CLINK_CPPFLAGS <- .buildClinkCppFlags(linkingToPackages)
# if the source file is in a package then add src and inst/include
if (.isPackageSourceFile(sourceFile)) {
srcDir <- dirname(sourceFile)
srcDir <- asBuildPath(srcDir)
incDir <- file.path(dirname(sourceFile), "..", "inst", "include")
incDir <- asBuildPath(incDir)
dirFlags <- paste0('-I"', c(srcDir, incDir), '"', collapse=" ")
buildEnv$CLINK_CPPFLAGS <- paste(buildEnv$CLINK_CPPFLAGS,
dirFlags,
collapse=" ")
}
# merge existing environment variables
for (name in names(buildEnv))
mergeIntoBuildEnv(name, Sys.getenv(name))
# add cygwin message muffler
buildEnv$CYGWIN = "nodosfilewarning"
# on windows see if we need to add Rtools to the path
# (don't do this for RStudio since it has it's own handling)
if (identical(Sys.info()[['sysname']], "Windows") &&
!nzchar(Sys.getenv("RSTUDIO"))) {
path <- .pathWithRtools()
if (!is.null(path))
buildEnv$PATH <- path
}
# create restore list
restore <- list()
for (name in names(buildEnv))
restore[[name]] <- Sys.getenv(name, unset = NA)
# set environment variables
do.call(Sys.setenv, buildEnv)
# return restore list
return (restore)
}
# If we don't have the GNU toolchain already on the path then see if
# we can find Rtools and add it to the path
.pathWithRtools <- function() {
# Only proceed if we don't have the required tools on the path
hasRtools <- nzchar(Sys.which("ls.exe")) && nzchar(Sys.which("gcc.exe"))
if (!hasRtools) {
# Read the Rtools registry key
key <- NULL
try(key <- utils::readRegistry("SOFTWARE\\R-core\\Rtools",
hive = "HLM", view = "32-bit"),
silent = TRUE)
# If we found the key examine it
if (!is.null(key)) {
# Check version -- we only support 2.15 and 2.16 right now
ver <- key$`Current Version`
if (identical("2.15", ver) || identical("2.16", ver) ||
identical("3.0", ver) || identical("3.1", ver)) {
# See if the InstallPath leads to the expected directories
rToolsPath <- key$`InstallPath`
if (!is.null(rToolsPath)) {
# Return modified PATH if execpted directories exist
binPath <- file.path(rToolsPath, "bin", fsep="\\")
gccPath <- file.path(rToolsPath, "gcc-4.6.3", "bin", fsep="\\")
if (file.exists(binPath) && file.exists(gccPath))
return(paste(binPath,
gccPath,
Sys.getenv("PATH"),
sep=.Platform$path.sep))
}
}
}
}
return(NULL)
}
# Build CLINK_CPPFLAGS from include directories of LinkingTo packages
.buildClinkCppFlags <- function(linkingToPackages) {
pkgCxxFlags <- NULL
for (package in linkingToPackages) {
packagePath <- find.package(package, NULL, quiet=TRUE)
packagePath <- asBuildPath(packagePath)
pkgCxxFlags <- paste(pkgCxxFlags,
paste0('-I"', packagePath, '/include"'),
collapse=" ")
}
return (pkgCxxFlags)
}
.restoreEnvironment <- function(restore) {
# variables to reset
setVars <- restore[!is.na(restore)]
if (length(setVars))
do.call(Sys.setenv, setVars)
# variables to remove
removeVars <- names(restore[is.na(restore)])
if (length(removeVars))
Sys.unsetenv(removeVars)
}
# Call the onBuild hook. This hook is provided so that external tools
# can perform processing (e.g. lint checking or other diagnostics) prior
# to the execution of a build). The showOutput flag is there to inform the
# subscriber whether they'll be getting output in the onBuildComplete hook
# or whether it will need to be scraped from the console (for verbose=TRUE)
# The onBuild hook is always called from within the temporary build directory
.callBuildHook <- function(file, fromCode, showOutput) {
for (fun in .getHooksList("sourceCpp.onBuild")) {
if (is.character(fun))
fun <- get(fun)
# allow the hook to cancel the build (errors in the hook explicitly
# do not cancel the build since they are unexpected bugs)
continue <- tryCatch(fun(file, fromCode, showOutput),
error = function(e) TRUE)
if (!continue)
return (FALSE)
}
return (TRUE)
}
# Call the onBuildComplete hook. This hook is provided so that external tools
# can do analysis of build errors and (for example) present them in a
# navigable list. Note that the output parameter will be NULL when showOutput
# is TRUE. Tools can try to scrape the output from the console (in an
# implemenentation-dependent fashion) or can simply not rely on output
# processing in that case (since the user explicitly asked for output to be
# printed to the console). The onBuildCompleted hook is always called within
# the temporary build directory.
.callBuildCompleteHook <- function(succeeded, output) {
# Call the hooks in reverse order to align sequencing with onBuild
for (fun in .getHooksList("sourceCpp.onBuildComplete")) {
if (is.character(fun))
fun <- get(fun)
try(fun(succeeded, output))
}
}
# The value for getHooks can be a single function or a list of functions,
# This function ensures that the result can always be processed as a list
.getHooksList <- function(name) {
hooks <- getHook(name)
if (!is.list(hooks))
hooks <- list(hooks)
hooks
}
# Generate list of includes based on LinkingTo. The pluginsOnly parameter
# to distinguish the case of capturing all includes needed for a compiliation
# (e.g. cppFunction) verses only needing to capture as/wrap converters which
# is the case for generation of shims (RcppExports.cpp) and Rcpp::interfaces
# package header files.
.linkingToIncludes <- function(linkingTo, pluginsOnly) {
# This field can be NULL or empty -- in that case just return Rcpp.h
if (is.null(linkingTo) || !nzchar(linkingTo))
return (c("#include "))
# Look for Rcpp inline plugins within the list or LinkedTo packages
include.before <- character()
include.after <- character()
linkingToPackages <- .parseLinkingTo(linkingTo)
for (package in linkingToPackages) {
# We already handle Rcpp internally
if (identical(package, "Rcpp"))
next
# see if there is a plugin that we can extract includes from
plugin <- .getInlinePlugin(package)
if (!is.null(plugin)) {
includes <- .pluginIncludes(plugin)
if (!is.null(includes)) {
include.before <- c(include.before, includes$before)
include.after <- c(include.after, includes$after)
}
}
# otherwise check for standard Rcpp::interfaces generated include
else if (!pluginsOnly) {
pkgPath <- find.package(package, NULL, quiet=TRUE)
pkgHeader <- paste(package, ".h", sep="")
pkgHeaderPath <- file.path(pkgPath, "include", pkgHeader)
if (file.exists(pkgHeaderPath)) {
pkgInclude <- paste("#include <", pkgHeader, ">", sep="")
include.after <- c(include.after, pkgInclude)
}
}
}
# return the includes
c(include.before, "#include ", include.after)
}
# Analyze the plugin's includes field to determine include.before and
# include.after. We are ONLY interested in plugins that work with Rcpp since
# the only types we need from includes are as/wrap marshallers. Therefore,
# we verify that the plugin was created using Rcpp.plugin.maker and then
# use that assumption to correctly extract include.before and include.after
.pluginIncludes <- function(plugin) {
# First determine the standard suffix of an Rcpp plugin by calling
# Rcpp.plugin.maker. If the plugin$includes has this suffix we know
# it's an Rcpp plugin
token <- "include_after_token"
stockRcppPlugin <- Rcpp.plugin.maker(include.after=token)
includes <- stockRcppPlugin()$includes
suffix <- strsplit(includes, token)[[1]][[2]]
# now ask the plugin for it's includes, ensure that the plugin includes
# are not null, and verify they have the Rcpp suffix before proceeding
pluginIncludes <- plugin()$includes
if (is.null(pluginIncludes))
return (NULL)
if (!grepl(suffix, pluginIncludes))
return (NULL)
# strip the suffix then split on stock Rcpp include to get before and after
pluginIncludes <- strsplit(pluginIncludes, suffix)[[1]][[1]]
pluginIncludes <- strsplit(pluginIncludes, c("#include "))[[1]]
# extract before and after and nix empty lines
before <- pluginIncludes[[1]]
before <- strsplit(before, "\n")[[1]]
before <- before[nzchar(before)]
after <- pluginIncludes[[2]]
after <- strsplit(after, "\n")[[1]]
after <- after[nzchar(after)]
# return before and after
list(before = before, after = after)
}
# Parse a LinkingTo field into a character vector
.parseLinkingTo <- function(linkingTo) {
if (is.null(linkingTo))
return (character())
linkingTo <- strsplit(linkingTo, "\\s*\\,")[[1]]
gsub("\\s", "", linkingTo)
}
# show diagnostics for failed builds
.showBuildFailureDiagnostics <- function() {
# RStudio does it's own diagnostics so only do this for other environments
if (nzchar(Sys.getenv("RSTUDIO")))
return();
# if we can't call R CMD SHLIB then notify the user they should
# install the appropriate development tools
if (!.checkDevelTools()) {
msg <- paste("\nWARNING: The tools required to build C++ code for R ",
"were not found.\n\n", sep="")
sysName <- Sys.info()[['sysname']]
if (identical(sysName, "Windows")) {
msg <- paste(msg, "Please download and install the appropriate ",
"version of Rtools:\n\n",
"http://cran.r-project.org/bin/windows/Rtools/\n",
sep="");
} else if (identical(sysName, "Darwin")) {
msg <- paste(msg, "Please install Command Line Tools for XCode ",
"(or equivalent).\n", sep="")
} else {
msg <- paste(msg, "Please install GNU development tools ",
"including a C++ compiler.\n", sep="")
}
message(msg)
}
}
# check if R development tools are installed (cache successful result)
.hasDevelTools <- FALSE
.checkDevelTools <- function() {
if (!.hasDevelTools) {
# create temp source file
tempFile <- file.path(tempdir(), "foo.c")
cat("void foo() {}\n", file = tempFile)
on.exit(unlink(tempFile))
# set working directory to tempdir (revert on exit)
oldDir <- setwd(tempdir())
on.exit(setwd(oldDir), add = TRUE)
# attempt the compilation and note whether we succeed
cmd <- paste(R.home(component="bin"), .Platform$file.sep, "R ",
"CMD SHLIB foo.c", sep = "")
result <- suppressWarnings(system(cmd,
ignore.stderr = TRUE,
intern = TRUE))
assignInMyNamespace(".hasDevelTools", is.null(attr(result, "status")))
# if we build successfully then remove the shared library
if (.hasDevelTools) {
lib <- file.path(tempdir(),
paste("foo", .Platform$dynlib.ext, sep=''))
unlink(lib)
}
}
.hasDevelTools
}
rcpp-0.11.0/R/exposeClass.R 0000644 0000000 0000000 00000016221 12253723677 012260 0 ustar .stdHeader <- c(
"#include ",
"using namespace Rcpp ;"
)
.asString <- function(what) if(is.character(what)) what else deparse(what)
.strings <- function(expr) {
if(is.call(expr) && ! identical(expr[[1]], quote(`::`)))
lapply(as.list(expr)[-1], .strings)
else
.asString(expr)
}
.specifyItems <- function(what) {
what <- as.list(what)
wn <- allNames(what)
simple <- !nzchar(wn)
## todo: error checking here that unnamed elements are single strings
wn[simple] <- as.character(what[simple])
names(what) <- wn
what[simple] <- list(character())
what
}
.writeFieldFunction <- function(fldi, typei, CppClass, readOnly, ns, con){
rootName <- paste0("field_", fldi)
writeLines(sprintf(" %s %s_get(%s *obj) { return obj->%s; }\n",
typei, rootName, CppClass, fldi), con)
value <- "_get"
if(!readOnly) {
writeLines(sprintf(" void %s_set(%s *obj, %s value) { obj->%s = value; }\n",
rootName, CppClass, typei, fldi), con)
value <- c(value, "_set")
}
paste0(ns, "::field_", fldi, value)
}
.writeMethodFunction <- function(mdi, sigi, CppClass, ns, con) {
mName <- paste0("method_", mdi)
if(length(sigi) < 1)
stop(gettextf("The type signature for method %s for class %s was of length 0: Must at least include the return type",
mdi, CppClass))
rtnType <- sigi[[1]]
sigi <- sigi[-1]
if(length(sigi)) {
argNames <- paste0("a", seq_along(sigi))
args <- paste(" ,", paste(sigi, argNames, collapse = ", "))
}
else argNames <- args <- ""
writeLines(sprintf(" %s %s(%s *obj%s){ return obj->%s(%s); }\n",
rtnType, mName, CppClass, args, mdi, argNames), con)
paste0(ns, "::",mName)
}
exposeClass <- function(class, constructors, fields, methods,
file = paste0(CppClass, "Module.cpp"),
header = character(),
module = paste0("class_",class), CppClass = class,
readOnly = character(), rename = character(),
Rfile = TRUE) {
## some argument checks
## TODO: checks on constructors, fields, methods
if(length(readOnly)) {
readOnly <- as.character(readOnly)
if(!all(nzchar(readOnly)))
stop("argument readOnly should be a vector of non-empty strings")
}
newnames <- allNames(rename)
if(length(rename)) {
if(!all(sapply(rename, function(x) is.character(x) && length(x) == 1 && nzchar(x))))
stop("argument rename should be a vector of single, non-empty strings")
if(!all(nzchar(newnames)))
stop("all the elements of argument rename should be non-empty strings")
}
if(is.character(file)) {
## are we in a package directory? Writable, searchable src subdirectory:
if(file.access("src",3)==0)
cfile <- file.path("src", file)
else
cfile <- file
con <- file(cfile, "w")
on.exit({message(sprintf("Wrote C++ file \"%s\"", cfile)); close(con)})
}
else
con <- file
## and for the R code:
if(identical(Rfile, FALSE)) {}
else {
if(identical(Rfile, TRUE))
Rfile <- sprintf("%sClass.R",class)
if(is.character(Rfile)) {
if(file.access("R",3)==0) # in a package directory
Rfile <- file.path("R", Rfile)
Rcon <- file(Rfile, "w")
msg <- sprintf("Wrote R file \"%s\"",Rfile)
on.exit({message(msg); close(Rcon)}, add = TRUE)
}
else
Rcon <- Rfile
Rfile <- TRUE
}
mfile <- tempfile()
mcon <- file(mfile, "w")
writeLines(.stdHeader, con)
if(length(header))
writeLines(header, con)
writeLines(c("", sprintf("RCPP_MODULE(%s) {\n",module), ""), mcon)
writeLines(sprintf(" class_<%s>(\"%s\")\n", CppClass, class), mcon)
## the constructors argument defines a list of vectors of types
for( cons in constructors) {
if(length(cons) > 1 ||
(length(cons) == 1 && nzchar(cons) && !identical(cons, "void")))
cons <- paste0("<", paste(cons, collapse = ","),">")
else
cons = ""
writeLines(paste0(" .constructor",cons,"()"),mcon)
}
writeLines("", mcon)
flds <- .specifyItems(fields)
nm <- names(flds)
rdOnly <- nm %in% readOnly
macros <- ifelse(rdOnly, ".field_readonly", ".field")
test <- nm %in% rename
if(any(test))
nm[test] <- newnames[match(nm[test], newnames)]
ns <- NULL
for(i in seq_along(nm)) {
typei <- flds[[i]]
nmi <- fldi <- nm[[i]]
macroi <- macros[[i]]
if(!length(typei) || identical(typei, "")) ## direct field
writeLines(sprintf(" %s(\"%s\", &%s::%s)",
macroi, nmi, CppClass, fldi), mcon)
else { # create a free function, e.g. for an inherited field
if(is.null(ns)) { # enclose in a namespace
ns <- paste("module",class,"NS", sep = "_")
writeLines(sprintf("\nnamespace %s {\n", ns),
con)
}
fldFuns <- .writeFieldFunction(fldi, typei, CppClass, rdOnly[[i]], ns, con)
if(rdOnly[[i]])
## NOTE: string 3rd arg. required by problem w. module parsing 10/3/13
writeLines(sprintf(" .property(\"%s\", &%s, \"read-only field\")",
nmi, fldFuns[[1]]), mcon)
else
writeLines(sprintf(" .property(\"%s\", &%s, &%s)",
nmi, fldFuns[[1]], fldFuns[[2]]), mcon)
}
}
writeLines("", mcon)
sigs <- .specifyItems(methods)
nm <- mds <- names(sigs)
test <- nm %in% rename
if(any(test))
nm[test] <- newnames[match(nm[test], newnames)]
for(i in seq_along(nm)) {
sigi <- sigs[[i]]
nmi <- nm[[i]]
mdi <- mds[[i]]
if(!length(sigi) || identical(sigi, "")) # direct method
writeLines(sprintf(" .method(\"%s\", &%s::%s)",
nmi, CppClass, mdi), mcon)
else { # create a free function, e.g. for an inherited method
if(is.null(ns)) { # enclose in a namespace
ns <- paste("module",class,"NS", sep = "_")
writeLines(sprintf("\nnamespace %s {\n", ns),
con)
}
mFun <- .writeMethodFunction(mdi, sigi, CppClass, ns, con)
writeLines(sprintf(" .method(\"%s\", &%s)",
nmi, mFun), mcon)
}
}
writeLines(" ;\n}", mcon)
close(mcon)
if(!is.null(ns))
writeLines(sprintf("} // %s", ns), con) # close namespace
writeLines(readLines(mfile), con)
if(Rfile) {
if(missing(CppClass))
CppString <- ""
else
CppString <- paste(",",dQuote(CppClass))
if(missing(module))
ModString <- ""
else
ModString <- paste(", module =", dQuote(module))
writeLines(sprintf("%s <- setRcppClass(\"%s\"%s%s)",
class, class, CppString,ModString), Rcon)
}
}
rcpp-0.11.0/R/01_show.R 0000644 0000000 0000000 00000010126 12253723677 011245 0 ustar # Copyright (C) 2010 - 2012 John Chambers, Dirk Eddelbuettel and Romain Francois
#
# This file is part of Rcpp.
#
# Rcpp is free software: you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 2 of the License, or
# (at your option) any later version.
#
# Rcpp 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Rcpp. If not, see .
setMethod( "show", "C++Object", function(object){
env <- as.environment(object)
pointer <- get(".pointer", envir = env)
cppclass <- get(".cppclass", envir = env)
txt <- sprintf( "C++ object <%s> of class '%s' <%s>",
externalptr_address(pointer),
.Call( Class__name, cppclass ),
externalptr_address(cppclass)
)
writeLines( txt )
} )
setMethod( "show", "C++Class", function(object){
doc <- object@docstring
txt <- sprintf( "C++ class '%s' <%s>%s",
.Call( Class__name, object@pointer ),
externalptr_address(object@pointer),
if( length(doc) && nchar(doc) ) sprintf( "\n docstring : %s", doc ) else ""
)
writeLines( txt )
ctors <- object@constructors
nctors <- length( ctors )
txt <- character( nctors )
for( i in seq_len(nctors) ){
ctor <- ctors[[i]]
doc <- ctor$docstring
txt[i] <- sprintf( " %s%s", ctor$signature, if( nchar(doc) ) sprintf( "\n docstring : %s", doc) else "" )
}
writeLines( "Constructors:" )
writeLines( paste( txt, collapse = "\n" ) )
fields <- object@fields
nfields <- length(fields)
if( nfields ){
names <- names(fields)
txt <- character(nfields)
writeLines( "\nFields: " )
for( i in seq_len(nfields) ){
f <- fields[[i]]
doc <- f$docstring
txt[i] <- sprintf( " %s %s%s%s",
f$cpp_class,
names[i],
if( f$read_only ) " [readonly]" else "",
if( nchar(doc) ) sprintf( "\n docstring : %s", doc ) else ""
)
}
writeLines( paste( txt, collapse = "\n" ) )
} else {
writeLines( "\nFields: No public fields exposed by this class" )
}
mets <- object@methods
nmethods <- length(mets)
if( nmethods ){
writeLines( "\nMethods: " )
txt <- character( nmethods )
for( i in seq_len(nmethods) ){
txt[i] <- mets[[i]]$info(" ")
}
writeLines( paste( txt, collapse = "\n" ) )
} else {
writeLines( "\nMethods: no methods exposed by this class" )
}
} )
setMethod( "show", "C++Function", function(object){
txt <- sprintf( "internal C++ function <%s>", externalptr_address(object@pointer) )
writeLines( txt )
doc <- object@docstring
if( length(doc) && nchar( doc ) ){
writeLines( sprintf( " docstring : %s", doc ) )
}
sign <- object@signature
if( length(sign) && nchar( sign ) ){
writeLines( sprintf( " signature : %s", sign ) )
}
} )
setMethod( "show", "Module", function( object ){
pointer <- .getModulePointer(object, FALSE)
if(identical(pointer, .badModulePointer)) {
object <- as.environment(object) ## not needed when 2.12.0 arrives
txt <- sprintf("Uninitialized module named \"%s\" from package \"%s\"",
get("moduleName", envir = object),
get("packageName", envir = object))
writeLines(txt)
}
else {
info <- .Call( Module__functions_arity, pointer )
name <- .Call( Module__name, pointer )
txt <- sprintf( "Rcpp module '%s' \n\t%d functions: ", name, length(info) )
writeLines( txt )
txt <- sprintf( "%15s : %d arguments", names(info), info )
writeLines( txt )
info <- .Call( Module__classes_info, pointer )
txt <- sprintf( "\n\t%d classes : ", length(info) )
writeLines( txt )
txt <- sprintf( "%15s ", names(info) )
writeLines( txt )
}
} )
rcpp-0.11.0/R/tools.R 0000644 0000000 0000000 00000003376 12253723677 011136 0 ustar # Copyright (C) 2010 - 2012 Dirk Eddelbuettel and Romain Francois
#
# This file is part of Rcpp.
#
# Rcpp is free software: you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 2 of the License, or
# (at your option) any later version.
#
# Rcpp 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Rcpp. If not, see .
externalptr_address <- function(xp){
.Call( as_character_externalptr, xp )
}
# just like assignInNamespace but first checks that the binding exists
forceAssignInNamespace <- function( x, value, env ){
is_ns <- isNamespace( env )
unlocker <- get( "unlockBinding", baseenv() )
if( is_ns && exists( x, env ) && bindingIsLocked(x, env ) ){
unlocker( x, env )
}
assign( x, value, env )
if( is_ns ){
lockBinding( x, env )
}
}
# Transform a path for passing to the build system on the command line.
# Leave paths alone for posix. For Windows, mirror the behavior of the
# R package build system by starting with the fully resolved absolute path,
# transforming it to a short path name if it contains spaces, and then
# converting backslashes to forward slashes
asBuildPath <- function(path) {
if (.Platform$OS.type == "windows") {
path <- normalizePath(path)
if (grepl(' ', path, fixed=TRUE))
path <- utils::shortPathName(path)
path <- gsub("\\\\", "/", path)
}
return(path)
}
rcpp-0.11.0/R/exceptions.R 0000644 0000000 0000000 00000001441 12253723677 012146 0 ustar # Copyright (C) 2009 - 2012 Dirk Eddelbuettel and Romain Francois
#
# This file is part of Rcpp.
#
# Rcpp is free software: you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 2 of the License, or
# (at your option) any later version.
#
# Rcpp 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Rcpp. If not, see .
.rcpp_error_recorder <- function(e){
invisible( .Call( rcpp_error_recorder, e ) )
}
rcpp-0.11.0/R/inline.R 0000644 0000000 0000000 00000003017 12253723677 011244 0 ustar # Copyright (C) 2009 - 2013 Dirk Eddelbuettel and Romain Francois
#
# This file is part of Rcpp.
#
# Rcpp is free software: you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 2 of the License, or
# (at your option) any later version.
#
# Rcpp 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Rcpp. If not, see .
Rcpp.plugin.maker <- function(
include.before = "",
include.after = "",
LinkingTo = unique( c( package, "Rcpp" ) ),
Depends = unique( c( package, "Rcpp" ) ),
libs = "",
Makevars = NULL ,
Makevars.win = NULL,
package = "Rcpp"
){
function( ... ){
includes <- sprintf( "%s
#include
%s
#ifndef BEGIN_RCPP
#define BEGIN_RCPP
#endif
#ifndef END_RCPP
#define END_RCPP
#endif
using namespace Rcpp;
", include.before, include.after )
out <- list(
env = list( PKG_LIBS = libs ),
includes = includes,
LinkingTo = LinkingTo ,
body = function( x ){
sprintf( "BEGIN_RCPP\n%s\nEND_RCPP", x )
},
Depends = Depends
)
if( !is.null(Makevars ) ) out$Makevars <- Makevars
if( !is.null(Makevars.win ) ) out$Makevars.win <- Makevars.win
out
}
}
inlineCxxPlugin <- Rcpp.plugin.maker()
rcpp-0.11.0/README.md 0000644 0000000 0000000 00000010264 12273300210 010673 0 ustar Rcpp: Seamless R and C++ Integration
====================================
[](https://travis-ci.org/RcppCore/Rcpp)
The [Rcpp package](http://cran.r-project.org/package=Rcpp) provides R functions as well as a C++ library
which facilitate the integration of R and C++
R data types (`SEXP`) are matched to C++ objects in a class hierarchy. All R
types are supported (vectors, functions, environment, etc ...) and each
type is mapped to a dedicated class. For example, numeric vectors are
represented as instances of the Rcpp::NumericVector class, environments are
represented as instances of Rcpp::Environment, functions are represented as
Rcpp::Function, etc ...
The
[Rcpp-introduction](http://cran.r-project.org/web/packages/Rcpp/vignettes/Rcpp-introduction.pdf)
vignette (also published as a [JSS paper](http://www.jstatsoft.org/v40/i08/)) provides a good
entry point to Rcpp as do the [Rcpp website](http://www.rcpp.org), the
[Rcpp page](http://dirk.eddelbuettel.com/code/rcpp.html) and the
[Rcpp Gallery](http://gallery.rcpp.org). Full documentation
is provided by the [Rcpp book](http://www.rcpp.org/book/).
Conversion from C++ to R and back is driven by the templates `Rcpp::wrap`
and `Rcpp::as` which are highly flexible and extensible, as documented
in the [Rcpp-extending](http://cran.r-project.org/web/packages/Rcpp/vignettes/Rcpp-extending.pdf) vignette.
Rcpp also provides Rcpp modules, a framework that allows exposing
C++ functions and classes to the R level. The [Rcpp-modules]((http://cran.r-project.org/web/packages/Rcpp/vignettes/Rcpp-modules.pdf) vignette
details the current set of features of Rcpp-modules.
Rcpp includes a concept called Rcpp sugar that brings many R functions
into C++. Sugar takes advantage of lazy evaluation and expression templates
to achieve great performance while exposing a syntax that is much nicer
to use than the equivalent low-level loop code. The [Rcpp-sugar]((http://cran.r-project.org/web/packages/Rcpp/vignettes/Rcpp-sugar.pdf)
gives an overview of the feature.
Rcpp attributes provide a high-level syntax for declaring C++
functions as callable from R and automatically generating the code
required to invoke them. Attributes are intended to facilitate both
interactive use of C++ within R sessions as well as to support R
package development. Attributes are built on top of Rcpp modules and
their implementation is based on previous work in the inline package.
See the [Rcpp-atttributes]((http://cran.r-project.org/web/packages/Rcpp/vignettes/Rcpp-attributes.pdf) vignettes for more details.
## Documentation
The package ships with nine pdf vignettes.
Additional documentation is available via the
[JSS paper](http://www.jstatsoft.org/v40/i08/) by Eddelbuettel and
Francois (2011, JSS) paper (corresponding to the 'intro' vignette)
and the [book](http://www.rcpp.org/book) by Eddelbuettel (2013, Springer);
see 'citation("Rcpp")' for details.
## Examples
The [Rcpp Gallery](http://gallery.rcpp.org) showcases over 70 fully documented
and working examples.
A number of examples are included as are over 800 unit tests in over 400 unit
test functions provide additional usage examples.
The [CRAN](http://cran.r-project.org) network contains
(as over early 2014) over 160 packages which also provide usage examples.
An earlier version of Rcpp, containing what we now call the 'classic Rcpp
API' was written during 2005 and 2006 by Dominick Samperi. This code has
been factored out of Rcpp into the package RcppClassic, and it is still
available for code relying on the older interface. New development should
always use this Rcpp package instead.
## Installation
Released and tested versions of Rcpp are available via the
[CRAN](http://cran.r-project.org) network, and can be installed from within R via
```R
install.packages("Rcpp")
```
To install from source, ensure you have a
[complete package development environment](http://www.rstudio.com/ide/docs/packages/prerequisites).
Also see questions 1.2 and 1.3 in the [Rcpp-FAQ](http://cran.r-project.org/web/packages/Rcpp/vignettes/Rcpp-FAQ.pdf).
## Authors
Dirk Eddelbuettel, Romain Francois, JJ Allaire, Doug Bates, John Chamber and
Kevin Ushey
## License
GPL (>= 2)
rcpp-0.11.0/build/ 0000755 0000000 0000000 00000000000 12273452733 010532 5 ustar rcpp-0.11.0/build/vignette.rds 0000644 0000000 0000000 00000000731 12273452733 013072 0 ustar TMS0Oj^h)
ެœ0ײ,rIJ u1k&eY $609#ǹBcY٧a/jx}mCEfC$M-͋ZV8EbG|<,lbrd q:> UG
tCđ 1x1 rcpp-0.11.0/ChangeLog 0000644 0000000 0000000 00000705513 12273452447 011222 0 ustar 2014-02-02 Dirk Eddelbuettel
* DESCRIPTION: Release 0.11.0
* inst/NEWS.Rd: Release 0.11.0
* inst/include/Rcpp/config.h: Release 0.11.0
* debian/*: Similarly updated for new release to Debian
2014-02-02 JJ Allaire
* R/Attributes.R: Use placeholder for .Call to avoid warning
2014-02-01 Dirk Eddelbuettel
* tests/doRUnit.R: Simplified following pattern in RProtoBuf
* vignettes/Rcpp-unitTests.Rnw: Remove a now superfluous global var
* vignettes/Rcpp.bib: Updated references to current packages
2014-02-01 JJ Allaire
* R/Attributes.R: Embedded R code chunks in sourceCpp can
now be disabled
2014-01-31 Dirk Eddelbuettel
* vignettes/Rcpp-FAQ.Rnw: Render code with background boxen
* vignettes/Rcpp-package.Rnw: Idem
* vignettes/Rcpp-modules.Rnw: Idem
* vignettes/Rcpp-extending.Rnw: Idem
* vignettes/Rcpp-sugar.Rnw: Idem
* vignettes/Rcpp-attributes.Rnw: Switched to highlight driver
* inst/include/Rcpp/Benchmark/Timer.h: Reverted back to using
iterators via use of anonymous namespace for accessors
* inst/announce/ANNOUNCE-0.11.0.txt: Updated
2014-01-31 Dirk Eddelbuettel
* man/Rcpp.package.skeleton.Rd: Also updated
2014-01-31 JJ Allaire
* R/Attributes.R: Embedded R code chunks in sourceCpp are now
executed within the working directory of the C++ source file.
2014-01-30 Dirk Eddelbuettel
* vignettes/Rcpp-package.Rnw: Updates for upcoming release
2014-01-28 Dirk Eddelbuettel
* vignettes/Rcpp-FAQ.Rnw: Some updates for upcoming release
2014-01-25 Dirk Eddelbuettel
* inst/include/Rcpp/Benchmark/Timer.h: Simplified -- Rcpp Gallery
example using it was not building any longer under g++
2014-01-23 Dirk Eddelbuettel
* inst/announce/ANNOUNCE-0.11.0.txt: Added for next release
2014-01-21 Dirk Eddelbuettel
* R/Rcpp.package.skeleton.R: Update skeleton package to add proper
Imports: to DESCRIPTION, and importFrom() to NAMESPACE
2014-01-19 Kevin Ushey
* inst/include/Rcpp/api/meat/Vector.h: Add missing UNPROTECT in
push_back_name__impl
2014-01-18 Kevin Ushey
* inst/unitTests/runit.S4.R: Add a test for ctor from slot proxy
* inst/unitTests/cpp/S4.cpp: Add a test for ctor from slot proxy
* inst/include/Rcpp/vector/Vector.h: Add missing r_cast to vector
ctor from proxy
2014-01-18 JJ Allaire
* R/Attributes.R: More restrictive matching of C++ file extensions
for compileAttributes.
2014-01-18 Kevin Ushey
* inst/unitTests/cpp/Matrix.cpp: Add unit test
* inst/unitTests/runit.Matrix.R: Add unit test
* inst/include/Rcpp/api/meat/Matrix.h: Bug fix in operator=
2014-01-17 Dirk Eddelbuettel
* R/RcppLdpath.R (RcppCxxFlags): Restore function to supply values
for include files for packages not yet converted to LinkingTo:
2014-01-16 JJ Allaire
* inst/include/Rcpp/macros/macros.h: Use Rf_onintr rather than
non-public Rf_jump_to_toplevel
* inst/include/Rcpp/DateVector.h: Fix GreedyVector compilation error
* inst/include/Rcpp/DatetimeVector.h: Fix GreedyVector compilation error
2014-01-15 Dirk Eddelbuettel
* inst/include/Rcpp/exceptions.h: Move stop() into Rcpp namespace
2014-01-03 JJ Allaire
* .gitignore: Added src/, *.Rproj, and .Rproj.user
* inst/include/Rcpp/Interrupt.h: New checkUserInterrupt function
that provides a C++ friendly implementation of R_CheckUserInterrupt
* inst/include/RcppCommon.h: Include Rcpp/Interrupts.h
* inst/include/macros/macros.h: Check for interrupts in END_RCPP
* src/attributes.cpp: Handle interrupted-error in attribute
function envelope.
2013-12-31 Dirk Eddelbuettel
* vignettes/Rcpp.bib: Updated CRAN package references
2013-12-20 Kevin Ushey
* inst/include/Rcpp/sugar/tools/mapcompare.h: Use a union for
type punning, to avoid compiler warning on aliasing. Also
switch to uint64_t to enforce 64bit comparison.
* inst/include/Rcpp/RObject.h: Add missing *this return for
RObject_impl::operator=
2013-12-20 Dirk Eddelbuettel
* inst/include/Rcpp/RObject.h: Applied fix by Kevin Ushey (#88)
* inst/include/Rcpp/vector/Vector.h: Ditto (#89)
2013-12-01 Kevin Ushey
* R/Rcpp.package.skeleton.R: Fixed bug relating to user-supplied
functions in 'list' argument
* inst/unitTests/runit.Rcpp.package.skeleton.R: Added unit tests
2013-11-30 Dirk Eddelbuettel
* vignettes/Rcpp-FAQ.Rnw: Updated and corrected in several spots
2013-11-22 Dirk Eddelbuettel
* inst/include/Rcpp/stats/nt.h: Correct expansion of (d|q|p)nt()
* inst/unitTests/runit.stats.R: Added unit tests for t dist with ncp
* inst/unitTests/cpp/stats.cpp: C++ side of expamded unit tests
2013-11-05 Dirk Eddelbuettel
* .travis.yml: Added to support continuous integration on github
2013-10-28 Romain Francois
* include/Rcpp/protection/Armor.h : Armor::operator SEXP has to be const
for it to work properly with wrap.
2013-10-27 Dirk Eddelbuettel
* DESCRIPTION: Release 0.10.6
* inst/NEWS.Rd: Release 0.10.6
* inst/include/Rcpp/config.h: Release 0.10.5
* debian/*: Similarly updated for new release to Debian
2013-10-17 JJ Allaire
* R/Attributes.R: sourceCpp now correctly binds to Rtools 3.0 and 3.1
2013-10-16 Dirk Eddelbuettel
* R/Rcpp.package.skeleton.R (Rcpp.package.skeleton): Deprecate
namespace argument which package.skeleton() no longer uses
* man/Rcpp.package.skeleton.Rd: Updated documentation accordingly
2013-10-16 Romain Francois
* include/Rcpp/api/meat/is.h : added missing implementation for
is and is
2013-10-14 Romain Francois
* inst/include/Rcpp/protection/protection.h: added
Shield/Shelter/Armor
* DESCRIPTION: bump to version 0.10.5.3
2013-10-12 Dirk Eddelbuettel
* DESCRIPTION (Depends): Rolled Depends: on R to "R (>= 3.0.0)" as
required by the vignette building code (with thanks to Uwe Ligges)
2013-10-08 Dirk Eddelbuettel
* NAMESPACE: Export LdFlags as well as RcppLdFlags
* man/RcppLdFlags.Rd: Updated
2013-10-06 John M Chambers
* R/exposeClass.R: avoid warning from unclosed file()
2013-10-06 John M Chambers
* NAMESPACE: change classModule to exposeClass
* R/classModule.R: delete
* man/classModule.Rd: delete
* R/exposeClass.R: add
* man/exposeClass.Rd: add
* man/setRcppClass.Rd: update, clarify, recommend exposeClass()
2013-10-03 John M Chambers
* R/classModule.R: new function to write module file for class
* man/classModule.Rd: documentation for new function classModule()
* NAMESPACE: export classModule
* R/loadModule.R: clean up an error message
* R/RcppClass.R: defaults for module consistent w. classModule()
* man/setRcppClass.Rd: add defaults, explain need for saveAs
2013-10-02 Dirk Eddelbuettel
* inst/include/Rcpp/traits/is_na.h: More fixes thanks to Thomas Tse
2013-10-01 Dirk Eddelbuettel
* inst/include/Rcpp/api/meat/is.h: Applied patch by Thomas Tse to
provide missing Character(Vector|Matrix)
* DESCRIPTION: Bump to development release 0.10.5.1
2013-09-28 Dirk Eddelbuettel
* DESCRIPTION: Release 0.10.5
* inst/NEWS.Rd: Release 0.10.5
* inst/include/Rcpp/config.h: Release 0.10.5
* debian/*: Similarly updated for new release to Debian
* vignettes/Rcpp-unitTests.Rnw: Switched to Charter font just like
the other eight vignettes
2013-09-28 Romain Francois
* include/Rcpp/module/Module_generated_CppMethod.h : more code bloat
to handle flexible semantics for passing parameters in methods
* include/Rcpp/module/Module_generated_Pointer_CppMethod.h : same
* inst/unitTests/cpp/Module.cpp: testing the above
* unitTests/runit.Module.R: testing
2013-09-27 Dirk Eddelbuettel
* vignettes/Rcpp-unitTests.Rnw: Re-activated vignette
* DESCRIPTION: Version number bumped to 0.10.4.6
2013-09-27 Romain Francois
* include/Rcpp/module/Module_generated_CppFunction.h : regenerated to
use input_parameter traits for more flexible parameter passing strategy
* unitTests/cpp/Module.cpp : more testing
* unitTests/runit.Module.R : more testing
2013-09-22 Dirk Eddelbuettel
* inst/include/Rcpp/sugar/functions/diff.h: Declare set_previous
const and add a missing traits:: prefix before is_na
* inst/unitTests/cpp/sugar.cpp: Unit test for diff() of int. vector
* inst/unitTests/runit.sugar.R: Invoke new test
2013-09-21 Dirk Eddelbuettel
* vignettes/Rcpp-modules.Rnw: Remove vignette-local compilations
which again caused problems for the Windows builds at R-Forge and
win-builder. Unit tests comprise the same functionality and pass.
* vignettes/Rcpp-attributes.Rnw: Refresh look by using Bitstream
Charter, and microtype package (cf http://www.khirevich.com/latex)
* vignettes/Rcpp-extending.Rnw: Idem
* vignettes/Rcpp-FAQ.Rnw: Idem
* vignettes/Rcpp-modules.Rnw: Idem
* vignettes/Rcpp-package.Rnw: Idem
* vignettes/Rcpp-quickref.Rnw: Idem
* vignettes/Rcpp-sugar.Rnw: Idem
2013-09-20 Dirk Eddelbuettel
* R/Module.R: More ':::' cleanups to make R CMD check happy
* R/RcppClass.R: Ditto
* NAMESPACE: Some new exports related to this
* man/setRcppClass.Rd: Document loadRcppClass()
* man/Rcpp-internal.Rd: Added in order to document
cpp_object_initializer() and cpp_object_dummy()
2013-09-19 Dirk Eddelbuettel
* inst/include/Rcpp/longlong.h: Unbreak long long by making it (as
before) conditional on g++ (or clang) as well as C++11. The condition
can be OR'ed with another suitably-defined variable, but the default
has to be off as CRAN compliance has to remain the standard
2013-09-19 Romain Francois
* include/Rcpp/longlong.h: isolate all handling of long long
in a separate file which we might choose not to include by default
* include/Rcpp/traits/r_sexptype_traits.h : unsigned int wrapped as
REALSXP long standing feature request from Murray.
* R/Attributes.R : Added the helper demangle and sizeof functions
* man/demangle.Rd : Documentation for demangle and sizeof
* include/Rcpp/platform/compiler.h : less restritive support of long
long types. But still behind a test for gcc and a test for the
availability of the type, and the __extension__. -pedantic does not
warn about it
2013-09-18 JJ Allaire
* R/Attributes.R: Don't search the inline package as a fallback when
loading plugins for the the Rcpp::plugins attribute
2013-09-18 Romain Francois
* vignettes/Rcpp-package.Rnw: Updating the vignette. Setting
attributes to TRUE by default.
* R/Rcpp.package.skeleton.R: Setting attributes to TRUE by
default. This is what we should encourage people to use.
* include/Rcpp/as.h: add as specialization
* include/Rcpp/sugar/functions/diff.h : rework the implementation of
diff so that it works even when we don't know the previous value
* unitTests/runit.sugar.R :
* unitTests/cpp/sugar.cpp :
* include/Rcpp/sugar/functions/range.h : factored out of minmax.h
* include/Rcpp/sugar/functions/min.h : factored out of minmax.h
* include/Rcpp/sugar/functions/max.h : factored out of minmax.h
* TODO : 3 less items
2013-09-17 JJ Allaire
* R/Attributes.R: Call inlineCxxPlugin and Rcpp.plugin.maker without
qualification rather than with ':::'
2013-09-17 Dirk Eddelbuettel
* NAMESPACE: Export RcppLdFlags which is often used to build Rcpp
* man/RcppLdFlags.Rd: Added required manual page
* R/Attributes.R: Call RcppLdFlags() via '::' instead of ':::'
* R/SHLIB.R: Ditto
* R/inline.R: Ditto
* vignettes/Rcpp-FAQ.Rnw: Add %\VignetteEngine{highlight::highlight}
* vignettes/Rcpp-attributes.Rnw: Idem
* vignettes/Rcpp-extending.Rnw: Idem
* vignettes/Rcpp-modules.Rnw: Idem
* vignettes/Rcpp-package.Rnw: Idem
* vignettes/Rcpp-quickref.Rnw: Idem
* vignettes/Rcpp-sugar.Rnw: Idem
* vignettes/Rcpp-package.Rnw: Altered to make use of highlight
package; also no longer build embedded demo package (which upsets R
CMD check under R-devel)
2013-09-16 JJ Allaire
* R/Attributes.R : Remove calls to non-exported functions from the tools package
2013-09-16 Romain Francois
* include/Rcpp/internal/Exporter.h : Specific handling of containers
(std::vector, std::deque, and std::list so that we use their faster
range constructor when we can, and so let the STL optimize how data
is copied
* include/Rcpp/api/meat/export.h : Implementation of the above
* include/Rcpp/vector/Vector.h : added Vector( const char* ) ctor
* DESCRIPTION : bump to 0.10.4.5 (for RcppExtras)
2013-09-15 Dirk Eddelbuettel
* inst/include/Rcpp/InputParameter.h (Rcpp): Add 'const' case
* inst/unitTests/cpp/Vector.cpp: New unit tests for std::vector
conversions, using both int and double arguments
* inst/unitTests/runit.Vector.R: R complement of these tests
2013-09-15 Romain Francois
* include/Rcpp/InputParameter.h : added the traits::input_parameter
trait to add another layer of abstration.
* include/Rcpp/macros/module.h : taking advantage of input_parameter
to specialize how to work with module objects
* src/attributes.cpp : using traits::input_parameter instead of
InputParameter
2013-09-14 Dirk Eddelbuettel
* src/attributes.cpp : Precede closing '>' by space to avoid '>>'
* inst/include/Rcpp/platform/compiler.h: Further refine #if test for
'long long' by conditioning __LP64__ on also using clang/llvm
* src/attributes.cpp : Precede closing '>' by space to avoid '>>'
2013-09-13 Romain Francois
* src/api.cpp : added "long long" to the capabilities function.
* include/Rcpp/platform/compiler.h : demangling is definitely
available on all mac versions using gcc. No point is testing for OSX
version.
* include/Rcpp/InputParameter.h : extra layer of abstraction to allow
for custom handling of references etc ... used in RcppArmadillo
* src/attributes.cpp : using InputParameter
* DESCRIPTION: bump to 0.10.4.4
2013-09-12 Romain Francois
* include/Rcpp/platform/compiler.h : patch submitted by Murray for
better support of long long type.
* include/Rcpp/platform/compiler.h : gcc 4.2.1 has tr1/unordered_map
and tr1/unordered_set. Previous test was for gcc 4.4.0 for some
reason
2013-08-31 Dirk Eddelbuettel
* inst/doc/*: Moved all vignettes to vignettes/*
* vignettes/*: Minor updates to some vignettes
2013-08-22 Romain Francois
* include/Rcpp/traits/is_primitive.h : new trait to identify if a
type is primitive, this is a shortcut of using r_type_traits and
compare it to r_type_primitive_tag
* include/Rcpp/traits/r_type_traits.h : new tag r_type_pair_tag to
handle wrapping map where KEY can be converted to String
and VALUE can wrap itself
* include/Rcpp/internal/wrap.h : handling map and vector
where T is a class handled by modules
* include/Rcpp/api/meat/wrap.h : implementations to handle map
* unitTests/cpp/wrap.cpp : more tests for map with KEY
not a string
* unitTests/runit.wrap.R : more tests for map with KEY
not a string
* include/Rcpp/internal/export.h : added export_range__dispatch for
the r_type_generic_tag tag. Meaning we can now use as< vector >
where T is not a primitive
* include/Rcpp/api/meat/export.h : implementation in meat because it needs as
2013-08-01 Romain Francois
* unitTests/cpp/wstring.cpp: fix to re-enable wstring test suite.
* unitTests/runit.wstring.R: re-enable the wstring test suite.
2013-07-31 Dirk Eddelbuettel
* DESCRIPTION: Bump development version to 0.10.4.3
* inst/doc/Makefile: Rejigged pdf builds in another attempt at
pleasing whatever runs the builds on r-forge. L'espoir fait vivre.
2013-07-25 Romain Francois
* include/Rcpp/sugar/functions/is_na.h : added is_na for DateVector and
DatetimeVector
* include/Rcpp/Date.h : added is_na method
* include/Rcpp/Datetime.h : added is_na method
* unitTests/cpp/dates.cpp : removed the ignoreme useless parameters
* unitTests/runit.Date.R : idem
* src/attributes.cpp: collecting functions in a FunctionMap. Will use this
for dispatching
2013-07-24 Romain Francois
* include/Rcpp/traits/is_module_object.h: trait class that identifies
at compile time if a given type is a type exposed by a module,
i.e. if we used the RCPP_EXPOSED_AS macro
* include/Rcpp/is.h: able to identify if an object is of a given type
exposed by a module (supports references and pointers too).
* src/Module.cpp: implementation of is_module_object_internal that
checks if an object is of a given typeid, used by is where T is
module exposed
2013-07-23 Romain Francois
* include/Rcpp/as.h: support as and as where T is a class
exposed by modules
* include/Rcpp/macros/module.h: idem
* include/Rcpp/traits/un_pointer.h: handle the object case
* include/Rcpp/traits/r_type_traits.h: adding traits to help the with
as and as
* unitTests/runit.Module.R: testing as and as
* unitTests/cpp/Module.cpp: idem
* src/attributes.cpp: take advantage of a more flexible as<>. The
Type class gains a full_name() method that shows const-ness and
reference-ness
2013-07-17 Romain Francois
* include/Rcpp/vector/instantiation.h: added the DoubleVector alias
to NumericVector
* include/Rcpp/is.h: added is template function
2013-07-11 Dirk Eddelbuettel
* R/Attributes.R: Add an OpenMP plugin
2013-07-03 Romain Francois
* unitTests/runit.modref.R: using sourceCpp
* unitTests/runit.Module.R: using sourceCpp
* unitTests/runit.Vector.R: no more uses of inline
* unitTests/runTests.R: we don't need inline no more for testing
* doc/unitTests/Rcpp-unitTests.R: idem
2013-07-02 Romain Francois
* include/Rcpp/vector/Vector.h: fill__dispatch was mispelled (as
fill_dispatch) for the non trivial case, so it did not work
* unitTests/runit.Matrix.R: using sourceCpp
* unitTests/runit.misc.R: using sourceCpp
* unitTests/runit.wrap.R: using sourceCpp
* unitTests/runit.support.R: using sourceCpp
* unitTests/runit.rmath.R: using sourceCpp
* unitTests/runit.RObject.R: using sourceCpp
* unitTests/runit.stats.R: using sourceCpp
* unitTests/runit.XPTr.R: using sourceCpp
* unitTests/runit.Vector.R: testing List( int, IntegerVector ) which
eventually uses fill__dispatch
* include/Rcpp/traits/r_type_traits.h: support for as and as
when T is module exposed
* include/Rcpp/as.h: as and as when T is module exposed
* include/Rcpp/module/Module_generated_CppFunction.h: removed the
remove_const_and_reference since as and as is supported
* src/attributes.cpp: automatically populating the environment with
the content of a module, rather than make the module object available
in the environment
2013-07-01 Romain Francois
* R/unit.test.R: added helper function Rcpp:::unit_test_setup to avoid
some boiler plate code in unit test files. See e.g. runit.Function.R for
an example
* unitTests/runit.as.R: using sourceCpp
* unitTests/runit.Function.R: using sourceCpp
* unitTests/runit.DataFrame.R: remove dependency on datasets
2013-06-25 Dirk Eddelbuettel
* src/api.cpp: Also test for #defined(__sun) when checking for system
lacking a valid backtrace() function for stack traces
2013-06-25 Romain Francois
* DESCRIPTION : devel version 0.10.4.1
* src/Module.cpp : bring a simplified version of RCPP_FUNCTION 1 .. 4
* unitTests/runit.macros.R : removed, as RCPP_FUNCTION ... are deprecated
* include/Rcpp/macros/preprocessor_generated.h : deprecating RCPP_FUNCTION_... macros
2013-06-24 Dirk Eddelbuettel
* inst/include/Rcpp/platform/compiler.h: Note the useful wiki page
http://sourceforge.net/p/predef/wiki/Home with #defines for OSs,
compilers, libraries and more
2013-06-23 Dirk Eddelbuettel
* DESCRIPTION: Release 0.10.4
* inst/NEWS.Rd: Release 0.10.4
* inst/include/Rcpp/config.h: Release 0.10.4
* debian/*: Similarly updated for new release to Debian
2013-06-19 Romain Francois
* inst/NEWS.Rd: Document planned depreciation of old RCPP_FUNCION_*
macros which are redundant thanks to Rcpp Modules and Rcpp Attributes
* include/Rcpp/vector/string_proxy.h : added operator
string_proxy::operator==( const string_proxy& ) so that me may
compare x[i] and y[i] (x and y being CharacterVector)
* include/Rcpp/module/Module_generated_Pointer_CppMethod.h : remove
const and reference to OUT type in several places, that was causing
problems e.g. on making the Rcpp-modules vignette
* include/Rcpp/module/Module_generated_CppMethod.h : idem
2013-06-18 Romain Francois
* include/Rcpp/module/Module_generated_CppFunction.h : using
BEGIN_RCPP / END_RCPP as suggested by Ben North on Rcpp-devel. This
should reduce cross dll exceptions issues on windows.
2013-06-14 Romain Francois
* include/Rcpp/stats/random/runif.h : removed unused max variable
* include/Rcpp/stats/random/rf.h : removed unused n1 and n2 variables
2013-06-13 Romain Francois
* src/Module.cpp: small buglet in macro. Reported on Rcpp-devel
2013-06-12 Dirk Eddelbuettel
* inst/doc/Makefile: Force serial build of vignettes in yet another
effort to not let R-Forge fail when trying to rebuild them
2013-06-08 Dirk Eddelbuettel
* inst/doc/Rcpp.bib: Updated entries
* inst/doc/Rcpp-introduction.Rnw: Added pointer to 'Rcpp Attributes'
vignette, as well as to 'Rcpp Sugar' and 'Rcpp Modules' vignettes.
* inst/doc/Rcpp-FAQ/Rcpp-FAQ.Rnw: Idem
2013-06-06 Romain Francois
* unitTests/cpp/Vector.cpp : more unit tests for erase
* unitTests/runit.Vector.R : more unit tests for erase
2013-06-05 Romain Francois
* include/Rcpp/api/meat/Vector.h : fixed Vector<>::erase(iterator,
iterator) and correct return value of erase
* unitTests/cpp/Vector.cpp : added regression test for the above fix
* unitTests/runit.Vector.R : added regression test for the above fix
* include/Rcpp/module/class.h : removed useless typedef
2013-05-31 Romain Francois
* unitTests/runit.sugar.R : new test for is_infinite and is_nan
* unitTests/cpp/sugar.cpp : new test for is_infinite and is_nan
* include/Rcpp/sugar/functions/is_infinite.h : new function
is_infinite
* include/Rcpp/traits/is_infinite.h : new function is_infinite
* include/Rcpp/sugar/functions/is_nan.h : new function is_nan
* include/Rcpp/traits/is_nan.h : new function is_nan
2013-05-30 Romain Francois
* include/Rcpp/sugar/functions/all.h : bug fixed for the NA=false
case
* include/Rcpp/sugar/functions/is_na.h : header
* include/Rcpp/sugar/functions/is_finite.h : added sugar is_finite
function
* include/Rcpp/traits/is_finite.h : added is_finite trait
* unitTests/runit.sugar.R : added test for is_finite
* unitTests/cpp/S4.cpp : new cpp file to host S4 unit tests
* unitTests/runit.S4.R : rework unit tests to use attributes
* unitTests/runit.Reference.R : unit tests for Rcpp::Reference
* unitTests/cpp/Reference.cpp : unit tests c++ code
2013-05-26 Dirk Eddelbuettel
* src/api.cpp: Minor tweak for internal formatting
2013-05-24 J.J. Allaire
* R/Attributes.R: Disallow compilation for files that don't have
extensions supported by R CMD SHLIB
2013-05-21 J.J. Allaire
* R/Attributes.R: Lookup plugins in inline package if they aren't
found within the Rcpp package
* man/pluginsAttribute.Rd: Documentation updates.
2013-05-17 J.J. Allaire
* src/attributes.cpp: prevent gc problems with RNGScope destructor
in attributes generated functions; don't include package header
file in generated cpp exports file
* src/api.cpp: use unsigned long for RNG scope counter
2013-04-28 Dirk Eddelbuettel
* src/api.cpp (Rcpp): No longer use Rd_format(Real|Complex) which is
a very verboten R internal; formatting to string is now very bare
bones
2013-04-27 Dirk Eddelbuettel
* src/Makevars: Improved use as well as a new possible overrride of
/usr/bin/install_name_tool on OS X, once again contributed by Simon
2013-04-16 Romain Francois
* include/Rcpp/sugar/functions/na_omit.h : new function na_omit to
remove missing values from a vector.
* src/attributes.cpp : portability fix (from Martyn Plummer)
* include/Rcpp/api/meat/Vector.h : portability fix (from Martyn
Plummer)
2013-04-14 Romain Francois
* include/Rcpp/traits/is_na.h: complex version did not work.
added default for VECSXP and EXPRSXP versions
2013-04-02 Dirk Eddelbuettel
* src/Date.cpp: Corrected operator-() for Date and Datetime objects
to behave more inline with C++ standard
* inst/include/Rcpp/Date.h: operator-() for Dates now returns a
double as the date itself is fractional double since epoch
* inst/unitTests/cpp/dates.cpp: New file with C++ portion of tests
factored out from R unit test file
* inst/unitTests/runit.Date.R: Rewritten for use with new C++ tests
2013-04-02 Romain Francois
* include/Rcpp/generated/DataFrame_generated.h : DateFrame::create
uses List::create and then feeds to the DataFrame constructor, which
seems to work better than the previous approach of calling back to the
data.frame function in R
* include/Rcpp/DataFrame.h : private function from_list, to help
the new implementation of DataFrame::create
* src/api.cpp : impl of DataFrame::from_list
2013-03-31 Dirk Eddelbuettel
* debian/control (Build-Depends): Modified for Debian-only rebuilds
under (rc version of upcoming) R 3.0.0 release
* debian/changelog: Entry for Debian build 0.10.3-2
2013-03-29 Dirk Eddelbuettel
* src/api.cpp (Rcpp): Re-enable coerce_to_string<>() for real and
complex types with Poor Man's Versions (TM) of Rf_EncodeReal and
Rf_EncodeComplex which the Powers That Be disallow from being used
2013-03-27 Romain Francois
* include/Rcpp/vector/MatrixRow.h : removed unintended printed
messaged (reported on Rcpp-devel by Michaeal Love)
2013-03-23 Dirk Eddelbuettel
* DESCRIPTION: Release 0.10.3
* inst/NEWS.Rd: Release 0.10.3
* inst/include/Rcpp/config.h: Release 0.10.3
* debian/*: Similarly updated for new release to Debian
2013-03-21 Dirk Eddelbuettel
* inst/unitTests/runit.wstring.R (test.as_vector_wstring): replace
the "€" symbol with its unicode equivalent "\u20ac"
2013-03-20 Dirk Eddelbuettel
* inst/doc/Rcpp.bib: Updated versions for several CRAN packages
* inst/CITATION: Add information about forthcoming book
2013-03-20 Romain Francois
* include/Rcpp/traits/is_wide_string.h : fixes to re-enable wrap(
vector ) and wrap( vector ), needed to support package
httpuv
* include/Rcpp/internal/wrap.h : same
2013-03-19 Dirk Eddelbuettel
* inst/include/Rcpp/config.h: Define RCPP_USE_NEW_PRESERVE_RELEASE
with default value of 0 to enable/disable new preserve/release code
* src/api.cpp: Bracket the new Rcpp object preserve / release code
with the new variable RCPP_USE_NEW_PRESERVE_RELEASE and fall back
to R behaviour if not set
2013-03-12 Romain Francois
* include/Rcpp/Module.h: added virtual destructor to CppProperty
2013-03-08 Dirk Eddelbuettel
* inst/include/Rcpp/platform/compiler.h: Improved g++ version
detection with thanks to Yan Zhou
2013-02-28 JJ Allaire
* src/attributes.cpp: standalone roxygen chunks (e.g. to document
a class) are now transposed into RcppExports.R
2013-02-27 JJ Allaire
* R/Rcpp.package.skeleton.R: eliminated spurious empty hello world
function definition in Rcpp.package.skeleton
2013-02-24 JJ Allaire
* R/Attributes.R: add global package include file to RcppExports.cpp
if it exists; handle Rcpp module definitions in sourceCpp
* src/attributes.cpp: handle Rcpp module definitions in sourceCpp
* man/sourceCpp.Rd: documentation updates
2013-02-20 Dirk Eddelbuettel
* inst/include/Rcpp/platform/compiler.h: As deteced by Gong-Yi Liao,
we need to test for __LONG_LONG_MAX__ (defined in limits.h) and not
LONG_LONG_MAX (defined climits which we do not include)
2013-02-19 Romain Francois
* src/api.cpp : more debugging
* include/RcppCommon.h : move sexp_to_name here. Used in some debugging
* include/Rcpp/vector/MatrixRow.h : fix const version of operator[]
* include/Rcpp/vector/Vector.h : more debugging
* include/Rcpp/internal/wrap.h : more debugging. more dispatch.
2013-02-18 Romain Francois
* include/Rcpp/vector/string_proxy.h : only declare operator+=
* include/Rcpp/String.h : define string_proxy::operator+=, now that
String is defined.
2013-02-15 JJ Allaire
* R/Attributes.R: Merge existing values of build related
environment variables for sourceCpp
2013-02-12 Romain Francois
* src/api.cpp : More careful about RCPP_PROTECTION_STACK init
2013-02-08 Romain Francois
* include/Rcpp/as.h: re-enable as(CharacterVector[int])
2013-02-07 Dirk Eddelbuettel
* inst/THANKS: Adding Ben North for the help / bug report on iterators
2013-02-05 Romain Francois
* include/Rcpp/vector/string_proxy.h : more wstring support
* include/Rcpp/XPtr.h : more debugging. removed delete_finalizer
which is no longer used
2013-02-05 JJ Allaire
* src/attributes.cpp : ensure that line comments invalidate block
comments when parsing for attributes
2013-02-04 Romain Francois
* include/Rcpp/traits/r_type_traits.h : make the
r_type_pairstring_string_tag tag more general, handling wstring as
well as string
* include/Rcpp/internal/wrap.h : using make_charsexp, a more generic
version of charsexp_from_wstring.
* include/Rcpp/as.h : more support fot wstring
* include/Rcpp/internal/wrap.h : rework the support of wstring
* include/Rcpp/internal/export.h : added as_string_elt to rework the
support of wstring
* include/Rcpp/traits/char_type.h : new trait to help the wstring
support
* include/Rcpp/String.h : added some support for wstring
* include/Rcpp/vector/string_proxy.h : adapt to add wstring support
* unitTests/runit.wstring.R : unit tests for wstring support
* unitTests/cpp/wstring.cpp : unit tests for wstring support
2013-02-03 Romain Francois
* include/Rcpp/traits/wrap_type_traits.h : support for wrap( wstring )
* include/Rcpp/internal/export.h : exporting wstring and containers
of wstring
* include/Rcpp/internal/wrap.h : support for wrap( wstring ) and
containers of wstring
* include/RcppCommon.h : definition of charsexp_from_wstring
* src/api.cpp: implementation of charsexp_from_wstring
2013-02-02 Romain Francois
* include/Rcpp/vector/MatrixRow.h: correct operator++(int) and
operator--(int)
* include/Rcpp/internal/Proxy_Iterator.h: correct operators ++ and --
* include/Rcpp/sugar/Range.h: correct operators ++ and --
* include/Rcpp/sugar/tools/iterator.h: correct operators ++ and --
* include/Rcpp/vector/MatrixBase.h : correct operators ++ and --
* include/Rcpp/vector/VectorBase.h : correct operators ++ and --
* unitTests/cpp/Vector.cpp: new unit tests
* unitTests/runit.Vector.R: new unit tests
* src/api.cpp: comment dropTrailing0 which is not used anymore
* include/Rcpp/as.h: support for as
* include/Rcpp/internal/export.h: more support for wstring
2013-01-15 Dirk Eddelbuettel
* src/api.cpp (Rcpp): Commented-out coerce_to_string() for real and
complex arguments as R-devel (as of today) dislikes use of non-API
functions Rf_EncodeComplex’, ‘Rf_EncodeReal’, ‘Rf_formatComplex’
* .Rbuildignore: Added inst/include/Rcpp/preprocessor and
sugar/functions/impl which are currently empty directories
* src/Timer.cpp (Rcpp): Avoid a 'long long' warning from a const
2014-01-15 JJ Allaire
* R/Attributes.R: don't add source directory as an include path for
sourceCpp; fix duplicate inclusion of Rcpp directory
* R/RcppLdpath.R: don't quote paths on windows
2014-01-14 JJ Allaire
* DESCRIPTION: bump version to 0.10.2.3
* R/Attributes.R: handle build paths with spaces on windows
* R/RcppLdpath.R: handle build paths with spaces on windows
* R/tools.R: handle build paths with spaces on windows
* src/Timer.cpp: fix OSX build (remove __MACH__ define check)
* R/: set svn eol-style native for source files
* src/: set svn eol-style native for source files
* inst/include/: set svn eol-style native for source files
2014-01-13 JJ Allaire
* R/Attributes.R: use plugin includes in cppFunction; stop with
explicit error on Windows then the Rcpl libPath or sourceCpp target
file contains spaces in it's path; add source file directory as an
include path for sourceCpp; special handling for sourceCpp include
paths on windows
* man/pluginsAttribute.Rd: clarify which fields of plugin are
used by sourceCpp
2014-01-12 JJ Allaire
* DESCRIPTION: bump version to 0.10.2.2
* NAMESPACE: add registerPlugin function
* R/Attributes.R: add registerPlugin function; add plugins parameter
to cppFunction
* man/cppFunction.Rd: documentation updates
* man/pluginsAttribute.Rd: documentation updates
* man/registerPlugin: documentation updates
2014-01-11 JJ Allaire
* R/Attributes.R: initial support for Rcpp::plugins attribute; add
built-in cpp11 plugin
* src/attributes.cpp: initial support for Rcpp::plugins attribute
2014-01-04 JJ Allaire
* R/Attributes.R: null check on pkginfo depends field
2013-01-02 Dirk Eddelbuettel
* src/Timer.cpp (Rcpp): Applied refinement of previously applied
patch re *BSD builds, see http://bugs.debian.org/697032 for more
2012-12-30 Dirk Eddelbuettel
* src/Timer.cpp (Rcpp): Added defined() tests for more *BSD family
members as the build also failed with the FreeBSD Kernel on Debian
2012-12-27 Dirk Eddelbuettel
* src/Timer.cpp (Rcpp): Applied patch kindly supplied by Rainer
Hurling to support compilation on FreeBSD
2012-12-26 JJ Allaire
* R/Attributes.R: return invisibly from void functions
* src/attributes.cpp: return invisibly from void functions
2012-12-21 Romain Francois
* NAMESPACE : remove C++ObjectS3 and C++ClassRepresentation classes
* R/00_classes.R: remove unused S4 classes
* src/internal.h: added Rcpp_PreserveObject, Rcpp_ReleaseObject and
Rcpp_ReplaceObject as replacements to R_ versions. The back end of the Rcpp_
version is a list (generic vector) instead of a linked list and
is faster
* src/Module.cpp: more debugging
* src/barrier.cpp: added get_Rcpp_protection_stack used in the new
stack system for protecting/releasing objects in Rcpp
* src/api.cpp: implemetation of Rcpp_PreserveObject, Rcpp_ReleaseObject
and Rcpp_ReplaceObject. RObject::setSEXP now uses the new system.
The RObject(SEXP) constructor now directly uses Rcpp_PreserveObject
More debugging for the RObject class
Changes in api classes to better use the new protection system
* unitTests/cpp/language.cpp: hosting unit test in sourceCpp form
* unitTests/runit.Language.R: update unit tests
* unitTests/runit.Module.client.package.R: remove code that has been
commented for ages
* include/Rcpp/DottedPair.h: better use of the RObject constructor
* include/Rcpp/vector/Vector.h: better use of the RObject constructor
* include/Rcpp/vector/Matrix.h: Using update_matrix instead of the virtual
update which has been removed.
* include/Rcpp/Module.h : more careful about types and constructors
* include/Rcpp/XPtr.h: more debugging
* include/Rcpp/macros/debug.h: more debugging macros
* include/Rcpp/module/class_Base.h: using classes instead of SEXP
* include/Rcpp/module/class.h: using classes instead of SEXP
* include/Rcpp/generated/Language__ctors.h : using update_language_object
instead of the virtual update which has been removed.
* include/Rcpp/api/meat/Vector.h : using update_vector instead of the
virtual update that has been removed, more debugging
* include/Rcpp/api/meat/Matrix.h : more debugging, using update_matrix
instead of the virtual update which has been removed
* include/Rcpp/Language.h : added update_language_object to
replace update which was virtual
* include/Rcpp/RObject.h : only keep declarations here
2012-12-21 Dirk Eddelbuettel
* DESCRIPTION: Release 0.10.2
* inst/NEWS.Rd: Release 0.10.2
* inst/include/Rcpp/config.h: Release 0.10.2
* debian/*: Similarly updated for new release to Debian
* inst/doc/unitTests/Rcpp-unitTests.R: added one more variable so
that unitTest vignette can be built against new sourceCpp based files
2012-12-15 Romain Francois
* include/Rcpp/exceptions.h: added exception_to_r_condition
* exceptions.cpp: new implementation of forward_exception_to_r that
directly calls stop rather than a function in Rcpp
* R/exceptions.R: remove code rendered useless
* src/Rcpp_init.c: less exports
* src/api.cpp: less going back to the R side
2012-12-14 Romain Francois
* include/Rcpp/sugar/functions/clamp.h: clamp was pretty wrong
* unitTests/runit.sugar.R: new unit test for clamp
* unitTests/cpp/sugar.cpp: new unit test for clamp
2012-12-12 JJ Allaire
* src/Attributes.R: always generate new dynlib file for rebuild=TRUE
* src/attributes.cpp: set svn:eol-style to native; always generate
new dynlib file for rebuild=TRUE; don't declare attributes constant
strings extern
2012-12-12 Romain Francois
* include/Rcpp/Symbol.h: c_str becomes const and added
Symbol::operator==(const char* )
2012-12-11 JJ Allaire
* R/Attributes.R: always print output when shared library is not
created
* src/attributes.cpp: consolidate attributes into single file
* src/Attributes.cpp: consolidate attributes into single file
* src/AttributesGen.h: consolidate attributes into single file
* src/AttributesGen.cpp: consolidate attributes into single file
* src/AttributesParser.h: consolidate attributes into single file
* src/AttributesParser.cpp: consolidate attributes into single file
* src/AttributesTypes.h: consolidate attributes into single file
* src/AttributesUtil.h: consolidate attributes into single file
* inst/NEWS.Rd: additional notes on changes to attributes
* inst/doc/Rcpp-attributes/Rcpp-attributes.Rnw: update for changes to
attributes in 0.10.2
2012-12-11 Romain Francois
* include/Rcpp/String.h: missing operator +=( const StringProxy& )
* include/Rcpp/sugar/functions/strings/strings.h : string sugar functions
* include/Rcpp/sugar/functions/strings/collapse.h : collapse
function, implementing paste( . , collapse = "" )
* include/Rcpp/complex.h: operator==( Rcomplex, Rcomplex )
* src/api.cpp: implementation of operator==(Rcomplex, Rcomplex)
* include/Rcpp/vector/Vector.h: added const version of operator[](string)
2012-12-10 JJ Allaire
* R/Attributes.R: warn when depends attribute is not matched with
required entries in package description; add Rtools to PATH for
duration of sourceCpp
* src/Attributes.cpp: warn when depends attribute is not matched with
required entries in package description
* src/AttributesGen.cpp: prune unnecessary includes from RcppExports
* src/Timer.cpp: fix timer build issues on windows
2012-12-10 Romain Francois
* src/api.cpp: import r_cast.cpp, coerce.cpp, RcppCommon.cpp
and debugging.cpp content
* include/platform/compiler.h: put here compiler specific deduction things
* src/internal.h: new header to host function declarations for
routines that are not exported into Rcpp.h
* src/Rcpp_init.c: export capabilities (renamed rcpp_capabilities)
* include/Rcpp/traits/traits.h: master file for all traits includes
* include/Rcpp/macros/macros.h: master file for all macros includes
* include/Rcpp/DataFrame.h: just have declaration for DataFrame
* include/Rcpp/Benchmark/Timer.h: move it into the Rcpp:: namespace
* include/Rcpp/cache.h: clean
* include/Rcpp/Reference.h : field was declared const and should not
be. added a ConstFieldProxy class for read only use
2012-12-09 Romain Francois
* src/api.cpp: merge many .cpp files here to reduce compile time
* src/barrier.cpp: merge with cache.cpp to reduce compile time
* include/Rcpp/exceptions.h: drop forward_uncaught_exceptions_to_r
* src/exceptions.cpp: drop forward_uncaught_exceptions_to_r
* src/Date.cpp: merge all Date related files
2012-12-08 Romain Francois
* src/Timer.cpp: implementation of Timer
* include/Rcpp/Benchmark/Timer.h: internal performance timer, based on
the code from the microbenchmark package
* include/Rcpp/api/meat/Matrix.h: move more in Matrix meat
* src/Date.cpp: import the code from posixt.cpp
2012-12-07 JJ Allaire
* src/AttributesGen.cpp: use __ prefix for variables in generated
code; add RNGScope for attribute exported functions.
2012-12-07 Romain Francois
* src/random.cpp: instantiations of random generators here
* include/Rcpp/stats/random/random.h: only have declarations of
random generators here. Rework the Generator template so that it
inherits RNGScope to provide automatic calls to GetRNGstate and
PutRNGstate
2012-12-06 JJ Allaire
* R/Attributes.R: revert DOS newlines; use new shared library name
for each rebuild in sourceCpp
* src/Attributes.cpp: revert DOS newlines; define RCPP_NO_SUGAR;
use new shared library name for each rebuild in sourceCpp
* src/AttributesGen.cpp: revert DOS newlines; convert 'try-error'
to exception for C++ interfaces
* src/AttributesGen.h: 'try-error' to exception for C++ interfaces
* src/AttributesParser.cpp: revert DOS newlines; define RCPP_NO_SUGAR
* src/RcppCommon.cpp: conversion from exeption to 'try-error'
* include/Rcpp/exceptions.h: conversion from exeption to 'try-error'
* include/Rcpp/preprocessor.h: add END_RCPP_RETURN_ERROR macro
to convert exceptions to 'try-error' objects
* include/Rcpp/iostream/Rstreambuf.h: revert DOS newlines
* DESCRIPTION: bump version to 0.10.1.5
2012-12-06 Dirk Eddelbuettel
* src/exceptions.cpp: Added include of cstdlib to compile
2012-12-06 Romain Francois
* include/Rcpp/api/meat/Environment.h: meat for Environment
* src/exceptions.cpp: include config so that it knows that Rcpp can
demangle
* unitTests/runit.environments.R: using sourceCpp
* src/Environment.cpp: less includes
* src/Evaluator.cpp: less includes
2012-12-05 Romain Francois
* src/cache.cpp: added get_cache
* include/Rcpp/hash/IndexHash.h: use a cached integer vector for the
hash table payload. The cache vector increases as needed.
* include/Rcpp/iostream/Rostream.h: make Rostream a template
* include/Rcpp/iostream/Rstreambuf.h: make Rstreambuf a template
* src/AttributesGen.cpp : include exceptions.h which was included
implicitely by Rostream.h before
* include/Rcpp/macros/debug.h : factor out the debugging macros
* include/Rcpp/api/meat/RObject.h : only declare templates that use
as and wrap. they are implemented later in the meat directory
* include/Rcpp/api/meat/meat.h: directory containing implementations
of templates using as and wrap
* include/RcppCommon.h: removed unused test_named
* src/RcppCommon.cpp: removed unused test_named
* src/r_cast.cpp: less includes
* src/posixt.cpp: less includes
2012-12-05 JJ Allaire
* src/Attributes.R: direct hookup of external ptr in sourceCpp
* src/Attributes.cpp: use code generation for compileAttributes;
direct hookup of external ptr in sourceCpp
* src/AttributesGen.cpp: use code generation for compileAttributes;
direct hookup of external ptr in sourceCpp
* src/AttributesGen.h: use code generation for compileAttributes;
direct hookup of external ptr in sourceCpp
* src/Module.cpp: fix typo in GetCppCallable
* include/Rcpp/iostream/Rstreambuf.h: add cstdio include
* DESCRIPTION: bump version to 0.10.1.4
2012-12-04 Dirk Eddelbuettel
* inst/include/Rcpp/hash/hash.h: Added include inttypes.h for intptr_t
2012-12-04 JJ Allaire
* R/Attributes.R: use simple code generation for sourceCpp
* src/Attributes.cpp: move generators into their own source file;
use simple code generation for sourceCpp
* src/AttributesGen.cpp: move generators into their own source file;
add C++ default argument parsing
* src/AttributesGen.h: move generators into their own source file
* src/AttributesParser.cpp: move generators into their own source file
* src/AttributesParser.h: move generators into their own source file
* src/AttributesTypes.h: new header for attributes types
* src/AttributesUtil.h: new header for attributes utilities
2012-12-04 Romain Francois
* include/Rcpp/hash/hash.h: new implementation of IndexHash, based on
Simon's fastmatch package
* include/Rcpp/sugar/functions/match.h: more efficient version of match
using new IndexHash
* include/Rcpp/sugar/functions/unique.h: more efficient version of
unique and in using IndexHash
* include/Rcpp/sugar/functions/duplicated.h: more efficient version
of duplicated and in using IndexHash
* include/Rcpp/sugar/functions/self_match.h: more efficient version
of self_match and in using IndexHash
* include/Rcpp/vector/Vector.h: more efficiently create Vector from
sugar expression that are already vectors, i.e. grab the SEXP
2012-12-03 Dirk Eddelbuettel
* inst/include/RcppCommon.h: Applied patch kindly contributed by Yan
Zhou which provides a number of more refined definition for support
of both the C++11 standard and different compilers
* inst/include/Rcpp/internal/wrap.h: Idem
* inst/include/Rcpp/sugar/sugar.h: Idem
* inst/include/Rcpp/traits/comparator_type.h: Idem
* inst/include/Rcpp/vector/Vector.h: Idem
* inst/unitTests/runit.wrap.R: Idem
* src/RcppCommon.cpp: Idem
* DESCRIPTION: Increase minor dev. version once more
2012-12-03 JJ Allaire
* R/Attributes.R: added function to check whether R development
tools are currently installed
2012-12-03 Romain Francois
* src/Module.cpp: move BEGIN_RCPP/END_RCPP to Module__invoke
* src/coerce.cpp: added coerce_to_string implementations
* include/RcppCommon.h : nicer formatting for RCPP_DEBUG_*, now up to
RCPP_DEBUG_5
* include/Rcpp/vector/Vector.h: debugging
* include/Rcpp/String.h: The String class
* include/Rcpp/as.h: support for String
* include/Rcpp/vector/converter.h : support for String
* include/Rcpp/vector/string_proxy.h: support for String
* include/Rcpp/internal/wrap.h : support for String
* include/Rcpp/internal/r_coerce.h: support for String
* include/Rcpp/sugar/functions/sapply.h: debugging
* include/Rcpp/traits/wrap_type_traits.h: support for String
* include/Rcpp/traits/r_type_traits.h: support for String
* unitTests/cpp/String.cpp : unit tests for String
* unitTests/runit.String.R: unit test for String
* include/Rcpp/sugar/sets.h: support for String
2012-12-01 Dirk Eddelbuettel
* inst/include/RcppCommon.h: Applied patch by Yan Zhou to add support
for clang++ with libc++, and Intel's icpc when std=c++11
2012-11-29 Romain Francois
* unitTests/runit.DataFrame.R: using sourceCpp
* include/Rcpp/vector/Matrix.h: fix yet another const correctness issue
2012-11-27 Dirk Eddelbuettel
* inst/include/Rcpp/iostream/Rostream.h: Check before deleting buf
2012-11-26 Dirk Eddelbuettel
* DESCRIPTION: Release 0.10.1
* inst/NEWS.Rd: Release 0.10.1
* inst/include/Rcpp/config.h: Release 0.10.1
* debian/*: Similarly updated for new release to Debian
* DESCRIPTION: Added paragraph about Rcpp attributes
* debian/control: Idem
2012-11-26 Romain Francois
* include/Rcpp/Module.h: comment out the unused and unuseable
converter overload.
* include/Rcpp/sugar/functions/pmin.h: be consistent about how the
pmin_op helper struct is defined (always a struct).
* include/Rcpp/sugar/functions/pmax.h: same for pmax
* include/Rcpp/stats/random/rbeta.h: fixed constructor issue
* unitTests/runit.sugar.R: rework to use sourceCpp instead of inline
* include/Rcpp/vector/Vector.h: added ctor to deal with
SingleLogicalResult
* include/Rcpp/vector/Matrix.h: another const correctness fix
2012-11-25 JJ Allaire
* R/Attributes.R: use echo = TRUE for sourceCpp R code chunks
* src/Module.cpp: BEGIN_RCPP/END_RCPP in InternalFunction_invoke
* inst/doc/Rcpp-attributes/Rcpp-attributes.Rnw: add documentation
on correct semantics for signaling error conditions
2012-11-24 JJ Allaire
* inst/doc/Rcpp-attributes/Rcpp-attributes.Rnw: expand discussion
of binary compatibility issues.
2012-11-23 Romain Francois
* src/AttributesParser.cpp : attempt to fix build issue on r-forge
* include/Rcpp/DataFrame.h: nrows() method
* include/Rcpp/vector/RangeIndexer.h: now derives from VectorBase so
that we can use it in sugar.
2012-11-22 JJ Allaire
* include/exceptions.h: new exception constructor / stop function
* src/exceptions.cpp: new exception constructor / stop function
* include/RcppCommon.h: new exception constructor / stop function
2012-11-22 Romain Francois
* include/Rcpp/iostream.h: use delete rdbuf() as recommended by
Martyn Plummer
* include/Rcpp/sugar/functions/self_match.h: self_match, giving a
functionality similar to match( x, unique(x) )
* src/coerce.cpp: added coercion to STRSXP
* include/Rcpp/internal/r_coerce.h : added r_coerce<.,STRPSXP>
* include/Rcpp/sugar/functions/table.h: sugar table
* include/Rcpp/sugar/functions/duplicated.h: sugar duplicated
2012-11-21 JJ Allaire
* R/Rcpp.package.skeleton.R: add 'attributes' and 'cpp_files'
parameters to Rcpp.pacakge.skeleton
* inst/skeleton/rcpp_hello_world_attributes.cpp: version of hello world
that uses attributes
* man/Rcpp.package.skeleton.Rd: doc updates
* inst/doc/Rcpp-attributes/Rcpp-attributes.Rnw: doc updates
* DESCRIPTION: bump version to 0.10.0.3
2012-11-21 Dirk Eddelbuettel
* inst/examples/Misc/piBySimulation.r: New simple example using Rcpp
attributes in a 'compute pi by simulation in R and C++' exercise
* inst/examples/Misc/piSugar.cpp: Corresponding C++ variant
2012-11-21 Romain Francois
* include/Rcpp/iostream/Rostream.h: Fix warning given by -Wreorder
* include/Rcpp/sugar/functions/mapply/mapply_3.h: more flexible
* include/Rcpp/vector/Vector.h: More efficient assign_object, which
is used in the assignment operator
* include/Rcpp/sugar/functions/clamp.h: added clamp function
2012-11-20 JJ Allaire
* src/Attributes.cpp: ensure dynlib cache state is always updated
* inst/doc/Rcpp-attributes/Rcpp-attributes.Rnw: elaborate further
on exporting C++ interfaces from packages
2012-11-20 Romain Francois
* include/Rcpp/iostream/Rostream.h: change order of initiaization in
ctor. was making solaris compiler unhappy
* include/Rcpp/stats/random/rnorm.h: not using function pointer
generators, as this generates (anachronisms) warning on
solaris. Also, this version is more efficient since there is no need
to dereference the function pointer
2012-11-19 JJ Allaire
* src/AttributesParser.h: support for argument default values
* src/AttributesParser.cpp: support for argument default values
* src/Attributes.cpp: support for argument default values
* man/exportAttribute.Rd: documentation updates
* man/compileAttributes.Rd: documentation updates
* man/sourceCpp.Rd: documentation updates
* inst/doc/Rcpp-attributes/Rcpp-attributes.Rnw: add documentation
on changes to attributes in 0.10.1
2012-11-18 JJ Allaire
* R/Attributes.R: sourceCpp embedded R code; print warning if no
export attributes are found in source file
* src/AttributesParser.h: sourceCpp embedded R code
* src/AttributesParser.cpp: sourceCpp embedded R code; new scheme
for mixing user and generated C++ headers
* src/Attributes.cpp: sourceCpp embedded R code; include
above generated modules
* man/sourceCpp.Rd: documentation updates
* man/interfacesAttribute.Rd: documentation updates
2012-11-18 Romain Francois
* include/Rcpp/vector/converter.h: allow CharacterVector::create(
NA_STRING )
* include/Rcpp/sugar/functions/mapply/mapply_2.h: more cases in mapply
2012-11-17 Dirk Eddelbuettel
* inst/doc/Rcpp-modules/Rcpp-modules.Rnw: Change free function name
'range' to 'uniformRange' to protect it from getting clobbered by the
new sugar function range.
2012-11-17 Romain Francois
* include/Rcpp/internal/wrap_end.h: have calls to wrap as late as
possible so that they "see" all (potentially user defined) overloads
of wrap.
* include/Rcpp/internal/SEXP_Iterator.h: directly iterate over SEXP.
const iterator for List and ExpressionVector
2012-11-16 Romain Francois
* include/Rcpp/vector/Vector.h : added static methods Vector::is_na
and Vector::get_na
* include/Rcpp/sugar/functions/setdiff.h: initial version of setdiff
and intersect
* include/Rcpp/vector/MatrixColumn.h: dealing with const-ness
* include/Rcpp/vector/MatrixRow.h: dealing with const-ness
* include/Rcpp/vector/traits.h: dealing with const-ness
* include/Rcpp/vector/proxy.h: dealing with const-ness
* include/Rcpp/vector/MatrixBase.h: dealing with const-ness
* include/Rcpp/vector/Vector.h: dealing with const-ness
2012-11-15 Romain Francois
* include/Rcpp/sugar/logical/SingleLogicalResult.h : apply patch
suggested by Karl Millar
* R/Attributes.R: new R function areMacrosDefined
* man/evalCpp.Rd: documentation update
* include/Rcpp/sugar/functions/match.h : generic version of match
* include/Rcpp/sugar/tools/iterator.h: help iterator that helps
writing match in terms of stl algorithms.
* include/Rcpp/vector/Vector.h: class no_init that can be used to create
an uninitialized vector. e.g. IntegerVector out = no_init(10) ;
* include/Rcpp/sugar/functions/unique.h: sugar version of %in% using
unordered_set
* include/Rcpp/sugar/functions/minmax.h: min, max, and range
2012-11-14 JJ Allaire
* src/Attributes.cpp: create sourceCpp context list using single
statement
2012-11-14 Dirk Eddelbuettel
* inst/announce/ANNOUNCE-0.10.0.txt: Fix typo spotted by Martin
Morgan in announcement mail
2012-11-14 Romain Francois
* include/Rcpp/internal/wrap.h: fix for wrap( std::complex )
* include/Rcpp/module/class_Base.h: factored out from Module.h
* R/00_classes.R: the C++Class gains the parents slot to hold information
about parent classes of the class
* src/Module.cpp : The CppClass constructor fills the parents slot of C++Class
2012-11-13 Dirk Eddelbuettel
* DESCRIPTION: Release 0.10.0
* inst/NEWS: Release 0.10.0
* inst/include/Rcpp/config.h: Release 0.10.0
* debian/*: Similarly updated for new release to Debian
2012-11-13 Romain Francois
* include/Rcpp/as.h: as
* include/Rcpp/internal/wrap.h : wrap( enum )
* include/Rcpp/traits/wrap_type_traits.h: trait to help wrap( enum )
* include/Rcpp/traits/r_type_traits.h: trait to help as
* include/Rcpp/module/macros.h: macros RCPP_EXPOSED_ENUM to help as/wrap
of enums
2012-11-12 Dirk Eddelbuettel
* inst/announce/ANNOUNCE-0.10.0.txt: Announcement draft
2012-11-12 JJ Allaire
* inst/doc/Rcpp-attributes/*: New vignette
2012-11-12 Romain Francois
* include/Rcpp/vector/Vector.h : adding const_iterator and associated
begin() and end() methods
* include/Rcpp/vector/Matrix.h : idem
2012-11-11 JJ Allaire
* src/Attributes.cpp: fully qualify _ in generated code
2012-11-11 Romain Francois
* include/Rcpp/iostream/Rstreambuf.h: implementing sync() so that
flush works
* src/Rstreambuf.cpp: implementation
* src/Rostream.cpp : added Rcerr that forwards to REprintf
2012-11-10 JJ Allaire
* R/Attributes.R: ensure function definitions are never stale
* src/Attributes.cpp: add optional hook for inclusion of package types
* examples/Attributes/Export.cpp: example use of Rcpp::export
* examples/Attributes/Depends.cpp: example use of Rcpp::depends
* examples/Attributes/sourceCpp.R: example use of sourceCpp()
* examples/Attributes/cppFunction.R: example use of cppFunction()
2012-11-09 Romain Francois
* R/Attributes.R: Passing verbose from evalCpp to cppFunction
* include/RcppCommon.h: include instead of
* include/Rcpp/vector/CharacterVectorExtractionIterator.h: iterator
class to quickly iterate over the content of a CharacterVector. The
content that is iterated over is to be considered read-only.
2012-11-08 JJ Allaire
* R/Attributes.R: special sourceCpp handling for file within the src
directory of a package; use .h as suffix for generated headers
* src/Attributes.cpp: add information on arguments to Rcpp module;
use inline rather than static linkage for generated C++ shims;
generated headers: add header guard and use .h suffix;
* man/cppFunction.Rd: update documentation
* man/sourceCpp.Rd: update documentation
* man/evalCpp.Rd: update documentation
* man/exportAttribute.Rd: update documentation
* man/interfacesAttribute.Rd: update documentation
2012-11-08 Romain Francois
* R/Module.R: Module functions taking no arguments don't get the ellipsis
anymore in their formals
* src/Module.cpp: passing up the number of arguments of the function
* R/Attributes.R: added evalCpp
* man/evalCpp.Rd: documentation for evalCpp
2012-11-07 JJ Allaire
* R/Attributes.R: derive depends from package LinkingTo; change
sourceCpp plugin parameter to depends and respect Rcpp::interfaces
generated include files
* src/Attributes.cpp: validate exported C++ functions before calling;
use static rather than inline for stubs to avoid call-site bloat;
improved error message when package hpp already exists; import Rcpp
namespace into package shim namespace
* src/AttributesParser.h: add signature and isHidden methods
* src/AttributesParser.cpp: add signature and isHidden methods
* src/exceptions.cpp: add function_not_exported exception
* include/Rcpp/exceptions.h: add function_not_exported exception
* man/cppFunction.Rd: update documentation
* man/sourceCpp.Rd: update documentation
* man/compileAttributes.Rd: update documentation
* man/dependsAttribute.Rd: update documentation
* man/exportAttribute.Rd: update documentation
* man/interfacesAttribute.Rd: update documentation
2012-11-07 Romain Francois
* src/Language.cpp: Language gains a fast_eval method, without the whole try/catch
* src/barrier.cpp: function char_nocheck to avoid the check in using CHAR
* include/Rcpp/sugar/functions/unique.h: sugar unique and sort_unique
using unordered_set (perhaps we could use it from c++11).
2012-11-06 JJ Allaire
* R/Attributes.R: tweak whitespace in verbose mode
* src/AttributesParser.h: support for interfaces attribute
* src/AttributesParser.cpp: support for interfaces attribute
* src/Attributes.cpp: support for interfaces attribute; refactor
code generators; use single module for exports; return list of
updated files from compileAttributes
* src/Module.cpp: add package parameter to GetCppCallable
* include/Rcpp/Module.h: add package parameter to GetCppCallable
* man/compileAttributes.Rd: documentation updates
2012-11-05 Romain Francois
* include/Rcpp/Module.h: added class CppInheritedProperty to handle
inherited properties
* include/Rcpp/module/class.h: implemented inheritance of properties
2012-11-05 JJ Allaire
* R/Attributes.R: use modules for attribute code generation
* src/Attributes.cpp: use modules for attribute code generation
* src/AttributesParser.h: use modules for attribute code generation
* src/AttributesParser.cpp: use modules for attribute code generation
2012-11-04 Dirk Eddelbuettel
* tests/doRUnit.R: In "development releases" (such as 0.9.15.5) we
now default to setting the required CRAN-test-workaround-kludge
"RunAllRcppTests" to "yes" as a default -- but not for actual
releases (with versions such as 0.9.15)
2012-11-04 Romain Francois
* include/Rcpp/module/CppFunction.h: fixed module bug (virtual function
was not defined)
2012-11-03 JJ Allaire
* Use CLINK_CPPFLAGS rather than PKG_CXXFLAGS for LinkingTo
include directories (identical behavior to inline)
2012-11-03 Romain Francois
* include/Rcpp/sugar/functions/which_min.h : sugar which.min
* include/Rcpp/sugar/functions/which_max.h : sugar which.max
* include/Rcpp/module/Module.h : added get_function_ptr which returns
the pointer of the target function as a DL_FUNC
2012-11-02 Dirk Eddelbuettel
* inst/unitTests/runit.rmath.R: More tests added
2012-11-02 Romain Francois
* include/Rcpp/module/CppFunction.h : factored CppFunction in its own
file and added the get_function_ptr virtual method. added
documentation
* include/Rcpp/module/Module_generated_CppFunction.h: implementation
of get_function_ptr in classes that derive CppFunction
* src/Module.cpp: s/get_function_ptr/get_function/
* include/Rcpp/module/Module.h : factored out and documented.
s/get_function_ptr/get_function/
2012-11-01 Dirk Eddelbuettel
* inst/unitTests/runit.rmath.R: New unit test file added
2012-11-01 JJ Allaire
* R/Attributes.R: change 'envir' param to 'env' for consistency with
the interface of loadModule
* man/sourceCpp.Rd: documentation updates
* man/cppFunction.Rd: documentation updates
2012-11-01 Romain Francois
* include/Rcpp/sugar/logical/or.h : implementing x | y where x and y
are Logical sugar expressions
* include/Rcpp/sugar/logical/and.h : implementing x & y where x and y
are Logical sugar expressions
2012-10-31 JJ Allaire
* R/Attributes.R: add cppFunction for inline-style definitions;
change 'local' param to (more clear and explicit) 'envir' param;
change 'show.output' param to 'showOutput'; add parameter to
onBuild hook to indicate if the source was from a 'code' parameter
* src/Attributes.cpp: factored parser into it's own file
* src/AttributesParser.h: attributes parser header
* src/AttributesParser.cpp: attributes parser implementation
* man/sourceCpp.Rd: documentation updates
* man/compileAttributes.Rd: documentation updates
* man/cppFunction.Rd: documentation for cppFunction
* NAMESPACE: export for cppFunction
2012-10-31 Romain Francois