Index: doc/user/user.tex
===================================================================
--- doc/user/user.tex	(revision 418d773ad9d5d212569dfdbbf0dd6d8727cb8c6c)
+++ doc/user/user.tex	(revision d28a03ecbd43a9006978a2f77f2752fc4daadd7d)
@@ -11,6 +11,6 @@
 %% Created On       : Wed Apr  6 14:53:29 2016
 %% Last Modified By : Peter A. Buhr
-%% Last Modified On : Tue Feb 13 08:31:21 2018
-%% Update Count     : 3161
+%% Last Modified On : Sat Apr 14 19:04:30 2018
+%% Update Count     : 3318
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
@@ -283,5 +283,5 @@
 
 double key = 5.0, vals[10] = { /* 10 sorted floating values */ };
-double * val = (double *)bsearch( &key, vals, 10, sizeof(vals[0]), comp );	$\C{// search sorted array}$
+double * val = (double *)bsearch( &key, vals, 10, sizeof(vals[0]), comp );	§\C{// search sorted array}§
 \end{lstlisting}
 which can be augmented simply with a polymorphic, type-safe, \CFA-overloaded wrappers:
@@ -292,8 +292,8 @@
 
 forall( otype T | { int ?<?( T, T ); } ) unsigned int bsearch( T key, const T * arr, size_t size ) {
-	T * result = bsearch( key, arr, size );	$\C{// call first version}$
-	return result ? result - arr : size; }	$\C{// pointer subtraction includes sizeof(T)}$
-
-double * val = bsearch( 5.0, vals, 10 );	$\C{// selection based on return type}$
+	T * result = bsearch( key, arr, size );	§\C{// call first version}§
+	return result ? result - arr : size; }	§\C{// pointer subtraction includes sizeof(T)}§
+
+double * val = bsearch( 5.0, vals, 10 );	§\C{// selection based on return type}§
 int posn = bsearch( 5.0, vals, 10 );
 \end{lstlisting}
@@ -353,5 +353,5 @@
 The 1999 C standard plus GNU extensions.
 \item
-\Indexc[deletekeywords=inline]{-fgnu89-inline}\index{compilation option!-fgnu89-inline@{\lstinline[deletekeywords=inline]$-fgnu89-inline$}}
+\Indexc[deletekeywords=inline]{-fgnu89-inline}\index{compilation option!-fgnu89-inline@{\lstinline[deletekeywords=inline]@-fgnu89-inline@}}
 Use the traditional GNU semantics for inline routines in C99 mode, which allows inline routines in header files.
 \end{description}
@@ -506,5 +506,5 @@
 
 C, \CC, and Java (and many other programming languages) have no exponentiation operator\index{exponentiation!operator}\index{operator!exponentiation}, \ie $x^y$, and instead use a routine, like \Indexc{pow}, to perform the exponentiation operation.
-\CFA extends the basic operators with the exponentiation operator ©?\?©\index{?\\?@\lstinline$?\?$} and ©?\=?©\index{?\\=?@\lstinline$?\=?$}, as in, ©x \ y© and ©x \= y©, which means $x^y$ and $x \leftarrow x^y$.
+\CFA extends the basic operators with the exponentiation operator ©?\?©\index{?\\?@\lstinline@?\?@} and ©?\=?©\index{?\\=?@\lstinline@?\=?@}, as in, ©x \ y© and ©x \= y©, which means $x^y$ and $x \leftarrow x^y$.
 The priority of the exponentiation operator is between the cast and multiplicative operators, so that ©w * (int)x \ (int)y * z© is parenthesized as ©((w * (((int)x) \ ((int)y))) * z)©.
 
@@ -524,9 +524,9 @@
 
 
-\section{\texorpdfstring{Labelled \LstKeywordStyle{continue} / \LstKeywordStyle{break}}{Labelled continue / break}}
+\section{\texorpdfstring{Labelled \protect\lstinline@continue@ / \protect\lstinline@break@}{Labelled continue / break}}
 
 While C provides ©continue© and ©break© statements for altering control flow, both are restricted to one level of nesting for a particular control structure.
 Unfortunately, this restriction forces programmers to use \Indexc{goto} to achieve the equivalent control-flow for more than one level of nesting.
-To prevent having to switch to the ©goto©, \CFA extends the \Indexc{continue}\index{continue@\lstinline $continue$!labelled}\index{labelled!continue@©continue©} and \Indexc{break}\index{break@\lstinline $break$!labelled}\index{labelled!break@©break©} with a target label to support static multi-level exit\index{multi-level exit}\index{static multi-level exit}~\cite{Buhr85}, as in Java.
+To prevent having to switch to the ©goto©, \CFA extends the \Indexc{continue}\index{continue@\lstinline@continue@!labelled}\index{labelled!continue@©continue©} and \Indexc{break}\index{break@\lstinline@break@!labelled}\index{labelled!break@©break©} with a target label to support static multi-level exit\index{multi-level exit}\index{static multi-level exit}~\cite{Buhr85}, as in Java.
 For both ©continue© and ©break©, the target label must be directly associated with a ©for©, ©while© or ©do© statement;
 for ©break©, the target label can also be associated with a ©switch©, ©if© or compound (©{}©) statement.
@@ -613,5 +613,5 @@
 \end{figure}
 
-Both labelled ©continue© and ©break© are a ©goto©\index{goto@\lstinline $goto$!restricted} restricted in the following ways:
+Both labelled ©continue© and ©break© are a ©goto©\index{goto@\lstinline@goto@!restricted} restricted in the following ways:
 \begin{itemize}
 \item
@@ -629,5 +629,5 @@
 
 
-\section{\texorpdfstring{\LstKeywordStyle{switch} Statement}{switch Statement}}
+\section{\texorpdfstring{\protect\lstinline@switch@ Statement}{switch Statement}}
 
 C allows a number of questionable forms for the ©switch© statement:
@@ -834,5 +834,5 @@
 
 
-\section{\texorpdfstring{\LstKeywordStyle{case} Clause}{case Clause}}
+\section{\texorpdfstring{\protect\lstinline@case@ Clause}{case Clause}}
 
 C restricts the ©case© clause of a ©switch© statement to a single value.
@@ -871,37 +871,14 @@
 \end{tabular}
 \end{cquote}
-In addition, two forms of subranges are allowed to specify case values: a new \CFA form and an existing GNU C form.\footnote{
-The GNU C form \emph{requires} spaces around the ellipse.}
-\begin{cquote}
-\begin{tabular}{@{}l@{\hspace{3em}}l@{\hspace{2em}}l@{}}
-\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}	& \multicolumn{1}{c@{\hspace{2em}}}{\textbf{GNU C}}	\\
+In addition, subranges are allowed to specify case values.\footnote{
+gcc has the same mechanism but awkward syntax, \lstinline@2 ...42@, because a space is required after a number, otherwise the period is a decimal point.}
 \begin{cfa}
 switch ( i ) {
-  case ®1~5:®
+  case ®1~5:®					§\C{// 1, 2, 3, 4, 5}§
 	...
-  case ®10~15:®
+  case ®10~15:®					§\C{// 10, 11, 12, 13, 14, 15}§
 	...
 }
 \end{cfa}
-&
-\begin{cfa}
-switch ( i )
-  case ®1 ... 5®:
-	...
-  case ®10 ... 15®:
-	...
-}
-\end{cfa}
-&
-\begin{cfa}
-
-// 1, 2, 3, 4, 5
-
-// 10, 11, 12, 13, 14, 15
-
-
-\end{cfa}
-\end{tabular}
-\end{cquote}
 Lists of subranges are also allowed.
 \begin{cfa}
@@ -910,6 +887,131 @@
 
 
-\section{\texorpdfstring{\LstKeywordStyle{with} Clause / Statement}{with Clause / Statement}}
-\label{s:WithClauseStatement}
+\section{\texorpdfstring{\protect\lstinline@with@ Statement}{with Statement}}
+\label{s:WithStatement}
+
+Grouping heterogeneous data into \newterm{aggregate}s (structure/union) is a common programming practice, and an aggregate can be further organized into more complex structures, such as arrays and containers:
+\begin{cfa}
+struct S {									§\C{// aggregate}§
+	char c;									§\C{// fields}§
+	int i;
+	double d;
+};
+S s, as[10];
+\end{cfa}
+However, functions manipulating aggregates must repeat the aggregate name to access its containing fields:
+\begin{cfa}
+void f( S s ) {
+	`s.`c; `s.`i; `s.`d;					§\C{// access containing fields}§
+}
+\end{cfa}
+which extends to multiple levels of qualification for nested aggregates.
+A similar situation occurs in object-oriented programming, \eg \CC:
+\begin{C++}
+struct S {
+	char c;									§\C{// fields}§
+	int i;
+	double d;
+	void f() {								§\C{// implicit ``this'' aggregate}§
+		`this->`c; `this->`i; `this->`d;	§\C{// access containing fields}§
+	}
+}
+\end{C++}
+Object-oriented nesting of member functions in a \lstinline[language=C++]@class/struct@ allows eliding \lstinline[language=C++]$this->$ because of lexical scoping.
+However, for other aggregate parameters, qualification is necessary:
+\begin{cfa}
+struct T { double m, n; };
+int S::f( T & t ) {							§\C{// multiple aggregate parameters}§
+	c; i; d;								§\C{\color{red}// this--{\textgreater}.c, this--{\textgreater}.i, this--{\textgreater}.d}§
+	`t.`m; `t.`n;							§\C{// must qualify}§
+}
+\end{cfa}
+
+To simplify the programmer experience, \CFA provides a @with@ statement (see Pascal~\cite[\S~4.F]{Pascal}) to elide aggregate qualification to fields by opening a scope containing the field identifiers.
+Hence, the qualified fields become variables with the side-effect that it is easier to optimizing field references in a block.
+\begin{cfa}
+void f( S & this ) `with ( this )` {		§\C{// with statement}§
+	c; i; d;								§\C{\color{red}// this.c, this.i, this.d}§
+}
+\end{cfa}
+with the generality of opening multiple aggregate-parameters:
+\begin{cfa}
+void f( S & s, T & t ) `with ( s, t )` {		§\C{// multiple aggregate parameters}§
+	c; i; d;								§\C{\color{red}// s.c, s.i, s.d}§
+	m; n;									§\C{\color{red}// t.m, t.n}§
+}
+\end{cfa}
+
+In detail, the @with@ statement has the form:
+\begin{cfa}
+§\emph{with-statement}§:
+	'with' '(' §\emph{expression-list}§ ')' §\emph{compound-statement}§
+\end{cfa}
+and may appear as the body of a function or nested within a function body.
+Each expression in the expression-list provides a type and object.
+The type must be an aggregate type.
+(Enumerations are already opened.)
+The object is the implicit qualifier for the open structure-fields.
+
+All expressions in the expression list are open in parallel within the compound statement.
+This semantic is different from Pascal, which nests the openings from left to right.
+The difference between parallel and nesting occurs for fields with the same name and type:
+\begin{cfa}
+struct S { int `i`; int j; double m; } s, w;
+struct T { int `i`; int k; int m; } t, w;
+with ( s, t ) {
+	j + k;									§\C{// unambiguous, s.j + t.k}§
+	m = 5.0;								§\C{// unambiguous, t.m = 5.0}§
+	m = 1;									§\C{// unambiguous, s.m = 1}§
+	int a = m;								§\C{// unambiguous, a = s.i }§
+	double b = m;							§\C{// unambiguous, b = t.m}§
+	int c = s.i + t.i;						§\C{// unambiguous, qualification}§
+	(double)m;								§\C{// unambiguous, cast}§
+}
+\end{cfa}
+For parallel semantics, both @s.i@ and @t.i@ are visible, so @i@ is ambiguous without qualification;
+for nested semantics, @t.i@ hides @s.i@, so @i@ implies @t.i@.
+\CFA's ability to overload variables means fields with the same name but different types are automatically disambiguated, eliminating most qualification when opening multiple aggregates.
+Qualification or a cast is used to disambiguate.
+
+There is an interesting problem between parameters and the function-body @with@, \eg:
+\begin{cfa}
+void ?{}( S & s, int i ) with ( s ) {		§\C{// constructor}§
+	`s.i = i;`  j = 3;  m = 5.5;			§\C{// initialize fields}§
+}
+\end{cfa}
+Here, the assignment @s.i = i@ means @s.i = s.i@, which is meaningless, and there is no mechanism to qualify the parameter @i@, making the assignment impossible using the function-body @with@.
+To solve this problem, parameters are treated like an initialized aggregate:
+\begin{cfa}
+struct Params {
+	S & s;
+	int i;
+} params;
+\end{cfa}
+and implicitly opened \emph{after} a function-body open, to give them higher priority:
+\begin{cfa}
+void ?{}( S & s, int `i` ) with ( s ) `with( §\emph{\color{red}params}§ )` {
+	s.i = `i`; j = 3; m = 5.5;
+}
+\end{cfa}
+Finally, a cast may be used to disambiguate among overload variables in a @with@ expression:
+\begin{cfa}
+with ( w ) { ... }							§\C{// ambiguous, same name and no context}§
+with ( (S)w ) { ... }						§\C{// unambiguous, cast}§
+\end{cfa}
+and @with@ expressions may be complex expressions with type reference (see Section~\ref{s:References}) to aggregate:
+% \begin{cfa}
+% struct S { int i, j; } sv;
+% with ( sv ) {								§\C{// implicit reference}§
+% 	S & sr = sv;
+% 	with ( sr ) {							§\C{// explicit reference}§
+% 		S * sp = &sv;
+% 		with ( *sp ) {						§\C{// computed reference}§
+% 			i = 3; j = 4;					§\C{\color{red}// sp--{\textgreater}i, sp--{\textgreater}j}§
+% 		}
+% 		i = 2; j = 3;						§\C{\color{red}// sr.i, sr.j}§
+% 	}
+% 	i = 1; j = 2;							§\C{\color{red}// sv.i, sv.j}§
+% }
+% \end{cfa}
 
 In \Index{object-oriented} programming, there is an implicit first parameter, often names \textbf{©self©} or \textbf{©this©}, which is elided.
@@ -935,5 +1037,5 @@
 \CFA provides a ©with© clause/statement (see Pascal~\cite[\S~4.F]{Pascal}) to elided the "©this.©" by opening a scope containing field identifiers, changing the qualified fields into variables and giving an opportunity for optimizing qualified references.
 \begin{cfa}
-int mem( S & this ) ®with this® { §\C{// with clause}§
+int mem( S & this ) ®with( this )® { §\C{// with clause}§
 	i = 1;						§\C{\color{red}// this.i}§
 	j = 2;						§\C{\color{red}// this.j}§
@@ -943,5 +1045,5 @@
 \begin{cfa}
 struct T { double m, n; };
-int mem2( S & this1, T & this2 ) ®with this1, this2® {
+int mem2( S & this1, T & this2 ) ®with( this1, this2 )® {
 	i = 1; j = 2;
 	m = 1.0; n = 2.0;
@@ -954,5 +1056,5 @@
 	struct S1 { ... } s1;
 	struct S2 { ... } s2;
-	®with s1® {					§\C{// with statement}§
+	®with( s1 )® {				§\C{// with statement}§
 		// access fields of s1 without qualification
 		®with s2® {				§\C{// nesting}§
@@ -971,16 +1073,10 @@
 struct S { int i; int j; double m; } a, c;
 struct T { int i; int k; int m } b, c;
-®with a, b® {
-	j + k;						§\C{// unambiguous, unique names define unique types}§
-	i;							§\C{// ambiguous, same name and type}§
-	a.i + b.i;					§\C{// unambiguous, qualification defines unique names}§
-	m;							§\C{// ambiguous, same name and no context to define unique type}§
-	m = 5.0;					§\C{// unambiguous, same name and context defines unique type}§
-	m = 1;						§\C{// unambiguous, same name and context defines unique type}§
-}
-®with c® { ... }				§\C{// ambiguous, same name and no context}§
-®with (S)c® { ... }				§\C{// unambiguous, same name and cast defines unique type}§
-\end{cfa}
-
+with( a, b )
+{
+}
+\end{cfa}
+
+\begin{comment}
 The components in the "with" clause
 
@@ -1007,4 +1103,5 @@
 the "with" to be implemented because I hate having to type all those object
 names for fields. It's a great way to drive people away from the language.
+\end{comment}
 
 
@@ -1595,5 +1692,5 @@
 
 \item
-lvalue to reference conversion: \lstinline[deletekeywords=lvalue]$lvalue-type cv1 T$ converts to ©cv2 T &©, which allows implicitly converting variables to references.
+lvalue to reference conversion: \lstinline[deletekeywords=lvalue]@lvalue-type cv1 T@ converts to ©cv2 T &©, which allows implicitly converting variables to references.
 \begin{cfa}
 int x, &r = ®x®, f( int & p ); // lvalue variable (int) convert to reference (int &)
@@ -6361,4 +6458,231 @@
 
 
+\section{Time}
+\label{s:TimeLib}
+
+
+%\subsection{\texorpdfstring{\protect\lstinline@Duration@}{Duration}}
+\subsection{\texorpdfstring{\LstKeywordStyle{\textmd{Duration}}}{Duration}}
+\label{s:Duration}
+
+\leavevmode
+\begin{cfa}[aboveskip=0pt,belowskip=0pt]
+struct Duration {
+	int64_t tv;							§\C{// nanoseconds}§
+};
+
+void ?{}( Duration & dur );
+void ?{}( Duration & dur, zero_t );
+
+Duration ?=?( Duration & dur, zero_t );
+
+Duration +?( Duration rhs );
+Duration ?+?( Duration & lhs, Duration rhs );
+Duration ?+=?( Duration & lhs, Duration rhs );
+
+Duration -?( Duration rhs );
+Duration ?-?( Duration & lhs, Duration rhs );
+Duration ?-=?( Duration & lhs, Duration rhs );
+
+Duration ?*?( Duration lhs, int64_t rhs );
+Duration ?*?( int64_t lhs, Duration rhs );
+Duration ?*=?( Duration & lhs, int64_t rhs );
+
+int64_t ?/?( Duration lhs, Duration rhs );
+Duration ?/?( Duration lhs, int64_t rhs );
+Duration ?/=?( Duration & lhs, int64_t rhs );
+double div( Duration lhs, Duration rhs );
+
+Duration ?%?( Duration lhs, Duration rhs );
+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 );
+
+Duration abs( Duration rhs );
+
+forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype & os, Duration dur );
+
+Duration ?`ns( int64_t nsec );
+Duration ?`us( int64_t usec );
+Duration ?`ms( int64_t msec );
+Duration ?`s( int64_t sec );
+Duration ?`s( double sec );
+Duration ?`m( int64_t min );
+Duration ?`m( double min );
+Duration ?`h( int64_t hours );
+Duration ?`h( double hours );
+Duration ?`d( int64_t days );
+Duration ?`d( double days );
+Duration ?`w( int64_t weeks );
+Duration ?`w( double weeks );
+
+int64_t ?`ns( Duration dur );
+int64_t ?`us( Duration dur );
+int64_t ?`ms( Duration dur );
+int64_t ?`s( Duration dur );
+int64_t ?`m( Duration dur );
+int64_t ?`h( Duration dur );
+int64_t ?`d( Duration dur );
+int64_t ?`w( Duration dur );
+\end{cfa}
+
+
+%\subsection{\texorpdfstring{\protect\lstinline@\timeval@}{timeval}}
+\subsection{\texorpdfstring{\LstKeywordStyle{\textmd{timeval}}}{timeval}}
+\label{s:timeval}
+
+\leavevmode
+\begin{cfa}[aboveskip=0pt,belowskip=0pt]
+void ?{}( timeval & 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 );
+
+timeval ?=?( timeval & t, zero_t );
+timeval ?+?( timeval & lhs, timeval rhs );
+timeval ?-?( timeval & lhs, timeval rhs );
+_Bool ?==?( timeval lhs, timeval rhs );
+_Bool ?!=?( timeval lhs, timeval rhs );
+\end{cfa}
+
+
+\subsection{\texorpdfstring{\protect\lstinline@timespec@}{timespec}}
+\label{s:timespec}
+
+\leavevmode
+\begin{cfa}[aboveskip=0pt,belowskip=0pt]
+void ?{}( timespec & 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 );
+
+timespec ?=?( timespec & t, zero_t );
+timespec ?+?( timespec & lhs, timespec rhs );
+timespec ?-?( timespec & lhs, timespec rhs );
+_Bool ?==?( timespec lhs, timespec rhs );
+_Bool ?!=?( timespec lhs, timespec rhs );
+\end{cfa}
+
+
+\subsection{\texorpdfstring{\protect\lstinline@itimerval@}{itimerval}}
+\label{s:itimerval}
+
+\leavevmode
+\begin{cfa}[aboveskip=0pt,belowskip=0pt]
+void ?{}( itimerval & itv, Duration alarm );
+void ?{}( itimerval & itv, Duration alarm, Duration interval );
+\end{cfa}
+
+
+\subsection{\texorpdfstring{\protect\lstinline@Time@}{Time}}
+\label{s:Time}
+
+\leavevmode
+\begin{cfa}[aboveskip=0pt,belowskip=0pt]
+struct Time {
+	uint64_t tv;						§\C{// nanoseconds since UNIX epoch}§
+};
+
+void ?{}( Time & time );
+void ?{}( Time & time, zero_t );
+void ?{}( Time & time, int year, int month = 0, int day = 0, int hour = 0, int min = 0, int sec = 0, int nsec = 0 );
+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 );
+
+Time ?+?( Time & lhs, Duration rhs ) { return (Time)@{ lhs.tv + rhs.tv }; }
+Time ?+?( Duration lhs, Time rhs ) { return rhs + lhs; }
+Time ?+=?( Time & lhs, Duration rhs ) { lhs = lhs + rhs; return lhs; }
+
+Duration ?-?( Time lhs, Time rhs ) { return (Duration)@{ lhs.tv - rhs.tv }; }
+Time ?-?( Time lhs, Duration rhs ) { return (Time)@{ lhs.tv - rhs.tv }; }
+Time ?-=?( Time & lhs, Duration rhs ) { lhs = lhs - rhs; return lhs; }
+_Bool ?==?( Time lhs, Time rhs ) { return lhs.tv == rhs.tv; }
+_Bool ?!=?( Time lhs, Time rhs ) { return lhs.tv != rhs.tv; }
+_Bool ?<?( Time lhs, Time rhs ) { return lhs.tv < rhs.tv; }
+_Bool ?<=?( Time lhs, Time rhs ) { return lhs.tv <= rhs.tv; }
+_Bool ?>?( Time lhs, Time rhs ) { return lhs.tv > rhs.tv; }
+_Bool ?>=?( Time lhs, Time rhs ) { return lhs.tv >= rhs.tv; }
+
+forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype & os, Time time );
+
+char * yy_mm_dd( Time time, char * buf );
+char * ?`ymd( Time time, char * buf ) {	// short form
+	return yy_mm_dd( time, buf );
+} // ymd
+
+char * mm_dd_yy( Time time, char * buf );
+char * ?`mdy( Time time, char * buf ) {	// short form
+	return mm_dd_yy( time, buf );
+} // mdy
+
+char * dd_mm_yy( Time time, char * buf );
+char * ?`dmy( Time time, char * buf ) {	// short form
+	return dd_mm_yy( time, buf );;
+} // dmy
+
+size_t strftime( char * buf, size_t size, const char * fmt, Time time );
+\end{cfa}
+
+
+\section{Clock}
+
+\subsection{C time}
+\label{s:Ctime}
+
+\leavevmode
+\begin{cfa}[aboveskip=0pt,belowskip=0pt]
+char * ctime( time_t tp );
+char * ctime_r( time_t tp, char * buf );
+tm * gmtime( time_t tp );
+tm * gmtime_r( time_t tp, tm * result );
+tm * localtime( time_t tp );
+tm * localtime_r( time_t tp, tm * result );
+\end{cfa}
+
+
+%\subsection{\texorpdfstring{\protect\lstinline@Clock@}{Clock}}
+\subsection{\texorpdfstring{\LstKeywordStyle{\textmd{Clock}}}{Clock}}
+\label{s:Clock}
+
+\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}§
+};
+
+void resetClock( Clock & clk );
+void resetClock( Clock & clk, Duration adj );
+void ?{}( Clock & clk );
+void ?{}( Clock & clk, Duration adj );
+Duration getRes();
+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 );
+\end{cfa}
+
+
 \section{Multi-precision Integers}
 \label{s:MultiPrecisionIntegers}
@@ -6658,5 +6982,4 @@
 \end{cfa}
 
-
 \bibliographystyle{plain}
 \bibliography{pl}