Description: dynamic exception specifications have been removed in C++17
 remove throw(ParserError) from functions and variables
Author: Christian T. Steigies <cts@debian.org>
Last-Update: 2022-10-31
Index: gle-graphics-4.3.3/src/gle/tokens/Tokenizer.h
===================================================================
--- gle-graphics-4.3.3.orig/src/gle/tokens/Tokenizer.h
+++ gle-graphics-4.3.3/src/gle/tokens/Tokenizer.h
@@ -137,7 +137,7 @@ public:
 
 IThrowsError* g_get_throws_error();
 
-double tokenizer_string_to_double(const char* value) throw(ParserError);
+double tokenizer_string_to_double(const char* value);
 
 #if defined(__UNIX__) || defined(__MAC__)
 	ParserError g_format_parser_error(const char* format, ...);
@@ -145,13 +145,13 @@ double tokenizer_string_to_double(const
 	ParserError g_format_parser_error(va_list format, ...);
 #endif
 
-void g_throw_parser_error(const string& err) throw(ParserError);
+void g_throw_parser_error(const string& err);
 
-void g_throw_parser_error(const char* err, int idx) throw(ParserError);
+void g_throw_parser_error(const char* err, int idx);
 
-void g_throw_parser_error(const char* str1, const char* str2, const char* str3) throw(ParserError);
+void g_throw_parser_error(const char* str1, const char* str2, const char* str3);
 
-void g_throw_parser_error_sys(const char* str1, const char* str2 = NULL, const char* str3 = NULL) throw(ParserError);
+void g_throw_parser_error_sys(const char* str1, const char* str2 = NULL, const char* str3 = NULL);
 
 #define MAX_PUSHBACK_CH 2
 
@@ -302,21 +302,21 @@ public:
 	Tokenizer(TokenizerLanguage* lang);
 	virtual ~Tokenizer();
 
-	int has_more_tokens() throw(ParserError);
+	int has_more_tokens();
 	// end of stream not reached
 
-	string& next_token() throw(ParserError);
+	string& next_token();
 	// returns next token.  throws exception if no more tokens.
 
-	string& next_continuous_string_excluding(const char* forbidden) throw(ParserError);
+	string& next_continuous_string_excluding(const char* forbidden);
 
-	string& try_next_token() throw(ParserError);
+	string& try_next_token();
 
-	string& read_line() throw(ParserError);
+	string& read_line();
 
-	double next_double() throw(ParserError);
+	double next_double();
 
-	int next_integer() throw(ParserError);
+	int next_integer();
 	// reads an integer token.  throws exception if token is not
 	// an integer
 
@@ -332,7 +332,7 @@ public:
 
 	TokenizerLangElem* try_find_lang_elem(int i);
 
-	void next_token_and_pos(TokenAndPos& tkpos) throw(ParserError);
+	void next_token_and_pos(TokenAndPos& tkpos);
 
 	void pushback_token();
 
@@ -344,7 +344,7 @@ public:
 
 	void pushback_token(const char* token);
 
-	void peek_token(string* token) throw(ParserError);
+	void peek_token(string* token);
 	// look at next token without moving the current token pointer
 
 	bool has_space_before() const { return m_space_before; };
@@ -365,40 +365,40 @@ public:
 
 	inline const TokenizerPos& token_stream_pos() const { return m_token_count; };
 
-	int is_next_token(const char* token) throw(ParserError);
+	int is_next_token(const char* token);
 
-	int is_next_token_i(const char* token) throw(ParserError);
+	int is_next_token_i(const char* token);
 
-	int is_next_token(const string& token) throw(ParserError) {
+	int is_next_token(const string& token) {
 		return is_next_token(token.c_str());
 	}
 	// checks wether next token is [token].  if so, the token is
 	// consumed (current token pointer moved).   Otherwise,
 	// the next token is not consumed.
 
-	int is_next_token_in(const char* charlist) throw(ParserError);
+	int is_next_token_in(const char* charlist);
 
-	void ensure_next_token(const char* token) throw(ParserError);
+	void ensure_next_token(const char* token);
 	// ensures the next token is [token] and moves current token pointer
 	// raises exception if next token is not [token]
 
-	void ensure_next_token_i(const char* token) throw(ParserError);
+	void ensure_next_token_i(const char* token);
 
-	int ensure_next_token_in(const char* charlist) throw(ParserError);
+	int ensure_next_token_in(const char* charlist);
 	// reads a one-character token occurring in charlist.
 	// raises exception when the next token is not as expected.
 
-	void ensure_next_token_list(const char* charlist) throw(ParserError);
+	void ensure_next_token_list(const char* charlist);
 	// reads a list of one-character tokens
 
 	void token_skip_to_end();
 	// skips to end of line
 
-	void read_till_close_comment() throw(ParserError);
+	void read_till_close_comment();
 
-	string& next_multilevel_token() throw(ParserError);
+	string& next_multilevel_token();
 
-	virtual char token_read_sig_char() throw(ParserError);
+	virtual char token_read_sig_char();
 
 	virtual void on_trailing_space();
 
@@ -449,14 +449,14 @@ protected:
 	void reset_position();
 	void reset_nopos();
 	void reset_all();
-    void undo_pushback_token();
-	void copy_string(char endch) throw(ParserError);
-	void multi_level_do_multi(char open) throw(ParserError);
-	void get_token() throw(ParserError);
+  	void undo_pushback_token();
+	void copy_string(char endch);
+	void multi_level_do_multi(char open);
+	void get_token();
 	// consumes one token (and forgets it?)
 	// raises exception when e.g. a string constant is not terminated.
-	void get_token_2() throw(ParserError);
-	void get_check_token() throw(ParserError);
+	void get_token_2();
+	void get_check_token();
 	TokenizerLangElem* findLangElem(const TokenizerLangHash* hash);
 	TokenizerLangElem* findLangElem2(const TokenizerLangHash* hash);
 };
@@ -471,8 +471,8 @@ public:
 	StreamTokenizer(istream* _is);
 	StreamTokenizer(istream* _is, TokenizerLanguage* lang);
 	virtual ~StreamTokenizer();
-	void open_tokens(const char* fname) throw(ParserError);
-	void open_tokens(const string& fname) throw(ParserError);
+	void open_tokens(const char* fname);
+	void open_tokens(const string& fname);
 	void open_tokens(istream* strm, const char* fname);
 	void close_tokens();
 	virtual int stream_ok();
Index: gle-graphics-4.3.3/src/gle/glepro.h
===================================================================
--- gle-graphics-4.3.3.orig/src/gle/glepro.h
+++ gle-graphics-4.3.3/src/gle/glepro.h
@@ -72,10 +72,10 @@ int df_circle_stroke(dbl r);
 int df_narc(dbl r,dbl t1,dbl t2,dbl cx,dbl cy);
 int mem_total(void);
 int mem_worst(void);
-GLERC<GLEColor> pass_color_var(const std::string& token) throw(ParserError);
+GLERC<GLEColor> pass_color_var(const std::string& token);
 int pass_font(const std::string& token);
 int pass_justify(const std::string& token);
-int pass_marker(char *s) throw(ParserError);
+int pass_marker(char *s);
 int testfree(int i);
 int text_printf(int *in,int ilen);
 int w_message(char *s);
@@ -145,9 +145,9 @@ const string& get_extra_arg(int i);
 void gle_abort(const char *s);
 void do_wait_for_enter();
 void do_wait_for_enter_exit(int exitcode);
-void validate_open_input_stream(ifstream& input, const string& fname) throw(ParserError);
-FILE* validate_fopen(const string& fname, const char *mode, bool isread) throw(ParserError);
-void validate_file_name(const string& fname, bool isread) throw(ParserError);
+void validate_open_input_stream(ifstream& input, const string& fname);
+FILE* validate_fopen(const string& fname, const char *mode, bool isread);
+void validate_file_name(const string& fname, bool isread);
 string fontdir(const char *s);
 int check_has_font(const std::string& name);
 int get_marker_string(const string& marker, IThrowsError* error);
Index: gle-graphics-4.3.3/src/gle/core.h
===================================================================
--- gle-graphics-4.3.3.orig/src/gle/core.h
+++ gle-graphics-4.3.3/src/gle/core.h
@@ -220,7 +220,7 @@ void g_get_hei(double *h);
 //void g_gsave(void);
 void g_hint(char *s);
 void g_marker(int i, double sz);
-void g_marker2(int i, double sz, double dval) throw (ParserError);
+void g_marker2(int i, double sz, double dval);
 void g_set_hei(double h);
 bool gclip(double *x1,double *y1, double *x2, double *y2,double xmin, double ymin, double xmax, double ymax);
 void g_pscomment(char* ss);
@@ -237,8 +237,8 @@ GLECore* g_get_core();
 // -- no need to ifdef these
 // they will simply print warning message if libraries are not linked
 //
-void g_bitmap(string& fname, double wx, double wy, int type) throw(ParserError);
-void g_bitmap_info(string& fname, int xvar, int yvar, int type) throw(ParserError);
+void g_bitmap(string& fname, double wx, double wy, int type);
+void g_bitmap_info(string& fname, int xvar, int yvar, int type);
 int g_bitmap_string_to_type(const std::string& stype);
 int g_bitmap_string_to_type(const char* stype);
 string g_bitmap_supported_types();
@@ -249,7 +249,7 @@ void g_elliptical_arc(double rx, double
 void g_elliptical_narc(double rx, double ry, double t1, double t2, double cx, double cy, int arrow);
 
 void g_arrowsize(GLEArrowProps* arrow);
-void g_arrowline(double x2, double y2, int flag, int can_fillpath) throw(ParserError);
+void g_arrowline(double x2, double y2, int flag, int can_fillpath);
 
 void g_arrowpoints(double cx,double cy,double dx,double dy, double *ax1,
                    double *ay1,double *ax2,double *ay2, double *nnx, double *nny);
@@ -273,7 +273,7 @@ int g_get_device();
 bool g_is_dummy_device();
 void g_resetfont();
 
-void g_arrow(double dx, double dy, int can_fillpath) throw(ParserError);
+void g_arrow(double dx, double dy, int can_fillpath);
 void g_arrowcurve(double x, double y, int arrow, double a1, double a2, double d1, double d2);
 bool g_has_size();
 void g_set_size(double width, double height, bool box);
@@ -295,8 +295,8 @@ int g_get_pdf_image_format();
 
 int g_get_compatibility();
 void g_set_compatibility(int compat);
-int g_set_compatibility(const string& compat) throw (ParserError);
-int g_parse_compatibility(const string& compat) throw (ParserError);
+int g_set_compatibility(const string& compat);
+int g_parse_compatibility(const string& compat);
 void g_compatibility_settings();
 
 void g_set_iconst(int i, int value);
@@ -323,10 +323,10 @@ void g_dev_rel(GLEPoint* pt);
 void g_dev(GLERectangle* rect);
 void g_undev(GLERectangle* rect);
 void g_undev(GLERectangle* rect, gmodel* g);
-void g_set_arrow_style(const char* shape) throw (ParserError);
-void g_set_arrow_tip(const char* tip) throw (ParserError);
+void g_set_arrow_style(const char* shape);
+void g_set_arrow_tip(const char* tip);
 
-void g_bitmap(GLEBitmap*, double wx, double wy, int type) throw(ParserError);
+void g_bitmap(GLEBitmap*, double wx, double wy, int type);
 
 void g_set_tex_scale(const char* ss);
 void g_set_tex_labels(bool onoff);
@@ -418,7 +418,7 @@ bool g_reset_message();
 void g_move(double zx,double zy);
 void g_set_pos(double zx,double zy);
 void g_newpath(void);
-void g_postscript(char *ss,double w,double h) throw (ParserError);
+void g_postscript(char *ss,double w,double h);
 bool g_parse_ps_boundingbox(const string& line, int* bx1, int* by1, int* bx2, int* by2);
 void g_rdev(double x, double y,double *xd,double *yd);
 void g_reverse(void);
Index: gle-graphics-4.3.3/src/gle/begin.h
===================================================================
--- gle-graphics-4.3.3.orig/src/gle/begin.h
+++ gle-graphics-4.3.3/src/gle/begin.h
@@ -71,7 +71,7 @@ bool begin_line_norep(int *pln, string&
 
 void replace_exp(string& exp);
 
-double token_next_double(int i) throw(ParserError);
+double token_next_double(int i);
 
 bool get_block_line(int pln, string& srclin);
 
Index: gle-graphics-4.3.3/src/gle/glearray.h
===================================================================
--- gle-graphics-4.3.3.orig/src/gle/glearray.h
+++ gle-graphics-4.3.3/src/gle/glearray.h
@@ -102,7 +102,7 @@ protected:
 public:
 	GLEZData();
 	~GLEZData();
-	void read(const string& fname) throw(ParserError);
+	void read(const string& fname);
 	inline double getZMin() { return m_ZMin; }
 	inline double getZMax() { return m_ZMax; }
 	inline GLERectangle* getBounds() { return &m_XYBounds; }
Index: gle-graphics-4.3.3/src/gle/letzfitz/let.cpp
===================================================================
--- gle-graphics-4.3.3.orig/src/gle/letzfitz/let.cpp
+++ gle-graphics-4.3.3/src/gle/letzfitz/let.cpp
@@ -69,7 +69,7 @@ void get_next_exp_file(TOKENS tk, int nt
 #define next_file_eval(s) get_next_exp_file(tk,ntk,&ct,&s)
 #define next_str(s) ct+=1;s=tk[ct]
 
-void get_from_to_step(TOKENS tk, int ntok, int *curtok, double* from, double* to, double* step) throw(ParserError) {
+void get_from_to_step(TOKENS tk, int ntok, int *curtok, double* from, double* to, double* step) {
 	(*curtok) = (*curtok) + 1;
 	if ((*curtok) >= ntok) {
 		return;
@@ -106,7 +106,7 @@ void get_from_to_step(TOKENS tk, int nto
 	}
 }
 
-void begin_letz(int *pln, GLEPcodeList* pclist, int *pcode, int *cp) throw(ParserError) {
+void begin_letz(int *pln, GLEPcodeList* pclist, int *pcode, int *cp) {
 	// Variables
 	double xmin = 10, xmax = 10, xstep = 1;
 	double ymin = 10, ymax = 10, ystep = 1;
Index: gle-graphics-4.3.3/src/gle/polish.h
===================================================================
--- gle-graphics-4.3.3.orig/src/gle/polish.h
+++ gle-graphics-4.3.3/src/gle/polish.h
@@ -133,9 +133,9 @@ protected:
 public:
 	GLEFunctionParserPcode();
 	~GLEFunctionParserPcode();
-	void polish(const char* fct, StringIntHash* vars = NULL) throw(ParserError);
-	void polishPos(const char* fct, int pos, StringIntHash* vars = NULL) throw(ParserError);
-	void polishX() throw(ParserError);
+	void polish(const char* fct, StringIntHash* vars = NULL);
+	void polishPos(const char* fct, int pos, StringIntHash* vars = NULL);
+	void polishX();
 	double evalDouble();
 	bool evalBool();
 	inline GLEPcode* getCode() { return &m_Pcode; }
@@ -149,17 +149,17 @@ protected:
 public:
 	GLEPolish();
 	~GLEPolish();
-	void internalPolish(const char *expr, GLEPcode& pcode, int *rtype) throw(ParserError);
-	void internalPolish(GLEPcode& pcode, int *rtype) throw(ParserError);
-	void internalEval(const char *exp, double *x) throw(ParserError);
-    void internalEvalString(const char* exp, string* str) throw(ParserError);
-	void polish(const char *expr, GLEPcode& pcode, int *rtype) throw(ParserError);
-	void eval(GLEArrayImpl* stk, const char *exp, double *x) throw(ParserError);
-	void evalString(GLEArrayImpl* stk, const char *exp, string *str, bool allownum = false) throw(ParserError);
-	GLEMemoryCell* evalGeneric(GLEArrayImpl* stk, const char *exp) throw(ParserError);
-	int get_params(GLEPcode& pcode, int np, int* plist, const string& name, int np_default = 0) throw(ParserError);
-	void get_array_index(GLEPcode& pcode) throw(ParserError);
-	double evalTokenToDouble() throw(ParserError);
+	void internalPolish(const char *expr, GLEPcode& pcode, int *rtype);
+	void internalPolish(GLEPcode& pcode, int *rtype);
+	void internalEval(const char *exp, double *x);
+    void internalEvalString(const char* exp, string* str);
+	void polish(const char *expr, GLEPcode& pcode, int *rtype);
+	void eval(GLEArrayImpl* stk, const char *exp, double *x);
+	void evalString(GLEArrayImpl* stk, const char *exp, string *str, bool allownum = false);
+	GLEMemoryCell* evalGeneric(GLEArrayImpl* stk, const char *exp);
+	int get_params(GLEPcode& pcode, int np, int* plist, const string& name, int np_default = 0);
+	void get_array_index(GLEPcode& pcode);
+	double evalTokenToDouble();
 	Tokenizer* getTokens(const string& str);
 	void initTokenizer();
 	inline void setExprVars(StringIntHash* vars) { m_vars = vars; }
@@ -171,9 +171,9 @@ public:
 	};
 };
 
-void polish_eval(char *exp, double *x) throw(ParserError);
-void polish_eval_string(const char *exp, string *str, bool allownum = false) throw(ParserError);
-void polish(char *expr, GLEPcode& pcode, int *rtype) throw(ParserError);
+void polish_eval(char *exp, double *x);
+void polish_eval_string(const char *exp, string *str, bool allownum = false);
+void polish(char *expr, GLEPcode& pcode, int *rtype);
 void eval_pcode(GLEPcode& pcode, double* x);
 void eval_pcode_str(GLEPcode& pcode, string& x);
 
Index: gle-graphics-4.3.3/src/gle/run.h
===================================================================
--- gle-graphics-4.3.3.orig/src/gle/run.h
+++ gle-graphics-4.3.3/src/gle/run.h
@@ -41,21 +41,21 @@
 
 class GLEPcodeList;
 
-void sub_call(int idx,double *pval,char **pstr,int *npm, int *otyp) throw(ParserError);
+void sub_call(int idx,double *pval,char **pstr,int *npm, int *otyp);
 
-GLEString* evalStringPtr(GLEArrayImpl* stk, GLEPcodeList* pclist, int *pcode, int *cp) throw(ParserError);
-GLERC<GLEString> evalString(GLEArrayImpl* stk, GLEPcodeList* pclist, int *pcode, int *cp, bool allowOther) throw(ParserError);
-GLEMemoryCell* evalGeneric(GLEArrayImpl* stk, GLEPcodeList* pclist, int *pcode, int *cp) throw(ParserError);
-double evalDouble(GLEArrayImpl* stk, GLEPcodeList* pclist, int *pcode, int *cp) throw(ParserError);
-bool evalBool(GLEArrayImpl* stk, GLEPcodeList* pclist, int *pcode, int *cp) throw(ParserError);
-GLERC<GLEColor> evalColor(GLEArrayImpl* stk, GLEPcodeList* pclist, int *pcode, int *cp) throw(ParserError);
-GLESub* eval_subroutine_call(GLEArrayImpl* stk, GLEPcodeList* pclist, int *pcode, int *cp) throw(ParserError);
-void eval_do_object_block_call(GLEArrayImpl* stk, GLESub* sub, GLEObjectDO* obj) throw(ParserError);
+GLEString* evalStringPtr(GLEArrayImpl* stk, GLEPcodeList* pclist, int *pcode, int *cp);
+GLERC<GLEString> evalString(GLEArrayImpl* stk, GLEPcodeList* pclist, int *pcode, int *cp, bool allowOther);
+GLEMemoryCell* evalGeneric(GLEArrayImpl* stk, GLEPcodeList* pclist, int *pcode, int *cp);
+double evalDouble(GLEArrayImpl* stk, GLEPcodeList* pclist, int *pcode, int *cp);
+bool evalBool(GLEArrayImpl* stk, GLEPcodeList* pclist, int *pcode, int *cp);
+GLERC<GLEColor> evalColor(GLEArrayImpl* stk, GLEPcodeList* pclist, int *pcode, int *cp);
+GLESub* eval_subroutine_call(GLEArrayImpl* stk, GLEPcodeList* pclist, int *pcode, int *cp);
+void eval_do_object_block_call(GLEArrayImpl* stk, GLESub* sub, GLEObjectDO* obj);
 
 void clear_run();
 
-void g_set_pagesize(const string& papersize) throw (ParserError);
-void g_set_margins(const string& margins) throw (ParserError);
+void g_set_pagesize(const string& papersize);
+void g_set_margins(const string& margins);
 
 GLEFileLocation* get_output_file();
 const string& get_input_file();
@@ -90,25 +90,25 @@ public:
 	void setBlockTypes(GLEBlocks* blocks);
 	GLEBlocks* getBlockTypes();
 	void setDeviceIsOpen(bool open);
-	void do_pcode(GLESourceLine &SLine,int *srclin, int *pcode, int plen, int *pend, bool& mkdrobjs) throw(ParserError);
-	void begin_object(const std::string& name, GLESub* sub) throw (ParserError);
-	void end_object() throw (ParserError);
-	void draw_object_static(const string& path, const string& name, int* pcode, int* cp, bool mkdrobjs) throw (ParserError);
-	void draw_object_subbyname(GLESub* sub, GLEObjectRepresention* newobj, GLEArrayImpl* path, GLEPoint* orig) throw (ParserError);
-	void draw_object_dynamic(int idx, GLEObjectRepresention* newobj, GLEArrayImpl* path, GLEPoint* orig) throw (ParserError);
-	void draw_object(const string& name, const char* newname) throw (ParserError);
-	void sub_call(GLESub* sub, GLEArrayImpl* arguments = 0) throw(ParserError);
-	void sub_call_stack(GLESub* sub, GLEArrayImpl* stk) throw(ParserError);
+	void do_pcode(GLESourceLine &SLine,int *srclin, int *pcode, int plen, int *pend, bool& mkdrobjs);
+	void begin_object(const std::string& name, GLESub* sub);
+	void end_object();
+	void draw_object_static(const string& path, const string& name, int* pcode, int* cp, bool mkdrobjs);
+	void draw_object_subbyname(GLESub* sub, GLEObjectRepresention* newobj, GLEArrayImpl* path, GLEPoint* orig);
+	void draw_object_dynamic(int idx, GLEObjectRepresention* newobj, GLEArrayImpl* path, GLEPoint* orig);
+	void draw_object(const string& name, const char* newname);
+	void sub_call(GLESub* sub, GLEArrayImpl* arguments = 0);
+	void sub_call_stack(GLESub* sub, GLEArrayImpl* stk);
 	void name_set(GLEString* name, double x1, double y1, double x2, double y2);
-	static GLEObjectRepresention* name_to_object(GLEObjectRepresention* obj, GLEArrayImpl* path, GLEJustify* just, unsigned int offs) throw (ParserError);
-	GLEObjectRepresention* name_to_object(GLEString* name, GLEJustify* just) throw(ParserError);
+	static GLEObjectRepresention* name_to_object(GLEObjectRepresention* obj, GLEArrayImpl* path, GLEJustify* just, unsigned int offs);
+	GLEObjectRepresention* name_to_object(GLEString* name, GLEJustify* just);
 	bool is_name(GLEObjectRepresention* obj, GLEArrayImpl* path, unsigned int offs);
 	bool is_name(GLEString* name);
-	void name_to_point(GLEString* name, GLEPoint* point) throw(ParserError);
-	void name_to_size(GLEString* name, double *wd, double *hi) throw(ParserError);
-	void name_join(GLEString* n1, GLEString* n2, int marrow, double a1, double a2, double d1, double d2)  throw(ParserError);
-	GLEStoredBox* last_box() throw (ParserError);
-	bool box_end() throw (ParserError);
+	void name_to_point(GLEString* name, GLEPoint* point);
+	void name_to_size(GLEString* name, double *wd, double *hi);
+	void name_join(GLEString* n1, GLEString* n2, int marrow, double a1, double a2, double d1, double d2);
+	GLEStoredBox* last_box();
+	bool box_end();
 	void begin_length(int var);
 	void end_length();
 	GLESubMap* getSubroutines();
Index: gle-graphics-4.3.3/src/gle/texinterface.h
===================================================================
--- gle-graphics-4.3.3.orig/src/gle/texinterface.h
+++ gle-graphics-4.3.3/src/gle/texinterface.h
@@ -219,12 +219,12 @@ protected:
 public:
 	TeXInterface();
 	~TeXInterface();
-	TeXObject* draw(const char* str) throw(ParserError);
-	TeXObject* drawUTF8(const char* str, GLERectangle* box = NULL) throw(ParserError);
-	TeXObject* draw(const std::string& str, GLERectangle* box) throw(ParserError);
-	TeXObject* draw(const char* str, int nblines, GLERectangle* box = NULL) throw(ParserError);
-	TeXObject* draw(const char* str, TeXObjectInfo& info, int nblines, GLERectangle* box = NULL) throw(ParserError);
-	TeXObject* drawObj(TeXHashObject* hobj, TeXObjectInfo& info, GLERectangle* box = NULL) throw(ParserError);
+	TeXObject* draw(const char* str);
+	TeXObject* drawUTF8(const char* str, GLERectangle* box = NULL);
+	TeXObject* draw(const std::string& str, GLERectangle* box);
+	TeXObject* draw(const char* str, int nblines, GLERectangle* box = NULL);
+	TeXObject* draw(const char* str, TeXObjectInfo& info, int nblines, GLERectangle* box = NULL);
+	TeXObject* drawObj(TeXHashObject* hobj, TeXObjectInfo& info, GLERectangle* box = NULL);
 	void scaleObject(string& obj_str, double hei);
 	void checkObjectDimensions();
 	int createObj(const char* str, double hei);
Index: gle-graphics-4.3.3/src/gle/var.h
===================================================================
--- gle-graphics-4.3.3.orig/src/gle/var.h
+++ gle-graphics-4.3.3/src/gle/var.h
@@ -223,7 +223,7 @@ void var_findadd_set(const char *s, GLEM
 GLEVarSubMap* var_add_local_submap();
 void var_remove_local_submap();
 bool str_var_valid_name(const string& name);
-void ensure_valid_var_name(const string& name) throw(ParserError);
-void ensure_valid_var_name(Tokenizer* tokens, const string& name) throw(ParserError);
+void ensure_valid_var_name(const string& name);
+void ensure_valid_var_name(Tokenizer* tokens, const string& name);
 
 #endif
Index: gle-graphics-4.3.3/src/gle/d_interface.h
===================================================================
--- gle-graphics-4.3.3.orig/src/gle/d_interface.h
+++ gle-graphics-4.3.3/src/gle/d_interface.h
@@ -86,7 +86,7 @@ public:
 	virtual void move(double zx,double zy) = 0;
 	virtual void narc(dbl r,dbl t1,dbl t2,dbl cx,dbl cy) = 0;
 	virtual void newpath(void) = 0;
-	virtual void opendev(double width, double height, GLEFileLocation* outputfile, const string& inputfile) throw(ParserError) = 0;
+	virtual void opendev(double width, double height, GLEFileLocation* outputfile, const string& inputfile) = 0;
 	virtual void pscomment(char* ss) = 0;
 	virtual void reverse(void)    /* reverse the order of stuff in the current path */ = 0;
 	virtual void set_color(const GLERC<GLEColor>& color) = 0;
@@ -169,7 +169,7 @@ public:
 	virtual void move(double zx,double zy);
 	virtual void narc(dbl r,dbl t1,dbl t2,dbl cx,dbl cy);
 	virtual void newpath(void);
-	virtual void opendev(double width, double height, GLEFileLocation* outputfile, const string& inputfile) throw(ParserError);
+	virtual void opendev(double width, double height, GLEFileLocation* outputfile, const string& inputfile);
 	virtual void pscomment(char* ss);
 	virtual void reverse(void)    /* reverse the order of stuff in the current path */;
 	virtual void set_color(const GLERC<GLEColor>& color);
@@ -265,7 +265,7 @@ public:
 	virtual void move(double zx,double zy);
 	virtual void narc(dbl r,dbl t1,dbl t2,dbl cx,dbl cy);
 	virtual void newpath(void);
-	virtual void opendev(double width, double height, GLEFileLocation* outputfile, const string& inputfile) throw(ParserError);
+	virtual void opendev(double width, double height, GLEFileLocation* outputfile, const string& inputfile);
 	virtual void pscomment(char* ss);
 	virtual void reverse(void)    /* reverse the order of stuff in the current path */;
 	virtual void set_color(const GLERC<GLEColor>& color);
@@ -308,7 +308,7 @@ class GLECairoDevicePDF : public GLECair
 public:
 	GLECairoDevicePDF(bool showerror);
 	virtual ~GLECairoDevicePDF();
-	virtual void opendev(double width, double height, GLEFileLocation* outputfile, const string& inputfile) throw(ParserError);
+	virtual void opendev(double width, double height, GLEFileLocation* outputfile, const string& inputfile);
 	virtual int getDeviceType();
 };
 
@@ -316,7 +316,7 @@ class GLECairoDeviceEPS : public GLECair
 public:
 	GLECairoDeviceEPS(bool showerror);
 	virtual ~GLECairoDeviceEPS();
-	virtual void opendev(double width, double height, GLEFileLocation* outputfile, const string& inputfile) throw(ParserError);
+	virtual void opendev(double width, double height, GLEFileLocation* outputfile, const string& inputfile);
 	virtual int getDeviceType();
 	virtual void getRecordedBytes(string* output);
 };
@@ -325,7 +325,7 @@ class GLECairoDeviceSVG : public GLECair
 public:
 	GLECairoDeviceSVG(bool showerror);
 	virtual ~GLECairoDeviceSVG();
-	virtual void opendev(double width, double height, GLEFileLocation* outputfile, const string& inputfile) throw(ParserError);
+	virtual void opendev(double width, double height, GLEFileLocation* outputfile, const string& inputfile);
 	virtual int getDeviceType();
 };
 
@@ -342,7 +342,7 @@ public:
 	GLECairoDeviceEMF(bool showerror);
 	virtual ~GLECairoDeviceEMF();
 	virtual void set_matrix(double newmat[3][3]);
-	virtual void opendev(double width, double height, GLEFileLocation* outputfile, const string& inputfile) throw(ParserError);
+	virtual void opendev(double width, double height, GLEFileLocation* outputfile, const string& inputfile);
 	virtual int getDeviceType();
 	virtual void closedev(void);
 	inline void setDPI(double d) { m_DPI = d; }
@@ -389,7 +389,7 @@ public:
 	virtual void move(double zx,double zy);
 	virtual void narc(dbl r,dbl t1,dbl t2,dbl cx,dbl cy);
 	virtual void newpath(void);
-	virtual void opendev(double width, double height, GLEFileLocation* outputfile, const string& inputfile) throw(ParserError);
+	virtual void opendev(double width, double height, GLEFileLocation* outputfile, const string& inputfile);
 	virtual void pscomment(char* ss);
 	virtual void reverse(void)    /* reverse the order of stuff in the current path */;
 	virtual void set_color(const GLERC<GLEColor>& color);
@@ -490,7 +490,7 @@ public:
 	virtual void move(double zx,double zy);
 	virtual void narc(dbl r,dbl t1,dbl t2,dbl cx,dbl cy);
 	virtual void newpath(void);
-	virtual void opendev(double width, double height, GLEFileLocation* outputfile, const string& inputfile) throw(ParserError);
+	virtual void opendev(double width, double height, GLEFileLocation* outputfile, const string& inputfile);
 	virtual void pscomment(char* ss);
 	virtual void reverse(void)    /* reverse the order of stuff in the current path */;
 	virtual void set_color(const GLERC<GLEColor>& color);
Index: gle-graphics-4.3.3/src/gle/gle-interface/gle-sourcefile.h
===================================================================
--- gle-graphics-4.3.3.orig/src/gle/gle-interface/gle-sourcefile.h
+++ gle-graphics-4.3.3/src/gle/gle-interface/gle-sourcefile.h
@@ -91,7 +91,7 @@ public:
 	void performUpdates();
 	int getNextInsertIndex(int line, int pos);
 	void load(istream& input);
-	void load() throw(ParserError);
+	void load();
 	bool tryLoad();
 	inline void addObjectDOConstructor(GLEObjectDOConstructor* cons) { m_Cons.add(cons); }
 	inline int getNbObjectDOConstructors() { return m_Cons.size(); }
@@ -128,7 +128,7 @@ public:
 	void scheduleInsertLine(int i, const string& str);
 	void performUpdates();
 	void sourceLineFileAndNumber(int line, ostream& err);
-	void load() throw(ParserError);
+	void load();
 	bool tryLoad();
 	void clearObjectDOConstructors();
 };
Index: gle-graphics-4.3.3/src/gle/letzfitz/fit.cpp
===================================================================
--- gle-graphics-4.3.3.orig/src/gle/letzfitz/fit.cpp
+++ gle-graphics-4.3.3/src/gle/letzfitz/fit.cpp
@@ -82,8 +82,8 @@ public:
 	string data_file;
 public:
 	GLEFitZData();
-	void loadData() throw(ParserError);
-	void sortData() throw(ParserError);
+	void loadData();
+	void sortData();
 };
 
 GLEFitZData::GLEFitZData() {
@@ -93,7 +93,7 @@ GLEFitZData::GLEFitZData() {
 }
 
 // different from the one in let.cpp because fields are optional here
-void get_from_to_step_fitz(TOKENS tk, int ntok, int *curtok, double* from, double* to, double* step) throw(ParserError) {
+void get_from_to_step_fitz(TOKENS tk, int ntok, int *curtok, double* from, double* to, double* step) {
 	(*curtok) = (*curtok) + 1;
 	if ((*curtok) >= ntok) {
 		return;
@@ -133,7 +133,7 @@ void get_from_to_step_fitz(TOKENS tk, in
 	}
 }
 
-void begin_fitz(int *pln, int *pcode, int *cp) throw(ParserError) {
+void begin_fitz(int *pln, int *pcode, int *cp) {
 	GLEFitZData data;
 	// Start with pcode from the next line
 	(*pln)++;
@@ -253,7 +253,7 @@ void setminmax(double v, double *min, do
 	if (v> *max) *max = v;
 }
 
-void GLEFitZData::loadData() throw(ParserError) {
+void GLEFitZData::loadData() {
 	TokenizerLanguage lang;
 	StreamTokenizer tokens(&lang);
 	string expanded(GLEExpandEnvironmentVariables(data_file));
@@ -282,7 +282,7 @@ void GLEFitZData::loadData() throw(Parse
 	}
 }
 
-void GLEFitZData::sortData() throw(ParserError) {
+void GLEFitZData::sortData() {
 	/* Copy data */
 	for (vector<double>::size_type i = 0; i < pntxyz.size(); i+=3) {
 		double xp = pntxyz[i];
Index: gle-graphics-4.3.3/src/gle/surface/gsurface.cpp
===================================================================
--- gle-graphics-4.3.3.orig/src/gle/surface/gsurface.cpp
+++ gle-graphics-4.3.3/src/gle/surface/gsurface.cpp
@@ -69,7 +69,7 @@ void hide_enddefaults(void);
 
 void text_expand(int x);
 void hide_defaults();
-void pass_line() throw(ParserError);
+void pass_line();
 void pass_title();
 void pass_cube();
 void pass_top();
@@ -230,7 +230,7 @@ int geton() {
         return true;
 }
 
-void pass_line() throw(ParserError) {
+void pass_line() {
 	if (ntk<1) return;
 	kw("SIZE") {sf.screenx = getf(); sf.screeny = getf();}
 	else kw("TITLE") pass_title();
Index: gle-graphics-4.3.3/src/gle/surface/gcontour.cpp
===================================================================
--- gle-graphics-4.3.3.orig/src/gle/surface/gcontour.cpp
+++ gle-graphics-4.3.3/src/gle/surface/gcontour.cpp
@@ -99,7 +99,7 @@ public:
 	inline double getDataY(int i) { return m_YPt[i]; }
 	inline double* getDataXArray() { return &m_XPt[0]; }
 	inline double* getDataYArray() { return &m_YPt[0]; }
-	inline void read(const string& fname) throw(ParserError) { m_Data.read(fname); }
+	inline void read(const string& fname) { m_Data.read(fname); }
 	inline GLERectangle* getBounds() { return m_Data.getBounds(); }
 	inline int getNX() { return m_Data.getNX(); }
 	inline int getNY() { return m_Data.getNY(); }
@@ -119,7 +119,7 @@ public:
 	void addVect(int m, double x, double y);
 	void fillDefault(double zmin, double zmax, double zdel);
 	void createLabels(bool alpha);
-	void openData(const string& name, const string& lab) throw(ParserError);
+	void openData(const string& name, const string& lab);
 	void closeData();
 	void doContour(double zz[], int nrz, int nx, int ny, double zmax);
 	void draw(double* x, double* y, int iflag);
@@ -181,7 +181,7 @@ void GLEContourInfo::createLabels(bool a
 	}
 }
 
-void GLEContourInfo::openData(const string& name, const string& lab) throw(ParserError) {
+void GLEContourInfo::openData(const string& name, const string& lab) {
 	m_DatFile = validate_fopen(name, "w", false);
 	m_LabFile = validate_fopen(lab, "w", false);
 }
@@ -327,7 +327,7 @@ void GLEContourInfo::addVect(int m, doub
 	}
 }
 
-void get_contour_values(GLEContourInfo* info, int ct) throw(ParserError) {
+void get_contour_values(GLEContourInfo* info, int ct) {
 	double from, to, step;
 	bool has_from = false;
 	bool has_to = false;
@@ -355,7 +355,7 @@ void get_contour_values(GLEContourInfo*
 	}
 }
 
-void begin_contour(int *pln, int *pcode, int *cp) throw(ParserError) {
+void begin_contour(int *pln, int *pcode, int *cp) {
 	string data_file;
 	vector<double> cval;
 	vector<string> clab;
Index: gle-graphics-4.3.3/src/gle/tokens/Tokenizer.cpp
===================================================================
--- gle-graphics-4.3.3.orig/src/gle/tokens/Tokenizer.cpp
+++ gle-graphics-4.3.3/src/gle/tokens/Tokenizer.cpp
@@ -173,7 +173,7 @@ ostream& mtab(ostream &os, int nb) {
 	return os;
 }
 
-double tokenizer_string_to_double(const char* value) throw(ParserError) {
+double tokenizer_string_to_double(const char* value) {
 	char *endp;
 	double dvalue = strtod(value, &endp);
 	if (value != endp && *endp == 0) {
@@ -274,14 +274,14 @@ string TokenizerPos::getString(int tab1,
 }
 
 
-void g_throw_parser_error(const string& err) throw(ParserError) {
+void g_throw_parser_error(const string& err) {
 	TokenizerPos pos;
 	pos.setColumn(-1);
 	ParserError err_exp(err, pos, NULL);
 	throw err_exp;
 }
 
-void g_throw_parser_error(const char* str1, const char* str2, const char* str3) throw(ParserError) {
+void g_throw_parser_error(const char* str1, const char* str2, const char* str3) {
 	TokenizerPos pos;
 	pos.setColumn(-1);
 	string err = str1;
@@ -291,7 +291,7 @@ void g_throw_parser_error(const char* st
 	throw err_exp;
 }
 
-void g_throw_parser_error_sys(const char* str1, const char* str2, const char* str3) throw(ParserError) {
+void g_throw_parser_error_sys(const char* str1, const char* str2, const char* str3) {
 	TokenizerPos pos;
 	pos.setColumn(-1);
 	ostringstream err_str;
@@ -304,7 +304,7 @@ void g_throw_parser_error_sys(const char
 	throw err_exp;
 }
 
-void g_throw_parser_error(const char* err, int idx) throw(ParserError) {
+void g_throw_parser_error(const char* err, int idx) {
 	char str[30];
 	sprintf(str, "%d", idx);
 	TokenizerPos pos;
@@ -635,7 +635,7 @@ void Tokenizer::reset_position() {
 	m_token_start.set(0, 0);
 }
 
-int Tokenizer::has_more_tokens() throw(ParserError) {
+int Tokenizer::has_more_tokens() {
   if (m_token_has_pushback > 0) {
 	  return 1;
   }
@@ -651,18 +651,18 @@ int Tokenizer::has_more_tokens() throw(P
   }
 }
 
-string& Tokenizer::next_token() throw(ParserError) {
+string& Tokenizer::next_token() {
 	get_check_token();
 //	cerr << m_token_start << "\t" << m_token << endl;
 	return m_token;
 }
 
-string& Tokenizer::try_next_token() throw(ParserError) {
+string& Tokenizer::try_next_token() {
 	get_token();
 	return m_token;
 }
 
-double Tokenizer::next_double() throw(ParserError) {
+double Tokenizer::next_double() {
 	char *ptr;
 	get_check_token();
 	double result = strtod(m_token.c_str(), &ptr);
@@ -670,7 +670,7 @@ double Tokenizer::next_double() throw(Pa
 	return result;
 }
 
-int Tokenizer::next_integer() throw(ParserError) {
+int Tokenizer::next_integer() {
 	char* ptr;
 	get_check_token();
 	int result = strtol(m_token.c_str(), &ptr, 10);
@@ -685,7 +685,7 @@ int Tokenizer::try_next_integer(int *i)
 	return *ptr != 0 ? 0 : 1;
 }
 
-void Tokenizer::get_token() throw(ParserError) {
+void Tokenizer::get_token() {
 	get_token_2();
 	if ((!m_langhash.isNull()) && m_token.length() > 0) {
 		TokenizerLangHash::const_iterator i = m_langhash->find(m_token);
@@ -718,7 +718,7 @@ TokenizerLangElem* Tokenizer::try_find_l
   return NULL;
 }
 
-void Tokenizer::get_token_2() throw(ParserError) {
+void Tokenizer::get_token_2() {
 	if (m_token_has_pushback > 0) {
 		const TokenAndPos& tkpos = m_pushback_tokens.back();
 		m_token = tkpos.getToken();
@@ -798,7 +798,7 @@ void Tokenizer::get_token_2() throw(Pars
 	}
 }
 
-void Tokenizer::copy_string(char string_delim) throw(ParserError) {
+void Tokenizer::copy_string(char string_delim) {
 	TokenizerPos pos = token_stream_pos();
 	while (m_token_at_end == 0) {
 		char token_ch = token_read_char_no_comment();
@@ -814,7 +814,7 @@ void Tokenizer::copy_string(char string_
 	throw error(pos, "unterminated string constant");
 }
 
-void Tokenizer::multi_level_do_multi(char open) throw(ParserError) {
+void Tokenizer::multi_level_do_multi(char open) {
 	vector<char> m_open_token;
 	m_open_token.push_back(open);
 	TokenizerLanguageMultiLevel* multi = m_language->getMulti();
@@ -852,7 +852,7 @@ void Tokenizer::multi_level_do_multi(cha
 	}
 }
 
-string& Tokenizer::next_continuous_string_excluding(const char* forbidden) throw(ParserError) {
+string& Tokenizer::next_continuous_string_excluding(const char* forbidden) {
    undo_pushback_token();
 	m_token = "";
 	char token_ch = token_read_sig_char();
@@ -888,7 +888,7 @@ void Tokenizer::undo_pushback_token()
 	}
 }
 
-string& Tokenizer::next_multilevel_token() throw(ParserError) {
+string& Tokenizer::next_multilevel_token() {
    undo_pushback_token();
 	m_token = "";
 	char token_ch = token_read_sig_char();
@@ -931,7 +931,7 @@ void Tokenizer::goto_position(const Toke
 	m_token_has_pushback_ch	= 0;
 }
 
-string& Tokenizer::read_line() throw(ParserError) {
+string& Tokenizer::read_line() {
 	m_token = "";
 	while (m_token_has_pushback > 0) {
 		TokenAndPos& tkpos = m_pushback_tokens.back();
@@ -1025,7 +1025,7 @@ void Tokenizer::read_number_term(char to
 	}
 }
 
-void Tokenizer::next_token_and_pos(TokenAndPos& tkpos) throw(ParserError) {
+void Tokenizer::next_token_and_pos(TokenAndPos& tkpos) {
 	get_check_token();
 	tkpos.setToken(m_token);
 	tkpos.setPos(m_token_start);
@@ -1055,14 +1055,14 @@ void Tokenizer::pushback_token(const cha
 	pushback_token(string(token), m_token_start);
 }
 
-void Tokenizer::get_check_token() throw(ParserError) {
+void Tokenizer::get_check_token() {
 	get_token();
 	if (m_token.length() == 0) {
 		throw eof_error();
 	}
 }
 
-void Tokenizer::peek_token(string* token) throw(ParserError) {
+void Tokenizer::peek_token(string* token) {
 	get_check_token();
 	pushback_token();
 	*token = m_token;
@@ -1084,7 +1084,7 @@ void Tokenizer::inc_line() {
 	m_token_count.set_line(m_token_count.getLine()+1);
 }
 
-int Tokenizer::is_next_token(const char* token) throw(ParserError) {
+int Tokenizer::is_next_token(const char* token) {
 	get_token();
 	if (m_token.length() == 0) {
 		return m_token == token;
@@ -1097,7 +1097,7 @@ int Tokenizer::is_next_token(const char*
 	}
 }
 
-int Tokenizer::is_next_token_i(const char* token) throw(ParserError) {
+int Tokenizer::is_next_token_i(const char* token) {
 	get_token();
 	if (m_token.length() == 0) {
 		return m_token == token;
@@ -1110,7 +1110,7 @@ int Tokenizer::is_next_token_i(const cha
 	}
 }
 
-int Tokenizer::is_next_token_in(const char* charlist) throw(ParserError) {
+int Tokenizer::is_next_token_in(const char* charlist) {
 	get_check_token();
 	if (m_token.length() == 1) {
 		char ch = m_token[0];
@@ -1120,7 +1120,7 @@ int Tokenizer::is_next_token_in(const ch
 	return -1;
 }
 
-int Tokenizer::ensure_next_token_in(const char* charlist) throw(ParserError) {
+int Tokenizer::ensure_next_token_in(const char* charlist) {
 	get_check_token();
 	if (m_token.length() == 1) {
 		char ch = m_token[0];
@@ -1129,21 +1129,21 @@ int Tokenizer::ensure_next_token_in(cons
 	throw error(string("expected one of '") + charlist + "', found '" + m_token + "'");
 }
 
-void Tokenizer::ensure_next_token(const char* token) throw(ParserError) {
+void Tokenizer::ensure_next_token(const char* token) {
 	get_check_token();
 	if (m_token != token) {
 		throw error(string("expected '") + token + "', found '" + m_token + "'");
 	}
 }
 
-void Tokenizer::ensure_next_token_i(const char* token) throw(ParserError) {
+void Tokenizer::ensure_next_token_i(const char* token) {
 	get_check_token();
 	if (!str_i_equals(m_token.c_str(), token)) {
 		throw error(string("expected '") + token + "', found '" + m_token + "'");
 	}
 }
 
-void Tokenizer::ensure_next_token_list(const char* charlist) throw(ParserError) {
+void Tokenizer::ensure_next_token_list(const char* charlist) {
 	char err = 0;
 	int len = strlen(charlist);
 	TokenizerPos start = m_token_start;
@@ -1165,7 +1165,7 @@ void Tokenizer::ensure_next_token_list(c
 	}
 }
 
-char Tokenizer::token_read_sig_char() throw(ParserError) {
+char Tokenizer::token_read_sig_char() {
 	char token_ch;
 	while (1) {
 		do {
@@ -1269,7 +1269,7 @@ void Tokenizer::token_skip_to_end() {
 	}
 }
 
-void Tokenizer::read_till_close_comment() throw(ParserError) {
+void Tokenizer::read_till_close_comment() {
 	TokenizerPos start = m_token_count;
 	int prev_ch = 0;
 	while (1) {
@@ -1361,7 +1361,7 @@ StreamTokenizer::~StreamTokenizer() {
 	close_tokens();
 }
 
-void StreamTokenizer::open_tokens(const char* fname) throw(ParserError) {
+void StreamTokenizer::open_tokens(const char* fname) {
 	m_fb = new filebuf();
 	m_fb->open(fname, ios::in);
 	if (!m_fb->is_open()) {
@@ -1374,7 +1374,7 @@ void StreamTokenizer::open_tokens(const
 	m_is = new istream(m_fb);
 }
 
-void StreamTokenizer::open_tokens(const string& fname) throw(ParserError) {
+void StreamTokenizer::open_tokens(const string& fname) {
 	open_tokens(fname.c_str());
 }
 
Index: gle-graphics-4.3.3/src/gle/axis.cpp
===================================================================
--- gle-graphics-4.3.3.orig/src/gle/axis.cpp
+++ gle-graphics-4.3.3/src/gle/axis.cpp
@@ -55,7 +55,7 @@
 double start_subtick(double dsubticks, double dticks, GLEAxis* ax);
 void nice_ticks(double *dticks, double *gmin,double *gmax, double *t1,double *tn,int minset, int maxset);
 void numtrim(char **d,char *s, double dticks);
-void nice_log_ticks(double *start, double *last, double gmin, double gmax) throw (ParserError);
+void nice_log_ticks(double *start, double *last, double gmin, double gmax);
 
 double fnloglen(double v, GLEAxis *ax);
 double fnlogx(double v, GLEAxis *ax);
@@ -872,7 +872,7 @@ void draw_axis_titles_v35(GLEAxis *ax, d
 	g_grestore();
 }
 
-void nice_log_ticks(double *start, double *last, double gmin, double gmax) throw (ParserError) {
+void nice_log_ticks(double *start, double *last, double gmin, double gmax) {
 	if (gmin <= 0 || gmax <= 0) {
 		stringstream err;
 		err << "illegal range for log axis: min = ";
@@ -1120,7 +1120,7 @@ int axis_type(const char *s) {
 	return GLE_AXIS_ALL;
 }
 
-int axis_type_check(const char *s) throw (ParserError) {
+int axis_type_check(const char *s) {
 	int type = axis_type(s);
 	if (type == GLE_AXIS_ALL) {
 		ostringstream err;
Index: gle-graphics-4.3.3/src/gle/axis.h
===================================================================
--- gle-graphics-4.3.3.orig/src/gle/axis.h
+++ gle-graphics-4.3.3/src/gle/axis.h
@@ -62,7 +62,7 @@ bool axis_is_max(int axis);
 bool axis_horizontal(int axis);
 int axis_get_orth(int axis, int which);
 int axis_type(const char *s);
-int axis_type_check(const char *s) throw (ParserError);
+int axis_type_check(const char *s);
 const char* axis_type_name(int type);
 bool axis_is_pos(double pos, int* cnt, double del, vector<double>& vec);
 bool axis_is_pos_perc(double pos, int* cnt, double perc, vector<double>& vec);
Index: gle-graphics-4.3.3/src/gle/graph.h
===================================================================
--- gle-graphics-4.3.3.orig/src/gle/graph.h
+++ gle-graphics-4.3.3/src/gle/graph.h
@@ -290,24 +290,24 @@ void iffree(void *p, const char *s);
 void setrange(double x, double y, int m);
 void gdraw_key(KeyInfo* info);
 void copy_default(int d);
-void do_dataset(int d, GLEGraphBlockInstance* graphBlock) throw(ParserError);
+void do_dataset(int d, GLEGraphBlockInstance* graphBlock);
 void do_each_dataset_settings();
 void fill_vec(double x1, double y1, double x2, double y2, vector<double>* vec);
 void do_smooth(void);
-void window_set(bool showError) throw(ParserError);
+void window_set(bool showError);
 void reset_axis_ranges();
 bool should_autorange_based_on_lets();
 void deleteLet(GLELet* let);
-GLELet* parseLet(GLESourceLine& sline) throw(ParserError);
-GLELet* parseLet(const string& letFct, int codeLine) throw(ParserError);
-void doLet(GLELet* let, bool nofirst) throw(ParserError);
+GLELet* parseLet(GLESourceLine& sline);
+GLELet* parseLet(const string& letFct, int codeLine);
+void doLet(GLELet* let, bool nofirst);
 void request(void);
 /*int draw_axis(void *axis);*/
 void bar_reset();
 void doskip(char *s,int *ct);
 void store_window_bounds_to_vars();
 void do_dataset_key(int d);
-void do_bigfile_compatibility() throw(ParserError);
+void do_bigfile_compatibility();
 void ensureDataSetCreated(int d);
 
 #define kw(ss) if (str_i_equals(tk[ct],ss))
@@ -347,7 +347,7 @@ public:
 class GLEDataSet;
 
 void draw_vec(double x1, double y1, double x2, double y2, GLEDataSet* ds);
-void draw_mark(double x1, double y1, int i, double sz, double dval, GLEDataSet* ds) throw (ParserError);
+void draw_mark(double x1, double y1, int i, double sz, double dval, GLEDataSet* ds);
 
 /* range of dataset dimension is initialized in window_set */
 /* can be different from axis range because "xmin" / "xmax" / "ymin" / "ymax" settings of dn */
@@ -468,7 +468,7 @@ public:
 	void clip(double *x, double *y);
 	bool contains(double x, double y);
 	bool contains(const GLEPoint& p);
-	void checkRanges() throw(ParserError);
+	void checkRanges();
 	void copyRangeIfRequired(int dimension);
 	vector<int> getMissingValues();
 	void validateDimensions();
@@ -540,16 +540,16 @@ GRAPHDEF GLEDataSet *dp[MAX_NB_DATA];
 GRAPHDEF bar_struct *br[MAX_NB_BAR];
 void vinit_axis(int i);
 void vinit_title_axis();
-void draw_bar(double x, double yf, double yt, double wd, bar_struct* barset, int di, GLEDataSet* toDataSet) throw(ParserError);
+void draw_bar(double x, double yf, double yt, double wd, bar_struct* barset, int di, GLEDataSet* toDataSet);
 void get_dataset_ranges();
 void set_bar_axis_places();
-int get_dataset_identifier(const std::string& ds, bool def = false) throw(ParserError);
-int get_dataset_identifier(const string& ds, GLEParser* parser, bool def) throw(ParserError);
+int get_dataset_identifier(const std::string& ds, bool def = false);
+int get_dataset_identifier(const string& ds, GLEParser* parser, bool def);
 
-double graph_bar_pos(double xpos, int bar, int set) throw(ParserError);
-void begin_graph(GLEGraphBlockBase* graphBlockBase, GLEGraphBlockInstance* graphBlock) throw (ParserError);
+double graph_bar_pos(double xpos, int bar, int set);
+void begin_graph(GLEGraphBlockBase* graphBlockBase, GLEGraphBlockInstance* graphBlock);
 bool execute_graph(GLESourceLine& sline, bool isCommandCheck, GLEGraphBlockInstance* graphBlock);
-void begin_key(int *pln, int *pcode, int *cp) throw (ParserError);
+void begin_key(int *pln, int *pcode, int *cp);
 void begin_tab(int *pln, int *pcode, int *cp);
 void begin_text(int *pln, int *pcode, int *cp, double w, int just);
 void draw_key(int nkd, struct offset_struct* koffset, char *kpos,double khei, int knobox);
Index: gle-graphics-4.3.3/src/gle/begin.cpp
===================================================================
--- gle-graphics-4.3.3.orig/src/gle/begin.cpp
+++ gle-graphics-4.3.3/src/gle/begin.cpp
@@ -51,7 +51,7 @@
 void replace_exp(char* exp);
 void replace_exp(string& exp);
 
-double token_next_double(int i) throw(ParserError) {
+double token_next_double(int i) {
 	char* tok = tk[i];
 	if (!is_float(tok)) {
 		stringstream err;
Index: gle-graphics-4.3.3/src/gle/core.cpp
===================================================================
--- gle-graphics-4.3.3.orig/src/gle/core.cpp
+++ gle-graphics-4.3.3/src/gle/core.cpp
@@ -506,7 +506,7 @@ void g_set_pagesize(int type) {
 	}
 }
 
-void g_set_pagesize(const string& papersize) throw (ParserError) {
+void g_set_pagesize(const string& papersize) {
 	SpaceStringTokenizer tokens(papersize.c_str());
 	const string& token = tokens.next_token();
 	int type = g_papersize_type(token);
@@ -520,7 +520,7 @@ void g_set_pagesize(const string& papers
 	}
 }
 
-void g_set_margins(const string& margins) throw (ParserError) {
+void g_set_margins(const string& margins) {
 	SpaceStringTokenizer tokens(margins.c_str());
 	g.topmargin = tokens.next_double();
 	g.bottommargin = tokens.next_double();
@@ -1881,7 +1881,7 @@ void g_marker(int i, double sz) {
 	g_marker2(i,sz,1.0);
 }
 
-void g_marker2(int i, double sz, double dval) throw(ParserError) {
+void g_marker2(int i, double sz, double dval) {
 	static double cx,cy,h,scale;
 	static double x1,y1,x2,y2;
 	if (i<0) {
@@ -2044,7 +2044,7 @@ bool g_parse_ps_boundingbox(const string
 	return false;
 }
 
-void g_postscript(char *fname, double wx, double wy) throw(ParserError) {
+void g_postscript(char *fname, double wx, double wy) {
 	/*
 	fname ... the filename
 	wx .... the users desired width  in GLE units
@@ -2157,7 +2157,7 @@ int g_bitmap_string_to_type(const char*
 	}
 }
 
-void g_update_bitmap_type(const string& fname, int* type) throw(ParserError) {
+void g_update_bitmap_type(const string& fname, int* type) {
 	if (*type == 0) {
 		string ext;
 		GetExtension(fname, ext);
@@ -2263,7 +2263,7 @@ GLEBitmap* g_bitmap_type_to_object(int t
 	}
 }
 
-void g_bitmap(string& fname, double wx, double wy, int type) throw(ParserError) {
+void g_bitmap(string& fname, double wx, double wy, int type) {
 	fname = GLEExpandEnvironmentVariables(fname);
 	validate_file_name(fname, true);
 	g_update_bitmap_type(fname, &type);
@@ -2288,7 +2288,7 @@ void g_bitmap(string& fname, double wx,
 	delete bitmap;
 }
 
-void g_bitmap(GLEBitmap* bitmap, double wx, double wy, int type) throw(ParserError) {
+void g_bitmap(GLEBitmap* bitmap, double wx, double wy, int type) {
 	/* Read header */
 	int result = bitmap->readHeader();
 	if (result != GLE_IMAGE_ERROR_NONE) {
@@ -2327,7 +2327,7 @@ void g_bitmap(GLEBitmap* bitmap, double
 	g_update_bounds(cx+wx, cy+wy);
 }
 
-void g_bitmap_info(string& fname, int xvar, int yvar, int type)  throw(ParserError) {
+void g_bitmap_info(string& fname, int xvar, int yvar, int type) {
 	fname = GLEExpandEnvironmentVariables(fname);
 	validate_file_name(fname, true);
 	g_update_bitmap_type(fname, &type);
@@ -2364,7 +2364,7 @@ void g_bitmap_info(string& fname, int xv
 
 void g_arrowpoints(double cx, double cy, double dx, double dy, GLEArrowPoints* pts);
 
-void g_arrowline(double x2, double y2, int flag, int can_fillpath) throw(ParserError) {
+void g_arrowline(double x2, double y2, int flag, int can_fillpath) {
 	double x1,y1;
 	GLECore* core = g_get_core();
 	if (core->isComputingLength()) {
@@ -2571,7 +2571,7 @@ void g_set_arrow_style(int shape) {
 	g.arrowstyle = shape;
 }
 
-void g_set_arrow_style(const char* shape) throw(ParserError) {
+void g_set_arrow_style(const char* shape) {
 	if (str_i_equals(shape, "SIMPLE")) {
 		g_set_arrow_style(GLE_ARRSTY_SIMPLE);
 	} else if (str_i_equals(shape, "FILLED")) {
@@ -2594,7 +2594,7 @@ void g_set_arrow_tip(int tip) {
 	g.arrowtip = tip;
 }
 
-void g_set_arrow_tip(const char* tip) throw (ParserError) {
+void g_set_arrow_tip(const char* tip) {
 	if (str_i_equals(tip, "SHARP")) {
 		g_set_arrow_tip(GLE_ARRTIP_SHARP);
 	} else if (str_i_equals(tip, "ROUND")) {
@@ -2604,7 +2604,7 @@ void g_set_arrow_tip(const char* tip) th
 	}
 }
 
-void g_arrow(double dx, double dy, int can_fillpath) throw(ParserError) {
+void g_arrow(double dx, double dy, int can_fillpath) {
 	int old_join;
 	char old_lstyle[15];
 	g_get_line_style(old_lstyle);
@@ -2756,7 +2756,7 @@ int g_get_compatibility() {
 	return g_compatibility;
 }
 
-int g_parse_compatibility(const string& compat) throw (ParserError) {
+int g_parse_compatibility(const string& compat) {
 	TokenizerLanguage lang;
 	lang.setSpaceTokens(" ");
 	lang.setSingleCharTokens(".");
@@ -2787,7 +2787,7 @@ int g_parse_compatibility(const string&
 	return value;
 }
 
-int g_set_compatibility(const string& compat) throw (ParserError) {
+int g_set_compatibility(const string& compat) {
 	int value = g_parse_compatibility(compat);
 	g_set_compatibility(value);
 	return value;
Index: gle-graphics-4.3.3/src/gle/sub.h
===================================================================
--- gle-graphics-4.3.3.orig/src/gle/sub.h
+++ gle-graphics-4.3.3/src/gle/sub.h
@@ -218,11 +218,11 @@ public:
 	inline int size() { return m_Subs.size(); }
 };
 
-GLESub* sub_get(int idx) throw(ParserError);
+GLESub* sub_get(int idx);
 GLESub* sub_find(const string& s);
 void sub_param(GLESub* sub, const string& name);
 
-void call_sub_byname(const string& name, double* args, int nb, const char* err_inf) throw(ParserError);
-void call_sub_byid(int idx, double* args, int nb, const char* err_inf) throw(ParserError);
+void call_sub_byname(const string& name, double* args, int nb, const char* err_inf);
+void call_sub_byid(int idx, double* args, int nb, const char* err_inf);
 
 #endif
Index: gle-graphics-4.3.3/src/gle/pass.h
===================================================================
--- gle-graphics-4.3.3.orig/src/gle/pass.h
+++ gle-graphics-4.3.3/src/gle/pass.h
@@ -151,58 +151,58 @@ public:
 	~GLEParser();
 	GLEBlocks* getBlockTypes();
 	void initTokenizer();
-	double evalTokenToDouble() throw(ParserError);
-	void evalTokenToString(string* str) throw(ParserError);
-	void evalTokenToFileName(string* str) throw(ParserError);
+	double evalTokenToDouble();
+	void evalTokenToString(string* str);
+	void evalTokenToFileName(string* str);
 	bool pass_block_specific(GLESourceLine& sourceLine, GLEPcode& pcode);
-	void passt(GLESourceLine &SLine, GLEPcode& pcode) throw(ParserError);
-	void polish_eol(GLEPcode& pcode, int *rtype) throw(ParserError);
-	void polish(GLEPcode& pcode, int *rtype) throw(ParserError);
-	void polish(const char* str, GLEPcode& pcode, int *rtype) throw(ParserError);
-	void polish_pos(const string& arg, int pos, GLEPcode& pcode, int* rtype) throw(ParserError);
-	void get_var(GLEPcode& pcode) throw (ParserError);
-	void get_xy(GLEPcode& pcode) throw(ParserError);
-	void get_exp(GLEPcode& pcode) throw(ParserError);
-	void get_exp_eol(GLEPcode& pcode) throw(ParserError);
-	void get_strexp(GLEPcode& pcode) throw(ParserError);
-	int get_anyexp(GLEPcode& pcode) throw(ParserError);
-	void pass_subroutine_call(GLESubCallInfo* info, int poscol) throw(ParserError);
-	void gen_subroutine_call_code(GLESubCallInfo* info, GLEPcode& pcode) throw(ParserError);
-	void gen_subroutine_call_polish_arg(GLESubCallInfo* info, int i, GLEPcode& pcode) throw(ParserError);
+	void passt(GLESourceLine &SLine, GLEPcode& pcode);
+	void polish_eol(GLEPcode& pcode, int *rtype);
+	void polish(GLEPcode& pcode, int *rtype);
+	void polish(const char* str, GLEPcode& pcode, int *rtype);
+	void polish_pos(const string& arg, int pos, GLEPcode& pcode, int* rtype);
+	void get_var(GLEPcode& pcode);
+	void get_xy(GLEPcode& pcode);
+	void get_exp(GLEPcode& pcode);
+	void get_exp_eol(GLEPcode& pcode);
+	void get_strexp(GLEPcode& pcode);
+	int get_anyexp(GLEPcode& pcode);
+	void pass_subroutine_call(GLESubCallInfo* info, int poscol);
+	void gen_subroutine_call_code(GLESubCallInfo* info, GLEPcode& pcode);
+	void gen_subroutine_call_polish_arg(GLESubCallInfo* info, int i, GLEPcode& pcode);
 	void evaluate_subroutine_arguments(GLESubCallInfo* info, GLEArrayImpl* arguments);
-	void get_subroutine_call(GLEPcode& pcode, string* name = NULL, int poscol = 0) throw(ParserError);
-	GLESub* get_subroutine_declaration(GLEPcode& pcode) throw(ParserError);
-	void get_subroutine_default_param(GLESub* sub) throw(ParserError);
-	void get_if(GLEPcode& pcode) throw(ParserError);
-	void parse_if(int srclin, GLEPcode& pcode) throw(ParserError);
+	void get_subroutine_call(GLEPcode& pcode, string* name = NULL, int poscol = 0);
+	GLESub* get_subroutine_declaration(GLEPcode& pcode);
+	void get_subroutine_default_param(GLESub* sub);
+	void get_if(GLEPcode& pcode);
+	void parse_if(int srclin, GLEPcode& pcode);
 	GLESourceBlock* add_else_block(int srclin, GLEPcode& pcode, bool dangling);
 	GLESourceBlock* add_else_block_update(int srclin, GLEPcode& pcode, int start_offs, bool dangling);
 	void do_endif(int srclin, GLEPcode& pcode);
 	void do_endsub(int srclin, GLEPcode& pcode);
-	int get_optional(OPKEY lkey, GLEPcode& pcode) throw(ParserError);
-	int get_first(OPKEY lkey) throw(ParserError);
-   int get_first(const string& token, OPKEY lkey) throw(ParserError);
-	void get_token(const char* token) throw(ParserError);
-	bool try_get_token(const char* token) throw(ParserError);
-	void get_fill(GLEPcode& pcode) throw (ParserError);
-	void get_marker(GLEPcode& pcode) throw (ParserError);
-	void get_var_add(int *var, int *vtype) throw (ParserError);
-	int pass_marker(const string& marker) throw (ParserError);
-	void define_marker_1(GLEPcode& pcode) throw (ParserError);
-	void define_marker_2(GLEPcode& pcode) throw (ParserError);
-	void get_font(GLEPcode& pcode) throw (ParserError);
-	void get_justify(GLEPcode& pcode) throw (ParserError);
-	void get_color(GLEPcode& pcode) throw (ParserError);
-	void get_join(GLEPcode& pcode) throw (ParserError);
-	void get_cap(GLEPcode& pcode) throw (ParserError);
-	void get_papersize(GLEPcode& pcode) throw (ParserError);
-	void do_text_mode(GLESourceLine &SLine, Tokenizer* tokens, GLEPcode& pcode) throw (ParserError);
-	void checkmode() throw(ParserError);
+	int get_optional(OPKEY lkey, GLEPcode& pcode);
+	int get_first(OPKEY lkey);
+   int get_first(const string& token, OPKEY lkey);
+	void get_token(const char* token);
+	bool try_get_token(const char* token);
+	void get_fill(GLEPcode& pcode);
+	void get_marker(GLEPcode& pcode);
+	void get_var_add(int *var, int *vtype);
+	int pass_marker(const string& marker);
+	void define_marker_1(GLEPcode& pcode);
+	void define_marker_2(GLEPcode& pcode);
+	void get_font(GLEPcode& pcode);
+	void get_justify(GLEPcode& pcode);
+	void get_color(GLEPcode& pcode);
+	void get_join(GLEPcode& pcode);
+	void get_cap(GLEPcode& pcode);
+	void get_papersize(GLEPcode& pcode);
+	void do_text_mode(GLESourceLine &SLine, Tokenizer* tokens, GLEPcode& pcode);
+	void checkmode();
 	void get_block_type(int type, string& result);
 	ParserError create_option_error(OPKEY lkey, int count, const string& token);
-	int get_one_option(op_key* lkey, GLEPcode& pcode, int plen) throw(ParserError);
-	void duplicate_error(GLEPcode& pcode, int pos) throw(ParserError);
-	void checkValidName(const string& name, const char* type, int pos) throw(ParserError);
+	int get_one_option(op_key* lkey, GLEPcode& pcode, int plen);
+	void duplicate_error(GLEPcode& pcode, int pos);
+	void checkValidName(const string& name, const char* type, int pos);
 	void setAllowSpace(bool allow);
 	bool not_at_end_command();
 	bool test_not_at_end_command();
@@ -211,8 +211,8 @@ public:
 	GLESourceBlock* last_block();
 	GLESourceBlock* find_block(int type);
 	void remove_last_block();
-	void check_loop_variable(int var) throw (ParserError);
-	GLESourceBlock* check_block_type(int pos, int t0, int t1, int t2) throw (ParserError);
+	void check_loop_variable(int var);
+	GLESourceBlock* check_block_type(int pos, int t0, int t1, int t2);
 	GLESubMap* getSubroutines();
 	inline Tokenizer* getTokens() { return &m_tokens; }
 	inline GLEPolish* getPolish() { return m_polish; }
@@ -238,7 +238,7 @@ int gt_firstval(OPKEY lkey, const char *
 bool gt_firstval_err(OPKEY lkey, const char *s, int* result);
 int gt_index(OPKEY lkey,char *s);
 int pass_justify(const std::string& s);
-int pass_marker(char *s) throw(ParserError);
+int pass_marker(char *s);
 void mark_clear(void);
 void pass_checkmode(void);
 void spop(int v);
Index: gle-graphics-4.3.3/src/gle/drawit.cpp
===================================================================
--- gle-graphics-4.3.3.orig/src/gle/drawit.cpp
+++ gle-graphics-4.3.3/src/gle/drawit.cpp
@@ -81,7 +81,7 @@ GLERun* getGLERunInstance() {
 	return g_GLERun;
 }
 
-void text_load_include(GLEParser* parser, const string& fname, GLESourceLine* code, GLESourceFile* file) throw(ParserError);
+void text_load_include(GLEParser* parser, const string& fname, GLESourceLine* code, GLESourceFile* file);
 
 void gle_set_constants() {
 	GLEMemoryCell value;
@@ -185,7 +185,7 @@ void output_error_cerr(ParserError& err)
 	}
 }
 
-void validate_open_input_stream(ifstream& input, const string& fname) throw(ParserError) {
+void validate_open_input_stream(ifstream& input, const string& fname) {
 	string expanded(GLEExpandEnvironmentVariables(fname));
 	validate_file_name(expanded, true);
 	input.open(expanded.c_str());
@@ -194,7 +194,7 @@ void validate_open_input_stream(ifstream
 	}
 }
 
-FILE* validate_fopen(const string& fname, const char *mode, bool isread) throw(ParserError) {
+FILE* validate_fopen(const string& fname, const char *mode, bool isread) {
 	string expanded(GLEExpandEnvironmentVariables(fname));
 	validate_file_name(expanded, isread);
 	FILE* result = fopen(expanded.c_str(), mode);
@@ -205,7 +205,7 @@ FILE* validate_fopen(const string& fname
 	return result;
 }
 
-void validate_file_name(const string& fname, bool isread) throw(ParserError) {
+void validate_file_name(const string& fname, bool isread) {
 	GLEInterface* iface = GLEGetInterfacePointer();
 	if (iface->hasFileInfos()) {
 		GLEFileLocation finfo;
@@ -251,7 +251,7 @@ void validate_file_name(const string& fn
 	}
 }
 
-void DrawIt(GLEScript* script, GLEFileLocation* outfile, CmdLineObj* cmdline, bool silent) throw (ParserError) {
+void DrawIt(GLEScript* script, GLEFileLocation* outfile, CmdLineObj* cmdline, bool silent) {
 	GLEGlobalSource* glecode = script->getSource();
 	GLEInterface* iface = script->getGLEInterface();
 	script->cleanUp();
@@ -394,7 +394,7 @@ void DrawIt(GLEScript* script, GLEFileLo
 	g_set_console_output(has_console);
 }
 
-void text_load_include(GLEParser* parser, const string& fname, GLESourceLine* code, GLESourceFile* file) throw(ParserError) {
+void text_load_include(GLEParser* parser, const string& fname, GLESourceLine* code, GLESourceFile* file) {
 	GLEFileLocation* loc = file->getLocation();
 	loc->setName(fname);
 	const string* dirname = NULL;
Index: gle-graphics-4.3.3/src/gle/drawit.h
===================================================================
--- gle-graphics-4.3.3.orig/src/gle/drawit.h
+++ gle-graphics-4.3.3/src/gle/drawit.h
@@ -36,5 +36,5 @@
  *                                                                      *
  ************************************************************************/
 
-void CompileGLE(const string& output_file, GLEGlobalSource &glecode, CmdLineObj* cmdline, bool silent) throw(ParserError);
-void DrawIt(GLEScript* script, GLEFileLocation* outfile, CmdLineObj* cmdline, bool silent = false) throw (ParserError);
+void CompileGLE(const string& output_file, GLEGlobalSource &glecode, CmdLineObj* cmdline, bool silent);
+void DrawIt(GLEScript* script, GLEFileLocation* outfile, CmdLineObj* cmdline, bool silent = false);
Index: gle-graphics-4.3.3/src/gle/eval.cpp
===================================================================
--- gle-graphics-4.3.3.orig/src/gle/eval.cpp
+++ gle-graphics-4.3.3/src/gle/eval.cpp
@@ -126,7 +126,7 @@ unsigned char float_to_color_comp_255(do
 	return (unsigned char)color;
 }
 
-void eval_get_extra_arg_test(int i, const char* type) throw(ParserError) {
+void eval_get_extra_arg_test(int i, const char* type) {
 	int max_arg = g_CmdLine.getNbExtraArgs();
 	if (max_arg == 0) {
 		stringstream s;
@@ -140,7 +140,7 @@ void eval_get_extra_arg_test(int i, cons
 	}
 }
 
-double eval_get_extra_arg_f(int i) throw(ParserError) {
+double eval_get_extra_arg_f(int i) {
 	eval_get_extra_arg_test(i, "");
 	const string& arg = g_CmdLine.getExtraArg(i-1);
 	if (!is_float(arg)) {
@@ -151,7 +151,7 @@ double eval_get_extra_arg_f(int i) throw
 	return atof(arg.c_str());
 }
 
-const char* eval_get_extra_arg_s(int i) throw(ParserError) {
+const char* eval_get_extra_arg_s(int i) {
 	eval_get_extra_arg_test(i, "$");
 	return g_CmdLine.getExtraArg(i-1).c_str();
 }
@@ -369,7 +369,7 @@ void eval_binary_operator(GLEArrayImpl*
 	stk->decrementSize(1);
 }
 
-void eval_pcode_loop(GLEArrayImpl* stk, GLEPcodeList* pclist, int *pcode, int plen) throw(ParserError) {
+void eval_pcode_loop(GLEArrayImpl* stk, GLEPcodeList* pclist, int *pcode, int plen) {
 	if (plen > 1000) {
 		gprint("Expression is suspiciously long %d \n",plen);
 	}
@@ -992,7 +992,7 @@ void eval_pcode_loop(GLEArrayImpl* stk,
 	}
 }
 
-GLESub* eval_subroutine_call(GLEArrayImpl* stk, GLEPcodeList* pclist, int *pcode, int *cp) throw(ParserError) {
+GLESub* eval_subroutine_call(GLEArrayImpl* stk, GLEPcodeList* pclist, int *pcode, int *cp) {
 	if (*(pcode+(*cp)++) != 1) {
 		(*cp)--;
 		gprint("PCODE, Expecting expression, v=%ld cp=%d \n", *(pcode + (*cp)), *cp);
@@ -1009,7 +1009,7 @@ GLESub* eval_subroutine_call(GLEArrayImp
 	return result;
 }
 
-void eval_do_object_block_call(GLEArrayImpl* stk, GLESub* sub, GLEObjectDO* obj) throw(ParserError) {
+void eval_do_object_block_call(GLEArrayImpl* stk, GLESub* sub, GLEObjectDO* obj) {
 	GLEObjectDOConstructor* cons = obj->getConstructor();
 	obj->makePropertyStore();
 	GLEArrayImpl* arr = obj->getProperties()->getArray();
@@ -1045,7 +1045,7 @@ void evalDoConstant(GLEArrayImpl* stk, i
 	stk->setDouble(stk->last(), both.d);
 }
 
-GLEMemoryCell* evalGeneric(GLEArrayImpl* stk, GLEPcodeList* pclist, int *pcode, int *cp) throw(ParserError) {
+GLEMemoryCell* evalGeneric(GLEArrayImpl* stk, GLEPcodeList* pclist, int *pcode, int *cp) {
 	int fixed_cp;
 	if (cp == 0) {
 		fixed_cp = 0;
@@ -1069,30 +1069,30 @@ GLEMemoryCell* evalGeneric(GLEArrayImpl*
 	return stk->get(stk->last() + 1);
 }
 
-double evalDouble(GLEArrayImpl* stk, GLEPcodeList* pclist, int *pcode, int *cp) throw(ParserError) {
+double evalDouble(GLEArrayImpl* stk, GLEPcodeList* pclist, int *pcode, int *cp) {
 	GLEMemoryCell* mc = evalGeneric(stk, pclist, pcode, cp);
 	gle_memory_cell_check(mc, GLEObjectTypeDouble);
 	return mc->Entry.DoubleVal;
 }
 
-bool evalBool(GLEArrayImpl* stk, GLEPcodeList* pclist, int *pcode, int *cp) throw(ParserError) {
+bool evalBool(GLEArrayImpl* stk, GLEPcodeList* pclist, int *pcode, int *cp) {
 	GLEMemoryCell* mc = evalGeneric(stk, pclist, pcode, cp);
 	gle_memory_cell_check(mc, GLEObjectTypeBool);
 	return mc->Entry.BoolVal;
 }
 
-GLEString* evalStringPtr(GLEArrayImpl* stk, GLEPcodeList* pclist, int *pcode, int *cp) throw(ParserError) {
+GLEString* evalStringPtr(GLEArrayImpl* stk, GLEPcodeList* pclist, int *pcode, int *cp) {
 	GLEMemoryCell* mc = evalGeneric(stk, pclist, pcode, cp);
 	gle_memory_cell_check(mc, GLEObjectTypeString);
 	return (GLEString*)mc->Entry.ObjectVal;
 }
 
-GLERC<GLEColor> evalColor(GLEArrayImpl* stk, GLEPcodeList* pclist, int *pcode, int *cp) throw(ParserError) {
+GLERC<GLEColor> evalColor(GLEArrayImpl* stk, GLEPcodeList* pclist, int *pcode, int *cp) {
 	GLEMemoryCell* mc = evalGeneric(stk, pclist, pcode, cp);
 	return memory_cell_to_color(get_global_polish(), stk, mc, g_get_throws_error(), 0);
 }
 
-GLERC<GLEString> evalString(GLEArrayImpl* stk, GLEPcodeList* pclist, int *pcode, int *cp, bool allowOther) throw(ParserError) {
+GLERC<GLEString> evalString(GLEArrayImpl* stk, GLEPcodeList* pclist, int *pcode, int *cp, bool allowOther) {
 	GLERC<GLEString> result;
 	GLEMemoryCell* mc = evalGeneric(stk, pclist, pcode, cp);
 	int type = gle_memory_cell_type(mc);
Index: gle-graphics-4.3.3/src/gle/font.cpp
===================================================================
--- gle-graphics-4.3.3.orig/src/gle/font.cpp
+++ gle-graphics-4.3.3/src/gle/font.cpp
@@ -46,7 +46,7 @@
 
 int text_gprint(int *in,int ilen);
 int fftext_block(uchar *s,double width,int justify);
-void font_load(void) throw (ParserError);
+void font_load(void);
 void font_init(void);
 
 int do_prim(uchar **in,int *out,int *lout);  /*  \frac{text}{text} */
@@ -140,7 +140,7 @@ void font_get_chardata(struct char_data
 	}
 }
 
-void font_load(void) throw(ParserError) {
+void font_load(void) {
 	/* load font.dat */
 	char inbuff[200];
 	string fname = fontdir("font.dat");
Index: gle-graphics-4.3.3/src/gle/graph.cpp
===================================================================
--- gle-graphics-4.3.3.orig/src/gle/graph.cpp
+++ gle-graphics-4.3.3/src/gle/graph.cpp
@@ -84,10 +84,10 @@ GLERC<GLEColor> g_graph_background;
 int freedataset(int i);
 void free_temp(void);
 void set_sizelength(void);
-void draw_graph(KeyInfo* keyinfo, GLEGraphBlockInstance* graphBlock) throw (ParserError);
+void draw_graph(KeyInfo* keyinfo, GLEGraphBlockInstance* graphBlock);
 void do_set_bar_color(const char* tk, bar_struct* bar, int type);
 void do_set_bar_style(const char* tk, bar_struct* bar);
-void do_axis_part_all(int xset) throw (ParserError);
+void do_axis_part_all(int xset);
 bool do_remaining_entries(int ct, bool isCommandCheck);
 void graph_freebars();
 double get_next_exp(TOKENS tk,int ntk,int *curtok);
@@ -422,7 +422,7 @@ bool GLEGraphBlockBase::checkLine(GLESou
 // axis is defined in terms of its base size, which is equal to g_fontsz.
 // A useful value for base is 0.25
 
-void begin_graph(GLEGraphBlockBase* graphBlockBase, GLEGraphBlockInstance* graphBlock) throw (ParserError) {
+void begin_graph(GLEGraphBlockBase* graphBlockBase, GLEGraphBlockInstance* graphBlock) {
 	g_colormap = NULL;
 	for (unsigned int i = 0; i < g_letCmds.size(); i++) {
 		deleteLet(g_letCmds[i]);
@@ -998,7 +998,7 @@ bool do_remaining_entries(int ct, bool i
 	return nb_found > 0;
 }
 
-void do_axis(int axis, bool craxis) throw (ParserError) {
+void do_axis(int axis, bool craxis) {
 	int ct = 2;
 	while (ct <= ntk)  {
 		kw("BASE") xx[axis].base = next_exp;
@@ -1098,7 +1098,7 @@ void do_axis(int axis, bool craxis) thro
 	}
 }
 
-void do_labels(int axis, bool showerr) throw (ParserError) {
+void do_labels(int axis, bool showerr) {
 	int ct = 2;
 	while (ct <= ntk)  {
 		if (*tk[ct]==' ') ct++;
@@ -1140,7 +1140,7 @@ void do_labels(int axis, bool showerr) t
 	}
 }
 
-void do_side(int axis, bool showerr) throw (ParserError) {
+void do_side(int axis, bool showerr) {
 	int ct = 2;
 	while (ct <= ntk)  {
 		if (*tk[ct]==' ') ct++;
@@ -1160,7 +1160,7 @@ void do_side(int axis, bool showerr) thr
 	}
 }
 
-void do_ticks(int axis, bool showerr) throw (ParserError) {
+void do_ticks(int axis, bool showerr) {
 	int ct = 2;
 	while (ct <= ntk)  {
 		if (*tk[ct]==' ') ct++;
@@ -1189,7 +1189,7 @@ void do_ticks(int axis, bool showerr) th
 	}
 }
 
-void do_subticks(int axis, bool showerr) throw (ParserError) {
+void do_subticks(int axis, bool showerr) {
 	int ct = 2;
 	while (ct <= ntk)  {
 		if (*tk[ct]==' ') ct++;
@@ -1216,7 +1216,7 @@ void do_subticks(int axis, bool showerr)
 	}
 }
 
-void do_axis_part(int axis, bool craxis, int xset) throw (ParserError) {
+void do_axis_part(int axis, bool craxis, int xset) {
 	// craxis = command is for current axis
 	// showerr = passing options for axis command to labels/side/ticks commands
 	switch (xset) {
@@ -1241,7 +1241,7 @@ void do_axis_part(int axis, bool craxis,
 	}
 }
 
-void do_axis_part_all(int xset) throw (ParserError) {
+void do_axis_part_all(int xset) {
 	int axis = axis_type(tk[1]);
 	if (axis == GLE_AXIS_ALL) {
 		do_axis_part(GLE_AXIS_X, false, xset);
@@ -1550,7 +1550,7 @@ void key_update_bounds(double ox, double
 	}
 }
 
-void draw_graph(KeyInfo* keyinfo, GLEGraphBlockInstance* graphBlock) throw (ParserError) {
+void draw_graph(KeyInfo* keyinfo, GLEGraphBlockInstance* graphBlock) {
 	GLERectangle box;
 	double ox,oy;
 
@@ -1776,7 +1776,7 @@ bool is_dataset_identifier(const char* d
 	return ptr != NULL && *ptr == 0 && result >= 0;
 }
 
-int get_dataset_identifier(const std::string& ds, bool def) throw(ParserError) {
+int get_dataset_identifier(const std::string& ds, bool def) {
 	int len = ds.size();
 	if (len <= 1 || toupper(ds[0]) != 'D') {
 		g_throw_parser_error("illegal data set identifier '", ds.c_str(), "'");
@@ -1814,7 +1814,7 @@ int get_dataset_identifier(const std::st
 	}
 }
 
-int get_dataset_identifier(const string& ds, GLEParser* parser, bool def) throw(ParserError) {
+int get_dataset_identifier(const string& ds, GLEParser* parser, bool def) {
 	Tokenizer* tokens = parser->getTokens();
 	if (str_i_equals(ds, "d")) {
 		tokens->ensure_next_token("[");
@@ -1852,7 +1852,7 @@ int get_dataset_identifier(const string&
 	}
 }
 
-int get_column_number(GLEParser* parser) throw(ParserError) {
+int get_column_number(GLEParser* parser) {
 	Tokenizer* tokens = parser->getTokens();
 	const string& token = tokens->next_token();
 	if (str_i_equals(token, "c")) {
Index: gle-graphics-4.3.3/src/gle/graph2.cpp
===================================================================
--- gle-graphics-4.3.3.orig/src/gle/graph2.cpp
+++ gle-graphics-4.3.3/src/gle/graph2.cpp
@@ -370,7 +370,7 @@ void GLEGraphPartBars::drawBar(int b) {
 	}
 }
 
-double graph_bar_pos(double xpos, int bar, int set) throw(ParserError) {
+double graph_bar_pos(double xpos, int bar, int set) {
 	if (set < 1 || set > g_nbar) {
 		g_throw_parser_error("illegal bar set: ", set);
 	}
@@ -392,7 +392,7 @@ double graph_bar_pos(double xpos, int ba
 	}
 }
 
-void draw_bar(double x, double yf, double yt, double wd, bar_struct* barset, int di, GLEDataSet* toDataSet) throw(ParserError) {
+void draw_bar(double x, double yf, double yt, double wd, bar_struct* barset, int di, GLEDataSet* toDataSet) {
 	/* draw a bar, wd wide, centere at x , from yf, to yt */
 	x = x + wd/2;
 	double x1 = x - wd/2;
@@ -534,7 +534,7 @@ bool should_autorange_based_on_lets() {
 	return false;
 }
 
-void window_set(bool showError) throw(ParserError) {
+void window_set(bool showError) {
 	// Called twice:
 	// - Before processing "let" commands - then "showError = false"
 	// - After processing "let" commands - then "showError = true"
@@ -1341,7 +1341,7 @@ void GLEGraphPartMarkers::drawMarkers(in
 	}
 }
 
-void draw_mark(double x, double y, int mrk, double msize, double dval, GLEDataSet* ds) throw (ParserError) {
+void draw_mark(double x, double y, int mrk, double msize, double dval, GLEDataSet* ds) {
 	if (ds->contains(x, y)) {
 		g_move(fnXY(x, y, ds));
 		g_marker2(mrk, msize, dval);
@@ -1534,7 +1534,7 @@ public:
 	GLELetDataSet();
 	~GLELetDataSet();
 	void initializeFrom(int dn, int var);
-	void complainNoFunction() throw (ParserError);
+	void complainNoFunction();
 	bool interpolateTo(double x, int lr);
 	inline int getNbValues() { return m_Vals.size(); }
 	inline double getXValue(int i) { return m_Vals[i].x; }
@@ -1608,7 +1608,7 @@ void GLELetDataSet::initializeFrom(int d
 	}
 }
 
-void GLELetDataSet::complainNoFunction() throw (ParserError) {
+void GLELetDataSet::complainNoFunction() {
 	for (unsigned int i = 1; i < m_Vals.size(); i++) {
 		if (m_Vals[i].x == m_Vals[i-1].x) {
 			ostringstream errs;
@@ -2160,12 +2160,12 @@ protected:
 public:
 	GLEFitLS();
 	virtual ~GLEFitLS();
-	void polish(const string& str) throw(ParserError);
+	void polish(const string& str);
 	void setXY(vector<double>* x, vector<double>* y);
 	void fit();
 	void testFit();
 	void setVarsVals(double* vals);
-	void toFunctionStr(const string& format, string* str) throw(ParserError);
+	void toFunctionStr(const string& format, string* str);
 	virtual double fitMSE(double* vals);
 	inline GLEFunctionParserPcode* getFunction() { return m_Function.get(); }
 	inline double getRSquare() { return m_RSquare; }
@@ -2181,7 +2181,7 @@ GLEFitLS::GLEFitLS() {
 GLEFitLS::~GLEFitLS() {
 }
 
-void GLEFitLS::polish(const string& str) throw(ParserError) {
+void GLEFitLS::polish(const string& str) {
 	m_FunctionStr = str;
 	m_Function->polish(str.c_str(), &m_VarMap);
 	/* Iterate over variables in expression */
@@ -2264,7 +2264,7 @@ double GLEFitLS::fitMSE(double* vals) {
 	return tot / m_X->size();
 }
 
-void GLEFitLS::toFunctionStr(const string& format, string* str) throw(ParserError) {
+void GLEFitLS::toFunctionStr(const string& format, string* str) {
 	*str = "";
 	string fmt_str = format;
 	if (fmt_str == "") fmt_str = "fix 3";
@@ -2328,12 +2328,12 @@ public:
 	~GLELet();
 	void initVars();
 	void initStep();
-	void doLet() throw(ParserError);
-	void parseFitFunction(const string& fct, GLEParser* parser) throw(ParserError);
-	void parseHistogram(GLEParser* parser) throw(ParserError);
-	void doFitFunction() throw(ParserError);
-	void doHistogram() throw(ParserError);
-	void complainAboutNoFunctions(GLEVectorAutoDelete<GLELetDataSet>& datasets) throw(ParserError);
+	void doLet();
+	void parseFitFunction(const string& fct, GLEParser* parser);
+	void parseHistogram(GLEParser* parser);
+	void doFitFunction();
+	void doHistogram();
+	void complainAboutNoFunctions(GLEVectorAutoDelete<GLELetDataSet>& datasets);
 	bool checkIdenticalRanges(GLEVectorAutoDelete<GLELetDataSet>& datasets);
 	void transformIdenticalRangeDatasets(GLEVectorAutoDelete<GLELetDataSet>& datasets, DataFill* fill);
 	void combineFunctions(GLEVectorAutoDelete<GLELetDataSet>& datasets, DataFill* fill, double logstep);
@@ -2566,7 +2566,7 @@ void GLELet::combineFunctions(GLEVectorA
 	}
 }
 
-void GLELet::complainAboutNoFunctions(GLEVectorAutoDelete<GLELetDataSet>& datasets) throw(ParserError) {
+void GLELet::complainAboutNoFunctions(GLEVectorAutoDelete<GLELetDataSet>& datasets) {
 	for (unsigned int i = 0; i < datasets.size(); i++) {
 		if (!datasets[i]->isFunction()) {
 			datasets[i]->complainNoFunction();
@@ -2574,7 +2574,7 @@ void GLELet::complainAboutNoFunctions(GL
 	}
 }
 
-void GLELet::doLet() throw(ParserError) {
+void GLELet::doLet() {
 	if (m_LetTo <= m_LetFrom) {
 		stringstream ss;
 		ss << "illegal range for let expression: ";
@@ -2687,7 +2687,7 @@ void GLELet::doLet() throw(ParserError)
 	vars->setNameMode(nameMode::NAME);
 }
 
-void GLELet::parseFitFunction(const string& fct, GLEParser* parser) throw(ParserError) {
+void GLELet::parseFitFunction(const string& fct, GLEParser* parser) {
 	Tokenizer* tokens = parser->getTokens();
 	string& token = tokens->next_token();
 	m_FitDS = get_dataset_identifier(token, parser, true);
@@ -2757,7 +2757,7 @@ void GLELet::parseFitFunction(const stri
 	}
 }
 
-void GLELet::doFitFunction() throw(ParserError) {
+void GLELet::doFitFunction() {
 	bool linfit = false, logefit = false, log10fit = false, powxfit = false, genfit = false;
 	// doing fitting routines
 	if (str_i_equals(m_fitType, "LINFIT"))   linfit = true;
@@ -2921,7 +2921,7 @@ void GLELet::doFitFunction() throw(Parse
 	delete let;
 }
 
-void GLELet::parseHistogram(GLEParser* parser) throw(ParserError) {
+void GLELet::parseHistogram(GLEParser* parser) {
 	Tokenizer* tokens = parser->getTokens();
 	string& token = tokens->next_token();
 	m_nrBins = -1;
@@ -2947,7 +2947,7 @@ void GLELet::parseHistogram(GLEParser* p
 	}
 }
 
-void GLELet::doHistogram() throw(ParserError) {
+void GLELet::doHistogram() {
 	int bins = m_nrBins;
 	GLEDataPairs histData(getDataset(m_HistDS));
 	if (!hasFrom() || !hasTo()) {
@@ -3040,7 +3040,7 @@ void deleteLet(GLELet* let) {
 //  no option after linfit results in line being drawn over the whole graph
 // DATA results in the line being drawn from the minimum to the maximum of the data series
 
-GLELet* parseLet(GLEParser* parser, int codeLine) throw(ParserError) {
+GLELet* parseLet(GLEParser* parser, int codeLine) {
 	GLELet* let = new GLELet();
 	let->setCodeLine(codeLine);
 	Tokenizer* tokens = parser->getTokens();
@@ -3133,19 +3133,19 @@ GLELet* parseLet(GLEParser* parser, int
 	return let;
 }
 
-GLELet* parseLet(GLESourceLine& sline) throw(ParserError) {
+GLELet* parseLet(GLESourceLine& sline) {
 	GLEParser* parser = get_global_parser();
 	parser->setString(sline.getCodeCStr());
 	return parseLet(parser, sline.getGlobalLineNo());
 }
 
-GLELet* parseLet(const string& letFct, int codeLine) throw(ParserError) {
+GLELet* parseLet(const string& letFct, int codeLine) {
 	GLEParser* parser = get_global_parser();
 	parser->setString(letFct.c_str());
 	return parseLet(parser, codeLine);
 }
 
-void doLet(GLELet* let, bool nofirst) throw(ParserError) {
+void doLet(GLELet* let, bool nofirst) {
 	g_set_error_line(let->getCodeLine());
 	let->setNoFirst(nofirst);
 	let->setFineTune(nofirst);
@@ -3255,7 +3255,7 @@ void fixup_err(string& err) {
 	}
 }
 
-void do_dataset(int d, GLEGraphBlockInstance* graphBlock) throw(ParserError) {
+void do_dataset(int d, GLEGraphBlockInstance* graphBlock) {
 	int ct = 2;
 	while (ct <= ntk)	{
 		kw("LINE") {
@@ -3624,7 +3624,7 @@ void get_dataset_ranges() {
 	}
 }
 
-void do_bigfile_compatibility_dn(int dn) throw(ParserError) {
+void do_bigfile_compatibility_dn(int dn) {
 	string infile = dp[dn]->bigfile;
 	if (infile.length() >= 1 && infile[infile.length()-1] == '$') {
 		int idx, typ;
@@ -3736,7 +3736,7 @@ void do_bigfile_compatibility_dn(int dn)
 	dp[dn]->fromData(xp, yp, miss);
 }
 
-void do_bigfile_compatibility() throw(ParserError) {
+void do_bigfile_compatibility() {
 	for (int dn = 1; dn <= ndata; dn++) {
 		if (dp[dn] != NULL) {
 			if (dp[dn]->bigfile != NULL) {
@@ -4325,7 +4325,7 @@ vector<int> GLEDataSet::getMissingValues
 	return result;
 }
 
-void GLEDataSet::checkRanges() throw(ParserError) {
+void GLEDataSet::checkRanges() {
 	// when parsing "let" -> already create dataset with ensureCreate...
 	// so that dn command applies to it
 	copyRangeIfRequired(GLE_DIM_X);
Index: gle-graphics-4.3.3/src/gle/pass.cpp
===================================================================
--- gle-graphics-4.3.3.orig/src/gle/pass.cpp
+++ gle-graphics-4.3.3/src/gle/pass.cpp
@@ -64,7 +64,7 @@ extern GLESubMap g_Subroutines;
 void get_cap(TOKENS tk,int *ntok,int *curtok,int *pcode,int *plen);
 void get_join(TOKENS tk,int *ntok,int *curtok,int *pcode,int *plen);
 void g_marker_def(char *s1, char *s2);
-void font_load(void) throw(ParserError);
+void font_load(void);
 bool execute_graph(GLESourceLine& sline, bool isCommandCheck);
 
 extern int this_line;
@@ -235,7 +235,7 @@ void GLEParser::get_block_type(int type,
 	result = block_type;
 }
 
-void GLEParser::checkmode() throw(ParserError) {
+void GLEParser::checkmode() {
 	/* Check for text mode block */
 	if (cur_mode != 0) {
 		string block_type;
@@ -279,7 +279,7 @@ void GLEParser::setAllowSpace(bool allow
 	else multi->setEndToken(' ');
 }
 
-void GLEParser::checkValidName(const string& name, const char* type, int pos) throw(ParserError) {
+void GLEParser::checkValidName(const string& name, const char* type, int pos) {
 	if (name.length() <= 0) {
 		throw getTokens()->error(pos, string("zero length ")+type+" name");
 	}
@@ -295,7 +295,7 @@ void GLEParser::checkValidName(const str
 	}
 }
 
-double GLEParser::evalTokenToDouble() throw(ParserError) {
+double GLEParser::evalTokenToDouble() {
 	double x = 0.0;
 	Tokenizer* tokens = getTokens();
 	string& expr = tokens->next_multilevel_token();
@@ -309,7 +309,7 @@ double GLEParser::evalTokenToDouble() th
 	return x;
 }
 
-void GLEParser::evalTokenToString(string* str) throw(ParserError) {
+void GLEParser::evalTokenToString(string* str) {
 	Tokenizer* tokens = getTokens();
 	string& expr = tokens->next_multilevel_token();
 	int pos = tokens->token_pos_col();
@@ -321,7 +321,7 @@ void GLEParser::evalTokenToString(string
 	}
 }
 
-void GLEParser::evalTokenToFileName(string* str) throw(ParserError) {
+void GLEParser::evalTokenToFileName(string* str) {
 	Tokenizer* tokens = getTokens();
    const string& token = tokens->next_continuous_string_excluding("\"$+");
    if (token != "") {
@@ -331,7 +331,7 @@ void GLEParser::evalTokenToFileName(stri
    }
 }
 
-void GLEParser::polish(GLEPcode& pcode, int *rtype) throw(ParserError) {
+void GLEParser::polish(GLEPcode& pcode, int *rtype) {
 	Tokenizer* tokens = getTokens();
 	string& expr = tokens->next_multilevel_token();
 	int pos = tokens->token_pos_col();
@@ -345,17 +345,17 @@ void GLEParser::polish(GLEPcode& pcode,
 	}
 }
 
-void GLEParser::polish_eol(GLEPcode& pcode, int *rtype) throw(ParserError) {
+void GLEParser::polish_eol(GLEPcode& pcode, int *rtype) {
 	setAllowSpace(true);
 	polish(pcode, rtype);
 	setAllowSpace(false);
 }
 
-void GLEParser::polish(const char* str, GLEPcode& pcode, int *rtype) throw(ParserError) {
+void GLEParser::polish(const char* str, GLEPcode& pcode, int *rtype) {
 	m_polish->polish(str, pcode, rtype);
 }
 
-void GLEParser::polish_pos(const string& arg, int pos, GLEPcode& pcode, int* rtype) throw(ParserError) {
+void GLEParser::polish_pos(const string& arg, int pos, GLEPcode& pcode, int* rtype) {
 	try {
 		m_polish->internalPolish(arg.c_str(), pcode, rtype);
 	} catch (ParserError& err) {
@@ -364,35 +364,35 @@ void GLEParser::polish_pos(const string&
 	}
 }
 
-void GLEParser::get_xy(GLEPcode& pcode) throw(ParserError) {
+void GLEParser::get_xy(GLEPcode& pcode) {
 	int vtype = 1;
 	polish(pcode, &vtype);
 	vtype = 1;
 	polish(pcode, &vtype);
 }
 
-void GLEParser::get_exp(GLEPcode& pcode) throw(ParserError) {
+void GLEParser::get_exp(GLEPcode& pcode) {
 	int vtype = 1;
 	polish(pcode, &vtype);
 }
 
-void GLEParser::get_exp_eol(GLEPcode& pcode) throw(ParserError) {
+void GLEParser::get_exp_eol(GLEPcode& pcode) {
 	int vtype = 1;
 	polish_eol(pcode, &vtype);
 }
 
-void GLEParser::get_strexp(GLEPcode& pcode) throw(ParserError) {
+void GLEParser::get_strexp(GLEPcode& pcode) {
 	int vtype = 2;
 	polish(pcode, &vtype);
 }
 
-int GLEParser::get_anyexp(GLEPcode& pcode) throw(ParserError) {
+int GLEParser::get_anyexp(GLEPcode& pcode) {
 	int vtype = 0;
 	polish(pcode, &vtype);
 	return vtype;
 }
 
-void GLEParser::get_if(GLEPcode& pcode) throw(ParserError) {
+void GLEParser::get_if(GLEPcode& pcode) {
 	Tokenizer* tokens = getTokens();
 	string expr = tokens->next_multilevel_token();
 	int pos = tokens->token_pos_col();
@@ -417,7 +417,7 @@ void GLEParser::get_if(GLEPcode& pcode)
 	}
 }
 
-void GLEParser::parse_if(int srclin, GLEPcode& pcode) throw(ParserError) {
+void GLEParser::parse_if(int srclin, GLEPcode& pcode) {
 	get_if(pcode);
 	GLESourceBlock* block = add_block(GLE_SRCBLK_MAGIC+GLE_OPBEGIN_IF, srclin);
 	block->setOffset2(pcode.size());
@@ -425,7 +425,7 @@ void GLEParser::parse_if(int srclin, GLE
 	pcode.addInt(0);
 }
 
-void GLEParser::get_subroutine_call(GLEPcode& pcode, string* name, int poscol) throw(ParserError) {
+void GLEParser::get_subroutine_call(GLEPcode& pcode, string* name, int poscol) {
 	string fct_name;
 	if (name != NULL) {
 		fct_name = *name;
@@ -443,7 +443,7 @@ void GLEParser::get_subroutine_call(GLEP
 	gen_subroutine_call_code(&info, pcode);
 }
 
-void GLEParser::pass_subroutine_call(GLESubCallInfo* info, int poscol) throw(ParserError) {
+void GLEParser::pass_subroutine_call(GLESubCallInfo* info, int poscol) {
 	GLESub* sub = info->getSub();
 	int np = sub->getNbParam();
 	string uc_token;
@@ -558,7 +558,7 @@ void GLEParser::pass_subroutine_call(GLE
 	}
 }
 
-void GLEParser::gen_subroutine_call_polish_arg(GLESubCallInfo* info, int i, GLEPcode& pcode) throw(ParserError) {
+void GLEParser::gen_subroutine_call_polish_arg(GLESubCallInfo* info, int i, GLEPcode& pcode) {
 	GLESub* sub = info->getSub();
 	try {
 		int vtype = sub->getParamType(i);
@@ -589,7 +589,7 @@ void GLEParser::evaluate_subroutine_argu
 	}
 }
 
-void GLEParser::gen_subroutine_call_code(GLESubCallInfo* info, GLEPcode& pcode) throw(ParserError) {
+void GLEParser::gen_subroutine_call_code(GLESubCallInfo* info, GLEPcode& pcode) {
 	/* pass all arguments */
 	GLESub* sub = info->getSub();
 	int np = sub->getNbParam();
@@ -603,7 +603,7 @@ void GLEParser::gen_subroutine_call_code
 	pcode.setInt(savelen, pcode.size() - savelen - 1);
 }
 
-GLESub* GLEParser::get_subroutine_declaration(GLEPcode& pcode) throw(ParserError) {
+GLESub* GLEParser::get_subroutine_declaration(GLEPcode& pcode) {
 	string uc_token;
 	string& token = m_tokens.next_token();
 	str_to_uppercase(token, uc_token);
@@ -658,7 +658,7 @@ GLESub* GLEParser::get_subroutine_declar
 	return sub;
 }
 
-void GLEParser::get_subroutine_default_param(GLESub* sub) throw(ParserError) {
+void GLEParser::get_subroutine_default_param(GLESub* sub) {
 	if (sub == NULL) {
 		return;
 	}
@@ -676,7 +676,7 @@ void GLEParser::get_subroutine_default_p
 	sub->setDefault(idx, token);
 }
 
-int GLEParser::get_optional(OPKEY lkey, GLEPcode& pcode) throw(ParserError) {
+int GLEParser::get_optional(OPKEY lkey, GLEPcode& pcode) {
 	// find the largest width
 	int count, width;
 	get_key_info(lkey, &count, &width);
@@ -727,11 +727,11 @@ ParserError GLEParser::create_option_err
 	return m_tokens.error(strm.str());
 }
 
-void GLEParser::duplicate_error(GLEPcode& pcode, int pos) throw(ParserError) {
+void GLEParser::duplicate_error(GLEPcode& pcode, int pos) {
 	if (pcode.getInt(pos) != 0) throw error("duplicate or illegal combination of qualifiers");
 }
 
-int GLEParser::get_one_option(op_key* lkey, GLEPcode& pcode, int plen) throw(ParserError) {
+int GLEParser::get_one_option(op_key* lkey, GLEPcode& pcode, int plen) {
 // switches 	int 	placed in directly, 1 present, 0 not present
 // expressions 	LONG* 	pointed to, 0 if not present.
 // color/fill	LONG* 	Pointer to exp 0 if not present.
@@ -795,11 +795,11 @@ int GLEParser::get_one_option(op_key* lk
 	return -1;
 }
 
-int GLEParser::get_first(OPKEY lkey) throw(ParserError) {
+int GLEParser::get_first(OPKEY lkey) {
 	return get_first(m_tokens.next_token(), lkey);
 }
 
-int GLEParser::get_first(const string& token, OPKEY lkey) throw(ParserError) {
+int GLEParser::get_first(const string& token, OPKEY lkey) {
 	int count, width;
 	get_key_info(lkey, &count, &width);
 	for (int i = 0; i < count; i++) {
@@ -810,7 +810,7 @@ int GLEParser::get_first(const string& t
 	throw create_option_error(lkey, count, token);
 }
 
-bool GLEParser::try_get_token(const char* token) throw(ParserError) {
+bool GLEParser::try_get_token(const char* token) {
 	string& my_token = m_tokens.try_next_token();
 	if (str_i_equals(token, my_token.c_str())) {
 		return true;
@@ -820,14 +820,14 @@ bool GLEParser::try_get_token(const char
 	return false;
 }
 
-void GLEParser::get_token(const char* token) throw(ParserError) {
+void GLEParser::get_token(const char* token) {
 	string& my_token = m_tokens.next_token();
 	if (!str_i_equals(token, my_token.c_str())) {
 		throw error(string("expected '")+token+"', but found '"+my_token+"' instead");
 	}
 }
 
-void GLEParser::get_fill(GLEPcode& pcode) throw (ParserError) {
+void GLEParser::get_fill(GLEPcode& pcode) {
 	get_color(pcode);
 }
 
@@ -911,7 +911,7 @@ GLERC<GLEColor> memory_cell_to_color(GLE
 	return color;
 }
 
-GLERC<GLEColor> pass_color_var(const std::string& token) throw(ParserError) {
+GLERC<GLEColor> pass_color_var(const std::string& token) {
 	GLERC<GLEColor> color(new GLEColor());
 	int result = 0;
 	if (token.empty()) {
@@ -926,7 +926,7 @@ GLERC<GLEColor> pass_color_var(const std
 	return color;
 }
 
-void GLEParser::get_color(GLEPcode& pcode) throw (ParserError) {
+void GLEParser::get_color(GLEPcode& pcode) {
 	int result = 0;
 	GLERC<GLEColor> color;
 	string& token = m_tokens.next_token();
@@ -968,7 +968,7 @@ int get_marker_string(const string& mark
    return mark_idx;
 }
 
-void GLEParser::get_marker(GLEPcode& pcode) throw (ParserError) {
+void GLEParser::get_marker(GLEPcode& pcode) {
 	int vtype = 1;
 	string& token = m_tokens.next_token();
 	if (token == "(" || is_float(token)) {
@@ -983,13 +983,13 @@ void GLEParser::get_marker(GLEPcode& pco
 	}
 }
 
-int pass_marker(char *name) throw(ParserError) {
+int pass_marker(char *name) {
 	string marker;
 	polish_eval_string(name, &marker);
    return get_marker_string(marker, g_get_throws_error());   
 }
 
-void GLEParser::define_marker_1(GLEPcode& pcode) throw (ParserError) {
+void GLEParser::define_marker_1(GLEPcode& pcode) {
 	string name;
 	Tokenizer* tokens = getTokens();
 	str_to_uppercase(tokens->next_token(), name);
@@ -1001,7 +1001,7 @@ void GLEParser::define_marker_1(GLEPcode
 	g_defmarker((char*)name.c_str(), (char*)font.c_str(), ccc, dx, dy, sz, true);
 }
 
-void GLEParser::define_marker_2(GLEPcode& pcode) throw (ParserError) {
+void GLEParser::define_marker_2(GLEPcode& pcode) {
 	string name, sub;
 	Tokenizer* tokens = getTokens();
 	tokens->ensure_next_token_i("marker");
@@ -1060,7 +1060,7 @@ int get_font_index(const string& token,
 	throw error->throwError(strm.str());
 }
 
-void GLEParser::get_font(GLEPcode& pcode) throw (ParserError) {
+void GLEParser::get_font(GLEPcode& pcode) {
 	string& token = m_tokens.next_token();
 	if (str_starts_with(token, "\"") || str_var_valid_name(token)) {
    	int etype = 1;
@@ -1085,7 +1085,7 @@ int pass_font(const std::string& token)
 	}
 }
 
-void GLEParser::get_papersize(GLEPcode& pcode) throw (ParserError) {
+void GLEParser::get_papersize(GLEPcode& pcode) {
 	const string& token = m_tokens.next_token();
 	int type = g_papersize_type(token);
 	if (type == GLE_PAPER_UNKNOWN) {
@@ -1098,7 +1098,7 @@ void GLEParser::get_papersize(GLEPcode&
 	}
 }
 
-void GLEParser::get_justify(GLEPcode& pcode) throw (ParserError) {
+void GLEParser::get_justify(GLEPcode& pcode) {
 	const string& token = m_tokens.next_token();
 	if (str_starts_with(token, "\"") || str_var_valid_name(token)) {
 		int etype = 1;
@@ -1122,22 +1122,22 @@ int pass_justify(const std::string& toke
 	return gt_firstval(op_justify, token.c_str());
 }
 
-void GLEParser::get_join(GLEPcode& pcode) throw (ParserError) {
+void GLEParser::get_join(GLEPcode& pcode) {
 	pcode.addInt(get_first(op_join));
 }
 
-void GLEParser::get_cap(GLEPcode& pcode) throw (ParserError) {
+void GLEParser::get_cap(GLEPcode& pcode) {
 	pcode.addInt(get_first(op_cap));
 }
 
-void GLEParser::get_var_add(int *var, int *vtype) throw (ParserError) {
+void GLEParser::get_var_add(int *var, int *vtype) {
 	string uc_token;
 	string& token = m_tokens.next_token();
 	str_to_uppercase(token, uc_token);
 	var_findadd((char*)uc_token.c_str(), var, vtype);
 }
 
-void GLEParser::get_var(GLEPcode& pcode) throw (ParserError) {
+void GLEParser::get_var(GLEPcode& pcode) {
 	int var;
 	int vtype = 0;
 	get_var_add(&var, &vtype);
@@ -1193,7 +1193,7 @@ bool GLEParser::pass_block_specific(GLES
 	return false;
 }
 
-void GLEParser::passt(GLESourceLine &SLine, GLEPcode& pcode) throw(ParserError) {
+void GLEParser::passt(GLESourceLine &SLine, GLEPcode& pcode) {
 	resetSpecial();
 	static int i,f,vtyp,v,vidx;
 	int srclin = SLine.getGlobalLineNo();
@@ -1969,7 +1969,7 @@ void GLEParser::passt(GLESourceLine &SLi
 	}
 }
 
-void GLEParser::do_text_mode(GLESourceLine &SLine, Tokenizer* tokens, GLEPcode& pcode) throw (ParserError) {
+void GLEParser::do_text_mode(GLESourceLine &SLine, Tokenizer* tokens, GLEPcode& pcode) {
 	int pos_endoffs = pcode.size();
 	// Save space for end offset
 	pcode.addInt(0);
@@ -2060,7 +2060,7 @@ void GLEParser::remove_last_block() {
 	m_blocks.pop_back();
 }
 
-void GLEParser::check_loop_variable(int var) throw (ParserError) {
+void GLEParser::check_loop_variable(int var) {
 	GLESourceBlock* block = last_block();
 	if (block == NULL || var != block->getVariable()) {
 		stringstream err;
@@ -2070,7 +2070,7 @@ void GLEParser::check_loop_variable(int
 	}
 }
 
-GLESourceBlock* GLEParser::check_block_type(int pos, int t0, int t1, int t2) throw (ParserError) {
+GLESourceBlock* GLEParser::check_block_type(int pos, int t0, int t1, int t2) {
 	GLESourceBlock* block = last_block();
 	if (block == NULL) {
 		stringstream err;
Index: gle-graphics-4.3.3/src/gle/polish.cpp
===================================================================
--- gle-graphics-4.3.3.orig/src/gle/polish.cpp
+++ gle-graphics-4.3.3/src/gle/polish.cpp
@@ -92,13 +92,13 @@ void GLEPolish::initTokenizer() {
 	m_tokens.select_language(0);
 }
 
-void GLEPolish::get_array_index(GLEPcode& pcode) throw(ParserError) {
+void GLEPolish::get_array_index(GLEPcode& pcode) {
 	int vtype = 1;
 	internalPolish(pcode, &vtype);
 	m_tokens.ensure_next_token("]");
 }
 
-int GLEPolish::get_params(GLEPcode& pcode, int np, int* plist, const string& name, int np_default ) throw(ParserError) {
+int GLEPolish::get_params(GLEPcode& pcode, int np, int* plist, const string& name, int np_default ) {
 	// called when subroutine is a left hand argument => a = myfunc(4,5)
 	// returns the number of parameters found
 	int nb_param = 0;
@@ -129,7 +129,7 @@ int GLEPolish::get_params(GLEPcode& pcod
 	return nb_param;
 }
 
-void GLEPolish::polish(const char *expr, GLEPcode& pcode, int *rtype) throw(ParserError) {
+void GLEPolish::polish(const char *expr, GLEPcode& pcode, int *rtype) {
 	try {
 		internalPolish(expr, pcode, rtype);
 	} catch (ParserError& err) {
@@ -138,7 +138,7 @@ void GLEPolish::polish(const char *expr,
 	}
 }
 
-void GLEPolish::internalPolish(const char *expr, GLEPcode& pcode, int *rtype) throw(ParserError) {
+void GLEPolish::internalPolish(const char *expr, GLEPcode& pcode, int *rtype) {
 	#ifdef DEBUG_POLISH
 		gprint("==== Start of expression {%s} \n",expr);
 	#endif
@@ -146,7 +146,7 @@ void GLEPolish::internalPolish(const cha
 	internalPolish(pcode, rtype);
 }
 
-void GLEPolish::internalPolish(GLEPcode& pcode, int *rtype) throw(ParserError) {
+void GLEPolish::internalPolish(GLEPcode& pcode, int *rtype) {
 	GLESub* sub;
 	string uc_token;
 	int idx, ret, np, *plist, term_bracket = false;
@@ -423,7 +423,7 @@ Tokenizer* GLEPolish::getTokens(const st
 	return &m_tokens;
 }
 
-void GLEPolish::internalEval(const char *exp, double *x) throw(ParserError) {
+void GLEPolish::internalEval(const char *exp, double *x) {
 	// difference with eval: no try / catch
 	int rtype = 1, cp = 0;
 	GLEPcodeList pc_list;
@@ -433,7 +433,7 @@ void GLEPolish::internalEval(const char
 	*x = evalDouble(stk.get(), &pc_list, (int*)&pcode[0], &cp);
 }
 
-void GLEPolish::internalEvalString(const char* exp, string* str) throw(ParserError) {
+void GLEPolish::internalEvalString(const char* exp, string* str) {
 	// difference with eval_string: no try / catch
 	int rtype = 2, cp = 0;
 	GLEPcodeList pc_list;
@@ -444,7 +444,7 @@ void GLEPolish::internalEvalString(const
 	*str = result->toUTF8();
 }
 
-void GLEPolish::eval(GLEArrayImpl* stk, const char *exp, double *x) throw(ParserError) {
+void GLEPolish::eval(GLEArrayImpl* stk, const char *exp, double *x) {
 	int rtype = 1, cp = 0;
 	GLEPcodeList pc_list;
 	GLEPcode pcode(&pc_list);
@@ -452,7 +452,7 @@ void GLEPolish::eval(GLEArrayImpl* stk,
 	*x = evalDouble(stk, &pc_list, (int*)&pcode[0], &cp);
 }
 
-void GLEPolish::evalString(GLEArrayImpl* stk, const char *exp, string *str, bool allownum) throw(ParserError) {
+void GLEPolish::evalString(GLEArrayImpl* stk, const char *exp, string *str, bool allownum) {
 	int rtype = allownum ? 0 : 2;
 	int cp = 0;
 	GLEPcodeList pc_list;
@@ -462,7 +462,7 @@ void GLEPolish::evalString(GLEArrayImpl*
 	*str = result->toUTF8();
 }
 
-GLEMemoryCell* GLEPolish::evalGeneric(GLEArrayImpl* stk, const char *exp) throw(ParserError) {
+GLEMemoryCell* GLEPolish::evalGeneric(GLEArrayImpl* stk, const char *exp) {
 	int cp = 0;
 	int rtype = 0;
 	GLEPcodeList pc_list;
@@ -494,7 +494,7 @@ void stack_op(GLEPcode& pcode, int stk[]
 	stkp[*nstk] = p;
 }
 
-void polish(char *expr, GLEPcode& pcode, int *rtype) throw(ParserError) {
+void polish(char *expr, GLEPcode& pcode, int *rtype) {
 	GLEPolish* polish = get_global_polish();
 	if (polish != NULL) {
 		polish->polish(expr, pcode, rtype);
@@ -514,13 +514,13 @@ void eval_pcode_str(GLEPcode& pcode, str
 	x = result->toUTF8();
 }
 
-void polish_eval(char *exp, double *x) throw(ParserError) {
+void polish_eval(char *exp, double *x) {
 	GLEPolish* polish = get_global_polish();
 	GLERC<GLEArrayImpl> stk(new GLEArrayImpl());
 	if (polish != NULL) polish->eval(stk.get(), exp, x);
 }
 
-void polish_eval_string(const char *exp, string *str, bool allownum) throw(ParserError) {
+void polish_eval_string(const char *exp, string *str, bool allownum) {
 	GLEPolish* polish = get_global_polish();
 	GLERC<GLEArrayImpl> stk(new GLEArrayImpl());
 	if (polish != NULL) polish->evalString(stk.get(), exp, str, allownum);
@@ -692,7 +692,7 @@ GLEFunctionParserPcode::GLEFunctionParse
 GLEFunctionParserPcode::~GLEFunctionParserPcode() {
 }
 
-void GLEFunctionParserPcode::polish(const char* fct, StringIntHash* vars) throw(ParserError) {
+void GLEFunctionParserPcode::polish(const char* fct, StringIntHash* vars) {
 	GLEPolish* polish = get_global_polish();
 	if (polish != NULL) {
 		int rtype = 1;
@@ -702,7 +702,7 @@ void GLEFunctionParserPcode::polish(cons
 	}
 }
 
-void GLEFunctionParserPcode::polishPos(const char* fct, int pos, StringIntHash* vars) throw(ParserError) {
+void GLEFunctionParserPcode::polishPos(const char* fct, int pos, StringIntHash* vars) {
 	GLEPolish* polish = get_global_polish();
 	if (polish != NULL) {
 		try {
@@ -717,7 +717,7 @@ void GLEFunctionParserPcode::polishPos(c
 	}
 }
 
-void GLEFunctionParserPcode::polishX() throw(ParserError) {
+void GLEFunctionParserPcode::polishX() {
 	polish("x", NULL);
 }
 
Index: gle-graphics-4.3.3/src/gle/run.cpp
===================================================================
--- gle-graphics-4.3.3.orig/src/gle/run.cpp
+++ gle-graphics-4.3.3/src/gle/run.cpp
@@ -55,7 +55,7 @@
 #include "sub.h"
 #include "gle-interface/gle-interface.h"
 
-void name_get2(char *n,double *x1,double *y1,double *x2,double *y2) throw(ParserError);
+void name_get2(char *n,double *x1,double *y1,double *x2,double *y2);
 
 #define GRAPHDEF extern
 #include "graph.h"
@@ -81,11 +81,11 @@ void run_bigfile(char *ss);
 void begin_config(const std::string& block, int *pln, int *pcode, int *cp);
 void begin_tex_preamble(int *pln, int *pcode, int *cp);
 void begin_tex(GLERun* run, int *pln, int *pcode, int *cp);
-void begin_surface(int *pln, int *pcode, int *cp) throw(ParserError);
-void begin_letz(int *pln, GLEPcodeList* pclist, int *pcode, int *cp) throw(ParserError);
-void begin_fitz(int *pln, int *pcode, int *cp) throw(ParserError);
-void begin_contour(int *pln, int *pcode, int *cp) throw(ParserError);
-// void begin_fitls(int *pln, int *pcode, int *cp) throw(ParserError);
+void begin_surface(int *pln, int *pcode, int *cp);
+void begin_letz(int *pln, GLEPcodeList* pclist, int *pcode, int *cp);
+void begin_fitz(int *pln, int *pcode, int *cp);
+void begin_contour(int *pln, int *pcode, int *cp);
+// void begin_fitls(int *pln, int *pcode, int *cp);
 
 class GLEBox {
 public:
@@ -175,11 +175,11 @@ public:
 	GLEFile();
 	~GLEFile();
 	void close();
-	void open(const char* fname) throw(ParserError);
-	bool eof() throw(ParserError);
-	char* getToken() throw(ParserError);
-	char* readLine() throw(ParserError);
-	void gotoNewLine() throw(ParserError);
+	void open(const char* fname);
+	bool eof();
+	char* getToken();
+	char* readLine();
+	void gotoNewLine();
 	void resetLang();
 	void setLangChars(int type, const char* str);
 	inline void setCommentChars(const std::string& str) { setLangChars(0, str.c_str()); }
@@ -194,16 +194,16 @@ vector<GLEFile*> g_Files;
 
 int f_getchan(void);
 void f_readahead(int chn);
-int f_testchan(int chn) throw(ParserError);
+int f_testchan(int chn);
 void siffree(char **s);
 void f_getline(int chn);
 char *f_gettok(int chn);
 static int chn;
-int f_eof(int chn) throw(ParserError);
+int f_eof(int chn);
 char *f_getnext(int chn);
 
 void f_create_chan(int var, const char* fname, int rd_wr);
-void f_close_chan(int idx) throw(ParserError);
+void f_close_chan(int idx);
 
 
 /*---------------------------------------------------------------------------*/
@@ -233,7 +233,7 @@ vector<int> g_drobj;
 
 #define PCODE_UNKNOWN_COMMAND 1
 
-void byte_code_error(int err) throw(ParserError) {
+void byte_code_error(int err) {
 	char str[50];
 	TokenizerPos pos;
 	pos.setColumn(-1);
@@ -255,7 +255,7 @@ int gle_is_open() {
 	return done_open;
 }
 
-void error_before_drawing_cmds(const char* name) throw(ParserError) {
+void error_before_drawing_cmds(const char* name) {
 	// NOTE: this can be broken by GLEGlobalSource::performUpdates(), which puts includes at front
 	string str = name;
 	str += " command must appear before drawing commands";
@@ -529,7 +529,7 @@ GLEBlocks* GLERun::getBlockTypes() {
 	return m_blockTypes;
 }
 
-void GLERun::do_pcode(GLESourceLine &sline, int *srclin, int *pcode, int plen, int *pend, bool& mkdrobjs) throw(ParserError) {
+void GLERun::do_pcode(GLESourceLine &sline, int *srclin, int *pcode, int plen, int *pend, bool& mkdrobjs) {
 /* srclin = The source line number */
 /* pcode =  a pointer to the pcode output buffer */
 /* plne =   a pointer to the length of the pcode output */
@@ -1766,7 +1766,7 @@ GLEStoredBox* box_start() {
 	return box;
 }
 
-GLEStoredBox* GLERun::last_box() throw (ParserError) {
+GLEStoredBox* GLERun::last_box() {
 	GLEBoxStack* stack = GLEBoxStack::getInstance();
 	if (stack->size() <= 0) {
 		g_throw_parser_error("too many end boxes");
@@ -1774,7 +1774,7 @@ GLEStoredBox* GLERun::last_box() throw (
 	return stack->lastBox();
 }
 
-bool GLERun::box_end() throw (ParserError) {
+bool GLERun::box_end() {
 	double x1, y1, x2, y2;
 	GLEBoxStack* stack = GLEBoxStack::getInstance();
 	if (stack->size() <= 0) {
@@ -1843,7 +1843,7 @@ bool GLERun::is_name(GLEObjectRepresenti
 	return true;
 }
 
-GLEObjectRepresention* GLERun::name_to_object(GLEObjectRepresention* obj, GLEArrayImpl* path, GLEJustify* just, unsigned int offs) throw (ParserError) {
+GLEObjectRepresention* GLERun::name_to_object(GLEObjectRepresention* obj, GLEArrayImpl* path, GLEJustify* just, unsigned int offs) {
 	/* check for just object name */
 	unsigned int size = path->size();
 	if (size <= offs) {
@@ -1921,7 +1921,7 @@ bool GLERun::is_name(GLEString* name) {
 	return false;
 }
 
-GLEObjectRepresention* GLERun::name_to_object(GLEString* name, GLEJustify* just) throw(ParserError) {
+GLEObjectRepresention* GLERun::name_to_object(GLEString* name, GLEJustify* just) {
 	int idx, type;
 	GLERC<GLEArrayImpl> path(name->split('.'));
 	GLEString* objname = (GLEString*)path->getObjectUnsafe(0);
@@ -1948,7 +1948,7 @@ GLEObjectRepresention* GLERun::name_to_o
 	return NULL;
 }
 
-void GLERun::name_to_point(GLEString* name, GLEPoint* point) throw(ParserError) {
+void GLERun::name_to_point(GLEString* name, GLEPoint* point) {
 	GLEJustify just;
 	GLEObjectRepresention* obj = name_to_object(name, &just);
 	if (obj != NULL) {
@@ -1961,7 +1961,7 @@ void GLERun::name_to_point(GLEString* na
 	}
 }
 
-void GLERun::name_to_size(GLEString* name, double *wd, double *hi) throw(ParserError) {
+void GLERun::name_to_size(GLEString* name, double *wd, double *hi) {
 	GLEJustify just;
 	GLEObjectRepresention* obj = name_to_object(name, &just);
 	if (obj != NULL) {
@@ -1975,7 +1975,7 @@ void GLERun::name_to_size(GLEString* nam
 	}
 }
 
-void GLERun::name_join(GLEString *n1, GLEString *n2, int marrow, double a1, double a2, double d1, double d2)  throw(ParserError) {
+void GLERun::name_join(GLEString *n1, GLEString *n2, int marrow, double a1, double a2, double d1, double d2)  {
 	GLEJustify j1, j2;
 	GLEObjectRepresention* obj1 = name_to_object(n1, &j1);
 	GLEObjectRepresention* obj2 = name_to_object(n2, &j2);
@@ -2006,7 +2006,7 @@ void GLERun::name_join(GLEString *n1, GL
 	g_arrowcurve(ex, ey, marrow, a1, a2, d1, d2);
 }
 
-void GLERun::draw_object_static(const string& path, const string& name, int* pcode, int* cp, bool mkdrobjs) throw (ParserError) {
+void GLERun::draw_object_static(const string& path, const string& name, int* pcode, int* cp, bool mkdrobjs) {
 	int cp_backup = *cp;
 	GLEPoint orig;
 	g_get_xy(&orig);
@@ -2093,7 +2093,7 @@ void GLERun::draw_object_static(const st
 	g_move(orig);
 }
 
-void GLERun::draw_object_subbyname(GLESub* sub, GLEObjectRepresention* newobj, GLEArrayImpl* path, GLEPoint* orig) throw (ParserError) {
+void GLERun::draw_object_subbyname(GLESub* sub, GLEObjectRepresention* newobj, GLEArrayImpl* path, GLEPoint* orig) {
 	bool hasoffs = (path->size() > 1);
 	GLEDevice* olddev = NULL;
 	if (hasoffs && !g_is_dummy_device()) {
@@ -2140,7 +2140,7 @@ void GLERun::draw_object_subbyname(GLESu
 	}
 }
 
-void GLERun::draw_object_dynamic(int idx, GLEObjectRepresention* newobj, GLEArrayImpl* path, GLEPoint* orig) throw (ParserError) {
+void GLERun::draw_object_dynamic(int idx, GLEObjectRepresention* newobj, GLEArrayImpl* path, GLEPoint* orig) {
 	GLEDataObject* obj = getVars()->getObject(idx);
 	if (obj == NULL || obj->getType() != GLEObjectTypeObjectRep) {
 		string err = getVars()->typeError(idx, GLEObjectTypeObjectRep);
@@ -2206,7 +2206,7 @@ void GLERun::draw_object_dynamic(int idx
 	}
 }
 
-void GLERun::draw_object(const string& path, const char* newname) throw (ParserError) {
+void GLERun::draw_object(const string& path, const char* newname) {
 	int idx, type;
 	char ostr[255];
 	GLEPoint orig;
@@ -2250,7 +2250,7 @@ void GLERun::draw_object(const string& p
 	g_move(orig);
 }
 
-void GLERun::begin_object(const std::string& name, GLESub* sub) throw (ParserError) {
+void GLERun::begin_object(const std::string& name, GLESub* sub) {
 	GLEStoredBox* box = box_start();
 	box->setStroke(false);
 	box->setObjectRep(getCRObjectRep());
@@ -2285,7 +2285,7 @@ void GLERun::begin_object(const std::str
 	}
 }
 
-void GLERun::end_object() throw (ParserError) {
+void GLERun::end_object() {
 	GLEBoxStack* stack = GLEBoxStack::getInstance();
 	if (stack->size() <= 0) {
 		g_throw_parser_error("too many end boxes");
@@ -2391,7 +2391,7 @@ void nm_adjust(GLEJustify jj, double *sx
 	}
 }
 
-int f_eof(int chn) throw(ParserError) {
+int f_eof(int chn) {
 	if (f_testchan(chn) == -1) return 1;
 	else return (int)g_Files[chn]->eof();
 }
@@ -2404,7 +2404,7 @@ void siffree(char **s) {
 	*s = NULL;
 }
 
-int f_testchan(int chn) throw(ParserError) {
+int f_testchan(int chn) {
 	if (chn < 0 || chn >= (int)g_Files.size() || g_Files[chn] == NULL) {
 		char chn_s[10];
 		sprintf(chn_s, "%d", chn);
@@ -2433,7 +2433,7 @@ void f_create_chan(int var, const char*
 	file->open(fname);
 }
 
-void f_close_chan(int idx) throw(ParserError) {
+void f_close_chan(int idx) {
 	if (f_testchan(idx) != -1) {
 		GLEFile* file = g_Files[idx];
 		file->close();
@@ -2465,7 +2465,7 @@ void GLEFile::close() {
 	}
 }
 
-void GLEFile::open(const char* fname) throw(ParserError) {
+void GLEFile::open(const char* fname) {
 	m_FileName = fname;
 	if (isRead()) {
 		validate_file_name(m_FileName, true);
@@ -2486,22 +2486,22 @@ void GLEFile::open(const char* fname) th
 	}
 }
 
-char* GLEFile::readLine() throw(ParserError) {
+char* GLEFile::readLine() {
 	m_buffer = m_Input->read_line();
 	return (char*)m_buffer.c_str();
 }
 
-char* GLEFile::getToken() throw(ParserError) {
+char* GLEFile::getToken() {
 	m_buffer = m_Input->next_token();
 	str_remove_quote(m_buffer);
 	return (char*)m_buffer.c_str();
 }
 
-void GLEFile::gotoNewLine() throw(ParserError) {
+void GLEFile::gotoNewLine() {
 	m_Input->token_skip_to_end();
 }
 
-bool GLEFile::eof() throw(ParserError) {
+bool GLEFile::eof() {
 	return m_Input->has_more_tokens() == 0 ? true : false;
 }
 
Index: gle-graphics-4.3.3/src/gle/sub.cpp
===================================================================
--- gle-graphics-4.3.3.orig/src/gle/sub.cpp
+++ gle-graphics-4.3.3/src/gle/sub.cpp
@@ -355,7 +355,7 @@ void sub_get_startend(int idx, int *ss,
 	*ee = sub->getEnd();
 }
 
-GLESub* sub_get(int idx) throw(ParserError) {
+GLESub* sub_get(int idx) {
 	if (!sub_is_valid(idx)) {
 		g_throw_parser_error("illegal subroutine identifier: ", idx);
 	}
@@ -372,7 +372,7 @@ std::cerr << std::endl;
 */
 
 /* 	Run a user defined function  */
-void GLERun::sub_call_stack(GLESub* sub, GLEArrayImpl* stk) throw(ParserError) {
+void GLERun::sub_call_stack(GLESub* sub, GLEArrayImpl* stk) {
 	// Save current return value
 	//gprint(sub->getName());
 	GLEMemoryCell save_return_value;
@@ -406,7 +406,7 @@ void GLERun::sub_call_stack(GLESub* sub,
 }
 
 /* 	Run a user defined function  */
-void GLERun::sub_call(GLESub* sub, GLEArrayImpl* arguments) throw(ParserError) {
+void GLERun::sub_call(GLESub* sub, GLEArrayImpl* arguments) {
 	GLEMemoryCell save_return_value;
 	GLE_MC_INIT(save_return_value);
 	GLE_MC_COPY(&save_return_value, &m_returnValue);
@@ -436,7 +436,7 @@ void GLERun::sub_call(GLESub* sub, GLEAr
 	var_free_local();
 }
 
-void call_sub_byname(const string& name, double* args, int nb, const char* err_inf) throw(ParserError) {
+void call_sub_byname(const string& name, double* args, int nb, const char* err_inf) {
 	GLESub* sub = sub_find(name);
 	if (sub == NULL)  {
 		stringstream err;
@@ -453,7 +453,7 @@ void call_sub_byname(const string& name,
 	getGLERunInstance()->sub_call(sub, stk.get());
 }
 
-void call_sub_byid(int idx, double* args, int nb, const char* err_inf) throw(ParserError) {
+void call_sub_byid(int idx, double* args, int nb, const char* err_inf) {
 	GLESub* sub = sub_get(idx);
 	if (sub == NULL) return;
 	if (sub->getNbParam() != nb) {
Index: gle-graphics-4.3.3/src/gle/var.cpp
===================================================================
--- gle-graphics-4.3.3.orig/src/gle/var.cpp
+++ gle-graphics-4.3.3/src/gle/var.cpp
@@ -634,13 +634,13 @@ bool var_valid_name(const string& name)
    return true;
 }
 
-void ensure_valid_var_name(const string& name) throw(ParserError) {
+void ensure_valid_var_name(const string& name) {
 	if (!var_valid_name(name)) {
 		g_throw_parser_error("illegal variable name '", name.c_str(), "'");
 	}
 }
 
-void ensure_valid_var_name(Tokenizer* tokens, const string& name) throw(ParserError) {
+void ensure_valid_var_name(Tokenizer* tokens, const string& name) {
 	if (!var_valid_name(name)) {
 		throw tokens->error(string("illegal variable name '")+name+"'");
 	}
Index: gle-graphics-4.3.3/src/gle/texinterface.cpp
===================================================================
--- gle-graphics-4.3.3.orig/src/gle/texinterface.cpp
+++ gle-graphics-4.3.3/src/gle/texinterface.cpp
@@ -104,28 +104,28 @@ TeXInterface::~TeXInterface() {
 	}
 }
 
-TeXObject* TeXInterface::draw(const char* str) throw(ParserError) {
+TeXObject* TeXInterface::draw(const char* str) {
 	TeXObjectInfo info;
 	return draw(str, info, 1);
 }
 
-TeXObject* TeXInterface::draw(const std::string& str, GLERectangle* box) throw(ParserError) {
+TeXObject* TeXInterface::draw(const std::string& str, GLERectangle* box) {
 	TeXObjectInfo info;
 	return draw(str.c_str(), info, 1, box);
 }
-TeXObject* TeXInterface::drawUTF8(const char* str, GLERectangle* box) throw(ParserError) {
+TeXObject* TeXInterface::drawUTF8(const char* str, GLERectangle* box) {
 	TeXObjectInfo info;
 	string utf8 = str;
 	decode_utf8_basic(utf8);
 	return draw(utf8.c_str(), info, 1, box);
 }
 
-TeXObject* TeXInterface::draw(const char* str, int nblines, GLERectangle* box) throw(ParserError) {
+TeXObject* TeXInterface::draw(const char* str, int nblines, GLERectangle* box) {
 	TeXObjectInfo info;
 	return draw(str, info, nblines, box);
 }
 
-TeXObject* TeXInterface::draw(const char* str, TeXObjectInfo& info, int nblines, GLERectangle* box) throw(ParserError) {
+TeXObject* TeXInterface::draw(const char* str, TeXObjectInfo& info, int nblines, GLERectangle* box) {
 	/* Load hash */
 	tryLoadHash();
 	/* Get object from hash */
@@ -166,7 +166,7 @@ void TeXInterface::scaleObject(string& o
 	}
 }
 
-TeXObject* TeXInterface::drawObj(TeXHashObject* hobj, TeXObjectInfo& info, GLERectangle* box) throw(ParserError) {
+TeXObject* TeXInterface::drawObj(TeXHashObject* hobj, TeXObjectInfo& info, GLERectangle* box) {
 	/* Throw exception if disabled*/
 	if (!isEnabled()) {
 		g_throw_parser_error("safe mode - TeX subsystem has been disabled");
Index: gle-graphics-4.3.3/src/gle/d_ps.cpp
===================================================================
--- gle-graphics-4.3.3.orig/src/gle/d_ps.cpp
+++ gle-graphics-4.3.3/src/gle/d_ps.cpp
@@ -178,7 +178,7 @@ FILE* PSGLEDevice::get_file_pointer(void
 	return psfile;
 }
 
-void PSGLEDevice::opendev(double width, double height, GLEFileLocation* outputfile, const string& inputfile) throw(ParserError) {
+void PSGLEDevice::opendev(double width, double height, GLEFileLocation* outputfile, const string& inputfile) {
 	first_ellipse = 1;
 	m_OutputName.copy(outputfile);
 	m_OutputName.addExtension(g_device_to_ext(getDeviceType()));
Index: gle-graphics-4.3.3/src/gle/d_dummy.cpp
===================================================================
--- gle-graphics-4.3.3.orig/src/gle/d_dummy.cpp
+++ gle-graphics-4.3.3/src/gle/d_dummy.cpp
@@ -146,7 +146,7 @@ void GLEDummyDevice::narc(dbl r,dbl t1,d
 void GLEDummyDevice::newpath(void) {
 }
 
-void GLEDummyDevice::opendev(double width, double height, GLEFileLocation* outputfile, const string& inputfile) throw(ParserError) {
+void GLEDummyDevice::opendev(double width, double height, GLEFileLocation* outputfile, const string& inputfile) {
 	g_scale(PS_POINTS_PER_INCH/CM_PER_INCH, PS_POINTS_PER_INCH/CM_PER_INCH);
 	g_translate(1.0*CM_PER_INCH/72, 1.0*CM_PER_INCH/72);
 }
Index: gle-graphics-4.3.3/src/gle/config.cpp
===================================================================
--- gle-graphics-4.3.3.orig/src/gle/config.cpp
+++ gle-graphics-4.3.3/src/gle/config.cpp
@@ -72,7 +72,7 @@ char *un_quote(char *ct);
 
 #define skipspace doskip(tk[ct],&ct)
 
-void begin_config(const std::string& block, int *pln, int *pcode, int *cp) throw(ParserError) {
+void begin_config(const std::string& block, int *pln, int *pcode, int *cp) {
 	string block_name(block);
 	ConfigSection* section = g_Config.getSection(block_name);
 	if (section == NULL) {
Index: gle-graphics-4.3.3/src/gle/d_cairo.cpp
===================================================================
--- gle-graphics-4.3.3.orig/src/gle/d_cairo.cpp
+++ gle-graphics-4.3.3/src/gle/d_cairo.cpp
@@ -552,7 +552,7 @@ void GLECairoDevice::newpath(void) {
 	cairo_new_path(m_cr);
 }
 
-void GLECairoDevice::opendev(double width, double height, GLEFileLocation* outputfile, const string& inputfile) throw(ParserError) {
+void GLECairoDevice::opendev(double width, double height, GLEFileLocation* outputfile, const string& inputfile) {
 }
 
 void GLECairoDevice::pscomment(char* ss) {
@@ -854,7 +854,7 @@ GLECairoDeviceSVG::GLECairoDeviceSVG(boo
 GLECairoDeviceSVG::~GLECairoDeviceSVG() {
 }
 
-void GLECairoDeviceSVG::opendev(double width, double height, GLEFileLocation* outputfile, const string& inputfile) throw(ParserError) {
+void GLECairoDeviceSVG::opendev(double width, double height, GLEFileLocation* outputfile, const string& inputfile) {
 	m_width = width;
 	m_height = height;
 	m_OutputName.copy(outputfile);
@@ -879,7 +879,7 @@ GLECairoDevicePDF::GLECairoDevicePDF(boo
 GLECairoDevicePDF::~GLECairoDevicePDF() {
 }
 
-void GLECairoDevicePDF::opendev(double width, double height, GLEFileLocation* outputfile, const string& inputfile) throw(ParserError) {
+void GLECairoDevicePDF::opendev(double width, double height, GLEFileLocation* outputfile, const string& inputfile) {
 	clearRecordedData();
 	m_width = width;
 	m_height = height;
@@ -909,7 +909,7 @@ GLECairoDeviceEPS::GLECairoDeviceEPS(boo
 GLECairoDeviceEPS::~GLECairoDeviceEPS() {
 }
 
-void GLECairoDeviceEPS::opendev(double width, double height, GLEFileLocation* outputfile, const string& inputfile) throw(ParserError) {
+void GLECairoDeviceEPS::opendev(double width, double height, GLEFileLocation* outputfile, const string& inputfile) {
 	clearRecordedData();
 	m_width = width;
 	m_height = height;
@@ -1017,7 +1017,7 @@ void GLECairoDeviceEMF::set_matrix(doubl
     cairo_set_matrix(m_cr, &matrix);
 }
 
-void GLECairoDeviceEMF::opendev(double width, double height, GLEFileLocation* outputfile, const string& inputfile) throw(ParserError) {
+void GLECairoDeviceEMF::opendev(double width, double height, GLEFileLocation* outputfile, const string& inputfile) {
 	m_width = width;
 	m_height = height;
 	m_OutputName.copy(outputfile);
Index: gle-graphics-4.3.3/src/gle/d_x.cpp
===================================================================
--- gle-graphics-4.3.3.orig/src/gle/d_x.cpp
+++ gle-graphics-4.3.3/src/gle/d_x.cpp
@@ -431,7 +431,7 @@ void X11GLEDevice::newpath()
 	path_newpath();
 }
 /*---------------------------------------------------------------------------*/
-void X11GLEDevice::opendev(double width, double height, GLEFileLocation* outputfile, const string& inputfile) throw(ParserError)
+void X11GLEDevice::opendev(double width, double height, GLEFileLocation* outputfile, const string& inputfile)
 {
 	gle_nspeed = 2; /* text mode = slow and fast */
 	xsizecm = 16;
Index: gle-graphics-4.3.3/src/gle/glearray.cpp
===================================================================
--- gle-graphics-4.3.3.orig/src/gle/glearray.cpp
+++ gle-graphics-4.3.3/src/gle/glearray.cpp
@@ -208,7 +208,7 @@ GLEZData::~GLEZData() {
 	if (m_Data != NULL) delete[] m_Data;
 }
 
-void GLEZData::read(const string& fname) throw(ParserError) {
+void GLEZData::read(const string& fname) {
 	string expanded(GLEExpandEnvironmentVariables(fname));
 	validate_file_name(expanded, false);
 	TokenizerLanguage lang;
Index: gle-graphics-4.3.3/src/gle/gle.cpp
===================================================================
--- gle-graphics-4.3.3.orig/src/gle/gle.cpp
+++ gle-graphics-4.3.3/src/gle/gle.cpp
@@ -87,7 +87,7 @@ ConfigCollection g_Config;
 void load_one_file(const char* name, CmdLineObj& cmdline, size_t* exit_code);
 void load_one_file_stdin(CmdLineObj& cmdline, size_t* exit_code);
 void init_option_args(CmdLineObj& cmdline);
-void do_gen_inittex(CmdLineObj& cmdline, GLEOptions& options) throw(ParserError);
+void do_gen_inittex(CmdLineObj& cmdline, GLEOptions& options);
 void process_option_args(CmdLineObj& cmdline, GLEOptions& options);
 void do_run_other_version(ConfigCollection& coll, int argc, char **argv);
 void gle_do_socket(const string& commands);
@@ -325,7 +325,7 @@ void do_show_info() {
 	do_wait_for_enter_exit(0);
 }
 
-void do_gen_inittex(CmdLineObj& cmdline, GLEOptions& options) throw(ParserError) {
+void do_gen_inittex(CmdLineObj& cmdline, GLEOptions& options) {
 	// Generate inittex.ini from init.tex
 	if (cmdline.hasOption(GLE_OPT_MKINITTEX)) {
 		IS_INSTALL = 1;
@@ -704,7 +704,7 @@ void get_out_name(GLEFileLocation* innam
 	}
 }
 
-GLERC<GLEScript> load_gle_code_sub(const char* name, CmdLineObj& cmdline) throw(ParserError) {
+GLERC<GLEScript> load_gle_code_sub(const char* name, CmdLineObj& cmdline) {
 	string in_name = name;
 	GLERC<GLEScript> script = new GLEScript();
 	GLEFileLocation* loc = script->getLocation();
@@ -713,7 +713,7 @@ GLERC<GLEScript> load_gle_code_sub(const
 	return script;
 }
 
-GLERC<GLEScript> load_gle_code_sub_stdin(CmdLineObj& cmdline) throw(ParserError) {
+GLERC<GLEScript> load_gle_code_sub_stdin(CmdLineObj& cmdline) {
 	GLERC<GLEScript> script = new GLEScript();
 	GLEFileLocation* loc = script->getLocation();
 	loc->createStdin();
@@ -740,7 +740,7 @@ void delete_temp_file(const string& file
 	}
 }
 
-void writeRecordedOutputFile(const string& fname, int deviceCode, string* buffer) throw (ParserError) {
+void writeRecordedOutputFile(const string& fname, int deviceCode, string* buffer) {
 	string outf = fname;
 	outf.append(g_device_to_ext(deviceCode));
 	ofstream out(outf.c_str(), ios::out | ios::binary);
@@ -751,7 +751,7 @@ void writeRecordedOutputFile(const strin
 	out.close();
 }
 
-void writeRecordedOutputFile(const string& fname, int deviceCode, GLEScript* script) throw (ParserError) {
+void writeRecordedOutputFile(const string& fname, int deviceCode, GLEScript* script) {
 	string* buffer = script->getRecordedBytesBuffer(deviceCode);
 	writeRecordedOutputFile(fname, deviceCode, buffer);
 }
@@ -774,13 +774,13 @@ public:
 	~GLELoadOneFileManager();
 	void update_bounding_box();
 	void delete_previous_output(int deviceCode);
-	void create_cairo_eps() throw(ParserError);
-	bool process_one_file_tex() throw(ParserError);
+	void create_cairo_eps();
+	bool process_one_file_tex();
 	void do_output_type(const char* type);
 	void cat_stdout(const char* ext);
 	void cat_stdout_and_del(const char* ext);
-	void create_latex_eps_ps_pdf() throw(ParserError);
-	void convert_eps_to_pdf_no_latex() throw(ParserError);
+	void create_latex_eps_ps_pdf();
+	void convert_eps_to_pdf_no_latex();
 	istream* get_eps_stream();
 	bool hasGenerated(int deviceCode);
 	bool hasFile(int deviceCode);
@@ -788,7 +788,7 @@ public:
 	void setHasGenerated(int deviceCode, bool value);
 	void setHasFile(int deviceCode, bool value);
 	void setHasIncFile(int deviceCode, bool value);
-	void write_recorded_data(int deviceCode) throw(ParserError);
+	void write_recorded_data(int deviceCode);
 	void clean_tex_temp_files();
 	void clean_inc_file(int deviceCode);
 	void delete_original_eps_pdf();
@@ -830,7 +830,7 @@ void GLELoadOneFileManager::delete_previ
 	}
 }
 
-void GLELoadOneFileManager::create_cairo_eps() throw(ParserError) {
+void GLELoadOneFileManager::create_cairo_eps() {
 	CmdLineArgSet* device = (CmdLineArgSet*)m_CmdLine->getOption(GLE_OPT_DEVICE)->getArg(0);
 	if (!hasGenerated(GLE_DEVICE_EPS) && device->hasValue(GLE_DEVICE_EPS)) {
 		setHasGenerated(GLE_DEVICE_EPS, true);
@@ -844,7 +844,7 @@ void GLELoadOneFileManager::create_cairo
 	}
 }
 
-bool GLELoadOneFileManager::process_one_file_tex() throw(ParserError) {
+bool GLELoadOneFileManager::process_one_file_tex() {
 	CmdLineArgSet* device = (CmdLineArgSet*)m_CmdLine->getOption(GLE_OPT_DEVICE)->getArg(0);
 	delete_previous_output(GLE_DEVICE_EPS);
 	delete_previous_output(GLE_DEVICE_PDF);
@@ -949,7 +949,7 @@ void GLELoadOneFileManager::cat_stdout_a
 	delete_temp_file(m_OutName->getFullPath(), ext);
 }
 
-void GLELoadOneFileManager::convert_eps_to_pdf_no_latex() throw(ParserError) {
+void GLELoadOneFileManager::convert_eps_to_pdf_no_latex() {
 	CmdLineArgSet* device = (CmdLineArgSet*)m_CmdLine->getOption(GLE_OPT_DEVICE)->getArg(0);
 	if (device->hasValue(GLE_DEVICE_PDF) && !hasGenerated(GLE_DEVICE_PDF)) {
 		setHasFile(GLE_DEVICE_PDF, true);
@@ -991,7 +991,7 @@ bool GLELoadOneFileManager::requires_tex
 	return false;
 }
 
-void GLELoadOneFileManager::create_latex_eps_ps_pdf() throw(ParserError) {
+void GLELoadOneFileManager::create_latex_eps_ps_pdf() {
 	/* m_OutName has no path and no extension */
 	m_IncName.fromAbsolutePath(m_OutName->getFullPath() + "_inc");
 	/* includegraphics does not handle "." in filenames */
@@ -1090,7 +1090,7 @@ void GLELoadOneFileManager::setHasIncFil
 	}
 }
 
-void GLELoadOneFileManager::write_recorded_data(int deviceCode) throw (ParserError) {
+void GLELoadOneFileManager::write_recorded_data(int deviceCode) {
 	CmdLineArgSet* device = (CmdLineArgSet*)m_CmdLine->getOption(GLE_OPT_DEVICE)->getArg(0);
 	if (!device->hasValue(deviceCode)) {
 		return;
@@ -1171,7 +1171,7 @@ void complain_latex_not_supported(int de
 	}
 }
 
-void load_one_file_sub(GLEScript* script, CmdLineObj& cmdline, size_t* exit_code) throw(ParserError) {
+void load_one_file_sub(GLEScript* script, CmdLineObj& cmdline, size_t* exit_code) {
 	GLEFileLocation out_name; /* out_name has no extension */
 	GLEGetInterfacePointer()->getConfig()->setAllowConfigBlocks(false);
 	GLEChDir(script->getLocation()->getDirectory());
Index: gle-graphics-4.3.3/src/gle/gle-interface.cpp
===================================================================
--- gle-graphics-4.3.3.orig/src/gle/gle-interface.cpp
+++ gle-graphics-4.3.3/src/gle/gle-interface.cpp
@@ -69,8 +69,8 @@ extern string GLE_WORKING_DIR;
 extern string GLE_TOP_DIR;
 
 void init_option_args(CmdLineObj& cmdline);
-void load_one_file_sub(GLEScript* script, CmdLineObj& cmdline, size_t* exit_code) throw(ParserError);
-GLERC<GLEScript> load_gle_code_sub(const char* name, CmdLineObj& cmdline) throw(ParserError);
+void load_one_file_sub(GLEScript* script, CmdLineObj& cmdline, size_t* exit_code);
+GLERC<GLEScript> load_gle_code_sub(const char* name, CmdLineObj& cmdline);
 
 void GLEScaleSimpleLineProperties(double scale, bool dir, GLEPropertyStore* prop);
 void GLEScaleArrowProperties(double scale, bool dir, GLEPropertyStore* prop);
@@ -1065,7 +1065,7 @@ GLEScript* GLEObjectDOConstructor::getSc
 }
 
 void output_error(ParserError& err);
-void eval(GLEArrayImpl* stk, GLEPcodeList* pclist, int *pcode, int *cp, double *oval, GLEString **ostr, int *otyp) throw(ParserError);
+void eval(GLEArrayImpl* stk, GLEPcodeList* pclist, int *pcode, int *cp, double *oval, GLEString **ostr, int *otyp);
 
 GLEObjectDO* GLEObjectDOConstructor::constructObject() {
 	GLEObjectDO* obj = new GLEObjectDO(this);
Index: gle-graphics-4.3.3/src/gle/gle-sourcefile.cpp
===================================================================
--- gle-graphics-4.3.3.orig/src/gle/gle-sourcefile.cpp
+++ gle-graphics-4.3.3/src/gle/gle-sourcefile.cpp
@@ -235,7 +235,7 @@ void GLESourceFile::load(istream& input)
 	}
 }
 
-void GLESourceFile::load() throw(ParserError) {
+void GLESourceFile::load() {
 	// called to load the main script or an include file
 	if (getLocation()->isStdin()) {
 		load(cin);
@@ -374,7 +374,7 @@ void GLEGlobalSource::sourceLineFileAndN
 	}
 }
 
-void GLEGlobalSource::load() throw(ParserError) {
+void GLEGlobalSource::load() {
 	GLESourceFile* main = getMainFile();
 	main->load();
 	main->trim(0);
