Index: doc/bibliography/pl.bib =================================================================== --- doc/bibliography/pl.bib (revision dd4e2d7a1ba13c040f8d0eb5c9b0c672b5755c3a) +++ doc/bibliography/pl.bib (revision 6c12fd28ccd5d0df5de4277788cba0edd4a3bc8c) @@ -4759,5 +4759,5 @@ contributer = {pabuhr@plg}, author = {Gregory R. Andrews}, - title = {A Method for Solving Synronization Problems}, + title = {A Method for Solving Synchronization Problems}, journal = scp, volume = 13, Index: libcfa/configure =================================================================== --- libcfa/configure (revision dd4e2d7a1ba13c040f8d0eb5c9b0c672b5755c3a) +++ libcfa/configure (revision 6c12fd28ccd5d0df5de4277788cba0edd4a3bc8c) @@ -790,6 +790,6 @@ enable_distcc with_cfa_name +enable_static enable_shared -enable_static with_pic enable_fast_install @@ -1452,6 +1452,6 @@ --disable-silent-rules verbose build output (undo: "make V=0") --enable-distcc whether or not to enable distributed compilation + --enable-static[=PKGS] build static libraries [default=no] --enable-shared[=PKGS] build shared libraries [default=yes] - --enable-static[=PKGS] build static libraries [default=yes] --enable-fast-install[=PKGS] optimize for fast installation [default=yes] @@ -8030,4 +8030,33 @@ # Set options +# Check whether --enable-static was given. +if test "${enable_static+set}" = set; then : + enableval=$enable_static; p=${PACKAGE-default} + case $enableval in + yes) enable_static=yes ;; + no) enable_static=no ;; + *) + enable_static=no + # Look at the argument we got. We use all the common list separators. + lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR, + for pkg in $enableval; do + IFS=$lt_save_ifs + if test "X$pkg" = "X$p"; then + enable_static=yes + fi + done + IFS=$lt_save_ifs + ;; + esac +else + enable_static=no +fi + + + + + + + @@ -8062,34 +8091,4 @@ fi - - - - - - - - - # Check whether --enable-static was given. -if test "${enable_static+set}" = set; then : - enableval=$enable_static; p=${PACKAGE-default} - case $enableval in - yes) enable_static=yes ;; - no) enable_static=no ;; - *) - enable_static=no - # Look at the argument we got. We use all the common list separators. - lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR, - for pkg in $enableval; do - IFS=$lt_save_ifs - if test "X$pkg" = "X$p"; then - enable_static=yes - fi - done - IFS=$lt_save_ifs - ;; - esac -else - enable_static=yes -fi @@ -17728,6 +17727,6 @@ macro_version='`$ECHO "$macro_version" | $SED "$delay_single_quote_subst"`' macro_revision='`$ECHO "$macro_revision" | $SED "$delay_single_quote_subst"`' +enable_static='`$ECHO "$enable_static" | $SED "$delay_single_quote_subst"`' enable_shared='`$ECHO "$enable_shared" | $SED "$delay_single_quote_subst"`' -enable_static='`$ECHO "$enable_static" | $SED "$delay_single_quote_subst"`' pic_mode='`$ECHO "$pic_mode" | $SED "$delay_single_quote_subst"`' enable_fast_install='`$ECHO "$enable_fast_install" | $SED "$delay_single_quote_subst"`' @@ -18857,9 +18856,9 @@ macro_revision=$macro_revision +# Whether or not to build static libraries. +build_old_libs=$enable_static + # Whether or not to build shared libraries. build_libtool_libs=$enable_shared - -# Whether or not to build static libraries. -build_old_libs=$enable_static # What type of objects to build. Index: libcfa/configure.ac =================================================================== --- libcfa/configure.ac (revision dd4e2d7a1ba13c040f8d0eb5c9b0c672b5755c3a) +++ libcfa/configure.ac (revision 6c12fd28ccd5d0df5de4277788cba0edd4a3bc8c) @@ -109,5 +109,5 @@ # Checks for programs. -LT_INIT +LT_INIT([disable-static]) AC_PROG_CXX Index: libcfa/src/bits/locks.hfa =================================================================== --- libcfa/src/bits/locks.hfa (revision dd4e2d7a1ba13c040f8d0eb5c9b0c672b5755c3a) +++ libcfa/src/bits/locks.hfa (revision 6c12fd28ccd5d0df5de4277788cba0edd4a3bc8c) @@ -115,5 +115,5 @@ char * strerror(int); } - #define CHECKED(x) { int err = x; if( err != 0 ) abort("KERNEL ERROR: %s\n", strerror(err)); } + #define CHECKED(x) { int err = x; if( err != 0 ) abort("KERNEL ERROR: Operation \"" #x "\" return error %d - %s\n", err, strerror(err)); } struct __bin_sem_t { Index: libcfa/src/concurrency/kernel.cfa =================================================================== --- libcfa/src/concurrency/kernel.cfa (revision dd4e2d7a1ba13c040f8d0eb5c9b0c672b5755c3a) +++ libcfa/src/concurrency/kernel.cfa (revision 6c12fd28ccd5d0df5de4277788cba0edd4a3bc8c) @@ -901,4 +901,5 @@ // Wake them up __cfadbg_print_safe(runtime_core, "Kernel : waking Processor %p\n", this->idles.head); + /* paranoid */ verify( ! kernelTLS.preemption_state.enabled ); post( this->idles.head->idle ); @@ -911,5 +912,11 @@ static bool __wake_proc(processor * this) { __cfadbg_print_safe(runtime_core, "Kernel : waking Processor %p\n", this); - return post( this->idle ); + + disable_interrupts(); + /* paranoid */ verify( ! kernelTLS.preemption_state.enabled ); + bool ret = post( this->idle ); + enable_interrupts( __cfaabi_dbg_ctx ); + + return ret; } Index: libcfa/src/exception.hfa =================================================================== --- libcfa/src/exception.hfa (revision 6c12fd28ccd5d0df5de4277788cba0edd4a3bc8c) +++ libcfa/src/exception.hfa (revision 6c12fd28ccd5d0df5de4277788cba0edd4a3bc8c) @@ -0,0 +1,106 @@ +// +// 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. +// +// exception.hfa -- User facing tools for working with exceptions. +// +// Author : Andrew Beach +// Created On : Thu Apr 7 10:25:00 2020 +// Last Modified By : Andrew Beach +// Last Modified On : Thu Apr 7 10:25:00 2020 +// Update Count : 0 +// + +// Everything below this line should be considered a patch while the exception +// objects themselves are designed and created and should be removed in time. +// ----------------------------------------------------------------------------------------------- + +// All internals helper macros begin with an underscore. +#define _CLOSE(...) __VA_ARGS__ } +#define _GLUE2(left, right) left##right +#define _GLUE3(left, middle, right) left##middle##right +#define _EXC_DISPATCH(to, ...) to(__VA_ARGS__,__cfaehm_base_exception_t,) + +// FWD_TRIVIAL_EXCEPTION(exception_name); +// Declare a trivial exception, one that adds no fields or features. +// This will make the exception visible and may go in a .hfa or .cfa file. +#define FWD_TRIVIAL_EXCEPTION(...) _EXC_DISPATCH(_FWD_TRIVIAL_EXCEPTION, __VA_ARGS__) +// INST_TRIVIAL_EXCEPTION(exception_name); +// Create the trival exception. This must be used exactly once and should be used in a .cfa file, +// as it creates the unique instance of the virtual table. +#define INST_TRIVIAL_EXCEPTION(...) _EXC_DISPATCH(_INST_TRIVIAL_EXCEPTION, __VA_ARGS__) +// TRIVIAL_EXCEPTION(exception_name[, parent_name]); +// Does both of the above, a short hand if the exception is only used in one .cfa file. +// For legacy reasons this is the only one that official supports having a parent other than the +// base exception. This feature may be removed or changed. +#define TRIVIAL_EXCEPTION(...) \ + _EXC_DISPATCH(_FWD_TRIVIAL_EXCEPTION, __VA_ARGS__); \ + _EXC_DISPATCH(_INST_TRIVIAL_EXCEPTION, __VA_ARGS__) +#define _FWD_TRIVIAL_EXCEPTION(exception_name, parent_name, ...) \ + _VTABLE_DECLARATION(exception_name, parent_name)(); \ + struct exception_name { \ + VTABLE_FIELD(exception_name); \ + }; \ + void ?{}(exception_name & this); \ + const char * _GLUE2(exception_name,_msg)(exception_name * this) +#define _INST_TRIVIAL_EXCEPTION(exception_name, parent_name, ...) \ + void ?{}(exception_name & this) { \ + VTABLE_INIT(this, exception_name); \ + } \ + const char * _GLUE2(exception_name,_msg)(exception_name * this) { \ + return #exception_name; \ + } \ + _VTABLE_INSTANCE(exception_name, parent_name,)(_GLUE2(exception_name,_msg)) + +// DATA_EXCEPTION(exception_name)(fields...); +// Forward declare an exception that adds fields but no features. The added fields go in the +// second argument list. The virtual table instance must be provided later (see VTABLE_INSTANCE). +#define DATA_EXCEPTION(...) _EXC_DISPATCH(_DATA_EXCEPTION, __VA_ARGS__) +#define _DATA_EXCEPTION(exception_name, parent_name, ...) \ + _VTABLE_DECLARATION(exception_name, parent_name)(); \ + struct exception_name { VTABLE_FIELD(exception_name); _CLOSE + +// VTABLE_DECLARATION(exception_name)([new_features...]); +// Declare a virtual table type for an exception with exception_name. You may also add features +// (fields on the virtual table) by including them in the second list. +#define VTABLE_DECLARATION(...) _EXC_DISPATCH(_VTABLE_DECLARATION, __VA_ARGS__) +#define _VTABLE_DECLARATION(exception_name, parent_name, ...) \ + struct exception_name; \ + VTABLE_TYPE(exception_name); \ + extern VTABLE_TYPE(exception_name) VTABLE_NAME(exception_name); \ + VTABLE_TYPE(exception_name) { \ + VTABLE_TYPE(parent_name) const * parent; \ + size_t size; \ + void (*copy)(exception_name * this, exception_name * other); \ + void (*free)(exception_name & this); \ + const char * (*msg)(exception_name * this); \ + _CLOSE + +// VTABLE_INSTANCE(exception_name)(msg [, others...]); +// Create the instance of the virtual table. There must be exactly one instance of a virtual table +// for each exception type. This fills in most of the fields of the virtual table (uses ?=? and +// ^?{}) but you must provide the message function and any other fields added in the declaration. +#define VTABLE_INSTANCE(...) _EXC_DISPATCH(_VTABLE_INSTANCE, __VA_ARGS__) +#define _VTABLE_INSTANCE(exception_name, parent_name, ...) \ + void _GLUE2(exception_name,_copy)(exception_name * this, exception_name * other) { \ + *this = *other; \ + } \ + VTABLE_TYPE(exception_name) VTABLE_NAME(exception_name) @= { \ + &VTABLE_NAME(parent_name), sizeof(exception_name), \ + _GLUE2(exception_name,_copy), ^?{}, \ + _CLOSE + +// VTABLE_TYPE(exception_name) | VTABLE_NAME(exception_name) +// Get the name of the vtable type or the name of the vtable instance for an exception type. +#define VTABLE_TYPE(exception_name) struct _GLUE2(exception_name,_vtable) +#define VTABLE_NAME(exception_name) _GLUE3(_,exception_name,_vtable_instance) + +// VTABLE_FIELD(exception_name); +// The declaration of the virtual table field. Should be the first declaration in a virtual type. +#define VTABLE_FIELD(exception_name) VTABLE_TYPE(exception_name) const * virtual_table + +// VTABLE_INIT(object_reference, exception_name); +// Sets a virtual table field on an object to the virtual table instance for the type. +#define VTABLE_INIT(this, exception_name) (this).virtual_table = &VTABLE_NAME(exception_name) Index: libcfa/src/heap.cfa =================================================================== --- libcfa/src/heap.cfa (revision dd4e2d7a1ba13c040f8d0eb5c9b0c672b5755c3a) +++ libcfa/src/heap.cfa (revision 6c12fd28ccd5d0df5de4277788cba0edd4a3bc8c) @@ -10,6 +10,6 @@ // Created On : Tue Dec 19 21:58:35 2017 // Last Modified By : Peter A. Buhr -// Last Modified On : Sat Apr 18 17:43:15 2020 -// Update Count : 718 +// Last Modified On : Wed May 6 17:29:26 2020 +// Update Count : 727 // @@ -19,9 +19,9 @@ #include // errno #include // memset, memcpy +#include // ULONG_MAX extern "C" { #include // mmap, munmap } // extern "C" -// #comment TD : Many of these should be merged into math I believe #include "bits/align.hfa" // libPow2 #include "bits/defs.hfa" // likely, unlikely @@ -30,4 +30,5 @@ //#include "stdlib.hfa" // bsearchl #include "malloc.h" +#include "bitmanip.hfa" // ceiling #define MIN(x, y) (y > x ? x : y) @@ -81,11 +82,11 @@ }; +size_t default_heap_expansion() __attribute__(( weak )) { + return __CFA_DEFAULT_HEAP_EXPANSION__; +} // default_heap_expansion + size_t default_mmap_start() __attribute__(( weak )) { return __CFA_DEFAULT_MMAP_START__; } // default_mmap_start - -size_t default_heap_expansion() __attribute__(( weak )) { - return __CFA_DEFAULT_HEAP_EXPANSION__; -} // default_heap_expansion @@ -360,11 +361,4 @@ -static inline bool setHeapExpand( size_t value ) { - if ( heapExpand < pageSize ) return true; - heapExpand = value; - return false; -} // setHeapExpand - - // thunk problem size_t Bsearchl( unsigned int key, const unsigned int * vals, size_t dim ) { @@ -383,5 +377,5 @@ static inline bool setMmapStart( size_t value ) { // true => mmapped, false => sbrk - if ( value < pageSize || bucketSizes[NoBucketSizes - 1] < value ) return true; + if ( value < pageSize || bucketSizes[NoBucketSizes - 1] < value ) return false; mmapStart = value; // set global @@ -390,5 +384,5 @@ assert( maxBucketsUsed < NoBucketSizes ); // subscript failure ? assert( mmapStart <= bucketSizes[maxBucketsUsed] ); // search failure ? - return false; + return true; } // setMmapStart @@ -449,5 +443,5 @@ #ifdef __CFA_DEBUG__ - checkHeader( addr < heapBegin || header < (HeapManager.Storage.Header *)heapBegin, name, addr ); // bad low address ? + checkHeader( addr < heapBegin, name, addr ); // bad low address ? #endif // __CFA_DEBUG__ @@ -508,5 +502,5 @@ // along with the block and is a multiple of the alignment size. - if ( unlikely( size > ~0ul - sizeof(HeapManager.Storage) ) ) return 0p; + if ( unlikely( size > ULONG_MAX - sizeof(HeapManager.Storage) ) ) return 0p; size_t tsize = size + sizeof(HeapManager.Storage); if ( likely( tsize < mmapStart ) ) { // small size => sbrk @@ -560,5 +554,5 @@ block->header.kind.real.home = freeElem; // pointer back to free list of apropriate size } else { // large size => mmap - if ( unlikely( size > ~0ul - pageSize ) ) return 0p; + if ( unlikely( size > ULONG_MAX - pageSize ) ) return 0p; tsize = libCeiling( tsize, pageSize ); // must be multiple of page size #ifdef __STATISTICS__ @@ -702,5 +696,5 @@ #endif // FASTLOOKUP - if ( setMmapStart( default_mmap_start() ) ) { + if ( ! setMmapStart( default_mmap_start() ) ) { abort( "HeapManager : internal error, mmap start initialization failure." ); } // if @@ -708,6 +702,5 @@ char * end = (char *)sbrk( 0 ); - 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 + heapBegin = heapEnd = sbrk( (char *)libCeiling( (long unsigned int)end, libAlign() ) - end ); // move start of heap to multiple of alignment } // HeapManager @@ -735,5 +728,5 @@ //assert( heapManager.heapBegin != 0 ); //heapManager{}; - if ( heapManager.heapBegin == 0p ) heapManager{}; + if ( heapManager.heapBegin == 0p ) heapManager{}; // sanity check } // memory_startup @@ -863,15 +856,5 @@ #endif // __STATISTICS__ - size_t size = dim * elemSize; - char * addr = (char *)mallocNoStats( size ); - if ( unlikely( addr == 0p ) ) return 0p; - - HeapManager.Storage.Header * header; - HeapManager.FreeHeader * freeElem; - size_t bsize, alignment; - headers( "aalloc", addr, header, freeElem, bsize, alignment ); - - header->kind.real.blockSize |= 2; // mark as zero filled - return addr; + return mallocNoStats( dim * elemSize ); } // aalloc @@ -914,6 +897,6 @@ // change size, DO NOT preserve STICKY PROPERTIES. + free( oaddr ); void * naddr = mallocNoStats( size ); // create new area - free( oaddr ); return naddr; } // resize @@ -988,14 +971,5 @@ #endif // __STATISTICS__ - size_t size = dim * elemSize; - char * addr = (char *)memalignNoStats( alignment, size ); - if ( unlikely( addr == 0p ) ) return 0p; - HeapManager.Storage.Header * header; - HeapManager.FreeHeader * freeElem; - size_t bsize; - headers( "amemalign", addr, header, freeElem, bsize, alignment ); - - header->kind.real.blockSize |= 2; // mark as zero filled - return addr; + return memalignNoStats( alignment, dim * elemSize ); } // amemalign @@ -1043,5 +1017,5 @@ // 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 + // or realloc(). Otherwise, or if free(ptr) has already been called before, undefined behaviour occurs. If ptr is // 0p, no operation is performed. void free( void * addr ) { @@ -1170,12 +1144,13 @@ - // Adjusts parameters that control the behavior of the memory-allocation functions (see malloc). The param argument + // Adjusts parameters that control the behaviour of the memory-allocation functions (see malloc). The param argument // specifies the parameter to be modified, and value specifies the new value for that parameter. int mallopt( int option, int value ) { choose( option ) { case M_TOP_PAD: - if ( setHeapExpand( value ) ) return 1; + heapExpand = ceiling( value, pageSize ); return 1; case M_MMAP_THRESHOLD: if ( setMmapStart( value ) ) return 1; + break; } // switch return 0; // error, unsupported Index: libcfa/src/iostream.cfa =================================================================== --- libcfa/src/iostream.cfa (revision dd4e2d7a1ba13c040f8d0eb5c9b0c672b5755c3a) +++ libcfa/src/iostream.cfa (revision 6c12fd28ccd5d0df5de4277788cba0edd4a3bc8c) @@ -10,6 +10,6 @@ // Created On : Wed May 27 17:56:53 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Apr 30 10:50:31 2020 -// Update Count : 1001 +// Last Modified On : Sat May 2 18:30:25 2020 +// Update Count : 1017 // @@ -583,27 +583,20 @@ if ( fmt.flags.pc && fmt.pc > 64 ) fmt.pc -= 64; else { fmt.flags.pc = false; fmt.pc = 0; } \ if ( fmt.flags.left ) { \ - fmt2.wd = fmt.wd; \ - if ( fmt2.wd <= 64 ) { \ - fmt2.wd = 64; \ - } else { \ - if ( fmt.pc > 0 ) { \ - fmt2.wd -= fmt.pc; \ - } else { \ - fmt2.wd = fmt.wd - high1( msig ); \ - } /* if */ \ - if ( ! fmt.flags.nobsdp ) fmt2.wd -= 2; \ - if ( fmt2.wd < 0 ) fmt2.wd = 0; \ - fmt2.flags.left = true; \ - fmt.wd = 0; \ - } /* if */ \ - printf( "left %d %d %x\n", f.wd, f.pc, f.all ); \ - printf( "left %d %d %x\n", fmt.wd, fmt.pc, fmt.all ); \ + fmt.flags.left = false; \ + fmt.wd = 0; \ + /* printf( "L %llo %llo %llo %d %d '%c' %x\n", msig, lsig, fmt.val, fmt.wd, fmt.pc, fmt.base, fmt.all ); */ \ + fmt2.flags.left = true; \ + int msigd = high1( msig ); \ + fmt2.wd = f.wd - (fmt.pc > msigd ? fmt.pc : msigd); \ + if ( ! fmt.flags.nobsdp ) fmt2.wd -= 2; /* compensate for 0b base specifier */ \ + if ( (int)fmt2.wd < 64 ) fmt2.wd = 64; /* cast deals with negative value */ \ + fmt2.flags.pc = true; fmt2.pc = 64; \ } else { \ if ( fmt.wd > 64 ) fmt.wd -= 64; \ - /* if ( ! fmt.flags.nobsdp && fmt.pc < fmt.wd ) fmt.wd -= 1; */ \ + else fmt.wd = 1; \ + /* printf( "R %llo %llo %llo %d %d '%c' %x\n", msig, lsig, fmt.val, fmt.wd, fmt.pc, fmt.base, fmt.all ); */ \ fmt2.wd = 64; \ - /* printf( "R %llo %llo %llo %llo %d %d '%c' %x\n", msig, lsig, fmt.val, fmt2.val, fmt.wd, fmt.pc, fmt.base, fmt.all ); */ \ } /* if */ \ - /* printf( "\nC %llo %d %d '%c' %x\n", fmt2.val, fmt2.wd, fmt2.pc, fmt2.base, fmt2.all ); */ \ + /* printf( "C %llo %d %d '%c' %x\n", fmt2.val, fmt2.wd, fmt2.pc, fmt2.base, fmt2.all ); */ \ (ostype &)(os | fmt | "" | fmt2); \ } else if ( f.base == 'o' ) { \ @@ -614,18 +607,16 @@ fmt.flags.left = false; \ fmt.wd = 0; \ - /* if ( fmt2.val > 1 && fmt.flags.pc && fmt.pc > 0 ) fmt.pc -= 1; */ \ /* printf( "L %llo %llo %llo %d %d '%c' %x %llo %d %d '%c' %x\n", msig, lsig, fmt.val, fmt.wd, fmt.pc, fmt.base, fmt.all, fmt2.val, fmt2.wd, fmt2.pc, fmt2.base, fmt2.all ); */ \ (ostype &)(os | fmt | "" | fmt2); \ sepOff( os ); \ fmt2.flags.left = true; \ - int msigd = ceiling( high1( fmt.val ), 3 ) + 1; \ - fmt2.wd = f.wd - (fmt.pc > msigd ? fmt.pc : msigd) - 1; \ + int msigd = ceiling( high1( fmt.val ), 3 ); \ + fmt2.wd = f.wd - (fmt.pc > msigd ? fmt.pc : msigd); \ + if ( ! fmt.flags.nobsdp ) fmt2.wd -= 1; /* compensate for 0 base specifier */ \ if ( (int)fmt2.wd < 21 ) fmt2.wd = 21; /* cast deals with negative value */ \ fmt2.flags.pc = true; fmt2.pc = 21; \ } else { \ if ( fmt.wd > 22 ) fmt.wd -= 22; \ - /* compensate for leading 0 */ \ - /*if ( ! fmt.flags.nobsdp && fmt.pc < fmt.wd ) fmt.wd -= 1;*/ \ - fmt2.wd = 1; \ + else fmt.wd = 1; \ /* printf( "R %llo %llo %llo %d %d '%c' %x %llo %d %d '%c' %x\n", msig, lsig, fmt.val, fmt.wd, fmt.pc, fmt.base, fmt.all, fmt2.val, fmt2.wd, fmt2.pc, fmt2.base, fmt2.all ); */ \ (ostype &)(os | fmt | "" | fmt2); \ @@ -636,26 +627,23 @@ /* printf( "\nC %llo %d %d '%c' %x\n", fmt2.val, fmt2.wd, fmt2.pc, fmt2.base, fmt2.all ); */ \ (ostype &)(os | fmt2); \ - } else { \ - if ( fmt.flags.pc && fmt.pc > 16 ) fmt.pc -= 16; \ + } else { /* f.base == 'x' | f.base == 'X' */ \ + if ( fmt.flags.pc && fmt.pc > 16 ) fmt.pc -= 16; else { fmt.flags.pc = false; fmt.pc = 0; } \ if ( fmt.flags.left ) { \ - fmt2.wd = fmt.wd; \ - if ( fmt2.wd <= 16 ) { \ - fmt2.wd = 16; \ - } else { \ - if ( fmt.pc > 0 ) { \ - fmt2.wd -= fmt.pc; \ - } else { \ - fmt2.wd = fmt.wd - ceiling2( high1( msig ), 4 ) / 4; \ - } /* if */ \ - if ( ! fmt.flags.nobsdp ) fmt2.wd -= 2; \ - if ( fmt2.wd < 0 ) fmt2.wd = 0; \ - fmt2.flags.left = true; \ - fmt.wd = 0; \ - } /* if */ \ + fmt.flags.left = false; \ + fmt.wd = 0; \ + /* printf( "L %llo %llo %llo %d %d '%c' %x\n", msig, lsig, fmt.val, fmt.wd, fmt.pc, fmt.base, fmt.all ); */ \ + fmt2.flags.left = true; \ + int msigd = high1( msig ); \ + fmt2.wd = f.wd - (fmt.pc > msigd ? fmt.pc : msigd); \ + if ( ! fmt.flags.nobsdp ) fmt2.wd -= 2; /* compensate for 0x base specifier */ \ + if ( (int)fmt2.wd < 16 ) fmt2.wd = 16; /* cast deals with negative value */ \ + fmt2.flags.pc = true; fmt2.pc = 16; \ } else { \ + if ( fmt.wd > 16 ) fmt.wd -= 16; \ + else fmt.wd = 1; \ + /* printf( "R %llo %llo %llo %d %d '%c' %x\n", msig, lsig, fmt.val, fmt.wd, fmt.pc, fmt.base, fmt.all ); */ \ fmt2.wd = 16; \ - if ( fmt.wd > 16 ) fmt.wd -= 16; \ } /* if */ \ - fmt2.pc = 16; fmt2.flags.pc = true; \ + /* printf( "C %llo %d %d '%c' %x\n", fmt2.val, fmt2.wd, fmt2.pc, fmt2.base, fmt2.all ); */ \ (ostype &)(os | fmt | "" | fmt2); \ } /* if */ \ Index: src/Parser/parser.yy =================================================================== --- src/Parser/parser.yy (revision dd4e2d7a1ba13c040f8d0eb5c9b0c672b5755c3a) +++ src/Parser/parser.yy (revision 6c12fd28ccd5d0df5de4277788cba0edd4a3bc8c) @@ -10,6 +10,6 @@ // Created On : Sat Sep 1 20:22:55 2001 // Last Modified By : Peter A. Buhr -// Last Modified On : Fri Mar 6 17:26:45 2020 -// Update Count : 4474 +// Last Modified On : Mon Apr 27 12:25:42 2020 +// Update Count : 4483 // @@ -966,7 +966,11 @@ tuple_expression_list: - assignment_expression_opt - | tuple_expression_list ',' assignment_expression_opt + assignment_expression + | '@' // CFA + { SemanticError( yylloc, "Eliding tuple element with '@' is currently unimplemented." ); $$ = nullptr; } + | tuple_expression_list ',' assignment_expression { $$ = (ExpressionNode *)($1->set_last( $3 )); } + | tuple_expression_list ',' '@' + { SemanticError( yylloc, "Eliding tuple element with '@' is currently unimplemented." ); $$ = nullptr; } ; Index: tests/exceptions/.expect/data-except.txt =================================================================== --- tests/exceptions/.expect/data-except.txt (revision 6c12fd28ccd5d0df5de4277788cba0edd4a3bc8c) +++ tests/exceptions/.expect/data-except.txt (revision 6c12fd28ccd5d0df5de4277788cba0edd4a3bc8c) @@ -0,0 +1,4 @@ +paired(3, 13) +paired(3, 13) +paired(3, 13) +paired(4, 13) Index: tests/exceptions/conditional.cfa =================================================================== --- tests/exceptions/conditional.cfa (revision dd4e2d7a1ba13c040f8d0eb5c9b0c672b5755c3a) +++ tests/exceptions/conditional.cfa (revision 6c12fd28ccd5d0df5de4277788cba0edd4a3bc8c) @@ -4,8 +4,8 @@ // up the non-trivial exception is reasonable to do. -#include "except-mac.hfa" +#include #include -DECLARE_EXCEPT(num_error, BASE_EXCEPT, +VTABLE_DECLARATION(num_error)( int (*code)(num_error *this); ); @@ -36,7 +36,4 @@ this.num = other.num; } -void copy(num_error * this, num_error * other) { - *this = *other; -} void ^?{}(num_error & this) { if( this.msg ) free( this.msg ); @@ -46,6 +43,7 @@ } -VTABLE_INSTANCE(num_error, BASE_EXCEPT, copy, ^?{}, - num_error_msg, num_error_code +VTABLE_INSTANCE(num_error)( + num_error_msg, + num_error_code, ); @@ -58,5 +56,5 @@ try { - THROW(&exc); + throw &exc; } catch (num_error * error ; 3 == error->virtual_table->code( error )) { caught_num_error(3, error); @@ -66,5 +64,5 @@ try { - THROW_RESUME(&exc); + throwResume &exc; } catchResume (num_error * error ; 3 == error->virtual_table->code( error )) { caught_num_error(3, error); Index: tests/exceptions/data-except.cfa =================================================================== --- tests/exceptions/data-except.cfa (revision 6c12fd28ccd5d0df5de4277788cba0edd4a3bc8c) +++ tests/exceptions/data-except.cfa (revision 6c12fd28ccd5d0df5de4277788cba0edd4a3bc8c) @@ -0,0 +1,50 @@ +// Test exceptions that add data but no functionality. + +#include + +DATA_EXCEPTION(paired)( + int first; + int second; +); + +void ?{}(paired & this, int first, int second) { + VTABLE_INIT(this, paired); + this.first = first; + this.second = second; +} + +void copy(paired * this, paired * other) { + *this = *other; +} + +const char * paired_msg(paired * this) { + return "paired"; +} + +VTABLE_INSTANCE(paired)(paired_msg); + +void throwPaired(int first, int second) { + paired exc = {first, second}; +} + +int main(int argc, char * argv[]) { + paired except = {3, 13}; + + try { + throw &except; + } catch (paired * exc) { + printf("%s(%d, %d)\n", paired_msg(exc), exc->first, exc->second); + ++exc->first; + } + + printf("%s(%d, %d)\n", paired_msg(&except), except.first, except.second); + + try { + throwResume &except; + } catchResume (paired * exc) { + printf("%s(%d, %d)\n", paired_msg(exc), exc->first, exc->second); + ++exc->first; + } + + printf("%s(%d, %d)\n", paired_msg(&except), except.first, except.second); +} Index: sts/exceptions/except-mac.hfa =================================================================== --- tests/exceptions/except-mac.hfa (revision dd4e2d7a1ba13c040f8d0eb5c9b0c672b5755c3a) +++ (revision ) @@ -1,81 +1,0 @@ -// Macros to try and make declaring and using exceptions easier -// No, these are not part of the language, they replace the virtual system. - -// Internal use: -#define GLUE2(left, right) left##right -#define GLUE3(left, middle, right) left##middle##right - -// The fully qualified name of the base exception type: -#define BASE_EXCEPT __cfaehm_base_exception_t - -// Get the name of the vtable type and vtable instance for an exception type: -#define TABLE(name) GLUE2(name,_vtable) -#define INSTANCE(name) GLUE3(_,name,_vtable_instance) - -// Throws and the bit of overhead: -#define THROW(expr) throw ((BASE_EXCEPT *)(expr)) -#define THROW_RESUME(expr) throwResume ((BASE_EXCEPT *)(expr)) - - - -// The following macros are for defining your own new exception types. - -// Declare vtable and forward declare the exception type and vtable instance. -// This should start a new exception declaration. -// ... argument is the additional vtable fields. -#define DECLARE_EXCEPT(except_name,parent_name,...) \ -struct except_name; \ -struct TABLE(except_name) { \ - struct TABLE(parent_name) const * parent; \ - size_t size; \ - void (*copy)(except_name *this, except_name * other); \ - void (*free)(except_name &this); \ - const char * (*msg)(except_name *this); \ - __VA_ARGS__ \ -}; \ -extern TABLE(except_name) INSTANCE(except_name) - -// The first field of the exception structure should be created with this. -#define VTABLE_FIELD(except_name) \ -struct TABLE(except_name) const * virtual_table - -// In each constructor the vtable must be initialized. -#define VTABLE_INIT(this_name,except_name) \ -this_name.virtual_table = &INSTANCE(except_name) - -// Declare the vtable instance. This should end an exception declaration. -// ... argument is the remaining vtable field values. -#define VTABLE_INSTANCE(except_name,parent_name,copy,free,msg,...) \ -TABLE(except_name) INSTANCE(except_name) @= { \ - &INSTANCE(parent_name), sizeof(except_name), \ - copy, free, msg, ## __VA_ARGS__ \ -} - -// Same, but used declarators for arguments. -#define VTABLE_INSTANCE_KEY(except_name,parent_name,copy,free,msg,...) \ -TABLE(except_name) INSTANCE(except_name) @= { \ - .parent : &INSTANCE(parent_name), .size : sizeof(except_name), \ - .copy : copy, .free : free, .msg : msg, ## __VA_ARGS__ \ -} - - - -// Declare a trivial exception, one that adds no features: -#define _TRIVIAL_EXCEPTION(name, parent_name, ...) \ -DECLARE_EXCEPT(name,parent_name,); \ -struct name { \ - VTABLE_FIELD(name); \ -}; \ -const char * GLUE2(name,_msg)(name * this) { \ - return #name; \ -} \ -void GLUE2(name,_copy)(name * this, name * other) { \ - this->virtual_table = other->virtual_table; \ -} \ -void ?{}(name & this) { \ - VTABLE_INIT(this,name); \ -} \ -VTABLE_INSTANCE(name,parent_name,GLUE2(name,_copy),^?{},GLUE2(name,_msg),) - -// TRIVIAL_EXCEPTION(name_of_exception, [parent_exception]) -#define TRIVIAL_EXCEPTION(...) _TRIVIAL_EXCEPTION(__VA_ARGS__,BASE_EXCEPT,) Index: tests/exceptions/finally.cfa =================================================================== --- tests/exceptions/finally.cfa (revision dd4e2d7a1ba13c040f8d0eb5c9b0c672b5755c3a) +++ tests/exceptions/finally.cfa (revision 6c12fd28ccd5d0df5de4277788cba0edd4a3bc8c) @@ -1,5 +1,5 @@ // Finally Clause Tests -#include "except-mac.hfa" +#include #include "except-io.hfa" @@ -12,5 +12,5 @@ try { printf("termination throw\n"); - THROW(&exc); + throw &exc; } finally { loud_exit a = "termination inner finally"; @@ -28,5 +28,5 @@ try { printf("resumption throw\n"); - THROW_RESUME(&exc); + throwResume &exc; } finally { loud_exit a = "resumption inner finally"; Index: tests/exceptions/interact.cfa =================================================================== --- tests/exceptions/interact.cfa (revision dd4e2d7a1ba13c040f8d0eb5c9b0c672b5755c3a) +++ tests/exceptions/interact.cfa (revision 6c12fd28ccd5d0df5de4277788cba0edd4a3bc8c) @@ -1,5 +1,5 @@ // Testing Interactions Between Termination and Resumption -#include "except-mac.hfa" +#include #include "except-io.hfa" @@ -10,5 +10,5 @@ // Resume falls back to terminate. try { - THROW_RESUME(&(star){}); + throwResume &(star){}; } catch (star *) { printf("caught as termination\n"); @@ -17,5 +17,5 @@ try { loud_region a = "try block with resume throw"; - THROW_RESUME(&(star){}); + throwResume &(star){}; } catch (star *) { printf("caught as termination\n"); @@ -29,5 +29,5 @@ try { try { - THROW(&(star){}); + throw &(star){}; } catchResume (star *) { printf("resume catch on terminate\n"); @@ -43,5 +43,5 @@ try { try { - THROW_RESUME(&(star){}); + throwResume &(star){}; } catch (star *) { printf("terminate catch on resume\n"); @@ -58,5 +58,5 @@ try { try { - THROW(&(star){}); + throw &(star){}; } catchResume (star *) { printf("inner resume catch (error)\n"); @@ -64,5 +64,5 @@ } catch (star * error) { printf("termination catch, will resume\n"); - THROW_RESUME(error); + throwResume error; } } catchResume (star *) { @@ -75,5 +75,5 @@ try { try { - THROW_RESUME(&(star){}); + throwResume &(star){}; } catch (star *) { printf("inner termination catch\n"); @@ -81,5 +81,5 @@ } catchResume (star * error) { printf("resumption catch, will terminate\n"); - THROW(error); + throw error; } } catch (star *) { @@ -94,10 +94,10 @@ try { printf("throwing resume moon\n"); - THROW_RESUME(&(moon){}); + throwResume &(moon){}; } catch (star *) { printf("termination catch\n"); } printf("throwing resume star\n"); - THROW_RESUME(&(star){}); + throwResume &(star){}; } catchResume (star *) { printf("resumption star catch\n"); @@ -105,5 +105,5 @@ } catchResume (moon *) { printf("resumption moon catch, will terminate\n"); - THROW(&(star){}); + throw &(star){}; } } catchResume (star *) { Index: tests/exceptions/resume.cfa =================================================================== --- tests/exceptions/resume.cfa (revision dd4e2d7a1ba13c040f8d0eb5c9b0c672b5755c3a) +++ tests/exceptions/resume.cfa (revision 6c12fd28ccd5d0df5de4277788cba0edd4a3bc8c) @@ -1,5 +1,5 @@ // Resumption Exception Tests -#include "except-mac.hfa" +#include #include "except-io.hfa" @@ -14,5 +14,5 @@ loud_exit a = "simple try clause"; printf("simple throw\n"); - THROW_RESUME(&(zen){}); + throwResume &(zen){}; printf("end of try clause\n"); } catchResume (zen * error) { @@ -25,5 +25,5 @@ try { printf("throwing child exception\n"); - THROW_RESUME(&(moment_of){}); + throwResume &(moment_of){}; } catchResume (zen *) { printf("inner parent match\n"); @@ -36,5 +36,5 @@ try { try { - THROW_RESUME(&(yin){}); + throwResume &(yin){}; } catchResume (zen *) { printf("caught yin as zen\n"); @@ -52,5 +52,5 @@ loud_exit a = "rethrow inner try"; printf("rethrow inner try\n"); - THROW_RESUME(&(zen){}); + throwResume &(zen){}; } catchResume (zen *) { loud_exit a = "rethrowing catch clause"; @@ -67,8 +67,8 @@ try { try { - THROW_RESUME(&(yin){}); + throwResume &(yin){}; } catchResume (yin *) { printf("caught yin, will throw yang\n"); - THROW_RESUME(&(yang){}); + throwResume &(yang){}; } catchResume (yang *) { printf("caught exception from same try\n"); @@ -83,10 +83,10 @@ try { printf("throwing first exception\n"); - THROW_RESUME(&(yin){}); + throwResume &(yin){}; } catchResume (yin *) { printf("caught first exception\n"); try { printf("throwing second exception\n"); - THROW_RESUME(&(yang){}); + throwResume &(yang){}; } catchResume (yang *) { printf("caught second exception\n"); @@ -104,10 +104,10 @@ try { try { - THROW_RESUME(&(zen){}); - THROW_RESUME(&(zen){}); + throwResume &(zen){}; + throwResume &(zen){}; } catchResume (zen *) { printf("inner catch\n"); } - THROW_RESUME(&(zen){}); + throwResume &(zen){}; } catchResume (zen *) { printf("outer catch\n"); Index: tests/exceptions/terminate.cfa =================================================================== --- tests/exceptions/terminate.cfa (revision dd4e2d7a1ba13c040f8d0eb5c9b0c672b5755c3a) +++ tests/exceptions/terminate.cfa (revision 6c12fd28ccd5d0df5de4277788cba0edd4a3bc8c) @@ -1,5 +1,5 @@ // Termination Exception Tests -#include "except-mac.hfa" +#include #include "except-io.hfa" @@ -14,5 +14,5 @@ loud_exit a = "simple try clause"; printf("simple throw\n"); - THROW(&(zen){}); + throw &(zen){}; printf("end of try clause\n"); } catch (zen * error) { @@ -25,5 +25,5 @@ try { printf("throwing child exception\n"); - THROW(&(moment_of){}); + throw &(moment_of){}; } catch (zen *) { printf("inner parent match\n"); @@ -36,5 +36,5 @@ try { try { - THROW(&(yin){}); + throw &(yin){}; } catch (zen *) { printf("caught yin as zen\n"); @@ -52,5 +52,5 @@ loud_exit a = "rethrow inner try"; printf("rethrow inner try\n"); - THROW(&(zen){}); + throw &(zen){}; } catch (zen *) { loud_exit a = "rethrowing catch clause"; @@ -67,8 +67,8 @@ try { try { - THROW(&(yin){}); + throw &(yin){}; } catch (yin *) { printf("caught yin, will throw yang\n"); - THROW(&(yang){}); + throw &(yang){}; } catch (yang *) { printf("caught exception from same try\n"); @@ -83,10 +83,10 @@ try { printf("throwing first exception\n"); - THROW(&(yin){}); + throw &(yin){}; } catch (yin *) { printf("caught first exception\n"); try { printf("throwing second exception\n"); - THROW(&(yang){}); + throw &(yang){}; } catch (yang *) { printf("caught second exception\n"); @@ -104,10 +104,10 @@ try { try { - THROW(&(zen){}); - THROW(&(zen){}); + throw &(zen){}; + throw &(zen){}; } catch (zen *) { printf("inner catch\n"); } - THROW(&(zen){}); + throw &(zen){}; } catch (zen *) { printf("outer catch\n"); Index: tests/manipulatorsOutput1.cfa =================================================================== --- tests/manipulatorsOutput1.cfa (revision dd4e2d7a1ba13c040f8d0eb5c9b0c672b5755c3a) +++ tests/manipulatorsOutput1.cfa (revision 6c12fd28ccd5d0df5de4277788cba0edd4a3bc8c) @@ -7,6 +7,6 @@ // Created On : Sat Jun 8 18:04:11 2019 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon Jun 10 12:37:28 2019 -// Update Count : 8 +// Last Modified On : Fri May 1 11:51:44 2020 +// Update Count : 9 // @@ -17,43 +17,60 @@ signed char sc = -12; printf( "%hhd %2hhd %5.2hhd %-5.2hhd %hho %#hho %hhx %#hhx %#8hhx %#8.10hhx %#8.3hhX %+-8.3hhd %08hhd\n", sc, sc, sc, sc, sc, sc, sc, sc, sc, sc, sc, sc, sc ); - sout | sc | wd(2,sc) | wd(5,2,sc) | left(wd(5,2,sc)) | nobase(oct(sc)) | oct(sc) | nobase(hex(sc)) | hex(sc) | wd(8,hex(sc)) | wd(8,10,hex(sc)) | upcase(wd(8,3,hex(sc))) | left(sign(upcase(wd(8,3,sc)))) | pad0(wd(8,sc)); + sout | sc | wd(2,sc) | wd(5,2,sc) | left(wd(5,2,sc)) | nobase(oct(sc)) | oct(sc) | nonl; + sout | nobase(hex(sc)) | hex(sc) | wd(8,hex(sc)) | wd(8,10,hex(sc)) | upcase(wd(8,3,hex(sc))) | nonl; + sout | left(sign(upcase(wd(8,3,sc)))) | pad0(wd(8,sc)); sout | "unsigned char"; unsigned char usc = 12; printf( "%hhu %2hhu %5.2hhu %-5.2hhu %hho %#hho %hhx %#hhx %#8hhx %#8.10hhx %#8.3hhX %-8.3hhu %08hhu\n", usc, usc, usc, usc, usc, usc, usc, usc, usc, usc, usc, usc, usc ); - sout | usc | wd(2,usc) | wd(5,2,usc) | left(wd(5,2,usc)) | nobase(oct(usc)) | oct(usc) | nobase(hex(usc)) | hex(usc) | wd(8,hex(usc)) | wd(8,10,hex(usc)) | upcase(wd(8,3,hex(usc))) | left(upcase(wd(8,3,usc))) | pad0(wd(8,usc)); + sout | usc | wd(2,usc) | wd(5,2,usc) | left(wd(5,2,usc)) | nobase(oct(usc)) | oct(usc) | nonl; + sout | nobase(hex(usc)) | hex(usc) | wd(8,hex(usc)) | wd(8,10,hex(usc)) | upcase(wd(8,3,hex(usc))) | nonl; + sout | left(upcase(wd(8,3,usc))) | pad0(wd(8,usc)); sout | "signed short int"; signed short int si = -12; printf( "%hd %2hd %5.2hd %-5.2hd %ho %#ho %hx %#hx %#8hx %#8.10hx %#8.3hX %+-8.3hd %08hd\n", si, si, si, si, si, si, si, si, si, si, si, si, si ); - sout | si | wd(2,si) | wd(5,2,si) | left(wd(5,2,si)) | nobase(oct(si)) | oct(si) | nobase(hex(si)) | hex(si) | wd(8,hex(si)) | wd(8,10,hex(si)) | upcase(wd(8,3,hex(si))) | left(sign(upcase(wd(8,3,si)))) | pad0(wd(8,si)); + sout | si | wd(2,si) | wd(5,2,si) | left(wd(5,2,si)) | nobase(oct(si)) | oct(si) | nonl; + sout | nobase(hex(si)) | hex(si) | wd(8,hex(si)) | wd(8,10,hex(si)) | upcase(wd(8,3,hex(si))) | nonl; + sout | left(sign(upcase(wd(8,3,si)))) | pad0(wd(8,si)); sout | "unsigned short int"; unsigned short int usi = 12; printf( "%hu %2hu %5.2hu %-5.2hu %ho %#ho %hx %#hx %#8hx %#8.10hx %#8.3hX %-8.3hu %08hu\n", usi, usi, usi, usi, usi, usi, usi, usi, usi, usi, usi, usi, usi ); - sout | usi | wd(2,usi) | wd(5,2,usi) | left(wd(5,2,usi)) | nobase(oct(usi)) | oct(usi) | nobase(hex(usi)) | hex(usi) | wd(8,hex(usi)) | wd(8,10,hex(usi)) | upcase(wd(8,3,hex(usi))) | left(upcase(wd(8,3,usi))) | pad0(wd(8,usi)); + sout | usi | wd(2,usi) | wd(5,2,usi) | left(wd(5,2,usi)) | nobase(oct(usi)) | oct(usi) | nonl; + sout | nobase(hex(usi)) | hex(usi) | wd(8,hex(usi)) | wd(8,10,hex(usi)) | upcase(wd(8,3,hex(usi))) | nonl; + sout | left(upcase(wd(8,3,usi))) | pad0(wd(8,usi)); sout | "signed int"; signed int i = -12; printf( "%d %2d %5.2d %-5.2d %o %#o %x %#x %#8x %#8.10x %#8.3X %+-8.3d %08d\n", i, i, i, i, i, i, i, i, i, i, i, i, i ); - sout | i | wd(2,i) | wd(5,2,i) | left(wd(5,2,i)) | nobase(oct(i)) | oct(i) | nobase(hex(i)) | hex(i) | wd(8,hex(i)) | wd(8,10,hex(i)) | upcase(wd(8,3,hex(i))) | left(sign(upcase(wd(8,3,i)))) | pad0(wd(8,i)); + sout | i | wd(2,i) | wd(5,2,i) | left(wd(5,2,i)) | nobase(oct(i)) | oct(i) | nonl; + sout | nobase(hex(i)) | hex(i) | wd(8,hex(i)) | wd(8,10,hex(i)) | upcase(wd(8,3,hex(i))) | nonl; + sout | left(sign(upcase(wd(8,3,i)))) | pad0(wd(8,i)); sout | "unsigned int"; unsigned int ui = 12; printf( "%u %2u %5.2u %-5.2u %o %#o %x %#x %#8x %#8.10x %#8.3X %-8.3u %08u\n", ui, ui, ui, ui, ui, ui, ui, ui, ui, ui, ui, ui, ui ); - sout | ui | wd(2,ui) | wd(5,2,ui) | left(wd(5,2,ui)) | nobase(oct(ui)) | oct(ui) | nobase(hex(ui)) | hex(ui) | wd(8,hex(ui)) | wd(8,10,hex(ui)) | upcase(wd(8,3,hex(ui))) | left(upcase(wd(8,3,ui))) | pad0(wd(8,ui)); + sout | ui | wd(2,ui) | wd(5,2,ui) | left(wd(5,2,ui)) | nobase(oct(ui)) | oct(ui) | nonl; + sout | nobase(hex(ui)) | hex(ui) | wd(8,hex(ui)) | wd(8,10,hex(ui)) | upcase(wd(8,3,hex(ui))) | nonl; + sout | left(upcase(wd(8,3,ui))) | pad0(wd(8,ui)); sout | "signed long long int"; signed long long int lli = -12; printf( "%lld %2lld %5.2lld %-5.2lld %llo %#llo %llx %#llx %#8llx %#8.10llx %#8.3llX %+-8.3lld %08lld\n", lli, lli, lli, lli, lli, lli, lli, lli, lli, lli, lli, lli, lli ); - sout | lli | wd(2,lli) | wd(5,2,lli) | left(wd(5,2,lli)) | nobase(oct(lli)) | oct(lli) | nobase(hex(lli)) | hex(lli) | wd(8,hex(lli)) | wd(8,10,hex(lli)) | upcase(wd(8,3,hex(lli))) | left(sign(upcase(wd(8,3,lli)))) | pad0(wd(8,lli)); + sout | lli | wd(2,lli) | wd(5,2,lli) | left(wd(5,2,lli)) | nobase(oct(lli)) | oct(lli) | nonl; + sout | nobase(hex(lli)) | hex(lli) | wd(8,hex(lli)) | wd(8,10,hex(lli)) | upcase(wd(8,3,hex(lli))) | nonl; + sout | left(sign(upcase(wd(8,3,lli)))) | pad0(wd(8,lli)); sout | "unsigned long long int"; unsigned long long int ulli = 12; printf( "%llu %2llu %5.2llu %-5.2llu %llo %#llo %llx %#llx %#8llx %#8.10llx %#8.3llX %-8.3llu %08llu\n", ulli, ulli, ulli, ulli, ulli, ulli, ulli, ulli, ulli, ulli, ulli, ulli, ulli ); - sout | ulli | wd(2,ulli) | wd(5,2,ulli) | left(wd(5,2,ulli)) | nobase(oct(ulli)) | oct(ulli) | nobase(hex(ulli)) | hex(ulli) | wd(8,hex(ulli)) | wd(8,10,hex(ulli)) | upcase(wd(8,3,hex(ulli))) | left(upcase(wd(8,3,ulli))) | pad0(wd(8,ulli)); + sout | ulli | wd(2,ulli) | wd(5,2,ulli) | left(wd(5,2,ulli)) | nobase(oct(ulli)) | oct(ulli) | nonl; + sout | nobase(hex(ulli)) | hex(ulli) | wd(8,hex(ulli)) | wd(8,10,hex(ulli)) | upcase(wd(8,3,hex(ulli))) | nonl; + sout | left(upcase(wd(8,3,ulli))) | pad0(wd(8,ulli)); sout | nl | "binary integral"; - sout | bin(0) | bin(13) | upcase(bin(13)) | nobase(bin(13)) | left(wd(8,bin(13))) | wd(8,bin(13)) | pad0(left(wd(8,bin(13)))) | pad0(wd(8,bin(13))) | pad0(wd(8,10,bin(13))) | pad0(wd(8,6,bin(13))); + sout | bin(0) | bin(13) | upcase(bin(13)) | nobase(bin(13)) | left(wd(8,bin(13))) | wd(8,bin(13)) | nonl; + sout | pad0(left(wd(8,bin(13)))) | pad0(wd(8,bin(13))) | pad0(wd(8,10,bin(13))) | pad0(wd(8,6,bin(13))); @@ -62,5 +79,7 @@ printf( "%g %8g %#8g %g %8g %8.0g %#8.0g %8.2g %#8.2g %-8.2g %-8.2g %-#8.2g %-+8.2g %-+#8.2g %08.2g %8.2E %8.2a %#8.2A %#8.2e\n", 0.0,3.0F,3.0F, f, f, f, f, f, f, 3.0F, f, f, f, f, f, f, f, f, f ); - sout | 0.0 | wd(8, 3.0F) | nodp(wd(8, 3.0F)) | f | wd(8, f) | ws(8,0, f) | nodp(ws(8,0, f)) | ws(8,2, f) | nodp(ws(8,2, f)) | left(ws(8,2, 3.0F)) | left(ws(8,2, f)) | left(nodp(ws(8,2, f))) | left(sign(ws(8,2, f))) | left(sign(nodp(ws(8,2, f)))) | pad0(ws(8,2, f)) | upcase(wd(8,2, sci(f))) | wd(8,2, hex(f)) | upcase(wd(8,2, hex(f))) | nodp(wd(8,2, sci(f))); + sout | 0.0 | wd(8, 3.0F) | nodp(wd(8, 3.0F)) | f | wd(8, f) | ws(8,0, f) | nodp(ws(8,0, f)) | ws(8,2, f) | nodp(ws(8,2, f)) | nonl; + sout | left(ws(8,2, 3.0F)) | left(ws(8,2, f)) | left(nodp(ws(8,2, f))) | left(sign(ws(8,2, f))) | left(sign(nodp(ws(8,2, f)))) | nonl; + sout | pad0(ws(8,2, f)) | upcase(wd(8,2, sci(f))) | wd(8,2, hex(f)) | upcase(wd(8,2, hex(f))) | nodp(wd(8,2, sci(f))); sout | "double"; @@ -68,5 +87,6 @@ printf( "%g %#8f %g %8f %#8.0f %8.0f %8.2f %-8.2f %-+#8.2f %08.2F %8.2E %8.2a %8.2A %8.2e\n", 0.0, 3.0, d, d, d, d, d, d, d, d, d, d, d, d ); - sout | 0.0 | wd(8, 3.0) | d | wd(8, d) | nodp(wd(8,0, d)) | wd(8,0, d) | wd(8,2, d) | left(wd(8,2, d)) | left(sign(wd(8,2, d))) | pad0(upcase(wd(8,2, d))) | upcase(wd(8,2, sci(d))) | wd(8,2, hex(d)) | upcase(wd(8,2, hex(d))) | wd(8,2, sci(d)); + sout | 0.0 | wd(8, 3.0) | d | wd(8, d) | nodp(wd(8,0, d)) | wd(8,0, d) | wd(8,2, d) | nonl; + sout | left(wd(8,2, d)) | left(sign(wd(8,2, d))) | pad0(upcase(wd(8,2, d))) | upcase(wd(8,2, sci(d))) | wd(8,2, hex(d)) | upcase(wd(8,2, hex(d))) | wd(8,2, sci(d)); sout | "long double"; @@ -74,5 +94,6 @@ printf( "%Lg %#8Lf %Lg %8Lf %#8.0Lf %8.0Lf %8.2Lf %-8.2Lf %-+#8.2Lf %08.2LF %8.2LE %8.2La %8.2LA %8.2Le\n", 0.0L, 3.0L, ld, ld, ld, ld, ld, ld, ld, ld, ld, ld, ld, ld ); - sout | 0.0L | wd(8, 3.0L) | ld | wd(8, ld) | nodp(wd(8,0, ld)) | wd(8,0, ld) | wd(8,2, ld) | left(wd(8,2, ld)) | left(sign(wd(8,2, ld))) | pad0(upcase(wd(8,2, ld))) | upcase(wd(8,2, sci(ld))) | wd(8,2, hex(ld)) | upcase(wd(8,2, hex(ld))) | wd(8,2, sci(ld)); + sout | 0.0L | wd(8, 3.0L) | ld | wd(8, ld) | nodp(wd(8,0, ld)) | wd(8,0, ld) | wd(8,2, ld) | nonl; + sout | left(wd(8,2, ld)) | left(sign(wd(8,2, ld))) | pad0(upcase(wd(8,2, ld))) | upcase(wd(8,2, sci(ld))) | wd(8,2, hex(ld)) | upcase(wd(8,2, hex(ld))) | wd(8,2, sci(ld)); @@ -80,5 +101,6 @@ char c = 'a'; printf( "%c %2c %5c %-5c %hho %#hho %hhx %#hhx %#8hhx %#8hhX %-8c %8c\n", c, c, c, c, c, c, c, c, c, c, c, c ); - sout | c | ' ' | wd(2,c) | wd(5,c) | left(wd(5,c)) | nobase(oct(c)) | oct(c) | nobase(hex(c)) | hex(c) | wd(8,hex(c)) | upcase(wd(8,hex(c))) | left(wd(8,c)) | wd(8,c); + sout | c | ' ' | wd(2,c) | wd(5,c) | left(wd(5,c)) | nobase(oct(c)) | oct(c) | nonl; + sout | nobase(hex(c)) | hex(c) | wd(8,hex(c)) | upcase(wd(8,hex(c))) | left(wd(8,c)) | wd(8,c); sout | nl | "string"; Index: tests/manipulatorsOutput3.cfa =================================================================== --- tests/manipulatorsOutput3.cfa (revision dd4e2d7a1ba13c040f8d0eb5c9b0c672b5755c3a) +++ tests/manipulatorsOutput3.cfa (revision 6c12fd28ccd5d0df5de4277788cba0edd4a3bc8c) @@ -52,6 +52,9 @@ sout | left(wd( 10,40, oct(y) )) | 'X'; - y = 123456789; + y = 01234567; sout | left(wd( 45, 49, oct(y) )) | 'X'; + y = -y; + sout | wd(0, oct(y)) | 'Y'; + sout | left(wd(0, oct(y))) | 'Y'; sout | nl; @@ -66,11 +69,33 @@ sout | left(wd( 45,49, upcase(hex(x)) )) | 'X'; - sout | nl | nl; + sout | nl; int128 divisor = 0x4b3b4ca85a86c47a; divisor <<= 16; divisor += 0x98a224000000000; + + // base 2 + sout | "base 2"; + sout | bin(divisor); + sout | upcase(bin(divisor)); + sout | wd(38, upcase(bin(divisor))); + sout | wd(40, upcase(bin(divisor))); + sout | wd(40, 38, upcase(bin(divisor))); + sout | wd(40, 30, upcase(bin(divisor))); + sout | pad0(sign(wd(40, 38, upcase(bin(divisor))))); + sout | nl; + + // oct + sout | "base 8"; + sout | upcase(oct(divisor)); + sout | wd(38, upcase(oct(divisor))); + sout | wd(40, upcase(oct(divisor))); + sout | wd(40, 38, upcase(oct(divisor))); + sout | wd(40, 30, upcase(oct(divisor))); + sout | pad0(sign(wd(40, 38, upcase(oct(divisor))))); + sout | nl; - // base 10 + // decimal + sout | "base 10"; sout | divisor; sout | wd(2, divisor); @@ -87,22 +112,8 @@ sout | pad0(wd(40, divisor)); sout | pad0(sign(wd(40,divisor))); - - // base 2 - sout | upcase(bin(divisor)); - sout | wd(38, upcase(bin(divisor))); - sout | wd(40, upcase(bin(divisor))); - sout | wd(40, 38, upcase(bin(divisor))); - sout | wd(40, 30, upcase(bin(divisor))); - sout | pad0(sign(wd(40, 38, upcase(bin(divisor))))); - - // oct - sout | upcase(oct(divisor)); - sout | wd(38, upcase(oct(divisor))); - sout | wd(40, upcase(oct(divisor))); - sout | wd(40, 38, upcase(oct(divisor))); - sout | wd(40, 30, upcase(oct(divisor))); - sout | pad0(sign(wd(40, 38, upcase(oct(divisor))))); + sout | nl; // hex + sout | "base 16"; sout | upcase(hex(divisor)); sout | wd(38, upcase(hex(divisor))); @@ -111,4 +122,5 @@ sout | wd(40, 30, upcase(hex(divisor))); sout | pad0(sign(wd(40, 38, upcase(hex(divisor))))); + sout | nl;