Changes in / [10e90cb:8ca3a72]

Location:

src

Files:

• CodeGen/CodeGenerator.cc (modified) (3 diffs)
• CodeTools/TrackLoc.cc (modified) (1 diff)
• Common/Assert.cc (modified) (2 diffs)
• Common/PassVisitor.h (modified) (1 diff)
• Common/PassVisitor.impl.h (modified) (1 diff)
• Common/PassVisitor.proto.h (modified) (5 diffs)
• Concurrency/Keywords.cc (modified) (4 diffs)
• GenPoly/Box.cc (modified) (10 diffs)
• InitTweak/FixGlobalInit.cc (modified) (1 diff)
• InitTweak/FixInit.cc (modified) (1 diff)
• InitTweak/InitTweak.cc (modified) (5 diffs)
• Parser/ParseNode.h (modified) (4 diffs)
• ResolvExpr/CommonType.cc (modified) (5 diffs)
• ResolvExpr/ConversionCost.cc (modified) (8 diffs)
• ResolvExpr/PtrsAssignable.cc (modified) (4 diffs)
• ResolvExpr/PtrsCastable.cc (modified) (2 diffs)
• ResolvExpr/TypeMap.h (modified) (2 diffs)
• ResolvExpr/typeops.h (modified) (1 diff)
• SymTab/ImplementationType.cc (modified) (3 diffs)
• SynTree/Statement.cc (modified) (2 diffs)
• SynTree/Type.h (modified) (1 diff)
• SynTree/Visitor.cc (modified) (3 diffs)
• driver/cc1.cc (modified) (2 diffs)
• driver/cfa.cc (modified) (1 diff)
• libcfa/Makefile.am (modified) (1 diff)
• libcfa/Makefile.in (modified) (13 diffs)
• libcfa/concurrency/alarm.c (modified) (1 diff)
• libcfa/concurrency/alarm.h (deleted)
• libcfa/concurrency/kernel (modified) (3 diffs)
• libcfa/concurrency/kernel.c (modified) (15 diffs)
• libcfa/concurrency/kernel_private.h (modified) (3 diffs)
• libcfa/concurrency/monitor (modified) (1 diff)
• libcfa/concurrency/monitor.c (modified) (3 diffs)
• libcfa/concurrency/preemption.c (deleted)
• libcfa/concurrency/preemption.h (deleted)
• libcfa/concurrency/signal.c (added)
• main.cc (modified) (1 diff)
• tests/test.py (modified) (1 diff)

src/CodeGen/CodeGenerator.cc

@@ -267 +267 @@
         }
 
-        void CodeGenerator::visit( __attribute__((unused)) TraitDecl * traitDecl ) {}
+        void CodeGenerator::visit( TraitDecl * traitDecl ) {}
 
         void CodeGenerator::visit( TypedefDecl * typeDecl ) {
@@ -328 +328 @@
         }
 
-        void CodeGenerator::visit( __attribute__((unused)) ConstructorInit * init ){
+        void CodeGenerator::visit( ConstructorInit * init ){
                 assertf( ! genC, "ConstructorInit nodes should not reach code generation." );
                 // xxx - generate something reasonable for constructor/destructor pairs
@@ -962 +962 @@
         }
 
-        void CodeGenerator::visit( __attribute__((unused)) NullStmt * nullStmt ) {
+        void CodeGenerator::visit( NullStmt * nullStmt ) {
                 //output << indent << CodeGenerator::printLabels( nullStmt->get_labels() );
                 output << "/* null statement */ ;";

src/CodeTools/TrackLoc.cc

@@ -85 +85 @@
                 }
 
-                void postvisit( __attribute__((unused)) BaseSyntaxNode * node ) {
+                void postvisit(BaseSyntaxNode * node) {
                         parents.pop();
                 }

src/Common/Assert.cc

@@ -21 +21 @@
 extern const char * __progname;                                                 // global name of running executable (argv[0])
 
-#define CFA_ASSERT_FMT "*CFA assertion error* \"%s\" from program \"%s\" in \"%s\" at line %d in file \"%s\""
+#define CFA_ASSERT_FMT "*CFA assertion error* from program \"%s\" in \"%s\" at line %d in file \"%s\""
 
 // called by macro assert in assert.h
 void __assert_fail( const char *assertion, const char *file, unsigned int line, const char *function ) {
-        fprintf( stderr, CFA_ASSERT_FMT ".\n", assertion, __progname, function, line, file );
+        fprintf( stderr, CFA_ASSERT_FMT ".\n", __progname, function, line, file );
         abort();
 }
@@ -31 +31 @@
 // called by macro assertf
 void __assert_fail_f( const char *assertion, const char *file, unsigned int line, const char *function, const char *fmt, ... ) {
-        fprintf( stderr, CFA_ASSERT_FMT ": ", assertion, __progname, function, line, file );
+        fprintf( stderr, CFA_ASSERT_FMT ": ", __progname, function, line, file );
         va_list args;
         va_start( args, fmt );

src/Common/PassVisitor.h

@@ -231 +231 @@
         std::list< Statement* > *       get_beforeStmts() { return stmtsToAddBefore_impl( pass, 0); }
         std::list< Statement* > *       get_afterStmts () { return stmtsToAddAfter_impl ( pass, 0); }
-        bool visit_children() { bool* skip = skip_children_impl(pass, 0); return ! (skip && *skip); }
 };
 

src/Common/PassVisitor.impl.h

@@ -3 +3 @@
 #define VISIT_START( node )  \
         call_previsit( node ); \
-        if( visit_children() ) { \
-
-#define VISIT_END( node )            \
-        }                              \
+
+#define VISIT_END( node )                \
         return call_postvisit( node ); \
 
 #define MUTATE_START( node )  \
         call_premutate( node ); \
-        if( visit_children() ) { \
 
 #define MUTATE_END( type, node )                \
-        }                                         \
         return call_postmutate< type * >( node ); \
 

src/Common/PassVisitor.proto.h

@@ -23 +23 @@
 
 template<typename pass_type, typename node_type>
-static inline void previsit_impl( __attribute__((unused)) pass_type& pass, __attribute__((unused)) node_type * node, __attribute__((unused)) long unused ) {}
+static inline void previsit_impl( __attribute__((unused)) pass_type& pass, node_type * node, __attribute__((unused)) long unused ) {}
 
 
@@ -32 +32 @@
 
 template<typename pass_type, typename node_type>
-static inline void postvisit_impl( __attribute__((unused)) pass_type& pass, __attribute__((unused)) node_type * node, __attribute__((unused)) long unused ) {}
+static inline void postvisit_impl( __attribute__((unused)) pass_type& pass, node_type * node, __attribute__((unused)) long unused ) {}
 
 // Mutate
@@ -41 +41 @@
 
 template<typename pass_type, typename node_type>
-static inline void premutate_impl( __attribute__((unused)) pass_type& pass, __attribute__((unused)) node_type * node, __attribute__((unused)) long unused ) {}
+static inline void premutate_impl( __attribute__((unused)) pass_type& pass, node_type * node, __attribute__((unused)) long unused ) {}
 
 
@@ -71 +71 @@
 
 // Fields
-#define FIELD_PTR( type, name )                                                                                                        \
-template<typename pass_type>                                                                                                           \
-static inline auto name##_impl( pass_type& pass, __attribute__((unused)) int unused ) ->decltype( &pass.name ) { return &pass.name; }  \
-                                                                                                                                       \
-template<typename pass_type>                                                                                                           \
+#define FIELD_PTR( type, name )                                                                                                                  \
+template<typename pass_type>                                                                                                                     \
+static inline auto name##_impl( pass_type& pass, __attribute__((unused)) int unused ) ->decltype( &pass.name ) { return &pass.name; }          \
+                                                                                                                                                 \
+template<typename pass_type>                                                                                                                     \
 static inline type * name##_impl( __attribute__((unused)) pass_type& pass, __attribute__((unused)) long unused ) { return nullptr;}    \
 
@@ -81 +81 @@
 FIELD_PTR( std::list< Statement* >, stmtsToAddBefore )
 FIELD_PTR( std::list< Statement* >, stmtsToAddAfter  )
-FIELD_PTR( bool, skip_children )

src/Concurrency/Keywords.cc

@@ -65 +65 @@
                 FunctionDecl * forwardDeclare( StructDecl * );
                 ObjectDecl * addField( StructDecl * );
-                void addRoutines( ObjectDecl *, FunctionDecl * );
+                void addRoutines( StructDecl *, ObjectDecl *, FunctionDecl * );
 
                 virtual bool is_target( StructDecl * decl ) = 0;
@@ -247 +247 @@
         void ConcurrentSueKeyword::visit(StructDecl * decl) {
                 Visitor::visit(decl);
-                if( decl->get_name() == type_name && decl->has_body() ) {
+                if( decl->get_name() == type_name ) {
                         assert( !type_decl );
                         type_decl = decl;
@@ -264 +264 @@
                 FunctionDecl * func = forwardDeclare( decl );
                 ObjectDecl * field = addField( decl );
-                addRoutines( field, func );
+                addRoutines( decl, field, func );
         }
 
@@ -359 +359 @@
         }
 
-        void ConcurrentSueKeyword::addRoutines( ObjectDecl * field, FunctionDecl * func ) {
+        void ConcurrentSueKeyword::addRoutines( StructDecl * decl, ObjectDecl * field, FunctionDecl * func ) {
                 CompoundStmt * statement = new CompoundStmt( noLabels );
                 statement->push_back( 

src/GenPoly/Box.cc

@@ -101 +101 @@
                         void passTypeVars( ApplicationExpr *appExpr, Type *polyRetType, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars );
                         /// wraps a function application with a new temporary for the out-parameter return value
-                        Expression *addRetParam( ApplicationExpr *appExpr, Type *retType, std::list< Expression *>::iterator &arg );
+                        Expression *addRetParam( ApplicationExpr *appExpr, FunctionType *function, Type *retType, std::list< Expression *>::iterator &arg );
                         /// Replaces all the type parameters of a generic type with their concrete equivalents under the current environment
                         void replaceParametersWithConcrete( ApplicationExpr *appExpr, std::list< Expression* >& params );
@@ -134 +134 @@
                   public:
                         template< typename DeclClass >
-                        DeclClass *handleDecl( DeclClass *decl );
+                        DeclClass *handleDecl( DeclClass *decl, Type *type );
                         template< typename AggDecl >
                         AggDecl * handleAggDecl( AggDecl * aggDecl );
@@ -663 +663 @@
                 }
 
-                Expression *Pass1::addRetParam( ApplicationExpr *appExpr, Type *retType, std::list< Expression *>::iterator &arg ) {
+                Expression *Pass1::addRetParam( ApplicationExpr *appExpr, FunctionType *function, Type *retType, std::list< Expression *>::iterator &arg ) {
                         // Create temporary to hold return value of polymorphic function and produce that temporary as a result
                         // using a comma expression.
@@ -730 +730 @@
                         Type *concrete = replaceWithConcrete( appExpr, dynType );
                         // add out-parameter for return value
-                        return addRetParam( appExpr, concrete, arg );
+                        return addRetParam( appExpr, function, concrete, arg );
                 }
 
@@ -737 +737 @@
 //                      if ( ! function->get_returnVals().empty() && isPolyType( function->get_returnVals().front()->get_type(), tyVars ) ) {
                         if ( isDynRet( function, tyVars ) ) {
-                                ret = addRetParam( appExpr, function->get_returnVals().front()->get_type(), arg );
+                                ret = addRetParam( appExpr, function, function->get_returnVals().front()->get_type(), arg );
                         } // if
                         std::string mangleName = mangleAdapterName( function, tyVars );
@@ -1280 +1280 @@
 
                 template< typename DeclClass >
-                DeclClass * Pass2::handleDecl( DeclClass *decl ) {
+                DeclClass * Pass2::handleDecl( DeclClass *decl, Type *type ) {
                         DeclClass *ret = static_cast< DeclClass *>( Parent::mutate( decl ) );
 
@@ -1294 +1294 @@
 
                 DeclarationWithType * Pass2::mutate( FunctionDecl *functionDecl ) {
-                        functionDecl = safe_dynamic_cast< FunctionDecl * > ( handleDecl( functionDecl ) );
+                        functionDecl = safe_dynamic_cast< FunctionDecl * > ( handleDecl( functionDecl, functionDecl->get_functionType() ) );
                         FunctionType * ftype = functionDecl->get_functionType();
                         if ( ! ftype->get_returnVals().empty() && functionDecl->get_statements() ) {
@@ -1319 +1319 @@
 
                 ObjectDecl * Pass2::mutate( ObjectDecl *objectDecl ) {
-                        return handleDecl( objectDecl );
+                        return handleDecl( objectDecl, objectDecl->get_type() );
                 }
 
@@ -1342 +1342 @@
                         addToTyVarMap( typeDecl, scopeTyVars );
                         if ( typeDecl->get_base() ) {
-                                return handleDecl( typeDecl );
+                                return handleDecl( typeDecl, typeDecl->get_base() );
                         } else {
                                 return Parent::mutate( typeDecl );
@@ -1349 +1349 @@
 
                 TypedefDecl * Pass2::mutate( TypedefDecl *typedefDecl ) {
-                        return handleDecl( typedefDecl );
+                        return handleDecl( typedefDecl, typedefDecl->get_base() );
                 }
 

src/InitTweak/FixGlobalInit.cc

@@ -125 +125 @@
 
         // only modify global variables
-        void GlobalFixer::visit( __attribute__((unused)) FunctionDecl *functionDecl ) {}
-        void GlobalFixer::visit( __attribute__((unused)) StructDecl *aggregateDecl ) {}
-        void GlobalFixer::visit( __attribute__((unused)) UnionDecl *aggregateDecl ) {}
-        void GlobalFixer::visit( __attribute__((unused)) EnumDecl *aggregateDecl ) {}
-        void GlobalFixer::visit( __attribute__((unused)) TraitDecl *aggregateDecl ) {}
-        void GlobalFixer::visit( __attribute__((unused)) TypeDecl *typeDecl ) {}
+        void GlobalFixer::visit( FunctionDecl *functionDecl ) {}
+        void GlobalFixer::visit( StructDecl *aggregateDecl ) {}
+        void GlobalFixer::visit( UnionDecl *aggregateDecl ) {}
+        void GlobalFixer::visit( EnumDecl *aggregateDecl ) {}
+        void GlobalFixer::visit( TraitDecl *aggregateDecl ) {}
+        void GlobalFixer::visit( TypeDecl *typeDecl ) {}
 
 } // namespace InitTweak

src/InitTweak/FixInit.cc

@@ -110 +110 @@
 
                         // don't go into other functions
-                        virtual void visit( __attribute__((unused)) FunctionDecl *decl ) override {}
+                        virtual void visit( FunctionDecl *decl ) override {}
 
                   protected:

src/InitTweak/InitTweak.cc

@@ -92 +92 @@
                 InitImpl( Initializer * init ) : init( init ) {}
 
-                virtual std::list< Expression * > next( __attribute((unused)) std::list< Expression * > & indices ) {
+                virtual std::list< Expression * > next( std::list< Expression * > & indices ) {
                         // this is wrong, but just a placeholder for now
                         // if ( ! flattened ) flatten( indices );
@@ -248 +248 @@
         }
 
-        Statement * ExprImpl::buildListInit( __attribute((unused)) UntypedExpr * dst, __attribute((unused)) std::list< Expression * > & indices ) {
+        Statement * ExprImpl::buildListInit( UntypedExpr * dst, std::list< Expression * > & indices ) {
                 return NULL;
         }
@@ -475 +475 @@
                 ConstExprChecker() : isConstExpr( true ) {}
 
-                virtual void visit( __attribute((unused)) ApplicationExpr *applicationExpr ) { isConstExpr = false; }
-                virtual void visit( __attribute((unused)) UntypedExpr *untypedExpr ) { isConstExpr = false; }
+                virtual void visit( ApplicationExpr *applicationExpr ) { isConstExpr = false; }
+                virtual void visit( UntypedExpr *untypedExpr ) { isConstExpr = false; }
                 virtual void visit( NameExpr *nameExpr ) {
                         // xxx - temporary hack, because 0 and 1 really should be constexprs, even though they technically aren't in Cforall today
@@ -487 +487 @@
                         if ( ! dynamic_cast< NameExpr * >( arg) && ! dynamic_cast< VariableExpr * >( arg ) && ! dynamic_cast< MemberExpr * >( arg ) && ! dynamic_cast< UntypedMemberExpr * >( arg ) ) isConstExpr = false;
                 }
-                virtual void visit( __attribute((unused)) LabelAddressExpr *labAddressExpr ) { isConstExpr = false; }
-                virtual void visit( __attribute((unused)) UntypedMemberExpr *memberExpr ) { isConstExpr = false; }
-                virtual void visit( __attribute((unused)) MemberExpr *memberExpr ) { isConstExpr = false; }
-                virtual void visit( __attribute((unused)) VariableExpr *variableExpr ) { isConstExpr = false; }
+                virtual void visit( LabelAddressExpr *labAddressExpr ) { isConstExpr = false; }
+                virtual void visit( UntypedMemberExpr *memberExpr ) { isConstExpr = false; }
+                virtual void visit( MemberExpr *memberExpr ) { isConstExpr = false; }
+                virtual void visit( VariableExpr *variableExpr ) { isConstExpr = false; }
                 // these might be okay?
                 // virtual void visit( SizeofExpr *sizeofExpr );
@@ -501 +501 @@
                 // virtual void visit( LogicalExpr *logicalExpr );
                 // virtual void visit( ConditionalExpr *conditionalExpr );
-                virtual void visit( __attribute((unused)) TypeExpr *typeExpr ) { isConstExpr = false; }
-                virtual void visit( __attribute((unused)) AsmExpr *asmExpr ) { isConstExpr = false; }
-                virtual void visit( __attribute((unused)) UntypedValofExpr *valofExpr ) { isConstExpr = false; }
-                virtual void visit( __attribute((unused)) CompoundLiteralExpr *compLitExpr ) { isConstExpr = false; }
-                virtual void visit( __attribute((unused)) UntypedTupleExpr *tupleExpr ) { isConstExpr = false; }
-                virtual void visit( __attribute((unused)) TupleExpr *tupleExpr ) { isConstExpr = false; }
-                virtual void visit( __attribute((unused)) TupleAssignExpr *tupleExpr ) { isConstExpr = false; }
+                virtual void visit( TypeExpr *typeExpr ) { isConstExpr = false; }
+                virtual void visit( AsmExpr *asmExpr ) { isConstExpr = false; }
+                virtual void visit( UntypedValofExpr *valofExpr ) { isConstExpr = false; }
+                virtual void visit( CompoundLiteralExpr *compLitExpr ) { isConstExpr = false; }
+                virtual void visit( UntypedTupleExpr *tupleExpr ) { isConstExpr = false; }
+                virtual void visit( TupleExpr *tupleExpr ) { isConstExpr = false; }
+                virtual void visit( TupleAssignExpr *tupleExpr ) { isConstExpr = false; }
 
                 bool isConstExpr;

src/Parser/ParseNode.h

@@ -61 +61 @@
         }
 
-        virtual void print( __attribute__((unused)) std::ostream &os, __attribute__((unused)) int indent = 0 ) const {}
-        virtual void printList( __attribute__((unused)) std::ostream &os, __attribute__((unused)) int indent = 0 ) const {}
+        virtual void print( std::ostream &os, int indent = 0 ) const {}
+        virtual void printList( std::ostream &os, int indent = 0 ) const {}
 
         static int indent_by;
@@ -113 +113 @@
         ExpressionNode * set_extension( bool exten ) { extension = exten; return this; }
 
-        virtual void print( __attribute__((unused)) std::ostream &os, __attribute__((unused)) int indent = 0 ) const override {}
-        void printOneLine( __attribute__((unused)) std::ostream &os, __attribute__((unused)) int indent = 0 ) const {}
+        virtual void print( std::ostream &os, int indent = 0 ) const override {}
+        void printOneLine( std::ostream &os, int indent = 0 ) const {}
 
         template<typename T>
@@ -283 +283 @@
         }
 
-        virtual void print( __attribute__((unused)) std::ostream &os, __attribute__((unused)) int indent = 0 ) const override;
-        virtual void printList( __attribute__((unused)) std::ostream &os, __attribute__((unused)) int indent = 0 ) const override;
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
+        virtual void printList( std::ostream &os, int indent = 0 ) const override;
 
         Declaration * build() const;
@@ -363 +363 @@
         virtual StatementNode * append_last_case( StatementNode * );
 
-        virtual void print( __attribute__((unused)) std::ostream &os, __attribute__((unused)) int indent = 0 ) const override {}
-        virtual void printList( __attribute__((unused)) std::ostream &os, __attribute__((unused)) int indent = 0 ) const override {}
+        virtual void print( std::ostream &os, int indent = 0 ) const override {}
+        virtual void printList( std::ostream &os, int indent = 0 ) const override {}
   private:
         std::unique_ptr<Statement> stmt;

src/ResolvExpr/CommonType.cc

@@ -43 +43 @@
 
                 void getCommonWithVoidPointer( PointerType* voidPointer, PointerType* otherPointer );
+                template< typename RefType > void handleRefType( RefType *inst, Type *other );
 
                 Type *result;
@@ -125 +126 @@
         }
 
-        void CommonType::visit( __attribute((unused)) VoidType *voidType ) {}
+        void CommonType::visit( VoidType *voidType ) {
+        }
 
         void CommonType::visit( BasicType *basicType ) {
@@ -187 +189 @@
         }
 
-        void CommonType::visit( __attribute((unused)) ArrayType *arrayType ) {}
-        void CommonType::visit( __attribute((unused)) FunctionType *functionType ) {}
-        void CommonType::visit( __attribute((unused)) StructInstType *aggregateUseType ) {}
-        void CommonType::visit( __attribute((unused)) UnionInstType *aggregateUseType ) {}
+        void CommonType::visit( ArrayType *arrayType ) {
+        }
+
+        void CommonType::visit( FunctionType *functionType ) {
+        }
+
+        template< typename RefType > void CommonType::handleRefType( RefType *inst, Type *other ) {
+        }
+
+        void CommonType::visit( StructInstType *aggregateUseType ) {
+        }
+
+        void CommonType::visit( UnionInstType *aggregateUseType ) {
+        }
 
         void CommonType::visit( EnumInstType *enumInstType ) {
@@ -202 +214 @@
         }
 
-        void CommonType::visit( __attribute((unused)) TraitInstType *aggregateUseType ) {
+        void CommonType::visit( TraitInstType *aggregateUseType ) {
         }
 
@@ -227 +239 @@
         }
 
-        void CommonType::visit( __attribute((unused)) TupleType *tupleType ) {}
-        void CommonType::visit( __attribute((unused)) VarArgsType *varArgsType ) {}
+        void CommonType::visit( TupleType *tupleType ) {
+        }
+
+        void CommonType::visit( VarArgsType *varArgsType ) {
+        }
 
         void CommonType::visit( ZeroType *zeroType ) {

src/ResolvExpr/ConversionCost.cc

@@ -149 +149 @@
         };
 
-        void ConversionCost::visit( __attribute((unused)) VoidType *voidType ) {
+        void ConversionCost::visit(VoidType *voidType) {
                 cost = Cost::infinity;
         }
@@ -186 +186 @@
         }
 
-        void ConversionCost::visit(__attribute((unused)) ArrayType *arrayType) {}
-        void ConversionCost::visit(__attribute((unused)) FunctionType *functionType) {}
+        void ConversionCost::visit(ArrayType *arrayType) {
+        }
+
+        void ConversionCost::visit(FunctionType *functionType) {
+        }
 
         void ConversionCost::visit(StructInstType *inst) {
@@ -205 +208 @@
         }
 
-        void ConversionCost::visit( __attribute((unused)) EnumInstType *inst ) {
+        void ConversionCost::visit(EnumInstType *inst) {
                 static Type::Qualifiers q;
                 static BasicType integer( q, BasicType::SignedInt );
@@ -214 +217 @@
         }
 
-        void ConversionCost::visit( __attribute((unused)) TraitInstType *inst) {
+        void ConversionCost::visit(TraitInstType *inst) {
         }
 
@@ -236 +239 @@
         }
 
-        void ConversionCost::visit( __attribute((unused)) TupleType *tupleType) {
+        void ConversionCost::visit(TupleType *tupleType) {
                 Cost c;
                 if ( TupleType *destAsTuple = dynamic_cast< TupleType* >( dest ) ) {
@@ -256 +259 @@
         }
 
-        void ConversionCost::visit( __attribute((unused)) VarArgsType *varArgsType) {
+        void ConversionCost::visit(VarArgsType *varArgsType) {
                 if ( dynamic_cast< VarArgsType* >( dest ) ) {
                         cost = Cost::zero;
@@ -262 +265 @@
         }
 
-        void ConversionCost::visit( __attribute((unused)) ZeroType *zeroType) {
+        void ConversionCost::visit(ZeroType *zeroType) {
                 if ( dynamic_cast< ZeroType* >( dest ) ) {
                         cost = Cost::zero;
@@ -278 +281 @@
         }
 
-        void ConversionCost::visit( __attribute((unused)) OneType *oneType) {
+        void ConversionCost::visit(OneType *oneType) {
                 if ( dynamic_cast< OneType* >( dest ) ) {
                         cost = Cost::zero;

src/ResolvExpr/PtrsAssignable.cc

@@ -63 +63 @@
         }
 
-        PtrsAssignable::PtrsAssignable( Type *dest, const TypeEnvironment &env ) : dest( dest ), result( 0 ), env( env ) {}
+        PtrsAssignable::PtrsAssignable( Type *dest, const TypeEnvironment &env ) : dest( dest ), result( 0 ), env( env ) {
+        }
 
-        void PtrsAssignable::visit( __attribute((unused)) VoidType *voidType ) {
+        void PtrsAssignable::visit( VoidType *voidType ) {
                 if ( dynamic_cast< FunctionType* >( dest ) ) {
                         result = 0;
@@ -73 +74 @@
         }
 
-        void PtrsAssignable::visit( __attribute__((unused)) BasicType *basicType ) {}
-        void PtrsAssignable::visit( __attribute__((unused)) PointerType *pointerType ) {}
-        void PtrsAssignable::visit( __attribute__((unused)) ArrayType *arrayType ) {}
-        void PtrsAssignable::visit( __attribute__((unused)) FunctionType *functionType ) {
+        void PtrsAssignable::visit( BasicType *basicType ) {
+        }
+
+        void PtrsAssignable::visit( PointerType *pointerType ) {
+        }
+
+        void PtrsAssignable::visit( ArrayType *arrayType ) {
+        }
+
+        void PtrsAssignable::visit( FunctionType *functionType ) {
                 result = -1;
         }
 
-        void PtrsAssignable::visit(  __attribute__((unused)) StructInstType *inst ) {}
-        void PtrsAssignable::visit(  __attribute__((unused)) UnionInstType *inst ) {}
+        void PtrsAssignable::visit( StructInstType *inst ) {
+                // I don't think we should be doing anything here, but I'm willing to admit that I might be wrong
+        }
+
+        void PtrsAssignable::visit( UnionInstType *inst ) {
+                // I don't think we should be doing anything here, but I'm willing to admit that I might be wrong
+        }
 
         void PtrsAssignable::visit( EnumInstType *inst ) {
@@ -91 +103 @@
         }
 
-        void PtrsAssignable::visit(  __attribute__((unused)) TraitInstType *inst ) {}
+        void PtrsAssignable::visit( TraitInstType *inst ) {
+                // I definitely don't think we should be doing anything here
+        }
+
         void PtrsAssignable::visit( TypeInstType *inst ) {
                 EqvClass eqvClass;
@@ -101 +116 @@
         }
 
-        void PtrsAssignable::visit(  __attribute__((unused)) TupleType *tupleType ) {}
-        void PtrsAssignable::visit(  __attribute__((unused)) VarArgsType *varArgsType ) {}
-        void PtrsAssignable::visit(  __attribute__((unused)) ZeroType *zeroType ) {}
-        void PtrsAssignable::visit(  __attribute__((unused)) OneType *oneType ) {}
+        void PtrsAssignable::visit( TupleType *tupleType ) {
+///  // This code doesn't belong here, but it might be useful somewhere else
+///   if ( TupleType *destAsTuple = dynamic_cast< TupleType* >( dest ) ) {
+///     int ret = 0;
+///     std::list< Type* >::const_iterator srcIt = tupleType->get_types().begin();
+///     std::list< Type* >::const_iterator destIt = destAsTuple->get_types().begin();
+///     while ( srcIt != tupleType->get_types().end() && destIt != destAsTuple->get_types().end() ) {
+///       int assignResult = ptrsAssignable( *srcIt++, *destIt++ );
+///       if ( assignResult == 0 ) {
+///         result = assignResult;
+///         return;
+///       } else if ( assignResult < 0 ) {
+///         ret = -1;
+///       } else if ( ret > 0 ) {
+///         ret += assignResult;
+///       }
+///     }
+///     if ( srcIt == tupleType->get_types().end() && destIt == destAsTuple->get_types().end() ) {
+///       result = ret;
+///     } else {
+///       result = 0;
+///     }
+///   }
+        }
+
+        void PtrsAssignable::visit( VarArgsType *varArgsType ) {
+        }
+
+        void PtrsAssignable::visit( ZeroType *zeroType ) {
+        }
+        
+        void PtrsAssignable::visit( OneType *oneType ) {
+        }
         
 } // namespace ResolvExpr

src/ResolvExpr/PtrsCastable.cc

@@ -92 +92 @@
         }
 
-        void PtrsCastable::visit( __attribute__((unused)) VoidType *voidType) {
+        void PtrsCastable::visit(VoidType *voidType) {
                 result = objectCast( dest, env, indexer );
         }
 
-        void PtrsCastable::visit( __attribute__((unused)) BasicType *basicType) {
+        void PtrsCastable::visit(BasicType *basicType) {
                 result = objectCast( dest, env, indexer );
         }
 
-        void PtrsCastable::visit( __attribute__((unused)) PointerType *pointerType) {
+        void PtrsCastable::visit(PointerType *pointerType) {
                 result = objectCast( dest, env, indexer );
         }
 
-        void PtrsCastable::visit( __attribute__((unused)) ArrayType *arrayType) {
+        void PtrsCastable::visit(ArrayType *arrayType) {
                 result = objectCast( dest, env, indexer );
         }
 
-        void PtrsCastable::visit( __attribute__((unused)) FunctionType *functionType) {
+        void PtrsCastable::visit(FunctionType *functionType) {
                 // result = -1;
                 result = functionCast( dest, env, indexer );
         }
 
-        void PtrsCastable::visit( __attribute__((unused)) StructInstType *inst) {
+        void PtrsCastable::visit(StructInstType *inst) {
                 result = objectCast( dest, env, indexer );
         }
 
-        void PtrsCastable::visit( __attribute__((unused)) UnionInstType *inst) {
+        void PtrsCastable::visit(UnionInstType *inst) {
                 result = objectCast( dest, env, indexer );
         }
 
-        void PtrsCastable::visit( __attribute__((unused)) EnumInstType *inst) {
+        void PtrsCastable::visit(EnumInstType *inst) {
                 if ( dynamic_cast< EnumInstType* >( dest ) ) {
                         result = 1;
@@ -144 +144 @@
         }
 
-        void PtrsCastable::visit( __attribute__((unused)) TupleType *tupleType) {
+        void PtrsCastable::visit(TupleType *tupleType) {
                 result = objectCast( dest, env, indexer );
         }
 
-        void PtrsCastable::visit( __attribute__((unused)) VarArgsType *varArgsType) {
+        void PtrsCastable::visit(VarArgsType *varArgsType) {
                 result = objectCast( dest, env, indexer );
         }
 
-        void PtrsCastable::visit( __attribute__((unused)) ZeroType *zeroType) {
+        void PtrsCastable::visit(ZeroType *zeroType) {
                 result = objectCast( dest, env, indexer );
         }
 
-        void PtrsCastable::visit( __attribute__((unused)) OneType *oneType) {
+        void PtrsCastable::visit(OneType *oneType) {
                 result = objectCast( dest, env, indexer );
         }

src/ResolvExpr/TypeMap.h

@@ -110 +110 @@
                         }
 
-                        virtual void visit( __attribute__((unused)) VoidType *voidType ) {
+                        virtual void visit( VoidType *voidType ) {
                                 findAndReplace( typeMap.voidValue );
                         }
@@ -138 +138 @@
                         }
 
-                        virtual void visit( __attribute__((unused)) FunctionType *functionType ) {
+                        virtual void visit( FunctionType *functionType ) {
                                 findAndReplace( typeMap.functionPointerValue );
                         }

src/ResolvExpr/typeops.h

@@ -132 +132 @@
         }
 
+        template< typename Container1, typename Container2 >
+        bool typesCompatibleList( Container1 &c1, Container2 &c2, const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
+                typename Container1::iterator i1 = c1.begin();
+                typename Container2::iterator i2 = c2.begin();
+                for ( ; i1 != c1.end() && i2 != c2.end(); ++i1, ++i2 ) {
+                        if ( ! typesCompatible( *i1, *i2, indexer ) ) {
+                                return false;
+                        } // if
+                }
+                return ( i1 == c1.end() ) && ( i2 == c2.end() );
+        }
+
         /// creates the type represented by the list of returnVals in a FunctionType. The caller owns the return value.
         Type * extractResultType( FunctionType * functionType );

src/SymTab/ImplementationType.cc

@@ -61 +61 @@
         }
 
-        void ImplementationType::visit( __attribute__((unused)) VoidType *voidType ) {}
-        void ImplementationType::visit( __attribute__((unused)) BasicType *basicType ) {}
+        void ImplementationType::visit(VoidType *voidType) {
+        }
+
+        void ImplementationType::visit(BasicType *basicType) {
+        }
 
         void ImplementationType::visit(PointerType *pointerType) {
@@ -86 +89 @@
         }
 
-        void ImplementationType::visit( __attribute__((unused)) StructInstType * aggregateUseType ) {}
-        void ImplementationType::visit( __attribute__((unused)) UnionInstType * aggregateUseType ) {}
-        void ImplementationType::visit( __attribute__((unused)) EnumInstType * aggregateUseType ) {}
-        void ImplementationType::visit( __attribute__((unused)) TraitInstType * aggregateUseType ) {}
+        void ImplementationType::visit(StructInstType *aggregateUseType) {
+        }
+
+        void ImplementationType::visit(UnionInstType *aggregateUseType) {
+        }
+
+        void ImplementationType::visit(EnumInstType *aggregateUseType) {
+        }
+
+        void ImplementationType::visit(TraitInstType *aggregateUseType) {
+        }
 
         void ImplementationType::visit(TypeInstType *inst) {
@@ -110 +120 @@
         }
 
-        void ImplementationType::visit( __attribute__((unused)) VarArgsType *varArgsType ) {}
-        void ImplementationType::visit( __attribute__((unused)) ZeroType *zeroType ) {}
-        void ImplementationType::visit( __attribute__((unused)) OneType *oneType ) {}
+        void ImplementationType::visit(VarArgsType *varArgsType) {
+        }
+
+        void ImplementationType::visit(ZeroType *zeroType) {
+        }
+
+        void ImplementationType::visit(OneType *oneType) {
+        }
 } // namespace SymTab
 

src/SynTree/Statement.cc

@@ -30 +30 @@
 Statement::Statement( std::list<Label> _labels ) : labels( _labels ) {}
 
-void Statement::print( __attribute__((unused)) std::ostream &, __attribute__((unused)) int indent ) const {}
+void Statement::print( std::ostream &, int indent ) const {}
 
 Statement::~Statement() {}
@@ -365 +365 @@
 NullStmt::NullStmt() : CompoundStmt( std::list<Label>() ) {}
 
-void NullStmt::print( std::ostream &os, __attribute__((unused)) int indent ) const {
+void NullStmt::print( std::ostream &os, int indent ) const {
         os << "Null Statement" << endl ;
 }

src/SynTree/Type.h

@@ -334 +334 @@
         virtual void print( std::ostream & os, int indent = 0 ) const;
 
-        virtual void lookup( __attribute__((unused)) const std::string & name, __attribute__((unused)) std::list< Declaration* > & foundDecls ) const {}
+        virtual void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const {}
   protected:
         virtual std::string typeString() const = 0;

src/SynTree/Visitor.cc

@@ -122 +122 @@
 }
 
-void Visitor::visit( __attribute__((unused)) BranchStmt *branchStmt ) {
+void Visitor::visit( BranchStmt *branchStmt ) {
 }
 
@@ -143 +143 @@
 }
 
-void Visitor::visit( __attribute__((unused)) NullStmt *nullStmt ) {
+void Visitor::visit( NullStmt *nullStmt ) {
 }
 
@@ -445 +445 @@
 
 
-void Visitor::visit( __attribute__((unused)) Subrange *subrange ) {}
-
-
-void Visitor::visit( __attribute__((unused)) Constant *constant ) {}
+void Visitor::visit( Subrange *subrange ) {}
+
+
+void Visitor::visit( Constant *constant ) {}
 // Local Variables: //
 // tab-width: 4 //

src/driver/cc1.cc

@@ -84 +84 @@
 
 
-void sigTermHandler( __attribute__((unused)) int signal ) {
+void sigTermHandler( int signal ) {
         if ( tmpfilefd != -1 ) {                                                        // RACE, file created ?
                 rmtmpfile();                                                                    // remove
@@ -469 +469 @@
 
 
-int main( const int argc, const char * const argv[], __attribute__((unused)) const char * const env[] ) {
+int main( const int argc, const char * const argv[], const char * const env[] ) {
 #ifdef __DEBUG_H__
         for ( int i = 0; env[i] != NULL; i += 1 ) {

src/driver/cfa.cc

@@ -271 +271 @@
                 args[nargs] = "-ldl";
                 nargs += 1;
-                args[nargs] = "-lrt";
-                nargs += 1;
                 args[nargs] = "-Xlinker";
                 nargs += 1;

src/libcfa/Makefile.am

@@ -54 +54 @@
 # not all platforms support concurrency, add option do disable it
 if BUILD_CONCURRENCY
-libsrc += concurrency/CtxSwitch-@MACHINE_TYPE@.S concurrency/alarm.c concurrency/invoke.c concurrency/preemption.c
+libsrc += concurrency/CtxSwitch-@MACHINE_TYPE@.S concurrency/alarm.c concurrency/invoke.c concurrency/signal.c
 endif
 

src/libcfa/Makefile.in

@@ -46 +46 @@
 
 # not all platforms support concurrency, add option do disable it
-@BUILD_CONCURRENCY_TRUE@am__append_4 = concurrency/CtxSwitch-@MACHINE_TYPE@.S concurrency/alarm.c concurrency/invoke.c concurrency/preemption.c
+@BUILD_CONCURRENCY_TRUE@am__append_4 = concurrency/CtxSwitch-@MACHINE_TYPE@.S concurrency/alarm.c concurrency/invoke.c concurrency/signal.c
 subdir = src/libcfa
 DIST_COMMON = $(am__nobase_cfa_include_HEADERS_DIST) \
@@ -104 +104 @@
         concurrency/kernel.c concurrency/monitor.c \
         concurrency/CtxSwitch-@MACHINE_TYPE@.S concurrency/alarm.c \
-        concurrency/invoke.c concurrency/preemption.c
+        concurrency/invoke.c concurrency/signal.c
 am__dirstamp = $(am__leading_dot)dirstamp
 @BUILD_CONCURRENCY_TRUE@am__objects_1 = concurrency/libcfa_d_a-coroutine.$(OBJEXT) \
@@ -122 +122 @@
 @BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_d_a-alarm.$(OBJEXT) \
 @BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_d_a-invoke.$(OBJEXT) \
-@BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_d_a-preemption.$(OBJEXT)
+@BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_d_a-signal.$(OBJEXT)
 am__objects_4 = libcfa_d_a-libcfa-prelude.$(OBJEXT) \
         libcfa_d_a-interpose.$(OBJEXT) \
@@ -138 +138 @@
         concurrency/kernel.c concurrency/monitor.c \
         concurrency/CtxSwitch-@MACHINE_TYPE@.S concurrency/alarm.c \
-        concurrency/invoke.c concurrency/preemption.c
+        concurrency/invoke.c concurrency/signal.c
 @BUILD_CONCURRENCY_TRUE@am__objects_5 = concurrency/libcfa_a-coroutine.$(OBJEXT) \
 @BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_a-thread.$(OBJEXT) \
@@ -154 +154 @@
 @BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_a-alarm.$(OBJEXT) \
 @BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_a-invoke.$(OBJEXT) \
-@BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_a-preemption.$(OBJEXT)
+@BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_a-signal.$(OBJEXT)
 am__objects_8 = libcfa_a-libcfa-prelude.$(OBJEXT) \
         libcfa_a-interpose.$(OBJEXT) \
@@ -445 +445 @@
 concurrency/libcfa_d_a-invoke.$(OBJEXT): concurrency/$(am__dirstamp) \
         concurrency/$(DEPDIR)/$(am__dirstamp)
-concurrency/libcfa_d_a-preemption.$(OBJEXT):  \
-        concurrency/$(am__dirstamp) \
+concurrency/libcfa_d_a-signal.$(OBJEXT): concurrency/$(am__dirstamp) \
         concurrency/$(DEPDIR)/$(am__dirstamp)
 libcfa-d.a: $(libcfa_d_a_OBJECTS) $(libcfa_d_a_DEPENDENCIES) $(EXTRA_libcfa_d_a_DEPENDENCIES) 
@@ -474 +473 @@
 concurrency/libcfa_a-invoke.$(OBJEXT): concurrency/$(am__dirstamp) \
         concurrency/$(DEPDIR)/$(am__dirstamp)
-concurrency/libcfa_a-preemption.$(OBJEXT):  \
-        concurrency/$(am__dirstamp) \
+concurrency/libcfa_a-signal.$(OBJEXT): concurrency/$(am__dirstamp) \
         concurrency/$(DEPDIR)/$(am__dirstamp)
 libcfa.a: $(libcfa_a_OBJECTS) $(libcfa_a_DEPENDENCIES) $(EXTRA_libcfa_a_DEPENDENCIES) 
@@ -490 +488 @@
         -rm -f concurrency/libcfa_a-kernel.$(OBJEXT)
         -rm -f concurrency/libcfa_a-monitor.$(OBJEXT)
-        -rm -f concurrency/libcfa_a-preemption.$(OBJEXT)
+        -rm -f concurrency/libcfa_a-signal.$(OBJEXT)
         -rm -f concurrency/libcfa_a-thread.$(OBJEXT)
         -rm -f concurrency/libcfa_d_a-alarm.$(OBJEXT)
@@ -497 +495 @@
         -rm -f concurrency/libcfa_d_a-kernel.$(OBJEXT)
         -rm -f concurrency/libcfa_d_a-monitor.$(OBJEXT)
-        -rm -f concurrency/libcfa_d_a-preemption.$(OBJEXT)
+        -rm -f concurrency/libcfa_d_a-signal.$(OBJEXT)
         -rm -f concurrency/libcfa_d_a-thread.$(OBJEXT)
         -rm -f containers/libcfa_a-maybe.$(OBJEXT)
@@ -539 +537 @@
 @AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_a-kernel.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_a-monitor.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_a-preemption.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_a-signal.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_a-thread.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_d_a-alarm.Po@am__quote@
@@ -546 +544 @@
 @AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_d_a-kernel.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_d_a-monitor.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_d_a-preemption.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_d_a-signal.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_d_a-thread.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@containers/$(DEPDIR)/libcfa_a-maybe.Po@am__quote@
@@ -871 +869 @@
 @am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_d_a-invoke.obj `if test -f 'concurrency/invoke.c'; then $(CYGPATH_W) 'concurrency/invoke.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/invoke.c'; fi`
 
-concurrency/libcfa_d_a-preemption.o: concurrency/preemption.c
-@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_d_a-preemption.o -MD -MP -MF concurrency/$(DEPDIR)/libcfa_d_a-preemption.Tpo -c -o concurrency/libcfa_d_a-preemption.o `test -f 'concurrency/preemption.c' || echo '$(srcdir)/'`concurrency/preemption.c
-@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_d_a-preemption.Tpo concurrency/$(DEPDIR)/libcfa_d_a-preemption.Po
-@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/preemption.c' object='concurrency/libcfa_d_a-preemption.o' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_d_a-preemption.o `test -f 'concurrency/preemption.c' || echo '$(srcdir)/'`concurrency/preemption.c
-
-concurrency/libcfa_d_a-preemption.obj: concurrency/preemption.c
-@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_d_a-preemption.obj -MD -MP -MF concurrency/$(DEPDIR)/libcfa_d_a-preemption.Tpo -c -o concurrency/libcfa_d_a-preemption.obj `if test -f 'concurrency/preemption.c'; then $(CYGPATH_W) 'concurrency/preemption.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/preemption.c'; fi`
-@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_d_a-preemption.Tpo concurrency/$(DEPDIR)/libcfa_d_a-preemption.Po
-@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/preemption.c' object='concurrency/libcfa_d_a-preemption.obj' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_d_a-preemption.obj `if test -f 'concurrency/preemption.c'; then $(CYGPATH_W) 'concurrency/preemption.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/preemption.c'; fi`
+concurrency/libcfa_d_a-signal.o: concurrency/signal.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_d_a-signal.o -MD -MP -MF concurrency/$(DEPDIR)/libcfa_d_a-signal.Tpo -c -o concurrency/libcfa_d_a-signal.o `test -f 'concurrency/signal.c' || echo '$(srcdir)/'`concurrency/signal.c
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_d_a-signal.Tpo concurrency/$(DEPDIR)/libcfa_d_a-signal.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/signal.c' object='concurrency/libcfa_d_a-signal.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_d_a-signal.o `test -f 'concurrency/signal.c' || echo '$(srcdir)/'`concurrency/signal.c
+
+concurrency/libcfa_d_a-signal.obj: concurrency/signal.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_d_a-signal.obj -MD -MP -MF concurrency/$(DEPDIR)/libcfa_d_a-signal.Tpo -c -o concurrency/libcfa_d_a-signal.obj `if test -f 'concurrency/signal.c'; then $(CYGPATH_W) 'concurrency/signal.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/signal.c'; fi`
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_d_a-signal.Tpo concurrency/$(DEPDIR)/libcfa_d_a-signal.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/signal.c' object='concurrency/libcfa_d_a-signal.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_d_a-signal.obj `if test -f 'concurrency/signal.c'; then $(CYGPATH_W) 'concurrency/signal.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/signal.c'; fi`
 
 libcfa_a-libcfa-prelude.obj: libcfa-prelude.c
@@ -1165 +1163 @@
 @am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_a-invoke.obj `if test -f 'concurrency/invoke.c'; then $(CYGPATH_W) 'concurrency/invoke.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/invoke.c'; fi`
 
-concurrency/libcfa_a-preemption.o: concurrency/preemption.c
-@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_a-preemption.o -MD -MP -MF concurrency/$(DEPDIR)/libcfa_a-preemption.Tpo -c -o concurrency/libcfa_a-preemption.o `test -f 'concurrency/preemption.c' || echo '$(srcdir)/'`concurrency/preemption.c
-@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_a-preemption.Tpo concurrency/$(DEPDIR)/libcfa_a-preemption.Po
-@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/preemption.c' object='concurrency/libcfa_a-preemption.o' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_a-preemption.o `test -f 'concurrency/preemption.c' || echo '$(srcdir)/'`concurrency/preemption.c
-
-concurrency/libcfa_a-preemption.obj: concurrency/preemption.c
-@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_a-preemption.obj -MD -MP -MF concurrency/$(DEPDIR)/libcfa_a-preemption.Tpo -c -o concurrency/libcfa_a-preemption.obj `if test -f 'concurrency/preemption.c'; then $(CYGPATH_W) 'concurrency/preemption.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/preemption.c'; fi`
-@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_a-preemption.Tpo concurrency/$(DEPDIR)/libcfa_a-preemption.Po
-@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/preemption.c' object='concurrency/libcfa_a-preemption.obj' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_a-preemption.obj `if test -f 'concurrency/preemption.c'; then $(CYGPATH_W) 'concurrency/preemption.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/preemption.c'; fi`
+concurrency/libcfa_a-signal.o: concurrency/signal.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_a-signal.o -MD -MP -MF concurrency/$(DEPDIR)/libcfa_a-signal.Tpo -c -o concurrency/libcfa_a-signal.o `test -f 'concurrency/signal.c' || echo '$(srcdir)/'`concurrency/signal.c
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_a-signal.Tpo concurrency/$(DEPDIR)/libcfa_a-signal.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/signal.c' object='concurrency/libcfa_a-signal.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_a-signal.o `test -f 'concurrency/signal.c' || echo '$(srcdir)/'`concurrency/signal.c
+
+concurrency/libcfa_a-signal.obj: concurrency/signal.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_a-signal.obj -MD -MP -MF concurrency/$(DEPDIR)/libcfa_a-signal.Tpo -c -o concurrency/libcfa_a-signal.obj `if test -f 'concurrency/signal.c'; then $(CYGPATH_W) 'concurrency/signal.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/signal.c'; fi`
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_a-signal.Tpo concurrency/$(DEPDIR)/libcfa_a-signal.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/signal.c' object='concurrency/libcfa_a-signal.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_a-signal.obj `if test -f 'concurrency/signal.c'; then $(CYGPATH_W) 'concurrency/signal.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/signal.c'; fi`
 install-nobase_cfa_includeHEADERS: $(nobase_cfa_include_HEADERS)
         @$(NORMAL_INSTALL)

src/libcfa/concurrency/alarm.c

@@ -1 @@
-//                              -*- Mode: CFA -*-
-//
-// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
-//
-// The contents of this file are covered under the licence agreement in the
-// file "LICENCE" distributed with Cforall.
-//
-// alarm.c --
-//
-// Author           : Thierry Delisle
-// Created On       : Fri Jun 2 11:31:25 2017
-// Last Modified By : Thierry Delisle
-// Last Modified On : --
-// Update Count     : 0
-//
-
-extern "C" {
-#include <time.h>
-#include <sys/time.h>
-}
-
-#include "alarm.h"
-#include "kernel_private.h"
-#include "preemption.h"
-
-//=============================================================================================
-// Clock logic
-//=============================================================================================
-
-__cfa_time_t __kernel_get_time() {
-        timespec curr;
-        clock_gettime( CLOCK_REALTIME, &curr );
-        return ((__cfa_time_t)curr.tv_sec * TIMEGRAN) + curr.tv_nsec;
-}
-
-void __kernel_set_timer( __cfa_time_t alarm ) {
-        itimerval val;
-        val.it_value.tv_sec = alarm / TIMEGRAN;                 // seconds
-        val.it_value.tv_usec = (alarm % TIMEGRAN) / ( TIMEGRAN / 1_000_000L ); // microseconds
-        val.it_interval.tv_sec = 0;
-        val.it_interval.tv_usec = 0;
-        setitimer( ITIMER_REAL, &val, NULL );
-}
-
-//=============================================================================================
-// Alarm logic
-//=============================================================================================
-
-void ?{}( alarm_node_t * this, thread_desc * thrd, __cfa_time_t alarm = 0, __cfa_time_t period = 0 ) {
-        this->thrd = thrd;
-        this->alarm = alarm;
-        this->period = period;
-        this->next = 0;
-        this->set = false;
-        this->kernel_alarm = false;
-}
-
-void ?{}( alarm_node_t * this, processor   * proc, __cfa_time_t alarm = 0, __cfa_time_t period = 0 ) {
-        this->proc = proc;
-        this->alarm = alarm;
-        this->period = period;
-        this->next = 0;
-        this->set = false;
-        this->kernel_alarm = true;
-}
-
-void ^?{}( alarm_node_t * this ) {
-        if( this->set ) {
-                unregister_self( this );
-        }
-}
-
-static inline void insert_at( alarm_list_t * this, alarm_node_t * n, __alarm_it_t p ) {
-        assert( !n->next );
-        if( p == this->tail ) {
-                this->tail = &n->next;
-        }
-        else {
-                n->next = *p;
-        }
-        *p = n;
-}
-
-void insert( alarm_list_t * this, alarm_node_t * n ) {
-        alarm_node_t ** it = &this->head;
-        while( (*it) && (n->alarm > (*it)->alarm) ) {
-                it = &(*it)->next;
-        }
-
-        insert_at( this, n, it );
-}
-
-alarm_node_t * pop( alarm_list_t * this ) {
-        alarm_node_t * head = this->head;
-        if( head ) {
-                this->head = head->next;
-                if( !head->next ) {
-                        this->tail = &this->head;
-                }
-                head->next = NULL;
-        }
-        return head;
-}
-
-static inline void remove_at( alarm_list_t * this, alarm_node_t * n, __alarm_it_t it ) {
-        assert( it );
-        assert( (*it)->next == n );
-
-        (*it)->next = n->next;
-        if( !n-> next ) {
-                this->tail = it;
-        }
-        n->next = NULL;
-}
-
-static inline void remove( alarm_list_t * this, alarm_node_t * n ) {
-        alarm_node_t ** it = &this->head;
-        while( (*it) && (*it)->next != n ) {
-                it = &(*it)->next;
-        }
-
-        if( *it ) { remove_at( this, n, it ); }
-}
-
-void register_self( alarm_node_t * this ) {
-        disable_interrupts();
-        assert( !systemProcessor->pending_alarm );
-        lock( &systemProcessor->alarm_lock );
-        {
-                insert( &systemProcessor->alarms, this );
-                if( systemProcessor->pending_alarm ) {
-                        tick_preemption();
-                }
-        }
-        unlock( &systemProcessor->alarm_lock );
-        this->set = true;
-        enable_interrupts();
-}
-
-void unregister_self( alarm_node_t * this ) {
-        disable_interrupts();
-        lock( &systemProcessor->alarm_lock );
-        remove( &systemProcessor->alarms, this );
-        unlock( &systemProcessor->alarm_lock );
-        disable_interrupts();
-        this->set = false;
-}

src/libcfa/concurrency/kernel

@@ -28 +28 @@
 //-----------------------------------------------------------------------------
 // Locks
-bool try_lock( spinlock * );
 void lock( spinlock * );
 void unlock( spinlock * );
@@ -86 +85 @@
 
         struct FinishAction finish;
-
-        struct alarm_node_t * preemption_alarm;
-        unsigned int preemption;
-
-        unsigned short disable_preempt_count;
-
-        bool pending_preemption;
 };
 
@@ -102 +94 @@
 
 // Local Variables: //
-// mode: CFA //
-// tab-width: 6 //
+// mode: c //
+// tab-width: 4 //
 // End: //

src/libcfa/concurrency/kernel.c

@@ -36 +36 @@
 //CFA Includes
 #include "libhdr.h"
-#include "preemption.h"
 
 //Private includes
@@ -48 +47 @@
 KERNEL_STORAGE(processorCtx_t, systemProcessorCtx);
 KERNEL_STORAGE(cluster, systemCluster);
-KERNEL_STORAGE(system_proc_t, systemProcessor);
+KERNEL_STORAGE(processor, systemProcessor);
 KERNEL_STORAGE(thread_desc, mainThread);
 KERNEL_STORAGE(machine_context_t, mainThread_context);
 
 cluster * systemCluster;
-system_proc_t * systemProcessor;
+processor * systemProcessor;
 thread_desc * mainThread;
 
@@ -119 +118 @@
 // Processor coroutine
 void ?{}(processorCtx_t * this, processor * proc) {
-        (&this->__cor){ "Processor" };
+        (&this->__cor){};
         this->proc = proc;
         proc->runner = this;
@@ -140 +139 @@
         (&this->terminated){};
         this->is_terminated = false;
-        this->preemption_alarm = NULL;
-        this->preemption = default_preemption();
-        this->disable_preempt_count = 1;                //Start with interrupts disabled
-        this->pending_preemption = false;
 
         start( this );
@@ -154 +149 @@
         (&this->terminated){};
         this->is_terminated = false;
-        this->disable_preempt_count = 0;
-        this->pending_preemption = false;
 
         this->runner = runner;
         LIB_DEBUG_PRINT_SAFE("Kernel : constructing processor context %p\n", runner);
         runner{ this };
-}
-
-void ?{}(system_proc_t * this, cluster * cltr, processorCtx_t * runner) {
-        (&this->alarms){};
-        (&this->alarm_lock){};
-        this->pending_alarm = false;
-
-        (&this->proc){ cltr, runner };
 }
 
@@ -193 +178 @@
 void main(processorCtx_t * runner) {
         processor * this = runner->proc;
-
         LIB_DEBUG_PRINT_SAFE("Kernel : core %p starting\n", this);
 
+        thread_desc * readyThread = NULL;
+        for( unsigned int spin_count = 0; ! this->is_terminated; spin_count++ ) 
         {
-                // Setup preemption data
-                preemption_scope scope = { this };
-
-                LIB_DEBUG_PRINT_SAFE("Kernel : core %p started\n", this);
-
-                thread_desc * readyThread = NULL;
-                for( unsigned int spin_count = 0; ! this->is_terminated; spin_count++ ) 
+                readyThread = nextThread( this->cltr );
+
+                if(readyThread) 
                 {
-                        readyThread = nextThread( this->cltr );
-
-                        if(readyThread)
-                        {
-                                runThread(this, readyThread);
-
-                                //Some actions need to be taken from the kernel
-                                finishRunning(this);
-
-                                spin_count = 0;
-                        }
-                        else
-                        {
-                                spin(this, &spin_count);
-                        }
-                }
-
-                LIB_DEBUG_PRINT_SAFE("Kernel : core %p stopping\n", this);
-        }
-
+                        runThread(this, readyThread);
+
+                        //Some actions need to be taken from the kernel
+                        finishRunning(this);
+
+                        spin_count = 0;
+                } 
+                else 
+                {
+                        spin(this, &spin_count);
+                }               
+        }
+
+        LIB_DEBUG_PRINT_SAFE("Kernel : core %p unlocking thread\n", this);
         signal( &this->terminated );
         LIB_DEBUG_PRINT_SAFE("Kernel : core %p terminated\n", this);
@@ -323 +299 @@
         LIB_DEBUG_PRINT_SAFE("Kernel : Starting core %p\n", this);
         
+        // pthread_attr_t attributes;
+        // pthread_attr_init( &attributes );
+
         pthread_create( &this->kernel_thread, NULL, CtxInvokeProcessor, (void*)this );
+
+        // pthread_attr_destroy( &attributes );
 
         LIB_DEBUG_PRINT_SAFE("Kernel : core %p started\n", this);       
@@ -335 +316 @@
         assertf( thrd->next == NULL, "Expected null got %p", thrd->next );
         
-        lock( &systemProcessor->proc.cltr->lock );
-        append( &systemProcessor->proc.cltr->ready_queue, thrd );
-        unlock( &systemProcessor->proc.cltr->lock );
+        lock( &systemProcessor->cltr->lock );
+        append( &systemProcessor->cltr->ready_queue, thrd );
+        unlock( &systemProcessor->cltr->lock );
 }
 
@@ -386 +367 @@
 }
 
-//=============================================================================================
-// Kernel Setup logic
-//=============================================================================================
 //-----------------------------------------------------------------------------
 // Kernel boot procedures
@@ -401 +379 @@
         mainThread{ &info };
 
-        LIB_DEBUG_PRINT_SAFE("Kernel : Main thread ready\n");
-
-        // Enable preemption
-        kernel_start_preemption();
-
         // Initialize the system cluster
         systemCluster = (cluster *)&systemCluster_storage;
         systemCluster{};
 
-        LIB_DEBUG_PRINT_SAFE("Kernel : System cluster ready\n");
-
         // Initialize the system processor and the system processor ctx
         // (the coroutine that contains the processing control flow)
-        systemProcessor = (system_proc_t *)&systemProcessor_storage;
+        systemProcessor = (processor *)&systemProcessor_storage;
         systemProcessor{ systemCluster, (processorCtx_t *)&systemProcessorCtx_storage };
 
         // Add the main thread to the ready queue 
-        // once resume is called on systemProcessor->runner the mainThread needs to be scheduled like any normal thread
+        // once resume is called on systemProcessor->ctx the mainThread needs to be scheduled like any normal thread
         ScheduleThread(mainThread);
 
         //initialize the global state variables
-        this_processor = &systemProcessor->proc;
+        this_processor = systemProcessor;
         this_processor->current_thread = mainThread;
         this_processor->current_coroutine = &mainThread->cor;
@@ -429 +400 @@
         // context. Hence, the main thread does not begin through CtxInvokeThread, like all other threads. The trick here is that
         // mainThread is on the ready queue when this call is made. 
-        resume( systemProcessor->proc.runner );
+        resume(systemProcessor->runner);
 
 
@@ -443 +414 @@
         // When its coroutine terminates, it return control to the mainThread
         // which is currently here
-        systemProcessor->proc.is_terminated = true;
+        systemProcessor->is_terminated = true;
         suspend();
 
@@ -450 +421 @@
         // Destroy the system processor and its context in reverse order of construction
         // These were manually constructed so we need manually destroy them
-        ^(systemProcessor->proc.runner){};
+        ^(systemProcessor->runner){};
         ^(systemProcessor){};
 
@@ -513 +484 @@
 }
 
-//=============================================================================================
-// Kernel Utilities
-//=============================================================================================
 //-----------------------------------------------------------------------------
 // Locks
@@ -523 +491 @@
 void ^?{}( spinlock * this ) {
 
-}
-
-bool try_lock( spinlock * this ) {
-        return this->lock == 0 && __sync_lock_test_and_set_4( &this->lock, 1 ) == 0;
 }
 

src/libcfa/concurrency/kernel_private.h

@@ -21 +21 @@
 #include "thread"
 
-#include "alarm.h"
-
 //-----------------------------------------------------------------------------
 // Scheduler
@@ -37 +35 @@
 //-----------------------------------------------------------------------------
 // Processor
-coroutine processorCtx_t {
+struct processorCtx_t {
         processor * proc;
+        coroutine_desc __cor;
 };
+
+DECL_COROUTINE(processorCtx_t);
 
 void main(processorCtx_t *);
@@ -46 +47 @@
 void finishRunning(processor * this);
 void spin(processor * this, unsigned int * spin_count);
-
-struct system_proc_t {
-        processor proc;
-
-        alarm_list_t alarms;
-        spinlock alarm_lock;
-
-        bool pending_alarm;
-};
-
-extern cluster * systemCluster;
-extern system_proc_t * systemProcessor;
-extern thread_local processor * this_processor;
-
-static inline void disable_interrupts() {
-        __attribute__((unused)) unsigned short prev = __atomic_fetch_add_2( &this_processor->disable_preempt_count, 1, __ATOMIC_SEQ_CST );
-        assert( prev != (unsigned short) -1 );
-}
-
-static inline void enable_interrupts_noRF() {
-        unsigned short prev = __atomic_fetch_add_2( &this_processor->disable_preempt_count, -1, __ATOMIC_SEQ_CST );
-        assert( prev != (unsigned short) 0 );
-}
-
-static inline void enable_interrupts() {
-        unsigned short prev = __atomic_fetch_add_2( &this_processor->disable_preempt_count, -1, __ATOMIC_SEQ_CST );
-        assert( prev != (unsigned short) 0 );
-        if( prev == 1 && this_processor->pending_preemption ) {
-                ScheduleInternal( this_processor->current_thread );
-                this_processor->pending_preemption = false;
-        }
-}
 
 //-----------------------------------------------------------------------------

src/libcfa/concurrency/monitor

@@ -92 +92 @@
 uintptr_t front( condition * this );
 
-struct __acceptable_t {
-        void (*func)(void);
-        unsigned short count;
-        monitor_desc * monitors[1];
-};
-
-void __accept_internal( unsigned short count, __acceptable_t * acceptables, void (*func)(void) );
-
 #endif //MONITOR_H

src/libcfa/concurrency/monitor.c

@@ -212 +212 @@
         ScheduleInternal( locks, count, threads, thread_count );
 
-
         //WE WOKE UP
 
@@ -313 +312 @@
         ScheduleInternal( locks, count, &signallee, 1 );
 
-
-
-
         LIB_DEBUG_PRINT_SAFE( "Back from signal block\n" );
 
@@ -334 +330 @@
         );
         return this->blocked.head->user_info;
-}
-
-//-----------------------------------------------------------------------------
-// Internal scheduling
-void __accept_internal( unsigned short count, __acceptable_t * acceptables, void (*func)(void) ) {
-        // thread_desc * this = this_thread();
-
-        // unsigned short count = this->current_monitor_count;
-        // unsigned int recursions[ count ];            //Save the current recursion levels to restore them later
-        // spinlock *   locks     [ count ];            //We need to pass-in an array of locks to ScheduleInternal
-
-        // lock_all( this->current_monitors, locks, count );
-
-
-
-
-
-        // // // Everything is ready to go to sleep
-        // // ScheduleInternal( locks, count, threads, thread_count );
-
-
-        // //WE WOKE UP
-
-
-        // //We are back, restore the owners and recursions
-        // lock_all( locks, count );
-        // restore_recursion( this->monitors, recursions, count );
-        // unlock_all( locks, count );
 }
 

src/main.cc

@@ -146 +146 @@
 } // sigSegvBusHandler
 
-void sigAbortHandler( __attribute__((unused)) int sig_num ) {
+void sigAbortHandler( int sig_num ) {
         backtrace( 6 );                                                                         // skip first 6 stack frames
         signal( SIGABRT, SIG_DFL);                                                      // reset default signal handler

src/tests/test.py

@@ -197 +197 @@
                         # fetch return code and error from the diff command
                         retcode, error = diff(".expect/%s.txt" % test.path, ".out/%s.log" % test.name, dry_run)
-
-        else:
-                with open (out_file, "r") as myfile:
-                        error = myfile.read()
-
-                
         # clean the executable
         sh("rm -f %s > /dev/null 2>&1" % test.name, dry_run)