Changes in / [341aa39:c41c2dbe]

Files:

• doc/user/user.tex (modified) (33 diffs)
• libcfa/src/fstream.cfa (modified) (16 diffs)
• libcfa/src/fstream.hfa (modified) (3 diffs)
• libcfa/src/gmp.hfa (modified) (2 diffs)
• libcfa/src/heap.cfa (modified) (7 diffs)
• libcfa/src/iostream.cfa (modified) (35 diffs)
• libcfa/src/iostream.hfa (modified) (2 diffs)
• libcfa/src/stdlib.hfa (modified) (7 diffs)
• libcfa/src/time.hfa (modified) (5 diffs)

doc/user/user.tex

@@ -11 +11 @@
 %% Created On       : Wed Apr  6 14:53:29 2016
 %% Last Modified By : Peter A. Buhr
-%% Last Modified On : Sat Mar 27 09:55:55 2021
-%% Update Count     : 4796
+%% Last Modified On : Tue Apr 20 23:25:56 2021
+%% Update Count     : 4888
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
@@ -66 +66 @@
 % math escape $...$ (dollar symbol)
 \input{common}                                          % common CFA document macros
+\setlength{\gcolumnposn}{3in}
 \CFAStyle                                                                                               % use default CFA format-style
 \lstset{language=CFA}                                                                   % CFA default lnaguage
@@ -2166 +2167 @@
 \section{Enumeration}
 
-An \newterm{enumeration} is a compile-time mechanism to give names to constants.
-There is no runtime manifestation of an enumeration.
-Their purpose is code-readability and maintenance -- changing an enum's value automatically updates all name usages during compilation.
-
-An enumeration defines a type containing a set of names, each called an \newterm{enumeration constant} (shortened to \newterm{enum}) with a fixed (©const©) value.
-\begin{cfa}
-enum Days { Mon, Tue, Wed, Thu, Fri, Sat, Sun }; // enumeration type definition, set of 7 names
+An \newterm{enumeration} is a compile-time mechanism to alias names to constants, like ©typedef© is a mechanism to alias names to types.
+Its purpose is to define a restricted-value type providing code-readability and maintenance -- changing an enum's value automatically updates all name usages during compilation.
+
+An enumeration type is a set of names, each called an \newterm{enumeration constant} (shortened to \newterm{enum}) aliased to a fixed value (constant).
+\begin{cfa}
+enum Days { Mon, Tue, Wed, Thu, Fri, Sat, Sun }; // enumeration type definition, set of 7 names & values
 Days days = Mon; // enumeration type declaration and initialization
 \end{cfa}
-The set of enums are injected into the scope of the definition and use the variable namespace.
+The set of enums are injected into the variable namespace at the definition scope.
 Hence, enums may be overloaded with enum/variable/function names.
 \begin{cfa}
@@ -2183 +2183 @@
 double Bar;                     $\C{// overload Foo.Bar, Goo.Bar}\CRT$
 \end{cfa}
-An anonymous enumeration is used to inject enums with specific values into a scope:
+An anonymous enumeration injects enums with specific values into a scope.
 \begin{cfa}
 enum { Prime = 103, BufferSize = 1024 };
 \end{cfa}
-An enumeration is better than using the C \Index{preprocessor}
+An enumeration is better than using C \Index{preprocessor} or constant declarations.
+\begin{cquote}
+\begin{tabular}{@{}l@{\hspace{4em}}l@{}}
 \begin{cfa}
 #define Mon 0
@@ -2193 +2195 @@
 #define Sun 6
 \end{cfa}
-or C constant declarations
-\begin{cfa}
-const int Mon = 0, ..., Sun = 6;
-\end{cfa}
+&
+\begin{cfa}
+const int Mon = 0,
+                         ...,
+                         Sun = 6;
+\end{cfa}
+\end{tabular}
+\end{cquote}
 because the enumeration is succinct, has automatic numbering, can appear in ©case© labels, does not use storage, and is part of the language type-system.
 Finally, the type of an enum is implicitly or explicitly specified and the constant value can be implicitly or explicitly specified.
@@ -2204 +2210 @@
 \subsection{Enum type}
 
-While an enumeration defines a new set-type of names, its underlying enums can be any ©const© type, and an enum's value comes from this type.
-\CFA provides an automatic conversion from an enum to its base type, \eg comparing/printing an enum compares/prints its value rather than the enum name.
+The type of enums can be any type, and an enum's value comes from this type.
+Because an enum is a constant, it cannot appear in a mutable context, \eg ©Mon = Sun© is disallowed, and has no address (it is an rvalue).
+Therefore, an enum is automatically converted to its constant's base-type, \eg comparing/printing an enum compares/prints its value rather than the enum name;
+there is no mechanism to print the enum name.
+
 The default enum type is ©int©.
 Hence, ©Days© is the set type ©Mon©, ©Tue©, ...\,, ©Sun©, while the type of each enum is ©int© and each enum represents a fixed integral value.
 If no values are specified for an integral enum type, the enums are automatically numbered by one from left to right starting at zero.
 Hence, the value of enum ©Mon© is 0, ©Tue© is 1, ...\,, ©Sun© is 6.
-If a value is specified, numbering continues by one from that value.
-It an enum value is an expression, the compiler performs constant-folding to obtain a constant value.
-
-Other integral types with associated values can be explicitly specified.
+If an enum value is specified, numbering continues by one from that value for subsequent unnumbered enums.
+If an enum value is an expression, the compiler performs constant-folding to obtain a constant value.
+
+\CFA allows other integral types with associated values.
 \begin{cfa}
 enum( @char@ ) Letter { A @= 'A'@,  B,  C,  I @= 'I'@,  J,  K };
@@ -2219 +2228 @@
 \end{cfa}
 For enumeration ©Letter©, enum ©A©'s value is explicitly set to ©'A'©, with ©B© and ©C© implicitly numbered with increasing values from ©'A'©, and similarly for enums ©I©, ©J©, and ©K©.
-Note, an enum is an immutable constant, \ie ©A = B© is disallowed;
-by transitivity, an enum's type is implicitly ©const©.
-Hence, a constant/enum cannot appear in a mutuable context nor is a constant/enum addressable (rvalue).
-
-Non-integral enum types have the restriction that all enums \emph{must} be explicitly specified, \ie incrementing by one for the next enum is not done even if supported by the enum type, \eg ©double©.
+
+Non-integral enum types must be explicitly initialized, \eg ©double© is not automatically numbered by one.
 \begin{cfa}
 // non-integral numeric
-enum( double ) Math { PI_2 = 1.570796, PI = 3.141597,  E = 2.718282 }
+enum( @double@ ) Math { PI_2 = 1.570796, PI = 3.141597,  E = 2.718282 }
 // pointer
-enum( char * ) Name { Fred = "Fred",  Mary = "Mary",  Jane = "Jane" };
+enum( @char *@ ) Name { Fred = "Fred",  Mary = "Mary",  Jane = "Jane" };
 int i, j, k;
-enum( int * ) ptr { I = &i,  J = &j,  K = &k };
-enum( int & ) ref { I = i,  J = j,  K = k };
+enum( @int *@ ) ptr { I = &i,  J = &j,  K = &k };
+enum( @int &@ ) ref { I = i,  J = j,  K = k };
 // tuple
-enum( [int, int] ) { T = [ 1, 2 ] };
+enum( @[int, int]@ ) { T = [ 1, 2 ] };
 // function
 void f() {...}   void g() {...}
-enum( void (*)() ) funs { F = f,  F = g };
+enum( @void (*)()@ ) funs { F = f,  F = g };
 // aggregate
 struct S { int i, j; };
-enum( S ) s { A = { 3,  4 }, B = { 7,  8 } };
+enum( @S@ ) s { A = { 3,  4 }, B = { 7,  8 } };
 // enumeration
-enum( Letter ) Greek { Alph = A, Beta = B, /* more enums */  }; // alphabet intersection
+enum( @Letter@ ) Greek { Alph = A, Beta = B, /* more enums */  }; // alphabet intersection
 \end{cfa}
 Enumeration ©Greek© may have more or less enums than ©Letter©, but the enum values \emph{must} be from ©Letter©.
@@ -2253 +2259 @@
 m = Alph;               $\C{// {\color{red}disallowed}}$
 m = 3.141597;   $\C{// {\color{red}disallowed}}$
-d = E;                  $\C{// allowed, conversion to base type}$
-d = m;                  $\C{// {\color{red}disallowed}}$
+d = m;                  $\C{// allowed}$
 d = Alph;               $\C{// {\color{red}disallowed}}$
 Letter l = A;   $\C{// allowed}$
@@ -2263 +2268 @@
 
 A constructor \emph{cannot} be used to initialize enums because a constructor executes at runtime.
-A fallback is to substitute C-style initialization overriding the constructor with ©@=©.
-\begin{cfa}
-enum( struct vec3 ) Axis { Up $@$= { 1, 0, 0 }, Left $@$= ..., Front $@$= ... }
+A fallback is explicit C-style initialization using ©@=©.
+\begin{cfa}
+enum( struct vec3 ) Axis { Up $@$= { 1, 0, 0 }, Left $@$= { 0, 1, 0 }, Front $@$= { 0, 0, 1 } }
 \end{cfa}
 Finally, enumeration variables are assignable and comparable only if the appropriate operators are defined for its enum type.
@@ -2274 +2279 @@
 \Index{Plan-9}\index{inheritance!enumeration} inheritance may be used with enumerations.
 \begin{cfa}
-enum( const char * ) Name2 { @inline Name@, Jack = "Jack", Jill = "Jill" };
-enum @/* inferred */@  Name3 { @inline Name@, @inline Name2@, Sue = "Sue", Tom = "Tom" };
+enum( char * ) Name2 { @inline Name@, Jack = "Jack", Jill = "Jill" };
+enum @/* inferred */@  Name3 { @inline Name2@, Sue = "Sue", Tom = "Tom" };
 \end{cfa}
 Enumeration ©Name2© inherits all the enums and their values from enumeration ©Name© by containment, and a ©Name© enumeration is a subtype of enumeration ©Name2©.
@@ -2281 +2286 @@
 The enum type for the inheriting type must be the same as the inherited type;
 hence the enum type may be omitted for the inheriting enumeration and it is inferred from the inherited enumeration, as for ©Name3©.
-When inheriting from integral types, automatic numbering may be used, so the inheritance placement left to right is important.
+When inheriting from integral types, automatic numbering may be used, so the inheritance placement left to right is important, \eg the placement of ©Sue© and ©Tom© before or after ©inline Name2©.
 
 Specifically, the inheritance relationship for ©Name©s is:
@@ -2301 +2306 @@
 j( Fred );    j( Jill );    j( Sue );    j( 'W' );
 \end{cfa}
-Note, the validity of calls is the same for call by reference as for call by value, and ©const© restrictions are the same as for other types.
+Note, the validity of calls is the same for call-by-reference as for call-by-value, and ©const© restrictions are the same as for other types.
 
 Enums cannot be created at runtime, so inheritence problems, such as contra-variance do not apply.
@@ -2313 +2318 @@
 \begin{cfa}
 // Fred is a subset of char *
-enum char * Fred { A = "A", B = "B", C = "C" };
+enum( char *) Fred { A = "A", B = "B", C = "C" };
 // Jack is a subset of Fred
-enum enum Fred Jack { W = A, Y = C};
+enum( enum Fred ) Jack { W = A, Y = C};
 // Mary is a superset of Fred
 enum Mary { inline Fred, D = "hello" };
@@ -4168 +4173 @@
 
 The format of numeric input values in the same as C constants without a trailing type suffix, as the input value-type is denoted by the input variable.
-For ©_Bool© type, the constants are ©true© and ©false©.
+For ©bool© type, the constants are ©true© and ©false©.
 For integral types, any number of digits, optionally preceded by a sign (©+© or ©-©), where a
 \begin{itemize}
@@ -4580 +4585 @@
 In C, the integer constants 0 and 1 suffice because the integer promotion rules can convert them to any arithmetic type, and the rules for pointer expressions treat constant expressions evaluating to 0 as a special case.
 However, user-defined arithmetic types often need the equivalent of a 1 or 0 for their functions or operators, polymorphic functions often need 0 and 1 constants of a type matching their polymorphic parameters, and user-defined pointer-like types may need a null value.
-Defining special constants for a user-defined type is more efficient than defining a conversion to the type from ©_Bool©.
+Defining special constants for a user-defined type is more efficient than defining a conversion to the type from ©bool©.
 
 Why just 0 and 1? Why not other integers? No other integers have special status in C.
@@ -5045 +5050 @@
 \begin{figure}
 \begin{cfa}
-#include <fstream>
-#include <coroutine>
-
-coroutine Fibonacci {
+#include <fstream.hfa>
+#include @<coroutine.hfa>@
+
+@coroutine@ Fibonacci {
         int fn; $\C{// used for communication}$
 };
-void ?{}( Fibonacci * this ) {
-        this->fn = 0;
-}
-void main( Fibonacci * this ) {
+
+void main( Fibonacci & fib ) with( fib ) { $\C{// called on first resume}$
         int fn1, fn2; $\C{// retained between resumes}$
-        this->fn = 0; $\C{// case 0}$
-        fn1 = this->fn;
-        suspend(); $\C{// return to last resume}$
-
-        this->fn = 1; $\C{// case 1}$
-        fn2 = fn1;
-        fn1 = this->fn;
-        suspend(); $\C{// return to last resume}$
-
-        for ( ;; ) { $\C{// general case}$
-                this->fn = fn1 + fn2;
-                fn2 = fn1;
-                fn1 = this->fn;
-                suspend(); $\C{// return to last resume}$
-        } // for
-}
-int next( Fibonacci * this ) {
-        resume( this ); $\C{// transfer to last suspend}$
-        return this->fn;
+        fn = 0;  fn1 = fn; $\C{// 1st case}$
+        @suspend;@ $\C{// restart last resume}$
+        fn = 1;  fn2 = fn1;  fn1 = fn; $\C{// 2nd case}$
+        @suspend;@ $\C{// restart last resume}$
+        for () {
+                fn = fn1 + fn2;  fn2 = fn1;  fn1 = fn; $\C{// general case}$
+                @suspend;@ $\C{// restart last resume}$
+        }
+}
+int next( Fibonacci & fib ) with( fib ) {
+        @resume( fib );@ $\C{// restart last suspend}$
+        return fn;
 }
 int main() {
         Fibonacci f1, f2;
-        for ( int i = 1; i <= 10; i += 1 ) {
-                sout | next( &f1 ) | ' ' | next( &f2 );
-        } // for
-}
-\end{cfa}
+        for ( 10 ) { $\C{// print N Fibonacci values}$
+                sout | next( f1 ) | next( f2 );
+        }
+}
+\end{cfa}
+\vspace*{-5pt}
 \caption{Fibonacci Coroutine}
 \label{f:FibonacciCoroutine}
@@ -5108 +5105 @@
 \begin{figure}
 \begin{cfa}
-#include <fstream>
-#include <kernel>
-#include <monitor>
-#include <thread>
-
-monitor global_t {
-        int value;
-};
-
-void ?{}(global_t * this) {
-        this->value = 0;
-}
-
-static global_t global;
-
-void increment3( global_t * mutex this ) {
-        this->value += 1;
-}
-void increment2( global_t * mutex this ) {
-        increment3( this );
-}
-void increment( global_t * mutex this ) {
-        increment2( this );
-}
+#include <fstream.hfa>
+#include @<thread.hfa>@
+
+@monitor@ AtomicCnt { int counter; };
+void ?{}( AtomicCnt & c, int init = 0 ) with(c) { counter = init; }
+int inc( AtomicCnt & @mutex@ c, int inc = 1 ) with(c) { return counter += inc; }
+int dec( AtomicCnt & @mutex@ c, int dec = 1 ) with(c) { return counter -= dec; }
+forall( ostype & | ostream( ostype ) ) { $\C{// print any stream}$
+        ostype & ?|?( ostype & os, AtomicCnt c ) { return os | c.counter; }
+        void ?|?( ostype & os, AtomicCnt c ) { (ostype &)(os | c.counter); ends( os ); }
+}
+
+AtomicCnt global; $\C{// shared}$
 
 thread MyThread {};
-
-void main( MyThread* this ) {
-        for(int i = 0; i < 1_000_000; i++) {
-                increment( &global );
+void main( MyThread & ) {
+        for ( i; 100_000 ) {
+                inc( global );
+                dec( global );
         }
 }
-int main(int argc, char* argv[]) {
-        processor p;
+int main() {
+        enum { Threads = 4 };
+        processor p[Threads - 1]; $\C{// + starting processor}$
         {
-                MyThread f[4];
+                MyThread t[Threads];
         }
-        sout | global.value;
+        sout | global; $\C{// print 0}$
 }
 \end{cfa}
 \caption{Atomic-Counter Monitor}
-\caption{f:AtomicCounterMonitor}
+\label{f:AtomicCounterMonitor}
 \end{figure}
 
@@ -7320 +7307 @@
 [ int, long double ] remquo( long double, long double );
 
-float div( float, float, int * );$\indexc{div}$ $\C{// alternative name for remquo}$
-double div( double, double, int * );
-long double div( long double, long double, int * );
 [ int, float ] div( float, float );
 [ int, double ] div( double, double );
@@ -7383 +7367 @@
 long double _Complex log( long double _Complex );
 
-float log2( float );$\indexc{log2}$
+int log2( unsigned int );$\indexc{log2}$
+long int log2( unsigned long int );
+long long int log2( unsigned long long int )
+float log2( float );
 double log2( double );
 long double log2( long double );
@@ -7565 +7552 @@
 \leavevmode
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
+// n / align * align
+signed char floor( signed char n, signed char align );
+unsigned char floor( unsigned char n, unsigned char align );
+short int floor( short int n, short int align );
+unsigned short int floor( unsigned short int n, unsigned short int align );
+int floor( int n, int align );
+unsigned int floor( unsigned int n, unsigned int align );
+long int floor( long int n, long int align );
+unsigned long int floor( unsigned long int n, unsigned long int align );
+long long int floor( long long int n, long long int align );
+unsigned long long int floor( unsigned long long int n, unsigned long long int align );
+
+// (n + (align - 1)) / align
+signed char ceiling_div( signed char n, char align );
+unsigned char ceiling_div( unsigned char n, unsigned char align );
+short int ceiling_div( short int n, short int align );
+unsigned short int ceiling_div( unsigned short int n, unsigned short int align );
+int ceiling_div( int n, int align );
+unsigned int ceiling_div( unsigned int n, unsigned int align );
+long int ceiling_div( long int n, long int align );
+unsigned long int ceiling_div( unsigned long int n, unsigned long int align );
+long long int ceiling_div( long long int n, long long int align );
+unsigned long long int ceiling_div( unsigned long long int n, unsigned long long int align );
+
+// floor( n + (n % align != 0 ? align - 1 : 0), align )
+signed char ceiling( signed char n, signed char align );
+unsigned char ceiling( unsigned char n, unsigned char align );
+short int ceiling( short int n, short int align );
+unsigned short int ceiling( unsigned short int n, unsigned short int align );
+int ceiling( int n, int align );
+unsigned int ceiling( unsigned int n, unsigned int align );
+long int ceiling( long int n, long int align );
+unsigned long int ceiling( unsigned long int n, unsigned long int align );
+long long int ceiling( long long int n, long long int align );
+unsigned long long int ceiling( unsigned long long int n, unsigned long long int align );
+
 float floor( float );$\indexc{floor}$
 double floor( double );
@@ -7667 +7690 @@
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
 struct Duration {
-        int64_t tv; $\C{// nanoseconds}$
+        int64_t tn; $\C{// nanoseconds}$
 };
 
 void ?{}( Duration & dur );
 void ?{}( Duration & dur, zero_t );
+void ?{}( Duration & dur, timeval t )
+void ?{}( Duration & dur, timespec t )
 
 Duration ?=?( Duration & dur, zero_t );
+Duration ?=?( Duration & dur, timeval t )
+Duration ?=?( Duration & dur, timespec t )
 
 Duration +?( Duration rhs );
@@ -7695 +7722 @@
 Duration ?%=?( Duration & lhs, Duration rhs );
 
-_Bool ?==?( Duration lhs, Duration rhs );
-_Bool ?!=?( Duration lhs, Duration rhs );
-_Bool ?<? ( Duration lhs, Duration rhs );
-_Bool ?<=?( Duration lhs, Duration rhs );
-_Bool ?>? ( Duration lhs, Duration rhs );
-_Bool ?>=?( Duration lhs, Duration rhs );
-
-_Bool ?==?( Duration lhs, zero_t );
-_Bool ?!=?( Duration lhs, zero_t );
-_Bool ?<? ( Duration lhs, zero_t );
-_Bool ?<=?( Duration lhs, zero_t );
-_Bool ?>? ( Duration lhs, zero_t );
-_Bool ?>=?( Duration lhs, zero_t );
+bool ?==?( Duration lhs, zero_t );
+bool ?!=?( Duration lhs, zero_t );
+bool ?<? ( Duration lhs, zero_t );
+bool ?<=?( Duration lhs, zero_t );
+bool ?>? ( Duration lhs, zero_t );
+bool ?>=?( Duration lhs, zero_t );
+
+bool ?==?( Duration lhs, Duration rhs );
+bool ?!=?( Duration lhs, Duration rhs );
+bool ?<? ( Duration lhs, Duration rhs );
+bool ?<=?( Duration lhs, Duration rhs );
+bool ?>? ( Duration lhs, Duration rhs );
+bool ?>=?( Duration lhs, Duration rhs );
 
 Duration abs( Duration rhs );
@@ -7734 +7761 @@
 int64_t ?`w( Duration dur );
 
+double ?`dns( Duration dur );
+double ?`dus( Duration dur );
+double ?`dms( Duration dur );
+double ?`ds( Duration dur );
+double ?`dm( Duration dur );
+double ?`dh( Duration dur );
+double ?`dd( Duration dur );
+double ?`dw( Duration dur );
+
 Duration max( Duration lhs, Duration rhs );
 Duration min( Duration lhs, Duration rhs );
+
+forall( ostype & | ostream( ostype ) ) ostype & ?|?( ostype & os, Duration dur );
 \end{cfa}
 
@@ -7746 +7784 @@
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
 void ?{}( timeval & t );
+void ?{}( timeval & t, zero_t );
 void ?{}( timeval & t, time_t sec, suseconds_t usec );
 void ?{}( timeval & t, time_t sec );
-void ?{}( timeval & t, zero_t );
 void ?{}( timeval & t, Time time );
 
@@ -7754 +7792 @@
 timeval ?+?( timeval & lhs, timeval rhs );
 timeval ?-?( timeval & lhs, timeval rhs );
-_Bool ?==?( timeval lhs, timeval rhs );
-_Bool ?!=?( timeval lhs, timeval rhs );
+bool ?==?( timeval lhs, timeval rhs );
+bool ?!=?( timeval lhs, timeval rhs );
 \end{cfa}
 
@@ -7766 +7804 @@
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
 void ?{}( timespec & t );
+void ?{}( timespec & t, zero_t );
 void ?{}( timespec & t, time_t sec, __syscall_slong_t nsec );
 void ?{}( timespec & t, time_t sec );
-void ?{}( timespec & t, zero_t );
 void ?{}( timespec & t, Time time );
 
@@ -7774 +7812 @@
 timespec ?+?( timespec & lhs, timespec rhs );
 timespec ?-?( timespec & lhs, timespec rhs );
-_Bool ?==?( timespec lhs, timespec rhs );
-_Bool ?!=?( timespec lhs, timespec rhs );
+bool ?==?( timespec lhs, timespec rhs );
+bool ?!=?( timespec lhs, timespec rhs );
 \end{cfa}
 
@@ -7797 +7835 @@
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
 struct Time {
-        uint64_t tv; $\C{// nanoseconds since UNIX epoch}$
+        uint64_t tn; $\C{// nanoseconds since UNIX epoch}$
 };
 
 void ?{}( Time & time );
 void ?{}( Time & time, zero_t );
+void ?{}( Time & time, timeval t );
+void ?{}( Time & time, timespec t );
 
 Time ?=?( Time & time, zero_t );
-
-void ?{}( Time & time, timeval t );
 Time ?=?( Time & time, timeval t );
-
-void ?{}( Time & time, timespec t );
 Time ?=?( Time & time, timespec t );
 
@@ -7818 +7854 @@
 Time ?-?( Time lhs, Duration rhs );
 Time ?-=?( Time & lhs, Duration rhs );
-_Bool ?==?( Time lhs, Time rhs );
-_Bool ?!=?( Time lhs, Time rhs );
-_Bool ?<?( Time lhs, Time rhs );
-_Bool ?<=?( Time lhs, Time rhs );
-_Bool ?>?( Time lhs, Time rhs );
-_Bool ?>=?( Time lhs, Time rhs );
+bool ?==?( Time lhs, Time rhs );
+bool ?!=?( Time lhs, Time rhs );
+bool ?<?( Time lhs, Time rhs );
+bool ?<=?( Time lhs, Time rhs );
+bool ?>?( Time lhs, Time rhs );
+bool ?>=?( Time lhs, Time rhs );
+
+int64_t ?`ns( Time t );
 
 char * yy_mm_dd( Time time, char * buf );
-char * ?`ymd( Time time, char * buf ) { // short form
-        return yy_mm_dd( time, buf );
-} // ymd
+char * ?`ymd( Time time, char * buf ); // short form
 
 char * mm_dd_yy( Time time, char * buf );
-char * ?`mdy( Time time, char * buf ) { // short form
-        return mm_dd_yy( time, buf );
-} // mdy
+char * ?`mdy( Time time, char * buf ); // short form
 
 char * dd_mm_yy( Time time, char * buf );
-char * ?`dmy( Time time, char * buf ) { // short form
-        return dd_mm_yy( time, buf );;
-} // dmy
+char * ?`dmy( Time time, char * buf ); // short form
 
 size_t strftime( char * buf, size_t size, const char * fmt, Time time );
-forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype & os, Time time );
+
+forall( ostype & | ostream( ostype ) ) ostype & ?|?( ostype & os, Time time );
 \end{cfa}
 
@@ -7867 +7900 @@
 \leavevmode
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
-struct Clock {
-        Duration offset; $\C{// for virtual clock: contains offset from real-time}$
-        int clocktype; $\C{// implementation only -1 (virtual), CLOCK\_REALTIME}$
+struct Clock { $\C{// virtual clock}$
+        Duration offset; $\C{// offset from computer real-time}$
 };
 
-void resetClock( Clock & clk );
-void resetClock( Clock & clk, Duration adj );
-void ?{}( Clock & clk );
-void ?{}( Clock & clk, Duration adj );
-
-Duration getResNsec(); $\C{// with nanoseconds}$
-Duration getRes(); $\C{// without nanoseconds}$
-
-Time getTimeNsec(); $\C{// with nanoseconds}$
-Time getTime(); $\C{// without nanoseconds}$
-Time getTime( Clock & clk );
-Time ?()( Clock & clk );
-timeval getTime( Clock & clk );
-tm getTime( Clock & clk );
+void ?{}( Clock & clk ); $\C{// create no offset}$
+void ?{}( Clock & clk, Duration adj ); $\C{// create with offset}$
+void reset( Clock & clk, Duration adj ); $\C{// change offset}$
+
+Duration resolutionHi(); $\C{// clock resolution in nanoseconds (fine)}$
+Duration resolution(); $\C{// clock resolution without nanoseconds (coarse)}$
+
+Time timeHiRes(); $\C{// real time with nanoseconds}$
+Time time(); $\C{// real time without nanoseconds}$
+Time time( Clock & clk ); $\C{// real time for given clock}$
+Time ?()( Clock & clk ); $\C{//\ \ \ \ alternative syntax}$
+timeval time( Clock & clk ); $\C{// convert to C time format}$
+tm time( Clock & clk );
+Duration processor(); $\C{// non-monotonic duration of kernel thread}$
+Duration program(); $\C{// non-monotonic duration of program CPU}$
+Duration boot(); $\C{// monotonic duration since computer boot}$
 \end{cfa}
 
@@ -8056 +8090 @@
 forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype * os, Int mp );
 \end{cfa}
-
-The following factorial programs contrast using GMP with the \CFA and C interfaces, where the output from these programs appears in \VRef[Figure]{f:MultiPrecisionFactorials}.
+\VRef[Figure]{f:MultiPrecisionFactorials} shows \CFA and C factorial programs using the GMP interfaces.
 (Compile with flag \Indexc{-lgmp} to link with the GMP library.)
+
+\begin{figure}
 \begin{cquote}
 \begin{tabular}{@{}l@{\hspace{\parindentlnth}}|@{\hspace{\parindentlnth}}l@{}}
-\multicolumn{1}{c|@{\hspace{\parindentlnth}}}{\textbf{\CFA}}    & \multicolumn{1}{@{\hspace{\parindentlnth}}c}{\textbf{C}}      \\
+\multicolumn{1}{@{}c|@{\hspace{\parindentlnth}}}{\textbf{\CFA}} & \multicolumn{1}{@{\hspace{\parindentlnth}}c}{\textbf{C}@{}}   \\
 \hline
 \begin{cfa}
@@ -8070 +8105 @@
 
         sout | 0 | fact;
-        for ( unsigned int i = 1; i <= 40; i += 1 ) {
+        for ( i; 40 ) {
                 fact *= i;
                 sout | i | fact;
@@ -8092 +8127 @@
 \end{tabular}
 \end{cquote}
-
-\begin{figure}
+\small
 \begin{cfa}
 Factorial Numbers

libcfa/src/fstream.cfa

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Mar  1 21:12:15 2021
-// Update Count     : 424
+// Last Modified On : Tue Apr 20 19:04:46 2021
+// Update Count     : 425
 //
 
@@ -31 +31 @@
 
 void ?{}( ofstream & os, void * file ) {
-        os.$file = file;
-        os.$sepDefault = true;
-        os.$sepOnOff = false;
-        os.$nlOnOff = true;
-        os.$prt = false;
-        os.$sawNL = false;
-        os.$acquired = false;
-        $sepSetCur( os, sepGet( os ) );
+        os.file$ = file;
+        os.sepDefault$ = true;
+        os.sepOnOff$ = false;
+        os.nlOnOff$ = true;
+        os.prt$ = false;
+        os.sawNL$ = false;
+        os.acquired$ = false;
+        sepSetCur$( os, sepGet( os ) );
         sepSet( os, " " );
         sepSetTuple( os, ", " );
@@ -44 +44 @@
 
 // private
-bool $sepPrt( ofstream & os ) { $setNL( os, false ); return os.$sepOnOff; }
-void $sepReset( ofstream & os ) { os.$sepOnOff = os.$sepDefault; }
-void $sepReset( ofstream & os, bool reset ) { os.$sepDefault = reset; os.$sepOnOff = os.$sepDefault; }
-const char * $sepGetCur( ofstream & os ) { return os.$sepCur; }
-void $sepSetCur( ofstream & os, const char sepCur[] ) { os.$sepCur = sepCur; }
-bool $getNL( ofstream & os ) { return os.$sawNL; }
-void $setNL( ofstream & os, bool state ) { os.$sawNL = state; }
-bool $getANL( ofstream & os ) { return os.$nlOnOff; }
-bool $getPrt( ofstream & os ) { return os.$prt; }
-void $setPrt( ofstream & os, bool state ) { os.$prt = state; }
+bool sepPrt$( ofstream & os ) { setNL$( os, false ); return os.sepOnOff$; }
+void sepReset$( ofstream & os ) { os.sepOnOff$ = os.sepDefault$; }
+void sepReset$( ofstream & os, bool reset ) { os.sepDefault$ = reset; os.sepOnOff$ = os.sepDefault$; }
+const char * sepGetCur$( ofstream & os ) { return os.sepCur$; }
+void sepSetCur$( ofstream & os, const char sepCur[] ) { os.sepCur$ = sepCur; }
+bool getNL$( ofstream & os ) { return os.sawNL$; }
+void setNL$( ofstream & os, bool state ) { os.sawNL$ = state; }
+bool getANL$( ofstream & os ) { return os.nlOnOff$; }
+bool getPrt$( ofstream & os ) { return os.prt$; }
+void setPrt$( ofstream & os, bool state ) { os.prt$ = state; }
 
 // public
-void ?{}( ofstream & os ) { os.$file = 0p; }
+void ?{}( ofstream & os ) { os.file$ = 0p; }
 
 void ?{}( ofstream & os, const char name[], const char mode[] ) {
@@ -70 +70 @@
 } // ^?{}
 
-void sepOn( ofstream & os ) { os.$sepOnOff = ! $getNL( os ); }
-void sepOff( ofstream & os ) { os.$sepOnOff = false; }
+void sepOn( ofstream & os ) { os.sepOnOff$ = ! getNL$( os ); }
+void sepOff( ofstream & os ) { os.sepOnOff$ = false; }
 
 bool sepDisable( ofstream & os ) {
-        bool temp = os.$sepDefault;
-        os.$sepDefault = false;
-        $sepReset( os );
+        bool temp = os.sepDefault$;
+        os.sepDefault$ = false;
+        sepReset$( os );
         return temp;
 } // sepDisable
 
 bool sepEnable( ofstream & os ) {
-        bool temp = os.$sepDefault;
-        os.$sepDefault = true;
-        if ( os.$sepOnOff ) $sepReset( os );                            // start of line ?
+        bool temp = os.sepDefault$;
+        os.sepDefault$ = true;
+        if ( os.sepOnOff$ ) sepReset$( os );                            // start of line ?
         return temp;
 } // sepEnable
 
-void nlOn( ofstream & os ) { os.$nlOnOff = true; }
-void nlOff( ofstream & os ) { os.$nlOnOff = false; }
-
-const char * sepGet( ofstream & os ) { return os.$separator; }
+void nlOn( ofstream & os ) { os.nlOnOff$ = true; }
+void nlOff( ofstream & os ) { os.nlOnOff$ = false; }
+
+const char * sepGet( ofstream & os ) { return os.separator$; }
 void sepSet( ofstream & os, const char s[] ) {
         assert( s );
-        strncpy( os.$separator, s, sepSize - 1 );
-        os.$separator[sepSize - 1] = '\0';
+        strncpy( os.separator$, s, sepSize - 1 );
+        os.separator$[sepSize - 1] = '\0';
 } // sepSet
 
-const char * sepGetTuple( ofstream & os ) { return os.$tupleSeparator; }
+const char * sepGetTuple( ofstream & os ) { return os.tupleSeparator$; }
 void sepSetTuple( ofstream & os, const char s[] ) {
         assert( s );
-        strncpy( os.$tupleSeparator, s, sepSize - 1 );
-        os.$tupleSeparator[sepSize - 1] = '\0';
+        strncpy( os.tupleSeparator$, s, sepSize - 1 );
+        os.tupleSeparator$[sepSize - 1] = '\0';
 } // sepSet
 
 void ends( ofstream & os ) {
-        if ( $getANL( os ) ) nl( os );
-        else $setPrt( os, false );                                                      // turn off
+        if ( getANL$( os ) ) nl( os );
+        else setPrt$( os, false );                                                      // turn off
         if ( &os == &exit ) exit( EXIT_FAILURE );
         if ( &os == &abort ) abort();
-        if ( os.$acquired ) { os.$acquired = false; release( os ); }
+        if ( os.acquired$ ) { os.acquired$ = false; release( os ); }
 } // ends
 
 int fail( ofstream & os ) {
-        return os.$file == 0 || ferror( (FILE *)(os.$file) );
+        return os.file$ == 0 || ferror( (FILE *)(os.file$) );
 } // fail
 
 int flush( ofstream & os ) {
-        return fflush( (FILE *)(os.$file) );
+        return fflush( (FILE *)(os.file$) );
 } // flush
 
@@ -136 +136 @@
 
 void close( ofstream & os ) {
-  if ( (FILE *)(os.$file) == 0p ) return;
-  if ( (FILE *)(os.$file) == (FILE *)stdout || (FILE *)(os.$file) == (FILE *)stderr ) return;
-
-        if ( fclose( (FILE *)(os.$file) ) == EOF ) {
+  if ( (FILE *)(os.file$) == 0p ) return;
+  if ( (FILE *)(os.file$) == (FILE *)stdout || (FILE *)(os.file$) == (FILE *)stderr ) return;
+
+        if ( fclose( (FILE *)(os.file$) ) == EOF ) {
                 abort | IO_MSG "close output" | nl | strerror( errno );
         } // if
-        os.$file = 0p;
+        os.file$ = 0p;
 } // close
 
@@ -150 +150 @@
         } // if
 
-        if ( fwrite( data, 1, size, (FILE *)(os.$file) ) != size ) {
+        if ( fwrite( data, 1, size, (FILE *)(os.file$) ) != size ) {
                 abort | IO_MSG "write" | nl | strerror( errno );
         } // if
@@ -159 +159 @@
         va_list args;
         va_start( args, format );
-        int len = vfprintf( (FILE *)(os.$file), format, args );
+        int len = vfprintf( (FILE *)(os.file$), format, args );
         if ( len == EOF ) {
-                if ( ferror( (FILE *)(os.$file) ) ) {
+                if ( ferror( (FILE *)(os.file$) ) ) {
                         abort | IO_MSG "invalid write";
                 } // if
@@ -167 +167 @@
         va_end( args );
 
-        $setPrt( os, true );                                                            // called in output cascade
-        $sepReset( os );                                                                        // reset separator
+        setPrt$( os, true );                                                            // called in output cascade
+        sepReset$( os );                                                                        // reset separator
         return len;
 } // fmt
 
 inline void acquire( ofstream & os ) {
-        lock( os.$lock );
-        if ( ! os.$acquired ) os.$acquired = true;
-        else unlock( os.$lock );
+        lock( os.lock$ );
+        if ( ! os.acquired$ ) os.acquired$ = true;
+        else unlock( os.lock$ );
 } // acquire
 
 inline void release( ofstream & os ) {
-        unlock( os.$lock );
+        unlock( os.lock$ );
 } // release
 
-void ?{}( osacquire & acq, ofstream & os ) { &acq.os = &os; lock( os.$lock ); }
+void ?{}( osacquire & acq, ofstream & os ) { &acq.os = &os; lock( os.lock$ ); }
 void ^?{}( osacquire & acq ) { release( acq.os ); }
 
@@ -204 +204 @@
 // private
 void ?{}( ifstream & is, void * file ) {
-        is.$file = file;
-        is.$nlOnOff = false;
-        is.$acquired = false;
+        is.file$ = file;
+        is.nlOnOff$ = false;
+        is.acquired$ = false;
 } // ?{}
 
 // public
-void ?{}( ifstream & is ) { is.$file = 0p; }
+void ?{}( ifstream & is ) { is.file$ = 0p; }
 
 void ?{}( ifstream & is, const char name[], const char mode[] ) {
@@ -224 +224 @@
 } // ^?{}
 
-void nlOn( ifstream & os ) { os.$nlOnOff = true; }
-void nlOff( ifstream & os ) { os.$nlOnOff = false; }
-bool getANL( ifstream & os ) { return os.$nlOnOff; }
+void nlOn( ifstream & os ) { os.nlOnOff$ = true; }
+void nlOff( ifstream & os ) { os.nlOnOff$ = false; }
+bool getANL( ifstream & os ) { return os.nlOnOff$; }
 
 int fail( ifstream & is ) {
-        return is.$file == 0p || ferror( (FILE *)(is.$file) );
+        return is.file$ == 0p || ferror( (FILE *)(is.file$) );
 } // fail
 
 void ends( ifstream & is ) {
-        if ( is.$acquired ) { is.$acquired = false; release( is ); }
+        if ( is.acquired$ ) { is.acquired$ = false; release( is ); }
 } // ends
 
 int eof( ifstream & is ) {
-        return feof( (FILE *)(is.$file) );
+        return feof( (FILE *)(is.file$) );
 } // eof
 
@@ -248 +248 @@
         } // if
         #endif // __CFA_DEBUG__
-        is.$file = file;
+        is.file$ = file;
 } // open
 
@@ -256 +256 @@
 
 void close( ifstream & is ) {
-  if ( (FILE *)(is.$file) == 0p ) return;
-  if ( (FILE *)(is.$file) == (FILE *)stdin ) return;
-
-        if ( fclose( (FILE *)(is.$file) ) == EOF ) {
+  if ( (FILE *)(is.file$) == 0p ) return;
+  if ( (FILE *)(is.file$) == (FILE *)stdin ) return;
+
+        if ( fclose( (FILE *)(is.file$) ) == EOF ) {
                 abort | IO_MSG "close input" | nl | strerror( errno );
         } // if
-        is.$file = 0p;
+        is.file$ = 0p;
 } // close
 
@@ -270 +270 @@
         } // if
 
-        if ( fread( data, size, 1, (FILE *)(is.$file) ) == 0 ) {
+        if ( fread( data, size, 1, (FILE *)(is.file$) ) == 0 ) {
                 abort | IO_MSG "read" | nl | strerror( errno );
         } // if
@@ -281 +281 @@
         } // if
 
-        if ( ungetc( c, (FILE *)(is.$file) ) == EOF ) {
+        if ( ungetc( c, (FILE *)(is.file$) ) == EOF ) {
                 abort | IO_MSG "ungetc" | nl | strerror( errno );
         } // if
@@ -291 +291 @@
 
         va_start( args, format );
-        int len = vfscanf( (FILE *)(is.$file), format, args );
+        int len = vfscanf( (FILE *)(is.file$), format, args );
         if ( len == EOF ) {
-                if ( ferror( (FILE *)(is.$file) ) ) {
+                if ( ferror( (FILE *)(is.file$) ) ) {
                         abort | IO_MSG "invalid read";
                 } // if
@@ -302 +302 @@
 
 inline void acquire( ifstream & is ) {
-        lock( is.$lock );
-        if ( ! is.$acquired ) is.$acquired = true;
-        else unlock( is.$lock );
+        lock( is.lock$ );
+        if ( ! is.acquired$ ) is.acquired$ = true;
+        else unlock( is.lock$ );
 } // acquire
 
 inline void release( ifstream & is ) {
-        unlock( is.$lock );
+        unlock( is.lock$ );
 } // release
 
-void ?{}( isacquire & acq, ifstream & is ) { &acq.is = &is; lock( is.$lock ); }
+void ?{}( isacquire & acq, ifstream & is ) { &acq.is = &is; lock( is.lock$ ); }
 void ^?{}( isacquire & acq ) { release( acq.is ); }
 

libcfa/src/fstream.hfa

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Mar  1 22:45:08 2021
-// Update Count     : 217
+// Last Modified On : Tue Apr 20 19:04:12 2021
+// Update Count     : 218
 //
 
@@ -26 +26 @@
 enum { sepSize = 16 };
 struct ofstream {
-        void * $file;
-        bool $sepDefault;
-        bool $sepOnOff;
-        bool $nlOnOff;
-        bool $prt;                                                                                      // print text
-        bool $sawNL;
-        const char * $sepCur;
-        char $separator[sepSize];
-        char $tupleSeparator[sepSize];
-        multiple_acquisition_lock $lock;
-        bool $acquired;
+        void * file$;
+        bool sepDefault$;
+        bool sepOnOff$;
+        bool nlOnOff$;
+        bool prt$;                                                                                      // print text
+        bool sawNL$;
+        const char * sepCur$;
+        char separator$[sepSize];
+        char tupleSeparator$[sepSize];
+        multiple_acquisition_lock lock$;
+        bool acquired$;
 }; // ofstream
 
 // private
-bool $sepPrt( ofstream & );
-void $sepReset( ofstream & );
-void $sepReset( ofstream &, bool );
-const char * $sepGetCur( ofstream & );
-void $sepSetCur( ofstream &, const char [] );
-bool $getNL( ofstream & );
-void $setNL( ofstream &, bool );
-bool $getANL( ofstream & );
-bool $getPrt( ofstream & );
-void $setPrt( ofstream &, bool );
+bool sepPrt$( ofstream & );
+void sepReset$( ofstream & );
+void sepReset$( ofstream &, bool );
+const char * sepGetCur$( ofstream & );
+void sepSetCur$( ofstream &, const char [] );
+bool getNL$( ofstream & );
+void setNL$( ofstream &, bool );
+bool getANL$( ofstream & );
+bool getPrt$( ofstream & );
+void setPrt$( ofstream &, bool );
 
 // public
@@ -94 +94 @@
 
 struct ifstream {
-        void * $file;
-        bool $nlOnOff;
-        multiple_acquisition_lock $lock;
-        bool $acquired;
+        void * file$;
+        bool nlOnOff$;
+        multiple_acquisition_lock lock$;
+        bool acquired$;
 }; // ifstream
 

libcfa/src/gmp.hfa

@@ -10 +10 @@
 // Created On       : Tue Apr 19 08:43:43 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Feb  9 09:56:54 2020
-// Update Count     : 31
+// Last Modified On : Tue Apr 20 20:59:21 2021
+// Update Count     : 32
 //
 
@@ -263 +263 @@
         forall( ostype & | ostream( ostype ) ) {
                 ostype & ?|?( ostype & os, Int mp ) {
-                        if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+                        if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
                         gmp_printf( "%Zd", mp.mpz );
                         sepOn( os );

libcfa/src/heap.cfa

@@ -10 +10 @@
 // Created On       : Tue Dec 19 21:58:35 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Mar 14 10:39:24 2021
-// Update Count     : 1032
+// Last Modified On : Tue Apr 20 21:20:48 2021
+// Update Count     : 1033
 //
 
@@ -1128 +1128 @@
 
         // Set the alignment for an the allocation and return previous alignment or 0 if no alignment.
-        size_t $malloc_alignment_set( void * addr, size_t alignment ) {
+        size_t malloc_alignment_set$( void * addr, size_t alignment ) {
           if ( unlikely( addr == 0p ) ) return libAlign();      // minimum alignment
                 size_t ret;
@@ -1139 +1139 @@
                 } // if
                 return ret;
-        } // $malloc_alignment_set
+        } // malloc_alignment_set$
 
 
@@ -1153 +1153 @@
 
         // Set allocation is zero filled and return previous zero filled.
-        bool $malloc_zero_fill_set( void * addr ) {
+        bool malloc_zero_fill_set$( void * addr ) {
           if ( unlikely( addr == 0p ) ) return false;           // null allocation is not zero fill
                 HeapManager.Storage.Header * header = headerAddr( addr );
@@ -1162 +1162 @@
                 header->kind.real.blockSize |= 2;                               // mark as zero filled
                 return ret;
-        } // $malloc_zero_fill_set
+        } // malloc_zero_fill_set$
 
 
@@ -1176 +1176 @@
 
         // Set allocation size and return previous size.
-        size_t $malloc_size_set( void * addr, size_t size ) {
+        size_t malloc_size_set$( void * addr, size_t size ) {
           if ( unlikely( addr == 0p ) ) return 0;                       // null allocation has 0 size
                 HeapManager.Storage.Header * header = headerAddr( addr );
@@ -1185 +1185 @@
                 header->kind.real.size = size;
                 return ret;
-        } // $malloc_size_set
+        } // malloc_size_set$
 
 

libcfa/src/iostream.cfa

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Apr 13 13:05:24 2021
-// Update Count     : 1324
+// Last Modified On : Tue Apr 20 19:09:41 2021
+// Update Count     : 1325
 //
 
@@ -38 +38 @@
 forall( ostype & | ostream( ostype ) ) {
         ostype & ?|?( ostype & os, bool b ) {
-                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
                 fmt( os, "%s", b ? "true" : "false" );
                 return os;
@@ -48 +48 @@
         ostype & ?|?( ostype & os, char c ) {
                 fmt( os, "%c", c );
-                if ( c == '\n' ) $setNL( os, true );
+                if ( c == '\n' ) setNL$( os, true );
                 return sepOff( os );
         } // ?|?
@@ -56 +56 @@
 
         ostype & ?|?( ostype & os, signed char sc ) {
-                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
                 fmt( os, "%hhd", sc );
                 return os;
@@ -65 +65 @@
 
         ostype & ?|?( ostype & os, unsigned char usc ) {
-                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
                 fmt( os, "%hhu", usc );
                 return os;
@@ -74 +74 @@
 
         ostype & ?|?( ostype & os, short int si ) {
-                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
                 fmt( os, "%hd", si );
                 return os;
@@ -83 +83 @@
 
         ostype & ?|?( ostype & os, unsigned short int usi ) {
-                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
                 fmt( os, "%hu", usi );
                 return os;
@@ -92 +92 @@
 
         ostype & ?|?( ostype & os, int i ) {
-                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
                 fmt( os, "%d", i );
                 return os;
@@ -101 +101 @@
 
         ostype & ?|?( ostype & os, unsigned int ui ) {
-                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
                 fmt( os, "%u", ui );
                 return os;
@@ -110 +110 @@
 
         ostype & ?|?( ostype & os, long int li ) {
-                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
                 fmt( os, "%ld", li );
                 return os;
@@ -119 +119 @@
 
         ostype & ?|?( ostype & os, unsigned long int uli ) {
-                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
                 fmt( os, "%lu", uli );
                 return os;
@@ -128 +128 @@
 
         ostype & ?|?( ostype & os, long long int lli ) {
-                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
                 fmt( os, "%lld", lli );
                 return os;
@@ -137 +137 @@
 
         ostype & ?|?( ostype & os, unsigned long long int ulli ) {
-                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
                 fmt( os, "%llu", ulli );
                 return os;
@@ -171 +171 @@
 
         ostype & ?|?( ostype & os, int128 llli ) {
-                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
                 base10_128( os, llli );
                 return os;
@@ -180 +180 @@
 
         ostype & ?|?( ostype & os, unsigned int128 ullli ) {
-                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
                 base10_128( os, ullli );
                 return os;
@@ -204 +204 @@
 
         ostype & ?|?( ostype & os, float f ) {
-                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
                 PrintWithDP( os, "%g", f );
                 return os;
@@ -213 +213 @@
 
         ostype & ?|?( ostype & os, double d ) {
-                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
                 PrintWithDP( os, "%.*lg", d, DBL_DIG );
                 return os;
@@ -222 +222 @@
 
         ostype & ?|?( ostype & os, long double ld ) {
-                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
                 PrintWithDP( os, "%.*Lg", ld, LDBL_DIG );
                 return os;
@@ -231 +231 @@
 
         ostype & ?|?( ostype & os, float _Complex fc ) {
-                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
 //              os | crealf( fc ) | nonl;
                 PrintWithDP( os, "%g", crealf( fc ) );
@@ -243 +243 @@
 
         ostype & ?|?( ostype & os, double _Complex dc ) {
-                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
 //              os | creal( dc ) | nonl;
                 PrintWithDP( os, "%.*lg", creal( dc ), DBL_DIG );
@@ -255 +255 @@
 
         ostype & ?|?( ostype & os, long double _Complex ldc ) {
-                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
 //              os | creall( ldc ) || nonl;
                 PrintWithDP( os, "%.*Lg", creall( ldc ), LDBL_DIG );
@@ -286 +286 @@
                 // first character IS NOT spacing or closing punctuation => add left separator
                 unsigned char ch = s[0];                                                // must make unsigned
-                if ( $sepPrt( os ) && mask[ ch ] != Close && mask[ ch ] != OpenClose ) {
-                        fmt( os, "%s", $sepGetCur( os ) );
+                if ( sepPrt$( os ) && mask[ ch ] != Close && mask[ ch ] != OpenClose ) {
+                        fmt( os, "%s", sepGetCur$( os ) );
                 } // if
 
                 // if string starts line, must reset to determine open state because separator is off
-                $sepReset( os );                                                                // reset separator
+                sepReset$( os );                                                                // reset separator
 
                 // last character IS spacing or opening punctuation => turn off separator for next item
                 size_t len = strlen( s );
                 ch = s[len - 1];                                                                // must make unsigned
-                if ( $sepPrt( os ) && mask[ ch ] != Open && mask[ ch ] != OpenClose ) {
+                if ( sepPrt$( os ) && mask[ ch ] != Open && mask[ ch ] != OpenClose ) {
                         sepOn( os );
                 } else {
                         sepOff( os );
                 } // if
-                if ( ch == '\n' ) $setNL( os, true );                   // check *AFTER* $sepPrt call above as it resets NL flag
+                if ( ch == '\n' ) setNL$( os, true );                   // check *AFTER* sepPrt$ call above as it resets NL flag
                 return write( os, s, len );
         } // ?|?
@@ -309 +309 @@
 
 //      ostype & ?|?( ostype & os, const char16_t * s ) {
-//              if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+//              if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
 //              fmt( os, "%ls", s );
 //              return os;
@@ -316 +316 @@
 // #if ! ( __ARM_ARCH_ISA_ARM == 1 && __ARM_32BIT_STATE == 1 ) // char32_t == wchar_t => ambiguous
 //      ostype & ?|?( ostype & os, const char32_t * s ) {
-//              if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+//              if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
 //              fmt( os, "%ls", s );
 //              return os;
@@ -323 +323 @@
 
 //      ostype & ?|?( ostype & os, const wchar_t * s ) {
-//              if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+//              if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
 //              fmt( os, "%ls", s );
 //              return os;
@@ -329 +329 @@
 
         ostype & ?|?( ostype & os, const void * p ) {
-                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
                 fmt( os, "%p", p );
                 return os;
@@ -343 +343 @@
         void ?|?( ostype & os, ostype & (* manip)( ostype & ) ) {
                 manip( os );
-                if ( $getPrt( os ) ) ends( os );                                // something printed ?
-                $setPrt( os, false );                                                   // turn off
+                if ( getPrt$( os ) ) ends( os );                                // something printed ?
+                setPrt$( os, false );                                                   // turn off
         } // ?|?
 
@@ -357 +357 @@
         ostype & nl( ostype & os ) {
                 (ostype &)(os | '\n');
-                $setPrt( os, false );                                                   // turn off
-                $setNL( os, true );
+                setPrt$( os, false );                                                   // turn off
+                setNL$( os, true );
                 flush( os );
                 return sepOff( os );                                                    // prepare for next line
@@ -364 +364 @@
 
         ostype & nonl( ostype & os ) {
-                $setPrt( os, false );                                                   // turn off
+                setPrt$( os, false );                                                   // turn off
                 return os;
         } // nonl
@@ -408 +408 @@
         ostype & ?|?( ostype & os, T arg, Params rest ) {
                 (ostype &)(os | arg);                                                   // print first argument
-                $sepSetCur( os, sepGetTuple( os ) );                    // switch to tuple separator
+                sepSetCur$( os, sepGetTuple( os ) );                    // switch to tuple separator
                 (ostype &)(os | rest);                                                  // print remaining arguments
-                $sepSetCur( os, sepGet( os ) );                                 // switch to regular separator
+                sepSetCur$( os, sepGet( os ) );                                 // switch to regular separator
                 return os;
         } // ?|?
@@ -416 +416 @@
                 // (ostype &)(?|?( os, arg, rest )); ends( os );
                 (ostype &)(os | arg);                                                   // print first argument
-                $sepSetCur( os, sepGetTuple( os ) );                    // switch to tuple separator
+                sepSetCur$( os, sepGetTuple( os ) );                    // switch to tuple separator
                 (ostype &)(os | rest);                                                  // print remaining arguments
-                $sepSetCur( os, sepGet( os ) );                                 // switch to regular separator
+                sepSetCur$( os, sepGet( os ) );                                 // switch to regular separator
                 ends( os );
         } // ?|?
@@ -447 +447 @@
 forall( ostype & | ostream( ostype ) ) { \
         ostype & ?|?( ostype & os, _Ostream_Manip(T) f ) { \
-                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) ); \
+                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) ); \
 \
                 if ( f.base == 'b' || f.base == 'B' ) {                 /* bespoke binary format */ \
@@ -691 +691 @@
                 int bufbeg = 0, i, len; \
 \
-                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) ); \
+                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) ); \
                 char fmtstr[sizeof(DFMTP) + 8];                                 /* sizeof includes '\0' */ \
                 if ( ! f.flags.pc ) memcpy( &fmtstr, DFMTNP, sizeof(DFMTNP) ); \
@@ -734 +734 @@
                 } // if
 
-                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
 
                 #define CFMTNP "% * "
@@ -772 +772 @@
                 } // if
 
-                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
 
                 #define SFMTNP "% * "

libcfa/src/iostream.hfa

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Apr 13 13:05:11 2021
-// Update Count     : 384
+// Last Modified On : Tue Apr 20 19:09:44 2021
+// Update Count     : 385
 //
 
@@ -24 +24 @@
 trait ostream( ostype & ) {
         // private
-        bool $sepPrt( ostype & );                                                       // get separator state (on/off)
-        void $sepReset( ostype & );                                                     // set separator state to default state
-        void $sepReset( ostype &, bool );                                       // set separator and default state
-        const char * $sepGetCur( ostype & );                            // get current separator string
-        void $sepSetCur( ostype &, const char [] );                     // set current separator string
-        bool $getNL( ostype & );                                                        // check newline
-        void $setNL( ostype &, bool );                                          // saw newline
-        bool $getANL( ostype & );                                                       // get auto newline (on/off)
-        bool $getPrt( ostype & );                                                       // get fmt called in output cascade
-        void $setPrt( ostype &, bool );                                         // set fmt called in output cascade
+        bool sepPrt$( ostype & );                                                       // get separator state (on/off)
+        void sepReset$( ostype & );                                                     // set separator state to default state
+        void sepReset$( ostype &, bool );                                       // set separator and default state
+        const char * sepGetCur$( ostype & );                            // get current separator string
+        void sepSetCur$( ostype &, const char [] );                     // set current separator string
+        bool getNL$( ostype & );                                                        // check newline
+        void setNL$( ostype &, bool );                                          // saw newline
+        bool getANL$( ostype & );                                                       // get auto newline (on/off)
+        bool getPrt$( ostype & );                                                       // get fmt called in output cascade
+        void setPrt$( ostype &, bool );                                         // set fmt called in output cascade
         // public
         void sepOn( ostype & );                                                         // turn separator state on

libcfa/src/stdlib.hfa

@@ -10 +10 @@
 // Created On       : Thu Jan 28 17:12:35 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Jan 21 22:02:13 2021
-// Update Count     : 574
+// Last Modified On : Tue Apr 20 21:20:03 2021
+// Update Count     : 575
 //
 
@@ -44 +44 @@
 
 // Macro because of returns
-#define $ARRAY_ALLOC( allocation, alignment, dim ) \
+#define ARRAY_ALLOC$( allocation, alignment, dim ) \
         if ( _Alignof(T) <= libAlign() ) return (T *)(void *)allocation( dim, (size_t)sizeof(T) ); /* C allocation */ \
         else return (T *)alignment( _Alignof(T), dim, sizeof(T) )
@@ -57 +57 @@
 
         T * aalloc( size_t dim ) {
-                $ARRAY_ALLOC( aalloc, amemalign, dim );
+                ARRAY_ALLOC$( aalloc, amemalign, dim );
         } // aalloc
 
         T * calloc( size_t dim ) {
-                $ARRAY_ALLOC( calloc, cmemalign, dim );
+                ARRAY_ALLOC$( calloc, cmemalign, dim );
         } // calloc
 
@@ -119 +119 @@
                 S_fill(T) ?`fill( T    a[], size_t nmemb )      { S_fill(T) ret = {'a', nmemb}; ret.fill.a = a; return ret; }
 
-        3. Replace the $alloc_internal function which is outside ttype forall-block with following function:
-                T * $alloc_internal( void * Resize, T * Realloc, size_t Align, size_t Dim, S_fill(T) Fill) {
+        3. Replace the alloc_internal$ function which is outside ttype forall-block with following function:
+                T * alloc_internal$( void * Resize, T * Realloc, size_t Align, size_t Dim, S_fill(T) Fill) {
                         T * ptr = NULL;
                         size_t size = sizeof(T);
@@ -145 +145 @@
 
                         return ptr;
-                } // $alloc_internal
+                } // alloc_internal$
 */
 
@@ -175 +175 @@
         S_realloc(T)    ?`realloc ( T * a )                             { return (S_realloc(T)){a}; }
 
-        T * $alloc_internal( void * Resize, T * Realloc, size_t Align, size_t Dim, S_fill(T) Fill ) {
+        T * alloc_internal$( void * Resize, T * Realloc, size_t Align, size_t Dim, S_fill(T) Fill ) {
                 T * ptr = NULL;
                 size_t size = sizeof(T);
@@ -206 +206 @@
 
                 return ptr;
-        } // $alloc_internal
-
-        forall( TT... | { T * $alloc_internal( void *, T *, size_t, size_t, S_fill(T), TT ); } ) {
-
-                T * $alloc_internal( void *       , T * Realloc, size_t Align, size_t Dim, S_fill(T) Fill, T_resize Resize, TT rest) {
-                return $alloc_internal( Resize, (T*)0p, Align, Dim, Fill, rest);
-                }
-
-                T * $alloc_internal( void * Resize, T *        , size_t Align, size_t Dim, S_fill(T) Fill, S_realloc(T) Realloc, TT rest) {
-                return $alloc_internal( (void*)0p, Realloc, Align, Dim, Fill, rest);
-                }
-
-                T * $alloc_internal( void * Resize, T * Realloc, size_t      , size_t Dim, S_fill(T) Fill, T_align Align, TT rest) {
-                return $alloc_internal( Resize, Realloc, Align, Dim, Fill, rest);
-                }
-
-                T * $alloc_internal( void * Resize, T * Realloc, size_t Align, size_t Dim, S_fill(T)     , S_fill(T) Fill, TT rest) {
-                return $alloc_internal( Resize, Realloc, Align, Dim, Fill, rest);
+        } // alloc_internal$
+
+        forall( TT... | { T * alloc_internal$( void *, T *, size_t, size_t, S_fill(T), TT ); } ) {
+
+                T * alloc_internal$( void *       , T * Realloc, size_t Align, size_t Dim, S_fill(T) Fill, T_resize Resize, TT rest) {
+                return alloc_internal$( Resize, (T*)0p, Align, Dim, Fill, rest);
+                }
+
+                T * alloc_internal$( void * Resize, T *        , size_t Align, size_t Dim, S_fill(T) Fill, S_realloc(T) Realloc, TT rest) {
+                return alloc_internal$( (void*)0p, Realloc, Align, Dim, Fill, rest);
+                }
+
+                T * alloc_internal$( void * Resize, T * Realloc, size_t      , size_t Dim, S_fill(T) Fill, T_align Align, TT rest) {
+                return alloc_internal$( Resize, Realloc, Align, Dim, Fill, rest);
+                }
+
+                T * alloc_internal$( void * Resize, T * Realloc, size_t Align, size_t Dim, S_fill(T)     , S_fill(T) Fill, TT rest) {
+                return alloc_internal$( Resize, Realloc, Align, Dim, Fill, rest);
                 }
 
             T * alloc( TT all ) {
-                return $alloc_internal( (void*)0p, (T*)0p, (_Alignof(T) > libAlign() ? _Alignof(T) : libAlign()), (size_t)1, (S_fill(T)){'0'}, all);
+                return alloc_internal$( (void*)0p, (T*)0p, (_Alignof(T) > libAlign() ? _Alignof(T) : libAlign()), (size_t)1, (S_fill(T)){'0'}, all);
             }
 
             T * alloc( size_t dim, TT all ) {
-                return $alloc_internal( (void*)0p, (T*)0p, (_Alignof(T) > libAlign() ? _Alignof(T) : libAlign()), dim, (S_fill(T)){'0'}, all);
+                return alloc_internal$( (void*)0p, (T*)0p, (_Alignof(T) > libAlign() ? _Alignof(T) : libAlign()), dim, (S_fill(T)){'0'}, all);
             }
 

libcfa/src/time.hfa

@@ -10 +10 @@
 // Created On       : Wed Mar 14 23:18:57 2018
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Apr 14 09:30:30 2021
-// Update Count     : 664
+// Last Modified On : Wed Apr 21 06:32:31 2021
+// Update Count     : 667
 //
 
@@ -28 +28 @@
 
 static inline {
+        void ?{}( Duration & dur, timeval t ) with( dur ) { tn = (int64_t)t.tv_sec * TIMEGRAN + t.tv_usec * 1000; }
+        void ?{}( Duration & dur, timespec t ) with( dur ) { tn = (int64_t)t.tv_sec * TIMEGRAN + t.tv_nsec; }
+
         Duration ?=?( Duration & dur, __attribute__((unused)) zero_t ) { return dur{ 0 }; }
-
-        void ?{}( Duration & dur, timeval t ) with( dur ) { tn = (int64_t)t.tv_sec * TIMEGRAN + t.tv_usec * 1000; }
         Duration ?=?( Duration & dur, timeval t ) with( dur ) {
                 tn = (int64_t)t.tv_sec * TIMEGRAN + t.tv_usec * (TIMEGRAN / 1_000_000LL);
                 return dur;
         } // ?=?
-
-        void ?{}( Duration & dur, timespec t ) with( dur ) { tn = (int64_t)t.tv_sec * TIMEGRAN + t.tv_nsec; }
         Duration ?=?( Duration & dur, timespec t ) with( dur ) {
                 tn = (int64_t)t.tv_sec * TIMEGRAN + t.tv_nsec;
@@ -61 +60 @@
         Duration ?%?( Duration lhs, Duration rhs ) { return (Duration)@{ lhs.tn % rhs.tn }; }
         Duration ?%=?( Duration & lhs, Duration rhs ) { lhs = lhs % rhs; return lhs; }
+
+        bool ?==?( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tn == 0; }
+        bool ?!=?( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tn != 0; }
+        bool ?<? ( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tn <  0; }
+        bool ?<=?( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tn <= 0; }
+        bool ?>? ( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tn >  0; }
+        bool ?>=?( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tn >= 0; }
 
         bool ?==?( Duration lhs, Duration rhs ) { return lhs.tn == rhs.tn; }
@@ -68 +74 @@
         bool ?>? ( Duration lhs, Duration rhs ) { return lhs.tn >  rhs.tn; }
         bool ?>=?( Duration lhs, Duration rhs ) { return lhs.tn >= rhs.tn; }
-
-        bool ?==?( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tn == 0; }
-        bool ?!=?( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tn != 0; }
-        bool ?<? ( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tn <  0; }
-        bool ?<=?( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tn <= 0; }
-        bool ?>? ( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tn >  0; }
-        bool ?>=?( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tn >= 0; }
 
         Duration abs( Duration rhs ) { return rhs.tn >= 0 ? rhs : -rhs; }
@@ -164 +163 @@
 void ?{}( Time & time, int year, int month = 1, int day = 1, int hour = 0, int min = 0, int sec = 0, int64_t nsec = 0 );
 static inline {
+        void ?{}( Time & time, timeval t ) with( time ) { tn = (int64_t)t.tv_sec * TIMEGRAN + t.tv_usec * 1000; }
+        void ?{}( Time & time, timespec t ) with( time ) { tn = (int64_t)t.tv_sec * TIMEGRAN + t.tv_nsec; }
+
         Time ?=?( Time & time, __attribute__((unused)) zero_t ) { return time{ 0 }; }
-
-        void ?{}( Time & time, timeval t ) with( time ) { tn = (int64_t)t.tv_sec * TIMEGRAN + t.tv_usec * 1000; }
         Time ?=?( Time & time, timeval t ) with( time ) {
                 tn = (int64_t)t.tv_sec * TIMEGRAN + t.tv_usec * (TIMEGRAN / 1_000_000LL);
                 return time;
         } // ?=?
-
-        void ?{}( Time & time, timespec t ) with( time ) { tn = (int64_t)t.tv_sec * TIMEGRAN + t.tv_nsec; }
         Time ?=?( Time & time, timespec t ) with( time ) {
                 tn = (int64_t)t.tv_sec * TIMEGRAN + t.tv_nsec;