Index: benchmark/io/http/main.cfa =================================================================== --- benchmark/io/http/main.cfa (revision 98168b962cfa480dd25d7905d6efa2c3bbb01645) +++ benchmark/io/http/main.cfa (revision 73a3be5b5f45d10ada01ab1d492f881e78767ff4) @@ -75,7 +75,22 @@ address.sin_port = htons( options.socket.port ); - ret = bind( server_fd, (struct sockaddr *)&address, sizeof(address) ); - if(ret < 0) { - abort( "bind error: (%d) %s\n", (int)errno, strerror(errno) ); + int waited = 0; + for() { + ret = bind( server_fd, (struct sockaddr *)&address, sizeof(address) ); + if(ret < 0) { + if(errno == 98) { + if(waited == 0) { + printf("Waiting for port\n"); + } else { + printf("\r%d", waited); + fflush(stdout); + } + waited ++; + sleep( 1`s ); + continue; + } + abort( "bind error: (%d) %s\n", (int)errno, strerror(errno) ); + } + break; } Index: libcfa/src/concurrency/coroutine.cfa =================================================================== --- libcfa/src/concurrency/coroutine.cfa (revision 98168b962cfa480dd25d7905d6efa2c3bbb01645) +++ libcfa/src/concurrency/coroutine.cfa (revision 73a3be5b5f45d10ada01ab1d492f881e78767ff4) @@ -28,4 +28,5 @@ #include "kernel_private.hfa" #include "exception.hfa" +#include "math.hfa" #define __CFA_INVOKE_PRIVATE__ @@ -87,4 +88,5 @@ void __stack_prepare( __stack_info_t * this, size_t create_size ); +void __stack_clean ( __stack_info_t * this ); //----------------------------------------------------------------------------- @@ -107,16 +109,17 @@ bool userStack = ((intptr_t)this.storage & 0x1) != 0; if ( ! userStack && this.storage ) { - __attribute__((may_alias)) intptr_t * istorage = (intptr_t *)&this.storage; - *istorage &= (intptr_t)-1; - - void * storage = this.storage->limit; - __cfaabi_dbg_debug_do( - storage = (char*)(storage) - __page_size; - if ( mprotect( storage, __page_size, PROT_READ | PROT_WRITE ) == -1 ) { - abort( "(coStack_t *)%p.^?{}() : internal error, mprotect failure, error(%d) %s.", &this, errno, strerror( errno ) ); - } - ); - __cfaabi_dbg_print_safe("Kernel : Deleting stack %p\n", storage); - free( storage ); + __stack_clean( &this ); + // __attribute__((may_alias)) intptr_t * istorage = (intptr_t *)&this.storage; + // *istorage &= (intptr_t)-1; + + // void * storage = this.storage->limit; + // __cfaabi_dbg_debug_do( + // storage = (char*)(storage) - __page_size; + // if ( mprotect( storage, __page_size, PROT_READ | PROT_WRITE ) == -1 ) { + // abort( "(coStack_t *)%p.^?{}() : internal error, mprotect failure, error(%d) %s.", &this, errno, strerror( errno ) ); + // } + // ); + // __cfaabi_dbg_print_safe("Kernel : Deleting stack %p\n", storage); + // free( storage ); } } @@ -167,24 +170,43 @@ assert(__page_size != 0l); size_t size = libCeiling( storageSize, 16 ) + stack_data_size; + size = ceiling(size, __page_size); // If we are running debug, we also need to allocate a guardpage to catch stack overflows. void * storage; - __cfaabi_dbg_debug_do( - storage = memalign( __page_size, size + __page_size ); - ); - __cfaabi_dbg_no_debug_do( - storage = (void*)malloc(size); - ); - - __cfaabi_dbg_print_safe("Kernel : Created stack %p of size %zu\n", storage, size); - __cfaabi_dbg_debug_do( - if ( mprotect( storage, __page_size, PROT_NONE ) == -1 ) { - abort( "__stack_alloc : internal error, mprotect failure, error(%d) %s.", (int)errno, strerror( (int)errno ) ); - } - storage = (void *)(((intptr_t)storage) + __page_size); - ); + // __cfaabi_dbg_debug_do( + // storage = memalign( __page_size, size + __page_size ); + // ); + // __cfaabi_dbg_no_debug_do( + // storage = (void*)malloc(size); + // ); + + // __cfaabi_dbg_print_safe("Kernel : Created stack %p of size %zu\n", storage, size); + // __cfaabi_dbg_debug_do( + // if ( mprotect( storage, __page_size, PROT_NONE ) == -1 ) { + // abort( "__stack_alloc : internal error, mprotect failure, error(%d) %s.", (int)errno, strerror( (int)errno ) ); + // } + // storage = (void *)(((intptr_t)storage) + __page_size); + // ); + storage = mmap(0p, size + __page_size, PROT_EXEC | PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0); + if(storage == ((void*)-1)) { + abort( "coroutine stack creation : internal error, mmap failure, error(%d) %s.", errno, strerror( errno ) ); + } + if ( mprotect( storage, __page_size, PROT_NONE ) == -1 ) { + abort( "coroutine stack creation : internal error, mprotect failure, error(%d) %s.", errno, strerror( errno ) ); + } // if + storage = (void *)(((intptr_t)storage) + __page_size); verify( ((intptr_t)storage & (libAlign() - 1)) == 0ul ); return [storage, size]; +} + +void __stack_clean ( __stack_info_t * this ) { + size_t size = ((intptr_t)this->storage->base) - ((intptr_t)this->storage->limit) + sizeof(__stack_t); + void * storage = this->storage->limit; + + storage = (void *)(((intptr_t)storage) - __page_size); + if(munmap(storage, size + __page_size) == -1) { + abort( "coroutine stack destruction : internal error, munmap failure, error(%d) %s.", errno, strerror( errno ) ); + } } @@ -210,7 +232,7 @@ assertf( size >= MinStackSize, "Stack size %zd provides less than minimum of %zd bytes for a stack.", size, MinStackSize ); - this->storage = (__stack_t *)((intptr_t)storage + size); + this->storage = (__stack_t *)((intptr_t)storage + size - sizeof(__stack_t)); this->storage->limit = storage; - this->storage->base = (void*)((intptr_t)storage + size); + this->storage->base = (void*)((intptr_t)storage + size - sizeof(__stack_t)); this->storage->exception_context.top_resume = 0p; this->storage->exception_context.current_exception = 0p; Index: libcfa/src/concurrency/coroutine.hfa =================================================================== --- libcfa/src/concurrency/coroutine.hfa (revision 98168b962cfa480dd25d7905d6efa2c3bbb01645) +++ libcfa/src/concurrency/coroutine.hfa (revision 73a3be5b5f45d10ada01ab1d492f881e78767ff4) @@ -102,5 +102,7 @@ } -extern void __stack_prepare ( __stack_info_t * this, size_t size /* ignored if storage already allocated */); +extern void __stack_prepare( __stack_info_t * this, size_t size /* ignored if storage already allocated */); +extern void __stack_clean ( __stack_info_t * this ); + // Suspend implementation inlined for performance Index: libcfa/src/concurrency/io/setup.cfa =================================================================== --- libcfa/src/concurrency/io/setup.cfa (revision 98168b962cfa480dd25d7905d6efa2c3bbb01645) +++ libcfa/src/concurrency/io/setup.cfa (revision 73a3be5b5f45d10ada01ab1d492f881e78767ff4) @@ -17,4 +17,9 @@ #define _GNU_SOURCE /* See feature_test_macros(7) */ +#if defined(__CFA_DEBUG__) + // #define __CFA_DEBUG_PRINT_IO__ + // #define __CFA_DEBUG_PRINT_IO_CORE__ +#endif + #include "io/types.hfa" #include "kernel.hfa" @@ -111,5 +116,5 @@ void __kernel_io_startup(void) { - __cfaabi_dbg_print_safe( "Kernel : Creating EPOLL instance\n" ); + __cfadbg_print_safe(io_core, "Kernel : Creating EPOLL instance\n" ); iopoll.epollfd = epoll_create1(0); @@ -118,5 +123,5 @@ } - __cfaabi_dbg_print_safe( "Kernel : Starting io poller thread\n" ); + __cfadbg_print_safe(io_core, "Kernel : Starting io poller thread\n" ); iopoll.run = true; @@ -132,6 +137,5 @@ // Wait for the io poller thread to finish - pthread_join( iopoll.thrd, 0p ); - free( iopoll.stack ); + __destroy_pthread( iopoll.thrd, iopoll.stack, 0p ); int ret = close(iopoll.epollfd); @@ -142,5 +146,5 @@ // Io polling is now fully stopped - __cfaabi_dbg_print_safe( "Kernel : IO poller stopped\n" ); + __cfadbg_print_safe(io_core, "Kernel : IO poller stopped\n" ); } @@ -150,5 +154,5 @@ id.id = doregister(&id); __cfaabi_tls.this_proc_id = &id; - __cfaabi_dbg_print_safe( "Kernel : IO poller thread starting\n" ); + __cfadbg_print_safe(io_core, "Kernel : IO poller thread starting\n" ); // Block signals to control when they arrive @@ -185,5 +189,5 @@ } - __cfaabi_dbg_print_safe( "Kernel : IO poller thread stopping\n" ); + __cfadbg_print_safe(io_core, "Kernel : IO poller thread stopping\n" ); unregister(&id); return 0p; Index: libcfa/src/concurrency/kernel/startup.cfa =================================================================== --- libcfa/src/concurrency/kernel/startup.cfa (revision 98168b962cfa480dd25d7905d6efa2c3bbb01645) +++ libcfa/src/concurrency/kernel/startup.cfa (revision 73a3be5b5f45d10ada01ab1d492f881e78767ff4) @@ -29,4 +29,5 @@ #include "kernel_private.hfa" #include "startup.hfa" // STARTUP_PRIORITY_XXX +#include "math.hfa" //----------------------------------------------------------------------------- @@ -539,4 +540,5 @@ } +extern size_t __page_size; void ^?{}(processor & this) with( this ){ if( ! __atomic_load_n(&do_terminate, __ATOMIC_ACQUIRE) ) { @@ -550,8 +552,5 @@ } - int err = pthread_join( kernel_thread, 0p ); - if( err != 0 ) abort("KERNEL ERROR: joining processor %p caused error %s\n", &this, strerror(err)); - - free( this.stack ); + __destroy_pthread( kernel_thread, this.stack, 0p ); disable_interrupts(); @@ -678,14 +677,23 @@ void * stack; - __cfaabi_dbg_debug_do( - stack = memalign( __page_size, stacksize + __page_size ); - // pthread has no mechanism to create the guard page in user supplied stack. - if ( mprotect( stack, __page_size, PROT_NONE ) == -1 ) { - abort( "mprotect : internal error, mprotect failure, error(%d) %s.", errno, strerror( errno ) ); - } // if - ); - __cfaabi_dbg_no_debug_do( - stack = malloc( stacksize ); - ); + #warning due to the thunk problem, stack creation uses mmap, revert to malloc once this goes away + // __cfaabi_dbg_debug_do( + // stack = memalign( __page_size, stacksize + __page_size ); + // // pthread has no mechanism to create the guard page in user supplied stack. + // if ( mprotect( stack, __page_size, PROT_NONE ) == -1 ) { + // abort( "mprotect : internal error, mprotect failure, error(%d) %s.", errno, strerror( errno ) ); + // } // if + // ); + // __cfaabi_dbg_no_debug_do( + // stack = malloc( stacksize ); + // ); + stacksize = ceiling( stacksize, __page_size ) + __page_size; + stack = mmap(0p, stacksize, PROT_EXEC | PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0); + if(stack == ((void*)-1)) { + abort( "pthread stack creation : internal error, mmap failure, error(%d) %s.", errno, strerror( errno ) ); + } + if ( mprotect( stack, __page_size, PROT_NONE ) == -1 ) { + abort( "pthread stack creation : internal error, mprotect failure, error(%d) %s.", errno, strerror( errno ) ); + } // if check( pthread_attr_setstack( &attr, stack, stacksize ), "pthread_attr_setstack" ); @@ -694,4 +702,24 @@ return stack; } + +void __destroy_pthread( pthread_t pthread, void * stack, void ** retval ) { + int err = pthread_join( pthread, retval ); + if( err != 0 ) abort("KERNEL ERROR: joining pthread %p caused error %s\n", (void*)pthread, strerror(err)); + + pthread_attr_t attr; + + check( pthread_attr_init( &attr ), "pthread_attr_init" ); // initialize attribute + + size_t stacksize; + // default stack size, normally defined by shell limit + check( pthread_attr_getstacksize( &attr, &stacksize ), "pthread_attr_getstacksize" ); + assert( stacksize >= PTHREAD_STACK_MIN ); + stacksize += __page_size; + + if(munmap(stack, stacksize) == -1) { + abort( "pthread stack destruction : internal error, munmap failure, error(%d) %s.", errno, strerror( errno ) ); + } +} + #if defined(__CFA_WITH_VERIFY__) Index: libcfa/src/concurrency/kernel_private.hfa =================================================================== --- libcfa/src/concurrency/kernel_private.hfa (revision 98168b962cfa480dd25d7905d6efa2c3bbb01645) +++ libcfa/src/concurrency/kernel_private.hfa (revision 73a3be5b5f45d10ada01ab1d492f881e78767ff4) @@ -49,4 +49,5 @@ void * __create_pthread( pthread_t *, void * (*)(void *), void * ); +void __destroy_pthread( pthread_t pthread, void * stack, void ** retval ); Index: libcfa/src/concurrency/preemption.cfa =================================================================== --- libcfa/src/concurrency/preemption.cfa (revision 98168b962cfa480dd25d7905d6efa2c3bbb01645) +++ libcfa/src/concurrency/preemption.cfa (revision 73a3be5b5f45d10ada01ab1d492f881e78767ff4) @@ -575,6 +575,5 @@ // Wait for the preemption thread to finish - pthread_join( alarm_thread, 0p ); - free( alarm_stack ); + __destroy_pthread( alarm_thread, alarm_stack, 0p ); // Preemption is now fully stopped Index: libcfa/src/heap.cfa =================================================================== --- libcfa/src/heap.cfa (revision 98168b962cfa480dd25d7905d6efa2c3bbb01645) +++ libcfa/src/heap.cfa (revision 73a3be5b5f45d10ada01ab1d492f881e78767ff4) @@ -10,6 +10,6 @@ // Created On : Tue Dec 19 21:58:35 2017 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon Sep 7 22:17:46 2020 -// Update Count : 957 +// Last Modified On : Fri Dec 11 07:36:34 2020 +// Update Count : 970 // @@ -464,4 +464,22 @@ } // headers +#ifdef __CFA_DEBUG__ +#if __SIZEOF_POINTER__ == 4 +#define MASK 0xdeadbeef +#else +#define MASK 0xdeadbeefdeadbeef +#endif +#define STRIDE size_t + +static void * Memset( void * addr, STRIDE size ) { // debug only + if ( size % sizeof(STRIDE) != 0 ) abort( "Memset() : internal error, size %zd not multiple of %zd.", size, sizeof(STRIDE) ); + if ( (STRIDE)addr % sizeof(STRIDE) != 0 ) abort( "Memset() : internal error, addr %p not multiple of %zd.", addr, sizeof(STRIDE) ); + + STRIDE * end = (STRIDE *)addr + size / sizeof(STRIDE); + for ( STRIDE * p = (STRIDE *)addr; p < end; p += 1 ) *p = MASK; + return addr; +} // Memset +#endif // __CFA_DEBUG__ + #define NO_MEMORY_MSG "insufficient heap memory available for allocating %zd new bytes." @@ -483,5 +501,6 @@ #ifdef __CFA_DEBUG__ // Set new memory to garbage so subsequent uninitialized usages might fail. - memset( (char *)heapEnd + heapRemaining, '\377', increase ); + //memset( (char *)heapEnd + heapRemaining, '\377', increase ); + Memset( (char *)heapEnd + heapRemaining, increase ); #endif // __CFA_DEBUG__ rem = heapRemaining + increase - size; @@ -557,5 +576,6 @@ #ifdef __CFA_DEBUG__ // Set new memory to garbage so subsequent uninitialized usages might fail. - memset( block, '\377', tsize ); + //memset( block, '\377', tsize ); + Memset( block, tsize ); #endif // __CFA_DEBUG__ block->header.kind.real.blockSize = tsize; // storage size for munmap @@ -606,5 +626,6 @@ #ifdef __CFA_DEBUG__ // Set free memory to garbage so subsequent usages might fail. - memset( ((HeapManager.Storage *)header)->data, '\377', freeElem->blockSize - sizeof( HeapManager.Storage ) ); + //memset( ((HeapManager.Storage *)header)->data, '\377', freeElem->blockSize - sizeof( HeapManager.Storage ) ); + Memset( ((HeapManager.Storage *)header)->data, freeElem->blockSize - sizeof( HeapManager.Storage ) ); #endif // __CFA_DEBUG__ @@ -935,5 +956,5 @@ header->kind.real.size = size; // reset allocation size if ( unlikely( ozfill ) && size > osize ) { // previous request zero fill and larger ? - memset( (char *)oaddr + osize, (int)'\0', size - osize ); // initialize added storage + memset( (char *)oaddr + osize, '\0', size - osize ); // initialize added storage } // if return oaddr; @@ -960,5 +981,5 @@ header->kind.real.blockSize |= 2; // mark new request as zero filled if ( size > osize ) { // previous request larger ? - memset( (char *)naddr + osize, (int)'\0', size - osize ); // initialize added storage + memset( (char *)naddr + osize, '\0', size - osize ); // initialize added storage } // if } // if @@ -1327,5 +1348,5 @@ header->kind.real.blockSize |= 2; // mark new request as zero filled if ( size > osize ) { // previous request larger ? - memset( (char *)naddr + osize, (int)'\0', size - osize ); // initialize added storage + memset( (char *)naddr + osize, '\0', size - osize ); // initialize added storage } // if } // if Index: src/AST/Convert.cpp =================================================================== --- src/AST/Convert.cpp (revision 98168b962cfa480dd25d7905d6efa2c3bbb01645) +++ src/AST/Convert.cpp (revision 73a3be5b5f45d10ada01ab1d492f881e78767ff4) @@ -233,5 +233,4 @@ const ast::Decl * namedTypePostamble( NamedTypeDecl * decl, const ast::NamedTypeDecl * node ) { // base comes from constructor - decl->parameters = get().acceptL( node->params ); decl->assertions = get().acceptL( node->assertions ); declPostamble( decl, node ); @@ -1704,5 +1703,4 @@ cache.emplace( old, decl ); decl->assertions = GET_ACCEPT_V(assertions, DeclWithType); - decl->params = GET_ACCEPT_V(parameters, TypeDecl); decl->extension = old->extension; decl->uniqueId = old->uniqueId; @@ -1720,5 +1718,4 @@ ); decl->assertions = GET_ACCEPT_V(assertions, DeclWithType); - decl->params = GET_ACCEPT_V(parameters, TypeDecl); decl->extension = old->extension; decl->uniqueId = old->uniqueId; Index: src/AST/Decl.hpp =================================================================== --- src/AST/Decl.hpp (revision 98168b962cfa480dd25d7905d6efa2c3bbb01645) +++ src/AST/Decl.hpp (revision 73a3be5b5f45d10ada01ab1d492f881e78767ff4) @@ -154,5 +154,4 @@ public: ptr base; - std::vector> params; std::vector> assertions; @@ -160,5 +159,5 @@ const CodeLocation & loc, const std::string & name, Storage::Classes storage, const Type * b, Linkage::Spec spec = Linkage::Cforall ) - : Decl( loc, name, storage, spec ), base( b ), params(), assertions() {} + : Decl( loc, name, storage, spec ), base( b ), assertions() {} /// Produces a name for the kind of alias Index: src/AST/Pass.impl.hpp =================================================================== --- src/AST/Pass.impl.hpp (revision 98168b962cfa480dd25d7905d6efa2c3bbb01645) +++ src/AST/Pass.impl.hpp (revision 73a3be5b5f45d10ada01ab1d492f881e78767ff4) @@ -609,5 +609,4 @@ VISIT({ guard_symtab guard { *this }; - maybe_accept( node, &TypeDecl::params ); maybe_accept( node, &TypeDecl::base ); }) @@ -638,5 +637,4 @@ VISIT({ guard_symtab guard { *this }; - maybe_accept( node, &TypedefDecl::params ); maybe_accept( node, &TypedefDecl::base ); }) Index: src/AST/Print.cpp =================================================================== --- src/AST/Print.cpp (revision 98168b962cfa480dd25d7905d6efa2c3bbb01645) +++ src/AST/Print.cpp (revision 73a3be5b5f45d10ada01ab1d492f881e78767ff4) @@ -221,11 +221,4 @@ ++indent; node->base->accept( *this ); - --indent; - } - - if ( ! node->params.empty() ) { - os << endl << indent << "... with parameters" << endl; - ++indent; - printAll( node->params ); --indent; } Index: src/Common/PassVisitor.impl.h =================================================================== --- src/Common/PassVisitor.impl.h (revision 98168b962cfa480dd25d7905d6efa2c3bbb01645) +++ src/Common/PassVisitor.impl.h (revision 73a3be5b5f45d10ada01ab1d492f881e78767ff4) @@ -835,5 +835,4 @@ { auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); - maybeAccept_impl( node->parameters, *this ); maybeAccept_impl( node->base , *this ); } @@ -858,5 +857,4 @@ { auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); - maybeAccept_impl( node->parameters, *this ); maybeAccept_impl( node->base , *this ); } @@ -880,5 +878,4 @@ { auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); - maybeMutate_impl( node->parameters, *this ); maybeMutate_impl( node->base , *this ); } @@ -904,5 +901,4 @@ { auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); - maybeAccept_impl( node->parameters, *this ); maybeAccept_impl( node->base , *this ); } @@ -921,5 +917,4 @@ { auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); - maybeAccept_impl( node->parameters, *this ); maybeAccept_impl( node->base , *this ); } @@ -938,5 +933,4 @@ { auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); - maybeMutate_impl( node->parameters, *this ); maybeMutate_impl( node->base , *this ); } Index: src/Parser/TypeData.cc =================================================================== --- src/Parser/TypeData.cc (revision 98168b962cfa480dd25d7905d6efa2c3bbb01645) +++ src/Parser/TypeData.cc (revision 73a3be5b5f45d10ada01ab1d492f881e78767ff4) @@ -900,5 +900,4 @@ ret = new TypeDecl( name, scs, typebuild( td->base ), TypeDecl::Dtype, true ); } // if - buildList( td->symbolic.params, ret->get_parameters() ); buildList( td->symbolic.assertions, ret->get_assertions() ); ret->base->attributes.splice( ret->base->attributes.end(), attributes ); Index: src/SynTree/Declaration.h =================================================================== --- src/SynTree/Declaration.h (revision 98168b962cfa480dd25d7905d6efa2c3bbb01645) +++ src/SynTree/Declaration.h (revision 73a3be5b5f45d10ada01ab1d492f881e78767ff4) @@ -181,5 +181,4 @@ public: Type * base; - std::list< TypeDecl * > parameters; std::list< DeclarationWithType * > assertions; @@ -190,5 +189,4 @@ Type * get_base() const { return base; } void set_base( Type * newValue ) { base = newValue; } - std::list< TypeDecl* > & get_parameters() { return parameters; } std::list< DeclarationWithType * >& get_assertions() { return assertions; } Index: src/SynTree/NamedTypeDecl.cc =================================================================== --- src/SynTree/NamedTypeDecl.cc (revision 98168b962cfa480dd25d7905d6efa2c3bbb01645) +++ src/SynTree/NamedTypeDecl.cc (revision 73a3be5b5f45d10ada01ab1d492f881e78767ff4) @@ -29,5 +29,4 @@ NamedTypeDecl::NamedTypeDecl( const NamedTypeDecl &other ) : Parent( other ), base( maybeClone( other.base ) ) { - cloneAll( other.parameters, parameters ); cloneAll( other.assertions, assertions ); } @@ -35,5 +34,4 @@ NamedTypeDecl::~NamedTypeDecl() { delete base; - deleteAll( parameters ); deleteAll( assertions ); } @@ -56,8 +54,4 @@ base->print( os, indent+1 ); } // if - if ( ! parameters.empty() ) { - os << endl << indent << "... with parameters" << endl; - printAll( parameters, os, indent+1 ); - } // if if ( ! assertions.empty() ) { os << endl << indent << "... with assertions" << endl; @@ -76,8 +70,4 @@ base->print( os, indent+1 ); } // if - if ( ! parameters.empty() ) { - os << endl << indent << "... with parameters" << endl; - printAll( parameters, os, indent+1 ); - } // if }