Changeset 5479e63


Ignore:
Timestamp:
Jul 13, 2016, 8:22:11 AM (5 years ago)
Author:
Peter A. Buhr <pabuhr@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, ctor, deferred_resn, demangler, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, resolv-new, with_gc
Children:
ed9ecda
Parents:
e4d3ceb
Message:

documentation for switch/choose statement

Location:
doc
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • doc/LaTeXmacros/common.tex

    re4d3ceb r5479e63  
    1111%% Created On       : Sat Apr  9 10:06:17 2016
    1212%% Last Modified By : Peter A. Buhr
    13 %% Last Modified On : Sun Jul 10 12:34:09 2016
    14 %% Update Count     : 205
     13%% Last Modified On : Tue Jul 12 20:37:57 2016
     14%% Update Count     : 206
    1515%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    1616
     
    238238\lstMakeShortInline©    % single-character for \lstinline
    239239
     240\let\Oldthebibliography\thebibliography
     241\renewcommand\thebibliography[1]{
     242  \Oldthebibliography{#1}
     243  \setlength{\parskip}{0pt}                     % reduce vertical spacing between references
     244  \setlength{\itemsep}{5pt plus 0.3ex}
     245}%
     246
    240247% Local Variables: %
    241248% tab-width: 4 %
  • doc/user/user.tex

    re4d3ceb r5479e63  
    1111%% Created On       : Wed Apr  6 14:53:29 2016
    1212%% Last Modified By : Peter A. Buhr
    13 %% Last Modified On : Sun Jul 10 12:52:09 2016
    14 %% Update Count     : 1200
     13%% Last Modified On : Wed Jul 13 08:14:39 2016
     14%% Update Count     : 1247
    1515%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    1616
     
    294294\item
    295295\Indexc{-nodebug}\index{compilation option!-nodebug@©-nodebug©}
    296 The program is linked with the non-debugging version of the unikernel or multikernel, so the execution of the program is faster.
     296The program is linked with the non-debugging version of the runtime system, so the execution of the program is faster.
    297297\Emph{However, no runtime checks or ©assert©s are performed so errors usually result in abnormal program termination.}
    298298
     
    721721®&®crc = &cx;                                   §\C{// error, cannot change crc}§
    722722\end{lstlisting}
    723 Hence, for type ©& const©, there is no pointer assignment, so ©&rc = &x© is disallowed, and \emph{the address value cannot be ©0© unless an arbitrary pointer is assigned to the reference}.
    724 In effect, the compiler is managing the addresses for type ©& const© not the programmer, and by a programming discipline of only using references with references, address errors can be prevented.
     723Hence, for type ©& const©, there is no pointer assignment, so ©&rc = &x© is disallowed, and \emph{the address value cannot be ©0© unless an arbitrary pointer is assigned to the reference}, e.g.:
     724\begin{lstlisting}
     725int & const r = *0;                             §\C{// where 0 is the int * zero}§
     726\end{lstlisting}
     727Otherwise, the compiler is managing the addresses for type ©& const© not the programmer, and by a programming discipline of only using references with references, address errors can be prevented.
    725728
    726729\Index{Initialization} is different than \Index{assignment} because initialization occurs on the empty (uninitialized) storage on an object, while assignment occurs on possibly initialized storage of an object.
     
    735738\begin{lstlisting}
    736739int & f( int & rp );                    §\C{// reference parameter and return}§
    737 z = f( x ) + f( y );                    §\C{// reference operator added
     740z = f( x ) + f( y );                    §\C{// reference operator added, temporaries needed for call results
    738741\end{lstlisting}
    739742Within routine ©f©, it is possible to change the argument by changing the corresponding parameter, and parameter ©rp© can be locally reassigned within ©f©.
    740 The return reference from ©f© is copied into a compiler generated temporary, which is treated as an initialization.
     743Since ©?+?© takes its arguments by value, the references returned from ©f© are used to initialize compiler generated temporaries with value semantics that copy from the references.
    741744
    742745When a pointer/reference parameter has a ©const© value (immutable), it is possible to pass literals and expressions.
     
    16461649\end{lstlisting}
    16471650The ability to fall-through to the next clause \emph{is} a useful form of control flow, specifically when a sequence of case actions compound:
     1651\begin{quote2}
     1652\begin{tabular}{@{}l@{\hspace{3em}}l@{}}
    16481653\begin{lstlisting}
    16491654switch ( argc ) {
     
    16581663}
    16591664\end{lstlisting}
     1665&
     1666\begin{lstlisting}
     1667
     1668if ( argc == 3 ) {
     1669        // open output file
     1670        ®// open input file
     1671®} else if ( argc == 2 ) {
     1672        ®// open input file
     1673
     1674®} else {
     1675        // usage message
     1676}
     1677\end{lstlisting}
     1678\end{tabular}
     1679\end{quote2}
    16601680In this example, case 2 is always done if case 3 is done.
    16611681This control flow is difficult to simulate with if statements or a ©switch© statement without fall-through as code must be duplicated or placed in a separate routine.
     
    16721692\end{lstlisting}
    16731693However, this situation is handled in other languages without fall-through by allowing a list of case values.
    1674 While fall-through itself is not a problem, the problem occurs when fall-through is the default, as this semantics is not intuitive to most programmers and is different from virtually all other programming languages with a ©switch© statement.
     1694While fall-through itself is not a problem, the problem occurs when fall-through is the default, as this semantics is unintuitive to many programmers and is different from virtually all other programming languages with a ©switch© statement.
    16751695Hence, default fall-through semantics results in a large number of programming errors as programmers often forget the ©break© statement at the end of a ©case© clause, resulting in inadvertent fall-through.
    16761696
     
    16821702        if ( j < k ) {
    16831703                ...
    1684           case 1:               // transfer into "if" statement
    1685                 if ( j < m ) {
    1686                         ...
    1687                   case 2:       // transfer into "if" statement
    1688                         ...
    1689                 }
    1690         }
    1691   case 3:
     1704          ®case 1:®             // transfer into "if" statement
     1705                ...
     1706        } // if
     1707  case 2:
    16921708        while ( j < 5 ) {
    16931709                ...
    1694           case 4:               // transfer into "while" statement
     1710          ®case 3:®             // transfer into "while" statement
    16951711                ...
    1696         }
    1697 }
     1712        } // while
     1713} // switch
    16981714\end{lstlisting}
    16991715The problem with this usage is branching into control structures, which is known to cause both comprehension and technical difficulties.
     
    17341750\begin{lstlisting}
    17351751switch ( x ) {
    1736         int y = 1;                      §\C{// unreachable initialization}§
    1737         x = 7;                          §\C{// unreachable code
     1752        ®int y = 1;®                            §\C{// unreachable initialization}§
     1753        ®x = 7;®                                        §\C{// unreachable code without label/branch
    17381754  case 3: ...
    1739         y = 3;
    17401755        ...
     1756        ®int z = 0;®                            §\C{// unreachable initialization, cannot appear after case}§
     1757        z = 2;
     1758  case 3:
     1759        ®x = z;®                                        §\C{// without fall through, z is uninitialized}§
    17411760}
    17421761\end{lstlisting}
    17431762While the declaration of the local variable ©y© is useful and its scope is across all ©case© clauses, the initialization for such a variable is defined to never be executed because control always transfers over it.
    1744 Furthermore, any statements before the first ©case© clause can only be executed if labelled and transfered to using a ©goto©, either from outside or inside of the ©switch©.
    1745 As mentioned, transfer into control structures should be forbidden.
    1746 Transfers from within the ©switch© body using a ©goto© are equally unpalatable.
     1763Furthermore, any statements before the first ©case© clause can only be executed if labelled and transferred to using a ©goto©, either from outside or inside of the ©switch©.
     1764As mentioned, transfer into control structures should be forbidden;
     1765transfers from within the ©switch© body using a ©goto© are equally unpalatable.
     1766As well, the declaration of ©z© is cannot occur after the ©case© because a label can only be attached to a statement, and without a fall through to case 3, ©z© is uninitialized.
    17471767\end{enumerate}
     1768
    17481769Before discussing potential language changes to deal with these problems, it is worth observing that in a typical C program:
    17491770\begin{itemize}
     
    17571778and there is only a medium amount of fall-through from one ©case© clause to the next, and most of these result from a list of case values executing common code, rather than a sequence of case actions that compound.
    17581779\end{itemize}
    1759 These observations help to put the effects of suggested changes into perspective.
     1780These observations help to put the suggested changes to the ©switch© into perspective.
    17601781\begin{enumerate}
    17611782\item
     
    17671788still work.
    17681789Nevertheless, reversing the default action would have a non-trivial effect on case actions that compound, such as the above example of processing shell arguments.
    1769 Therefore, to preserve backwards compatibility, it is necessary to introduce a new kind of ©switch© statement, called ©choose©, with no fall-through semantics.
    1770 The ©choose© statement is identical to the new ©switch© statement, except there is no implicit fall-through between case-clauses and the ©break© statement applies to the enclosing loop construct (as for the ©continue© statement in a ©switch© statement).
    1771 It is still possible to fall-through if a case-clause ends with the new keyword ©fallthru©, e.g.:
     1790Therefore, to preserve backwards compatibility, it is necessary to introduce a new kind of ©switch© statement, called ©choose©, with no implicit fall-through semantics and an explicit fall-through if the last statement of a case-clause ends with the new keyword ©fallthru©, e.g.:
    17721791\begin{lstlisting}
    17731792®choose® ( i ) {
    1774   case 3:
     1793  case 1:  case 2:  case 3:
    17751794        ...
    1776         ®fallthru®;             §\C{// explicit fall through}§
    1777   case 5:
    1778         ...                             §\C{// implicit end of switch}§
     1795        ®// implicit end of switch (break)
     1796  ®case 5:
     1797        ...
     1798        ®fallthru®;                                     §\C{// explicit fall through}§
    17791799  case 7:
    17801800        ...
    1781         ®break®                 §\C{// transfer to end of enclosing loop / switch}§
     1801        ®break®                                         §\C{// explicit end of switch}§
    17821802  default:
    17831803        j = 3;
    17841804}
    17851805\end{lstlisting}
    1786 The ability to fall-through is retained because it is a sufficient C-idiom that most C programmers simply expect it, and its absence might discourage these programmers from using the ©choose© statement.
    1787 \item
    1788 Eliminating \Index*{Duff's device} is straightforward and only invalidates a small amount of very questionable code.
    1789 The solution is to allow ©case© clauses to only appear at the same nesting level as the ©switch© body, as is done in most other programming languages with ©switch© statements.
     1806Like the ©switch© statement, the ©choose© statement retains the fall-through semantics for a list of ©case© clauses;
     1807the implicit ©break© is applied only at the end of the \emph{statements} following a ©case© clause.
     1808The explicit ©fallthru© is retained because it is a C-idiom most C programmers expect, and its absence might discourage programmers from using the ©choose© statement.
     1809As well, allowing an explicit ©break© from the ©choose© is a carry over from the ©switch© statement, and expected by C programmers.
     1810\item
     1811\Index*{Duff's device} is eliminated from both ©switch© and ©choose© statements, and only invalidates a small amount of very questionable code.
     1812Hence, the ©case© clause must appear at the same nesting level as the ©switch©/©choose© body, as is done in most other programming languages with ©switch© statements.
    17901813\item
    17911814The issue of ©default© at locations other than at the end of the cause clause can be solved by using good programming style, and there are a few reasonable situations involving fall-through where the ©default© clause needs to appear is locations other than at the end.
    1792 Therefore, no language change is made for this issue.
    1793 \item
    1794 Dealing with unreachable code at the start of a ©switch© statement is solved by defining the declaration-list, including any associated initialization, at the start of a ©switch© statement body to be executed \emph{before} the transfer to the appropriate ©case© clause.
    1795 This semantics is the same as for declarations at the start of a loop body, which are executed before each iteration of the loop body.
    1796 As well, statements cannot appear before the first ©case© clause.
    1797 The change is compatible for declarations with initialization in this context because existing code cannot assume the initialization has occurred.
    1798 The change is incompatible for statements, but any existing code using it is highly questionable, as in:
    1799 \begin{lstlisting}
    1800 switch ( i ) {
    1801         L: x = 5;               §\C{// questionable code}§
     1815Therefore, no change is made for this issue.
     1816\item
     1817Dealing with unreachable code in a ©switch©/©choose© body is solved by restricting declarations and associated initialization to the start of statement body, which is executed \emph{before} the transfer to the appropriate ©case© clause.\footnote{
     1818Essentially, these declarations are hoisted before the statement and both declarations and statement are surrounded by a compound statement.} and precluding statements before the first ©case© clause.
     1819Further declaration in the statement body are disallowed.
     1820\begin{lstlisting}
     1821switch ( x ) {
     1822        ®int i = 0;®                            §\C{// allowed}§
    18021823  case 0:
    18031824        ...
    1804 }
    1805 \end{lstlisting}
    1806 The statement after the ©switch© can never be executed unless it is labelled.
    1807 If it is labelled, it must be transfered to from outside or inside the ©switch© statement, neither of which is acceptable control flow.
     1825        ®int i = 0;®                            §\C{// disallowed}§
     1826  case 1:
     1827    {
     1828                ®int i = 0;®                    §\C{// allowed in any compound statement}§
     1829                ...
     1830        }
     1831  ...
     1832}
     1833\end{lstlisting}
    18081834\end{enumerate}
    18091835
     
    18871913\section{Exception Handling}
    18881914
    1889 Exception handling provides two mechanim: change of control flow from a raise to a handler, and commumication from the riase to the handler.
     1915Exception handling provides two mechanism: change of control flow from a raise to a handler, and communication from the raise to the handler.
    18901916\begin{lstlisting}
    18911917exception void h( int i );
     
    21402166A facility that let programmers declare specific constants..const Rational 12., for instance. would not be much of an improvement.
    21412167Some facility for defining the creation of values of programmer-defined types from arbitrary integer tokens would be needed.
    2142 The complexity of such a feature doesn.t seem worth the gain.
     2168The complexity of such a feature does not seem worth the gain.
    21432169
    21442170For example, to define the constants for a complex type, the programmer would define the following:
     
    26682694} s;
    26692695\end{lstlisting}
    2670 The problem occurs in accesing these fields using the selection operation ``©.©'':
     2696The problem occurs in accessing these fields using the selection operation ``©.©'':
    26712697\begin{lstlisting}
    26722698s.0 = 0;        // ambiguity with floating constant .0
     
    26782704®s.§\textvisiblespace§1® = 1;
    26792705\end{lstlisting}
    2680 While this sytact is awkward, it is unlikely many programers will name fields of a structure 0 or 1.
     2706While this syntax is awkward, it is unlikely many programmers will name fields of a structure 0 or 1.
    26812707Like the \Index*[C++]{\CC} lexical problem with closing template-syntax, e.g, ©Foo<Bar<int®>>®©, this issue can be solved with a more powerful lexer/parser.
    26822708
     
    29903016In \CFA, multiple definitions are not necessary.
    29913017Within a module, all of the module's global definitions are visible throughout the module.
    2992 For example, the following code compiles, even though isOdd was not declared before being called:
     3018For example, the following code compiles, even though ©isOdd© was not declared before being called:
    29933019\begin{lstlisting}
    29943020bool isEven(unsigned int x) {
     
    43304356\item[Difficulty of converting:] keyword clashes are accommodated by syntactic transformations using the \CFA backquote escape-mechanism:
    43314357\begin{lstlisting}
    4332 int `otype` = 3;                                // make keyword an indentifier
     4358int `otype` = 3;                                // make keyword an identifier
    43334359double `choose` = 3.5;
    43344360\end{lstlisting}
     
    44674493\begin{description}
    44684494\item[Change:] comma expression is disallowed as subscript
    4469 \item[Rationale:] safety issue to prevent subscripting error for multidimensional arrays: ©x[i,j]© instead of ©x[i][j]©, and this syntactic form then taken by \CFA for new styple arrays.
     4495\item[Rationale:] safety issue to prevent subscripting error for multidimensional arrays: ©x[i,j]© instead of ©x[i][j]©, and this syntactic form then taken by \CFA for new style arrays.
    44704496\item[Effect on original feature:] change to semantics of well-defined feature.
    44714497\item[Difficulty of converting:] semantic transformation of ©x[i,j]© to ©x[(i,j)]©
     
    44794505\index{input/output library}
    44804506
    4481 The goal for the \CFA I/O is to make I/O as simple as possible in the common cases, while fully supporting polmorphism and user defined types in a consistent way.
     4507The 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.
    44824508The common case is printing out a sequence of variables separated by whitespace.
    44834509\begin{quote2}
     
    45164542Finally, the logical-or operator has a link with the Shell pipe-operator for moving data, although data flows in the opposite direction.
    45174543
    4518 The implicit seperator\index{I/O separator} character (space/blank) is a separator not a terminator.
     4544The implicit separator\index{I/O separator} character (space/blank) is a separator not a terminator.
    45194545The rules for implicitly adding the separator are:
    45204546\begin{enumerate}
    45214547\item
    4522 A seperator does not appear at the start or end of a line.
     4548A separator does not appear at the start or end of a line.
    45234549\begin{lstlisting}[belowskip=0pt]
    45244550sout | 1 | 2 | 3 | endl;
     
    45284554\end{lstlisting}
    45294555\item
    4530 A seperator does not appear before or after a character literal or variable.
     4556A separator does not appear before or after a character literal or variable.
    45314557\begin{lstlisting}
    45324558sout | '1' | '2' | '3' | endl;
     
    45344560\end{lstlisting}
    45354561\item
    4536 A seperator does not appear before or after a null (empty) C string
     4562A separator does not appear before or after a null (empty) C string
    45374563\begin{lstlisting}
    45384564sout | 1 | "" | 2 | "" | 3 | endl;
     
    45414567which is a local mechanism to disable insertion of the separator character.
    45424568\item
    4543 A seperator does not appear before a C string starting with the (extended) \Index{ASCII}\index{ASCII!extended} characters: \lstinline[mathescape=off]@([{$£¥¡¿«@
     4569A separator does not appear before a C string starting with the (extended) \Index{ASCII}\index{ASCII!extended} characters: \lstinline[mathescape=off]@([{$£¥¡¿«@
    45444570%$
    45454571\begin{lstlisting}[mathescape=off]
     
    47444770
    47454771
    4746 \subsection{min / max / swap}
     4772\subsection{min / max / clamp / swap}
    47474773
    47484774\begin{lstlisting}[aboveskip=0pt,belowskip=0pt]
     
    47524778forall( otype T | { int ?>?( T, T ); } )
    47534779T max( const T t1, const T t2 );§\indexc{max}§
     4780
     4781forall( otype T | { T min( T, T ); T max( T, T ); } )
     4782T clamp( T value, T min_val, T max_val );§\indexc{clamp}§
    47544783
    47554784forall( otype T )
     
    51365165When creating and computing with rational numbers, results are constantly reduced to keep the numerator and denominator as small as possible.
    51375166
    5138 \begin{lstlisting}[aboveskip=0pt,belowskip=0pt]
     5167\begin{lstlisting}[belowskip=0pt]
    51395168// implementation
    51405169struct Rational {§\indexc{Rational}§
Note: See TracChangeset for help on using the changeset viewer.