Index: libcfa/src/heap.cfa
===================================================================
--- libcfa/src/heap.cfa	(revision 514247d2ce3ed93eb65184b7e372236868d74b72)
+++ libcfa/src/heap.cfa	(revision 933933c7028ae75d883ec7f91df299e7ee478fc3)
@@ -1,4 +1,2 @@
-// #comment TD : this file uses both spaces and tabs for indentation
-
 //
 // Cforall Version 1.0.0 Copyright (C) 2017 University of Waterloo
@@ -12,6 +10,6 @@
 // Created On       : Tue Dec 19 21:58:35 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Aug 11 08:22:16 2018
-// Update Count     : 495
+// Last Modified On : Thu Aug 23 06:11:44 2018
+// Update Count     : 511
 //
 
@@ -25,9 +23,9 @@
 
 // #comment TD : Many of these should be merged into math I believe
-#include "bits/align.hfa"									// libPow2
-#include "bits/defs.hfa"									// likely, unlikely
-#include "bits/locks.hfa"									// __spinlock_t
+#include "bits/align.hfa"								// libPow2
+#include "bits/defs.hfa"								// likely, unlikely
+#include "bits/locks.hfa"								// __spinlock_t
 #include "startup.hfa"									// STARTUP_PRIORITY_MEMORY
-#include "stdlib.hfa"										// bsearchl
+#include "stdlib.hfa"									// bsearchl
 #include "malloc.h"
 
@@ -151,12 +149,12 @@
 
 extern "C" {
-void heapAppStart() {									// called by __cfaabi_appready_startup
-	allocFree = 0;
-} // heapAppStart
-
-void heapAppStop() {									// called by __cfaabi_appready_startdown
-	fclose( stdin ); fclose( stdout );
-	checkUnfreed();
-} // heapAppStop
+	void heapAppStart() {								// called by __cfaabi_appready_startup
+		allocFree = 0;
+	} // heapAppStart
+
+	void heapAppStop() {								// called by __cfaabi_appready_startdown
+		fclose( stdin ); fclose( stdout );
+		checkUnfreed();
+	} // heapAppStop
 } // extern "C"
 #endif // __CFA_DEBUG__
@@ -167,14 +165,12 @@
 
 	struct Storage {
-	    struct Header {									// header
+		struct Header {									// header
 			union Kind {
 				struct RealHeader {
 					union {
-						// #comment TD : this code use byte size but the comment uses bit size
-
-						struct {						// 32-bit word => 64-bit header, 64-bit word => 128-bit header
+						struct {						// 4-byte word => 8-byte header, 8-byte word => 16-byte header
 							#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ && __SIZEOF_POINTER__ == 4
 							uint32_t padding;			// unused, force home/blocksize to overlay alignment in fake header
-							#endif // __ORDER_BIG_ENDIAN__ && __U_WORDSIZE__ == 32
+							#endif // __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ && __SIZEOF_POINTER__ == 4
 
 							union {
@@ -189,9 +185,7 @@
 							#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ && __SIZEOF_POINTER__ == 4
 							uint32_t padding;			// unused, force home/blocksize to overlay alignment in fake header
-							#endif // __ORDER_LITTLE_ENDIAN__ && __U_WORDSIZE__ == 32
-
+							#endif // __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ && __SIZEOF_POINTER__ == 4
 						};
-
-						// #comment TD : C++ code
+						// future code
 						#if BUCKLOCK == LOCKFREE
 						Stack<Storage>::Link next;		// freed block points next freed block of same size (double-wide)
@@ -211,7 +205,7 @@
 				} fake; // FakeHeader
 			} kind; // Kind
-	    } header; // Header
-	    char pad[ALIGN - sizeof( Header )];
-	    char data[0];									// storage
+		} header; // Header
+		char pad[ALIGN - sizeof( Header )];
+		char data[0];									// storage
 	}; // Storage
 
@@ -220,13 +214,13 @@
 	struct FreeHeader {
 		#if BUCKLOCK == SPINLOCK
-	    __spinlock_t lock;								// must be first field for alignment
-	    Storage * freeList;
+		__spinlock_t lock;								// must be first field for alignment
+		Storage * freeList;
 		#elif BUCKLOCK == LOCKFREE
-		// #comment TD : C++ code
-	    StackLF<Storage> freeList;
+		// future code
+		StackLF<Storage> freeList;
 		#else
-			#error undefined lock type for bucket lock
+		#error undefined lock type for bucket lock
 		#endif // SPINLOCK
-	    size_t blockSize;								// size of allocations on this list
+		size_t blockSize;								// size of allocations on this list
 	}; // FreeHeader
 
@@ -249,7 +243,6 @@
 static unsigned int maxBucketsUsed;						// maximum number of buckets in use
 
-// #comment TD : This array is not const but it feels like it should be
 // Powers of 2 are common allocation sizes, so make powers of 2 generate the minimum required size.
-static unsigned int bucketSizes[NoBucketSizes] @= {		// different bucket sizes
+static const unsigned int bucketSizes[NoBucketSizes] @= { // different bucket sizes
 	16, 32, 48, 64,
 	64 + sizeof(HeapManager.Storage), 96, 112, 128, 128 + sizeof(HeapManager.Storage), 160, 192, 224,
@@ -279,5 +272,5 @@
 // #comment TD : The return type of this function should be commented
 static inline bool setMmapStart( size_t value ) {
-	if ( value < pageSize || bucketSizes[NoBucketSizes - 1] < value ) return true;
+  if ( value < pageSize || bucketSizes[NoBucketSizes - 1] < value ) return true;
 	mmapStart = value;									// set global
 
@@ -313,5 +306,5 @@
 	sbrk( (char *)libCeiling( (long unsigned int)End, libAlign() ) - End ); // move start of heap to multiple of alignment
 	heapBegin = heapEnd = sbrk( 0 );					// get new start point
-} // HeapManager
+			   } // HeapManager
 
 
@@ -323,5 +316,5 @@
 	// } // if
 	#endif // __STATISTICS__
-} // ~HeapManager
+				} // ~HeapManager
 
 
@@ -329,5 +322,5 @@
 void memory_startup( void ) {
 	#ifdef __CFA_DEBUG__
-	if ( unlikely( heapBoot ) ) {					// check for recursion during system boot
+	if ( unlikely( heapBoot ) ) {						// check for recursion during system boot
 		// DO NOT USE STREAMS AS THEY MAY BE UNAVAILABLE AT THIS POINT.
 		abort( "boot() : internal error, recursively invoked during system boot." );
@@ -336,6 +329,5 @@
 	#endif // __CFA_DEBUG__
 
-	// #comment TD : This assertion seems redundent with the above code
-	assert( heapManager.heapBegin == 0 );
+	assert( heapManager.heapBegin == 0 );				// always perform check, done once
 	heapManager{};
 } // memory_startup
@@ -374,28 +366,27 @@
 	char helpText[512];
 	__cfaabi_dbg_bits_print_buffer( helpText, sizeof(helpText),
-			"\nHeap statistics:\n"
-			"  malloc: calls %u / storage %llu\n"
-			"  calloc: calls %u / storage %llu\n"
-			"  memalign: calls %u / storage %llu\n"
-			"  cmemalign: calls %u / storage %llu\n"
-			"  realloc: calls %u / storage %llu\n"
-			"  free: calls %u / storage %llu\n"
-			"  mmap: calls %u / storage %llu\n"
-			"  munmap: calls %u / storage %llu\n"
-			"  sbrk: calls %u / storage %llu\n",
-			malloc_calls, malloc_storage,
-			calloc_calls, calloc_storage,
-			memalign_calls, memalign_storage,
-			cmemalign_calls, cmemalign_storage,
-			realloc_calls, realloc_storage,
-			free_calls, free_storage,
-			mmap_calls, mmap_storage,
-			munmap_calls, munmap_storage,
-			sbrk_calls, sbrk_storage
+									"\nHeap statistics:\n"
+									"  malloc: calls %u / storage %llu\n"
+									"  calloc: calls %u / storage %llu\n"
+									"  memalign: calls %u / storage %llu\n"
+									"  cmemalign: calls %u / storage %llu\n"
+									"  realloc: calls %u / storage %llu\n"
+									"  free: calls %u / storage %llu\n"
+									"  mmap: calls %u / storage %llu\n"
+									"  munmap: calls %u / storage %llu\n"
+									"  sbrk: calls %u / storage %llu\n",
+									malloc_calls, malloc_storage,
+									calloc_calls, calloc_storage,
+									memalign_calls, memalign_storage,
+									cmemalign_calls, cmemalign_storage,
+									realloc_calls, realloc_storage,
+									free_calls, free_storage,
+									mmap_calls, mmap_storage,
+									munmap_calls, munmap_storage,
+									sbrk_calls, sbrk_storage
 		);
 } // printStats
 
-// #comment TD : Why do we have this?
-static int printStatsXML( FILE * stream ) {
+static int printStatsXML( FILE * stream ) {				// see malloc_info
 	char helpText[512];
 	int len = snprintf( helpText, sizeof(helpText),
@@ -431,6 +422,6 @@
 static inline void noMemory() {
 	abort( "Heap memory exhausted at %zu bytes.\n"
-			"Possible cause is very large memory allocation and/or large amount of unfreed storage allocated by the program or system/library routines.",
-			((char *)(sbrk( 0 )) - (char *)(heapManager.heapBegin)) );
+		   "Possible cause is very large memory allocation and/or large amount of unfreed storage allocated by the program or system/library routines.",
+		   ((char *)(sbrk( 0 )) - (char *)(heapManager.heapBegin)) );
 } // noMemory
 
@@ -444,5 +435,5 @@
 
 static inline bool setHeapExpand( size_t value ) {
-	if ( heapExpand < pageSize ) return true;
+  if ( heapExpand < pageSize ) return true;
 	heapExpand = value;
 	return false;
@@ -453,6 +444,6 @@
 	if ( unlikely( check ) ) {							// bad address ?
 		abort( "Attempt to %s storage %p with address outside the heap.\n"
-				"Possible cause is duplicate free on same block or overwriting of memory.",
-				name, addr );
+			   "Possible cause is duplicate free on same block or overwriting of memory.",
+			   name, addr );
 	} // if
 } // checkHeader
@@ -484,5 +475,5 @@
 
 	#ifdef __CFA_DEBUG__
-			checkHeader( addr < heapBegin || header < (HeapManager.Storage.Header *)heapBegin, name, addr ); // bad low address ?
+	checkHeader( addr < heapBegin || header < (HeapManager.Storage.Header *)heapBegin, name, addr ); // bad low address ?
 	#endif // __CFA_DEBUG__
 
@@ -490,20 +481,20 @@
 	//               It's called as the first statement of both branches of the last if, with the same parameters in all cases
 
-		// header may be safe to dereference
-		fakeHeader( header, size, alignment );
+	// header may be safe to dereference
+	fakeHeader( header, size, alignment );
 	#ifdef __CFA_DEBUG__
-			checkHeader( header < (HeapManager.Storage.Header *)heapBegin || (HeapManager.Storage.Header *)heapEnd < header, name, addr ); // bad address ? (offset could be + or -)
+	checkHeader( header < (HeapManager.Storage.Header *)heapBegin || (HeapManager.Storage.Header *)heapEnd < header, name, addr ); // bad address ? (offset could be + or -)
 	#endif // __CFA_DEBUG__
 
-		freeElem = (HeapManager.FreeHeader *)((size_t)header->kind.real.home & -3);
+	freeElem = (HeapManager.FreeHeader *)((size_t)header->kind.real.home & -3);
 	#ifdef __CFA_DEBUG__
-			if ( freeElem < &freeLists[0] || &freeLists[NoBucketSizes] <= freeElem ) {
-			abort( "Attempt to %s storage %p with corrupted header.\n"
-				 "Possible cause is duplicate free on same block or overwriting of header information.",
-			   		name, addr );
-			} // if
+	if ( freeElem < &freeLists[0] || &freeLists[NoBucketSizes] <= freeElem ) {
+		abort( "Attempt to %s storage %p with corrupted header.\n"
+			   "Possible cause is duplicate free on same block or overwriting of header information.",
+			   name, addr );
+	} // if
 	#endif // __CFA_DEBUG__
-		size = freeElem->blockSize;
-		return false;
+	size = freeElem->blockSize;
+	return false;
 } // headers
 
@@ -521,12 +512,12 @@
 			return 0;
 		} // if
-#ifdef __STATISTICS__
+		#ifdef __STATISTICS__
 		sbrk_calls += 1;
 		sbrk_storage += increase;
-#endif // __STATISTICS__
-#ifdef __CFA_DEBUG__
+		#endif // __STATISTICS__
+		#ifdef __CFA_DEBUG__
 		// Set new memory to garbage so subsequent uninitialized usages might fail.
 		memset( (char *)heapEnd + heapRemaining, '\377', increase );
-#endif // __CFA_DEBUG__
+		#endif // __CFA_DEBUG__
 		rem = heapRemaining + increase - size;
 	} // if
@@ -560,8 +551,8 @@
 
 		#if defined( SPINLOCK )
-			lock( freeElem->lock __cfaabi_dbg_ctx2 );
-			block = freeElem->freeList;						// remove node from stack
+		lock( freeElem->lock __cfaabi_dbg_ctx2 );
+		block = freeElem->freeList;						// remove node from stack
 		#else
-			block = freeElem->freeList.pop();
+		block = freeElem->freeList.pop();
 		#endif // SPINLOCK
 		if ( unlikely( block == 0 ) ) {					// no free block ?
@@ -569,9 +560,10 @@
 			unlock( freeElem->lock );
 			#endif // SPINLOCK
+
 			// Freelist for that size was empty, so carve it out of the heap if there's enough left, or get some more
 			// and then carve it off.
 
 			block = (HeapManager.Storage *)extend( tsize );	// mutual exclusion on call
-			if ( unlikely( block == 0 ) ) return 0;
+  if ( unlikely( block == 0 ) ) return 0;
 			#if defined( SPINLOCK )
 		} else {
@@ -582,9 +574,9 @@
 
 		block->header.kind.real.home = freeElem;		// pointer back to free list of apropriate size
-		} else {											// large size => mmap
+	} else {											// large size => mmap
 		tsize = libCeiling( tsize, pageSize );			// must be multiple of page size
 		#ifdef __STATISTICS__
-			__atomic_add_fetch( &mmap_calls, 1, __ATOMIC_SEQ_CST );
-			__atomic_add_fetch( &mmap_storage, tsize, __ATOMIC_SEQ_CST );
+		__atomic_add_fetch( &mmap_calls, 1, __ATOMIC_SEQ_CST );
+		__atomic_add_fetch( &mmap_storage, tsize, __ATOMIC_SEQ_CST );
 		#endif // __STATISTICS__
 		block = (HeapManager.Storage *)mmap( 0, tsize, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, mmapFd, 0 );
@@ -593,23 +585,23 @@
 			abort( "(HeapManager &)0x%p.doMalloc() : internal error, mmap failure, size:%zu error:%d.", &heapManager, tsize, errno );
 		} // if
-#ifdef __CFA_DEBUG__
+		#ifdef __CFA_DEBUG__
 		// Set new memory to garbage so subsequent uninitialized usages might fail.
 		memset( block, '\377', tsize );
-#endif // __CFA_DEBUG__
+		#endif // __CFA_DEBUG__
 		block->header.kind.real.blockSize = tsize;		// storage size for munmap
-		} // if
-
-		void * area = &(block->data);						// adjust off header to user bytes
+	} // if
+
+	void * area = &(block->data);						// adjust off header to user bytes
 
 	#ifdef __CFA_DEBUG__
-			assert( ((uintptr_t)area & (libAlign() - 1)) == 0 ); // minimum alignment ?
-			__atomic_add_fetch( &allocFree, tsize, __ATOMIC_SEQ_CST );
-		if ( traceHeap() ) {
-			enum { BufferSize = 64 };
-			char helpText[BufferSize];
-			int len = snprintf( helpText, BufferSize, "%p = Malloc( %zu ) (allocated %zu)\n", area, size, tsize );
-			// int len = snprintf( helpText, BufferSize, "Malloc %p %zu\n", area, size );
-			__cfaabi_dbg_bits_write( helpText, len );
-		} // if
+	assert( ((uintptr_t)area & (libAlign() - 1)) == 0 ); // minimum alignment ?
+	__atomic_add_fetch( &allocFree, tsize, __ATOMIC_SEQ_CST );
+	if ( traceHeap() ) {
+		enum { BufferSize = 64 };
+		char helpText[BufferSize];
+		int len = snprintf( helpText, BufferSize, "%p = Malloc( %zu ) (allocated %zu)\n", area, size, tsize );
+		// int len = snprintf( helpText, BufferSize, "Malloc %p %zu\n", area, size );
+		__cfaabi_dbg_bits_write( helpText, len );
+	} // if
 	#endif // __CFA_DEBUG__
 
@@ -620,7 +612,7 @@
 static inline void doFree( void * addr ) with ( heapManager ) {
 	#ifdef __CFA_DEBUG__
-		if ( unlikely( heapManager.heapBegin == 0 ) ) {
-			abort( "doFree( %p ) : internal error, called before heap is initialized.", addr );
-		} // if
+	if ( unlikely( heapManager.heapBegin == 0 ) ) {
+		abort( "doFree( %p ) : internal error, called before heap is initialized.", addr );
+	} // if
 	#endif // __CFA_DEBUG__
 
@@ -631,40 +623,40 @@
 	if ( headers( "free", addr, header, freeElem, size, alignment ) ) { // mmapped ?
 		#ifdef __STATISTICS__
-			__atomic_add_fetch( &munmap_calls, 1, __ATOMIC_SEQ_CST );
-			__atomic_add_fetch( &munmap_storage, size, __ATOMIC_SEQ_CST );
+		__atomic_add_fetch( &munmap_calls, 1, __ATOMIC_SEQ_CST );
+		__atomic_add_fetch( &munmap_storage, size, __ATOMIC_SEQ_CST );
 		#endif // __STATISTICS__
 		if ( munmap( header, size ) == -1 ) {
 			#ifdef __CFA_DEBUG__
 			abort( "Attempt to deallocate storage %p not allocated or with corrupt header.\n"
-					"Possible cause is invalid pointer.",
-					addr );
+				   "Possible cause is invalid pointer.",
+				   addr );
 			#endif // __CFA_DEBUG__
 		} // if
-		} else {
+	} else {
 		#ifdef __CFA_DEBUG__
-			// Set free memory to garbage so subsequent usages might fail.
-			memset( ((HeapManager.Storage *)header)->data, '\377', freeElem->blockSize - sizeof( HeapManager.Storage ) );
+		// Set free memory to garbage so subsequent usages might fail.
+		memset( ((HeapManager.Storage *)header)->data, '\377', freeElem->blockSize - sizeof( HeapManager.Storage ) );
 		#endif // __CFA_DEBUG__
 
 		#ifdef __STATISTICS__
-			free_storage += size;
+		free_storage += size;
 		#endif // __STATISTICS__
 		#if defined( SPINLOCK )
-			lock( freeElem->lock __cfaabi_dbg_ctx2 );		// acquire spin lock
-			header->kind.real.next = freeElem->freeList;	// push on stack
-			freeElem->freeList = (HeapManager.Storage *)header;
-			unlock( freeElem->lock );						// release spin lock
+		lock( freeElem->lock __cfaabi_dbg_ctx2 );		// acquire spin lock
+		header->kind.real.next = freeElem->freeList;	// push on stack
+		freeElem->freeList = (HeapManager.Storage *)header;
+		unlock( freeElem->lock );						// release spin lock
 		#else
-			freeElem->freeList.push( *(HeapManager.Storage *)header );
+		freeElem->freeList.push( *(HeapManager.Storage *)header );
 		#endif // SPINLOCK
-		} // if
+	} // if
 
 	#ifdef __CFA_DEBUG__
-   		 __atomic_add_fetch( &allocFree, -size, __ATOMIC_SEQ_CST );
-		if ( traceHeap() ) {
-			char helpText[64];
-			int len = snprintf( helpText, sizeof(helpText), "Free( %p ) size:%zu\n", addr, size );
-			__cfaabi_dbg_bits_write( helpText, len );
-		} // if
+	__atomic_add_fetch( &allocFree, -size, __ATOMIC_SEQ_CST );
+	if ( traceHeap() ) {
+		char helpText[64];
+		int len = snprintf( helpText, sizeof(helpText), "Free( %p ) size:%zu\n", addr, size );
+		__cfaabi_dbg_bits_write( helpText, len );
+	} // if
 	#endif // __CFA_DEBUG__
 } // doFree
@@ -674,6 +666,6 @@
 	size_t total = 0;
 	#ifdef __STATISTICS__
-		__cfaabi_dbg_bits_acquire();
-		__cfaabi_dbg_bits_print_nolock( "\nBin lists (bin size : free blocks on list)\n" );
+	__cfaabi_dbg_bits_acquire();
+	__cfaabi_dbg_bits_print_nolock( "\nBin lists (bin size : free blocks on list)\n" );
 	#endif // __STATISTICS__
 	for ( unsigned int i = 0; i < maxBucketsUsed; i += 1 ) {
@@ -695,31 +687,31 @@
 
 		#ifdef __STATISTICS__
-			__cfaabi_dbg_bits_print_nolock( "%7zu, %-7u  ", size, N );
-			if ( (i + 1) % 8 == 0 ) __cfaabi_dbg_bits_print_nolock( "\n" );
+		__cfaabi_dbg_bits_print_nolock( "%7zu, %-7u  ", size, N );
+		if ( (i + 1) % 8 == 0 ) __cfaabi_dbg_bits_print_nolock( "\n" );
 		#endif // __STATISTICS__
 	} // for
 	#ifdef __STATISTICS__
-		__cfaabi_dbg_bits_print_nolock( "\ntotal free blocks:%zu\n", total );
-		__cfaabi_dbg_bits_release();
+	__cfaabi_dbg_bits_print_nolock( "\ntotal free blocks:%zu\n", total );
+	__cfaabi_dbg_bits_release();
 	#endif // __STATISTICS__
 	return (char *)heapEnd - (char *)heapBegin - total;
 } // checkFree
 
-// #comment TD : This is not a good name, plus this feels like it could easily be folded into doMalloc
-static inline void * malloc2( size_t size ) {			// necessary for malloc statistics
+
+static inline void * mallocNoStats( size_t size ) {		// necessary for malloc statistics
 	assert( heapManager.heapBegin != 0 );
 	void * area = doMalloc( size );
 	if ( unlikely( area == 0 ) ) errno = ENOMEM;		// POSIX
 	return area;
-} // malloc2
-
-
-static inline void * memalign2( size_t alignment, size_t size ) { // necessary for malloc statistics
-#ifdef __CFA_DEBUG__
+} // mallocNoStats
+
+
+static inline void * memalignNoStats( size_t alignment, size_t size ) { // necessary for malloc statistics
+	#ifdef __CFA_DEBUG__
 	checkAlign( alignment );							// check alignment
-#endif // __CFA_DEBUG__
+	#endif // __CFA_DEBUG__
 
 	// if alignment <= default alignment, do normal malloc as two headers are unnecessary
-	if ( unlikely( alignment <= libAlign() ) ) return malloc2( size );
+  if ( unlikely( alignment <= libAlign() ) ) return mallocNoStats( size );
 
 	// Allocate enough storage to guarantee an address on the alignment boundary, and sufficient space before it for
@@ -732,7 +724,7 @@
 	// subtract libAlign() because it is already the minimum alignment
 	// add sizeof(Storage) for fake header
-	// #comment TD : this is the only place that calls doMalloc without calling malloc2, why ?
+	// #comment TD : this is the only place that calls doMalloc without calling mallocNoStats, why ?
 	char * area = (char *)doMalloc( size + alignment - libAlign() + sizeof(HeapManager.Storage) );
-	if ( unlikely( area == 0 ) ) return area;
+  if ( unlikely( area == 0 ) ) return area;
 
 	// address in the block of the "next" alignment address
@@ -749,34 +741,32 @@
 
 	return user;
-} // memalign2
+} // memalignNoStats
 
 
 extern "C" {
-	// The malloc() function allocates size bytes and returns a pointer to the
-	// allocated memory. The memory is not initialized. If size is 0, then malloc()
-	// returns either NULL, or a unique pointer value that can later be successfully
-	// passed to free().
+	// The malloc() function allocates size bytes and returns a pointer to the allocated memory. The memory is not
+	// initialized. If size is 0, then malloc() returns either NULL, or a unique pointer value that can later be
+	// successfully passed to free().
 	void * malloc( size_t size ) {
 		#ifdef __STATISTICS__
-			__atomic_add_fetch( &malloc_calls, 1, __ATOMIC_SEQ_CST );
-			__atomic_add_fetch( &malloc_storage, size, __ATOMIC_SEQ_CST );
-		#endif // __STATISTICS__
-
-		return malloc2( size );
-		} // malloc
-
-	// The calloc() function allocates memory for an array of nmemb elements of
-	// size bytes each and returns a pointer to the allocated memory. The memory
-	// is set to zero. If nmemb or size is 0, then calloc() returns either NULL,
-	// or a unique pointer value that can later be successfully passed to free().
-		void * calloc( size_t noOfElems, size_t elemSize ) {
+		__atomic_add_fetch( &malloc_calls, 1, __ATOMIC_SEQ_CST );
+		__atomic_add_fetch( &malloc_storage, size, __ATOMIC_SEQ_CST );
+		#endif // __STATISTICS__
+
+		return mallocNoStats( size );
+	} // malloc
+
+	// The calloc() function allocates memory for an array of nmemb elements of size bytes each and returns a pointer to
+	// the allocated memory. The memory is set to zero. If nmemb or size is 0, then calloc() returns either NULL, or a
+	// unique pointer value that can later be successfully passed to free().
+	void * calloc( size_t noOfElems, size_t elemSize ) {
 		size_t size = noOfElems * elemSize;
 		#ifdef __STATISTICS__
-			__atomic_add_fetch( &calloc_calls, 1, __ATOMIC_SEQ_CST );
-			__atomic_add_fetch( &calloc_storage, size, __ATOMIC_SEQ_CST );
-		#endif // __STATISTICS__
-
-		char * area = (char *)malloc2( size );
-		if ( unlikely( area == 0 ) ) return 0;
+		__atomic_add_fetch( &calloc_calls, 1, __ATOMIC_SEQ_CST );
+		__atomic_add_fetch( &calloc_storage, size, __ATOMIC_SEQ_CST );
+		#endif // __STATISTICS__
+
+		char * area = (char *)mallocNoStats( size );
+	  if ( unlikely( area == 0 ) ) return 0;
 
 		HeapManager.Storage.Header * header;
@@ -790,7 +780,7 @@
 			memset( area, '\0', asize - sizeof(HeapManager.Storage) ); // set to zeros
 
-		header->kind.real.blockSize |= 2;		// mark as zero filled
+		header->kind.real.blockSize |= 2;				// mark as zero filled
 		return area;
-		} // calloc
+	} // calloc
 
 	// #comment TD : Document this function
@@ -798,10 +788,10 @@
 		size_t size = noOfElems * elemSize;
 		#ifdef __STATISTICS__
-			__atomic_add_fetch( &cmemalign_calls, 1, __ATOMIC_SEQ_CST );
-			__atomic_add_fetch( &cmemalign_storage, size, __ATOMIC_SEQ_CST );
-		#endif // __STATISTICS__
-
-		char * area = (char *)memalign2( alignment, size );
-		if ( unlikely( area == 0 ) ) return 0;
+		__atomic_add_fetch( &cmemalign_calls, 1, __ATOMIC_SEQ_CST );
+		__atomic_add_fetch( &cmemalign_storage, size, __ATOMIC_SEQ_CST );
+		#endif // __STATISTICS__
+
+		char * area = (char *)memalignNoStats( alignment, size );
+	  if ( unlikely( area == 0 ) ) return 0;
 		HeapManager.Storage.Header * header;
 		HeapManager.FreeHeader * freeElem;
@@ -811,27 +801,24 @@
 		// Mapped storage is zero filled, but in debug mode mapped memory is scrubbed in doMalloc, so it has to be reset to zero.
 		if ( ! mapped )
-		#endif // __CFA_DEBUG__
+			#endif // __CFA_DEBUG__
 			memset( area, '\0', asize - ( (char *)area - (char *)header ) ); // set to zeros
 		header->kind.real.blockSize |= 2;				// mark as zero filled
 
 		return area;
-		} // cmemalign
-
-	// The realloc() function changes the size of the memory block pointed to by
-	// ptr to size bytes. The contents will be unchanged in the range from the
-	// start of the region up to the minimum of the old and new sizes. If the new
-	// size is larger than the old size, the added memory will not be initialized.
-	// If ptr is NULL, then the call is equivalent to malloc(size), for all values
-	// of size; if size is equal to zero, and ptr is not NULL, then the call is
-	// equivalent to free(ptr). Unless ptr is NULL, it must have been returned by
-	// an earlier call to malloc(), calloc() or realloc(). If the area pointed to
-	// was moved, a free(ptr) is done.
-		void * realloc( void * addr, size_t size ) {
-		#ifdef __STATISTICS__
-			__atomic_add_fetch( &realloc_calls, 1, __ATOMIC_SEQ_CST );
-		#endif // __STATISTICS__
-
-		if ( unlikely( addr == 0 ) ) return malloc2( size ); // special cases
-		if ( unlikely( size == 0 ) ) { free( addr ); return 0; }
+	} // cmemalign
+
+	// The realloc() function changes the size of the memory block pointed to by ptr to size bytes. The contents will be
+	// unchanged in the range from the start of the region up to the minimum of the old and new sizes. If the new size
+	// is larger than the old size, the added memory will not be initialized.  If ptr is NULL, then the call is
+	// equivalent to malloc(size), for all values of size; if size is equal to zero, and ptr is not NULL, then the call
+	// is equivalent to free(ptr). Unless ptr is NULL, it must have been returned by an earlier call to malloc(),
+	// calloc() or realloc(). If the area pointed to was moved, a free(ptr) is done.
+	void * realloc( void * addr, size_t size ) {
+		#ifdef __STATISTICS__
+		__atomic_add_fetch( &realloc_calls, 1, __ATOMIC_SEQ_CST );
+		#endif // __STATISTICS__
+
+	  if ( unlikely( addr == 0 ) ) return mallocNoStats( size ); // special cases
+	  if ( unlikely( size == 0 ) ) { free( addr ); return 0; }
 
 		HeapManager.Storage.Header * header;
@@ -848,5 +835,5 @@
 
 		#ifdef __STATISTICS__
-			__atomic_add_fetch( &realloc_storage, size, __ATOMIC_SEQ_CST );
+		__atomic_add_fetch( &realloc_storage, size, __ATOMIC_SEQ_CST );
 		#endif // __STATISTICS__
 
@@ -855,7 +842,7 @@
 			area = memalign( alignment, size );			// create new area
 		} else {
-			area = malloc2( size );	// create new area
+			area = mallocNoStats( size );				// create new area
 		} // if
-		if ( unlikely( area == 0 ) ) return 0;
+	  if ( unlikely( area == 0 ) ) return 0;
 		if ( unlikely( header->kind.real.blockSize & 2 ) ) { // previous request zero fill (calloc/cmemalign) ?
 			assert( (header->kind.real.blockSize & 1) == 0 );
@@ -864,5 +851,5 @@
 			// Mapped storage is zero filled, but in debug mode mapped memory is scrubbed in doMalloc, so it has to be reset to zero.
 			if ( ! mapped )
-			#endif // __CFA_DEBUG__
+				#endif // __CFA_DEBUG__
 				memset( (char *)area + usize, '\0', asize - ( (char *)area - (char *)header ) - usize ); // zero-fill back part
 			header->kind.real.blockSize |= 2;			// mark new request as zero fill
@@ -874,9 +861,7 @@
 
 
-	// The obsolete function memalign() allocates size bytes and returns
-	// a pointer to the allocated memory. The memory address will be a
-	// multiple of alignment, which must be a power of two.
-	void * memalign( size_t alignment, size_t size ) __attribute__ ((deprecated));
-		void * memalign( size_t alignment, size_t size ) {
+	// The obsolete function memalign() allocates size bytes and returns a pointer to the allocated memory. The memory
+	// address will be a multiple of alignment, which must be a power of two.
+	void * memalign( size_t alignment, size_t size ) {
 		#ifdef __STATISTICS__
 		__atomic_add_fetch( &memalign_calls, 1, __ATOMIC_SEQ_CST );
@@ -884,11 +869,11 @@
 		#endif // __STATISTICS__
 
-		void * area = memalign2( alignment, size );
+		void * area = memalignNoStats( alignment, size );
 
 		return area;
-		} // memalign
-
-	// The function aligned_alloc() is the same as memalign(), except for
-	// the added restriction that size should be a multiple of alignment.
+	} // memalign
+
+	// The function aligned_alloc() is the same as memalign(), except for the added restriction that size should be a
+	// multiple of alignment.
 	void * aligned_alloc( size_t alignment, size_t size ) {
 		return memalign( alignment, size );
@@ -896,20 +881,17 @@
 
 
-	// The function posix_memalign() allocates size bytes and places the address
-	// of the allocated memory in *memptr. The address of the allocated memory
-	// will be a multiple of alignment, which must be a power of two and a multiple
-	// of sizeof(void *). If size is 0, then posix_memalign() returns either NULL,
-	// or a unique pointer value that can later be successfully passed to free(3).
+	// The function posix_memalign() allocates size bytes and places the address of the allocated memory in *memptr. The
+	// address of the allocated memory will be a multiple of alignment, which must be a power of two and a multiple of
+	// sizeof(void *). If size is 0, then posix_memalign() returns either NULL, or a unique pointer value that can later
+	// be successfully passed to free(3).
 	int posix_memalign( void ** memptr, size_t alignment, size_t size ) {
-		if ( alignment < sizeof(void *) || ! libPow2( alignment ) ) return EINVAL; // check alignment
+	  if ( alignment < sizeof(void *) || ! libPow2( alignment ) ) return EINVAL; // check alignment
 		* memptr = memalign( alignment, size );
-		if ( unlikely( * memptr == 0 ) ) return ENOMEM;
+	  if ( unlikely( * memptr == 0 ) ) return ENOMEM;
 		return 0;
 	} // posix_memalign
 
-	// The obsolete function valloc() allocates size bytes and returns a pointer
-	// to the allocated memory. The memory address will be a multiple of the page size.
-	// It is equivalent to memalign(sysconf(_SC_PAGESIZE),size).
-	void * valloc( size_t size ) __attribute__ ((deprecated));
+	// The obsolete function valloc() allocates size bytes and returns a pointer to the allocated memory. The memory
+	// address will be a multiple of the page size.  It is equivalent to memalign(sysconf(_SC_PAGESIZE),size).
 	void * valloc( size_t size ) {
 		return memalign( pageSize, size );
@@ -917,11 +899,10 @@
 
 
-	// The free() function frees the memory space pointed to by ptr, which must
-	// have been returned by a previous call to malloc(), calloc() or realloc().
-	// Otherwise, or if free(ptr) has already been called before, undefined
-	// behavior occurs. If ptr is NULL, no operation is performed.
+	// The free() function frees the memory space pointed to by ptr, which must have been returned by a previous call to
+	// malloc(), calloc() or realloc().  Otherwise, or if free(ptr) has already been called before, undefined behavior
+	// occurs. If ptr is NULL, no operation is performed.
 	void free( void * addr ) {
 		#ifdef __STATISTICS__
-			__atomic_add_fetch( &free_calls, 1, __ATOMIC_SEQ_CST );
+		__atomic_add_fetch( &free_calls, 1, __ATOMIC_SEQ_CST );
 		#endif // __STATISTICS__
 
@@ -931,9 +912,9 @@
 		if ( unlikely( addr == 0 ) ) {					// special case
 			#ifdef __CFA_DEBUG__
-				if ( traceHeap() ) {
-					#define nullmsg "Free( 0x0 ) size:0\n"
-					// Do not debug print free( 0 ), as it can cause recursive entry from sprintf.
-					__cfaabi_dbg_bits_write( nullmsg, sizeof(nullmsg) - 1 );
-				} // if
+			if ( traceHeap() ) {
+				#define nullmsg "Free( 0x0 ) size:0\n"
+				// Do not debug print free( 0 ), as it can cause recursive entry from sprintf.
+				__cfaabi_dbg_bits_write( nullmsg, sizeof(nullmsg) - 1 );
+			} // if
 			#endif // __CFA_DEBUG__
 			return;
@@ -943,32 +924,30 @@
 	} // free
 
-	// The mallopt() function adjusts parameters that control the behavior of the
-	// memory-allocation functions (see malloc(3)). The param argument specifies
-	// the parameter to be modified, and value specifies the new value for that
+	// The mallopt() function adjusts parameters that control the behavior of the memory-allocation functions (see
+	// malloc(3)). The param argument specifies the parameter to be modified, and value specifies the new value for that
 	// parameter.
-		int mallopt( int option, int value ) {
+	int mallopt( int option, int value ) {
 		choose( option ) {
-			case M_TOP_PAD:
-				if ( setHeapExpand( value ) ) fallthru default;
-			case M_MMAP_THRESHOLD:
-				if ( setMmapStart( value ) ) fallthru default;
-			default:
-				// #comment TD : 1 for unsopported feels wrong
-				return 1;									// success, or unsupported
+		  case M_TOP_PAD:
+			if ( setHeapExpand( value ) ) fallthru default;
+		  case M_MMAP_THRESHOLD:
+			if ( setMmapStart( value ) ) fallthru default;
+		  default:
+			// #comment TD : 1 for unsopported feels wrong
+			return 1;									// success, or unsupported
 		} // switch
 		return 0;										// error
 	} // mallopt
 
-	// The malloc_trim() function attempts to release free memory at the top
-	// of the heap (by calling sbrk(2) with a suitable argument).
+	// The malloc_trim() function attempts to release free memory at the top of the heap (by calling sbrk(2) with a
+	// suitable argument).
 	int malloc_trim( size_t ) {
 		return 0;										// => impossible to release memory
 	} // malloc_trim
 
-	// The malloc_usable_size() function returns the number of usable bytes in the
-	// block pointed to by ptr, a pointer to a block of memory allocated by
-	// malloc(3) or a related function.
-		size_t malloc_usable_size( void * addr ) {
-		if ( unlikely( addr == 0 ) ) return 0;			// null allocation has 0 size
+	// The malloc_usable_size() function returns the number of usable bytes in the block pointed to by ptr, a pointer to
+	// a block of memory allocated by malloc(3) or a related function.
+	size_t malloc_usable_size( void * addr ) {
+	  if ( unlikely( addr == 0 ) ) return 0;			// null allocation has 0 size
 
 		HeapManager.Storage.Header * header;
@@ -982,7 +961,7 @@
 
 
-		// #comment TD : Document this function
+    // The malloc_alignment() function returns the alignment of the allocation.
 	size_t malloc_alignment( void * addr ) {
-		if ( unlikely( addr == 0 ) ) return libAlign();	// minimum alignment
+	  if ( unlikely( addr == 0 ) ) return libAlign();	// minimum alignment
 		HeapManager.Storage.Header * header = (HeapManager.Storage.Header *)( (char *)addr - sizeof(HeapManager.Storage) );
 		if ( (header->kind.fake.alignment & 1) == 1 ) {	// fake header ?
@@ -991,10 +970,10 @@
 			return libAlign ();							// minimum alignment
 		} // if
-		} // malloc_alignment
-
-
-		// #comment TD : Document this function
+	} // malloc_alignment
+
+
+    // The malloc_zero_fill() function returns true if the allocation is zero filled, i.e., initially allocated by calloc().
 	bool malloc_zero_fill( void * addr ) {
-		if ( unlikely( addr == 0 ) ) return false;		// null allocation is not zero fill
+	  if ( unlikely( addr == 0 ) ) return false;		// null allocation is not zero fill
 
 		HeapManager.Storage.Header * header = (HeapManager.Storage.Header *)( (char *)addr - sizeof(HeapManager.Storage) );
@@ -1003,28 +982,30 @@
 		} // if
 		return (header->kind.real.blockSize & 2) != 0;	// zero filled (calloc/cmemalign) ?
-		} // malloc_zero_fill
-
-
-	// #comment TD : Document this function
+	} // malloc_zero_fill
+
+
+    // The malloc_stats() function prints (on default standard error) statistics about memory allocated by malloc(3) and
+    // related functions.
 	void malloc_stats( void ) {
 		#ifdef __STATISTICS__
-			printStats();
-			if ( checkFree() ) checkFree( heapManager );
-		#endif // __STATISTICS__
-		} // malloc_stats
-
-	// #comment TD : Document this function
-		int malloc_stats_fd( int fd ) {
-		#ifdef __STATISTICS__
-			int temp = statfd;
-			statfd = fd;
-			return temp;
+		printStats();
+		if ( checkFree() ) checkFree( heapManager );
+		#endif // __STATISTICS__
+	} // malloc_stats
+
+	// The malloc_stats_fd() function changes the file descripter where malloc_stats() writes the statistics.
+	int malloc_stats_fd( int fd ) {
+		#ifdef __STATISTICS__
+		int temp = statfd;
+		statfd = fd;
+		return temp;
 		#else
-			return -1;
-		#endif // __STATISTICS__
-		} // malloc_stats_fd
-
-
-	// #comment TD : Document this function
+		return -1;
+		#endif // __STATISTICS__
+	} // malloc_stats_fd
+
+	// The malloc_info() function exports an XML string that describes the current state of the memory-allocation
+	// implementation in the caller.  The string is printed on the file stream stream.  The exported string includes
+	// information about all arenas (see malloc(3)).
 	int malloc_info( int options, FILE * stream ) {
 		return printStatsXML( stream );
@@ -1032,11 +1013,17 @@
 
 
-	// #comment TD : What are these two functions for?
+	// The malloc_get_state() function records the current state of all malloc(3) internal bookkeeping variables (but
+	// not the actual contents of the heap or the state of malloc_hook(3) functions pointers).  The state is recorded in
+	// a system-dependent opaque data structure dynamically allocated via malloc(3), and a pointer to that data
+	// structure is returned as the function result.  (It is the caller's responsibility to free(3) this memory.)
 	void * malloc_get_state( void ) {
-		return 0;
+		return 0;										// unsupported
 	} // malloc_get_state
 
+
+	// The malloc_set_state() function restores the state of all malloc(3) internal bookkeeping variables to the values
+	// recorded in the opaque data structure pointed to by state.
 	int malloc_set_state( void * ptr ) {
-		return 0;
+		return 0;										// unsupported
 	} // malloc_set_state
 } // extern "C"
Index: src/Parser/lex.ll
===================================================================
--- src/Parser/lex.ll	(revision 514247d2ce3ed93eb65184b7e372236868d74b72)
+++ src/Parser/lex.ll	(revision 933933c7028ae75d883ec7f91df299e7ee478fc3)
@@ -10,6 +10,6 @@
  * Created On       : Sat Sep 22 08:58:10 2001
  * Last Modified By : Peter A. Buhr
- * Last Modified On : Wed Aug  8 17:23:17 2018
- * Update Count     : 685
+ * Last Modified On : Wed Aug 29 15:02:41 2018
+ * Update Count     : 686
  */
 
@@ -410,6 +410,8 @@
 ">>="			{ NAMEDOP_RETURN(RSassign); }
 
-"~="			{ NAMEDOP_RETURN(Erange); }				// CFA
 "@="			{ NAMEDOP_RETURN(ATassign); }			// CFA
+"~="			{ NAMEDOP_RETURN(ErangeUpEq); }			// CFA
+"-~"			{ NAMEDOP_RETURN(ErangeDown); }			// CFA
+"-~="			{ NAMEDOP_RETURN(ErangeDownEq); }		// CFA
 
 				/* CFA, operator identifier */
Index: src/Parser/parser.yy
===================================================================
--- src/Parser/parser.yy	(revision 514247d2ce3ed93eb65184b7e372236868d74b72)
+++ src/Parser/parser.yy	(revision 933933c7028ae75d883ec7f91df299e7ee478fc3)
@@ -10,6 +10,6 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Aug  8 17:50:07 2018
-// Update Count     : 3998
+// Last Modified On : Wed Aug 29 16:44:17 2018
+// Update Count     : 4006
 //
 
@@ -186,4 +186,8 @@
 } // fieldDecl
 
+ExpressionNode *forInc( const OperKinds op ) {
+	return new ExpressionNode( build_constantInteger( *new string( op == OperKinds::LThan || op == OperKinds::LEThan ? "1" : "-1" ) ) );
+} // forInc
+
 ForCtrl * forCtrl( ExpressionNode * type, string * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
 	return new ForCtrl(
@@ -290,5 +294,5 @@
 %token ANDassign	ERassign	ORassign				// &=	^=	|=
 
-%token Erange											// ~=
+%token ErangeUpEq	ErangeDown	ErangeDownEq			// ~=	-~	-~=
 %token ATassign											// @=
 
@@ -1138,10 +1142,10 @@
 				$$ = new ForCtrl( (ExpressionNode * )nullptr, (ExpressionNode * )nullptr, (ExpressionNode * )nullptr );
 			} else {
-				$$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), new ExpressionNode( build_constantInteger( *new string( "0" ) ) ), OperKinds::LThan, $1->clone(),
-							 new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) );
+				$$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), new ExpressionNode( build_constantInteger( *new string( "0" ) ) ),
+							  OperKinds::LThan, $1->clone(), forInc( OperKinds::LThan ) );
 			} // if
 		}
 	| constant_expression inclexcl constant_expression	// CFA
-		{ $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), $1->clone(), $2, $3, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
+		{ $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), $1->clone(), $2, $3, forInc( $2 ) ); }
 	| constant_expression inclexcl constant_expression '~' constant_expression // CFA
 		{ $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), $1->clone(), $2, $3, $5 ); }
@@ -1154,6 +1158,6 @@
 			} else {
 				if ( NameExpr *identifier = dynamic_cast<NameExpr *>($1->get_expr()) ) {
-					$$ = forCtrl( $3, new string( identifier->name ), new ExpressionNode( build_constantInteger( *new string( "0" ) ) ), OperKinds::LThan, $3->clone(),
-								 new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) );
+					$$ = forCtrl( $3, new string( identifier->name ), new ExpressionNode( build_constantInteger( *new string( "0" ) ) ),
+								  OperKinds::LThan, $3->clone(), forInc( OperKinds::LThan ) );
 				} else {
 					SemanticError( yylloc, "Expression disallowed. Only loop-index name allowed" ); $$ = nullptr;
@@ -1167,5 +1171,5 @@
 			} else {
 				if ( NameExpr *identifier = dynamic_cast<NameExpr *>($1->get_expr()) ) {
-					$$ = forCtrl( $3, new string( identifier->name ), $3->clone(), $4, $5, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) );
+					$$ = forCtrl( $3, new string( identifier->name ), $3->clone(), $4, $5, forInc( $4 ) );
 				} else {
 					SemanticError( yylloc, "Expression disallowed. Only loop-index name allowed" ); $$ = nullptr;
@@ -1194,6 +1198,10 @@
 	'~'
 		{ $$ = OperKinds::LThan; }
-	| Erange
+	| ErangeUpEq
 		{ $$ = OperKinds::LEThan; }
+	| ErangeDown
+		{ $$ = OperKinds::GThan; }
+	| ErangeDownEq
+		{ $$ = OperKinds::GEThan; }
  	;
 
Index: tests/.expect/forctrl.txt
===================================================================
--- tests/.expect/forctrl.txt	(revision 514247d2ce3ed93eb65184b7e372236868d74b72)
+++ tests/.expect/forctrl.txt	(revision 933933c7028ae75d883ec7f91df299e7ee478fc3)
@@ -2,12 +2,17 @@
 empty
 empty
-X X X X X X X X X X
-Y Y Y Y Y
-Z Z Z Z Z
+A A A A A A A A A A
+B B B B B
+C C C C C
+D D D D D
+E E E E E
 0 1 2 3 4 5 6 7 8 9
 0 1 2 3 4 5 6 7 8 9
+2 4 6 8 10
+10 8 6 4 2
 0.5 1.5 2.5 3.5 4.5
+5.5 4.5 3.5 2.5 1.5
 2 4 6 8 10
-2 4 6 8 10
+10 8 6 4 2
 3 6 9
 (0 0)(1 1)(2 2)(3 3)(4 4)(5 5)(6 6)(7 7)(8 8)(9 9)
Index: tests/forctrl.c
===================================================================
--- tests/forctrl.c	(revision 514247d2ce3ed93eb65184b7e372236868d74b72)
+++ tests/forctrl.c	(revision 933933c7028ae75d883ec7f91df299e7ee478fc3)
@@ -10,6 +10,6 @@
 // Created On       : Wed Aug  8 18:32:59 2018
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Aug 16 09:25:47 2018
-// Update Count     : 6
+// Last Modified On : Wed Aug 29 18:04:15 2018
+// Update Count     : 26
 // 
 
@@ -33,12 +33,24 @@
 	do { sout | "empty"; break; } while ();	sout | endl;
 	for () { sout | "empty"; break; }		sout | endl;
-	for ( 10 ) { sout | "X"; }				sout | endl;
-	for ( 0.5 ~ 5.5 ) { sout | "Y"; }		sout | endl;
-	for ( 2 ~= 10 ~ 2 ) { sout | "Z"; }		sout | endl;
+
+	for ( 10 ) { sout | "A"; }				sout | endl;
+
+	for ( 2 ~= 10 ~ 2 ) { sout | "B"; }		sout | endl;
+	for ( 10 -~= 2 ~ -2 ) { sout | "C"; }	sout | endl;
+	for ( 0.5 ~ 5.5 ) { sout | "D"; }		sout | endl;
+	for ( 5.5 -~ 0.5 ) { sout | "E"; }		sout | endl;
+
 	for ( i; 10 ) { sout | i; }				sout | endl;
 	for ( j; 10 ) { sout | j; }				sout | endl;
+
+	//for ( i; 1 ~= 10 ~ 2 ) { sout | i; }	sout | endl;
+	for ( i; 2 ~= 10 ~ 2 ) { sout | i; }	sout | endl;
+	for ( i; 10 -~= 2 ~ -2 ) { sout | i; }	sout | endl;
 	for ( i; 0.5 ~ 5.5 ) { sout | i; }		sout | endl;
-	for ( i; 2 ~= 10 ~ 2 ) { sout | i; }	sout | endl;
+	for ( i; 5.5 -~ 0.5 ) { sout | i; }		sout | endl;
+
 	for ( ui; 2u ~= 10u ~ 2u ) { sout | ui; } sout | endl;
+	for ( ui; 10u -~= 2u ~ -2u ) { sout | ui; } sout | endl;
+
 	int start = 3, comp = 10, inc = 2;
 	for ( i; start ~ comp ~ inc + 1 ) { sout | i; } sout | endl;
