// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; indent-tabs-mode: nil; -*-

//

// attributes.cpp: Rcpp R/C++ interface class library -- Rcpp attributes

//

// Copyright (C) 2012 - 2013 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 <http://www.gnu.org/licenses/>.

#define COMPILING_RCPP

#include <sys/types.h>

#include <sys/stat.h>

#include <errno.h>

#include <cstring>

#include <string>

#include <vector>

#include <map>

#include <set>

#include <algorithm>

#include <fstream>

#include <sstream>

#define RCPP_NO_SUGAR

#include <Rcpp.h>

/*******************************************************************

* AttributesUtil.h

*******************************************************************/

namespace Rcpp {

namespace attributes {

// Utility class for getting file existence and last modified time

class FileInfo {

public:

explicit FileInfo(const std::string& path);

std::string path() const { return path_; }

bool exists() const { return exists_; }

time_t lastModified() const { return lastModified_; }

private:

std::string path_;

bool exists_;

time_t lastModified_;

};

// Remove a file

bool removeFile(const std::string& path);

// Recursively create a directory

void createDirectory(const std::string& path);

// Known whitespace chars

extern const char * const kWhitespaceChars;

// Query whether a character is whitespace

bool isWhitespace(char ch);

// Trim a string

void trimWhitespace(std::string* pStr);

// Strip trailing line comments

void stripTrailingLineComments(std::string* pStr);

// Strip balanced quotes from around a string (assumes already trimmed)

void stripQuotes(std::string* pStr);

// is the passed string quoted?

bool isQuoted(const std::string& str);

// show a warning message

void showWarning(const std::string& msg);

// is the line a C++ roxygen comment? (started with //')

bool isRoxygenCpp(const std::string& str);

} // namespace attributes

} // namespace Rcpp

/*******************************************************************

* AttributesTypes.h

*******************************************************************/

namespace Rcpp {

namespace attributes {

// Known attribute names & parameters

const char * const kExportAttribute = "export";

const char * const kDependsAttribute = "depends";

const char * const kPluginsAttribute = "plugins";

const char * const kInterfacesAttribute = "interfaces";

const char * const kInterfaceR = "r";

const char * const kInterfaceCpp = "cpp";

// Type info

class Type {

public:

Type() {}

Type(const std::string& name, bool isConst, bool isReference)

: name_(name), isConst_(isConst), isReference_(isReference)

{

}

bool empty() const { return name().empty(); }

const std::string& name() const { return name_; }

std::string full_name() const {

std::string res ;

if( isConst() ) res += "const " ;

res += name() ;

if( isReference() ) res += "&" ;

return res ;

}

bool isVoid() const { return name() == "void"; }

bool isConst() const { return isConst_; }

bool isReference() const { return isReference_; }

private:

std::string name_;

bool isConst_;

bool isReference_;

};

// Argument info

class Argument {

public:

Argument() {}

Argument(const std::string& name,

const Type& type,

const std::string& defaultValue)

: name_(name), type_(type), defaultValue_(defaultValue)

{

}

bool empty() const { return type().empty(); }

const std::string& name() const { return name_; }

const Type& type() const { return type_; }

const std::string& defaultValue() const { return defaultValue_; }

private:

std::string name_;

Type type_;

std::string defaultValue_;

};

// Function info

class Function {

public:

Function() {}

Function(const Type& type,

const std::string& name,

const std::vector<Argument>& arguments,

const std::string& source)

: type_(type), name_(name), arguments_(arguments), source_(source)

{

}

Function renamedTo(const std::string& name) const {

return Function(type(), name, arguments(), source());

}

std::string signature() const { return signature(name()); }

std::string signature(const std::string& name) const;

bool isHidden() const {

return name().find_first_of('.') == 0;

}

bool empty() const { return name().empty(); }

const Type& type() const { return type_; }

const std::string& name() const { return name_; }

const std::vector<Argument>& arguments() const { return arguments_; }

const std::string& source() const { return source_; }

private:

Type type_;

std::string name_;

std::vector<Argument> arguments_;

std::string source_;

};

// Attribute parameter (with optional value)

class Param {

public:

Param() {}

explicit Param(const std::string& paramText);

bool empty() const { return name().empty(); }

const std::string& name() const { return name_; }

const std::string& value() const { return value_; }

private:

std::string name_;

std::string value_;

};

// Attribute (w/ optional params and signature of function it qualifies)

class Attribute {

public:

Attribute() {}

Attribute(const std::string& name,

const std::vector<Param>& params,

const Function& function,

const std::vector<std::string>& roxygen)

: name_(name), params_(params), function_(function), roxygen_(roxygen)

{

}

bool empty() const { return name().empty(); }

const std::string& name() const { return name_; }

const std::vector<Param>& params() const { return params_; }

Param paramNamed(const std::string& name) const;

bool hasParameter(const std::string& name) const {

return !paramNamed(name).empty();

}

const Function& function() const { return function_; }

bool isExportedFunction() const {

return (name() == kExportAttribute) && !function().empty();

}

std::string exportedName() const {

if (!params().empty())

return params()[0].name();

else

return function().name();

}

const std::vector<std::string>& roxygen() const { return roxygen_; }

private:

std::string name_;

std::vector<Param> params_;

Function function_;

std::vector<std::string> roxygen_;

};

class FunctionMap {

std::map< std::string, std::vector<Function> > map_ ;

public:

FunctionMap(){};

~FunctionMap(){} ;

void insert( const Function& fun ){

map_[ fun.name() ].push_back( fun ) ;

}

} ;

// Operator << for parsed types

std::ostream& operator<<(std::ostream& os, const Type& type);

std::ostream& operator<<(std::ostream& os, const Argument& argument);

std::ostream& operator<<(std::ostream& os, const Function& function);

std::ostream& operator<<(std::ostream& os, const Param& param);

std::ostream& operator<<(std::ostream& os, const Attribute& attribute);

// interface to source file attributes

class SourceFileAttributes

{

public:

virtual ~SourceFileAttributes() {};

virtual const std::string& sourceFile() const = 0;

virtual bool hasInterface(const std::string& name) const = 0;

typedef std::vector<Attribute>::const_iterator const_iterator;

virtual const_iterator begin() const = 0;

virtual const_iterator end() const = 0;

virtual const std::vector<std::string>& modules() const = 0;

virtual const std::vector<std::vector<std::string> >& roxygenChunks() const = 0;

virtual bool hasGeneratorOutput() const = 0;

};

} // namespace attributes

} // namespace Rcpp

/*******************************************************************

* AttributesParser.h

*******************************************************************/

namespace Rcpp {

namespace attributes {

// Helper class for determining whether we are in a comment

class CommentState {

public:

CommentState() : inComment_(false) {}

private:

// prohibit copying

CommentState(const CommentState&);

CommentState& operator=(const CommentState&);

public:

bool inComment() const { return inComment_; }

void submitLine(const std::string& line);

void reset() { inComment_ = false; }

private:

bool inComment_;

};

// Class used to parse and return attribute information from a source file

class SourceFileAttributesParser : public SourceFileAttributes {

public:

explicit SourceFileAttributesParser(const std::string& sourceFile);

private:

// prohibit copying

SourceFileAttributesParser(const SourceFileAttributesParser&);

SourceFileAttributesParser& operator=(const SourceFileAttributesParser&);

public:

// implemetnation of SourceFileAttributes interface

virtual const std::string& sourceFile() const {

return sourceFile_;

}

virtual const_iterator begin() const { return attributes_.begin(); }

virtual const_iterator end() const { return attributes_.end(); }

virtual const std::vector<std::string>& modules() const

{

return modules_;

}

virtual const std::vector<std::vector<std::string> >& roxygenChunks() const {

return roxygenChunks_;

}

virtual bool hasGeneratorOutput() const

{

return !attributes_.empty() ||

!modules_.empty() ||

!roxygenChunks_.empty();

}

virtual bool hasInterface(const std::string& name) const {

for (const_iterator it=begin(); it != end(); ++it) {

if (it->name() == kInterfacesAttribute) {

return it->hasParameter(name);

}

}

// if there's no interfaces attrbute we default to R

if (name == kInterfaceR)

return true;

else

return false;

}

// Get lines of embedded R code

const std::vector<std::string>& embeddedR() const {

return embeddedR_;

}

private:

// Parsing helpers

Attribute parseAttribute(const std::vector<std::string>& match,

int lineNumber);

std::vector<Param> parseParameters(const std::string& input);

Function parseFunction(size_t lineNumber);

std::string parseSignature(size_t lineNumber);

std::vector<std::string> parseArguments(const std::string& argText);

Type parseType(const std::string& text);

// Validation helpers

bool isKnownAttribute(const std::string& name) const;

void attributeWarning(const std::string& message,

const std::string& attribute,

size_t lineNumber);

void attributeWarning(const std::string& message, size_t lineNumber);

void rcppExportWarning(const std::string& message, size_t lineNumber);

void rcppExportNoFunctionFoundWarning(size_t lineNumber);

void rcppExportInvalidParameterWarning(const std::string& param,

size_t lineNumber);

void rcppInterfacesWarning(const std::string& message,

size_t lineNumber);

private:

std::string sourceFile_;

CharacterVector lines_;

std::vector<Attribute> attributes_;

FunctionMap functionMap_ ;

std::vector<std::string> modules_;

std::vector<std::string> embeddedR_;

std::vector<std::vector<std::string> > roxygenChunks_;

std::vector<std::string> roxygenBuffer_;

};

} // namespace attributes

} // namespace Rcpp

/*******************************************************************

* AttributesGen.h

*******************************************************************/

namespace Rcpp {

namespace attributes {

// Abstract class which manages writing of code for compileAttributes

class ExportsGenerator {

protected:

ExportsGenerator(const std::string& targetFile,

const std::string& package,

const std::string& commentPrefix);

private:

// prohibit copying

ExportsGenerator(const ExportsGenerator&);

ExportsGenerator& operator=(const ExportsGenerator&);

public:

virtual ~ExportsGenerator() {}

// Name of target file and package

const std::string& targetFile() const { return targetFile_; }

const std::string& package() const { return package_; }

// Abstract interface for code generation

virtual void writeBegin() = 0;

void writeFunctions(const SourceFileAttributes& attributes,

bool verbose); // see doWriteFunctions below

virtual void writeEnd() = 0;

virtual bool commit(const std::vector<std::string>& includes) = 0;

// Remove the generated file entirely

bool remove();

// Allow generator to appear as a std::ostream&

operator std::ostream&() {

return codeStream_;

}

protected:

// Allow access to the output stream

std::ostream& ostr() {

return codeStream_;

}

bool hasCppInterface() const {

return hasCppInterface_;

}

// Shared knowledge about function namees

std::string exportValidationFunction() {

return "RcppExport_validate";

}

std::string exportValidationFunctionRegisteredName() {

return package() + "_" + exportValidationFunction();

}

std::string registerCCallableExportedName() {

return package() + "_RcppExport_registerCCallable";

}

// Commit the stream -- is a no-op if the existing code is identical

// to the generated code. Returns true if data was written and false

// if it wasn't (throws exception on io error)

bool commit(const std::string& preamble = std::string());

private:

// Private virtual for doWriteFunctions so the base class

// can always intercept writeFunctions

virtual void doWriteFunctions(const SourceFileAttributes& attributes,

bool verbose) = 0;

// Check whether it's safe to overwrite this file (i.e. whether we

// generated the file in the first place)

bool isSafeToOverwrite() const {

return existingCode_.empty() ||

(existingCode_.find(generatorToken()) != std::string::npos);

}

// UUID that we write into a comment within the file (so that we can

// strongly identify that a file was generated by us before overwriting it)

std::string generatorToken() const {

return "10BE3573-1514-4C36-9D1C-5A225CD40393";

}

private:

std::string targetFile_;

std::string package_;

std::string commentPrefix_;

std::string existingCode_;

std::ostringstream codeStream_;

bool hasCppInterface_;

};

// Class which manages generating RcppExports.cpp

class CppExportsGenerator : public ExportsGenerator {

public:

explicit CppExportsGenerator(const std::string& packageDir,

const std::string& package,

const std::string& fileSep);

virtual void writeBegin() {};

virtual void writeEnd();

virtual bool commit(const std::vector<std::string>& includes);

private:

virtual void doWriteFunctions(const SourceFileAttributes& attributes,

bool verbose);

std::string registerCCallable(size_t indent,

const std::string& exportedName,

const std::string& name) const;

private:

std::vector<Attribute> cppExports_;

};

// Class which manages generating PackageName_RcppExports.h header file

class CppExportsIncludeGenerator : public ExportsGenerator {

public:

CppExportsIncludeGenerator(const std::string& packageDir,

const std::string& package,

const std::string& fileSep);

virtual void writeBegin();

virtual void writeEnd();

virtual bool commit(const std::vector<std::string>& includes);

private:

virtual void doWriteFunctions(const SourceFileAttributes& attributes,

bool verbose);

std::string getCCallable(const std::string& function) const;

std::string getHeaderGuard() const;

private:

std::string includeDir_;

};

// Class which manages generating PackageName_RcppExports.h header file

class CppPackageIncludeGenerator : public ExportsGenerator {

public:

CppPackageIncludeGenerator(const std::string& packageDir,

const std::string& package,

const std::string& fileSep);

virtual void writeBegin() {}

virtual void writeEnd();

virtual bool commit(const std::vector<std::string>& includes);

private:

virtual void doWriteFunctions(const SourceFileAttributes& attributes,

bool verbose) {}

std::string getHeaderGuard() const;

private:

std::string includeDir_;

};

// Class which manages generator RcppExports.R

class RExportsGenerator : public ExportsGenerator {

public:

RExportsGenerator(const std::string& packageDir,

const std::string& package,

const std::string& fileSep);

virtual void writeBegin() {}

virtual void writeEnd();

virtual bool commit(const std::vector<std::string>& includes);

private:

virtual void doWriteFunctions(const SourceFileAttributes& attributes,

bool verbose);

};

// Class to manage and dispatch to a list of generators

class ExportsGenerators {

public:

typedef std::vector<ExportsGenerator*>::iterator Itr;

ExportsGenerators() {}

virtual ~ExportsGenerators();

void add(ExportsGenerator* pGenerator);

void writeBegin();

void writeFunctions(const SourceFileAttributes& attributes,

bool verbose);

void writeEnd();

// Commit and return a list of the files that were updated

std::vector<std::string> commit(

const std::vector<std::string>& includes);

// Remove and return a list of files that were removed

std::vector<std::string> remove();

private:

// prohibit copying

ExportsGenerators(const ExportsGenerators&);

ExportsGenerators& operator=(const ExportsGenerators&);

private:

std::vector<ExportsGenerator*> generators_;

};

// Standalone generation helpers (used by sourceCpp)

std::string generateRArgList(const Function& function);

void generateCpp(std::ostream& ostr,

const SourceFileAttributes& attributes,

bool includePrototype,

bool cppInterface,

const std::string& contextId);

} // namespace attributes

} // namespace Rcpp

/*******************************************************************

* AttributesParser.cpp

*******************************************************************/

namespace Rcpp {

namespace attributes {

namespace {

Rcpp::List regexMatches(Rcpp::CharacterVector lines,

const std::string& regex)

{

Rcpp::Environment base("package:base");

Rcpp::Function regexec = base["regexec"];

Rcpp::Function regmatches = base["regmatches"];

Rcpp::RObject result = regexec(regex, lines);

Rcpp::List matches = regmatches(lines, result);

return matches;

}

// Parse embedded R code chunks from a file (receives the lines of the

// file as a CharcterVector for using with regexec and as a standard

// stl vector for traversal/insepection)

std::vector<std::string> parseEmbeddedR(

Rcpp::CharacterVector linesVector,

const std::deque<std::string>& lines) {

Rcpp::List matches = regexMatches(linesVector,

"^\\s*/\\*{3,}\\s+[Rr]\\s*$");

bool withinRBlock = false;

CommentState commentState;

std::vector<std::string> embeddedR;

for (int i = 0; i<matches.size(); i++) {

// track comment state

std::string line = lines[i];

commentState.submitLine(line);

// is this a line that begins an R code block?

const Rcpp::CharacterVector match = matches[i];

bool beginRBlock = match.size() > 0;

// check state and do the right thing

if (beginRBlock) {

withinRBlock = true;

}

else if (withinRBlock) {

if (commentState.inComment())

embeddedR.push_back(line);

else

withinRBlock = false;

}

}

return embeddedR;

}

} // anonymous namespace

// Generate a type signature for the function with the provided name

// (type signature == function pointer declaration)

std::string Function::signature(const std::string& name) const {

std::ostringstream ostr;

ostr << type() << "(*" << name << ")(";

const std::vector<Argument>& args = arguments();

for (std::size_t i = 0; i<args.size(); i++) {

ostr << args[i].type();

if (i != (args.size()-1))

ostr << ",";

}

ostr << ")";

return ostr.str();

}

// Parse attribute parameter from parameter text

Param::Param(const std::string& paramText)

{

// parse out name/value pair if there is one

std::string::size_type pos = paramText.find("=") ;

if ( pos != std::string::npos ) {

// name

name_ = paramText.substr(0, pos);

trimWhitespace(&name_);

// value

value_ = paramText.substr(pos + 1) ;

trimWhitespace(&value_);

stripQuotes(&value_);

}

else {

name_ = paramText;

stripQuotes(&name_);

}

}

// Check if the attribute has a parameter of a paricular name

Param Attribute::paramNamed(const std::string& name) const {

for (std::vector<Param>::const_iterator

it = params_.begin(); it != params_.end(); ++it) {

if (it->name() == name)

return *it;

}

return Param();

}

// Type operator <<

std::ostream& operator<<(std::ostream& os, const Type& type) {

if (!type.empty()) {

if (type.isConst())

os << "const ";

os << type.name();

if (type.isReference())

os << "&";

}

return os;

}

// Argument operator <<

std::ostream& operator<<(std::ostream& os, const Argument& argument) {

if (!argument.empty()) {

os << argument.type();

if (!argument.name().empty()) {

os << " ";

os << argument.name();

if (!argument.defaultValue().empty())

os << " = " << argument.defaultValue();

}

}

return os;

}

// Function operator <<

std::ostream& operator<<(std::ostream& os, const Function& function) {

if (!function.empty()) {

if (!function.type().empty()) {

os << function.type();

os << " ";

}

os << function.name();

os << "(";

const std::vector<Argument>& arguments = function.arguments();

for (std::size_t i = 0; i<arguments.size(); i++) {

os << arguments[i];

if (i != (arguments.size()-1))

os << ", ";

}

os << ")";

}

return os;

}

// Param operator <<

std::ostream& operator<<(std::ostream& os, const Param& param) {

if (!param.empty()) {

os << param.name();

if (!param.value().empty())

os << "=" << param.value();

}

return os;

}

// Attribute operator <<

std::ostream& operator<<(std::ostream& os, const Attribute& attribute) {

if (!attribute.empty()) {

os << "[[Rcpp::" << attribute.name();

const std::vector<Param>& params = attribute.params();

if (params.size() > 0) {

os << "(";

for (std::size_t i = 0; i<params.size(); i++) {

os << params[i];

if (i != (params.size()-1))

os << ",";

}

os << ")";

}

os << "]]";

if (!attribute.function().empty())

os << " " << attribute.function();

}

return os;

}

// Parse the attributes from a source file

SourceFileAttributesParser::SourceFileAttributesParser

(const std::string& sourceFile)

: sourceFile_(sourceFile)

{

// First read the entire file into a std::stringstream so we can check

// it for attributes (we don't want to do any of our more expensive

// processing steps if there are no attributes to parse)

std::ifstream ifs(sourceFile_.c_str());

if (ifs.fail())

throw Rcpp::file_io_error(sourceFile_);

std::stringstream buffer;

buffer << ifs.rdbuf();

std::string contents = buffer.str();

// Check for attribute signature

if (contents.find("[[Rcpp::") != std::string::npos ||

contents.find("RCPP_MODULE") != std::string::npos) {

// Now read into a list of strings (which we can pass to regexec)

// First read into a std::deque (which will handle lots of append

// operations efficiently) then copy into an R chracter vector

std::string line;

std::deque<std::string> lines;

while(std::getline(buffer, line)) {

// strip \r (for the case of windows line terminators on posix)

if (line.length() > 0 && *line.rbegin() == '\r')

line.erase(line.length()-1, 1);

stripTrailingLineComments(&line);

lines.push_back(line);

}

lines_ = Rcpp::wrap(lines);

// Scan for attributes

CommentState commentState;

Rcpp::List matches = regexMatches(lines_,

"^\\s*//\\s*\\[\\[Rcpp::(\\w+)(\\(.*?\\))?\\]\\]\\s*$");

for (int i = 0; i<matches.size(); i++) {

// track whether we are in a comment and bail if we are in one

std::string line = lines[i];

commentState.submitLine(line);

if (commentState.inComment())

continue;

// attribute line

const Rcpp::CharacterVector match = matches[i];

if (match.size() > 0) {

// if the match size isn't 3 then regmatches has not behaved

// as expected (it should return a vector of either 0 or 3

// elements). we don't ever expect this to occur but if it

// does let's not crash

if (match.size() != 3)

continue;

// add the attribute

Attribute attr = parseAttribute(

Rcpp::as<std::vector<std::string> >(match), i);

attributes_.push_back(attr);

if( attr.isExportedFunction() ){

functionMap_.insert(attr.function());

}

}

// if it's not an attribute line then it could still be a

// line of interest (e.g. roxygen comment)

else {

// save roxygen comments

if (line.find("//'") == 0) {

std::string roxLine = "#" + line.substr(2);

roxygenBuffer_.push_back(roxLine);

}

// a non-roxygen line causes us to clear the roxygen buffer

else if (!roxygenBuffer_.empty()) {

roxygenChunks_.push_back(roxygenBuffer_);

roxygenBuffer_.clear();

}

}

}

// Scan for Rcpp modules

commentState.reset();

Rcpp::List modMatches = regexMatches(lines_,

"^\\s*RCPP_MODULE\\s*\\(\\s*(\\w+)\\s*\\).*$");

for (int i = 0; i<modMatches.size(); i++) {

// track whether we are in a comment and bail if we are in one

std::string line = lines[i];

commentState.submitLine(line);

if (commentState.inComment())

continue;

// get the module declaration

Rcpp::CharacterVector match = modMatches[i];

if (match.size() > 0) {

const char * name = match[1];

modules_.push_back(name);

}

}

// Parse embedded R

embeddedR_ = parseEmbeddedR(lines_, lines);

}

}

// Parse an attribute from the vector returned by regmatches

Attribute SourceFileAttributesParser::parseAttribute(

const std::vector<std::string>& match,

int lineNumber) {

// Attribute name

std::string name = match[1];

// Warn if this is an unknown attribute

if (!isKnownAttribute(name)) {

attributeWarning("Unrecognized attribute Rcpp::" + name,

lineNumber);

}

// Extract params if we've got them

std::vector<Param> params;

std::string paramsText = match[2];

if (!paramsText.empty()) {

// we know from the regex that it's enclosed in parens so remove

// trim before we do this just in case someone updates the regex

// to allow for whitespace around the call

trimWhitespace(&paramsText);

paramsText = paramsText.substr(1, paramsText.size()-2);

// parse the parameters

params = parseParameters(paramsText);

}

// Extract function signature if this is a function attribute

// and it doesn't appear at the end of the file

Function function;

// special handling for export

if (name == kExportAttribute) {

// parse the function (unless we are at the end of the file in

// which case we print a warning)

if ((lineNumber + 1) < lines_.size())

function = parseFunction(lineNumber + 1);

else

rcppExportWarning("No function found", lineNumber);

}

// validate interfaces parameter

else if (name == kInterfacesAttribute) {

if (params.empty()) {

rcppInterfacesWarning("No interfaces specified", lineNumber);

}

else {

for (std::size_t i=0; i<params.size(); i++) {

std::string param = params[i].name();

if (param != kInterfaceR && param != kInterfaceCpp) {

rcppInterfacesWarning(

"Unknown interface '" + param + "'", lineNumber);

}