Index: doc/papers/general/Paper.tex =================================================================== --- doc/papers/general/Paper.tex (revision d8548e26dec392bef45acc8a5f8a4baea00c9257) +++ doc/papers/general/Paper.tex (revision 566b74f30cbffd7534d18835ce6998cc9baef525) @@ -117,5 +117,5 @@ _Alignas, _Alignof, __alignof, __alignof__, asm, __asm, __asm__, _At, __attribute, __attribute__, auto, _Bool, catch, catchResume, choose, _Complex, __complex, __complex__, - __const, __const__, disable, dtype, enable, __extension__, fallthrough, fallthru, + __const, __const__, disable, dtype, enable, exception, __extension__, fallthrough, fallthru, finally, forall, ftype, _Generic, _Imaginary, inline, __label__, lvalue, _Noreturn, one_t, otype, restrict, _Static_assert, throw, throwResume, trait, try, ttype, typeof, __typeof, @@ -260,5 +260,5 @@ \Celeven did add @_Generic@ expressions, which can be used in preprocessor macros to provide a form of ad-hoc polymorphism; however, this polymorphism is both functionally and ergonomically inferior to \CFA name overloading. The macro wrapping the generic expression imposes some limitations; as an example, it could not implement the example above, because the variables @max@ would collide with the functions @max@. -Ergonomic limitations of @_Generic@ include the necessity to put a fixed list of supported types in a single place and manually dispatch to appropriate overloads, as well as possible namespace pollution from the functions dispatched to, which must all have distinct names. +Ergonomic limitations of @_Generic@ include the necessity to put a fixed list of supported types in a single place and manually dispatch to appropriate overloads, as well as possible namespace pollution from the functions dispatched to, which must all have distinct names. Though name-overloading removes a major use-case for @_Generic@ expressions, \CFA does implement @_Generic@ for backwards-compatibility purposes. \TODO{actually implement that} @@ -1357,10 +1357,11 @@ \subsection{Exception Handling} -\CFA provides two forms of exception handling: \newterm{resumption} (fix-up) and \newterm{recovery} (see Figure~\ref{f:CFAExceptionHandling}). +The following framework for \CFA exception handling is in place, excluding a run-time type information and dynamic casts. +\CFA provides two forms of exception handling: \newterm{fix-up} and \newterm{recovery} (see Figure~\ref{f:CFAExceptionHandling}). Both mechanisms provide dynamic call to a handler using dynamic name-lookup, where fix-up has dynamic return and recovery has static return from the handler. -\CFA restricts exception types to those defined by aggregate type @_Exception@. +\CFA restricts exception types to those defined by aggregate type @exception@. The form of the raise dictates the set of handlers examined during propagation: \newterm{resumption propagation} (@resume@) only examines resumption handlers (@catchResume@); \newterm{terminating propagation} (@throw@) only examines termination handlers (@catch@). If @resume@ or @throw@ have no exception type, it is a reresume/rethrow, meaning the currently exception continues propagation. -If there is no current exception, the reresume/rethrow results in an error. +If there is no current exception, the reresume/rethrow results in a runtime error. \begin{figure} @@ -1370,9 +1371,10 @@ \multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{Resumption}} & \multicolumn{1}{c}{\textbf{Recovery}} \\ \begin{cfa} -`_Exception R { int fix; };` +`exception R { int fix; };` void f() { R r; ... `resume( r );` ... ... r.fix // control does return here after handler +} `try` { ... f(); ... @@ -1383,9 +1385,10 @@ & \begin{cfa} -`_Exception T {};` +`exception T {};` void f() { ... `throw( T{} );` ... // control does NOT return here after handler +} `try` { ... f(); ... @@ -1420,6 +1423,6 @@ ... write( `datafile`, ... ); ... $\C{// may throw IOError}$ ... write( `logfile`, ... ); ... -} catch ( IOError err; `err == datafile` ) { ... } $\C{// handle datafile error}$ - catch ( IOError err; `err == logfile` ) { ... } $\C{// handle logfile error}$ +} catch ( IOError err; `err.file == datafile` ) { ... } $\C{// handle datafile error}$ + catch ( IOError err; `err.file == logfile` ) { ... } $\C{// handle logfile error}$ catch ( IOError err ) { ... } $\C{// handler error from other files}$ \end{cfa} @@ -1429,7 +1432,8 @@ The resumption raise can specify an alternate stack on which to raise an exception, called a \newterm{nonlocal raise}: \begin{cfa} -resume [ $\emph{exception-type}$ ] [ _At $\emph{alternate-stack}$ ] ; -\end{cfa} -The @_At@ clause raises the specified exception or the currently propagating exception (reresume) at another coroutine or task~\cite{Delisle18}. +resume( $\emph{exception-type}$, $\emph{alternate-stack}$ ) +resume( $\emph{alternate-stack}$ ) +\end{cfa} +These overloads of @resume@ raise the specified exception or the currently propagating exception (reresume) at another coroutine or task~\cite{Delisle18}. Nonlocal raise is restricted to resumption to provide the exception handler the greatest flexibility because processing the exception does not unwind its stack, allowing it to continue after the handle returns. @@ -1622,5 +1626,5 @@ \lstMakeShortInline@% \end{cquote} -Specifiers must appear at the start of a \CFA routine declaration\footnote{\label{StorageClassSpecifier}. +Specifiers must appear at the start of a \CFA routine declaration\footnote{\label{StorageClassSpecifier} The placement of a storage-class specifier other than at the beginning of the declaration specifiers in a declaration is an obsolescent feature.~\cite[\S~6.11.5(1)]{C11}}. @@ -1677,5 +1681,5 @@ * [ * int, int ] ( int ) jp; $\C{// pointer to routine returning pointer to int and int, with int parameter}$ \end{cfa} -Note, \emph{a routine name cannot be specified}: +Note, a routine name cannot be specified: \begin{cfa} * [ int x ] f () fp; $\C{// routine name "f" is disallowed}$ @@ -1994,4 +1998,5 @@ The addition of @one_t@ allows generic algorithms to handle the unit value uniformly for types where that is meaningful. \TODO{Make this sentence true} In particular, polymorphic functions in the \CFA prelude define @++x@ and @x++@ in terms of @x += 1@, allowing users to idiomatically define all forms of increment for a type @T@ by defining the single function @T & ?+=(T &, one_t)@; analogous overloads for the decrement operators are present as well. + \subsection{Integral Suffixes} @@ -2614,5 +2619,5 @@ \section{Acknowledgments} -The authors would like to recognize the design assistance of Glen Ditchfield, Richard Bilson, and Thierry Delisle on the features described in this paper, and thank Magnus Madsen and the three anonymous reviewers for valuable feedback. +The authors would like to recognize the design assistance of Glen Ditchfield, Richard Bilson, and Thierry Delisle on the features described in this paper, and thank Magnus Madsen for feedback in the writing. %This work is supported in part by a corporate partnership with \grantsponsor{Huawei}{Huawei Ltd.}{http://www.huawei.com}, and Aaron Moss and Peter Buhr are funded by the \grantsponsor{Natural Sciences and Engineering Research Council} of Canada. % the first author's \grantsponsor{NSERC-PGS}{NSERC PGS D}{http://www.nserc-crsng.gc.ca/Students-Etudiants/PG-CS/BellandPostgrad-BelletSuperieures_eng.asp} scholarship. Index: src/Parser/DeclarationNode.cc =================================================================== --- src/Parser/DeclarationNode.cc (revision d8548e26dec392bef45acc8a5f8a4baea00c9257) +++ src/Parser/DeclarationNode.cc (revision 566b74f30cbffd7534d18835ce6998cc9baef525) @@ -10,6 +10,6 @@ // Created On : Sat May 16 12:34:05 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon Nov 20 09:21:52 2017 -// Update Count : 1031 +// Last Modified On : Thu Feb 22 15:37:17 2018 +// Update Count : 1033 // @@ -120,8 +120,4 @@ } // DeclarationNode::clone -bool DeclarationNode::get_hasEllipsis() const { - return hasEllipsis; -} - void DeclarationNode::print( std::ostream &os, int indent ) const { os << string( indent, ' ' ); @@ -167,10 +163,9 @@ } -DeclarationNode * DeclarationNode::newFunction( string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body, bool newStyle ) { +DeclarationNode * DeclarationNode::newFunction( string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body ) { DeclarationNode * newnode = new DeclarationNode; newnode->name = name; newnode->type = new TypeData( TypeData::Function ); newnode->type->function.params = param; - newnode->type->function.newStyle = newStyle; newnode->type->function.body = body; Index: src/Parser/ParseNode.h =================================================================== --- src/Parser/ParseNode.h (revision d8548e26dec392bef45acc8a5f8a4baea00c9257) +++ src/Parser/ParseNode.h (revision 566b74f30cbffd7534d18835ce6998cc9baef525) @@ -10,6 +10,6 @@ // Created On : Sat May 16 13:28:16 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon Nov 27 17:33:35 2017 -// Update Count : 824 +// Last Modified On : Thu Feb 22 17:49:31 2018 +// Update Count : 827 // @@ -209,5 +209,5 @@ enum Length { Short, Long, LongLong, NoLength }; static const char * lengthNames[]; - enum Aggregate { Struct, Union, Trait, Coroutine, Monitor, Thread, NoAggregate }; + enum Aggregate { Struct, Union, Exception, Trait, Coroutine, Monitor, Thread, NoAggregate }; static const char * aggregateNames[]; enum TypeClass { Otype, Dtype, Ftype, Ttype, NoTypeClass }; @@ -226,5 +226,5 @@ static DeclarationNode * newForall( DeclarationNode * ); static DeclarationNode * newFromTypedef( std::string * ); - static DeclarationNode * newFunction( std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body, bool newStyle = false ); + static DeclarationNode * newFunction( std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body ); static DeclarationNode * newAggregate( Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body ); static DeclarationNode * newEnum( std::string * name, DeclarationNode * constants, bool body ); @@ -288,5 +288,4 @@ Type * buildType() const; - bool get_hasEllipsis() const; LinkageSpec::Spec get_linkage() const { return linkage; } DeclarationNode * extractAggregate() const; Index: src/Parser/TypeData.cc =================================================================== --- src/Parser/TypeData.cc (revision d8548e26dec392bef45acc8a5f8a4baea00c9257) +++ src/Parser/TypeData.cc (revision 566b74f30cbffd7534d18835ce6998cc9baef525) @@ -10,6 +10,6 @@ // Created On : Sat May 16 15:12:51 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon Sep 25 18:33:41 2017 -// Update Count : 587 +// Last Modified On : Thu Feb 22 15:49:00 2018 +// Update Count : 597 // @@ -54,5 +54,4 @@ function.oldDeclList = nullptr; function.body = nullptr; - function.newStyle = false; function.withExprs = nullptr; break; @@ -195,5 +194,4 @@ newtype->function.oldDeclList = maybeClone( function.oldDeclList ); newtype->function.body = maybeClone( function.body ); - newtype->function.newStyle = function.newStyle; newtype->function.withExprs = maybeClone( function.withExprs ); break; @@ -881,7 +879,5 @@ FunctionType * buildFunction( const TypeData * td ) { assert( td->kind == TypeData::Function ); - bool hasEllipsis = td->function.params ? td->function.params->get_hasEllipsis() : true; - if ( ! td->function.params ) hasEllipsis = ! td->function.newStyle; - FunctionType * ft = new FunctionType( buildQualifiers( td ), hasEllipsis ); + FunctionType * ft = new FunctionType( buildQualifiers( td ), ! td->function.params || td->function.params->hasEllipsis ); buildList( td->function.params, ft->get_parameters() ); buildForall( td->forall, ft->get_forall() ); Index: src/Parser/TypeData.h =================================================================== --- src/Parser/TypeData.h (revision d8548e26dec392bef45acc8a5f8a4baea00c9257) +++ src/Parser/TypeData.h (revision 566b74f30cbffd7534d18835ce6998cc9baef525) @@ -10,6 +10,6 @@ // Created On : Sat May 16 15:18:36 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Fri Sep 1 23:33:45 2017 -// Update Count : 190 +// Last Modified On : Thu Feb 22 15:21:23 2018 +// Update Count : 191 // @@ -64,5 +64,4 @@ mutable DeclarationNode * oldDeclList; StatementNode * body; - bool newStyle; ExpressionNode * withExprs; // expressions from function's with_clause }; Index: src/Parser/lex.ll =================================================================== --- src/Parser/lex.ll (revision d8548e26dec392bef45acc8a5f8a4baea00c9257) +++ src/Parser/lex.ll (revision 566b74f30cbffd7534d18835ce6998cc9baef525) @@ -10,6 +10,6 @@ * Created On : Sat Sep 22 08:58:10 2001 * Last Modified By : Peter A. Buhr - * Last Modified On : Wed Oct 25 13:53:56 2017 - * Update Count : 634 + * Last Modified On : Thu Feb 22 18:11:27 2018 + * Update Count : 637 */ @@ -232,4 +232,5 @@ enum { KEYWORD_RETURN(ENUM); } __extension__ { KEYWORD_RETURN(EXTENSION); } // GCC +exception { KEYWORD_RETURN(EXCEPTION); } // CFA extern { KEYWORD_RETURN(EXTERN); } fallthru { KEYWORD_RETURN(FALLTHRU); } // CFA Index: src/Parser/parser.yy =================================================================== --- src/Parser/parser.yy (revision d8548e26dec392bef45acc8a5f8a4baea00c9257) +++ src/Parser/parser.yy (revision 566b74f30cbffd7534d18835ce6998cc9baef525) @@ -10,6 +10,6 @@ // Created On : Sat Sep 1 20:22:55 2001 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Feb 15 17:12:31 2018 -// Update Count : 3006 +// Last Modified On : Thu Feb 22 17:48:54 2018 +// Update Count : 3028 // @@ -187,4 +187,5 @@ %token TYPEOF LABEL // GCC %token ENUM STRUCT UNION +%token EXCEPTION // CFA %token COROUTINE MONITOR THREAD // CFA %token OTYPE FTYPE DTYPE TTYPE TRAIT // CFA @@ -314,5 +315,5 @@ %type cfa_identifier_parameter_declarator_tuple cfa_identifier_parameter_ptr -%type cfa_parameter_declaration cfa_parameter_list cfa_parameter_type_list cfa_parameter_type_list_opt +%type cfa_parameter_declaration cfa_parameter_list cfa_parameter_type_list_opt %type cfa_typedef_declaration cfa_variable_declaration cfa_variable_specifier @@ -322,6 +323,5 @@ %type KR_declaration_list KR_declaration_list_opt -%type parameter_declaration parameter_list parameter_type_list -%type parameter_type_list_opt +%type parameter_declaration parameter_list parameter_type_list_opt %type paren_identifier paren_type @@ -779,6 +779,6 @@ | unary_expression assignment_operator assignment_expression { $$ = new ExpressionNode( build_binary_val( $2, $1, $3 ) ); } - | unary_expression '=' '{' initializer_list comma_opt '}' // FIX ME - { $$ = nullptr; } + | unary_expression '=' '{' initializer_list comma_opt '}' + { throw SemanticError( yylloc, "Initializer assignment is currently unimplemented." ); $$ = nullptr; } // FIX ME ; @@ -849,4 +849,6 @@ | waitfor_statement | exception_statement + | enable_disable_statement + { throw SemanticError( yylloc, "enable/disable statement is currently unimplemented." ); $$ = nullptr; } // FIX ME | asm_statement ; @@ -1064,6 +1066,6 @@ | RETURN comma_expression_opt ';' { $$ = new StatementNode( build_return( $2 ) ); } - | RETURN '{' initializer_list comma_opt '}' // FIX ME - { $$ = nullptr; } + | RETURN '{' initializer_list comma_opt '}' + { throw SemanticError( yylloc, "Initializer return is currently unimplemented." ); $$ = nullptr; } // FIX ME | THROW assignment_expression_opt ';' // handles rethrow { $$ = new StatementNode( build_throw( $2 ) ); } @@ -1193,4 +1195,13 @@ ; +enable_disable_statement: + enable_disable_key identifier_list compound_statement + ; + +enable_disable_key: + ENABLE + | DISABLE + ; + asm_statement: ASM asm_volatile_opt '(' string_literal ')' ';' @@ -1392,5 +1403,5 @@ DeclarationNode * ret = new DeclarationNode; ret->type = maybeClone( $1->type->base ); - $$ = $1->appendList( DeclarationNode::newFunction( $5, ret, $8, nullptr, true ) ); + $$ = $1->appendList( DeclarationNode::newFunction( $5, ret, $8, nullptr ) ); } ; @@ -1422,9 +1433,9 @@ // To obtain LR(1 ), this rule must be factored out from function return type (see cfa_abstract_declarator). { - $$ = DeclarationNode::newFunction( $2, $1, $5, 0, true ); + $$ = DeclarationNode::newFunction( $2, $1, $5, 0 ); } | cfa_function_return identifier_or_type_name '(' push cfa_parameter_type_list_opt pop ')' { - $$ = DeclarationNode::newFunction( $2, $1, $5, 0, true ); + $$ = DeclarationNode::newFunction( $2, $1, $5, 0 ); } ; @@ -1881,4 +1892,6 @@ | UNION { $$ = DeclarationNode::Union; } + | EXCEPTION + { $$ = DeclarationNode::Exception; } | COROUTINE { $$ = DeclarationNode::Coroutine; } @@ -1990,14 +2003,10 @@ ; -// Minimum of one parameter after which ellipsis is allowed only at the end. - -cfa_parameter_type_list_opt: // CFA +cfa_parameter_type_list_opt: // CFA, abstract + real // empty + { $$ = DeclarationNode::newBasicType( DeclarationNode::Void ); } + | ELLIPSIS { $$ = nullptr; } - | cfa_parameter_type_list - ; - -cfa_parameter_type_list: // CFA, abstract + real - cfa_abstract_parameter_list + | cfa_abstract_parameter_list | cfa_parameter_list | cfa_parameter_list pop ',' push cfa_abstract_parameter_list @@ -2030,9 +2039,7 @@ // empty { $$ = nullptr; } - | parameter_type_list - ; - -parameter_type_list: - parameter_list + | ELLIPSIS + { $$ = nullptr; } + | parameter_list | parameter_list pop ',' push ELLIPSIS { $$ = $1->addVarArgs(); } Index: src/libcfa/exception.c =================================================================== --- src/libcfa/exception.c (revision d8548e26dec392bef45acc8a5f8a4baea00c9257) +++ src/libcfa/exception.c (revision 566b74f30cbffd7534d18835ce6998cc9baef525) @@ -10,6 +10,6 @@ // Created On : Mon Jun 26 15:13:00 2017 // Last Modified By : Peter A. Buhr -// Last Modified On : Fri Feb 9 14:41:55 2018 -// Update Count : 8 +// Last Modified On : Thu Feb 22 18:17:34 2018 +// Update Count : 11 // @@ -52,5 +52,5 @@ struct __cfaabi_ehm__try_resume_node * current_resume; - exception * current_exception; + exception_t * current_exception; int current_handler_index; } shared_stack = {NULL, NULL, 0, 0}; @@ -71,12 +71,12 @@ // This macro should be the only thing that needs to change across machines. Used in the personality function, way down // in termination. -// struct _Unwind_Context * -> _Unwind_Reason_Code(*)(exception *) +// struct _Unwind_Context * -> _Unwind_Reason_Code(*)(exception_t *) #define MATCHER_FROM_CONTEXT(ptr_to_context) \ - (*(_Unwind_Reason_Code(**)(exception*))(_Unwind_GetCFA(ptr_to_context) + 8)) + (*(_Unwind_Reason_Code(**)(exception_t *))(_Unwind_GetCFA(ptr_to_context) + 8)) // RESUMPTION ================================================================ -void __cfaabi_ehm__throw_resume(exception * except) { +void __cfaabi_ehm__throw_resume(exception_t * except) { __cfaabi_dbg_print_safe("Throwing resumption exception\n"); @@ -106,5 +106,5 @@ void __cfaabi_ehm__try_resume_setup(struct __cfaabi_ehm__try_resume_node * node, - _Bool (*handler)(exception * except)) { + _Bool (*handler)(exception_t * except)) { node->next = shared_stack.top_resume; node->handler = handler; @@ -126,9 +126,9 @@ }; -#define NODE_TO_EXCEPT(node) ((exception *)(1 + (node))) +#define NODE_TO_EXCEPT(node) ((exception_t *)(1 + (node))) #define EXCEPT_TO_NODE(except) ((struct __cfaabi_ehm__node *)(except) - 1) // Creates a copy of the indicated exception and sets current_exception to it. -static void __cfaabi_ehm__allocate_exception( exception * except ) { +static void __cfaabi_ehm__allocate_exception( exception_t * except ) { struct exception_context_t * context = this_exception_context(); @@ -151,5 +151,5 @@ // Delete the provided exception, unsetting current_exception if relivant. -static void __cfaabi_ehm__delete_exception( exception * except ) { +static void __cfaabi_ehm__delete_exception( exception_t * except ) { struct exception_context_t * context = this_exception_context(); @@ -179,5 +179,5 @@ // If this isn't a rethrow (*except==0), delete the provided exception. void __cfaabi_ehm__cleanup_terminate( void * except ) { - if ( *(void**)except ) __cfaabi_ehm__delete_exception( *(exception**)except ); + if ( *(void**)except ) __cfaabi_ehm__delete_exception( *(exception_t **)except ); } @@ -233,5 +233,5 @@ } -void __cfaabi_ehm__throw_terminate( exception * val ) { +void __cfaabi_ehm__throw_terminate( exception_t * val ) { __cfaabi_dbg_print_safe("Throwing termination exception\n"); @@ -348,5 +348,5 @@ // _Unwind_Reason_Code (*matcher)() = (_Unwind_Reason_Code (*)())lsd_info.LPStart + imatcher; - _Unwind_Reason_Code (*matcher)(exception *) = + _Unwind_Reason_Code (*matcher)(exception_t *) = MATCHER_FROM_CONTEXT(context); int index = matcher(shared_stack.current_exception); @@ -409,6 +409,6 @@ __attribute__((noinline)) void __cfaabi_ehm__try_terminate(void (*try_block)(), - void (*catch_block)(int index, exception * except), - __attribute__((unused)) int (*match_block)(exception * except)) { + void (*catch_block)(int index, exception_t * except), + __attribute__((unused)) int (*match_block)(exception_t * except)) { //! volatile int xy = 0; //! printf("%p %p %p %p\n", &try_block, &catch_block, &match_block, &xy); Index: src/libcfa/exception.h =================================================================== --- src/libcfa/exception.h (revision d8548e26dec392bef45acc8a5f8a4baea00c9257) +++ src/libcfa/exception.h (revision 566b74f30cbffd7534d18835ce6998cc9baef525) @@ -9,7 +9,7 @@ // Author : Andrew Beach // Created On : Mon Jun 26 15:11:00 2017 -// Last Modified By : Andrew Beach -// Last Modified On : Thr Aug 17 15:44:00 2017 -// Update Count : 6 +// Last Modified By : Peter A. Buhr +// Last Modified On : Thu Feb 22 18:11:15 2018 +// Update Count : 8 // @@ -22,5 +22,5 @@ struct __cfaabi_ehm__base_exception_t; -typedef struct __cfaabi_ehm__base_exception_t exception; +typedef struct __cfaabi_ehm__base_exception_t exception_t; struct __cfaabi_ehm__base_exception_t_vtable { const struct __cfaabi_ehm__base_exception_t_vtable * parent; @@ -39,13 +39,13 @@ // Used in throw statement translation. -void __cfaabi_ehm__throw_terminate(exception * except) __attribute__((noreturn)); +void __cfaabi_ehm__throw_terminate(exception_t * except) __attribute__((noreturn)); void __cfaabi_ehm__rethrow_terminate() __attribute__((noreturn)); -void __cfaabi_ehm__throw_resume(exception * except); +void __cfaabi_ehm__throw_resume(exception_t * except); // Function catches termination exceptions. void __cfaabi_ehm__try_terminate( void (*try_block)(), - void (*catch_block)(int index, exception * except), - int (*match_block)(exception * except)); + void (*catch_block)(int index, exception_t * except), + int (*match_block)(exception_t * except)); // Clean-up the exception in catch blocks. @@ -55,5 +55,5 @@ struct __cfaabi_ehm__try_resume_node { struct __cfaabi_ehm__try_resume_node * next; - _Bool (*handler)(exception * except); + _Bool (*handler)(exception_t * except); }; @@ -61,5 +61,5 @@ void __cfaabi_ehm__try_resume_setup( struct __cfaabi_ehm__try_resume_node * node, - _Bool (*handler)(exception * except)); + _Bool (*handler)(exception_t * except)); void __cfaabi_ehm__try_resume_cleanup( struct __cfaabi_ehm__try_resume_node * node); Index: src/libcfa/stdhdr/math.h =================================================================== --- src/libcfa/stdhdr/math.h (revision d8548e26dec392bef45acc8a5f8a4baea00c9257) +++ src/libcfa/stdhdr/math.h (revision 566b74f30cbffd7534d18835ce6998cc9baef525) @@ -10,10 +10,20 @@ // Created On : Mon Jul 4 23:25:26 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Tue Jul 5 20:38:18 2016 -// Update Count : 12 +// Last Modified On : Thu Feb 22 18:16:07 2018 +// Update Count : 13 // extern "C" { +#if ! defined( exception ) // nesting ? +#define exception `exception` // make keyword an identifier +#define __CFA_MATH_H__ +#endif + #include_next // has internal check for multiple expansion + +#if defined( exception ) && defined( __CFA_MATH_H__ ) // reset only if set +#undef exception +#undef __CFA_MATH_H__ +#endif } // extern "C"