Get rid of dynamic exception specification

Leont · Leont · commit 6bd18a4337e8 · 2018-02-22T10:53:15.000+01:00
diff --git a/examples/game.C b/examples/game.C
@@ -41,8 +41,7 @@ struct game_exception : public std::exception {
 	const char* what() {
 		return message.c_str();
 	}
-	~game_exception() throw() {
-	}
+	~game_exception() = default;
 };
 
 class game {
diff --git a/perl++/headers/helpers.h b/perl++/headers/helpers.h
@@ -50,8 +50,7 @@ namespace perl {
 		const char* what() {
 			return message.c_str();
 		}
-		~Runtime_exception() throw() {
-		}
+		~Runtime_exception() = default;
 	};
 
 	class Out_of_bounds_exception : public Runtime_exception {
diff --git a/tap++/headers/tap++.h b/tap++/headers/tap++.h
@@ -18,74 +18,72 @@ namespace TAP {
         	//Return the variant of "Failed test" or "Failed
 	        //(TODO) test" required by whether the current test is
 	        //a todo test
-		char const * failed_test_msg() throw();
+		char const * failed_test_msg() noexcept;
 	}
 	class fatal_exception : public std::exception {
 		std::string message;
 		public:
 		fatal_exception(const std::string& _message) : message(_message) {
 		}
-		const char* what() const throw() {
+		const char* what() const noexcept {
 			return message.c_str();
 		}
-		~fatal_exception() throw() {
-		}
 	};
 	extern const details::skip_all_type skip_all;
 	extern const details::no_plan_type no_plan;
-	void plan(unsigned) throw(fatal_exception);
-	void plan(const details::skip_all_type&, const std::string& = "") throw(fatal_exception);
-	void plan(const details::no_plan_type&) throw();
-	void done_testing() throw(fatal_exception);
-	void done_testing(unsigned) throw(fatal_exception);
+	void plan(unsigned);
+	void plan(const details::skip_all_type&, const std::string& = "");
+	void plan(const details::no_plan_type&);
+	void done_testing();
+	void done_testing(unsigned);
 
-	unsigned planned() throw();
-	unsigned encountered() throw();
+	unsigned planned();
+	unsigned encountered();
 
-	bool ok(bool, const std::string& = "") throw();
-	bool not_ok(bool, const std::string& = "") throw();
+	bool ok(bool, const std::string& = "");
+	bool not_ok(bool, const std::string& = "");
 
-	bool pass(const std::string& = "") throw();
-	bool fail(const std::string& = "") throw();
+	bool pass(const std::string& = "");
+	bool fail(const std::string& = "");
 
-	void skip(unsigned, const std::string& = "") throw();
-	void bail_out(const std::string& reason) throw();
+	void skip(unsigned, const std::string& = "");
+	void bail_out(const std::string& reason);
 
-	int exit_status() throw();
-	bool summary() throw();
+	int exit_status();
+	bool summary();
 
-	void set_output(std::ostream&) throw(fatal_exception);
-	void set_error(std::ostream&) throw(fatal_exception);
+	void set_output(std::ostream&);
+	void set_error(std::ostream&);
 
-	template<typename T> void diag(const T& first) throw() {
+	template<typename T> void diag(const T& first) {
 		*details::error << "# " << first << std::endl;
 	}
-	template<typename T1, typename T2> void diag(const T1& first, const T2& second) throw() {
+	template<typename T1, typename T2> void diag(const T1& first, const T2& second) {
 		*details::error << "# " << first << second << std::endl;
 	}
-	template<typename T1, typename T2, typename T3> void diag(const T1& first, const T2& second, const T3& third) throw() {
+	template<typename T1, typename T2, typename T3> void diag(const T1& first, const T2& second, const T3& third) {
 		*details::error << "# " << first << second << third << std::endl;
 	}
-	template<typename T1, typename T2, typename T3, typename T4> void diag(const T1& first, const T2& second, const T3& third, const T4& fourth) throw() {
+	template<typename T1, typename T2, typename T3, typename T4> void diag(const T1& first, const T2& second, const T3& third, const T4& fourth) {
 		*details::error << "# " << first << second << third << fourth << std::endl;
 	}
-	template<typename T1, typename T2, typename T3, typename T4, typename T5> void diag(const T1& first, const T2& second, const T3& third, const T4& fourth, const T5& fifth) throw() {
+	template<typename T1, typename T2, typename T3, typename T4, typename T5> void diag(const T1& first, const T2& second, const T3& third, const T4& fourth, const T5& fifth) {
 		*details::error << "# " << first << second << third << fourth << fifth << std::endl;
 	}
 
-	template<typename T> void note(const T& first) throw() {
+	template<typename T> void note(const T& first) {
 		*details::output << "# " << first << std::endl;
 	}
-	template<typename T1, typename T2> void note(const T1& first, const T2& second) throw() {
+	template<typename T1, typename T2> void note(const T1& first, const T2& second) {
 		*details::output << "# " << first << second << std::endl;
 	}
-	template<typename T1, typename T2, typename T3> void note(const T1& first, const T2& second, const T3& third) throw() {
+	template<typename T1, typename T2, typename T3> void note(const T1& first, const T2& second, const T3& third) {
 		*details::output << "# " << first << second << third << std::endl;
 	}
-	template<typename T1, typename T2, typename T3, typename T4> void note(const T1& first, const T2& second, const T3& third, const T4& fourth) throw() {
+	template<typename T1, typename T2, typename T3, typename T4> void note(const T1& first, const T2& second, const T3& third, const T4& fourth) {
 		*details::output << "# " << first << second << third << fourth << std::endl;
 	}
-	template<typename T1, typename T2, typename T3, typename T4, typename T5> void note(const T1& first, const T2& second, const T3& third, const T4& fourth, const T5& fifth) throw() {
+	template<typename T1, typename T2, typename T3, typename T4, typename T5> void note(const T1& first, const T2& second, const T3& third, const T4& fourth, const T5& fifth) {
 		*details::output << "# " << first << second << third << fourth << fifth << std::endl;
 	}
 
@@ -172,8 +170,8 @@ namespace TAP {
 	class todo_guard {
 		const std::string value;
 		public:
-		todo_guard() throw();
-		~todo_guard() throw();
+		todo_guard();
+		~todo_guard();
 	};
 }
 
@@ -183,22 +181,22 @@ namespace TAP {
 	namespace details {
 		struct Skip_exception {
 			const std::string reason;
-			Skip_exception(const std::string& _reason) throw() : reason(_reason) {
+			Skip_exception(const std::string& _reason) : reason(_reason) {
 			}
 		};
 		struct Todo_exception {
 			const std::string reason;
-			Todo_exception(const std::string& _reason) throw() : reason(_reason) {
+			Todo_exception(const std::string& _reason) : reason(_reason) {
 			}
 		};
 
-		void start_block(unsigned) throw();
-		unsigned stop_block() throw(fatal_exception);
+		void start_block(unsigned);
+		unsigned stop_block();
 
 	}
 
-	void skip(const std::string& reason) throw(details::Skip_exception);
-	void skip_todo(const std::string& reason) throw(details::Todo_exception);
+	void skip(const std::string& reason);
+	void skip_todo(const std::string& reason);
 }
 
 #define TRY(action, name) do {\
diff --git a/tap++/source/tap++.C b/tap++/source/tap++.C
@@ -15,7 +15,7 @@ namespace TAP {
 		unsigned counter = 0;
 		unsigned not_oks = 0;
 
-		std::string todo_test() throw() {
+		std::string todo_test() {
 			if (TODO == "") {
 				return TODO;
 			}
@@ -24,24 +24,24 @@ namespace TAP {
 			}
 		}
 
-		bool is_todo_test() throw() { return TODO != ""; }
+		bool is_todo_test() noexcept { return TODO != ""; }
 
 		bool is_planned = false;
 		bool no_planned = false;
 		bool has_output_plan = false;
 
-		void output_plan(unsigned tests, const std::string& extra = "") throw(fatal_exception) {
+		void output_plan(unsigned tests, const std::string& extra = "") {
 			if (has_output_plan) {
 				throw fatal_exception("Can't plan twice");
 			}
 			*details::output << "1.." << tests << extra << std::endl;
 			has_output_plan = true;
 		}
-		inline const std::string to_string(unsigned num) throw() {
+		inline const std::string to_string(unsigned num) {
 			return boost::lexical_cast<std::string>(num);
 		}
 
-		inline void _done_testing(unsigned tests) throw(fatal_exception) {
+		inline void _done_testing(unsigned tests) {
 			static bool is_done = false;
 			if (is_done) {
 				fail("done_testing() was already called");
@@ -63,40 +63,40 @@ namespace TAP {
 
 	}
 
-	void plan(unsigned tests) throw(fatal_exception) {
+	void plan(unsigned tests) {
 		if (is_planned) {
 			bail_out("Can't plan again!");
 		}
 		is_planned = true;
 		output_plan(tests);
 		expected = tests;
 	}
-	void plan(const details::skip_all_type&, const std::string& reason) throw(fatal_exception) {
+	void plan(const details::skip_all_type&, const std::string& reason) {
 		output_plan(0, " #skip " + reason);
 		std::exit(0);
 	}
-	void plan(const details::no_plan_type&) throw() {
+	void plan(const details::no_plan_type&) {
 		is_planned = true;
 		no_planned = true;
 	}
 
-	void done_testing() throw(fatal_exception) {
+	void done_testing() {
 		_done_testing(encountered());
 	}
 
-	void done_testing(unsigned tests) throw(fatal_exception) {
+	void done_testing(unsigned tests) {
 		no_planned = false;
 		_done_testing(tests);
 	}
 
-	unsigned planned() throw() {
+	unsigned planned() {
 		return expected;
 	}
-	unsigned encountered() throw() {
+	unsigned encountered() {
 		return counter;
 	}
 
-	int exit_status() throw () {
+	int exit_status() {
 //		bool passing;
 		if (!is_planned && encountered()) {
 			diag("Tests were run but no plan was declared and done_testing() was not seen.");
@@ -112,80 +112,80 @@ namespace TAP {
 			return 255;
 		}
 	}
-	bool summary() throw() {
+	bool summary() {
 		return not_oks;
 	}
 
-	void bail_out(const std::string& reason) throw() {
+	void bail_out(const std::string& reason) {
 		*details::output << "Bail out!  " << reason << std::endl;
 		std::exit(255); // Does not unwind stack!
 	}
 
-	bool ok(bool is_ok, const std::string& message) throw() {
+	bool ok(bool is_ok, const std::string& message) {
 		const char* hot_or_not = is_ok ? "" : "not ";
 		*details::output << hot_or_not << "ok " << ++counter<< " - " << message << todo_test()  << std::endl;
 		if (!is_ok && !is_todo_test()) {
 			++not_oks;
 		}
 		return is_ok;
 	}
-	bool not_ok(bool is_not_ok, const std::string& message) throw() {
+	bool not_ok(bool is_not_ok, const std::string& message) {
 		return !ok(!is_not_ok, message);
 	}
 
-	bool pass(const std::string& message) throw() {
+	bool pass(const std::string& message) {
 		return ok(true, message);
 	}
-	bool fail(const std::string& message) throw() {
+	bool fail(const std::string& message) {
 		return ok(false, message);
 	}
 
-	void skip(unsigned num, const std::string& reason) throw ()  {
+	void skip(unsigned num, const std::string& reason) {
 		for(unsigned i = 0; i < num; ++i) {
 			pass(" # skip " + reason);
 		}
 	}
 
-	void set_output(std::ostream& new_output) throw (fatal_exception) {
+	void set_output(std::ostream& new_output) {
 		if (is_planned) {
 			throw fatal_exception("Can't set output after plan()");
 		}
 		details::output = &new_output;
 	}
-	void set_error(std::ostream& new_error) throw(fatal_exception) {
+	void set_error(std::ostream& new_error) {
 		if (is_planned) {
 			throw fatal_exception("Can't set error after plan()");
 		}
 		details::error = &new_error;
 	}
-	todo_guard::todo_guard() throw() : value(TODO) {
+	todo_guard::todo_guard() : value(TODO) {
 	}
-	todo_guard::~todo_guard() throw() {
+	todo_guard::~todo_guard() {
 		TODO = value;
 	}
 	namespace details {
 		std::ostream* output = &std::cout;
 		std::ostream* error = &std::cout;
 		static std::stack<unsigned> block_expected;
-		void start_block(unsigned expected) throw() {
+		void start_block(unsigned expected) {
 			block_expected.push(encountered() + expected);
 		}
-		unsigned stop_block() throw(fatal_exception) {
+		unsigned stop_block() {
 			unsigned ret = block_expected.top();
 			block_expected.pop();
 			return ret;
 		}
 
-	 	char const * failed_test_msg() throw() {
-		     return is_todo_test()?"Failed (TODO) test":"Failed test";
+	 	char const * failed_test_msg() noexcept {
+		     return is_todo_test() ? "Failed (TODO) test" : "Failed test";
 		}
 
 	}
 	
-	void skip(const std::string& reason) throw(details::Skip_exception) {
+	void skip(const std::string& reason) {
 		throw details::Skip_exception(reason);
 	}
-	void skip_todo(const std::string& reason) throw(details::Todo_exception) {
+	void skip_todo(const std::string& reason) {
 		throw details::Todo_exception(reason);
 	}
 

Original file line number	Diff line number	Diff line change
`@@ -41,8 +41,7 @@ struct game_exception : public std::exception {`
`41`	`41`	`const char* what() {`
`42`	`42`	`return message.c_str();`
`43`	`43`	`}`
`44`		`- ~game_exception() throw() {`
`45`		`- }`
	`44`	`+ ~game_exception() = default;`
`46`	`45`	`};`
`47`	`46`
`48`	`47`	`class game {`
Original file line number	Diff line number	Diff line change
`@@ -50,8 +50,7 @@ namespace perl {`
`50`	`50`	`const char* what() {`
`51`	`51`	`return message.c_str();`
`52`	`52`	`}`
`53`		`- ~Runtime_exception() throw() {`
`54`		`- }`
	`53`	`+ ~Runtime_exception() = default;`
`55`	`54`	`};`
`56`	`55`
`57`	`56`	`class Out_of_bounds_exception : public Runtime_exception {`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ namespace TAP {`
`15`	`15`	`unsigned counter = 0;`
`16`	`16`	`unsigned not_oks = 0;`
`17`	`17`
`18`		`- std::string todo_test() throw() {`
	`18`	`+ std::string todo_test() {`
`19`	`19`	`if (TODO == "") {`
`20`	`20`	`return TODO;`
`21`	`21`	`}`
`@@ -24,24 +24,24 @@ namespace TAP {`
`24`	`24`	`}`
`25`	`25`	`}`
`26`	`26`
`27`		`- bool is_todo_test() throw() { return TODO != ""; }`
	`27`	`+ bool is_todo_test() noexcept { return TODO != ""; }`
`28`	`28`
`29`	`29`	`bool is_planned = false;`
`30`	`30`	`bool no_planned = false;`
`31`	`31`	`bool has_output_plan = false;`
`32`	`32`
`33`		`- void output_plan(unsigned tests, const std::string& extra = "") throw(fatal_exception) {`
	`33`	`+ void output_plan(unsigned tests, const std::string& extra = "") {`
`34`	`34`	`if (has_output_plan) {`
`35`	`35`	`throw fatal_exception("Can't plan twice");`
`36`	`36`	`}`
`37`	`37`	`*details::output << "1.." << tests << extra << std::endl;`
`38`	`38`	`has_output_plan = true;`
`39`	`39`	`}`
`40`		`- inline const std::string to_string(unsigned num) throw() {`
	`40`	`+ inline const std::string to_string(unsigned num) {`
`41`	`41`	`return boost::lexical_cast<std::string>(num);`
`42`	`42`	`}`
`43`	`43`
`44`		`- inline void _done_testing(unsigned tests) throw(fatal_exception) {`
	`44`	`+ inline void _done_testing(unsigned tests) {`
`45`	`45`	`static bool is_done = false;`
`46`	`46`	`if (is_done) {`
`47`	`47`	`fail("done_testing() was already called");`
`@@ -63,40 +63,40 @@ namespace TAP {`
`63`	`63`
`64`	`64`	`}`
`65`	`65`
`66`		`- void plan(unsigned tests) throw(fatal_exception) {`
	`66`	`+ void plan(unsigned tests) {`
`67`	`67`	`if (is_planned) {`
`68`	`68`	`bail_out("Can't plan again!");`
`69`	`69`	`}`
`70`	`70`	`is_planned = true;`
`71`	`71`	`output_plan(tests);`
`72`	`72`	`expected = tests;`
`73`	`73`	`}`
`74`		`- void plan(const details::skip_all_type&, const std::string& reason) throw(fatal_exception) {`
	`74`	`+ void plan(const details::skip_all_type&, const std::string& reason) {`
`75`	`75`	`output_plan(0, " #skip " + reason);`
`76`	`76`	`std::exit(0);`
`77`	`77`	`}`
`78`		`- void plan(const details::no_plan_type&) throw() {`
	`78`	`+ void plan(const details::no_plan_type&) {`
`79`	`79`	`is_planned = true;`
`80`	`80`	`no_planned = true;`
`81`	`81`	`}`
`82`	`82`
`83`		`- void done_testing() throw(fatal_exception) {`
	`83`	`+ void done_testing() {`
`84`	`84`	`_done_testing(encountered());`
`85`	`85`	`}`
`86`	`86`
`87`		`- void done_testing(unsigned tests) throw(fatal_exception) {`
	`87`	`+ void done_testing(unsigned tests) {`
`88`	`88`	`no_planned = false;`
`89`	`89`	`_done_testing(tests);`
`90`	`90`	`}`
`91`	`91`
`92`		`- unsigned planned() throw() {`
	`92`	`+ unsigned planned() {`
`93`	`93`	`return expected;`
`94`	`94`	`}`
`95`		`- unsigned encountered() throw() {`
	`95`	`+ unsigned encountered() {`
`96`	`96`	`return counter;`
`97`	`97`	`}`
`98`	`98`
`99`		`- int exit_status() throw () {`
	`99`	`+ int exit_status() {`
`100`	`100`	`// bool passing;`
`101`	`101`	`if (!is_planned && encountered()) {`
`102`	`102`	`diag("Tests were run but no plan was declared and done_testing() was not seen.");`
`@@ -112,80 +112,80 @@ namespace TAP {`
`112`	`112`	`return 255;`
`113`	`113`	`}`
`114`	`114`	`}`
`115`		`- bool summary() throw() {`
	`115`	`+ bool summary() {`
`116`	`116`	`return not_oks;`
`117`	`117`	`}`
`118`	`118`
`119`		`- void bail_out(const std::string& reason) throw() {`
	`119`	`+ void bail_out(const std::string& reason) {`
`120`	`120`	`*details::output << "Bail out! " << reason << std::endl;`
`121`	`121`	`std::exit(255); // Does not unwind stack!`
`122`	`122`	`}`
`123`	`123`
`124`		`- bool ok(bool is_ok, const std::string& message) throw() {`
	`124`	`+ bool ok(bool is_ok, const std::string& message) {`
`125`	`125`	`const char* hot_or_not = is_ok ? "" : "not ";`
`126`	`126`	`*details::output << hot_or_not << "ok " << ++counter<< " - " << message << todo_test() << std::endl;`
`127`	`127`	`if (!is_ok && !is_todo_test()) {`
`128`	`128`	`++not_oks;`
`129`	`129`	`}`
`130`	`130`	`return is_ok;`
`131`	`131`	`}`
`132`		`- bool not_ok(bool is_not_ok, const std::string& message) throw() {`
	`132`	`+ bool not_ok(bool is_not_ok, const std::string& message) {`
`133`	`133`	`return !ok(!is_not_ok, message);`
`134`	`134`	`}`
`135`	`135`
`136`		`- bool pass(const std::string& message) throw() {`
	`136`	`+ bool pass(const std::string& message) {`
`137`	`137`	`return ok(true, message);`
`138`	`138`	`}`
`139`		`- bool fail(const std::string& message) throw() {`
	`139`	`+ bool fail(const std::string& message) {`
`140`	`140`	`return ok(false, message);`
`141`	`141`	`}`
`142`	`142`
`143`		`- void skip(unsigned num, const std::string& reason) throw () {`
	`143`	`+ void skip(unsigned num, const std::string& reason) {`
`144`	`144`	`for(unsigned i = 0; i < num; ++i) {`
`145`	`145`	`pass(" # skip " + reason);`
`146`	`146`	`}`
`147`	`147`	`}`
`148`	`148`
`149`		`- void set_output(std::ostream& new_output) throw (fatal_exception) {`
	`149`	`+ void set_output(std::ostream& new_output) {`
`150`	`150`	`if (is_planned) {`
`151`	`151`	`throw fatal_exception("Can't set output after plan()");`
`152`	`152`	`}`
`153`	`153`	`details::output = &new_output;`
`154`	`154`	`}`
`155`		`- void set_error(std::ostream& new_error) throw(fatal_exception) {`
	`155`	`+ void set_error(std::ostream& new_error) {`
`156`	`156`	`if (is_planned) {`
`157`	`157`	`throw fatal_exception("Can't set error after plan()");`
`158`	`158`	`}`
`159`	`159`	`details::error = &new_error;`
`160`	`160`	`}`
`161`		`- todo_guard::todo_guard() throw() : value(TODO) {`
	`161`	`+ todo_guard::todo_guard() : value(TODO) {`
`162`	`162`	`}`
`163`		`- todo_guard::~todo_guard() throw() {`
	`163`	`+ todo_guard::~todo_guard() {`
`164`	`164`	`TODO = value;`
`165`	`165`	`}`
`166`	`166`	`namespace details {`
`167`	`167`	`std::ostream* output = &std::cout;`
`168`	`168`	`std::ostream* error = &std::cout;`
`169`	`169`	`static std::stack<unsigned> block_expected;`
`170`		`- void start_block(unsigned expected) throw() {`
	`170`	`+ void start_block(unsigned expected) {`
`171`	`171`	`block_expected.push(encountered() + expected);`
`172`	`172`	`}`
`173`		`- unsigned stop_block() throw(fatal_exception) {`
	`173`	`+ unsigned stop_block() {`
`174`	`174`	`unsigned ret = block_expected.top();`
`175`	`175`	`block_expected.pop();`
`176`	`176`	`return ret;`
`177`	`177`	`}`
`178`	`178`
`179`		`- char const * failed_test_msg() throw() {`
`180`		`- return is_todo_test()?"Failed (TODO) test":"Failed test";`
	`179`	`+ char const * failed_test_msg() noexcept {`
	`180`	`+ return is_todo_test() ? "Failed (TODO) test" : "Failed test";`
`181`	`181`	`}`
`182`	`182`
`183`	`183`	`}`
`184`	`184`
`185`		`- void skip(const std::string& reason) throw(details::Skip_exception) {`
	`185`	`+ void skip(const std::string& reason) {`
`186`	`186`	`throw details::Skip_exception(reason);`
`187`	`187`	`}`
`188`		`- void skip_todo(const std::string& reason) throw(details::Todo_exception) {`
	`188`	`+ void skip_todo(const std::string& reason) {`
`189`	`189`	`throw details::Todo_exception(reason);`
`190`	`190`	`}`
`191`	`191`