Index: doc/user/user.tex =================================================================== --- doc/user/user.tex (revision 236f13390c74aff36386095c9fc9fff394243822) +++ doc/user/user.tex (revision 9c447e225244a18c96cc4536ae39da1e56abe7b3) @@ -11,6 +11,6 @@ %% Created On : Wed Apr 6 14:53:29 2016 %% Last Modified By : Peter A. Buhr -%% Last Modified On : Tue Apr 23 14:13:10 2024 -%% Update Count : 6623 +%% Last Modified On : Tue Jul 9 10:43:40 2024 +%% Update Count : 6887 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% @@ -182,5 +182,5 @@ & \begin{cfa}[tabsize=3] -#include §\indexc{fstream}§ +#include §\indexc{fstream.hfa}§ int main( void ) { @@ -445,5 +445,5 @@ #include §\indexc{stdio.h}§ §\C{// C header file}§ #else -#include §\indexc{fstream}§ §\C{// \CFA header file}§ +#include §\indexc{fstream.hfa}§ §\C{// \CFA header file}§ #endif \end{cfa} @@ -1006,8 +1006,8 @@ \subsection{Loop Control} -Looping a fixed number of times, possibly with a loop index, occurs frequently. -\CFA condenses simply looping to facilitate coding speed and safety~\see{examples in \VRef[Figure]{f:LoopControlExamples}}. - -The \Indexc{for}, \Indexc{while}, and \Indexc{do} loop-control are extended to allow an empty conditional, which implies a comparison value of ©1© (true). +Looping a predefined number of times, possibly with a loop index, occurs frequently. +\CFA condenses writing loops to facilitate coding speed and safety. + +\Indexc{for}, \Indexc{while}, and \Indexc{do} loop-control\index{loop control} are extended with an empty conditional, meaning a comparison value of ©1© (true). \begin{cfa} while ( ®/* empty */® ) §\C{// while ( true )}§ @@ -1015,4 +1015,116 @@ do ... while ( ®/* empty */® ) §\C{// do ... while ( true )}§ \end{cfa} + +The ©for© control\index{for control}, \ie ©for ( /* control */ )©, is extended with a range and step. +A range is a set of values defined by an optional low value (default to 0), tilde, and high value, ©L ~ H©, with an optional step ©~ S© (default to 1), which means an ascending set of values from ©L© to ©H© in positive steps of ©S©. +\begin{cfa} +0 ~ 5 §\C{// \{ 0, 1, 2, 3, 4, 5 \}}§ +-8 ~ -2 ~ 2 §\C{// \{ -8. -6, -4, -2 \}}§ +-3 ~ 3 ~ 1 §\C{// \{ -3, -2, -1, 0, 1, 2, 3 \}}§ +\end{cfa} +\R{Warning}: A range in descending order, \eg ©5 ~ -3© is the null (empty) set, \ie no values in the set. +\R{Warning}: A ©0© or negative step is undefined. +Note, the order of values in a set may not be the order the values are presented during looping. + +The range character, ©'~'©, is decorated on the left and right to control how the set values are presented in the loop body. +The range character can be prefixed with ©'+'© or ©'-'© indicating the \emph{direction} the range is scanned, \ie from left to right (ascending) or right to left (descending). +Ascending stepping uses operator \Indexc{+=}; +descending stepping uses operator \Indexc{-=}. +If there is no prefix character, it defaults to ©'+'©. +\begin{cfa} +-8 ®§\Sp§®~ -2 §\C{// ascending, no prefix}§ +0 ®+®~ 5 §\C{// ascending, prefix}§ +-3 ®-®~ 3 §\C{// descending}§ +\end{cfa} +For descending iteration, the ©L© and ©H© values are \emph{implicitly} switched, and the increment/decrement for ©S© is toggled. +When changing the iteration direction, this form is faster and safer, \ie the direction prefix can be added/removed without changing existing (correct) program text. +\R{Warning}: reversing the range endpoints for descending order results in an empty set. +\begin{cfa} +for ( i; ®10 -~ 1® ) §{\C{// WRONG descending range!}§ +\end{cfa} + +Because C uses zero origin, most loops iterate from 0 to $N - 1$. +Hence, when scanning a range during iteration, the last value is dropped, \eg ©0 ~ 5© is ©0, 1, 2, 3, 4©, an exclusive range, [©L©,©H©\R{)}. +To obtain \emph{all} the values in the range, the range character is postfixed with ©'='©, \eg ©0 ~= 5© is ©0, 1, 2, 3, 4, 5©, an inclusive range, [©L©,©H©\R{]}. +\index{\~}\index{ascending exclusive range} +\index{\~=}\index{ascending inclusive range} +\index{-\~}\index{descending exclusive range} +\index{-\~=}\index{descending inclusive range} + +©for© control is formalized by the following regular expression: +\begin{cquote} +[ ©L© ]\ \ [ ©+©\ \ |\ \ ©-© ]\ \ \R{©~©}\ \ [ ©=© ]\ \ ©H©\ \ [ ©~© ©S© ] +\end{cquote} +where ©[©\,©]© denotes optional and ©|© denotes alternative. +That is, the optional low set value, the optional scan direction (ascending/descending), the (possibly) required range character, the optional include last-scan value, the required high set value, and the optional range character and step value. +\R{Warning}: the regular expression allows the form ©~H©, but this syntax has a preexisting meaning in C: complement the bits of ©H©, \eg ©for ( ~5 )© meaning ©for ( -6 )©, as ©-6© is the complement of ©5©. +This anomaly is unlikely to cause problems because programers will write the shorter ©for ( 5 )©. + +The previous ©for© loops have an anonymous loop index in which the range iteration is computed. +To access the value of the range iteration in the loop body, a \Index{loop index} is specified before the range. +\begin{cfa} +for ( ®int i;® 0 ~ 10 ~ 2 ) { ... ®i® ... } §\C{// loop index available in loop body}§ +\end{cfa} +Hence, unlike the 3 components in the C ©for©-control, there are only two components in the \CFA ©for©-control: the optional index variable and the range. +The index type is optional (like \CC ©auto©), where the type is normally inferred from the low value ©L© because it initializes the index (the type of ©H© can be different from ©L©). +When ©L© is omitted, the type of the required high value ©H© is used, as both ©L© and ©H© are the same type in this case. +\begin{cfa} +for ( i; ®1.5® ~ 5 ) §\C{// typeof(1.5) i; 1.5 is low value}§ +for ( i; ®5.5® ) §\C{// typeof(5.5) i; 5.5 is high value}§ +\end{cfa} + +The following examples illustrate common \CFA ©for©-control combinations, with the C counter-part in the comment. +\begin{itemize}[itemsep=0pt] +\item +©H© is implicit ascending exclusive range [0,©H©\R{)}. +\begin{cfa} +for ( ®5® ) §\C{// for ( typeof(5) i; i < 5; i += 1 )}§ +\end{cfa} +\item +©~=© ©H© is implicit ascending inclusive range [0,©H©\R{]}. +\begin{cfa} +for ( ®~=® 5 ) §\C{// for ( typeof(5) i; i <= 5; i += 1 )}§ +\end{cfa} +\item +©L© ©~©\index{~@©~©} ©H© is explicit ascending exclusive range [©L©,©H©\R{)}. +\begin{cfa} +for ( 1 ®~® 5 ) §\C{// for ( typeof(1) i = 1; i < 5; i += 1 )}§ +\end{cfa} +\item +©L© ©~=©\index{~=@©~=©} ©H© is explicit ascending inclusive range [©L©,©H©\R{]}. +\begin{cfa} +for ( 1 ®~=® 5 ) §\C{// for ( typeof(1) i = 1; i <= 5; i += 1 )}§ +\end{cfa} +\item +©L© ©-~©\index{-~@©-~©} ©H© is explicit descending exclusive range \R{(}©H©,©L©], where ©L© and ©H© are implicitly interchanged to make the range descending. +\begin{cfa} +for ( 1 ®-~® 5 ) §\C{// for ( typeof(1) i = 5; i > 0; i -= 1 )}§ +\end{cfa} +\item +©L© ©-~=©\index{-~=@©-~=©} ©H© is explicit descending inclusive range \R{[}©H©,©L©], where ©L© and ©H© are implicitly interchanged to make the range descending. +\begin{cfa} +for ( 1 ®-~=® 5 ) §\C{// for ( typeof(1) i = 5; i >= 0; i -= 1 )}§ +\end{cfa} +\end{itemize} + +There are situations when the ©for©-control actions need to be moved into the loop body, \eg a mid-loop exit does not need an iteration-completion test in the ©for© control. +The character ©'@'© indicates that a specific ©for©-control action is ignored, \ie generates no code. +\begin{cfa} +for ( i; ®@® -~ 10 ) §\C{// for ( typeof(10) i = 10; \R{/*empty*/}; i -= 1 )}§ +for ( i; 1 ~ ®@® ~ 2 ) §\C{// for ( typeof(1) i = 1; \R{/* empty */}; i += 2 )}§ +for ( i; 1 ~ 10 ~ ®@® ) §\C{// for ( typeof(1) i = 1; i < 10; \R{/* empty */} )}§ +for ( i; 1 ~ ®@® ~ ®@® ) §\C{// for ( typeof(1) i = 1; \R{/* empty */}; \R{/* empty */} )}§ +\end{cfa} +\R{Warning}: ©L© \emph{cannot} be elided for the ascending range, \lstinline{@ ~ 5}, nor ©H© for the descending range, \lstinline{1 -~ @}, as the loop index is uninitialized. +\R{Warning}: ©H© \emph{cannot} be elided in an anonymous loop index, ©1 ~ @©, as there is no index to stop the loop. + +There are situations when multiple loop indexes are required. +The character ©':'© means add another index, where any number of indices may be chained in a single ©for© control. +\begin{cfa} +for ( i; 5 ®:® j; 2 ~ 12 ~ 3 ) §\C{// for ( typeof(i) i = 1, j = 2; \R{i < 5 \&\& j < 12}; i += 1, j += 3 )}§ +for ( i; 5 ®:® j; 2 ~ @ ~ 3 ) §\C{// for ( typeof(i) i = 1, j = 2; \R{i < 5}; i += 1, j += 3 )}§ +for ( i; 5 ®:® j; 2.5 ~ @ ~ 3.5 ) §\C{// no C equivalent, without hoisting declaration of floating-point j}§ +\end{cfa} +\VRef[Figure]{f:LoopControlExamples} shows more complex loop-control examples across all the different options. \begin{figure} @@ -1025,5 +1137,5 @@ for () { sout | "empty"; break; } §\C[3in]{sout | nl | nlOff;}§ -for ( 0 ) { sout | "A"; } sout | "zero"; §\C{sout | nl;}§ +for ( 0 ) { sout | "A"; } §\C{sout | nl;}§ for ( 1 ) { sout | "A"; } §\C{sout | nl;}§ for ( 10 ) { sout | "A"; } §\C{sout | nl;}§ @@ -1073,5 +1185,5 @@ empty -zero + A A A A A A A A A A A @@ -1120,110 +1232,73 @@ \end{figure} -% for () => for ( ;; ) -% for ( 10 - t ) => for ( typeof(10 - t) ? = 0 ; ? < 10 - t; ? += 1 ) // using 0 and 1 -% for ( i ; 10 - t ) => for ( typeof(10 - t) i = 0 ; i < 10 - t; i += 1 ) // using 0 and 1 -% for ( T i ; 10 - t ) => for ( T i = 0 ; i < 10 - t; i += 1 ) // using 0 and 1 -% for ( 3~9 ) => for ( int ? = 3 ; ? < 9; ? += 1 ) // using 1 -% for ( i ; 3~9 ) => for ( int i = 3 ; i < 9; i += 1 ) // using 1 -% for ( T i ; 3~9 ) => for ( T i = 3 ; i < 9; i += 1 ) // using 1 - -The ©for© control is extended with 4 new loop-control operators, which are not overloadable: -\begin{description}[itemsep=0pt,parsep=0pt] -\item -\Indexc{\~} (tilde) \Index{up-to exclusive range}, -\item -\Indexc{\~=} (tilde equal) \Index{up-to inclusive range}, -\item -\Indexc{-\~} (minus tilde) \Index{down-to exclusive range}, -\item -\Indexc{-\~=} (minus tilde equal) \Index{down-to inclusive range}. -\end{description} - -The ©for© index components, low (L), high (H), and increment (I), are optional. -If missing: -\begin{itemize}[itemsep=0pt,parsep=0pt] -\item -\Indexc{0} is the implicit low value. -\item -\Indexc{1} is the implicit increment value. -\item -The up-to range uses operator \Indexc{+=} for increment. -\item -The down-to range uses operator \Indexc{-=} for decrement. -\end{itemize} - -If no type is specified for the loop index, it is the type of the high value H (when the low value is implicit) or the low value L. -\begin{cfa} -for ( ®5® ) §\C{// typeof(5) anonymous-index; 5 is high value}§ -for ( i; ®1.5® ~ 5.5 ) §\C{// typeof(1.5) i; 1.5 is low value}§ -for ( ®int i®; 0 ~ 10 ~ 2 ) §\C{// int i; type is explicit}§ -\end{cfa} - -The following are examples for constructing different for-control: -\begin{itemize}[itemsep=0pt] -\item -H is implicit up-to exclusive range [0,H\R{)}. -\begin{cfa} -for ( ®5® ) §\C{// for ( typeof(5) i; i < 5; i += 1 )}§ -\end{cfa} -\item -©~=© H is implicit up-to inclusive range [0,H\R{]}. -\begin{cfa} -for ( ®~=® 5 ) §\C{// for ( typeof(5) i; i <= 5; i += 1 )}§ -\end{cfa} -\item -L ©~©\index{~@©~©} H is explicit up-to exclusive range [L,H\R{)}. -\begin{cfa} -for ( 1 ®~® 5 ) §\C{// for ( typeof(1) i = 1; i < 5; i += 1 )}§ -\end{cfa} -\item -L ©~=©\index{~=@©~=©} H is explicit up-to inclusive range [L,H\R{]}. -\begin{cfa} -for ( 1 ®~=® 5 ) §\C{// for ( typeof(1) i = 1; i <= 5; i += 1 )}§ -\end{cfa} -\item -L ©-~©\index{-~@©-~©} H is explicit down-to exclusive range [H,L\R{)}, where L and H are implicitly interchanged to make the range down-to. -\begin{cfa} -for ( 1 ®-~® 5 ) §\C{// for ( typeof(1) i = 5; i > 0; i -= 1 )}§ -\end{cfa} -\item -L ©-~=©\index{-~=@©-~=©} H is explicit down-to inclusive range [H,L\R{]}, where L and H are implicitly interchanged to make the range down-to. -\begin{cfa} -for ( 1 ®-~=® 5 ) §\C{// for ( typeof(1) i = 5; i >= 0; i -= 1 )}§ -\end{cfa} -\item -©@© means put nothing in this field. -\begin{cfa} -for ( i; 1 ~ ®@® ~ 2 ) §\C{// for ( typeof(1) i = 1; \R{/* empty */}; i += 2 )}§ -for ( i; 1 ~ 10 ~ ®@® ) §\C{// for ( typeof(1) i = 1; i < 10; \R{/* empty */} )}§ -for ( i; 1 ~ ®@® ~ ®@® ) §\C{// for ( typeof(1) i = 1; /*empty*/; \R{/* empty */} )}§ -\end{cfa} -L cannot be elided for the up-to range, \lstinline{@ ~ 5}, and H for the down-to range, \lstinline{1 -~ @}, because then the loop index is uninitialized. -Similarly, the high value cannot be elided is an anonymous loop index (©1 ~ @©), as there is no index to stop the loop. -\item -©:© means add another index. -\begin{cfa} -for ( i; 5 ®:® j; 2 ~ 12 ~ 3 ) §\C{// for ( typeof(i) i = 1, j = 2; i < 5 \&\& j < 12; i += 1, j += 3 )}§ -\end{cfa} -\end{itemize} -\R{Warning}: specifying the down-to range maybe unexpected because the loop control \emph{implicitly} switches the L and H values (and toggles the increment/decrement for I): -\begin{cfa} -for ( i; 1 ~ 10 ) §{\C{// up range}§ -for ( i; 1 -~ 10 ) §{\C{// down range}§ -for ( i; ®10 -~ 1® ) §{\C{// \R{WRONG down range!}}}§ -\end{cfa} -The reason for this semantics is that the range direction can be toggled by adding/removing the minus, ©'-'©, versus interchanging the L and H expressions, which has a greater chance of introducing errors. - - -%\subsection{\texorpdfstring{Labelled \protect\lstinline{continue} / \protect\lstinline{break}}{Labelled continue / break}} -\subsection{\texorpdfstring{Labelled \LstKeywordStyle{continue} / \LstKeywordStyle{break} Statement}{Labelled continue / break Statement}} - -C \Indexc{continue} and \Indexc{break} statements are restricted to one level of nesting for a particular control structure. -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@©continue©!labelled}\index{labelled!continue@©continue©} and \Indexc{break}\index{break@©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 \Indexc{for}, \Indexc{while} or \Indexc{do} statement; -for ©break©, the target label can also be associated with a \Indexc{switch}, \Indexc{if} or compound (©{}©) statement. -\VRef[Figure]{f:MultiLevelExit} shows a comparison between labelled ©continue© and ©break© and the corresponding C equivalent using ©goto© and labels. -The innermost loop has 8 exit points, which cause continuation or termination of one or more of the 7 \Index{nested control-structure}s. +Finally, any type that satisfies the ©Iterate© trait can be used with ©for© control. +\begin{cfa} +forall( T ) trait Iterate { + void ?{}( T & t, zero_t ); + int ??( T t1, T t2 ); + int ?>=?( T t1, T t2 ); + T ?+=?( T & t1, T t2 ); + T ?+=?( T & t, one_t ); + T ?-=?( T & t1, T t2 ); + T ?-=?( T & t, one_t ); +} +\end{cfa} +\VRef[Figure]{f:ForControlStructureType} shows an example of a structure using ©for© control. +Note, the use of ©(S){0}© when implicitly setting the loop-index type, because using 0 incorrect declares the index to ©int© rather than ©S©. + +\begin{figure} +\begin{tabular}{@{}l@{\hspace{5pt}}l@{}} +\begin{cfa} +struct S { int i, j; }; +void ?{}( S & s, int i = 0, int j = 0 ) { s.[i, j] = [i, j]; } +void ?{}( S & s, zero_t ) { s.[i, j] = 0; } +int ??( S t1, S t2 ) { return t1.i > t2.i && t1.j > t2.j; } +int ?>=?( S t1, S t2 ) { return t1.i >= t2.i && t1.j >= t2.j; } +S ?+=?( S & t1, S t2 ) { t1.i += t2.i; t1.j += t2.j; return t1; } +S ?+=?( S & t, one_t ) { t.i += 1; t.j += 1; return t; } +S ?-=?( S & t1, S t2 ) { t1.i -= t2.i; t1.j -= t2.j; return t1; } +S ?-=?( S & t, one_t ) { t.i -= 1; t.j -= 1; return t; } +ofstream & ?|?( ofstream & os, S s ) { + return os | "(" | s.i | s.j | ")"; +} +void & ?|?( ofstream & os, S s ) { + (ofstream &)(os | s); ends( os ); +} + + + +\end{cfa} +& +\begin{cfa} +int main() { + for ( S i = 0; i < (S){10,10}; i += 1 ) { sout | i; } sout | "A" | nl; // C + for ( S i; 0 ~ (S){10,10} ) { sout | i; } sout | "B" | nl; // CFA + for ( i; (S){10,10} ) { sout | i; } sout | "C" | nl; + for ( i; (S){0} ~ (S){10,10} ) { sout | i; } sout | "D" | nl; + for ( i; (S){0} ~= (S){10,10} ) { sout | i; } sout | "E" | nl; + for ( i; (S){0} ~= (S){10,10} ~ (S){2} ) { sout | i; } sout | "F" | nl; + for ( i; (S){0} -~ (S){10,10} ) { sout | i; } sout | "G" | nl; + for ( i; (S){0} -~= (S){10,10} ) { sout | i; } sout | "H" | nl; + for ( i; (S){0} -~= (S){10,10} ~ (S){2,1} ) { sout | i; } sout | "I" | nl; +} +(0 0) (1 1) (2 2) (3 3) (4 4) (5 5) (6 6) (7 7) (8 8) (9 9) A +(0 0) (1 1) (2 2) (3 3) (4 4) (5 5) (6 6) (7 7) (8 8) (9 9) B +(0 0) (1 1) (2 2) (3 3) (4 4) (5 5) (6 6) (7 7) (8 8) (9 9) C +(0 0) (1 1) (2 2) (3 3) (4 4) (5 5) (6 6) (7 7) (8 8) (9 9) D +(0 0) (1 1) (2 2) (3 3) (4 4) (5 5) (6 6) (7 7) (8 8) (9 9) (10 10) E +(0 0) (2 0) (4 0) (6 0) (8 0) (10 0) F +(10 10) (9 9) (8 8) (7 7) (6 6) (5 5) (4 4) (3 3) (2 2) (1 1) G +(10 10) (9 9) (8 8) (7 7) (6 6) (5 5) (4 4) (3 3) (2 2) (1 1) (0 0) H +(10 10) (8 9) (6 8) (4 7) (2 6) (0 5) I +\end{cfa} +\end{tabular} +\caption{For Control with Structure Type} +\label{f:ForControlStructureType} +\end{figure} + \begin{figure} @@ -1297,4 +1372,16 @@ \end{figure} + +%\subsection{\texorpdfstring{Labelled \protect\lstinline{continue} / \protect\lstinline{break}}{Labelled continue / break}} +\subsection{\texorpdfstring{Labelled \LstKeywordStyle{continue} / \LstKeywordStyle{break} Statement}{Labelled continue / break Statement}} + +C \Indexc{continue} and \Indexc{break} statements are restricted to one level of nesting for a particular control structure. +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@©continue©!labelled}\index{labelled!continue@©continue©} and \Indexc{break}\index{break@©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 \Indexc{for}, \Indexc{while} or \Indexc{do} statement; +for ©break©, the target label can also be associated with a \Indexc{switch}, \Indexc{if} or compound (©{}©) statement. +\VRef[Figure]{f:MultiLevelExit} shows a comparison between labelled ©continue© and ©break© and the corresponding C equivalent using ©goto© and labels. +The innermost loop has 8 exit points, which cause continuation or termination of one or more of the 7 \Index{nested control-structure}s. + Both labelled \Indexc{continue} and \Indexc{break} are a \Indexc{goto}\index{goto@©goto©!restricted} restricted in the following ways: \begin{itemize} @@ -3103,10 +3190,10 @@ Similarly, if the argument is an expression, it must be parenthesized, \eg ©(i + 3)`h©, or only the last operand of the expression is the argument, \eg ©i + (3`h)©. -\VRef[Figure]{f:UnitsComparison} shows a common usage for postfix functions: converting basic literals into user literals. +\VRef[Figure]{f:UnitsComparison} shows a common example for postfix functions: converting basic literals into user literals. \see*{\VRef{s:DynamicStorageManagement} for other uses for postfix functions.} -The \CFA example (left) stores a mass in units of stones (1 stone = 14 lb or 6.35 kg) and provides an addition operator (imagine a full set of arithmetic operators). +The \CFA example (left) stores a mass in units of stones (1 stone = 14 lb or 6.35 kg) and provides an addition operator ©?+?© (imagine a full set of arithmetic operators). +The arithmetic operators manipulate stones and the postfix operations convert to/from different units. The three postfixing function names ©st©, ©lb©, and ©kg©, represent units stones, pounds, and kilograms, respectively. Each name has two forms that bidirectional convert: a value of a specified unit to stones, \eg ©w = 14`lb© $\Rightarrow$ ©w == 1© stone or a ©Weight© from stones back to specific units, \eg ©w`lb© (1 stone) to ©14©. -All arithmetic operations manipulate stones and the postfix operations convert to the different units. A similar group of postfix functions provide user constants for converting time units into nanoseconds, which is the basic time unit, \eg ©ns©, ©us©, ©ms©, ©s©, ©m©, ©h©, ©d©, and ©w©, for nanosecond, microsecond, millisecond, second, minute, hour, day, and week, respectively. (Note, month is not a fixed period of time nor is year because of leap years.) @@ -3209,7 +3296,7 @@ The \CC example (right) provides a \emph{restricted} capability via user literals. -The \lstinline[language=C++]{operator ""} only takes a constant argument (\ie no variable argument), and the constant type must be the highest-level constant-type, \eg ©long double© for all floating-point constants. +The \lstinline[language=C++]{operator""} only takes a constant argument (\ie no variable as an argument), and the constant type must be the highest-level constant-type, \eg ©long double© for all floating-point constants. As well, there is no constant conversion, \ie ©int© to ©double© constants, so integral constants are handled by a separate set of routines, with maximal integral type ©unsigned long long int©. -Finally, there is no mechanism to use this syntax for a bidirectional conversion because \lstinline[language=C++]{operator ""} does not accept variable arguments. +Finally, there is no mechanism to use this syntax for a bidirectional conversion because \lstinline[language=C++]{operator""} only accepts a constant argument. @@ -5069,5 +5156,5 @@ \begin{comment} -#include +#include #include // strcpy @@ -6330,5 +6417,5 @@ \begin{figure} \begin{cfa} -#include +#include #include #include @@ -9826,4 +9913,23 @@ A contrary analysis: https://hackaday.com/2024/02/29/the-white-house-memory-safety-appeal-is-a-security-red-herring/ + +From: Ian Fox +Date: Fri, 10 May 2024 22:11:41 +0200 +Subject: Article on C and memory safety +To: pabuhr@uwaterloo.ca + +Hi Dr. Buhr! + +I came across this + +article the other day which I thought made some excellent points, and it +reminded me of your C forall project (especially with regards to the part +about being able to opt in incrementally to the safety features while +rewriting a codebase) so I figured you might enjoy it if you hadn't seen it +already. + +All the best! +Ian + % Local Variables: % % tab-width: 4 % Index: src/AST/Pass.impl.hpp =================================================================== --- src/AST/Pass.impl.hpp (revision 236f13390c74aff36386095c9fc9fff394243822) +++ src/AST/Pass.impl.hpp (revision 9c447e225244a18c96cc4536ae39da1e56abe7b3) @@ -784,4 +784,5 @@ maybe_accept_top( node, &WhileDoStmt::cond ); maybe_accept_as_compound( node, &WhileDoStmt::body ); + maybe_accept_as_compound( node, &WhileDoStmt::else_ ); } @@ -804,4 +805,5 @@ maybe_accept_top( node, &ForStmt::range_over ); maybe_accept_as_compound( node, &ForStmt::body ); + maybe_accept_as_compound( node, &ForStmt::else_ ); }