Changes in / [45c43e5:17fc7a5]


Ignore:
Files:
3 deleted
24 edited

Legend:

Unmodified
Added
Removed

  • doc/papers/general/Paper.tex

    r45c43e5 r17fc7a5  
    4141
    4242\newcommand{\Textbf}[2][red]{{\color{#1}{\textbf{#2}}}}
    43 %\newcommand{\TODO}[1]{\textbf{TODO}: {\itshape #1}} % TODO included
    44 \newcommand{\TODO}[1]{} % TODO elided
     43\newcommand{\TODO}[1]{\textbf{TODO}: {\itshape #1}} % TODO included
     44%\newcommand{\TODO}[1]{} % TODO elided
    4545
    4646% Default underscore is too low and wide. Cannot use lstlisting "literate" as replacing underscore
    … …  
    117117                _Alignas, _Alignof, __alignof, __alignof__, asm, __asm, __asm__, _At, __attribute,
    118118                __attribute__, auto, _Bool, catch, catchResume, choose, _Complex, __complex, __complex__,
    119                 __const, __const__, disable, dtype, enable, exception, __extension__, fallthrough, fallthru,
     119                __const, __const__, disable, dtype, enable, __extension__, fallthrough, fallthru,
    120120                finally, forall, ftype, _Generic, _Imaginary, inline, __label__, lvalue, _Noreturn, one_t,
    121121                otype, restrict, _Static_assert, throw, throwResume, trait, try, ttype, typeof, __typeof,
    … …  
    261261The 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@.
    262262Ergonomic 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.
    263 Though name-overloading removes a major use-case for @_Generic@ expressions, \CFA does implement @_Generic@ for backwards-compatibility purposes. \TODO{actually implement that}
    264263
    265264% http://fanf.livejournal.com/144696.html
    … …  
    13571356\subsection{Exception Handling}
    13581357
    1359 The following framework for \CFA exception handling is in place, excluding a run-time type information and dynamic casts.
    1360 \CFA provides two forms of exception handling: \newterm{fix-up} and \newterm{recovery} (see Figure~\ref{f:CFAExceptionHandling}).
     1358\CFA provides two forms of exception handling: \newterm{resumption} (fix-up) and \newterm{recovery} (see Figure~\ref{f:CFAExceptionHandling}).
    13611359Both 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.
    1362 \CFA restricts exception types to those defined by aggregate type @exception@.
     1360\CFA restricts exception types to those defined by aggregate type @_Exception@.
    13631361The 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@).
    13641362If @resume@ or @throw@ have no exception type, it is a reresume/rethrow, meaning the currently exception continues propagation.
    1365 If there is no current exception, the reresume/rethrow results in a runtime error.
     1363If there is no current exception, the reresume/rethrow results in an error.
    13661364
    13671365\begin{figure}
    … …  
    13711369\multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{Resumption}}       & \multicolumn{1}{c}{\textbf{Recovery}} \\
    13721370\begin{cfa}
    1373 `exception R { int fix; };`
     1371`_Exception R { int fix; };`
    13741372void f() {
    13751373        R r;
    13761374        ... `resume( r );` ...
    13771375        ... r.fix // control does return here after handler
    1378 }
    13791376`try` {
    13801377        ... f(); ...
    … …  
    13851382&
    13861383\begin{cfa}
    1387 `exception T {};`
     1384`_Exception T {};`
    13881385void f() {
    13891386
    13901387        ... `throw( T{} );` ...
    13911388        // control does NOT return here after handler
    1392 }
    13931389`try` {
    13941390        ... f(); ...
    … …  
    14231419        ... write( `datafile`, ... ); ...               $\C{// may throw IOError}$
    14241420        ... write( `logfile`, ... ); ...
    1425 } catch ( IOError err; `err.file == datafile` ) { ... } $\C{// handle datafile error}$
    1426    catch ( IOError err; `err.file == logfile` ) { ... } $\C{// handle logfile error}$
     1421} catch ( IOError err; `err == datafile` ) { ... } $\C{// handle datafile error}$
     1422   catch ( IOError err; `err == logfile` ) { ... } $\C{// handle logfile error}$
    14271423   catch ( IOError err ) { ... }                        $\C{// handler error from other files}$
    14281424\end{cfa}
    … …  
    14321428The resumption raise can specify an alternate stack on which to raise an exception, called a \newterm{nonlocal raise}:
    14331429\begin{cfa}
    1434 resume( $\emph{exception-type}$, $\emph{alternate-stack}$ )
    1435 resume( $\emph{alternate-stack}$ )
    1436 \end{cfa}
    1437 These overloads of @resume@ raise the specified exception or the currently propagating exception (reresume) at another coroutine or task~\cite{Delisle18}.
     1430resume [ $\emph{exception-type}$ ] [ _At $\emph{alternate-stack}$ ] ;
     1431\end{cfa}
     1432The @_At@ clause raises the specified exception or the currently propagating exception (reresume) at another coroutine or task~\cite{Delisle18}.
    14381433Nonlocal 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.
    14391434
    … …  
    16261621\lstMakeShortInline@%
    16271622\end{cquote}
    1628 Specifiers must appear at the start of a \CFA routine declaration\footnote{\label{StorageClassSpecifier}
     1623Specifiers must appear at the start of a \CFA routine declaration\footnote{\label{StorageClassSpecifier}.
    16291624The 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}}.
    16301625
    … …  
    16811676* [ * int, int ] ( int ) jp;                            $\C{// pointer to routine returning pointer to int and int, with int parameter}$
    16821677\end{cfa}
    1683 Note, a routine name cannot be specified:
     1678Note, \emph{a routine name cannot be specified}:
    16841679\begin{cfa}
    16851680* [ int x ] f () fp;                                            $\C{// routine name "f" is disallowed}$
    … …  
    19891984
    19901985In C, @0@ has the special property that it is the only ``false'' value; by the standard, any value which compares equal to @0@ is false, while any value that compares unequal to @0@ is true.
    1991 As such, an expression @x@ in any boolean context (such as the condition of an @if@ or @while@ statement, or the arguments to @&&@, @||@, or @?:@) can be rewritten as @x != 0@ without changing its semantics.
     1986As such, an expression @x@ in any boolean context (such as the condition of an @if@ or @while@ statement, or the arguments to an @&&@, @||@, or ternary operator) can be rewritten as @x != 0@ without changing its semantics.
    19921987The operator overloading feature of \CFA provides a natural means to implement this truth value comparison for arbitrary types, but the C type system is not precise enough to distinguish an equality comparison with @0@ from an equality comparison with an arbitrary integer or pointer.
    1993 To provide this precision, \CFA introduces a new type @zero_t@ as type type of literal @0@ (somewhat analagous to @nullptr_t@ and @nullptr@ in \CCeleven); @zero_t@ can only take the value @0@, but has implicit conversions to the integer and pointer types so that C code involving @0@ continues to work properly.
     1988To provide this precision, \CFA introduces a new type @zero_t@ as type type of literal @0@ (somewhat analagous to @nullptr_t@ and @nullptr@ in \CCeleven); @zero_t@ can only take the value @0@, but has implicit conversions to the integer and pointer types so that standard C code involving @0@ continues to work properly.
    19941989With this addition, the \CFA compiler rewrites @if (x)@ and similar expressions to @if ((x) != 0)@ or the appropriate analogue, and any type @T@ can be made ``truthy'' by defining an operator overload @int ?!=?(T, zero_t)@.
    19951990\CC makes types truthy by adding a conversion to @bool@; prior to the addition of explicit cast operators in \CCeleven this approach had the pitfall of making truthy types transitively convertable to any numeric type; our design for \CFA avoids this issue.
    … …  
    26192614\section{Acknowledgments}
    26202615
    2621 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.
     2616The 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.
    26222617%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.
    26232618% 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.

  • src/Parser/DeclarationNode.cc

    r45c43e5 r17fc7a5  
    1010// Created On       : Sat May 16 12:34:05 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Feb 22 15:37:17 2018
    13 // Update Count     : 1033
     12// Last Modified On : Mon Nov 20 09:21:52 2017
     13// Update Count     : 1031
    1414//
    1515
    … …  
    120120} // DeclarationNode::clone
    121121
     122bool DeclarationNode::get_hasEllipsis() const {
     123        return hasEllipsis;
     124}
     125
    122126void DeclarationNode::print( std::ostream &os, int indent ) const {
    123127        os << string( indent, ' ' );
    … …  
    163167}
    164168
    165 DeclarationNode * DeclarationNode::newFunction( string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body ) {
     169DeclarationNode * DeclarationNode::newFunction( string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body, bool newStyle ) {
    166170        DeclarationNode * newnode = new DeclarationNode;
    167171        newnode->name = name;
    168172        newnode->type = new TypeData( TypeData::Function );
    169173        newnode->type->function.params = param;
     174        newnode->type->function.newStyle = newStyle;
    170175        newnode->type->function.body = body;
    171176

  • src/Parser/ParseNode.h

    r45c43e5 r17fc7a5  
    1010// Created On       : Sat May 16 13:28:16 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Feb 22 17:49:31 2018
    13 // Update Count     : 827
     12// Last Modified On : Mon Nov 27 17:33:35 2017
     13// Update Count     : 824
    1414//
    1515
    … …  
    209209        enum Length { Short, Long, LongLong, NoLength };
    210210        static const char * lengthNames[];
    211         enum Aggregate { Struct, Union, Exception, Trait, Coroutine, Monitor, Thread, NoAggregate };
     211        enum Aggregate { Struct, Union, Trait, Coroutine, Monitor, Thread, NoAggregate };
    212212        static const char * aggregateNames[];
    213213        enum TypeClass { Otype, Dtype, Ftype, Ttype, NoTypeClass };
    … …  
    226226        static DeclarationNode * newForall( DeclarationNode * );
    227227        static DeclarationNode * newFromTypedef( std::string * );
    228         static DeclarationNode * newFunction( std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body );
     228        static DeclarationNode * newFunction( std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body, bool newStyle = false );
    229229        static DeclarationNode * newAggregate( Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body );
    230230        static DeclarationNode * newEnum( std::string * name, DeclarationNode * constants, bool body );
    … …  
    288288        Type * buildType() const;
    289289
     290        bool get_hasEllipsis() const;
    290291        LinkageSpec::Spec get_linkage() const { return linkage; }
    291292        DeclarationNode * extractAggregate() const;

  • src/Parser/TypeData.cc

    r45c43e5 r17fc7a5  
    1010// Created On       : Sat May 16 15:12:51 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Feb 22 15:49:00 2018
    13 // Update Count     : 597
     12// Last Modified On : Mon Sep 25 18:33:41 2017
     13// Update Count     : 587
    1414//
    1515
    … …  
    5454                function.oldDeclList = nullptr;
    5555                function.body = nullptr;
     56                function.newStyle = false;
    5657                function.withExprs = nullptr;
    5758                break;
    … …  
    194195                newtype->function.oldDeclList = maybeClone( function.oldDeclList );
    195196                newtype->function.body = maybeClone( function.body );
     197                newtype->function.newStyle = function.newStyle;
    196198                newtype->function.withExprs = maybeClone( function.withExprs );
    197199                break;
    … …  
    879881FunctionType * buildFunction( const TypeData * td ) {
    880882        assert( td->kind == TypeData::Function );
    881         FunctionType * ft = new FunctionType( buildQualifiers( td ), ! td->function.params || td->function.params->hasEllipsis );
     883        bool hasEllipsis = td->function.params ? td->function.params->get_hasEllipsis() : true;
     884        if ( ! td->function.params ) hasEllipsis = ! td->function.newStyle;
     885        FunctionType * ft = new FunctionType( buildQualifiers( td ), hasEllipsis );
    882886        buildList( td->function.params, ft->get_parameters() );
    883887        buildForall( td->forall, ft->get_forall() );

  • src/Parser/TypeData.h

    r45c43e5 r17fc7a5  
    1010// Created On       : Sat May 16 15:18:36 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Feb 22 15:21:23 2018
    13 // Update Count     : 191
     12// Last Modified On : Fri Sep  1 23:33:45 2017
     13// Update Count     : 190
    1414//
    1515
    … …  
    6464                mutable DeclarationNode * oldDeclList;
    6565                StatementNode * body;
     66                bool newStyle;
    6667                ExpressionNode * withExprs;             // expressions from function's with_clause
    6768        };

  • src/Parser/lex.ll

    r45c43e5 r17fc7a5  
    1010 * Created On       : Sat Sep 22 08:58:10 2001
    1111 * Last Modified By : Peter A. Buhr
    12  * Last Modified On : Thu Feb 22 18:11:27 2018
    13  * Update Count     : 637
     12 * Last Modified On : Wed Oct 25 13:53:56 2017
     13 * Update Count     : 634
    1414 */
    1515
    … …  
    232232enum                    { KEYWORD_RETURN(ENUM); }
    233233__extension__   { KEYWORD_RETURN(EXTENSION); }                  // GCC
    234 exception               { KEYWORD_RETURN(EXCEPTION); }                  // CFA
    235234extern                  { KEYWORD_RETURN(EXTERN); }
    236235fallthru                { KEYWORD_RETURN(FALLTHRU); }                   // CFA

  • src/Parser/parser.yy

    r45c43e5 r17fc7a5  
    1010// Created On       : Sat Sep  1 20:22:55 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Feb 22 17:48:54 2018
    13 // Update Count     : 3028
     12// Last Modified On : Thu Feb 15 17:12:31 2018
     13// Update Count     : 3006
    1414//
    1515
    … …  
    187187%token TYPEOF LABEL                                                                             // GCC
    188188%token ENUM STRUCT UNION
    189 %token EXCEPTION                                                                                // CFA
    190189%token COROUTINE MONITOR THREAD                                                 // CFA
    191190%token OTYPE FTYPE DTYPE TTYPE TRAIT                                    // CFA
    … …  
    315314%type<decl> cfa_identifier_parameter_declarator_tuple cfa_identifier_parameter_ptr
    316315
    317 %type<decl> cfa_parameter_declaration cfa_parameter_list cfa_parameter_type_list_opt
     316%type<decl> cfa_parameter_declaration cfa_parameter_list cfa_parameter_type_list cfa_parameter_type_list_opt
    318317
    319318%type<decl> cfa_typedef_declaration cfa_variable_declaration cfa_variable_specifier
    … …  
    323322%type<decl> KR_declaration_list KR_declaration_list_opt
    324323
    325 %type<decl> parameter_declaration parameter_list parameter_type_list_opt
     324%type<decl> parameter_declaration parameter_list parameter_type_list
     325%type<decl> parameter_type_list_opt
    326326
    327327%type<decl> paren_identifier paren_type
    … …  
    779779        | unary_expression assignment_operator assignment_expression
    780780                { $$ = new ExpressionNode( build_binary_val( $2, $1, $3 ) ); }
    781         | unary_expression '=' '{' initializer_list comma_opt '}'
    782                 { throw SemanticError( yylloc, "Initializer assignment is currently unimplemented." ); $$ = nullptr; } // FIX ME
     781        | unary_expression '=' '{' initializer_list comma_opt '}' // FIX ME
     782                { $$ = nullptr; }
    783783        ;
    784784
    … …  
    849849        | waitfor_statement
    850850        | exception_statement
    851         | enable_disable_statement
    852                 { throw SemanticError( yylloc, "enable/disable statement is currently unimplemented." ); $$ = nullptr; } // FIX ME
    853851        | asm_statement
    854852        ;
    … …  
    10661064        | RETURN comma_expression_opt ';'
    10671065                { $$ = new StatementNode( build_return( $2 ) ); }
    1068         | RETURN '{' initializer_list comma_opt '}'
    1069                 { throw SemanticError( yylloc, "Initializer return is currently unimplemented." ); $$ = nullptr; } // FIX ME
     1066        | RETURN '{' initializer_list comma_opt '}'                     // FIX ME
     1067                { $$ = nullptr; }
    10701068        | THROW assignment_expression_opt ';'                           // handles rethrow
    10711069                { $$ = new StatementNode( build_throw( $2 ) ); }
    … …  
    11951193        ;
    11961194
    1197 enable_disable_statement:
    1198         enable_disable_key identifier_list compound_statement
    1199         ;
    1200 
    1201 enable_disable_key:
    1202         ENABLE
    1203         | DISABLE
    1204         ;
    1205 
    12061195asm_statement:
    12071196        ASM asm_volatile_opt '(' string_literal ')' ';'
    … …  
    14031392                        DeclarationNode * ret = new DeclarationNode;
    14041393                        ret->type = maybeClone( $1->type->base );
    1405                         $$ = $1->appendList( DeclarationNode::newFunction( $5, ret, $8, nullptr ) );
     1394                        $$ = $1->appendList( DeclarationNode::newFunction( $5, ret, $8, nullptr, true ) );
    14061395                }
    14071396        ;
    … …  
    14331422                // To obtain LR(1 ), this rule must be factored out from function return type (see cfa_abstract_declarator).
    14341423                {
    1435                         $$ = DeclarationNode::newFunction( $2, $1, $5, 0 );
     1424                        $$ = DeclarationNode::newFunction( $2, $1, $5, 0, true );
    14361425                }
    14371426        | cfa_function_return identifier_or_type_name '(' push cfa_parameter_type_list_opt pop ')'
    14381427                {
    1439                         $$ = DeclarationNode::newFunction( $2, $1, $5, 0 );
     1428                        $$ = DeclarationNode::newFunction( $2, $1, $5, 0, true );
    14401429                }
    14411430        ;
    … …  
    18921881        | UNION
    18931882                { $$ = DeclarationNode::Union; }
    1894         | EXCEPTION
    1895                 { $$ = DeclarationNode::Exception; }
    18961883        | COROUTINE
    18971884                { $$ = DeclarationNode::Coroutine; }
    … …  
    20031990        ;
    20041991
    2005 cfa_parameter_type_list_opt:                                                    // CFA, abstract + real
     1992// Minimum of one parameter after which ellipsis is allowed only at the end.
     1993
     1994cfa_parameter_type_list_opt:                                                    // CFA
    20061995        // empty
    2007                 { $$ = DeclarationNode::newBasicType( DeclarationNode::Void ); }
    2008         | ELLIPSIS
    20091996                { $$ = nullptr; }
    2010         | cfa_abstract_parameter_list
     1997        | cfa_parameter_type_list
     1998        ;
     1999
     2000cfa_parameter_type_list:                                                                // CFA, abstract + real
     2001        cfa_abstract_parameter_list
    20112002        | cfa_parameter_list
    20122003        | cfa_parameter_list pop ',' push cfa_abstract_parameter_list
    … …  
    20392030        // empty
    20402031                { $$ = nullptr; }
    2041         | ELLIPSIS
    2042                 { $$ = nullptr; }
    2043         | parameter_list
     2032        | parameter_type_list
     2033        ;
     2034
     2035parameter_type_list:
     2036        parameter_list
    20442037        | parameter_list pop ',' push ELLIPSIS
    20452038                { $$ = $1->addVarArgs(); }

  • src/benchmark/bench.h

    r45c43e5 r17fc7a5  
    1010#if defined(__cforall)
    1111}
    12 #include <bits/cfatime.h>
    1312#endif
    14 
    1513
    1614static inline unsigned long long int Time() {
    … …  
    4745        ( EndTime - StartTime ) / n;
    4846
    49 __cfa_time_t default_preemption() {
     47unsigned int default_preemption() {
    5048        return 0;
    5149}

  • src/libcfa/Makefile.am

    r45c43e5 r17fc7a5  
    101101        gmp                             \
    102102        bits/align.h            \
    103         bits/cfatime.h          \
    104103        bits/containers.h               \
    105104        bits/defs.h             \

  • src/libcfa/Makefile.in

    r45c43e5 r17fc7a5  
    264264        concurrency/thread concurrency/kernel concurrency/monitor \
    265265        ${shell find stdhdr -type f -printf "%p "} math gmp \
    266         bits/align.h bits/cfatime.h bits/containers.h bits/defs.h \
    267         bits/debug.h bits/locks.h concurrency/invoke.h
     266        bits/align.h bits/containers.h bits/defs.h bits/debug.h \
     267        bits/locks.h concurrency/invoke.h
    268268HEADERS = $(nobase_cfa_include_HEADERS)
    269269am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
    … …  
    437437        gmp                             \
    438438        bits/align.h            \
    439         bits/cfatime.h          \
    440439        bits/containers.h               \
    441440        bits/defs.h             \

  • src/libcfa/bits/cfatime.h

    r45c43e5 r17fc7a5  
    4848// ctors
    4949static inline void ?{}( __cfa_time_t & this ) { this.val = 0; }
    50 static inline void ?{}( __cfa_time_t & this, const __cfa_time_t & rhs ) { this.val = rhs.val; }
    5150static inline void ?{}( __cfa_time_t & this, zero_t zero ) { this.val = 0; }
    5251
    … …  
    9392static inline __cfa_time_t from_us ( uint64_t val ) { __cfa_time_t ret; ret.val = val *         1_000ul; return ret; }
    9493static inline __cfa_time_t from_ns ( uint64_t val ) { __cfa_time_t ret; ret.val = val *             1ul; return ret; }
    95 
    96 static inline uint64_t to_s  ( __cfa_time_t t ) { return t.val / 1_000_000_000ul; }
    97 static inline uint64_t to_ms ( __cfa_time_t t ) { return t.val /     1_000_000ul; }
    98 static inline uint64_t to_us ( __cfa_time_t t ) { return t.val /         1_000ul; }
    99 static inline uint64_t to_ns ( __cfa_time_t t ) { return t.val /             1ul; }

  • src/libcfa/concurrency/coroutine.c

    r45c43e5 r17fc7a5  
    9999// Wrapper for co
    100100void CoroutineCtxSwitch(coroutine_desc* src, coroutine_desc* dst) {
    101         verify( preemption_state.enabled || this_processor->do_terminate );
     101        verify( preemption.enabled || this_processor->do_terminate );
    102102        disable_interrupts();
    103103
    … …  
    117117
    118118        enable_interrupts( __cfaabi_dbg_ctx );
    119         verify( preemption_state.enabled || this_processor->do_terminate );
     119        verify( preemption.enabled || this_processor->do_terminate );
    120120} //ctxSwitchDirect
    121121

  • src/libcfa/concurrency/kernel

    r45c43e5 r17fc7a5  
    1919
    2020#include "invoke.h"
    21 #include "bits/cfatime.h"
    2221
    2322extern "C" {
    … …  
    4948
    5049        // Preemption rate on this cluster
    51         __cfa_time_t preemption_rate;
     50        unsigned long long int preemption;
    5251};
    53 
    54 extern __cfa_time_t default_preemption();
    5552
    5653void ?{} (cluster & this);

  • src/libcfa/concurrency/kernel.c

    r45c43e5 r17fc7a5  
    6060// volatile thread_local unsigned short disable_preempt_count = 1;
    6161
    62 volatile thread_local __cfa_kernel_preemption_state_t preemption_state = { false, false, 1 };
     62volatile thread_local __cfa_kernel_preemption_data_t preemption = { false, false, 1 };
    6363
    6464//-----------------------------------------------------------------------------
    … …  
    180180        ready_queue_lock{};
    181181
    182         preemption_rate = default_preemption();
     182        preemption = default_preemption();
    183183}
    184184
    … …  
    209209                        if(readyThread)
    210210                        {
    211                                 verify( !preemption_state.enabled );
     211                                verify( !preemption.enabled );
    212212
    213213                                runThread(this, readyThread);
    214214
    215                                 verify( !preemption_state.enabled );
     215                                verify( !preemption.enabled );
    216216
    217217                                //Some actions need to be taken from the kernel
    … …  
    262262void finishRunning(processor * this) with( this->finish ) {
    263263        if( action_code == Release ) {
    264                 verify( !preemption_state.enabled );
     264                verify( !preemption.enabled );
    265265                unlock( *lock );
    266266        }
    … …  
    269269        }
    270270        else if( action_code == Release_Schedule ) {
    271                 verify( !preemption_state.enabled );
     271                verify( !preemption.enabled );
    272272                unlock( *lock );
    273273                ScheduleThread( thrd );
    274274        }
    275275        else if( action_code == Release_Multi ) {
    276                 verify( !preemption_state.enabled );
     276                verify( !preemption.enabled );
    277277                for(int i = 0; i < lock_count; i++) {
    278278                        unlock( *locks[i] );
    … …  
    306306        this_coroutine = NULL;
    307307        this_thread = NULL;
    308         preemption_state.enabled = false;
    309         preemption_state.disable_count = 1;
     308        preemption.enabled = false;
     309        preemption.disable_count = 1;
    310310        // SKULLDUGGERY: We want to create a context for the processor coroutine
    311311        // which is needed for the 2-step context switch. However, there is no reason
    … …  
    351351        coroutine_desc * dst = get_coroutine(*this->runner);
    352352
    353         verify( !preemption_state.enabled );
     353        verify( !preemption.enabled );
    354354
    355355        create_stack(&dst->stack, dst->stack.size);
    356356        CtxStart(this->runner, CtxInvokeCoroutine);
    357357
    358         verify( !preemption_state.enabled );
     358        verify( !preemption.enabled );
    359359
    360360        dst->last = src;
    … …  
    382382        src->state = Active;
    383383
    384         verify( !preemption_state.enabled );
     384        verify( !preemption.enabled );
    385385}
    386386
    … …  
    392392        verify( thrd->self_cor.state != Halted );
    393393
    394         verify( !preemption_state.enabled );
     394        verify( !preemption.enabled );
    395395
    396396        verifyf( thrd->next == NULL, "Expected null got %p", thrd->next );
    … …  
    402402        }
    403403
    404         verify( !preemption_state.enabled );
     404        verify( !preemption.enabled );
    405405}
    406406
    407407thread_desc * nextThread(cluster * this) with( *this ) {
    408         verify( !preemption_state.enabled );
     408        verify( !preemption.enabled );
    409409        lock( ready_queue_lock __cfaabi_dbg_ctx2 );
    410410        thread_desc * head = pop_head( ready_queue );
    411411        unlock( ready_queue_lock );
    412         verify( !preemption_state.enabled );
     412        verify( !preemption.enabled );
    413413        return head;
    414414}
    … …  
    416416void BlockInternal() {
    417417        disable_interrupts();
    418         verify( !preemption_state.enabled );
     418        verify( !preemption.enabled );
    419419        returnToKernel();
    420         verify( !preemption_state.enabled );
     420        verify( !preemption.enabled );
    421421        enable_interrupts( __cfaabi_dbg_ctx );
    422422}
    … …  
    427427        this_processor->finish.lock        = lock;
    428428
    429         verify( !preemption_state.enabled );
     429        verify( !preemption.enabled );
    430430        returnToKernel();
    431         verify( !preemption_state.enabled );
     431        verify( !preemption.enabled );
    432432
    433433        enable_interrupts( __cfaabi_dbg_ctx );
    … …  
    439439        this_processor->finish.thrd        = thrd;
    440440
    441         verify( !preemption_state.enabled );
     441        verify( !preemption.enabled );
    442442        returnToKernel();
    443         verify( !preemption_state.enabled );
     443        verify( !preemption.enabled );
    444444
    445445        enable_interrupts( __cfaabi_dbg_ctx );
    … …  
    453453        this_processor->finish.thrd        = thrd;
    454454
    455         verify( !preemption_state.enabled );
     455        verify( !preemption.enabled );
    456456        returnToKernel();
    457         verify( !preemption_state.enabled );
     457        verify( !preemption.enabled );
    458458
    459459        enable_interrupts( __cfaabi_dbg_ctx );
    … …  
    466466        this_processor->finish.lock_count  = count;
    467467
    468         verify( !preemption_state.enabled );
     468        verify( !preemption.enabled );
    469469        returnToKernel();
    470         verify( !preemption_state.enabled );
     470        verify( !preemption.enabled );
    471471
    472472        enable_interrupts( __cfaabi_dbg_ctx );
    … …  
    481481        this_processor->finish.thrd_count  = thrd_count;
    482482
    483         verify( !preemption_state.enabled );
     483        verify( !preemption.enabled );
    484484        returnToKernel();
    485         verify( !preemption_state.enabled );
     485        verify( !preemption.enabled );
    486486
    487487        enable_interrupts( __cfaabi_dbg_ctx );
    … …  
    489489
    490490void LeaveThread(__spinlock_t * lock, thread_desc * thrd) {
    491         verify( !preemption_state.enabled );
     491        verify( !preemption.enabled );
    492492        this_processor->finish.action_code = thrd ? Release_Schedule : Release;
    493493        this_processor->finish.lock        = lock;
    … …  
    503503// Kernel boot procedures
    504504void kernel_startup(void) {
    505         verify( !preemption_state.enabled );
     505        verify( !preemption.enabled );
    506506        __cfaabi_dbg_print_safe("Kernel : Starting\n");
    507507
    … …  
    548548        __cfaabi_dbg_print_safe("Kernel : Started\n--------------------------------------------------\n\n");
    549549
    550         verify( !preemption_state.enabled );
     550        verify( !preemption.enabled );
    551551        enable_interrupts( __cfaabi_dbg_ctx );
    552         verify( preemption_state.enabled );
     552        verify( preemption.enabled );
    553553}
    554554
    … …  
    556556        __cfaabi_dbg_print_safe("\n--------------------------------------------------\nKernel : Shutting down\n");
    557557
    558         verify( preemption_state.enabled );
     558        verify( preemption.enabled );
    559559        disable_interrupts();
    560         verify( !preemption_state.enabled );
     560        verify( !preemption.enabled );
    561561
    562562        // SKULLDUGGERY: Notify the mainProcessor it needs to terminates.

  • src/libcfa/concurrency/kernel_private.h

    r45c43e5 r17fc7a5  
    7878// extern volatile thread_local unsigned short disable_preempt_count;
    7979
    80 struct __cfa_kernel_preemption_state_t {
     80struct __cfa_kernel_preemption_data_t {
    8181        bool enabled;
    8282        bool in_progress;
    … …  
    8484};
    8585
    86 extern volatile thread_local __cfa_kernel_preemption_state_t preemption_state;
     86extern volatile thread_local __cfa_kernel_preemption_data_t preemption;
    8787
    8888//-----------------------------------------------------------------------------

  • src/libcfa/concurrency/preemption.c

    r45c43e5 r17fc7a5  
    2323}
    2424
    25 #include "bits/cfatime.h"
    2625#include "bits/signal.h"
    2726
    28 #if !defined(__CFA_DEFAULT_PREEMPTION__)
    29 #define __CFA_DEFAULT_PREEMPTION__ 10`cfa_ms
    30 #endif
    31 
    32 __cfa_time_t default_preemption() __attribute__((weak)) {
     27//TODO move to defaults
     28#define __CFA_DEFAULT_PREEMPTION__ 10000
     29
     30//TODO move to defaults
     31__attribute__((weak)) unsigned int default_preemption() {
    3332        return __CFA_DEFAULT_PREEMPTION__;
    3433}
    … …  
    150149        // Disable interrupts by incrementing the counter
    151150        void disable_interrupts() {
    152                 preemption_state.enabled = false;
    153                 __attribute__((unused)) unsigned short new_val = preemption_state.disable_count + 1;
    154                 preemption_state.disable_count = new_val;
     151                preemption.enabled = false;
     152                __attribute__((unused)) unsigned short new_val = preemption.disable_count + 1;
     153                preemption.disable_count = new_val;
    155154                verify( new_val < 65_000u );              // If this triggers someone is disabling interrupts without enabling them
    156155        }
    … …  
    162161                thread_desc * thrd = this_thread;         // Cache the thread now since interrupts can start happening after the atomic add
    163162
    164                 unsigned short prev = preemption_state.disable_count;
    165                 preemption_state.disable_count -= 1;
     163                unsigned short prev = preemption.disable_count;
     164                preemption.disable_count -= 1;
    166165                verify( prev != 0u );                     // If this triggers someone is enabled already enabled interruptsverify( prev != 0u );
    167166
    168167                // Check if we need to prempt the thread because an interrupt was missed
    169168                if( prev == 1 ) {
    170                         preemption_state.enabled = true;
     169                        preemption.enabled = true;
    171170                        if( proc->pending_preemption ) {
    172171                                proc->pending_preemption = false;
    … …  
    182181        // Don't execute any pending CtxSwitch even if counter reaches 0
    183182        void enable_interrupts_noPoll() {
    184                 unsigned short prev = preemption_state.disable_count;
    185                 preemption_state.disable_count -= 1;
     183                unsigned short prev = preemption.disable_count;
     184                preemption.disable_count -= 1;
    186185                verifyf( prev != 0u, "Incremented from %u\n", prev );                     // If this triggers someone is enabled already enabled interrupts
    187186                if( prev == 1 ) {
    188                         preemption_state.enabled = true;
     187                        preemption.enabled = true;
    189188                }
    190189        }
    … …  
    236235// If false : preemption is unsafe and marked as pending
    237236static inline bool preemption_ready() {
    238         bool ready = preemption_state.enabled && !preemption_state.in_progress; // Check if preemption is safe
     237        bool ready = preemption.enabled && !preemption.in_progress; // Check if preemption is safe
    239238        this_processor->pending_preemption = !ready;                        // Adjust the pending flag accordingly
    240239        return ready;
    … …  
    251250
    252251        // Start with preemption disabled until ready
    253         preemption_state.enabled = false;
    254         preemption_state.disable_count = 1;
     252        preemption.enabled = false;
     253        preemption.disable_count = 1;
    255254
    256255        // Initialize the event kernel
    … …  
    295294        this.proc->preemption_alarm = &this.alarm;
    296295
    297         update_preemption( this.proc, this.proc->cltr->preemption_rate );
     296        update_preemption( this.proc, from_us(this.proc->cltr->preemption) );
    298297}
    299298
    … …  
    331330        __cfaabi_dbg_print_buffer_decl( " KERNEL: preempting core %p (%p).\n", this_processor, this_thread);
    332331
    333         preemption_state.in_progress = true;                      // Sync flag : prevent recursive calls to the signal handler
     332        preemption.in_progress = true;                      // Sync flag : prevent recursive calls to the signal handler
    334333        signal_unblock( SIGUSR1 );                          // We are about to CtxSwitch out of the signal handler, let other handlers in
    335         preemption_state.in_progress = false;                     // Clear the in progress flag
     334        preemption.in_progress = false;                     // Clear the in progress flag
    336335
    337336        // Preemption can occur here

  • src/libcfa/concurrency/preemption.h

    r45c43e5 r17fc7a5  
    1919#include "kernel_private.h"
    2020
     21__attribute__((weak)) unsigned int default_preemption();
    2122void kernel_start_preemption();
    2223void kernel_stop_preemption();

  • src/libcfa/concurrency/thread.c

    r45c43e5 r17fc7a5  
    9898
    9999void yield( void ) {
    100         verify( preemption_state.enabled );
     100        verify( preemption.enabled );
    101101        BlockInternal( this_thread );
    102         verify( preemption_state.enabled );
     102        verify( preemption.enabled );
    103103}
    104104

  • src/libcfa/exception.c

    r45c43e5 r17fc7a5  
    1010// Created On       : Mon Jun 26 15:13:00 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Feb 22 18:17:34 2018
    13 // Update Count     : 11
     12// Last Modified On : Fri Feb  9 14:41:55 2018
     13// Update Count     : 8
    1414//
    1515
    … …  
    5252    struct __cfaabi_ehm__try_resume_node * current_resume;
    5353
    54     exception_t * current_exception;
     54    exception * current_exception;
    5555    int current_handler_index;
    5656} shared_stack = {NULL, NULL, 0, 0};
    … …  
    7171// This macro should be the only thing that needs to change across machines.  Used in the personality function, way down
    7272// in termination.
    73 // struct _Unwind_Context * -> _Unwind_Reason_Code(*)(exception_t *)
     73// struct _Unwind_Context * -> _Unwind_Reason_Code(*)(exception *)
    7474#define MATCHER_FROM_CONTEXT(ptr_to_context) \
    75         (*(_Unwind_Reason_Code(**)(exception_t *))(_Unwind_GetCFA(ptr_to_context) + 8))
     75        (*(_Unwind_Reason_Code(**)(exception*))(_Unwind_GetCFA(ptr_to_context) + 8))
    7676
    7777
    7878// RESUMPTION ================================================================
    7979
    80 void __cfaabi_ehm__throw_resume(exception_t * except) {
     80void __cfaabi_ehm__throw_resume(exception * except) {
    8181
    8282        __cfaabi_dbg_print_safe("Throwing resumption exception\n");
    … …  
    106106
    107107void __cfaabi_ehm__try_resume_setup(struct __cfaabi_ehm__try_resume_node * node,
    108                         _Bool (*handler)(exception_t * except)) {
     108                        _Bool (*handler)(exception * except)) {
    109109        node->next = shared_stack.top_resume;
    110110        node->handler = handler;
    … …  
    126126};
    127127
    128 #define NODE_TO_EXCEPT(node) ((exception_t *)(1 + (node)))
     128#define NODE_TO_EXCEPT(node) ((exception *)(1 + (node)))
    129129#define EXCEPT_TO_NODE(except) ((struct __cfaabi_ehm__node *)(except) - 1)
    130130
    131131// Creates a copy of the indicated exception and sets current_exception to it.
    132 static void __cfaabi_ehm__allocate_exception( exception_t * except ) {
     132static void __cfaabi_ehm__allocate_exception( exception * except ) {
    133133        struct exception_context_t * context = this_exception_context();
    134134
    … …  
    151151
    152152// Delete the provided exception, unsetting current_exception if relivant.
    153 static void __cfaabi_ehm__delete_exception( exception_t * except ) {
     153static void __cfaabi_ehm__delete_exception( exception * except ) {
    154154        struct exception_context_t * context = this_exception_context();
    155155
    … …  
    179179// If this isn't a rethrow (*except==0), delete the provided exception.
    180180void __cfaabi_ehm__cleanup_terminate( void * except ) {
    181         if ( *(void**)except ) __cfaabi_ehm__delete_exception( *(exception_t **)except );
     181        if ( *(void**)except ) __cfaabi_ehm__delete_exception( *(exception**)except );
    182182}
    183183
    … …  
    233233}
    234234
    235 void __cfaabi_ehm__throw_terminate( exception_t * val ) {
     235void __cfaabi_ehm__throw_terminate( exception * val ) {
    236236        __cfaabi_dbg_print_safe("Throwing termination exception\n");
    237237
    … …  
    348348                                        // _Unwind_Reason_Code (*matcher)() = (_Unwind_Reason_Code (*)())lsd_info.LPStart + imatcher;
    349349
    350                                         _Unwind_Reason_Code (*matcher)(exception_t *) =
     350                                        _Unwind_Reason_Code (*matcher)(exception *) =
    351351                                                MATCHER_FROM_CONTEXT(context);
    352352                                        int index = matcher(shared_stack.current_exception);
    … …  
    409409__attribute__((noinline))
    410410void __cfaabi_ehm__try_terminate(void (*try_block)(),
    411                 void (*catch_block)(int index, exception_t * except),
    412                 __attribute__((unused)) int (*match_block)(exception_t * except)) {
     411                void (*catch_block)(int index, exception * except),
     412                __attribute__((unused)) int (*match_block)(exception * except)) {
    413413        //! volatile int xy = 0;
    414414        //! printf("%p %p %p %p\n", &try_block, &catch_block, &match_block, &xy);

  • src/libcfa/exception.h

    r45c43e5 r17fc7a5  
    99// Author           : Andrew Beach
    1010// Created On       : Mon Jun 26 15:11:00 2017
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Feb 22 18:11:15 2018
    13 // Update Count     : 8
     11// Last Modified By : Andrew Beach
     12// Last Modified On : Thr Aug 17 15:44:00 2017
     13// Update Count     : 6
    1414//
    1515
    … …  
    2222
    2323struct __cfaabi_ehm__base_exception_t;
    24 typedef struct __cfaabi_ehm__base_exception_t exception_t;
     24typedef struct __cfaabi_ehm__base_exception_t exception;
    2525struct __cfaabi_ehm__base_exception_t_vtable {
    2626        const struct __cfaabi_ehm__base_exception_t_vtable * parent;
    … …  
    3939
    4040// Used in throw statement translation.
    41 void __cfaabi_ehm__throw_terminate(exception_t * except) __attribute__((noreturn));
     41void __cfaabi_ehm__throw_terminate(exception * except) __attribute__((noreturn));
    4242void __cfaabi_ehm__rethrow_terminate() __attribute__((noreturn));
    43 void __cfaabi_ehm__throw_resume(exception_t * except);
     43void __cfaabi_ehm__throw_resume(exception * except);
    4444
    4545// Function catches termination exceptions.
    4646void __cfaabi_ehm__try_terminate(
    4747    void (*try_block)(),
    48     void (*catch_block)(int index, exception_t * except),
    49     int (*match_block)(exception_t * except));
     48    void (*catch_block)(int index, exception * except),
     49    int (*match_block)(exception * except));
    5050
    5151// Clean-up the exception in catch blocks.
    … …  
    5555struct __cfaabi_ehm__try_resume_node {
    5656    struct __cfaabi_ehm__try_resume_node * next;
    57     _Bool (*handler)(exception_t * except);
     57    _Bool (*handler)(exception * except);
    5858};
    5959
    … …  
    6161void __cfaabi_ehm__try_resume_setup(
    6262    struct __cfaabi_ehm__try_resume_node * node,
    63     _Bool (*handler)(exception_t * except));
     63    _Bool (*handler)(exception * except));
    6464void __cfaabi_ehm__try_resume_cleanup(
    6565    struct __cfaabi_ehm__try_resume_node * node);

  • src/libcfa/stdhdr/math.h

    r45c43e5 r17fc7a5  
    1010// Created On       : Mon Jul  4 23:25:26 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Feb 22 18:16:07 2018
    13 // Update Count     : 13
     12// Last Modified On : Tue Jul  5 20:38:18 2016
     13// Update Count     : 12
    1414//
    1515
    1616extern "C" {
    17 #if ! defined( exception )                                                              // nesting ?
    18 #define exception `exception`                                                   // make keyword an identifier
    19 #define __CFA_MATH_H__
    20 #endif
    21 
    2217#include_next <math.h>                                                                  // has internal check for multiple expansion
    23 
    24 #if defined( exception ) && defined( __CFA_MATH_H__ )   // reset only if set
    25 #undef exception
    26 #undef __CFA_MATH_H__
    27 #endif
    2818} // extern "C"
    2919

  • src/prelude/builtins.c

    r45c43e5 r17fc7a5  
    2323void exit( int status, const char fmt[], ... ) __attribute__ (( format(printf, 2, 3), __nothrow__, __leaf__, __noreturn__ ));
    2424void abort ( const char fmt[], ... ) __attribute__ (( format(printf, 1, 2), __nothrow__, __leaf__, __noreturn__ ));
    25 
    26 // increment/decrement unification
    27 
    28 static inline forall( dtype T | { T& ?+=?( T&, one_t ); } )
    29 T& ++? ( T& x ) { return x += 1; }
    30 
    31 static inline forall( dtype T | sized(T) | { void ?{}( T&, T ); void ^?{}( T& ); T& ?+=?( T&, one_t ); } )
    32 T& ?++ ( T& x ) { T tmp = x; x += 1; return tmp; }
    33 
    34 static inline forall( dtype T | { T& ?-=?( T&, one_t ); } )
    35 T& --? ( T& x ) { return x -= 1; }
    36 
    37 static inline forall( dtype T | sized(T) | { void ?{}( T&, T ); void ^?{}( T& ); T& ?-=?( T&, one_t ); } )
    38 T& ?-- ( T& x ) { T tmp = x; x -= 1; return tmp; }
    3925
    4026// exponentiation operator implementation

  • tools/Makefile.am

    r45c43e5 r17fc7a5  
    1818CFLAGS = -Wall -Wextra -O2 -g
    1919
    20 noinst_PROGRAMS = busy catchsig repeat
     20noinst_PROGRAMS = catchsig repeat
    2121
    22 busy_SOURCES     = busy.c
    23 busy_LDFLAGS     = -pthread
    2422catchsig_SOURCES = catchsig.c
    2523repeat_SOURCES   = repeat.c

  • tools/Makefile.in

    r45c43e5 r17fc7a5  
    9292build_triplet = @build@
    9393host_triplet = @host@
    94 noinst_PROGRAMS = busy$(EXEEXT) catchsig$(EXEEXT) repeat$(EXEEXT)
     94noinst_PROGRAMS = catchsig$(EXEEXT) repeat$(EXEEXT)
    9595subdir = tools
    9696ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
    … …  
    104104CONFIG_CLEAN_VPATH_FILES =
    105105PROGRAMS = $(noinst_PROGRAMS)
    106 am_busy_OBJECTS = busy.$(OBJEXT)
    107 busy_OBJECTS = $(am_busy_OBJECTS)
    108 busy_LDADD = $(LDADD)
    109 busy_LINK = $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(busy_LDFLAGS) $(LDFLAGS) \
    110         -o $@
    111106am_catchsig_OBJECTS = catchsig.$(OBJEXT)
    112107catchsig_OBJECTS = $(am_catchsig_OBJECTS)
    … …  
    143138am__v_CCLD_0 = @echo "  CCLD    " $@;
    144139am__v_CCLD_1 =
    145 SOURCES = $(busy_SOURCES) $(catchsig_SOURCES) $(repeat_SOURCES)
    146 DIST_SOURCES = $(busy_SOURCES) $(catchsig_SOURCES) $(repeat_SOURCES)
     140SOURCES = $(catchsig_SOURCES) $(repeat_SOURCES)
     141DIST_SOURCES = $(catchsig_SOURCES) $(repeat_SOURCES)
    147142am__can_run_installinfo = \
    148143  case $$AM_UPDATE_INFO_DIR in \
    … …  
    291286top_builddir = @top_builddir@
    292287top_srcdir = @top_srcdir@
    293 busy_SOURCES = busy.c
    294 busy_LDFLAGS = -pthread
    295288catchsig_SOURCES = catchsig.c
    296289repeat_SOURCES = repeat.c
    … …  
    332325        -test -z "$(noinst_PROGRAMS)" || rm -f $(noinst_PROGRAMS)
    333326
    334 busy$(EXEEXT): $(busy_OBJECTS) $(busy_DEPENDENCIES) $(EXTRA_busy_DEPENDENCIES)
    335         @rm -f busy$(EXEEXT)
    336         $(AM_V_CCLD)$(busy_LINK) $(busy_OBJECTS) $(busy_LDADD) $(LIBS)
    337 
    338327catchsig$(EXEEXT): $(catchsig_OBJECTS) $(catchsig_DEPENDENCIES) $(EXTRA_catchsig_DEPENDENCIES)
    339328        @rm -f catchsig$(EXEEXT)
    … …  
    350339        -rm -f *.tab.c
    351340
    352 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/busy.Po@am__quote@
    353341@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/catchsig.Po@am__quote@
    354342@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/repeat.Po@am__quote@
Note: See TracChangeset for help on using the changeset viewer.