Index: Jenkins/FullBuild =================================================================== --- Jenkins/FullBuild (revision a8e64c4029370bc62f193afaf75b9ad8e7f8a7df) +++ Jenkins/FullBuild (revision 0a208b842a9212f139dda75575089886452b6015) @@ -161,5 +161,5 @@ """ - def email_to = "pabuhr@uwaterloo.ca, rschlunt@uwaterloo.ca, a3moss@uwaterloo.ca, tdelisle@uwaterloo.ca, brice.dobry@huawei.com, ajbeach@edu.uwaterloo.ca" + def email_to = "cforall@lists.uwaterloo.ca" //send email notification Index: Jenkinsfile =================================================================== --- Jenkinsfile (revision a8e64c4029370bc62f193afaf75b9ad8e7f8a7df) +++ Jenkinsfile (revision 0a208b842a9212f139dda75575089886452b6015) @@ -374,5 +374,5 @@ """ - def email_to = "pabuhr@uwaterloo.ca, rschlunt@uwaterloo.ca, a3moss@uwaterloo.ca, tdelisle@uwaterloo.ca, brice.dobry@huawei.com, ajbeach@edu.uwaterloo.ca" + def email_to = "cforall@lists.uwaterloo.ca" //send email notification Index: doc/bibliography/cfa.bib =================================================================== --- doc/bibliography/cfa.bib (revision a8e64c4029370bc62f193afaf75b9ad8e7f8a7df) +++ doc/bibliography/cfa.bib (revision 0a208b842a9212f139dda75575089886452b6015) @@ -3035,4 +3035,14 @@ year = 1992, pages = {T1-53}, +} + +@manual{GMP, + keywords = {GMP arbitrary-precision library}, + contributer = {pabuhr@plg}, + title = {{GNU} Multiple Precision Arithmetic Library}, + author = {GMP}, + organization= {GNU}, + year = 2016, + note = {\href{https://gmplib.org}{https://\-gmplib.org}}, } Index: doc/user/user.tex =================================================================== --- doc/user/user.tex (revision a8e64c4029370bc62f193afaf75b9ad8e7f8a7df) +++ doc/user/user.tex (revision 0a208b842a9212f139dda75575089886452b6015) @@ -11,6 +11,6 @@ %% Created On : Wed Apr 6 14:53:29 2016 %% Last Modified By : Peter A. Buhr -%% Last Modified On : Sun May 21 23:36:42 2017 -%% Update Count : 1822 +%% Last Modified On : Wed May 24 22:21:42 2017 +%% Update Count : 1994 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% @@ -151,5 +151,5 @@ Like \Index*[C++]{\CC}, there may be both an old and new ways to achieve the same effect. -For example, the following programs compare the \CFA and C I/O mechanisms. +For example, the following programs compare the \CFA, C, nad \CC I/O mechanisms, where the programs output the same result. \begin{quote2} \begin{tabular}{@{}l@{\hspace{1.5em}}l@{\hspace{1.5em}}l@{}} @@ -183,5 +183,4 @@ \end{tabular} \end{quote2} -The programs output the same result. While the \CFA I/O looks similar to the \Index*[C++]{\CC} output style, there are important differences, such as automatic spacing between variables as in \Index*{Python} (see~\VRef{s:IOLibrary}). @@ -1426,5 +1425,28 @@ -\section{Type/Routine Nesting} +\section{Unnamed Structure Fields} + +C requires each field of a structure to have a name, except for a bit field associated with a basic type, \eg: +\begin{cfa} +struct { + int f1; §\C{// named field}§ + int f2 : 4; §\C{// named field with bit field size}§ + int : 3; §\C{// unnamed field for basic type with bit field size}§ + int ; §\C{// disallowed, unnamed field}§ + int *; §\C{// disallowed, unnamed field}§ + int (*)(int); §\C{// disallowed, unnamed field}§ +}; +\end{cfa} +This requirement is relaxed by making the field name optional for all field declarations; therefore, all the field declarations in the example are allowed. +As for unnamed bit fields, an unnamed field is used for padding a structure to a particular size. +A list of unnamed fields is also supported, \eg: +\begin{cfa} +struct { + int , , ; §\C{// 3 unnamed fields}§ +} +\end{cfa} + + +\section{Nesting} Nesting of types and routines is useful for controlling name visibility (\newterm{name hiding}). @@ -1796,27 +1818,4 @@ -\section{Unnamed Structure Fields} - -C requires each field of a structure to have a name, except for a bit field associated with a basic type, \eg: -\begin{cfa} -struct { - int f1; §\C{// named field}§ - int f2 : 4; §\C{// named field with bit field size}§ - int : 3; §\C{// unnamed field for basic type with bit field size}§ - int ; §\C{// disallowed, unnamed field}§ - int *; §\C{// disallowed, unnamed field}§ - int (*)(int); §\C{// disallowed, unnamed field}§ -}; -\end{cfa} -This requirement is relaxed by making the field name optional for all field declarations; therefore, all the field declarations in the example are allowed. -As for unnamed bit fields, an unnamed field is used for padding a structure to a particular size. -A list of unnamed fields is also supported, \eg: -\begin{cfa} -struct { - int , , ; §\C{// 3 unnamed fields}§ -} -\end{cfa} - - \section{Field Tuples} @@ -1861,58 +1860,33 @@ 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 ©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 ©continue©\index{continue@©continue©}\index{continue@©continue©!labelled}\index{labelled!continue@©continue©} and ©break©\index{break@©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,Java}. +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@©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,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. - -The following example shows the labelled ©continue© specifying which control structure is the target for the next loop iteration: -\begin{quote2} -\begin{tabular}{@{}l@{\hspace{3em}}l@{}} -\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}} & \multicolumn{1}{c}{\textbf{C}} \\ -\begin{cfa} -®L1:® do { - ®L2:® while ( ... ) { - ®L3:® for ( ... ) { - ... continue ®L1®; ... // continue do - ... continue ®L2®; ... // continue while - ... continue ®L3®; ... // continue for - } // for - } // while -} while ( ... ); -\end{cfa} -& -\begin{cfa} -do { - while ( ... ) { - for ( ... ) { - ... goto L1; ... - ... goto L2; ... - ... goto L3; ... - L3: ; } - L2: ; } -L1: ; } while ( ... ); -\end{cfa} -\end{tabular} -\end{quote2} -The innermost loop has three restart points, which cause the next loop iteration to begin. - -The following example shows the labelled ©break© specifying which control structure is the target for exit: -\begin{quote2} -\begin{tabular}{@{}l@{\hspace{3em}}l@{}} -\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}} & \multicolumn{1}{c}{\textbf{C}} \\ -\begin{cfa} -®L1:® { +\VRef[Figure]{f:MultiLevelResumeTermination} shows the labelled ©continue© and ©break©, specifying which control structure is the target for exit, and the corresponding C program using only ©goto©. +The innermost loop has 7 exit points, which cause resumption or termination of one or more of the 7 \Index{nested control-structure}s. + +\begin{figure} +\begin{tabular}{@{\hspace{\parindentlnth}}l@{\hspace{1.5em}}l@{}} +\multicolumn{1}{c@{\hspace{1.5em}}}{\textbf{\CFA}} & \multicolumn{1}{c}{\textbf{C}} \\ +\begin{cfa} +®LC:® { ... §declarations§ ... - ®L2:® switch ( ... ) { + ®LS:® switch ( ... ) { case 3: - ®L3:® if ( ... ) { - ®L4:® for ( ... ) { - ... break ®L1®; ... // exit compound statement - ... break ®L2®; ... // exit switch - ... break ®L3®; ... // exit if - ... break ®L4®; ... // exit loop + ®LIF:® if ( ... ) { + ®LF:® for ( ... ) { + ®LW:® while ( ... ) { + ... break ®LC®; ... // terminate compound + ... break ®LS®; ... // terminate switch + ... break ®LIF®; ... // terminate if + ... continue ®LF;® ... // resume loop + ... break ®LF®; ... // terminate loop + ... continue ®LW®; ... // resume loop + ... break ®LW®; ... // terminate loop + } // while } // for } else { - ... break ®L3®; ... // exit if + ... break ®LIF®; ... // terminate if } // if } // switch @@ -1925,31 +1899,37 @@ switch ( ... ) { case 3: - if ( ... ) { + if ( ... ) { for ( ... ) { - ... goto L1; ... - ... goto L2; ... - ... goto L3; ... - ... goto L4; ... - } L4: ; + for ( ... ) { + ... goto ®LC®; ... + ... goto ®LS®; ... + ... goto ®LIF®; ... + ... goto ®LFC®; ... + ... goto ®LFB®; ... + ... goto ®LWC®; ... + ... goto ®LWB®; ... + ®LWC®: ; } ®LWB:® ; + ®LFC:® ; } ®LFB:® ; } else { - ... goto L3; ... - } L3: ; - } L2: ; -} L1: ; + ... goto ®LIF®; ... + } ®L3:® ; + } ®LS:® ; +} ®LC:® ; \end{cfa} \end{tabular} -\end{quote2} -The innermost loop has four exit points, which cause termination of one or more of the four \Index{nested control structure}s. - -Both ©continue© and ©break© with target labels are simply a ©goto©\index{goto@©goto©!restricted} restricted in the following ways: +\caption{Multi-level Resume/Termination} +\label{f:MultiLevelResumeTermination} +\end{figure} + +Both labelled ©continue© and ©break© are a ©goto©\index{goto@©goto©!restricted} restricted in the following ways: \begin{itemize} \item -They cannot be used to create a loop. -This means that only the looping construct can be used to create a loop. -This restriction is important since all situations that can result in repeated execution of statements in a program are clearly delineated. -\item -Since they always transfer out of containing control structures, they cannot be used to branch into a control structure. +They cannot create a loop, which means only the looping constructs cause looping. +This restriction means all situations resulting in repeated execution are clearly delineated. +\item +They cannot branch into a control structure. +This restriction prevents missing initialization at the start of a control structure resulting in undefined behaviour. \end{itemize} -The advantage of the labelled ©continue©/©break© is allowing static multi-level exits without having to use the ©goto© statement and tying control flow to the target control structure rather than an arbitrary point in a program. +The advantage of the labelled ©continue©/©break© is allowing static multi-level exits without having to use the ©goto© statement, and tying control flow to the target control structure rather than an arbitrary point in a program. Furthermore, the location of the label at the \emph{beginning} of the target control structure informs the reader that complex control-flow is occurring in the body of the control structure. With ©goto©, the label is at the end of the control structure, which fails to convey this important clue early enough to the reader. @@ -2268,5 +2248,5 @@ \index{input/output library} -The goal for the \CFA I/O is to make I/O as simple as possible in the common cases, while fully supporting polymorphism and user defined types in a consistent way. +The goal of \CFA I/O is to simplify the common cases\index{I/O!common case}, while fully supporting polymorphism and user defined types in a consistent way. The common case is printing out a sequence of variables separated by whitespace. \begin{quote2} @@ -2274,5 +2254,5 @@ \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}} & \multicolumn{1}{c}{\textbf{\CC}} \\ \begin{cfa} -int x = 0, y = 1, z = 2; +int x = 1, y = 2, z = 3; sout | x ®|® y ®|® z | endl; \end{cfa} @@ -2281,10 +2261,25 @@ cout << x ®<< " "® << y ®<< " "® << z << endl; +\end{cfa} +\\ +\begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt] +1 2 3 +\end{cfa} +& +\begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt] +1 2 3 \end{cfa} \end{tabular} \end{quote2} The \CFA form has half as many characters as the \CC form, and is similar to \Index*{Python} I/O with respect to implicit separators. - -The logical-or operator is used because it is the lowest-priority overloadable operator, other than assignment. +A tuple prints all the tuple's values, each separated by ©", "©. +\begin{cfa}[mathescape=off,aboveskip=0pt,belowskip=0pt] +[int, int] t1 = [1, 2], t2 = [3, 4]; +sout | t1 | t2 | endl; §\C{// print tuples}§ +\end{cfa} +\begin{cfa}[mathescape=off,showspaces=true,belowskip=0pt] +1, 2, 3, 4 +\end{cfa} +\CFA uses the logical-or operator for I/O because it is the lowest-priority overloadable operator, other than assignment. Therefore, fewer output expressions require parenthesis. \begin{quote2} @@ -2299,5 +2294,10 @@ & \begin{cfa} -cout << x * 3 << y + 1 << (z << 2) << (x == y) << (x | y) << (x || y) << (x > z ? 1 : 2) << endl; +cout << x * 3 << y + 1 << ®(®z << 2®)® << ®(®x == y®)® << (x | y) << (x || y) << (x > z ? 1 : 2) << endl; +\end{cfa} +\\ +& +\begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt] +3 3 12 0 3 1 2 \end{cfa} \end{tabular} @@ -2305,4 +2305,5 @@ Finally, the logical-or operator has a link with the Shell pipe-operator for moving data, where data flows in the correct direction for input but the opposite direction for output. + The implicit separator\index{I/O separator} character (space/blank) is a separator not a terminator. The rules for implicitly adding the separator are: @@ -2316,4 +2317,5 @@ 1 2 3 \end{cfa} + \item A separator does not appear before or after a character literal or variable. @@ -2322,6 +2324,7 @@ 123 \end{cfa} -\item -A separator does not appear before or after a null (empty) C string + +\item +A separator does not appear before or after a null (empty) C string. \begin{cfa} sout | 1 | "" | 2 | "" | 3 | endl; @@ -2329,6 +2332,7 @@ \end{cfa} which is a local mechanism to disable insertion of the separator character. -\item -A separator does not appear before a C string starting with the (extended) \Index{ASCII}\index{ASCII!extended} characters: \lstinline[mathescape=off]@([{=$£¥¡¿«@ + +\item +A separator does not appear before a C string starting with the (extended) \Index{ASCII}\index{ASCII!extended} characters: \lstinline[mathescape=off,basicstyle=\tt]@([{=$£¥¡¿«@ %$ \begin{cfa}[mathescape=off] @@ -2337,29 +2341,64 @@ \end{cfa} %$ -\begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt] -x (1 x [2 x {3 x =4 x $5 x £6 x ¥7 x ¡8 x ¿9 x «10 +\begin{cfa}[mathescape=off,basicstyle=\tt,showspaces=true,aboveskip=0pt,belowskip=0pt] +x ®(®1 x ®[®2 x ®{®3 x ®=®4 x ®$®5 x ®£®6 x ®¥®7 x ®¡®8 x ®¿®9 x ®«®10 \end{cfa} %$ +where \lstinline[basicstyle=\tt]@¡¿@ are inverted opening exclamation and question marks, and \lstinline[basicstyle=\tt]@«@ is an opening citation mark. + \item {\lstset{language=CFA,deletedelim=**[is][]{¢}{¢}} -A seperator does not appear after a C string ending with the (extended) \Index{ASCII}\index{ASCII!extended} characters: ©,.;!?)]}%¢»© +A seperator does not appear after a C string ending with the (extended) \Index{ASCII}\index{ASCII!extended} characters: \lstinline[basicstyle=\tt]@,.;!?)]}%¢»@ \begin{cfa}[belowskip=0pt] sout | 1 | ", x" | 2 | ". x" | 3 | "; x" | 4 | "! x" | 5 | "? x" | 6 | "% x" | 7 | "¢ x" | 8 | "» x" | 9 | ") x" | 10 | "] x" | 11 | "} x" | endl; \end{cfa} -\begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt] -1, x 2. x 3; x 4! x 5? x 6% x 7§\textcent§ x 8» x 9) x 10] x 11} x +\begin{cfa}[basicstyle=\tt,showspaces=true,aboveskip=0pt,belowskip=0pt] +1®,® x 2®.® x 3®;® x 4®!® x 5®?® x 6®%® x 7§\color{red}\textcent§ x 8®»® x 9®)® x 10®]® x 11®}® x \end{cfa}}% -\item -A seperator does not appear before or after a C string begining/ending with the \Index{ASCII} quote or whitespace characters: \lstinline[showspaces=true]@`'": \t\v\f\r\n@ +where \lstinline[basicstyle=\tt]@»@ is a closing citation mark. + +\item +A seperator does not appear before or after a C string begining/ending with the \Index{ASCII} quote or whitespace characters: \lstinline[basicstyle=\tt,showspaces=true]@`'": \t\v\f\r\n@ \begin{cfa}[belowskip=0pt] sout | "x`" | 1 | "`x'" | 2 | "'x\"" | 3 | "\"x:" | 4 | ":x " | 5 | " x\t" | 6 | "\tx" | endl; \end{cfa} -\begin{cfa}[mathescape=off,showspaces=true,showtabs=true,aboveskip=0pt,belowskip=0pt] -x`1`x'2'x"3"x:4:x 5 x 6 x +\begin{cfa}[basicstyle=\tt,showspaces=true,showtabs=true,aboveskip=0pt,belowskip=0pt] +x®`®1®`®x§\color{red}\texttt{'}§2§\color{red}\texttt{'}§x§\color{red}\texttt{"}§3§\color{red}\texttt{"}§x®:®4®:®x® ®5® ®x® ®6® ®x +\end{cfa} + +\item +If a space is desired before or after one of the special string start/end characters, simply insert a space. +\begin{cfa}[belowskip=0pt] +sout | "x (§\color{red}\texttt{\textvisiblespace}§" | 1 | "§\color{red}\texttt{\textvisiblespace}§) x" | 2 | "§\color{red}\texttt{\textvisiblespace}§, x" | 3 | "§\color{red}\texttt{\textvisiblespace}§:x:§\color{red}\texttt{\textvisiblespace}§" | 4 | endl; +\end{cfa} +\begin{cfa}[basicstyle=\tt,showspaces=true,showtabs=true,aboveskip=0pt,belowskip=0pt] +x (® ®1® ®) x 2® ®, x 3® ®:x:® ®4 \end{cfa} \end{enumerate} -The following \CC-style \Index{manipulator}s allow control over implicit seperation. +The following routines and \CC-style \Index{manipulator}s control implicit seperation. +\begin{enumerate} +\item +Routines \Indexc{sepSet}\index{manipulator!sepSet@©sepSet©} and \Indexc{sepGet}\index{manipulator!sepGet@©sepGet©} set and get the separator string. +The separator string can be at most 16 characters including the ©'\0'© string terminator (15 printable characters). +\begin{cfa}[mathescape=off,aboveskip=0pt,belowskip=0pt] +sepSet( sout, ", $" ); §\C{// set separator from " " to ", \$"}§ +sout | 1 | 2 | 3 | " \"" | ®sepGet( sout )® | "\"" | endl; +\end{cfa} +%$ +\begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt] +1, $2, $3 ®", $"® +\end{cfa} +%$ +\begin{cfa}[mathescape=off,aboveskip=0pt,belowskip=0pt] +sepSet( sout, " " ); §\C{// reset separator to " "}§ +sout | 1 | 2 | 3 | " \"" | ®sepGet( sout )® | "\"" | endl; +\end{cfa} +\begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt] +1 2 3 ®" "® +\end{cfa} + +\item Manipulators \Indexc{sepOn}\index{manipulator!sepOn@©sepOn©} and \Indexc{sepOff}\index{manipulator!sepOff@©sepOff©} \emph{locally} toggle printing the separator, \ie the seperator is adjusted only with respect to the next printed item. \begin{cfa}[mathescape=off,belowskip=0pt] @@ -2375,4 +2414,6 @@ 12 3 \end{cfa} + +\item Manipulators \Indexc{sepDisable}\index{manipulator!sepDisable@©sepDisable©} and \Indexc{sepEnable}\index{manipulator!sepEnable@©sepEnable©} \emph{globally} toggle printing the separator, \ie the seperator is adjusted with respect to all subsequent printed items, unless locally adjusted. \begin{cfa}[mathescape=off,aboveskip=0pt,belowskip=0pt] @@ -2394,51 +2435,33 @@ 1 2 3 \end{cfa} -Printing a tuple outputs all the tuple's values separated by ©", "©: + +\item +Routine \Indexc{sepSetTuple}\index{manipulator!sepSetTuple@©sepSetTuple©} and \Indexc{sepGetTuple}\index{manipulator!sepGetTuple@©sepGetTuple©} get and set the tuple separator-string. +The tuple separator-string can be at most 16 characters including the ©'\0'© string terminator (15 printable characters). \begin{cfa}[mathescape=off,aboveskip=0pt,belowskip=0pt] -sout | [2, 3] | [4, 5] | endl; §\C{// print tuple}§ +sepSetTuple( sout, " " ); §\C{// set tuple separator from ", " to " "}§ +sout | t1 | t2 | " \"" | ®sepGetTuple( sout )® | "\"" | endl; +\end{cfa} +\begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt] +1 2 3 4 ®" "® +\end{cfa} +\begin{cfa}[mathescape=off,aboveskip=0pt,belowskip=0pt] +sepSetTuple( sout, ", " ); §\C{// reset tuple separator to ", "}§ +sout | t1 | t2 | " \"" | ®sepGetTuple( sout )® | "\"" | endl; +\end{cfa} +\begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt] +1, 2, 3, 4 ®", "® +\end{cfa} + +\item +The tuple separator can also be turned on and off. +\begin{cfa}[mathescape=off,aboveskip=0pt,belowskip=0pt] +sout | sepOn | t1 | sepOff | t2 | endl; §\C{// locally turn on/off implicit separation}§ \end{cfa} \begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt] -2, 3, 4, 5 -\end{cfa} -The tuple separator can also be turned on and off: -\begin{cfa}[mathescape=off,aboveskip=0pt,belowskip=0pt] -sout | sepOn | [2, 3] | sepOff | [4, 5] | endl; §\C{// locally turn on/off implicit separation}§ -\end{cfa} -\begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt] -, 2, 34, 5 +, 1, 23, 4 \end{cfa} Notice a tuple seperator starts the line because the next item is a tuple. -Finally, the stream routines \Indexc{sepGet}\index{manipulator!sepGet@©sepGet©} and \Indexc{sepSet}\index{manipulator!sepSet@©sepSet©} get and set the basic separator-string. -\begin{cfa}[mathescape=off,aboveskip=0pt,aboveskip=0pt,belowskip=0pt] -sepSet( sout, ", $" ); §\C{// set separator from " " to ", \$"}§ -sout | 1 | 2 | 3 | " \"" | sepGet( sout ) | "\"" | endl; -\end{cfa} -%$ -\begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt] -1, $2, $3 ", $" -\end{cfa} -%$ -\begin{cfa}[mathescape=off,aboveskip=0pt,aboveskip=0pt,belowskip=0pt] -sepSet( sout, " " ); §\C{// reset separator to " "}§ -sout | 1 | 2 | 3 | " \"" | sepGet( sout ) | "\"" | endl; -\end{cfa} -\begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt] -1 2 3 " " -\end{cfa} -and the stream routines \Indexc{sepGetTuple}\index{manipulator!sepGetTuple@©sepGetTuple©} and \Indexc{sepSetTuple}\index{manipulator!sepSetTuple@©sepSetTuple©} get and set the tuple separator-string. -\begin{cfa}[mathescape=off,aboveskip=0pt,aboveskip=0pt,belowskip=0pt] -sepSetTuple( sout, " " ); §\C{// set tuple separator from ", " to " "}§ -sout | [2, 3] | [4, 5] | " \"" | sepGetTuple( sout ) | "\"" | endl; -\end{cfa} -\begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt] -2 3 4 5 " " -\end{cfa} -\begin{cfa}[mathescape=off,aboveskip=0pt,aboveskip=0pt,belowskip=0pt] -sepSetTuple( sout, ", " ); §\C{// reset tuple separator to ", "}§ -sout | [2, 3] | [4, 5] | " \"" | sepGetTuple( sout ) | "\"" | endl; -\end{cfa} -\begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt] -2, 3, 4, 5 ", " -\end{cfa} +\end{enumerate} \begin{comment} @@ -2446,6 +2469,9 @@ int main( void ) { - int x = 0, y = 1, z = 2; - sout | x * 3 | y + 1 | z << 2 | x == y | (x | y) | (x || y) | (x > z ? 1 : 2) | endl | endl; + int x = 1, y = 2, z = 3; + sout | x | y | z | endl; + [int, int] t1 = [1, 2], t2 = [3, 4]; + sout | t1 | t2 | endl; // print tuple + sout | x * 3 | y + 1 | z << 2 | x == y | (x | y) | (x || y) | (x > z ? 1 : 2) | endl; sout | 1 | 2 | 3 | endl; sout | '1' | '2' | '3' | endl; @@ -2456,13 +2482,5 @@ | 7 | "¢ x" | 8 | "» x" | 9 | ") x" | 10 | "] x" | 11 | "} x" | endl; sout | "x`" | 1 | "`x'" | 2 | "'x\"" | 3 | "\"x:" | 4 | ":x " | 5 | " x\t" | 6 | "\tx" | endl; - - sout | sepOn | 1 | 2 | 3 | sepOn | endl; // separator at start of line - sout | 1 | sepOff | 2 | 3 | endl; // locally turn off implicit separator - sout | sepDisable | 1 | 2 | 3 | endl; // globally turn off implicit separation - sout | 1 | sepOn | 2 | 3 | endl; // locally turn on implicit separator - sout | sepEnable | 1 | 2 | 3 | endl; // globally turn on implicit separation - - sout | [2, 3] | [4, 5] | endl; // print tuple - sout | sepOn | [2, 3] | sepOff | [4, 5] | endl; // locally turn on/off implicit separation + sout | "x ( " | 1 | " ) x" | 2 | " , x" | 3 | " :x: " | 4 | endl; sepSet( sout, ", $" ); // set separator from " " to ", $" @@ -2471,12 +2489,23 @@ sout | 1 | 2 | 3 | " \"" | sepGet( sout ) | "\"" | endl; + sout | sepOn | 1 | 2 | 3 | sepOn | endl; // separator at start of line + sout | 1 | sepOff | 2 | 3 | endl; // locally turn off implicit separator + + sout | sepDisable | 1 | 2 | 3 | endl; // globally turn off implicit separation + sout | 1 | sepOn | 2 | 3 | endl; // locally turn on implicit separator + sout | sepEnable | 1 | 2 | 3 | endl; // globally turn on implicit separation + sepSetTuple( sout, " " ); // set tuple separator from ", " to " " - sout | [2, 3] | [4, 5] | " \"" | sepGetTuple( sout ) | "\"" | endl; + sout | t1 | t2 | " \"" | sepGetTuple( sout ) | "\"" | endl; sepSetTuple( sout, ", " ); // reset tuple separator to ", " - sout | [2, 3] | [4, 5] | " \"" | sepGetTuple( sout ) | "\"" | endl; + sout | t1 | t2 | " \"" | sepGetTuple( sout ) | "\"" | endl; + + sout | t1 | t2 | endl; // print tuple + sout | sepOn | t1 | sepOff | t2 | endl; // locally turn on/off implicit separation } // Local Variables: // // tab-width: 4 // +// fill-column: 100 // // End: // \end{comment} @@ -2972,5 +3001,5 @@ generic (type T | bool ??( T, T ); } ) -T max( const T t1, const T t2 );§\indexc{max}§ +T max( T t1, T t2 );§\indexc{max}§ forall( otype T | { T min( T, T ); T max( T, T ); } ) @@ -5232,5 +5307,5 @@ \label{s:Math Library} -The \CFA math-library wraps many existing explicitly-polymorphic C math-routines into implicitly-polymorphic versions. +The \CFA math-library wraps explicitly-polymorphic C math-routines into implicitly-polymorphic versions. @@ -5239,11 +5314,4 @@ \leavevmode \begin{cfa}[aboveskip=0pt,belowskip=0pt] -float fabs( float );§\indexc{fabs}§ -double fabs( double ); -long double fabs( long double ); -float cabs( float _Complex ); -double cabs( double _Complex ); -long double cabs( long double _Complex ); - float ?%?( float, float );§\indexc{fmod}§ float fmod( float, float ); @@ -5600,4 +5668,258 @@ +\section{Multi-precision Integers} +\label{s:MultiPrecisionIntegers} + +\CFA has an interface to the \Index{GMP} \Index{multi-precision} signed-integers~\cite{GMP}, similar to the \CC interface provided by GMP. +The \CFA interface wraps GMP routines into operator routines to make programming with multi-precision integers identical to using fixed-sized integers. +The \CFA type name for multi-precision signed-integers is \Indexc{Int}. + +\begin{cfa} +void ?{}( Int * this ); §\C{// constructor}§ +void ?{}( Int * this, Int init ); +void ?{}( Int * this, zero_t ); +void ?{}( Int * this, one_t ); +void ?{}( Int * this, signed long int init ); +void ?{}( Int * this, unsigned long int init ); +void ?{}( Int * this, const char * val ); +void ^?{}( Int * this ); + +Int ?=?( Int * lhs, Int rhs ); §\C{// assignment}§ +Int ?=?( Int * lhs, long int rhs ); +Int ?=?( Int * lhs, unsigned long int rhs ); +Int ?=?( Int * lhs, const char * rhs ); + +char ?=?( char * lhs, Int rhs ); +short int ?=?( short int * lhs, Int rhs ); +int ?=?( int * lhs, Int rhs ); +long int ?=?( long int * lhs, Int rhs ); +unsigned char ?=?( unsigned char * lhs, Int rhs ); +unsigned short int ?=?( unsigned short int * lhs, Int rhs ); +unsigned int ?=?( unsigned int * lhs, Int rhs ); +unsigned long int ?=?( unsigned long int * lhs, Int rhs ); + +long int narrow( Int val ); +unsigned long int narrow( Int val ); + +int ?==?( Int oper1, Int oper2 ); §\C{// comparison}§ +int ?==?( Int oper1, long int oper2 ); +int ?==?( long int oper2, Int oper1 ); +int ?==?( Int oper1, unsigned long int oper2 ); +int ?==?( unsigned long int oper2, Int oper1 ); + +int ?!=?( Int oper1, Int oper2 ); +int ?!=?( Int oper1, long int oper2 ); +int ?!=?( long int oper1, Int oper2 ); +int ?!=?( Int oper1, unsigned long int oper2 ); +int ?!=?( unsigned long int oper1, Int oper2 ); + +int ??( Int oper1, Int oper2 ); +int ?>?( Int oper1, long int oper2 ); +int ?>?( long int oper1, Int oper2 ); +int ?>?( Int oper1, unsigned long int oper2 ); +int ?>?( unsigned long int oper1, Int oper2 ); + +int ?>=?( Int oper1, Int oper2 ); +int ?>=?( Int oper1, long int oper2 ); +int ?>=?( long int oper1, Int oper2 ); +int ?>=?( Int oper1, unsigned long int oper2 ); +int ?>=?( unsigned long int oper1, Int oper2 ); + +Int +?( Int oper ); §\C{// arithmetic}§ +Int -?( Int oper ); +Int ~?( Int oper ); + +Int ?&?( Int oper1, Int oper2 ); +Int ?&?( Int oper1, long int oper2 ); +Int ?&?( long int oper1, Int oper2 ); +Int ?&?( Int oper1, unsigned long int oper2 ); +Int ?&?( unsigned long int oper1, Int oper2 ); +Int ?&=?( Int * lhs, Int rhs ); + +Int ?|?( Int oper1, Int oper2 ); +Int ?|?( Int oper1, long int oper2 ); +Int ?|?( long int oper1, Int oper2 ); +Int ?|?( Int oper1, unsigned long int oper2 ); +Int ?|?( unsigned long int oper1, Int oper2 ); +Int ?|=?( Int * lhs, Int rhs ); + +Int ?^?( Int oper1, Int oper2 ); +Int ?^?( Int oper1, long int oper2 ); +Int ?^?( long int oper1, Int oper2 ); +Int ?^?( Int oper1, unsigned long int oper2 ); +Int ?^?( unsigned long int oper1, Int oper2 ); +Int ?^=?( Int * lhs, Int rhs ); + +Int ?+?( Int addend1, Int addend2 ); +Int ?+?( Int addend1, long int addend2 ); +Int ?+?( long int addend2, Int addend1 ); +Int ?+?( Int addend1, unsigned long int addend2 ); +Int ?+?( unsigned long int addend2, Int addend1 ); +Int ?+=?( Int * lhs, Int rhs ); +Int ?+=?( Int * lhs, long int rhs ); +Int ?+=?( Int * lhs, unsigned long int rhs ); +Int ++?( Int * lhs ); +Int ?++( Int * lhs ); + +Int ?-?( Int minuend, Int subtrahend ); +Int ?-?( Int minuend, long int subtrahend ); +Int ?-?( long int minuend, Int subtrahend ); +Int ?-?( Int minuend, unsigned long int subtrahend ); +Int ?-?( unsigned long int minuend, Int subtrahend ); +Int ?-=?( Int * lhs, Int rhs ); +Int ?-=?( Int * lhs, long int rhs ); +Int ?-=?( Int * lhs, unsigned long int rhs ); +Int --?( Int * lhs ); +Int ?--( Int * lhs ); + +Int ?*?( Int multiplicator, Int multiplicand ); +Int ?*?( Int multiplicator, long int multiplicand ); +Int ?*?( long int multiplicand, Int multiplicator ); +Int ?*?( Int multiplicator, unsigned long int multiplicand ); +Int ?*?( unsigned long int multiplicand, Int multiplicator ); +Int ?*=?( Int * lhs, Int rhs ); +Int ?*=?( Int * lhs, long int rhs ); +Int ?*=?( Int * lhs, unsigned long int rhs ); + +Int ?/?( Int dividend, Int divisor ); +Int ?/?( Int dividend, unsigned long int divisor ); +Int ?/?( unsigned long int dividend, Int divisor ); +Int ?/?( Int dividend, long int divisor ); +Int ?/?( long int dividend, Int divisor ); +Int ?/=?( Int * lhs, Int rhs ); +Int ?/=?( Int * lhs, long int rhs ); +Int ?/=?( Int * lhs, unsigned long int rhs ); + +[ Int, Int ] div( Int dividend, Int divisor ); +[ Int, Int ] div( Int dividend, unsigned long int divisor ); + +Int ?%?( Int dividend, Int divisor ); +Int ?%?( Int dividend, unsigned long int divisor ); +Int ?%?( unsigned long int dividend, Int divisor ); +Int ?%?( Int dividend, long int divisor ); +Int ?%?( long int dividend, Int divisor ); +Int ?%=?( Int * lhs, Int rhs ); +Int ?%=?( Int * lhs, long int rhs ); +Int ?%=?( Int * lhs, unsigned long int rhs ); + +Int ?<>?( Int shiften, mp_bitcnt_t shift ); +Int ?>>=?( Int * lhs, mp_bitcnt_t shift ); + +Int abs( Int oper ); §\C{// number functions}§ +Int fact( unsigned long int N ); +Int gcd( Int oper1, Int oper2 ); +Int pow( Int base, unsigned long int exponent ); +Int pow( unsigned long int base, unsigned long int exponent ); +void srandom( gmp_randstate_t state ); +Int random( gmp_randstate_t state, mp_bitcnt_t n ); +Int random( gmp_randstate_t state, Int n ); +Int random( gmp_randstate_t state, mp_size_t max_size ); +int sgn( Int oper ); +Int sqrt( Int oper ); + +forall( dtype istype | istream( istype ) ) istype * ?|?( istype * is, Int * mp ); §\C{// I/O}§ +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}. +(Compile with flag \Indexc{-lgmp} to link with the GMP library.) +\begin{quote2} +\begin{tabular}{@{}l@{\hspace{\parindentlnth}}|@{\hspace{\parindentlnth}}l@{}} +\multicolumn{1}{c|@{\hspace{\parindentlnth}}}{\textbf{\CFA}} & \multicolumn{1}{@{\hspace{\parindentlnth}}c}{\textbf{C}} \\ +\hline +\begin{cfa} +#include +int main( void ) { + sout | "Factorial Numbers" | endl; + Int fact; + fact = 1; + sout | 0 | fact | endl; + for ( unsigned int i = 1; i <= 40; i += 1 ) { + fact *= i; + sout | i | fact | endl; + } +} +\end{cfa} +& +\begin{cfa} +#include +int main( void ) { + ®gmp_printf®( "Factorial Numbers\n" ); + ®mpz_t® fact; + ®mpz_init_set_ui®( fact, 1 ); + ®gmp_printf®( "%d %Zd\n", 0, fact ); + for ( unsigned int i = 1; i <= 40; i += 1 ) { + ®mpz_mul_ui®( fact, fact, i ); + ®gmp_printf®( "%d %Zd\n", i, fact ); + } +} +\end{cfa} +\end{tabular} +\end{quote2} + +\begin{figure} +\begin{cfa} +Factorial Numbers +0 1 +1 1 +2 2 +3 6 +4 24 +5 120 +6 720 +7 5040 +8 40320 +9 362880 +10 3628800 +11 39916800 +12 479001600 +13 6227020800 +14 87178291200 +15 1307674368000 +16 20922789888000 +17 355687428096000 +18 6402373705728000 +19 121645100408832000 +20 2432902008176640000 +21 51090942171709440000 +22 1124000727777607680000 +23 25852016738884976640000 +24 620448401733239439360000 +25 15511210043330985984000000 +26 403291461126605635584000000 +27 10888869450418352160768000000 +28 304888344611713860501504000000 +29 8841761993739701954543616000000 +30 265252859812191058636308480000000 +31 8222838654177922817725562880000000 +32 263130836933693530167218012160000000 +33 8683317618811886495518194401280000000 +34 295232799039604140847618609643520000000 +35 10333147966386144929666651337523200000000 +36 371993326789901217467999448150835200000000 +37 13763753091226345046315979581580902400000000 +38 523022617466601111760007224100074291200000000 +39 20397882081197443358640281739902897356800000000 +40 815915283247897734345611269596115894272000000000 +\end{cfa} +\caption{Multi-precision Factorials} +\label{f:MultiPrecisionFactorials} +\end{figure} + + \section{Rational Numbers} \label{s:RationalNumbers} @@ -5612,21 +5934,16 @@ }; // Rational -// constants -extern struct Rational 0; -extern struct Rational 1; - -// constructors -Rational rational(); +Rational rational(); §\C{// constructors}§ Rational rational( long int n ); Rational rational( long int n, long int d ); - -// getter/setter for numerator/denominator -long int numerator( Rational r ); +void ?{}( Rational * r, zero_t ); +void ?{}( Rational * r, one_t ); + +long int numerator( Rational r ); §\C{// numerator/denominator getter/setter}§ long int numerator( Rational r, long int n ); long int denominator( Rational r ); long int denominator( Rational r, long int d ); -// comparison -int ?==?( Rational l, Rational r ); +int ?==?( Rational l, Rational r ); §\C{// comparison}§ int ?!=?( Rational l, Rational r ); int ?=?( Rational l, Rational r ); -// arithmetic -Rational -?( Rational r ); +Rational -?( Rational r ); §\C{// arithmetic}§ Rational ?+?( Rational l, Rational r ); Rational ?-?( Rational l, Rational r ); @@ -5642,10 +5958,8 @@ Rational ?/?( Rational l, Rational r ); -// conversion -double widen( Rational r ); +double widen( Rational r ); §\C{// conversion}§ Rational narrow( double f, long int md ); -// I/O -forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, Rational * ); +forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, Rational * ); // I/O forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, Rational ); \end{cfa} Index: src/Parser/lex.ll =================================================================== --- src/Parser/lex.ll (revision a8e64c4029370bc62f193afaf75b9ad8e7f8a7df) +++ src/Parser/lex.ll (revision 0a208b842a9212f139dda75575089886452b6015) @@ -10,6 +10,6 @@ * Created On : Sat Sep 22 08:58:10 2001 * Last Modified By : Peter A. Buhr - * Last Modified On : Thu May 18 09:03:49 2017 - * Update Count : 513 + * Last Modified On : Mon May 22 07:46:30 2017 + * Update Count : 525 */ @@ -377,30 +377,30 @@ "?"{op_binary_over}"?" { IDENTIFIER_RETURN(); } // binary /* - This rule handles ambiguous cases with operator identifiers, e.g., "int *?*?()", where the string "*?*?" - can be lexed as "*"/"?*?" or "*?"/"*?". Since it is common practise to put a unary operator juxtaposed - to an identifier, e.g., "*i", users will be annoyed if they cannot do this with respect to operator - identifiers. Even with this special hack, there are 5 general cases that cannot be handled. The first - case is for the function-call identifier "?()": - - int * ?()(); // declaration: space required after '*' - * ?()(); // expression: space required after '*' - - Without the space, the string "*?()" is ambiguous without N character look ahead; it requires scanning - ahead to determine if there is a '(', which is the start of an argument/parameter list. - - The 4 remaining cases occur in expressions: - - i++?i:0; // space required before '?' - i--?i:0; // space required before '?' - i?++i:0; // space required after '?' - i?--i:0; // space required after '?' - - In the first two cases, the string "i++?" is ambiguous, where this string can be lexed as "i"/"++?" or - "i++"/"?"; it requires scanning ahead to determine if there is a '(', which is the start of an argument - list. In the second two cases, the string "?++x" is ambiguous, where this string can be lexed as - "?++"/"x" or "?"/"++x"; it requires scanning ahead to determine if there is a '(', which is the start of - an argument list. + This rule handles ambiguous cases with operator identifiers, e.g., "int *?*?()", where the string "*?*?" can be + lexed as "*?"/"*?" or "*"/"?*?". Since it is common practise to put a unary operator juxtaposed to an identifier, + e.g., "*i", users will be annoyed if they cannot do this with respect to operator identifiers. Therefore, there is + a lexical look-ahead for the second case, with backtracking to return the leading unary operator and then + reparsing the trailing operator identifier. Otherwise a space is needed between the unary operator and operator + identifier to disambiguate this common case. + + A similar issue occurs with the dereference, *?(...), and routine-call, ?()(...) identifiers. The ambiguity + occurs when the deference operator has no parameters, *?() and *?()(...), requiring arbitrary whitespace + look-ahead for the routine-call parameter-list to disambiguate. However, the dereference operator must have a + parameter/argument to dereference *?(...). Hence, always interpreting the string *?() as * ?() does not preclude + any meaningful program. + + The remaining cases are with the increment/decrement operators and conditional expression: + + i++? ...(...); + i?++ ...(...); + + requiring arbitrary whitespace look-ahead for the operator parameter-list, even though that interpretation is an + incorrect expression (juxtaposed identifiers). Therefore, it is necessary to disambiguate these cases with a + space: + + i++ ? i : 0; + i? ++i : 0; */ -{op_unary}"?"({op_unary_pre_post}|"[?]"|{op_binary_over}"?") { +{op_unary}"?"({op_unary_pre_post}|"()"|"[?]"|{op_binary_over}"?") { // 1 or 2 character unary operator ? int i = yytext[1] == '?' ? 1 : 2; Index: src/libcfa/containers/maybe =================================================================== --- src/libcfa/containers/maybe (revision 0a208b842a9212f139dda75575089886452b6015) +++ src/libcfa/containers/maybe (revision 0a208b842a9212f139dda75575089886452b6015) @@ -0,0 +1,56 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// maybe -- May contain a value. +// +// Author : Andrew Beach +// Created On : Wed May 25 14:43:00 2017 +// Last Modified By : Andrew Beach +// Last Modified On : Wed Apr 25 16:58:00 2017 +// Update Count : 1 +// + + +#ifndef MAYBE_H +#define MAYBE_H + + +// DO NOT USE DIRECTLY! +forall(otype T) +struct maybe { + _Bool has_value; + T value; +}; + + +forall(otype T) +void ?{}(maybe(T) * this); + +forall(otype T) +void ?{}(maybe(T) * this, T value); + +forall(otype T) +void ?{}(maybe(T) * this, maybe(T) other); + +forall(otype T) +void ^?{}(maybe(T) * this); + +forall(otype T) +_Bool ?!=?(result(T, E) this, zero_t); + +forall(otype T) +maybe(T) maybe_value(T value); + +forall(otype T) +maybe(T) maybe_none(); + +forall(otype T) +_Bool has_value(maybe(T) * this); + +forall(otype T) +T get(maybe(T) * this); + +#endif // MAYBE_H Index: src/libcfa/containers/maybe.c =================================================================== --- src/libcfa/containers/maybe.c (revision 0a208b842a9212f139dda75575089886452b6015) +++ src/libcfa/containers/maybe.c (revision 0a208b842a9212f139dda75575089886452b6015) @@ -0,0 +1,70 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// maybe.c -- May contain a value. +// +// Author : Andrew Beach +// Created On : Wed May 25 15:40:00 2017 +// Last Modified By : Andrew Beach +// Last Modified On : Wed May 25 17:00:00 2017 +// Update Count : 1 +// + +#include +#include + + +forall(otype T) +void ?{}(maybe(T) * this) { + this->has_value = false; +} + +forall(otype T) +void ?{}(maybe(T) * this, T value) { + this->has_value = true; + this->value = value; +} + +forall(otype T) +void ?{}(maybe(T) * this, maybe(T) other) { + this->has_value = other.has_value; + if (other.has_value) { + this->value = other.value; + } +} + +forall(otype T) +void ^?{}(maybe(T) * this) { + if (this->has_value) { + ^(this->value){}; + } +} + +forall(otype T) +_Bool ?!=?(result(T, E) this, zero_t) { + return !this->has_value; +} + +forall(otype T) +maybe(T) maybe_value(T value) { + return (Maybe(T)){value}; +} + +forall(otype T) +maybe(T) maybe_none() { + return (Maybe(T)){}; +} + +forall(otype T) +_Bool has_value(maybe(T) * this) { + return this->has_value; +} + +forall(otype T) +T get(maybe(T) * this) { + assertf(this->has_value, "attempt to get from maybe without value"); + return this->value; +} Index: src/libcfa/containers/result =================================================================== --- src/libcfa/containers/result (revision 0a208b842a9212f139dda75575089886452b6015) +++ src/libcfa/containers/result (revision 0a208b842a9212f139dda75575089886452b6015) @@ -0,0 +1,65 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// result -- Contains the expected value or an error value. +// +// Author : Andrew Beach +// Created On : Wed May 25 14:45:00 2017 +// Last Modified By : Andrew Beach +// Last Modified On : Wed May 25 16:57:00 2017 +// Update Count : 1 +// + + +#ifndef RESULT_H +#define RESULT_H + + +// DO NOT USE DIRECTLY! +forall(otype T, otype E) +struct result { + _Bool has_value; + union { + T value; + E error; + }; +}; + + +forall(otype T, otype E) +void ?{}(result(T, E) * this); + +forall(otype T, otype E) +void ?{}(result(T, E) * this, one_t, T value); + +forall(otype T, otype E) +void ?{}(result(T, E) * this, zero_t, E error); + +forall(otype T, otype E) +void ?{}(result(T, E) * this, result(T, E) other); + +forall(otype T, otype E) +void ^?{}(result(T, E) * this); + +forall(otype T, otype E) +_Bool ?!=?(result(T, E) this, zero_t); + +forall(otype T, otype E) +result(T, E) result_value(T value); + +forall(otype T, otype E) +result(T, E) result_error(E error); + +forall(otype T, otype E) +_Bool has_value(result(T, E) * this); + +forall(otype T, otype E) +T get(result(T, E) * this); + +forall(otype T, otype E) +E get_error(result(T, E) * this); + +#endif // RESULT_H Index: src/libcfa/containers/result.c =================================================================== --- src/libcfa/containers/result.c (revision 0a208b842a9212f139dda75575089886452b6015) +++ src/libcfa/containers/result.c (revision 0a208b842a9212f139dda75575089886452b6015) @@ -0,0 +1,87 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// result.c -- Contains the expected value or an error value. +// +// Author : Andrew Beach +// Created On : Wed May 25 15:40:00 2017 +// Last Modified By : Andrew Beach +// Last Modified On : Wed May 25 17:02:00 2017 +// Update Count : 1 +// + +#include +#include + + +forall(otype T, otype E) +void ?{}(result(T, E) * this) { + this->has_value = false; + (this->error){}; +} + +forall(otype T, otype E) +void ?{}(result(T, E) * this, one_t, T value) { + this->has_value = true; + this->value = value; +} + +forall(otype T, otype E) +void ?{}(result(T, E) * this, zero_t, E error) { + this->has_value = false; + this->error = error; +} + +forall(otype T, otype E) +void ?{}(result(T, E) * this, result(T, E) other) { + this->has_value = other.has_value; + if (other.has_value) { + this->value = other.value; + } else { + this->error = other.error; + } +} + +forall(otype T, otype E) +void ^?{}(result(T, E) * this) { + if (this->has_value) { + ^(this->value){}; + } else { + ^(this->error){}; + } +} + +forall(otype T, otype E) +_Bool ?!=?(result(T, E) this, zero_t) { + return !this->has_value; +} + +forall(otype T, otype E) +result(T, E) result_value(T value) { + return (Result(T, E)){1, value}; +} + +forall(otype T, otype E) +result(T, E) result_error(E error) { + return (Result(T, E)){0, value}; +} + +forall(otype T, otype E) +_Bool has_value(result(T, E) * this) { + return this->has_value; +} + +forall(otype T, otype E) +T get(result(T, E) * this) { + assertf(this->has_value, "attempt to get from result without value"); + return this->value; +} + +forall(otype T, otype E) +E get_error(result(T, E) * this) { + assertf(this->has_value, "attempt to get from result without error"); + return this->error; +} Index: src/libcfa/math =================================================================== --- src/libcfa/math (revision a8e64c4029370bc62f193afaf75b9ad8e7f8a7df) +++ src/libcfa/math (revision 0a208b842a9212f139dda75575089886452b6015) @@ -10,6 +10,6 @@ // Created On : Mon Apr 18 23:37:04 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Sun Apr 24 12:45:02 2016 -// Update Count : 59 +// Last Modified On : Wed May 24 17:40:39 2017 +// Update Count : 60 // @@ -20,11 +20,4 @@ #include // fpclassify, isfinite, isnormal, isnan, isinf } // extern "C" - -float fabs( float ); -// extern "C" { double fabs( double ); } -long double fabs( long double ); -float cabs( float _Complex ); -// extern "C" { double cabs( double _Complex ); } -long double cabs( long double _Complex ); float ?%?( float, float ); Index: src/libcfa/math.c =================================================================== --- src/libcfa/math.c (revision a8e64c4029370bc62f193afaf75b9ad8e7f8a7df) +++ src/libcfa/math.c (revision 0a208b842a9212f139dda75575089886452b6015) @@ -10,6 +10,6 @@ // Created On : Tue Apr 19 22:23:08 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Sun Apr 24 08:52:31 2016 -// Update Count : 75 +// Last Modified On : Tue May 23 22:52:13 2017 +// Update Count : 76 // @@ -19,9 +19,4 @@ #include } // extern "C" - -float fabs( float x ) { return fabsf( x ); } -long double fabs( long double x ) { return fabsl( x ); } -float cabs( float _Complex x ) { return cabsf( x ); } -long double cabs( long double _Complex x ) { return cabsl( x ); } float ?%?( float x, float y ) { return fmodf( x, y ); } Index: src/libcfa/stdlib =================================================================== --- src/libcfa/stdlib (revision a8e64c4029370bc62f193afaf75b9ad8e7f8a7df) +++ src/libcfa/stdlib (revision 0a208b842a9212f139dda75575089886452b6015) @@ -10,6 +10,6 @@ // Created On : Thu Jan 28 17:12:35 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Tue May 9 08:42:44 2017 -// Update Count : 107 +// Last Modified On : Wed May 24 18:06:27 2017 +// Update Count : 115 // @@ -28,5 +28,4 @@ //--------------------------------------- -extern "C" { void * malloc( size_t ); } // use default C routine for void * forall( dtype T | sized(T) ) T * malloc( void ); forall( dtype T | sized(T) ) T * malloc( char fill ); @@ -42,9 +41,4 @@ forall( dtype T | sized(T) ) T * memalign( size_t alignment ); // deprecated forall( dtype T | sized(T) ) int posix_memalign( T ** ptr, size_t alignment ); - -extern "C" { -void * memset( void * ptr, int fill, size_t size ); -void free( void * ptr ); -} // extern "C" forall( dtype T, ttype Params | sized(T) | { void ?{}(T *, Params); } ) T * new( Params p ); @@ -109,5 +103,5 @@ double abs( double _Complex ); long double abs( long double _Complex ); -forall ( otype T | { void ?{}( T *, zero_t ); int ? #include @@ -20,2 +35,7 @@ #endif // __CFA } + +// Local Variables: // +// tab-width: 4 // +// compile-command: "cfa complex.c" // +// End: // Index: src/tests/gmp.c =================================================================== --- src/tests/gmp.c (revision a8e64c4029370bc62f193afaf75b9ad8e7f8a7df) +++ src/tests/gmp.c (revision 0a208b842a9212f139dda75575089886452b6015) @@ -10,6 +10,6 @@ // Created On : Tue Apr 19 08:55:51 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon May 22 09:05:09 2017 -// Update Count : 538 +// Last Modified On : Wed May 24 22:05:38 2017 +// Update Count : 540 // @@ -88,5 +88,5 @@ sout | (int)0 | fact | endl; for ( unsigned int i = 1; i <= 40; i += 1 ) { - fact = fact * i; // general case + fact *= i; // general case sout | i | fact | endl; } // for @@ -94,5 +94,5 @@ // Local Variables: // -// mode: c // // tab-width: 4 // +// compile-command: "cfa gmp.c -l gmp" // // End: // Index: src/tests/math.c =================================================================== --- src/tests/math.c (revision a8e64c4029370bc62f193afaf75b9ad8e7f8a7df) +++ src/tests/math.c (revision 0a208b842a9212f139dda75575089886452b6015) @@ -10,6 +10,6 @@ // Created On : Fri Apr 22 14:59:21 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Sun Apr 24 13:24:20 2016 -// Update Count : 70 +// Last Modified On : Wed May 24 13:04:33 2017 +// Update Count : 71 // @@ -22,5 +22,4 @@ long double l; - sout | "fabs:" | fabs( -1.0F ) | fabs( -1.0D ) | fabs( -1.0L ) | cabs( -1.0F+1.0FI ) | cabs( -1.0D+1.0DI ) | cabs( -1.0DL+1.0LI ) | endl; sout | "fmod:" | 5.0F % -2.0F | fmod( 5.0F, -2.0F ) | 5.0D % -2.0D | fmod( 5.0D, -2.0D ) | 5.0L % -2.0L | fmod( 5.0L, -2.0L ) | endl; sout | "remainder:" | remainder( 2.0F, 3.0F ) | remainder( 2.0D, 3.0D ) | remainder( 2.0L, 3.0L ) | endl; Index: src/tests/numericConstants.c =================================================================== --- src/tests/numericConstants.c (revision a8e64c4029370bc62f193afaf75b9ad8e7f8a7df) +++ src/tests/numericConstants.c (revision 0a208b842a9212f139dda75575089886452b6015) @@ -1,2 +1,17 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// numericConstants.c -- +// +// Author : Peter A. Buhr +// Created On : Wed May 24 22:10:36 2017 +// Last Modified By : Peter A. Buhr +// Last Modified On : Wed May 24 22:11:36 2017 +// Update Count : 2 +// + int main() { 1; // decimal @@ -48,3 +63,8 @@ 0x_ff.ffp0; // hex real 0x_1.ffff_ffff_p_128_l; -} +} // main + +// Local Variables: // +// tab-width: 4 // +// compile-command: "cfa minmax.c" // +// End: // Index: src/tests/rational.c =================================================================== --- src/tests/rational.c (revision a8e64c4029370bc62f193afaf75b9ad8e7f8a7df) +++ src/tests/rational.c (revision 0a208b842a9212f139dda75575089886452b6015) @@ -10,6 +10,6 @@ // Created On : Mon Mar 28 08:43:12 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon May 15 21:32:22 2017 -// Update Count : 64 +// Last Modified On : Wed May 17 15:46:35 2017 +// Update Count : 65 //