Context Navigation

-                      r9ca94af
+                      r2296885
 %% 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
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 …
 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:
 …
 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}
 …
 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}
 …
 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)©.
 …
 \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.
 …
 \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
 …
 \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:
 …
 \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.
 …
 \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}
 …
+\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.
 …
 \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}§
 …
 \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;
 …
         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}§
 …
 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
 …
 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}
 …
 \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 &)
 …
+\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}
 …
 \end{cfa}
 \bibliographystyle{plain}
 \bibliography{pl}

Note: See TracChangeset for help on using the changeset viewer.

Context Navigation

Changeset 2296885

Legend:

doc/user/user.tex

Download in other formats: