[Rcpp-commits] r1284 - pkg/Rcpp/inst/include/Rcpp pkg/Rcpp/inst/include/Rcpp/module pkg/Rcpp/src scripts

noreply at r-forge.r-project.org noreply at r-forge.r-project.org
Wed May 19 14:16:55 CEST 2010


Author: romain
Date: 2010-05-19 14:16:55 +0200 (Wed, 19 May 2010)
New Revision: 1284

Modified:
   pkg/Rcpp/inst/include/Rcpp/Module.h
   pkg/Rcpp/inst/include/Rcpp/module/Module_generated_CppFunction.h
   pkg/Rcpp/src/Module.cpp
   scripts/generator_Module_CppFunction.R
Log:
trying to better handle exception/R errors in module calls

Modified: pkg/Rcpp/inst/include/Rcpp/Module.h
===================================================================
--- pkg/Rcpp/inst/include/Rcpp/Module.h	2010-05-19 11:54:03 UTC (rev 1283)
+++ pkg/Rcpp/inst/include/Rcpp/Module.h	2010-05-19 12:16:55 UTC (rev 1284)
@@ -45,19 +45,25 @@
 		Module(const char* name_) : name(name_), functions() {}
 		      
 		SEXP invoke( const std::string& name, SEXP* args, int nargs){
-			MAP::iterator it = functions.find( name );
-			if( it == functions.end() ){
-				::Rf_error( "no such function" ) ;
+			try{
+				MAP::iterator it = functions.find( name );
+				if( it == functions.end() ){
+					throw std::range_error( "no such function" ) ; 
+				}
+				CppFunction* fun = it->second ;
+				if( fun->nargs() > nargs ){
+					throw std::range_error( "incorrect number of arguments" ) ; 	
+				}
+				 
+				return Rcpp::List::create( 
+					Rcpp::Named("result") = fun->operator()( args ), 
+					Rcpp::Named("void")   = fun->is_void() 
+				) ;
+			} catch( std::exception& __ex__ ){
+				forward_exception_to_r( __ex__ ); 
 			}
-			CppFunction* fun = it->second ;
-			if( fun->nargs() > nargs ){
-				::Rf_error( "expecting %d arguments", fun->nargs() ) ;	
-			}
-			return Rcpp::List::create( 
-				Rcpp::Named("result") = fun->operator()( args ), 
-				Rcpp::Named("void")   = fun->is_void() 
-			) ;
-		}
+			return R_NilValue ; // -Wall
+		}                                                                                  
 		
 		Rcpp::IntegerVector functions_arity() ;
 		

Modified: pkg/Rcpp/inst/include/Rcpp/module/Module_generated_CppFunction.h
===================================================================
--- pkg/Rcpp/inst/include/Rcpp/module/Module_generated_CppFunction.h	2010-05-19 11:54:03 UTC (rev 1283)
+++ pkg/Rcpp/inst/include/Rcpp/module/Module_generated_CppFunction.h	2010-05-19 12:16:55 UTC (rev 1284)
@@ -26,14 +26,8 @@
 class CppFunction0 : public CppFunction {
 	public:
 		CppFunction0(OUT (*fun)(void) ) : CppFunction(), ptr_fun(fun){}
-		SEXP operator()(SEXP* args){
-			SEXP res = R_NilValue ;
-			try{
-				res = Rcpp::wrap( ptr_fun() ) ;
-			} catch( std::exception& __ex__ ){
-				forward_exception_to_r( __ex__ ) ;
-			}
-			return res ;
+		SEXP operator()(SEXP* args) throw(std::range_error) {
+			return Rcpp::wrap( ptr_fun() ) ;
 		}
 		
 		inline int nargs(){ return 0; }
@@ -48,7 +42,7 @@
 	public:
 		CppFunction0(void (*fun)(void) )  ;
 		
-		SEXP operator()(SEXP* args) ;
+		SEXP operator()(SEXP* args) throw(std::exception) ;
 		
 		inline int nargs(){ return 0; }
 		inline bool is_void(){ return true; }
@@ -63,14 +57,9 @@
 	public:
 
 		CppFunction1(OUT (*fun)(U0) ) : CppFunction(), ptr_fun(fun){}
-		SEXP operator()(SEXP* args){
-			SEXP res = R_NilValue ;
-			try{
-				res = Rcpp::wrap( ptr_fun( Rcpp::as<U0>( args[0] ) ) ) ;
-			} catch( std::exception& __ex__ ){
-				forward_exception_to_r( __ex__ ) ;
-			}
-			return res ;
+		
+		SEXP operator()(SEXP* args) throw(std::exception){
+			return Rcpp::wrap( ptr_fun( Rcpp::as<U0>( args[0] ) ) ) ;
 		}
 		
 		inline int nargs(){ return 1; }
@@ -83,12 +72,9 @@
 class CppFunction1<void,U0> : public CppFunction {
 	public:
 		CppFunction1(void (*fun)(U0) ) : CppFunction(), ptr_fun(fun){}
-		SEXP operator()(SEXP* args){
-			try{
-				ptr_fun( Rcpp::as<U0>( args[0] ) ) ;
-			} catch( std::exception& __ex__ ){
-				forward_exception_to_r( __ex__ ) ;
-			}
+		
+		SEXP operator()(SEXP* args) throw(std::exception) {
+			ptr_fun( Rcpp::as<U0>( args[0] ) ) ;
 			return R_NilValue ;
 		}
 		
@@ -106,14 +92,9 @@
 	public:
 
 		CppFunction2(OUT (*fun)(U0, U1) ) : CppFunction(), ptr_fun(fun){}
-		SEXP operator()(SEXP* args){
-			SEXP res = R_NilValue ;
-			try{
-				res = Rcpp::wrap( ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ) ) ) ;
-			} catch( std::exception& __ex__ ){
-				forward_exception_to_r( __ex__ ) ;
-			}
-			return res ;
+		
+		SEXP operator()(SEXP* args) throw(std::exception){
+			return Rcpp::wrap( ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ) ) ) ;
 		}
 		
 		inline int nargs(){ return 2; }
@@ -126,12 +107,9 @@
 class CppFunction2<void,U0, U1> : public CppFunction {
 	public:
 		CppFunction2(void (*fun)(U0, U1) ) : CppFunction(), ptr_fun(fun){}
-		SEXP operator()(SEXP* args){
-			try{
-				ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ) ) ;
-			} catch( std::exception& __ex__ ){
-				forward_exception_to_r( __ex__ ) ;
-			}
+		
+		SEXP operator()(SEXP* args) throw(std::exception) {
+			ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ) ) ;
 			return R_NilValue ;
 		}
 		
@@ -149,14 +127,9 @@
 	public:
 
 		CppFunction3(OUT (*fun)(U0, U1, U2) ) : CppFunction(), ptr_fun(fun){}
-		SEXP operator()(SEXP* args){
-			SEXP res = R_NilValue ;
-			try{
-				res = Rcpp::wrap( ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ) ) ) ;
-			} catch( std::exception& __ex__ ){
-				forward_exception_to_r( __ex__ ) ;
-			}
-			return res ;
+		
+		SEXP operator()(SEXP* args) throw(std::exception){
+			return Rcpp::wrap( ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ) ) ) ;
 		}
 		
 		inline int nargs(){ return 3; }
@@ -169,12 +142,9 @@
 class CppFunction3<void,U0, U1, U2> : public CppFunction {
 	public:
 		CppFunction3(void (*fun)(U0, U1, U2) ) : CppFunction(), ptr_fun(fun){}
-		SEXP operator()(SEXP* args){
-			try{
-				ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ) ) ;
-			} catch( std::exception& __ex__ ){
-				forward_exception_to_r( __ex__ ) ;
-			}
+		
+		SEXP operator()(SEXP* args) throw(std::exception) {
+			ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ) ) ;
 			return R_NilValue ;
 		}
 		
@@ -192,14 +162,9 @@
 	public:
 
 		CppFunction4(OUT (*fun)(U0, U1, U2, U3) ) : CppFunction(), ptr_fun(fun){}
-		SEXP operator()(SEXP* args){
-			SEXP res = R_NilValue ;
-			try{
-				res = Rcpp::wrap( ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ) ) ) ;
-			} catch( std::exception& __ex__ ){
-				forward_exception_to_r( __ex__ ) ;
-			}
-			return res ;
+		
+		SEXP operator()(SEXP* args) throw(std::exception){
+			return Rcpp::wrap( ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ) ) ) ;
 		}
 		
 		inline int nargs(){ return 4; }
@@ -212,12 +177,9 @@
 class CppFunction4<void,U0, U1, U2, U3> : public CppFunction {
 	public:
 		CppFunction4(void (*fun)(U0, U1, U2, U3) ) : CppFunction(), ptr_fun(fun){}
-		SEXP operator()(SEXP* args){
-			try{
-				ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ) ) ;
-			} catch( std::exception& __ex__ ){
-				forward_exception_to_r( __ex__ ) ;
-			}
+		
+		SEXP operator()(SEXP* args) throw(std::exception) {
+			ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ) ) ;
 			return R_NilValue ;
 		}
 		
@@ -235,14 +197,9 @@
 	public:
 
 		CppFunction5(OUT (*fun)(U0, U1, U2, U3, U4) ) : CppFunction(), ptr_fun(fun){}
-		SEXP operator()(SEXP* args){
-			SEXP res = R_NilValue ;
-			try{
-				res = Rcpp::wrap( ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ) ) ) ;
-			} catch( std::exception& __ex__ ){
-				forward_exception_to_r( __ex__ ) ;
-			}
-			return res ;
+		
+		SEXP operator()(SEXP* args) throw(std::exception){
+			return Rcpp::wrap( ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ) ) ) ;
 		}
 		
 		inline int nargs(){ return 5; }
@@ -255,12 +212,9 @@
 class CppFunction5<void,U0, U1, U2, U3, U4> : public CppFunction {
 	public:
 		CppFunction5(void (*fun)(U0, U1, U2, U3, U4) ) : CppFunction(), ptr_fun(fun){}
-		SEXP operator()(SEXP* args){
-			try{
-				ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ) ) ;
-			} catch( std::exception& __ex__ ){
-				forward_exception_to_r( __ex__ ) ;
-			}
+		
+		SEXP operator()(SEXP* args) throw(std::exception) {
+			ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ) ) ;
 			return R_NilValue ;
 		}
 		
@@ -278,14 +232,9 @@
 	public:
 
 		CppFunction6(OUT (*fun)(U0, U1, U2, U3, U4, U5) ) : CppFunction(), ptr_fun(fun){}
-		SEXP operator()(SEXP* args){
-			SEXP res = R_NilValue ;
-			try{
-				res = Rcpp::wrap( ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ) ) ) ;
-			} catch( std::exception& __ex__ ){
-				forward_exception_to_r( __ex__ ) ;
-			}
-			return res ;
+		
+		SEXP operator()(SEXP* args) throw(std::exception){
+			return Rcpp::wrap( ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ) ) ) ;
 		}
 		
 		inline int nargs(){ return 6; }
@@ -298,12 +247,9 @@
 class CppFunction6<void,U0, U1, U2, U3, U4, U5> : public CppFunction {
 	public:
 		CppFunction6(void (*fun)(U0, U1, U2, U3, U4, U5) ) : CppFunction(), ptr_fun(fun){}
-		SEXP operator()(SEXP* args){
-			try{
-				ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ) ) ;
-			} catch( std::exception& __ex__ ){
-				forward_exception_to_r( __ex__ ) ;
-			}
+		
+		SEXP operator()(SEXP* args) throw(std::exception) {
+			ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ) ) ;
 			return R_NilValue ;
 		}
 		
@@ -321,14 +267,9 @@
 	public:
 
 		CppFunction7(OUT (*fun)(U0, U1, U2, U3, U4, U5, U6) ) : CppFunction(), ptr_fun(fun){}
-		SEXP operator()(SEXP* args){
-			SEXP res = R_NilValue ;
-			try{
-				res = Rcpp::wrap( ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ) ) ) ;
-			} catch( std::exception& __ex__ ){
-				forward_exception_to_r( __ex__ ) ;
-			}
-			return res ;
+		
+		SEXP operator()(SEXP* args) throw(std::exception){
+			return Rcpp::wrap( ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ) ) ) ;
 		}
 		
 		inline int nargs(){ return 7; }
@@ -341,12 +282,9 @@
 class CppFunction7<void,U0, U1, U2, U3, U4, U5, U6> : public CppFunction {
 	public:
 		CppFunction7(void (*fun)(U0, U1, U2, U3, U4, U5, U6) ) : CppFunction(), ptr_fun(fun){}
-		SEXP operator()(SEXP* args){
-			try{
-				ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ) ) ;
-			} catch( std::exception& __ex__ ){
-				forward_exception_to_r( __ex__ ) ;
-			}
+		
+		SEXP operator()(SEXP* args) throw(std::exception) {
+			ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ) ) ;
 			return R_NilValue ;
 		}
 		
@@ -364,14 +302,9 @@
 	public:
 
 		CppFunction8(OUT (*fun)(U0, U1, U2, U3, U4, U5, U6, U7) ) : CppFunction(), ptr_fun(fun){}
-		SEXP operator()(SEXP* args){
-			SEXP res = R_NilValue ;
-			try{
-				res = Rcpp::wrap( ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ), Rcpp::as<U7>( args[7] ) ) ) ;
-			} catch( std::exception& __ex__ ){
-				forward_exception_to_r( __ex__ ) ;
-			}
-			return res ;
+		
+		SEXP operator()(SEXP* args) throw(std::exception){
+			return Rcpp::wrap( ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ), Rcpp::as<U7>( args[7] ) ) ) ;
 		}
 		
 		inline int nargs(){ return 8; }
@@ -384,12 +317,9 @@
 class CppFunction8<void,U0, U1, U2, U3, U4, U5, U6, U7> : public CppFunction {
 	public:
 		CppFunction8(void (*fun)(U0, U1, U2, U3, U4, U5, U6, U7) ) : CppFunction(), ptr_fun(fun){}
-		SEXP operator()(SEXP* args){
-			try{
-				ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ), Rcpp::as<U7>( args[7] ) ) ;
-			} catch( std::exception& __ex__ ){
-				forward_exception_to_r( __ex__ ) ;
-			}
+		
+		SEXP operator()(SEXP* args) throw(std::exception) {
+			ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ), Rcpp::as<U7>( args[7] ) ) ;
 			return R_NilValue ;
 		}
 		
@@ -407,14 +337,9 @@
 	public:
 
 		CppFunction9(OUT (*fun)(U0, U1, U2, U3, U4, U5, U6, U7, U8) ) : CppFunction(), ptr_fun(fun){}
-		SEXP operator()(SEXP* args){
-			SEXP res = R_NilValue ;
-			try{
-				res = Rcpp::wrap( ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ), Rcpp::as<U7>( args[7] ), Rcpp::as<U8>( args[8] ) ) ) ;
-			} catch( std::exception& __ex__ ){
-				forward_exception_to_r( __ex__ ) ;
-			}
-			return res ;
+		
+		SEXP operator()(SEXP* args) throw(std::exception){
+			return Rcpp::wrap( ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ), Rcpp::as<U7>( args[7] ), Rcpp::as<U8>( args[8] ) ) ) ;
 		}
 		
 		inline int nargs(){ return 9; }
@@ -427,12 +352,9 @@
 class CppFunction9<void,U0, U1, U2, U3, U4, U5, U6, U7, U8> : public CppFunction {
 	public:
 		CppFunction9(void (*fun)(U0, U1, U2, U3, U4, U5, U6, U7, U8) ) : CppFunction(), ptr_fun(fun){}
-		SEXP operator()(SEXP* args){
-			try{
-				ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ), Rcpp::as<U7>( args[7] ), Rcpp::as<U8>( args[8] ) ) ;
-			} catch( std::exception& __ex__ ){
-				forward_exception_to_r( __ex__ ) ;
-			}
+		
+		SEXP operator()(SEXP* args) throw(std::exception) {
+			ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ), Rcpp::as<U7>( args[7] ), Rcpp::as<U8>( args[8] ) ) ;
 			return R_NilValue ;
 		}
 		
@@ -450,14 +372,9 @@
 	public:
 
 		CppFunction10(OUT (*fun)(U0, U1, U2, U3, U4, U5, U6, U7, U8, U9) ) : CppFunction(), ptr_fun(fun){}
-		SEXP operator()(SEXP* args){
-			SEXP res = R_NilValue ;
-			try{
-				res = Rcpp::wrap( ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ), Rcpp::as<U7>( args[7] ), Rcpp::as<U8>( args[8] ), Rcpp::as<U9>( args[9] ) ) ) ;
-			} catch( std::exception& __ex__ ){
-				forward_exception_to_r( __ex__ ) ;
-			}
-			return res ;
+		
+		SEXP operator()(SEXP* args) throw(std::exception){
+			return Rcpp::wrap( ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ), Rcpp::as<U7>( args[7] ), Rcpp::as<U8>( args[8] ), Rcpp::as<U9>( args[9] ) ) ) ;
 		}
 		
 		inline int nargs(){ return 10; }
@@ -470,12 +387,9 @@
 class CppFunction10<void,U0, U1, U2, U3, U4, U5, U6, U7, U8, U9> : public CppFunction {
 	public:
 		CppFunction10(void (*fun)(U0, U1, U2, U3, U4, U5, U6, U7, U8, U9) ) : CppFunction(), ptr_fun(fun){}
-		SEXP operator()(SEXP* args){
-			try{
-				ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ), Rcpp::as<U7>( args[7] ), Rcpp::as<U8>( args[8] ), Rcpp::as<U9>( args[9] ) ) ;
-			} catch( std::exception& __ex__ ){
-				forward_exception_to_r( __ex__ ) ;
-			}
+		
+		SEXP operator()(SEXP* args) throw(std::exception) {
+			ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ), Rcpp::as<U7>( args[7] ), Rcpp::as<U8>( args[8] ), Rcpp::as<U9>( args[9] ) ) ;
 			return R_NilValue ;
 		}
 		
@@ -493,14 +407,9 @@
 	public:
 
 		CppFunction11(OUT (*fun)(U0, U1, U2, U3, U4, U5, U6, U7, U8, U9, U10) ) : CppFunction(), ptr_fun(fun){}
-		SEXP operator()(SEXP* args){
-			SEXP res = R_NilValue ;
-			try{
-				res = Rcpp::wrap( ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ), Rcpp::as<U7>( args[7] ), Rcpp::as<U8>( args[8] ), Rcpp::as<U9>( args[9] ), Rcpp::as<U10>( args[10] ) ) ) ;
-			} catch( std::exception& __ex__ ){
-				forward_exception_to_r( __ex__ ) ;
-			}
-			return res ;
+		
+		SEXP operator()(SEXP* args) throw(std::exception){
+			return Rcpp::wrap( ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ), Rcpp::as<U7>( args[7] ), Rcpp::as<U8>( args[8] ), Rcpp::as<U9>( args[9] ), Rcpp::as<U10>( args[10] ) ) ) ;
 		}
 		
 		inline int nargs(){ return 11; }
@@ -513,12 +422,9 @@
 class CppFunction11<void,U0, U1, U2, U3, U4, U5, U6, U7, U8, U9, U10> : public CppFunction {
 	public:
 		CppFunction11(void (*fun)(U0, U1, U2, U3, U4, U5, U6, U7, U8, U9, U10) ) : CppFunction(), ptr_fun(fun){}
-		SEXP operator()(SEXP* args){
-			try{
-				ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ), Rcpp::as<U7>( args[7] ), Rcpp::as<U8>( args[8] ), Rcpp::as<U9>( args[9] ), Rcpp::as<U10>( args[10] ) ) ;
-			} catch( std::exception& __ex__ ){
-				forward_exception_to_r( __ex__ ) ;
-			}
+		
+		SEXP operator()(SEXP* args) throw(std::exception) {
+			ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ), Rcpp::as<U7>( args[7] ), Rcpp::as<U8>( args[8] ), Rcpp::as<U9>( args[9] ), Rcpp::as<U10>( args[10] ) ) ;
 			return R_NilValue ;
 		}
 		
@@ -536,14 +442,9 @@
 	public:
 
 		CppFunction12(OUT (*fun)(U0, U1, U2, U3, U4, U5, U6, U7, U8, U9, U10, U11) ) : CppFunction(), ptr_fun(fun){}
-		SEXP operator()(SEXP* args){
-			SEXP res = R_NilValue ;
-			try{
-				res = Rcpp::wrap( ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ), Rcpp::as<U7>( args[7] ), Rcpp::as<U8>( args[8] ), Rcpp::as<U9>( args[9] ), Rcpp::as<U10>( args[10] ), Rcpp::as<U11>( args[11] ) ) ) ;
-			} catch( std::exception& __ex__ ){
-				forward_exception_to_r( __ex__ ) ;
-			}
-			return res ;
+		
+		SEXP operator()(SEXP* args) throw(std::exception){
+			return Rcpp::wrap( ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ), Rcpp::as<U7>( args[7] ), Rcpp::as<U8>( args[8] ), Rcpp::as<U9>( args[9] ), Rcpp::as<U10>( args[10] ), Rcpp::as<U11>( args[11] ) ) ) ;
 		}
 		
 		inline int nargs(){ return 12; }
@@ -556,12 +457,9 @@
 class CppFunction12<void,U0, U1, U2, U3, U4, U5, U6, U7, U8, U9, U10, U11> : public CppFunction {
 	public:
 		CppFunction12(void (*fun)(U0, U1, U2, U3, U4, U5, U6, U7, U8, U9, U10, U11) ) : CppFunction(), ptr_fun(fun){}
-		SEXP operator()(SEXP* args){
-			try{
-				ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ), Rcpp::as<U7>( args[7] ), Rcpp::as<U8>( args[8] ), Rcpp::as<U9>( args[9] ), Rcpp::as<U10>( args[10] ), Rcpp::as<U11>( args[11] ) ) ;
-			} catch( std::exception& __ex__ ){
-				forward_exception_to_r( __ex__ ) ;
-			}
+		
+		SEXP operator()(SEXP* args) throw(std::exception) {
+			ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ), Rcpp::as<U7>( args[7] ), Rcpp::as<U8>( args[8] ), Rcpp::as<U9>( args[9] ), Rcpp::as<U10>( args[10] ), Rcpp::as<U11>( args[11] ) ) ;
 			return R_NilValue ;
 		}
 		
@@ -579,14 +477,9 @@
 	public:
 
 		CppFunction13(OUT (*fun)(U0, U1, U2, U3, U4, U5, U6, U7, U8, U9, U10, U11, U12) ) : CppFunction(), ptr_fun(fun){}
-		SEXP operator()(SEXP* args){
-			SEXP res = R_NilValue ;
-			try{
-				res = Rcpp::wrap( ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ), Rcpp::as<U7>( args[7] ), Rcpp::as<U8>( args[8] ), Rcpp::as<U9>( args[9] ), Rcpp::as<U10>( args[10] ), Rcpp::as<U11>( args[11] ), Rcpp::as<U12>( args[12] ) ) ) ;
-			} catch( std::exception& __ex__ ){
-				forward_exception_to_r( __ex__ ) ;
-			}
-			return res ;
+		
+		SEXP operator()(SEXP* args) throw(std::exception){
+			return Rcpp::wrap( ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ), Rcpp::as<U7>( args[7] ), Rcpp::as<U8>( args[8] ), Rcpp::as<U9>( args[9] ), Rcpp::as<U10>( args[10] ), Rcpp::as<U11>( args[11] ), Rcpp::as<U12>( args[12] ) ) ) ;
 		}
 		
 		inline int nargs(){ return 13; }
@@ -599,12 +492,9 @@
 class CppFunction13<void,U0, U1, U2, U3, U4, U5, U6, U7, U8, U9, U10, U11, U12> : public CppFunction {
 	public:
 		CppFunction13(void (*fun)(U0, U1, U2, U3, U4, U5, U6, U7, U8, U9, U10, U11, U12) ) : CppFunction(), ptr_fun(fun){}
-		SEXP operator()(SEXP* args){
-			try{
-				ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ), Rcpp::as<U7>( args[7] ), Rcpp::as<U8>( args[8] ), Rcpp::as<U9>( args[9] ), Rcpp::as<U10>( args[10] ), Rcpp::as<U11>( args[11] ), Rcpp::as<U12>( args[12] ) ) ;
-			} catch( std::exception& __ex__ ){
-				forward_exception_to_r( __ex__ ) ;
-			}
+		
+		SEXP operator()(SEXP* args) throw(std::exception) {
+			ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ), Rcpp::as<U7>( args[7] ), Rcpp::as<U8>( args[8] ), Rcpp::as<U9>( args[9] ), Rcpp::as<U10>( args[10] ), Rcpp::as<U11>( args[11] ), Rcpp::as<U12>( args[12] ) ) ;
 			return R_NilValue ;
 		}
 		
@@ -622,14 +512,9 @@
 	public:
 
 		CppFunction14(OUT (*fun)(U0, U1, U2, U3, U4, U5, U6, U7, U8, U9, U10, U11, U12, U13) ) : CppFunction(), ptr_fun(fun){}
-		SEXP operator()(SEXP* args){
-			SEXP res = R_NilValue ;
-			try{
-				res = Rcpp::wrap( ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ), Rcpp::as<U7>( args[7] ), Rcpp::as<U8>( args[8] ), Rcpp::as<U9>( args[9] ), Rcpp::as<U10>( args[10] ), Rcpp::as<U11>( args[11] ), Rcpp::as<U12>( args[12] ), Rcpp::as<U13>( args[13] ) ) ) ;
-			} catch( std::exception& __ex__ ){
-				forward_exception_to_r( __ex__ ) ;
-			}
-			return res ;
+		
+		SEXP operator()(SEXP* args) throw(std::exception){
+			return Rcpp::wrap( ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ), Rcpp::as<U7>( args[7] ), Rcpp::as<U8>( args[8] ), Rcpp::as<U9>( args[9] ), Rcpp::as<U10>( args[10] ), Rcpp::as<U11>( args[11] ), Rcpp::as<U12>( args[12] ), Rcpp::as<U13>( args[13] ) ) ) ;
 		}
 		
 		inline int nargs(){ return 14; }
@@ -642,12 +527,9 @@
 class CppFunction14<void,U0, U1, U2, U3, U4, U5, U6, U7, U8, U9, U10, U11, U12, U13> : public CppFunction {
 	public:
 		CppFunction14(void (*fun)(U0, U1, U2, U3, U4, U5, U6, U7, U8, U9, U10, U11, U12, U13) ) : CppFunction(), ptr_fun(fun){}
-		SEXP operator()(SEXP* args){
-			try{
-				ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ), Rcpp::as<U7>( args[7] ), Rcpp::as<U8>( args[8] ), Rcpp::as<U9>( args[9] ), Rcpp::as<U10>( args[10] ), Rcpp::as<U11>( args[11] ), Rcpp::as<U12>( args[12] ), Rcpp::as<U13>( args[13] ) ) ;
-			} catch( std::exception& __ex__ ){
-				forward_exception_to_r( __ex__ ) ;
-			}
+		
+		SEXP operator()(SEXP* args) throw(std::exception) {
+			ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ), Rcpp::as<U7>( args[7] ), Rcpp::as<U8>( args[8] ), Rcpp::as<U9>( args[9] ), Rcpp::as<U10>( args[10] ), Rcpp::as<U11>( args[11] ), Rcpp::as<U12>( args[12] ), Rcpp::as<U13>( args[13] ) ) ;
 			return R_NilValue ;
 		}
 		
@@ -665,14 +547,9 @@
 	public:
 
 		CppFunction15(OUT (*fun)(U0, U1, U2, U3, U4, U5, U6, U7, U8, U9, U10, U11, U12, U13, U14) ) : CppFunction(), ptr_fun(fun){}
-		SEXP operator()(SEXP* args){
-			SEXP res = R_NilValue ;
-			try{
-				res = Rcpp::wrap( ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ), Rcpp::as<U7>( args[7] ), Rcpp::as<U8>( args[8] ), Rcpp::as<U9>( args[9] ), Rcpp::as<U10>( args[10] ), Rcpp::as<U11>( args[11] ), Rcpp::as<U12>( args[12] ), Rcpp::as<U13>( args[13] ), Rcpp::as<U14>( args[14] ) ) ) ;
-			} catch( std::exception& __ex__ ){
-				forward_exception_to_r( __ex__ ) ;
-			}
-			return res ;
+		
+		SEXP operator()(SEXP* args) throw(std::exception){
+			return Rcpp::wrap( ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ), Rcpp::as<U7>( args[7] ), Rcpp::as<U8>( args[8] ), Rcpp::as<U9>( args[9] ), Rcpp::as<U10>( args[10] ), Rcpp::as<U11>( args[11] ), Rcpp::as<U12>( args[12] ), Rcpp::as<U13>( args[13] ), Rcpp::as<U14>( args[14] ) ) ) ;
 		}
 		
 		inline int nargs(){ return 15; }
@@ -685,12 +562,9 @@
 class CppFunction15<void,U0, U1, U2, U3, U4, U5, U6, U7, U8, U9, U10, U11, U12, U13, U14> : public CppFunction {
 	public:
 		CppFunction15(void (*fun)(U0, U1, U2, U3, U4, U5, U6, U7, U8, U9, U10, U11, U12, U13, U14) ) : CppFunction(), ptr_fun(fun){}
-		SEXP operator()(SEXP* args){
-			try{
-				ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ), Rcpp::as<U7>( args[7] ), Rcpp::as<U8>( args[8] ), Rcpp::as<U9>( args[9] ), Rcpp::as<U10>( args[10] ), Rcpp::as<U11>( args[11] ), Rcpp::as<U12>( args[12] ), Rcpp::as<U13>( args[13] ), Rcpp::as<U14>( args[14] ) ) ;
-			} catch( std::exception& __ex__ ){
-				forward_exception_to_r( __ex__ ) ;
-			}
+		
+		SEXP operator()(SEXP* args) throw(std::exception) {
+			ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ), Rcpp::as<U7>( args[7] ), Rcpp::as<U8>( args[8] ), Rcpp::as<U9>( args[9] ), Rcpp::as<U10>( args[10] ), Rcpp::as<U11>( args[11] ), Rcpp::as<U12>( args[12] ), Rcpp::as<U13>( args[13] ), Rcpp::as<U14>( args[14] ) ) ;
 			return R_NilValue ;
 		}
 		
@@ -708,14 +582,9 @@
 	public:
 
 		CppFunction16(OUT (*fun)(U0, U1, U2, U3, U4, U5, U6, U7, U8, U9, U10, U11, U12, U13, U14, U15) ) : CppFunction(), ptr_fun(fun){}
-		SEXP operator()(SEXP* args){
-			SEXP res = R_NilValue ;
-			try{
-				res = Rcpp::wrap( ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ), Rcpp::as<U7>( args[7] ), Rcpp::as<U8>( args[8] ), Rcpp::as<U9>( args[9] ), Rcpp::as<U10>( args[10] ), Rcpp::as<U11>( args[11] ), Rcpp::as<U12>( args[12] ), Rcpp::as<U13>( args[13] ), Rcpp::as<U14>( args[14] ), Rcpp::as<U15>( args[15] ) ) ) ;
-			} catch( std::exception& __ex__ ){
-				forward_exception_to_r( __ex__ ) ;
-			}
-			return res ;
+		
+		SEXP operator()(SEXP* args) throw(std::exception){
+			return Rcpp::wrap( ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ), Rcpp::as<U7>( args[7] ), Rcpp::as<U8>( args[8] ), Rcpp::as<U9>( args[9] ), Rcpp::as<U10>( args[10] ), Rcpp::as<U11>( args[11] ), Rcpp::as<U12>( args[12] ), Rcpp::as<U13>( args[13] ), Rcpp::as<U14>( args[14] ), Rcpp::as<U15>( args[15] ) ) ) ;
 		}
 		
 		inline int nargs(){ return 16; }
@@ -728,12 +597,9 @@
 class CppFunction16<void,U0, U1, U2, U3, U4, U5, U6, U7, U8, U9, U10, U11, U12, U13, U14, U15> : public CppFunction {
 	public:
 		CppFunction16(void (*fun)(U0, U1, U2, U3, U4, U5, U6, U7, U8, U9, U10, U11, U12, U13, U14, U15) ) : CppFunction(), ptr_fun(fun){}
-		SEXP operator()(SEXP* args){
-			try{
-				ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ), Rcpp::as<U7>( args[7] ), Rcpp::as<U8>( args[8] ), Rcpp::as<U9>( args[9] ), Rcpp::as<U10>( args[10] ), Rcpp::as<U11>( args[11] ), Rcpp::as<U12>( args[12] ), Rcpp::as<U13>( args[13] ), Rcpp::as<U14>( args[14] ), Rcpp::as<U15>( args[15] ) ) ;
-			} catch( std::exception& __ex__ ){
-				forward_exception_to_r( __ex__ ) ;
-			}
+		
+		SEXP operator()(SEXP* args) throw(std::exception) {
+			ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ), Rcpp::as<U7>( args[7] ), Rcpp::as<U8>( args[8] ), Rcpp::as<U9>( args[9] ), Rcpp::as<U10>( args[10] ), Rcpp::as<U11>( args[11] ), Rcpp::as<U12>( args[12] ), Rcpp::as<U13>( args[13] ), Rcpp::as<U14>( args[14] ), Rcpp::as<U15>( args[15] ) ) ;
 			return R_NilValue ;
 		}
 		
@@ -751,14 +617,9 @@
 	public:
 
 		CppFunction17(OUT (*fun)(U0, U1, U2, U3, U4, U5, U6, U7, U8, U9, U10, U11, U12, U13, U14, U15, U16) ) : CppFunction(), ptr_fun(fun){}
-		SEXP operator()(SEXP* args){
-			SEXP res = R_NilValue ;
-			try{
-				res = Rcpp::wrap( ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ), Rcpp::as<U7>( args[7] ), Rcpp::as<U8>( args[8] ), Rcpp::as<U9>( args[9] ), Rcpp::as<U10>( args[10] ), Rcpp::as<U11>( args[11] ), Rcpp::as<U12>( args[12] ), Rcpp::as<U13>( args[13] ), Rcpp::as<U14>( args[14] ), Rcpp::as<U15>( args[15] ), Rcpp::as<U16>( args[16] ) ) ) ;
-			} catch( std::exception& __ex__ ){
-				forward_exception_to_r( __ex__ ) ;
-			}
-			return res ;
+		
+		SEXP operator()(SEXP* args) throw(std::exception){
+			return Rcpp::wrap( ptr_fun( Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ), Rcpp::as<U7>( args[7] ), Rcpp::as<U8>( args[8] ), Rcpp::as<U9>( args[9] ), Rcpp::as<U10>( args[10] ), Rcpp::as<U11>( args[11] ), Rcpp::as<U12>( args[12] ), Rcpp::as<U13>( args[13] ), Rcpp::as<U14>( args[14] ), Rcpp::as<U15>( args[15] ), Rcpp::as<U16>( args[16] ) ) ) ;
 		}
 		
 		inline int nargs(){ return 17; }
@@ -771,12 +632,9 @@
 class CppFunction17<void,U0, U1, U2, U3, U4, U5, U6, U7, U8, U9, U10, U11, U12, U13, U14, U15, U16> : public CppFunction {
 	public:
 		CppFunction17(void (*fun)(U0, U1, U2, U3, U4, U5, U6, U7, U8, U9, U10, U11, U12, U13, U14, U15, U16) ) : CppFunction(), ptr_fun(fun){}
-		SEXP operator()(SEXP* args){
-			try{
[TRUNCATED]

To get the complete diff run:
    svnlook diff /svnroot/rcpp -r 1284


More information about the Rcpp-commits mailing list