Index: doc/LaTeXmacros/common.tex =================================================================== --- doc/LaTeXmacros/common.tex (revision 387368546018aa1d0ac996c3a245f916a26a8cd2) +++ doc/LaTeXmacros/common.tex (revision 6603c1dbfb45fe26d6acd74a1e2ed275886ab34e) @@ -11,6 +11,6 @@ %% Created On : Sat Apr 9 10:06:17 2016 %% Last Modified By : Peter A. Buhr -%% Last Modified On : Tue Aug 2 17:02:02 2016 -%% Update Count : 228 +%% Last Modified On : Sun Aug 14 08:27:29 2016 +%% Update Count : 231 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% @@ -153,4 +153,8 @@ {\abbrevFont{etc}.\xspace}% }% +\newcommand{\etal}{% + \@ifnextchar{.}{\abbrevFont{et~al}}% + {\abbrevFont{et al}.\xspace}% +}% \makeatother @@ -251,5 +255,5 @@ literate={-}{\raisebox{-0.15ex}{\texttt{-}}}1 {^}{\raisebox{0.6ex}{$\scriptscriptstyle\land\,$}}1 {~}{\raisebox{0.3ex}{$\scriptstyle\sim\,$}}1 {_}{\makebox[1.2ex][c]{\rule{1ex}{0.1ex}}}1 {`}{\ttfamily\upshape\hspace*{-0.1ex}`}1 - {<-}{$\leftarrow$}2 {=>}{$\Rightarrow$}2 {...}{$\dots$}2, + {<-}{$\leftarrow$}2 {=>}{$\Rightarrow$}2, }% Index: doc/aaron_comp_II/comp_II.tex =================================================================== --- doc/aaron_comp_II/comp_II.tex (revision 387368546018aa1d0ac996c3a245f916a26a8cd2) +++ doc/aaron_comp_II/comp_II.tex (revision 6603c1dbfb45fe26d6acd74a1e2ed275886ab34e) @@ -413,4 +413,5 @@ \subsection{Argument-Parameter Matching} The first axis for consideration is argument-parameter matching direction --- whether the type matching for a candidate function to a set of candidate arguments is directed by the argument types or the parameter types. +For programming languages without implicit conversions, argument-parameter matching is essentially the entirety of the expression resolution problem, and is generally referred to as ``overload resolution'' in the literature. All expression resolution algorithms form a DAG of interpretations, some explicitly, some implicitly; in this DAG, arcs point from function-call interpretations to argument interpretations, as below: \begin{figure}[h] @@ -422,5 +423,5 @@ double *f(int*, int*); // $f_d$ -char *f(char*, char*); // $f_c$ +char *f(char*, int*); // $f_c$ f( f( p, p ), p ); @@ -463,13 +464,25 @@ Deciding when to switch between bottom-up and top-down resolution to minimize wasted work in a hybrid algorithm is a necessarily heuristic process, and though finding good heuristics for which subexpressions to swich matching strategies on is an open question, one reasonable approach might be to set a threshold $t$ for the number of candidate functions, and to use top-down resolution for any subexpression with fewer than $t$ candidate functions, to minimize the number of unmatchable argument interpretations computed, but to use bottom-up resolution for any subexpression with at least $t$ candidate functions, to reduce duplication in argument interpretation computation between the different candidate functions. +Ganzinger and Ripken~\cite{Ganzinger80} propose an approach (later refined by Pennello~\etal~\cite{Pennello80}) that uses a top-down filtering pass followed by a bottom-up filtering pass to reduce the number of candidate interpretations; they prove that for the Ada programming language a small number of such iterations is sufficient to converge to a solution for the expression resolution problem. +Persch~\etal~\cite{PW:overload} developed a similar two-pass approach where the bottom-up pass is followed by the top-down pass. +These algorithms differ from the hybrid approach under investigation in that they take multiple passes over the expression tree to yield a solution, and also in that they apply both filtering heuristics to all expression nodes; \CFA's polymorphic functions and implicit conversions make the approach of filtering out invalid types taken by all of these algorithms infeasible. + \subsubsection{Common Subexpression Caching} With any of these argument-parameter approaches, it may be a useful optimization to cache the resolution results for common subexpressions; in Figure~\ref{fig:res_dag} this optimization would result in the list of interpretations $[p_c, p_i]$ for ©p© only being calculated once, and re-used for each of the three instances of ©p©. \subsection{Implicit Conversion Application} -Baker's and Cormack's algorithms do not account for implicit conversions\footnote{Baker does briefly comment on an approach for handling implicit conversions, but does not provide an implementable algorithm.}; both assume that there is at most one valid interpretation of a given expression for each distinct type. -Integrating implicit conversion handling into their algorithms provides some choice of implementation approach. +With the exception of Bilson, the authors mentioned above do not account for implicit conversions in their algorithms\footnote{Baker does briefly comment on an approach for handling implicit conversions, but does not provide an implementable algorithm.}; all assume that there is at most one valid interpretation of a given expression for each distinct type. +Integrating implicit conversion handling into the presented argument-parameter matching algorithms thus provides some choice of implementation approach. + +Inference of polymorphic type variables can be considered a form of implicit conversion application, where monomorphic types are implicitly converted to instances of some polymorphic type\footnote{This ``conversion'' may not be implemented in any explicit way at runtime, but does need to be handled by the expression resolver as an inexact match between argument and parameter types.}. +This form of implicit conversion is particularly common in functional languages; Haskell's type classes~\cite{typeclass} are a particularly well-studied variant of this inference. +However, type classes arguably do not allow name overloading, as (at least in the Haskell implmentation) identifiers belonging to type classes may not be overloaded in any other context than an implementation of that type class; this provides a single (possibly polymorphic) interpretation of any identifier, simplifing the expression resolution problem relative to \CFA. +\CC~\cite{ANSI98:C++} includes both name overloading and implicit conversions in its expression resolution specification, though unlike \CFA it does complete type-checking on a generated monomorphization of template functions, where \CFA simply checks a list of type constraints. +The upcoming Concepts standard~\cite{C++concepts} defines a system of type constraints similar in principle to \CFA's. +Cormack and Wright~\cite{Cormack90} present an algorithm which integrates overload resolution with a polymorphic type inference approach very similar to \CFA's. +However, their algorithm does not account for implicit conversions other than polymorphic type binding and their discussion of their overload resolution algorithm is not sufficiently detailed to classify it with the other argument-parameter matching approaches\footnote{Their overload resolution algorithm is possibly a variant of Ganzinger and Ripken~\cite{Ganzinger80} or Pennello~\etal~\cite{Pennello80}, modified to allow for polymorphic type binding.}. \subsubsection{On Parameters} -Bilson does account for implicit conversions in his algorithm, but it is unclear the approach is optimal. +Bilson does account for implicit conversions in his algorithm, but it is unclear if the approach is optimal. His algorithm integrates checking for valid implicit conversions into the argument-parameter-matching step, essentially trading more expensive matching for a smaller number of argument interpretations. This approach may result in the same subexpression being checked for a type match with the same type multiple times, though again memoization may mitigate this cost, and this approach does not generate implicit conversions that are not useful to match the containing function. @@ -484,10 +497,10 @@ \subsection{Candidate Set Generation} -Cormack, Baker and Bilson all generate the complete set of candidate argument interpretations before attempting to match the containing function call expression. +All the algorithms discussed to this point generate the complete set of candidate argument interpretations before attempting to match the containing function call expression. However, given that the top-level expression interpretation that is ultimately chosen is the minimal-cost valid interpretation, any consideration of non-minimal-cost interpretations is in some sense wasted work. Under the assumption that that programmers generally write function calls with relatively low-cost interpretations, a possible work-saving heuristic is to generate only the lowest-cost argument interpretations first, attempt to find a valid top-level interpretation using them, and only if that fails generate the next higher-cost argument interpretations. \subsubsection{Eager} -Within the eager approach taken by Cormack, Baker and Bilson, there are still variants to explore. +Within the eager approach taken by the existing top-down and bottom-up algorithms, there are still variants to explore. Cormack and Baker do not account for implict conversions, and thus do not account for the possibility of multiple valid interpretations with distinct costs; Bilson, on the other hand, sorts the list of interpretations to aid in finding minimal-cost interpretations. Sorting the lists of argument or function call interpretations by cost at some point during resolution may provide useful opportunities to short-circuit expression evaluation when a minimal-cost interpretation is found, though it is unclear if this short-circuiting behaviour justifies the cost of the sort. @@ -559,5 +572,5 @@ This proposed project should provide valuable data on how to implement a performant compiler for modern programming languages such as \CFA with powerful static type-systems, specifically targeting the feature interaction between name overloading and implicit conversions. -This work is not limited in applicability to \CFA, but may also be useful for supporting efficient compilation of the upcoming ``Concepts'' standard~\cite{C++concepts} for \CC template constraints, for instance. +This work is not limited in applicability to \CFA, but may also be useful for supporting efficient compilation of the upcoming Concepts standard~\cite{C++concepts} for \CC template constraints, for instance. \appendix Index: doc/bibliography/cfa.bib =================================================================== --- doc/bibliography/cfa.bib (revision 387368546018aa1d0ac996c3a245f916a26a8cd2) +++ doc/bibliography/cfa.bib (revision 6603c1dbfb45fe26d6acd74a1e2ed275886ab34e) @@ -4685,4 +4685,23 @@ } +@article{Ganzinger80, + contributer = {a3moss@uwaterloo.ca}, + author = {Ganzinger, Harald and Ripken, Knut}, + title = {Operator Identification in {ADA}: Formal Specification, Complexity, and Concrete Implementation}, + journal = {SIGPLAN Notices}, + issue_date = {February 1980}, + volume = {15}, + number = {2}, + month = feb, + year = {1980}, + issn = {0362-1340}, + pages = {30--42}, + numpages = {13}, + url = {http://doi.acm.org/10.1145/947586.947589}, + doi = {10.1145/947586.947589}, + publisher = {ACM}, + address = {New York, NY, USA} +} + @article{Ford82, keywords = {}, @@ -5851,4 +5870,23 @@ } +@article{Pennello80, + contributer = {a3moss@uwaterloo.ca}, + author = {Pennello, Tom and DeRemer, Frank and Meyers, Richard}, + title = {A Simplified Operator Identification Scheme for {Ada}}, + journal = {SIGPLAN Notices}, + issue_date = {July-August 1980}, + volume = {15}, + number = {7 and 8}, + month = jul, + year = {1980}, + issn = {0362-1340}, + pages = {82--87}, + numpages = {6}, + url = {http://doi.acm.org/10.1145/947680.947688}, + doi = {10.1145/947680.947688}, + publisher = {ACM}, + address = {New York, NY, USA}, +} + @inproceedings{Dice10, keywords = {hardware, synchronization, transactional memory}, Index: doc/user/user.tex =================================================================== --- doc/user/user.tex (revision 387368546018aa1d0ac996c3a245f916a26a8cd2) +++ doc/user/user.tex (revision 6603c1dbfb45fe26d6acd74a1e2ed275886ab34e) @@ -11,6 +11,6 @@ %% Created On : Wed Apr 6 14:53:29 2016 %% Last Modified By : Peter A. Buhr -%% Last Modified On : Tue Aug 2 17:39:02 2016 -%% Update Count : 1286 +%% Last Modified On : Sun Aug 14 08:23:06 2016 +%% Update Count : 1323 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% @@ -317,5 +317,5 @@ \item -\Indexc{-no-include-std}\index{compilation option!-no-include-std@©-no-include-std©} +\Indexc{-no-include-stdhdr}\index{compilation option!-no-include-stdhdr@©-no-include-stdhdr©} Do not supply ©extern "C"© wrappers for \Celeven standard include files (see~\VRef{s:StandardHeaders}). \textbf{This option is \emph{not} the default.} @@ -807,4 +807,30 @@ +\section{Backquote Identifiers} +\label{s:BackquoteIdentifiers} + +\CFA accommodates keyword clashes by syntactic transformations using the \CFA backquote escape-mechanism: +\begin{lstlisting} +int `otype` = 3; // make keyword an identifier +double `choose` = 3.5; +\end{lstlisting} +Programs can be converted easily by enclosing keyword identifiers in backquotes, and the backquotes can be removed later when the identifier name is changed to an non-keyword name. +Clashes in C header files (see~\VRef{s:StandardHeaders}) can be handled automatically using the preprocessor, ©#include_next© and ©-I filename©: +\begin{lstlisting} +// include file uses the CFA keyword "otype". +#if ! defined( otype ) // nesting ? +#define otype `otype` +#define __CFA_BFD_H__ +#endif // ! otype + +#include_next // must have internal check for multiple expansion + +#if defined( otype ) && defined( __CFA_BFD_H__ ) // reset only if set +#undef otype +#undef __CFA_BFD_H__ +#endif // otype && __CFA_BFD_H__ +\end{lstlisting} + + \section{Type Operators} @@ -1011,5 +1037,22 @@ Alternatively, prototype definitions can be eliminated by using a two-pass compilation, and implicitly creating header files for exports. The former is easy to do, while the latter is more complex. -Currently, \CFA does \emph{not} attempt to support named arguments. + +Furthermore, named arguments do not work well in a \CFA-style programming-languages because they potentially introduces a new criteria for type matching. +For example, it is technically possible to disambiguate between these two overloaded definitions of ©f© based on named arguments at the call site: +\begin{lstlisting} +int f( int i, int j ); +int f( int x, double y ); + +f( j : 3, i : 4 ); §\C{// 1st f}§ +f( x : 7, y : 8.1 ); §\C{// 2nd f}§ +f( 4, 5 ); §\C{// ambiguous call}§ +\end{lstlisting} +However, named arguments compound routine resolution in conjunction with conversions: +\begin{lstlisting} +f( i : 3, 5.7 ); §\C{// ambiguous call ?}§ +\end{lstlisting} +Depending on the cost associated with named arguments, this call could be resolvable or ambiguous. +Adding named argument into the routine resolution algorithm does not seem worth the complexity. +Therefore, \CFA does \emph{not} attempt to support named arguments. \item[Default Arguments] @@ -1021,16 +1064,16 @@ the allowable positional calls are: \begin{lstlisting} -p(); §\C{// rewrite $\Rightarrow$ p( 1, 2, 3 )}§ -p( 4 ); §\C{// rewrite $\Rightarrow$ p( 4, 2, 3 )}§ -p( 4, 4 ); §\C{// rewrite $\Rightarrow$ p( 4, 4, 3 )}§ -p( 4, 4, 4 ); §\C{// rewrite $\Rightarrow$ p( 4, 4, 4 )}§ +p(); §\C{// rewrite $\Rightarrow$ p( 1, 2, 3 )}§ +p( 4 ); §\C{// rewrite $\Rightarrow$ p( 4, 2, 3 )}§ +p( 4, 4 ); §\C{// rewrite $\Rightarrow$ p( 4, 4, 3 )}§ +p( 4, 4, 4 ); §\C{// rewrite $\Rightarrow$ p( 4, 4, 4 )}§ // empty arguments -p( , 4, 4 ); §\C{// rewrite $\Rightarrow$ p( 1, 4, 4 )}§ -p( 4, , 4 ); §\C{// rewrite $\Rightarrow$ p( 4, 2, 4 )}§ -p( 4, 4, ); §\C{// rewrite $\Rightarrow$ p( 4, 4, 3 )}§ -p( 4, , ); §\C{// rewrite $\Rightarrow$ p( 4, 2, 3 )}§ -p( , 4, ); §\C{// rewrite $\Rightarrow$ p( 1, 4, 3 )}§ -p( , , 4 ); §\C{// rewrite $\Rightarrow$ p( 1, 2, 4 )}§ -p( , , ); §\C{// rewrite $\Rightarrow$ p( 1, 2, 3 )}§ +p( , 4, 4 ); §\C{// rewrite $\Rightarrow$ p( 1, 4, 4 )}§ +p( 4, , 4 ); §\C{// rewrite $\Rightarrow$ p( 4, 2, 4 )}§ +p( 4, 4, ); §\C{// rewrite $\Rightarrow$ p( 4, 4, 3 )}§ +p( 4, , ); §\C{// rewrite $\Rightarrow$ p( 4, 2, 3 )}§ +p( , 4, ); §\C{// rewrite $\Rightarrow$ p( 1, 4, 3 )}§ +p( , , 4 ); §\C{// rewrite $\Rightarrow$ p( 1, 2, 4 )}§ +p( , , ); §\C{// rewrite $\Rightarrow$ p( 1, 2, 3 )}§ \end{lstlisting} Here the missing arguments are inserted from the default values in the parameter list. @@ -1067,12 +1110,12 @@ The conflict occurs because both named and ellipse arguments must appear after positional arguments, giving two possibilities: \begin{lstlisting} -p( /* positional */, . . ., /* named */ ); -p( /* positional */, /* named */, . . . ); +p( /* positional */, ... , /* named */ ); +p( /* positional */, /* named */, ... ); \end{lstlisting} While it is possible to implement both approaches, the first possibly is more complex than the second, \eg: \begin{lstlisting} -p( int x, int y, int z, . . . ); -p( 1, 4, 5, 6, z : 3, y : 2 ); §\C{// assume p( /* positional */, . . ., /* named */ );}§ -p( 1, z : 3, y : 2, 4, 5, 6 ); §\C{// assume p( /* positional */, /* named */, . . . );}§ +p( int x, int y, int z, ... ); +p( 1, 4, 5, 6, z : 3, y : 2 ); §\C{// assume p( /* positional */, ... , /* named */ );}§ +p( 1, z : 3, y : 2, 4, 5, 6 ); §\C{// assume p( /* positional */, /* named */, ... );}§ \end{lstlisting} In the first call, it is necessary for the programmer to conceptually rewrite the call, changing named arguments into positional, before knowing where the ellipse arguments begin. @@ -1082,7 +1125,7 @@ The problem is exacerbated with default arguments, \eg: \begin{lstlisting} -void p( int x, int y = 2, int z = 3. . . ); -p( 1, 4, 5, 6, z : 3 ); §\C{// assume p( /* positional */, . . ., /* named */ );}§ -p( 1, z : 3, 4, 5, 6 ); §\C{// assume p( /* positional */, /* named */, . . . );}§ +void p( int x, int y = 2, int z = 3... ); +p( 1, 4, 5, 6, z : 3 ); §\C{// assume p( /* positional */, ... , /* named */ );}§ +p( 1, z : 3, 4, 5, 6 ); §\C{// assume p( /* positional */, /* named */, ... );}§ \end{lstlisting} The first call is an error because arguments 4 and 5 are actually positional not ellipse arguments; @@ -1129,6 +1172,7 @@ \subsection{Type Nesting} -\CFA allows \Index{type nesting}, and type qualification of the nested types (see \VRef[Figure]{f:TypeNestingQualification}), where as C hoists\index{type hoisting} (refactors) nested types into the enclosing scope and has no type qualification. +\CFA allows \Index{type nesting}, and type qualification of the nested typres (see \VRef[Figure]{f:TypeNestingQualification}), where as C hoists\index{type hoisting} (refactors) nested types into the enclosing scope and has no type qualification. \begin{figure} +\centering \begin{tabular}{@{}l@{\hspace{3em}}l|l@{}} \multicolumn{1}{c@{\hspace{3em}}}{\textbf{C Type Nesting}} & \multicolumn{1}{c}{\textbf{C Implicit Hoisting}} & \multicolumn{1}{|c}{\textbf{\CFA}} \\ @@ -1397,5 +1441,5 @@ Mass assignment has the following form: \begin{lstlisting} -[ §\emph{lvalue}§, ..., §\emph{lvalue}§ ] = §\emph{expr}§; +[ §\emph{lvalue}§, ... , §\emph{lvalue}§ ] = §\emph{expr}§; \end{lstlisting} \index{lvalue} @@ -1437,5 +1481,5 @@ Multiple assignment has the following form: \begin{lstlisting} -[ §\emph{lvalue}§, . . ., §\emph{lvalue}§ ] = [ §\emph{expr}§, . . ., §\emph{expr}§ ]; +[ §\emph{lvalue}§, ... , §\emph{lvalue}§ ] = [ §\emph{expr}§, ... , §\emph{expr}§ ]; \end{lstlisting} \index{lvalue} @@ -1873,7 +1917,7 @@ \begin{lstlisting} switch ( i ) { - ®case 1, 3, 5®: + case ®1, 3, 5®: ... - ®case 2, 4, 6®: + case ®2, 4, 6®: ... } @@ -1906,7 +1950,7 @@ \begin{lstlisting} switch ( i ) { - ®case 1~5:® + case ®1~5:® ... - ®case 10~15:® + case ®10~15:® ... } @@ -1915,7 +1959,7 @@ \begin{lstlisting} switch ( i ) - case 1 ... 5: + case ®1 ... 5®: ... - case 10 ... 15: + case ®10 ... 15®: ... } @@ -4369,23 +4413,151 @@ +\section{Incompatible} + +The following incompatibles exist between \CFA and C, and are similar to Annex C for \CC~\cite{ANSI14:C++}. + +\begin{enumerate} +\item +\begin{description} +\item[Change:] add new keywords \\ +New keywords are added to \CFA (see~\VRef{s:NewKeywords}). +\item[Rationale:] keywords added to implement new semantics of \CFA. +\item[Effect on original feature:] change to semantics of well-defined feature. \\ +Any ISO C programs using these keywords as identifiers are invalid \CFA programs. +\item[Difficulty of converting:] keyword clashes are accommodated by syntactic transformations using the \CFA backquote escape-mechanism (see~\VRef{s:BackquoteIdentifiers}): +\item[How widely used:] clashes among new \CFA keywords and existing identifiers are rare. +\end{description} + +\item +\begin{description} +\item[Change:] type of character literal ©int© to ©char© to allow more intuitive overloading: +\begin{lstlisting} +int rtn( int i ); +int rtn( char c ); +rtn( 'x' ); §\C{// programmer expects 2nd rtn to be called}§ +\end{lstlisting} +\item[Rationale:] it is more intuitive for the call to ©rtn© to match the second version of definition of ©rtn© rather than the first. +In particular, output of ©char© variable now print a character rather than the decimal ASCII value of the character. +\begin{lstlisting} +sout | 'x' | " " | (int)'x' | endl; +x 120 +\end{lstlisting} +Having to cast ©'x'© to ©char© is non-intuitive. +\item[Effect on original feature:] change to semantics of well-defined feature that depend on: +\begin{lstlisting} +sizeof( 'x' ) == sizeof( int ) +\end{lstlisting} +no long work the same in \CFA programs. +\item[Difficulty of converting:] simple +\item[How widely used:] programs that depend upon ©sizeof( 'x' )© are rare and can be changed to ©sizeof(char)©. +\end{description} + +\item +\begin{description} +\item[Change:] make string literals ©const©: +\begin{lstlisting} +char * p = "abc"; §\C{// valid in C, deprecated in \CFA}§ +char * q = expr ? "abc" : "de"; §\C{// valid in C, invalid in \CFA}§ +\end{lstlisting} +The type of a string literal is changed from ©[] char© to ©const [] char©. +Similarly, the type of a wide string literal is changed from ©[] wchar_t© to ©const [] wchar_t©. +\item[Rationale:] This change is a safety issue: +\begin{lstlisting} +char * p = "abc"; +p[0] = 'w'; §\C{// segment fault or change constant literal}§ +\end{lstlisting} +The same problem occurs when passing a string literal to a routine that changes its argument. +\item[Effect on original feature:] change to semantics of well-defined feature. +\item[Difficulty of converting:] simple syntactic transformation, because string literals can be converted to ©char *©. +\item[How widely used:] programs that have a legitimate reason to treat string literals as pointers to potentially modifiable memory are rare. +\end{description} + +\item +\begin{description} +\item[Change:] remove \newterm{tentative definitions}, which only occurs at file scope: +\begin{lstlisting} +int i; §\C{// forward definition}§ +int *j = ®&i®; §\C{// forward reference, valid in C, invalid in \CFA}§ +int i = 0; §\C{// definition}§ +\end{lstlisting} +is valid in C, and invalid in \CFA because duplicate overloaded object definitions at the same scope level are disallowed. +This change makes it impossible to define mutually referential file-local static objects, if initializers are restricted to the syntactic forms of C. For example, +\begin{lstlisting} +struct X { int i; struct X *next; }; +static struct X a; §\C{// forward definition}§ +static struct X b = { 0, ®&a® }; §\C{// forward reference, valid in C, invalid in \CFA}§ +static struct X a = { 1, &b }; §\C{// definition}§ +\end{lstlisting} +\item[Rationale:] avoids having different initialization rules for builtin types and userdefined types. +\item[Effect on original feature:] change to semantics of well-defined feature. +\item[Difficulty of converting:] the initializer for one of a set of mutually-referential file-local static objects must invoke a routine call to achieve the initialization. +\item[How widely used:] seldom +\end{description} + +\item +\begin{description} +\item[Change:] have ©struct© introduce a scope for nested types: +\begin{lstlisting} +enum ®Colour® { R, G, B, Y, C, M }; +struct Person { + enum ®Colour® { R, G, B }; §\C{// nested type}§ + struct Face { §\C{// nested type}§ + ®Colour® Eyes, Hair; §\C{// type defined outside (1 level)}§ + }; + ß.ß®Colour® shirt; §\C{// type defined outside (top level)}§ + ®Colour® pants; §\C{// type defined same level}§ + Face looks[10]; §\C{// type defined same level}§ +}; +®Colour® c = R; §\C{// type/enum defined same level}§ +Personß.ß®Colour® pc = Personß.ßR; §\C{// type/enum defined inside}§ +Personß.ßFace pretty; §\C{// type defined inside}§ +\end{lstlisting} +In C, the name of the nested types belongs to the same scope as the name of the outermost enclosing structure, i.e., the nested types are hoisted to the scope of the outer-most type, which is not useful and confusing. +\CFA is C \emph{incompatible} on this issue, and provides semantics similar to \Index*[C++]{\CC}. +Nested types are not hoisted and can be referenced using the field selection operator ``©.©'', unlike the \CC scope-resolution operator ``©::©''. +\item[Rationale:] ©struct© scope is crucial to \CFA as an information structuring and hiding mechanism. +\item[Effect on original feature:] change to semantics of well-defined feature. +\item[Difficulty of converting:] Semantic transformation. +\item[How widely used:] C programs rarely have nest types because they are equivalent to the hoisted version. +\end{description} + +\item +\begin{description} +\item[Change:] In C++, the name of a nested class is local to its enclosing class. +\item[Rationale:] C++ classes have member functions which require that classes establish scopes. +\item[Difficulty of converting:] Semantic transformation. To make the struct type name visible in the scope of the enclosing struct, the struct tag could be declared in the scope of the enclosing struct, before the enclosing struct is defined. Example: +\begin{lstlisting} +struct Y; §\C{// struct Y and struct X are at the same scope}§ +struct X { +struct Y { /* ... */ } y; +}; +\end{lstlisting} +All the definitions of C struct types enclosed in other struct definitions and accessed outside the scope of the enclosing struct could be exported to the scope of the enclosing struct. +Note: this is a consequence of the difference in scope rules, which is documented in 3.3. +\item[How widely used:] Seldom. +\end{description} + +\item +\begin{description} +\item[Change:] comma expression is disallowed as subscript +\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. +\item[Effect on original feature:] change to semantics of well-defined feature. +\item[Difficulty of converting:] semantic transformation of ©x[i,j]© to ©x[(i,j)]© +\item[How widely used:] seldom. +\end{description} +\end{enumerate} + + \section{New Keywords} \label{s:NewKeywords} \begin{quote2} -\begin{tabular}{ll} -©catch© & ©lvalue© \\ -©catchResume© & \\ -©choose© & ©otype© \\ - & \\ -©disable© & ©throw© \\ -©dtype© & ©throwResume© \\ - & ©trait© \\ -©enable© & ©try© \\ - & \\ -©fallthrough© \\ -©fallthru© \\ -©finally© \\ -©forall© \\ -©ftype© \\ +\begin{tabular}{lll} +©catch© & ©fallthrough© & ©otype© \\ +©catchResume© & ©fallthru© & ©throw© \\ +©choose© & ©finally© & ©throwResume© \\ +©disable© & ©forall© & ©trait© \\ +©dtype© & ©ftype© & ©try© \\ +©enable© & ©lvalue© & \\ \end{tabular} \end{quote2} @@ -4395,5 +4567,5 @@ \label{s:StandardHeaders} -C prescribes the following standard header-files: +C prescribes the following standard header-files~\cite[\S~7.1.2]{C11}: \begin{quote2} \begin{minipage}{\linewidth} @@ -4412,166 +4584,7 @@ \end{minipage} \end{quote2} -For the prescribed head-files, \CFA implicit wraps their includes in an ©extern "C"©; +For the prescribed head-files, \CFA implicitly wraps their includes in an ©extern "C"©; hence, names in these include files are not mangled\index{mangling!name} (see~\VRef{s:Interoperability}). All other C header files must be explicitly wrapped in ©extern "C"© to prevent name mangling. - - -\section{Incompatible} - -The following incompatibles exist between \CFA and C, and are similar to Annex C for \CC~\cite{ANSI14:C++}. - -\begin{enumerate} -\item -\begin{description} -\item[Change:] add new keywords (see~\VRef{s:NewKeywords}) \\ -New keywords are added to \CFA. -\item[Rationale:] keywords added to implement new semantics of \CFA. -\item[Effect on original feature:] change to semantics of well-defined feature. \\ -Any ISO C programs using these keywords as identifiers are invalid \CFA programs. -\item[Difficulty of converting:] keyword clashes are accommodated by syntactic transformations using the \CFA backquote escape-mechanism: -\begin{lstlisting} -int `otype` = 3; // make keyword an identifier -double `choose` = 3.5; -\end{lstlisting} -Programs can be converted automatically by enclosing keyword identifiers in backquotes, and the backquotes can be remove later when the identifier name is changed. -Clashes in C system libraries (include files) can be handled automatically using preprocessor, ©#include_next© and ©-Ifilename©: -\begin{lstlisting} -// include file uses the CFA keyword "otype". -#if ! defined( otype ) // nesting ? -#define otype `otype` -#define __CFA_BFD_H__ -#endif // ! otype - -#include_next // must have internal check for multiple expansion - -#if defined( otype ) && defined( __CFA_BFD_H__ ) // reset only if set -#undef otype -#undef __CFA_BFD_H__ -#endif // otype && __CFA_BFD_H__ -\end{lstlisting} -\item[How widely used:] clashes among new \CFA keywords and existing identifiers are rare. -\end{description} - -\item -\begin{description} -\item[Change:] type of character literal ©int© to ©char© to allow more intuitive overloading: -\begin{lstlisting} -int rtn( int i ); -int rtn( char c ); -rtn( 'x' ); // programmer expects 2nd rtn to be called -\end{lstlisting} -\item[Rationale:] it is more intuitive for the call to ©rtn© to match the second version of definition of ©rtn© rather than the first. -In particular, output of ©char© variable now print a character rather than the decimal ASCII value of the character. -\begin{lstlisting} -sout | 'x' | " " | (int)'x' | endl; -x 120 -\end{lstlisting} -Having to cast ©'x'© to ©char© is non-intuitive. -\item[Effect on original feature:] change to semantics of well-defined feature that depend on: -\begin{lstlisting} -sizeof( 'x' ) == sizeof( int ) -\end{lstlisting} -no long work the same in \CFA programs. -\item[Difficulty of converting:] simple -\item[How widely used:] programs that depend upon ©sizeof( 'x' )© are rare and can be changed to ©sizeof(char)©. -\end{description} - -\item -\begin{description} -\item[Change:] make string literals ©const©: -\begin{lstlisting} -char * p = "abc"; // valid in C, deprecated in §\CFA§ -char * q = expr ? "abc" : "de"; // valid in C, invalid in §\CFA§ -\end{lstlisting} -The type of a string literal is changed from ©[] char© to ©const [] char©. -Similarly, the type of a wide string literal is changed from ©[] wchar_t© to ©const [] wchar_t©. -\item[Rationale:] This change is a safety issue: -\begin{lstlisting} -char * p = "abc"; -p[0] = 'w'; // segment fault or change constant literal -\end{lstlisting} -The same problem occurs when passing a string literal to a routine that changes its argument. -\item[Effect on original feature:] change to semantics of well-defined feature. -\item[Difficulty of converting:] simple syntactic transformation, because string literals can be converted to ©char *©. -\item[How widely used:] programs that have a legitimate reason to treat string literals as pointers to potentially modifiable memory are rare. -\end{description} - -\item -\begin{description} -\item[Change:] remove \newterm{tentative definitions}, which only occurs at file scope: -\begin{lstlisting} -int i; // forward definition -int *j = ®&i®; // forward reference, valid in C, invalid in §\CFA§ -int i = 0; // definition -\end{lstlisting} -is valid in C, and invalid in \CFA because duplicate overloaded object definitions at the same scope level are disallowed. -This change makes it impossible to define mutually referential file-local static objects, if initializers are restricted to the syntactic forms of C. For example, -\begin{lstlisting} -struct X { int i; struct X *next; }; -static struct X a; // forward definition -static struct X b = { 0, ®&a® }; // forward reference, valid in C, invalid in §\CFA§ -static struct X a = { 1, &b }; // definition -\end{lstlisting} -\item[Rationale:] avoids having different initialization rules for builtin types and userdefined types. -\item[Effect on original feature:] change to semantics of well-defined feature. -\item[Difficulty of converting:] the initializer for one of a set of mutually-referential file-local static objects must invoke a routine call to achieve the initialization. -\item[How widely used:] seldom -\end{description} - -\item -\begin{description} -\item[Change:] have ©struct© introduce a scope for nested types -In C, the name of the nested types belongs to the same scope as the name of the outermost enclosing -Example: -\begin{lstlisting} -enum ®Colour® { R, G, B, Y, C, M }; -struct Person { - enum ®Colour® { R, G, B }; // nested type - struct Face { // nested type - ®Colour® Eyes, Hair; // type defined outside (1 level) - }; - ß.ß®Colour® shirt; // type defined outside (top level) - ®Colour® pants; // type defined same level - Face looks[10]; // type defined same level -}; -®Colour® c = R; // type/enum defined same level -Personß.ß®Colour® pc = Personß.ßR; // type/enum defined inside -Personß.ßFace pretty; // type defined inside -\end{lstlisting} -\item[Rationale:] ©struct© scope is crucial to \CFA as an information structuring and hiding mechanism. -\item[Effect on original feature:] change to semantics of well-defined feature. -\item[Difficulty of converting:] Semantic transformation. -\item[How widely used:] C programs rarely have nest types because they are equivalent to the hoisted version. - -\CFA is C \emph{incompatible} on this issue, and provides semantics similar to \Index*[C++]{\CC}. -Nested types are not hoisted and can be referenced using the field selection operator ``©.©'', unlike the \CC scope-resolution operator ``©::©''. -Given that nested types in C are equivalent to not using them, \ie they are essentially useless, it is unlikely there are any realistic usages that break because of this incompatibility. -\end{description} - -\item -\begin{description} -\item[Change:] In C++, the name of a nested class is local to its enclosing class. -\item[Rationale:] C++ classes have member functions which require that classes establish scopes. -\item[Difficulty of converting:] Semantic transformation. To make the struct type name visible in the scope of the enclosing struct, the struct tag could be declared in the scope of the enclosing struct, before the enclosing struct is defined. Example: -\begin{lstlisting} -struct Y; // struct Y and struct X are at the same scope -struct X { -struct Y { /* ... */ } y; -}; -\end{lstlisting} -All the definitions of C struct types enclosed in other struct definitions and accessed outside the scope of the enclosing struct could be exported to the scope of the enclosing struct. -Note: this is a consequence of the difference in scope rules, which is documented in 3.3. -\item[How widely used:] Seldom. -\end{description} - -\item -\begin{description} -\item[Change:] comma expression is disallowed as subscript -\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. -\item[Effect on original feature:] change to semantics of well-defined feature. -\item[Difficulty of converting:] semantic transformation of ©x[i,j]© to ©x[(i,j)]© -\item[How widely used:] seldom. -\end{description} -\end{enumerate} @@ -4749,4 +4762,5 @@ \subsection{malloc} +\leavevmode \begin{lstlisting}[aboveskip=0pt,belowskip=0pt] forall( otype T ) T * malloc( void );§\indexc{malloc}§ @@ -4765,8 +4779,9 @@ forall( otype T ) T * memset( T * ptr ); // remove when default value available \end{lstlisting} -\ + \subsection{ato / strto} +\leavevmode \begin{lstlisting}[aboveskip=0pt,belowskip=0pt] int ato( const char * ptr );§\indexc{ato}§ @@ -4796,9 +4811,9 @@ long double _Complex strto( const char * sptr, char ** eptr ); \end{lstlisting} -\ \subsection{bsearch / qsort} +\leavevmode \begin{lstlisting}[aboveskip=0pt,belowskip=0pt] forall( otype T | { int ?get_link() ) { - set_link( o->get_link()->clone() ); + if ( o->get_next() ) { + set_last( o->get_next()->clone() ); } // if } // if @@ -757,5 +757,5 @@ DeclarationNode *DeclarationNode::appendList( DeclarationNode *node ) { if ( node != 0 ) { - set_link( node ); + set_last( node ); } // if return this; @@ -794,5 +794,5 @@ errors.append( e ); } // try - cur = dynamic_cast( cur->get_link() ); + cur = dynamic_cast( cur->get_next() ); } // while if ( ! errors.isEmpty() ) { @@ -831,5 +831,5 @@ errors.append( e ); } // try - cur = dynamic_cast< DeclarationNode *>( cur->get_link() ); + cur = dynamic_cast< DeclarationNode *>( cur->get_next() ); } // while if ( ! errors.isEmpty() ) { @@ -848,5 +848,5 @@ errors.append( e ); } // try - cur = dynamic_cast< DeclarationNode *>( cur->get_link() ); + cur = dynamic_cast< DeclarationNode *>( cur->get_next() ); } // while if ( ! errors.isEmpty() ) { Index: src/Parser/ExpressionNode.cc =================================================================== --- src/Parser/ExpressionNode.cc (revision 387368546018aa1d0ac996c3a245f916a26a8cd2) +++ src/Parser/ExpressionNode.cc (revision 6603c1dbfb45fe26d6acd74a1e2ed275886ab34e) @@ -10,6 +10,6 @@ // Created On : Sat May 16 13:17:07 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Wed Aug 10 11:07:38 2016 -// Update Count : 486 +// Last Modified On : Thu Aug 11 20:24:36 2016 +// Update Count : 487 // @@ -309,57 +309,4 @@ //############################################################################## - -// ForCtlExprNode::ForCtlExprNode( ParseNode *init_, ExpressionNode *cond, ExpressionNode *incr ) throw ( SemanticError ) : condition( cond ), change( incr ) { -// if ( init_ == 0 ) -// init = 0; -// else { -// DeclarationNode *decl; -// ExpressionNode *exp; - -// if (( decl = dynamic_cast(init_) ) != 0) -// init = new StatementNode( decl ); -// else if (( exp = dynamic_cast( init_)) != 0) -// init = new StatementNode( StatementNode::Exp, exp ); -// else -// throw SemanticError("Error in for control expression"); -// } -// } - -// ForCtlExprNode::ForCtlExprNode( const ForCtlExprNode &other ) -// : ExpressionNode( other ), init( maybeClone( other.init ) ), condition( maybeClone( other.condition ) ), change( maybeClone( other.change ) ) { -// } - -// ForCtlExprNode::~ForCtlExprNode() { -// delete init; -// delete condition; -// delete change; -// } - -// Expression *ForCtlExprNode::build() const { -// // this shouldn't be used! -// assert( false ); -// return 0; -// } - -// void ForCtlExprNode::print( std::ostream &os, int indent ) const{ -// os << string( indent,' ' ) << "For Control Expression -- :" << endl; - -// os << string( indent + 2, ' ' ) << "initialization:" << endl; -// if ( init != 0 ) -// init->printList( os, indent + 4 ); - -// os << string( indent + 2, ' ' ) << "condition: " << endl; -// if ( condition != 0 ) -// condition->print( os, indent + 4 ); -// os << string( indent + 2, ' ' ) << "increment: " << endl; -// if ( change != 0 ) -// change->print( os, indent + 4 ); -// } - -// void ForCtlExprNode::printOneLine( std::ostream &, int indent ) const { -// assert( false ); -// } - -//############################################################################## Expression *build_typevalue( DeclarationNode *decl ) { Index: src/Parser/InitializerNode.cc =================================================================== --- src/Parser/InitializerNode.cc (revision 387368546018aa1d0ac996c3a245f916a26a8cd2) +++ src/Parser/InitializerNode.cc (revision 6603c1dbfb45fe26d6acd74a1e2ed275886ab34e) @@ -10,6 +10,6 @@ // Created On : Sat May 16 13:20:24 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon Jul 4 15:37:15 2016 -// Update Count : 15 +// Last Modified On : Sat Aug 13 18:55:11 2016 +// Update Count : 18 // @@ -25,8 +25,8 @@ : expr( _expr ), aggregate( aggrp ), designator( des ), kids( 0 ), maybeConstructed( true ) { if ( aggrp ) - kids = dynamic_cast< InitializerNode *>( get_link() ); + kids = dynamic_cast< InitializerNode *>( get_next() ); if ( kids != 0 ) - set_link( 0 ); + set_last( 0 ); } @@ -34,8 +34,8 @@ : expr( 0 ), aggregate( aggrp ), designator( des ), kids( 0 ), maybeConstructed( true ) { if ( init != 0 ) - set_link(init); + set_last( init ); if ( aggrp ) - kids = dynamic_cast< InitializerNode *>( get_link() ); + kids = dynamic_cast< InitializerNode *>( get_next() ); if ( kids != 0 ) @@ -58,5 +58,5 @@ while ( curdes != 0) { curdes->printOneLine(os); - curdes = (ExpressionNode *)(curdes->get_link()); + curdes = (ExpressionNode *)(curdes->get_next()); if ( curdes ) os << ", "; } // while @@ -72,5 +72,5 @@ InitializerNode *moreInit; - if ( get_link() != 0 && ((moreInit = dynamic_cast< InitializerNode * >( get_link() ) ) != 0) ) + if ( get_next() != 0 && ((moreInit = dynamic_cast< InitializerNode * >( get_next() ) ) != 0) ) moreInit->printOneLine( os ); } Index: src/Parser/ParseNode.cc =================================================================== --- src/Parser/ParseNode.cc (revision 387368546018aa1d0ac996c3a245f916a26a8cd2) +++ src/Parser/ParseNode.cc (revision 6603c1dbfb45fe26d6acd74a1e2ed275886ab34e) @@ -10,6 +10,6 @@ // Created On : Sat May 16 13:26:29 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Sun Aug 7 23:32:47 2016 -// Update Count : 94 +// Last Modified On : Sat Aug 13 18:55:35 2016 +// Update Count : 98 // @@ -31,11 +31,10 @@ ParseNode *current = this; - while ( current->get_link() != 0 ) - current = current->get_link(); - + while ( current->get_next() != 0 ) + current = current->get_next(); return current; } -ParseNode *ParseNode::set_link( ParseNode *next_ ) { +ParseNode *ParseNode::set_last( ParseNode *next_ ) { if ( next_ != 0 ) get_last()->next = next_; return this; @@ -54,6 +53,5 @@ ParseNode &ParseNode::operator,( ParseNode &p ) { - set_link( &p ); - + set_last( &p ); return *this; } Index: src/Parser/ParseNode.h =================================================================== --- src/Parser/ParseNode.h (revision 387368546018aa1d0ac996c3a245f916a26a8cd2) +++ src/Parser/ParseNode.h (revision 6603c1dbfb45fe26d6acd74a1e2ed275886ab34e) @@ -10,6 +10,6 @@ // Created On : Sat May 16 13:28:16 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Aug 11 12:24:11 2016 -// Update Count : 443 +// Last Modified On : Sun Aug 14 16:29:20 2016 +// Update Count : 483 // @@ -45,8 +45,8 @@ virtual ~ParseNode(); - ParseNode *get_link() const { return next; } + ParseNode *get_next() const { return next; } + ParseNode *set_next( ParseNode *newlink ) { next = newlink; return this; } ParseNode *get_last(); - ParseNode *set_link( ParseNode * ); - void set_next( ParseNode *newlink ) { next = newlink; } + ParseNode *set_last( ParseNode * ); virtual ParseNode *clone() const { return 0; }; @@ -92,5 +92,5 @@ ExpressionNode *expr; bool aggregate; - ExpressionNode *designator; // may be list + ExpressionNode *designator; // may be list InitializerNode *kids; bool maybeConstructed; @@ -336,18 +336,6 @@ StatementNode(); - StatementNode( const std::string *name ); - StatementNode( Type t, ExpressionNode *control = 0, StatementNode *block = 0 ); - StatementNode( Type t, std::string *target ); StatementNode( DeclarationNode *decl ); - ~StatementNode(); - - static StatementNode *newCatchStmt( DeclarationNode *d = 0, StatementNode *s = 0, bool catchRestP = false ); - - StatementNode *set_block( StatementNode *b ) { block = b; return this; } - StatementNode *get_block() const { return block; } - - void set_control( ExpressionNode *c ) { control = c; } - ExpressionNode *get_control() const { return control; } StatementNode::Type get_type() const { return type; } @@ -357,30 +345,22 @@ void addDeclaration( DeclarationNode *newDecl ) { decl = newDecl; } - void setCatchRest( bool newVal ) { isCatchRest = newVal; } - - std::string get_target() const; - - // StatementNode *add_controlexp( ExpressionNode * ); - StatementNode *append_block( StatementNode * ); + virtual StatementNode *append_last_case( StatementNode * ); - void print( std::ostream &os, int indent = 0) const; + virtual void print( std::ostream &os, int indent = 0) const {} virtual StatementNode *clone() const; virtual Statement *build() const; - private: + public: static const char *StType[]; Type type; - ExpressionNode *control; - StatementNode *block; std::list labels; - std::string *target; // target label for jump statements DeclarationNode *decl; - bool isCatchRest; }; // StatementNode class StatementNode2 : public StatementNode { public: - StatementNode2() {} + StatementNode2() { stmt = nullptr; } StatementNode2( Statement *stmt ) : stmt( stmt ) {} + StatementNode2( DeclarationNode *decl ); virtual ~StatementNode2() {} @@ -392,6 +372,7 @@ return this; } + virtual std::list get_labels() const { assert( false ); return StatementNode::get_labels(); } + virtual StatementNode *append_last_case( StatementNode * ); - virtual std::list get_labels() const { assert( false ); return StatementNode::get_labels(); } virtual void print( std::ostream &os, int indent = 0 ) {} @@ -401,9 +382,11 @@ }; // StatementNode +Statement *build_expr( ExpressionNode *ctl ); + struct ForCtl { ForCtl( ExpressionNode *expr, ExpressionNode *condition, ExpressionNode *change ) : - init( new StatementNode( StatementNode::Exp, expr ) ), condition( condition ), change( change ) {} + init( new StatementNode2( build_expr( expr ) ) ), condition( condition ), change( change ) {} ForCtl( DeclarationNode *decl, ExpressionNode *condition, ExpressionNode *change ) : - init( new StatementNode( decl ) ), condition( condition ), change( change ) {} + init( new StatementNode2( decl ) ), condition( condition ), change( change ) {} StatementNode *init; @@ -412,5 +395,4 @@ }; -Statement *build_expr( ExpressionNode *ctl ); Statement *build_if( ExpressionNode *ctl, StatementNode *then_stmt, StatementNode *else_stmt ); Statement *build_switch( ExpressionNode *ctl, StatementNode *stmt ); @@ -423,4 +405,7 @@ Statement *build_return( ExpressionNode *ctl ); Statement *build_throw( ExpressionNode *ctl ); +Statement *build_try( StatementNode *try_stmt, StatementNode *catch_stmt, StatementNode *finally_stmt ); +Statement *build_catch( DeclarationNode *decl, StatementNode *stmt, bool catchAny = false ); +Statement *build_finally( StatementNode *stmt ); //############################################################################## @@ -429,5 +414,4 @@ public: CompoundStmtNode(); - CompoundStmtNode( const std::string * ); CompoundStmtNode( StatementNode * ); ~CompoundStmtNode(); @@ -445,8 +429,8 @@ class AsmStmtNode : public StatementNode { public: - AsmStmtNode( Type, bool voltile, ConstantExpr *instruction, ExpressionNode *output = 0, ExpressionNode *input = 0, ExpressionNode *clobber = 0, LabelNode *gotolabels = 0 ); + AsmStmtNode( bool voltile, ConstantExpr *instruction, ExpressionNode *output = 0, ExpressionNode *input = 0, ExpressionNode *clobber = 0, LabelNode *gotolabels = 0 ); ~AsmStmtNode(); - void print( std::ostream &os, int indent = 0 ) const; + void print( std::ostream &os, int indent = 0 ) const {} Statement *build() const; private: @@ -477,5 +461,5 @@ errors.append( e ); } // try - cur = dynamic_cast< NodeType *>( cur->get_link() ); + cur = dynamic_cast< NodeType *>( cur->get_next() ); } // while if ( ! errors.isEmpty() ) { Index: src/Parser/StatementNode.cc =================================================================== --- src/Parser/StatementNode.cc (revision 387368546018aa1d0ac996c3a245f916a26a8cd2) +++ src/Parser/StatementNode.cc (revision 6603c1dbfb45fe26d6acd74a1e2ed275886ab34e) @@ -10,6 +10,6 @@ // Created On : Sat May 16 14:59:41 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Aug 11 16:19:45 2016 -// Update Count : 210 +// Last Modified On : Sun Aug 14 13:10:54 2016 +// Update Count : 288 // @@ -34,9 +34,8 @@ }; -StatementNode::StatementNode() : ParseNode(), control( 0 ), block( 0 ), labels( 0 ), target( 0 ), decl( 0 ), isCatchRest ( false ) {} - -StatementNode::StatementNode( const string *name ) : ParseNode( name ), control( 0 ), block( 0 ), labels( 0 ), target( 0 ), decl( 0 ), isCatchRest ( false ) {} - -StatementNode::StatementNode( DeclarationNode *decl ) : type( Decl ), control( 0 ), block( 0 ), labels( 0 ), target( 0 ), isCatchRest ( false ) { +StatementNode::StatementNode() : ParseNode(), labels( 0 ), decl( 0 ) {} + +StatementNode::StatementNode( DeclarationNode *decl ) : type( Decl ), labels( 0 ) { + assert( false ); if ( decl ) { if ( DeclarationNode *agg = decl->extractAggregate() ) { @@ -46,11 +45,11 @@ nextStmt->decl = decl; next = nextStmt; - if ( decl->get_link() ) { - next->set_next( new StatementNode( dynamic_cast< DeclarationNode* >( decl->get_link() ) ) ); + if ( decl->get_next() ) { + next->set_next( new StatementNode( dynamic_cast( decl->get_next() ) ) ); decl->set_next( 0 ); } // if } else { - if ( decl->get_link() ) { - next = new StatementNode( dynamic_cast< DeclarationNode* >( decl->get_link() ) ); + if ( decl->get_next() ) { + next = new StatementNode( dynamic_cast( decl->get_next() ) ); decl->set_next( 0 ); } // if @@ -60,41 +59,36 @@ } -StatementNode::StatementNode( Type t, ExpressionNode *ctrl_label, StatementNode *block ) : type( t ), control( ctrl_label ), block( block ), labels( 0 ), target( 0 ), decl( 0 ), isCatchRest ( false ) { - this->control = ( t == Default ) ? 0 : control; -} - -StatementNode::StatementNode( Type t, string *target ) : type( t ), control( 0 ), block( 0 ), labels( 0 ), target( target ), decl( 0 ), isCatchRest ( false ) {} +StatementNode2::StatementNode2( DeclarationNode *decl ) { + if ( decl ) { + DeclarationNode *agg = decl->extractAggregate(); + if ( agg ) { + StatementNode *nextStmt = new StatementNode; + nextStmt->type = Decl; + nextStmt->decl = decl; + next = nextStmt; + if ( decl->get_next() ) { + next->set_next( new StatementNode2( dynamic_cast(decl->get_next()) ) ); + decl->set_next( 0 ); + } // if + } else { + if ( decl->get_next() ) { + next = new StatementNode2( dynamic_cast( decl->get_next() ) ); + decl->set_next( 0 ); + } // if + agg = decl; + } // if + stmt = new DeclStmt( noLabels, maybeBuild(agg) ); + } else { + assert( false ); + } // if +} StatementNode::~StatementNode() { - delete control; - delete block; - delete target; delete decl; } -StatementNode * StatementNode::newCatchStmt( DeclarationNode *d, StatementNode *s, bool catchRestP ) { - StatementNode *ret = new StatementNode( StatementNode::Catch, 0, s ); - ret->addDeclaration( d ); - ret->setCatchRest( catchRestP ); - - return ret; -} - -std::string StatementNode::get_target() const{ - if ( target ) - return *target; - - return string(""); -} - StatementNode * StatementNode::clone() const { - StatementNode *newnode = new StatementNode( type, maybeClone( control ), maybeClone( block ) ); - if ( target ) { - newnode->target = new string( *target ); - } else { - newnode->target = 0; - } // if - newnode->decl = maybeClone( decl ); - return newnode; + assert( false ); + return 0; } @@ -107,26 +101,6 @@ } -StatementNode *StatementNode::append_block( StatementNode *stmt ) { - if ( stmt != 0 ) { - if ( block == 0 ) - block = stmt; - else - block->set_link( stmt ); - } // if - return this; -} - StatementNode *StatementNode::append_last_case( StatementNode *stmt ) { assert( false ); - if ( stmt != 0 ) { - StatementNode *next = ( StatementNode *)get_link(); - if ( next && ( next->get_type() == StatementNode::Case || next->get_type() == StatementNode::Default ) ) - next->append_last_case( stmt ); - else - if ( block == 0 ) - block = stmt; - else - block->set_link( stmt ); - } // if return this; } @@ -134,5 +108,6 @@ StatementNode *StatementNode2::append_last_case( StatementNode *stmt ) { StatementNode *prev = this; - for ( StatementNode * curr = prev; curr != nullptr; curr = (StatementNode *)curr->get_link() ) { + // find end of list and maintain previous pointer + for ( StatementNode * curr = prev; curr != nullptr; curr = (StatementNode *)curr->get_next() ) { StatementNode2 *node = dynamic_cast(curr); assert( node ); @@ -140,195 +115,38 @@ prev = curr; } // for + // conver from StatementNode list to Statement list StatementNode2 *node = dynamic_cast(prev); std::list stmts; buildList( stmt, stmts ); - CaseStmt * caseStmt; - caseStmt = dynamic_cast(node->stmt); + // splice any new Statements to end of currents Statements + CaseStmt * caseStmt = dynamic_cast(node->stmt); caseStmt->get_statements().splice( caseStmt->get_statements().end(), stmts ); return this; } -void StatementNode::print( std::ostream &os, int indent ) const { - if ( ! labels.empty() ) { - std::list::const_iterator i; - - os << string( indent, ' ' ); - for ( i = labels.begin(); i != labels.end(); i++ ) - os << *i << ":"; - os << endl; - } // if - +Statement *StatementNode::build() const { switch ( type ) { case Decl: - decl->print( os, indent ); - break; + return new DeclStmt( noLabels, maybeBuild< Declaration >( decl ) ); + assert( false ); case Exp: - if ( control ) { - os << string( indent, ' ' ); - control->print( os, indent ); - os << endl; - } else - os << string( indent, ' ' ) << "Null Statement" << endl; - break; - default: - os << string( indent, ' ' ) << StatementNode::StType[type] << endl; - if ( type == Catch ) { - if ( decl ) { - os << string( indent + ParseNode::indent_by, ' ' ) << "Declaration: " << endl; - decl->print( os, indent + 2 * ParseNode::indent_by ); - } else if ( isCatchRest ) { - os << string( indent + ParseNode::indent_by, ' ' ) << "Catches the rest " << endl; - } else { - ; // should never reach here - } // if - } // if - if ( control ) { - os << string( indent + ParseNode::indent_by, ' ' ) << "Control: " << endl; - control->printList( os, indent + 2 * ParseNode::indent_by ); - } // if - if ( block ) { - os << string( indent + ParseNode::indent_by, ' ' ) << "Cases: " << endl; - block->printList( os, indent + 2 * ParseNode::indent_by ); - } // if - if ( target ) { - os << string( indent + ParseNode::indent_by, ' ' ) << "Target: " << get_target() << endl; - } // if - break; - } // switch -} - -Statement *StatementNode::build() const { - std::list branches; - std::list exps; - std::list