Index: doc/theses/fangren_yu_COOP_S20/Report.tex =================================================================== --- doc/theses/fangren_yu_COOP_S20/Report.tex (revision b4b63e8f7b73b2f77b154650ba47a2df216a9713) +++ doc/theses/fangren_yu_COOP_S20/Report.tex (revision dd53f757269164e57222b201af9b60c094c663de) @@ -13,8 +13,14 @@ \usepackage{latexsym} % \Box glyph \usepackage{mathptmx} % better math font with "times" +\usepackage{appendix} \usepackage[usenames]{color} \input{common} % common CFA document macros \usepackage[dvips,plainpages=false,pdfpagelabels,pdfpagemode=UseNone,colorlinks=true,pagebackref=true,linkcolor=blue,citecolor=blue,urlcolor=blue,pagebackref=true,breaklinks=true]{hyperref} \usepackage{breakurl} +\urlstyle{sf} + +% reduce spacing +\setlist[itemize]{topsep=5pt,parsep=0pt}% global +\setlist[enumerate]{topsep=5pt,parsep=0pt}% global \usepackage[pagewise]{lineno} @@ -112,5 +118,5 @@ \begin{itemize} \item -type declaration: @struct@, @union@, @typedef@ or type parameter (see Appendix A.1) +type declaration: @struct@, @union@, @typedef@ or type parameter (see \VRef[Appendix]{s:KindsTypeParameters}) \item variable declaration @@ -374,4 +380,6 @@ \subsubsection{Source: \lstinline{AST/SymbolTable.hpp}} + + \subsubsection{Source: \lstinline{SymTab/Indexer.h}} @@ -526,17 +534,23 @@ Each pair of compatible branch expression types produce a possible interpretation, and the cost is defined as the sum of the expression costs plus the sum of conversion costs to the common type. + \subsection{Conversion and Application Cost} -There were some unclear parts in the previous documentation of cost system, as described in the Moss thesis \cite{Moss19}, section 4.1.2. Some clarification are presented in this section. + +There were some unclear parts in the previous documentation in the cost system, as described in the Moss thesis~\cite{Moss19}, section 4.1.2. +Some clarification are presented in this section. \begin{enumerate} \item -Conversion to a type denoted by parameter may incur additional cost if the match is not exact. For example, if a function is declared to accept @(T, T)@ and receives @(int, long)@, @T@ is deducted @long@ and an additional widening conversion cost is added for @int@ to @T@. - -\item -The specialization level of a function is the sum of the least depth of an appearance of type parameter (counting pointers, references and parameterized types), plus the number of assertions. A higher specialization level is favored if conversion cost of arguments are equal. - -\item -Coercion of pointer types is only allowed in explicit cast expressions; the only allowed implicit pointer casts are adding qualifiers to the base type and cast to @void*@, and those counts as safe conversions. Note that implicit cast from @void*@ to other pointer types is no longer valid, as opposed to standard C. - +Conversion to a type denoted by parameter may incur additional cost if the match is not exact. +For example, if a function is declared to accept @(T, T)@ and receives @(int, long)@, @T@ is deducted @long@ and an additional widening conversion cost is added for @int@ to @T@. + +\item +The specialization level of a function is the sum of the least depth of an appearance of a type parameter (counting pointers, references and parameterized types), plus the number of assertions. +A higher specialization level is favoured if argument conversion costs are equal. + +\item +Coercion of pointer types is only allowed in explicit cast expressions; +the only allowed implicit pointer casts are adding qualifiers to the base type and cast to @void*@, and these counts as safe conversions. +Note that implicit cast from @void *@ to other pointer types is no longer valid, as opposed to standard C. \end{enumerate} @@ -556,5 +570,5 @@ At the call site, implicit parameters are automatically inserted by the compiler. -Implementation of implicit parameters is discussed in Appendix A.3. +Implementation of implicit parameters is discussed in \VRef[Appendix]{s:ImplementationParametricFunctions}. \section{Tests} @@ -597,18 +611,40 @@ It is suggested to run performance tests with optimization (@g++@ flag @-O3@). + +\begin{appendices}[toc,titletoc] \section{Appendix} + \subsection{Kinds of Type Parameters} -The type parameters in a @forall@ clause has three different kinds: -\begin{enumerate} -\item -@dtype@: any data type (built-in or user defined). There is also a difference between opaque types (incomplete types, those with only a forward declaration) and concrete types. Only concrete types can be directly used as a variable type. \CFA provides the @otype@ shorthand to require a type parameter as concrete, which also implicitly asserts the existence of its constructor and destructor\footnote{\CFA implements the same automatic resource management (RAII) semantics as \CC.}. -\item -@ftype@: any function type. Since @ftype@ does not provide any information about parameter types of a function, it is rarely used. The main purpose of introducing @ftype@ is to disallow a function to match a pointer overload, since variables and functions can have the same names. -\item -@ttype@: tuple (variadic) type. @ttype@ parameter may only appear as type of the last parameter in a function, and it provides a type-safe way to implement variadic functions. Note however, that it has certain restrictions, as described in the implementation section below. - +\label{s:KindsTypeParameters} + +A type parameter in a @forall@ clause has three possible kinds: +\begin{enumerate}[listparindent=0pt] +\item +@dtype@: any data type (built-in or user defined). + +There is also a difference between opaque types (incomplete types, \ie those with only a forward declaration) and concrete types. +Only concrete types can be directly used as a variable type. + +\CFA provides the @otype@ shorthand to require a type parameter be concrete, which also implicitly asserts the existence of its default and copy constructors, assignment, and destructor\footnote{\CFA implements the same automatic resource management (RAII) semantics as \CC.}. +\item +@ftype@: any function type. + +@ftype@ provides two purposes: +\begin{itemize} +\item +Differentiate function pointer from data pointer because (in theory) some systems have different sizes for these pointers. +\item +Disallow a function pointer to match an overloaded data pointer, since variables and functions can have the same names. +\end{itemize} + +\item +@ttype@: tuple (variadic) type. + +@ttype@ parameter may only appear as type of the last parameter in a function, and it provides a type-safe way to implement variadic functions. +Note however, that it has certain restrictions, as described in the implementation section below. \end{enumerate} + \subsection{GNU C Nested Functions} @@ -616,21 +652,21 @@ In ISO C, function definitions are not allowed to be nested. GCC allows nested functions with full lexical scoping. The following example is taken from GCC documentation\footnote{\url{https://gcc.gnu.org/onlinedocs/gcc/Nested-Functions.html}}: - -\begin{C++} -bar (int *array, int offset, int size) -{ - int access (int *array, int index) - { return array[index + offset]; } - int i; - /* ... */ - for (i = 0; i < size; i++) - /* ... */ access (array, i) /* ... */ +\begin{C++} +void bar( int * array, int offset, int size ) { + int access( int * array, int index ) { return array[index + offset]; } + int i; + /* ... */ + for ( i = 0; i < size; i++ ) + /* ... */ access (array, i) /* ... */ } \end{C++} - -GCC nested functions behave identically to \CC lambda functions with default by-reference capture (stack-allocated, lifetime ends upon exiting the block declared in), while also possible to be passed as arguments with standard function pointer types. +GCC nested functions behave identically to \CC lambda functions with default by-reference capture (stack-allocated, lifetime ends upon exiting the declared block), while also possible to be passed as arguments with standard function pointer types. + \subsection{Implementation of Parametric Functions} -\CFA implements parametric functions using the implicit parameter approach: required assertions are passed to the callee by function pointers; size of a parametric type must also be known if referenced directly (i.e. not as a pointer). +\label{s:ImplementationParametricFunctions} + +\CFA implements parametric functions using the implicit parameter approach: required assertions are passed to the callee by function pointers; +size of a parametric type must also be known if referenced directly (\ie not as a pointer). The implementation is similar to the one from Scala\footnote{\url{https://www.scala-lang.org/files/archive/spec/2.13/07-implicits.html}}, with some notable differences in resolution: @@ -641,21 +677,20 @@ The parameter (assertion) name must match the actual declarations. \item -Currently, assertions are all functions. Note that since \CFA has variable overloading, implicit value parameters might also be supported in the future. +Currently, assertions are all functions. +Note that since \CFA has variable overloading, implicit value parameters might also be supported in the future. \end{enumerate} For example, the \CFA function declaration - \begin{cfa} -forall(otype T | {int foo(T, int);}) +forall( otype T | { int foo( T, int ); } ) int bar(T); \end{cfa} - after implicit parameter expansion, has the actual signature\footnote{\textbf{otype} also requires the type to have constructor and destructor, which are the first two function pointers preceding the one for \textbf{foo}.} - -\begin{C++} -int bar(T, size_t, void (*)(T&), void (*)(T&), int (*)(T, int)); -\end{C++} - -The implicit parameter approach has an apparent issue: when the satisfying declaration is also parametric, it may require its own implicit parameters too. That also causes the supplied implicit parameter to have a different \textbf{actual} type than the \textbf{nominal} type, so it cannot be passed directly. Therefore, a wrapper with matching actual type must be created, and here it is where GCC nested function is used internally by the compiler. +\begin{C++} +int bar( T, size_t, void (*)(T&), void (*)(T&), int (*)(T, int) ); +\end{C++} +The implicit parameter approach has an apparent issue: when the satisfying declaration is also parametric, it may require its own implicit parameters too. +That also causes the supplied implicit parameter to have a different \textbf{actual} type than the \textbf{nominal} type, so it cannot be passed directly. +Therefore, a wrapper with matching actual type must be created, and it is here where GCC nested functions are used internally by the compiler. Consider the following program: @@ -663,15 +698,13 @@ int assertion(int); -forall (otype T | {int assertion(T);}) +forall( otype T | { int assertion(T); } ) void foo(T); -forall (otype T | {void foo(T);}) +forall(otype T | { void foo(T); } ) void bar(T t) { foo(t); } \end{cfa} - -\CFA compiler translates the program to non-parametric form\footnote{In the final code output, T needs to be replaced by an opaque type, and arguments must be accessed by a frame pointer offset table, due to the unknown sizes. The presented code here is simplified for better understanding.} - +The \CFA compiler translates the program to non-parametric form\footnote{In the final code output, \lstinline@T@ needs to be replaced by an opaque type, and arguments must be accessed by a frame pointer offset table, due to the unknown sizes. The presented code here is simplified for better understanding.} \begin{C++} // ctor, dtor and size arguments are omitted @@ -682,23 +715,22 @@ } \end{C++} - However, when @bar(1)@ is called, @foo@ cannot be directly provided as an argument: - \begin{C++} bar(1, foo); // WRONG: foo has different actual type \end{C++} - and an additional step is required: - \begin{C++} { void _foo_wrapper(int t) { - foo(t, assertion); + foo( t, assertion ); } - bar(1, _foo_wrapper); + bar( 1, _foo_wrapper ); } \end{C++} - -Nested assertions and implicit parameter creation may continue indefinitely. This is a limitation of implicit parameter implementation. In particular, polymorphic variadic recursion must be structural (i.e. number of arguments decreases in any possible recursive calls), otherwise code generation gets into an infinite loop. \CFA compiler sets a limit on assertion depth and reports an error if assertion resolution does not terminate within the limit. +Nested assertions and implicit parameter creation may continue indefinitely. +This issue is a limitation of implicit parameter implementation. +In particular, polymorphic variadic recursion must be structural (\ie the number of arguments decreases in any possible recursive calls), otherwise code generation gets into an infinite loop. +The \CFA compiler sets a limit on assertion depth and reports an error if assertion resolution does not terminate within the limit (as for \lstinline[language=C++]@templates@ in \CC). +\end{appendices} \bibliographystyle{plain} Index: libcfa/src/limits.cfa =================================================================== --- libcfa/src/limits.cfa (revision b4b63e8f7b73b2f77b154650ba47a2df216a9713) +++ libcfa/src/limits.cfa (revision dd53f757269164e57222b201af9b60c094c663de) @@ -10,6 +10,6 @@ // Created On : Wed Apr 6 18:06:52 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Mar 1 16:22:51 2018 -// Update Count : 74 +// Last Modified On : Wed Sep 30 22:56:32 2020 +// Update Count : 76 // @@ -23,131 +23,131 @@ // Integral Constants -const signed char MIN = SCHAR_MIN; -const unsigned char MIN = 0; -const short int MIN = SHRT_MIN; -const unsigned short int MIN = 0; -const int MIN = INT_MIN; -const unsigned int MIN = 0; -const long int MIN = LONG_MIN; -const unsigned long int MIN = 0; -const long long int MIN = LLONG_MIN; -const unsigned long long int MIN = 0; +signed char MIN = SCHAR_MIN; +unsigned char MIN = 0; +short int MIN = SHRT_MIN; +unsigned short int MIN = 0; +int MIN = INT_MIN; +unsigned int MIN = 0; +long int MIN = LONG_MIN; +unsigned long int MIN = 0; +long long int MIN = LLONG_MIN; +unsigned long long int MIN = 0; -const signed char MAX = SCHAR_MAX; -const unsigned char MAX = UCHAR_MAX; -const short int MAX = SHRT_MAX; -const unsigned short int MAX = USHRT_MAX; -const int MAX = INT_MAX; -const unsigned int MAX = UINT_MAX; -const long int MAX = LONG_MAX; -const unsigned long int MAX = ULONG_MAX; -const long long int MAX = LLONG_MAX; -const unsigned long long int MAX = ULLONG_MAX; +signed char MAX = SCHAR_MAX; +unsigned char MAX = UCHAR_MAX; +short int MAX = SHRT_MAX; +unsigned short int MAX = USHRT_MAX; +int MAX = INT_MAX; +unsigned int MAX = UINT_MAX; +long int MAX = LONG_MAX; +unsigned long int MAX = ULONG_MAX; +long long int MAX = LLONG_MAX; +unsigned long long int MAX = ULLONG_MAX; // Floating-Point Constants -const float MIN = FLT_MIN; -const double MIN = DBL_MIN; -const long double MIN = LDBL_MIN; -const float _Complex MIN = __FLT_MIN__ + __FLT_MIN__ * I; -const double _Complex MIN = DBL_MIN + DBL_MIN * I; -const long double _Complex MIN = LDBL_MIN + LDBL_MIN * I; +float MIN = FLT_MIN; +double MIN = DBL_MIN; +long double MIN = LDBL_MIN; +float _Complex MIN = __FLT_MIN__ + __FLT_MIN__ * I; +double _Complex MIN = DBL_MIN + DBL_MIN * I; +long double _Complex MIN = LDBL_MIN + LDBL_MIN * I; -const float MAX = FLT_MAX; -const double MAX = DBL_MAX; -const long double MAX = LDBL_MAX; -const float _Complex MAX = FLT_MAX + FLT_MAX * I; -const double _Complex MAX = DBL_MAX + DBL_MAX * I; -const long double _Complex MAX = LDBL_MAX + LDBL_MAX * I; +float MAX = FLT_MAX; +double MAX = DBL_MAX; +long double MAX = LDBL_MAX; +float _Complex MAX = FLT_MAX + FLT_MAX * I; +double _Complex MAX = DBL_MAX + DBL_MAX * I; +long double _Complex MAX = LDBL_MAX + LDBL_MAX * I; -const float PI = (float)M_PI; // pi -const float PI_2 = (float)M_PI_2; // pi / 2 -const float PI_4 = (float)M_PI_4; // pi / 4 -const float _1_PI = (float)M_1_PI; // 1 / pi -const float _2_PI = (float)M_2_PI; // 2 / pi -const float _2_SQRT_PI = (float)M_2_SQRTPI; // 2 / sqrt(pi) +float PI = (float)M_PI; // pi +float PI_2 = (float)M_PI_2; // pi / 2 +float PI_4 = (float)M_PI_4; // pi / 4 +float _1_PI = (float)M_1_PI; // 1 / pi +float _2_PI = (float)M_2_PI; // 2 / pi +float _2_SQRT_PI = (float)M_2_SQRTPI; // 2 / sqrt(pi) -const double PI = M_PI; // pi -const double PI_2 = M_PI_2; // pi / 2 -const double PI_4 = M_PI_4; // pi / 4 -const double _1_PI = M_1_PI; // 1 / pi -const double _2_PI = M_2_PI; // 2 / pi -const double _2_SQRT_PI = M_2_SQRTPI; // 2 / sqrt(pi) +double PI = M_PI; // pi +double PI_2 = M_PI_2; // pi / 2 +double PI_4 = M_PI_4; // pi / 4 +double _1_PI = M_1_PI; // 1 / pi +double _2_PI = M_2_PI; // 2 / pi +double _2_SQRT_PI = M_2_SQRTPI; // 2 / sqrt(pi) -const long double PI = M_PIl; // pi -const long double PI_2 = M_PI_2l; // pi / 2 -const long double PI_4 = M_PI_4l; // pi / 4 -const long double _1_PI = M_1_PIl; // 1 / pi -const long double _2_PI = M_2_PIl; // 2 / pi -const long double _2_SQRT_PI = M_2_SQRTPIl; // 2 / sqrt(pi) +long double PI = M_PIl; // pi +long double PI_2 = M_PI_2l; // pi / 2 +long double PI_4 = M_PI_4l; // pi / 4 +long double _1_PI = M_1_PIl; // 1 / pi +long double _2_PI = M_2_PIl; // 2 / pi +long double _2_SQRT_PI = M_2_SQRTPIl; // 2 / sqrt(pi) -const float _Complex PI = (float)M_PI + 0.0_iF; // pi -const float _Complex PI_2 = (float)M_PI_2 + 0.0_iF; // pi / 2 -const float _Complex PI_4 = (float)M_PI_4 + 0.0_iF; // pi / 4 -const float _Complex _1_PI = (float)M_1_PI + 0.0_iF; // 1 / pi -const float _Complex _2_PI = (float)M_2_PI + 0.0_iF; // 2 / pi -const float _Complex _2_SQRT_PI = (float)M_2_SQRTPI + 0.0_iF; // 2 / sqrt(pi) +float _Complex PI = (float)M_PI + 0.0_iF; // pi +float _Complex PI_2 = (float)M_PI_2 + 0.0_iF; // pi / 2 +float _Complex PI_4 = (float)M_PI_4 + 0.0_iF; // pi / 4 +float _Complex _1_PI = (float)M_1_PI + 0.0_iF; // 1 / pi +float _Complex _2_PI = (float)M_2_PI + 0.0_iF; // 2 / pi +float _Complex _2_SQRT_PI = (float)M_2_SQRTPI + 0.0_iF; // 2 / sqrt(pi) -const double _Complex PI = M_PI + 0.0_iD; // pi -const double _Complex PI_2 = M_PI_2 + 0.0_iD; // pi / 2 -const double _Complex PI_4 = M_PI_4 + 0.0_iD; // pi / 4 -const double _Complex _1_PI = M_1_PI + 0.0_iD; // 1 / pi -const double _Complex _2_PI = M_2_PI + 0.0_iD; // 2 / pi -const double _Complex _2_SQRT_PI = M_2_SQRTPI + 0.0_iD; // 2 / sqrt(pi) +double _Complex PI = M_PI + 0.0_iD; // pi +double _Complex PI_2 = M_PI_2 + 0.0_iD; // pi / 2 +double _Complex PI_4 = M_PI_4 + 0.0_iD; // pi / 4 +double _Complex _1_PI = M_1_PI + 0.0_iD; // 1 / pi +double _Complex _2_PI = M_2_PI + 0.0_iD; // 2 / pi +double _Complex _2_SQRT_PI = M_2_SQRTPI + 0.0_iD; // 2 / sqrt(pi) -const long double _Complex PI = M_PIl + 0.0_iL; // pi -const long double _Complex PI_2 = M_PI_2l + 0.0_iL; // pi / 2 -const long double _Complex PI_4 = M_PI_4l + 0.0_iL; // pi / 4 -const long double _Complex _1_PI = M_1_PIl + 0.0_iL; // 1 / pi -const long double _Complex _2_PI = M_2_PIl + 0.0_iL; // 2 / pi -const long double _Complex _2_SQRT_PI = M_2_SQRTPIl + 0.0_iL; // 2 / sqrt(pi) +long double _Complex PI = M_PIl + 0.0_iL; // pi +long double _Complex PI_2 = M_PI_2l + 0.0_iL; // pi / 2 +long double _Complex PI_4 = M_PI_4l + 0.0_iL; // pi / 4 +long double _Complex _1_PI = M_1_PIl + 0.0_iL; // 1 / pi +long double _Complex _2_PI = M_2_PIl + 0.0_iL; // 2 / pi +long double _Complex _2_SQRT_PI = M_2_SQRTPIl + 0.0_iL; // 2 / sqrt(pi) -const float E = (float)M_E; // e -const float LOG2_E = (float)M_LOG2E; // log_2(e) -const float LOG10_E = (float)M_LOG10E; // log_10(e) -const float LN_2 = (float)M_LN2; // log_e(2) -const float LN_10 = (float)M_LN10; // log_e(10) -const float SQRT_2 = (float)M_SQRT2; // sqrt(2) -const float _1_SQRT_2 = (float)M_SQRT1_2; // 1 / sqrt(2) +float E = (float)M_E; // e +float LOG2_E = (float)M_LOG2E; // log_2(e) +float LOG10_E = (float)M_LOG10E; // log_10(e) +float LN_2 = (float)M_LN2; // log_e(2) +float LN_10 = (float)M_LN10; // log_e(10) +float SQRT_2 = (float)M_SQRT2; // sqrt(2) +float _1_SQRT_2 = (float)M_SQRT1_2; // 1 / sqrt(2) -const double E = M_E; // e -const double LOG2_E = M_LOG2E; // log_2(e) -const double LOG10_E = M_LOG10E; // log_10(e) -const double LN_2 = M_LN2; // log_e(2) -const double LN_10 = M_LN10; // log_e(10) -const double SQRT_2 = M_SQRT2; // sqrt(2) -const double _1_SQRT_2 = M_SQRT1_2; // 1 / sqrt(2) +double E = M_E; // e +double LOG2_E = M_LOG2E; // log_2(e) +double LOG10_E = M_LOG10E; // log_10(e) +double LN_2 = M_LN2; // log_e(2) +double LN_10 = M_LN10; // log_e(10) +double SQRT_2 = M_SQRT2; // sqrt(2) +double _1_SQRT_2 = M_SQRT1_2; // 1 / sqrt(2) -const long double E = M_El; // e -const long double LOG2_E = M_LOG2El; // log_2(e) -const long double LOG10_E = M_LOG10El; // log_10(e) -const long double LN_2 = M_LN2l; // log_e(2) -const long double LN_10 = M_LN10l; // log_e(10) -const long double SQRT_2 = M_SQRT2l; // sqrt(2) -const long double _1_SQRT_2 = M_SQRT1_2l; // 1 / sqrt(2) +long double E = M_El; // e +long double LOG2_E = M_LOG2El; // log_2(e) +long double LOG10_E = M_LOG10El; // log_10(e) +long double LN_2 = M_LN2l; // log_e(2) +long double LN_10 = M_LN10l; // log_e(10) +long double SQRT_2 = M_SQRT2l; // sqrt(2) +long double _1_SQRT_2 = M_SQRT1_2l; // 1 / sqrt(2) -const float _Complex E = M_E + 0.0_iF; // e -const float _Complex LOG2_E = M_LOG2E + 0.0_iF; // log_2(e) -const float _Complex LOG10_E = M_LOG10E + 0.0_iF; // log_10(e) -const float _Complex LN_2 = M_LN2 + 0.0_iF; // log_e(2) -const float _Complex LN_10 = M_LN10 + 0.0_iF; // log_e(10) -const float _Complex SQRT_2 = M_SQRT2 + 0.0_iF; // sqrt(2) -const float _Complex _1_SQRT_2 = M_SQRT1_2 + 0.0_iF; // 1 / sqrt(2) +float _Complex E = M_E + 0.0_iF; // e +float _Complex LOG2_E = M_LOG2E + 0.0_iF; // log_2(e) +float _Complex LOG10_E = M_LOG10E + 0.0_iF; // log_10(e) +float _Complex LN_2 = M_LN2 + 0.0_iF; // log_e(2) +float _Complex LN_10 = M_LN10 + 0.0_iF; // log_e(10) +float _Complex SQRT_2 = M_SQRT2 + 0.0_iF; // sqrt(2) +float _Complex _1_SQRT_2 = M_SQRT1_2 + 0.0_iF; // 1 / sqrt(2) -const double _Complex E = M_E + 0.0_iD; // e -const double _Complex LOG2_E = M_LOG2E + 0.0_iD; // log_2(e) -const double _Complex LOG10_E = M_LOG10E + 0.0_iD; // log_10(e) -const double _Complex LN_2 = M_LN2 + 0.0_iD; // log_e(2) -const double _Complex LN_10 = M_LN10 + 0.0_iD; // log_e(10) -const double _Complex SQRT_2 = M_SQRT2 + 0.0_iD; // sqrt(2) -const double _Complex _1_SQRT_2 = M_SQRT1_2 + 0.0_iD; // 1 / sqrt(2) +double _Complex E = M_E + 0.0_iD; // e +double _Complex LOG2_E = M_LOG2E + 0.0_iD; // log_2(e) +double _Complex LOG10_E = M_LOG10E + 0.0_iD; // log_10(e) +double _Complex LN_2 = M_LN2 + 0.0_iD; // log_e(2) +double _Complex LN_10 = M_LN10 + 0.0_iD; // log_e(10) +double _Complex SQRT_2 = M_SQRT2 + 0.0_iD; // sqrt(2) +double _Complex _1_SQRT_2 = M_SQRT1_2 + 0.0_iD; // 1 / sqrt(2) -const long double _Complex E = M_El + 0.0_iL; // e -const long double _Complex LOG2_E = M_LOG2El + 0.0_iL; // log_2(e) -const long double _Complex LOG10_E = M_LOG10El + 0.0_iL; // log_10(e) -const long double _Complex LN_2 = M_LN2l + 0.0_iL; // log_e(2) -const long double _Complex LN_10 = M_LN10l + 0.0_iL; // log_e(10) -const long double _Complex SQRT_2 = M_SQRT2l + 0.0_iL; // sqrt(2) -const long double _Complex _1_SQRT_2 = M_SQRT1_2l + 0.0_iL; // 1 / sqrt(2) +long double _Complex E = M_El + 0.0_iL; // e +long double _Complex LOG2_E = M_LOG2El + 0.0_iL; // log_2(e) +long double _Complex LOG10_E = M_LOG10El + 0.0_iL; // log_10(e) +long double _Complex LN_2 = M_LN2l + 0.0_iL; // log_e(2) +long double _Complex LN_10 = M_LN10l + 0.0_iL; // log_e(10) +long double _Complex SQRT_2 = M_SQRT2l + 0.0_iL; // sqrt(2) +long double _Complex _1_SQRT_2 = M_SQRT1_2l + 0.0_iL; // 1 / sqrt(2) // Local Variables: // Index: libcfa/src/limits.hfa =================================================================== --- libcfa/src/limits.hfa (revision b4b63e8f7b73b2f77b154650ba47a2df216a9713) +++ libcfa/src/limits.hfa (revision dd53f757269164e57222b201af9b60c094c663de) @@ -10,6 +10,6 @@ // Created On : Wed Apr 6 18:06:52 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Mar 1 16:20:54 2018 -// Update Count : 13 +// Last Modified On : Wed Sep 30 22:56:35 2020 +// Update Count : 15 // @@ -18,131 +18,131 @@ // Integral Constants -extern const signed char MIN; -extern const unsigned char MIN; -extern const short int MIN; -extern const unsigned short int MIN; -extern const int MIN; -extern const unsigned int MIN; -extern const long int MIN; -extern const unsigned long int MIN; -extern const long long int MIN; -extern const unsigned long long int MIN; +extern signed char MIN; +extern unsigned char MIN; +extern short int MIN; +extern unsigned short int MIN; +extern int MIN; +extern unsigned int MIN; +extern long int MIN; +extern unsigned long int MIN; +extern long long int MIN; +extern unsigned long long int MIN; -extern const signed char MAX; -extern const unsigned char MAX; -extern const short int MAX; -extern const unsigned short int MAX; -extern const int MAX; -extern const unsigned int MAX; -extern const long int MAX; -extern const unsigned long int MAX; -extern const long long int MAX; -extern const unsigned long long int MAX; +extern signed char MAX; +extern unsigned char MAX; +extern short int MAX; +extern unsigned short int MAX; +extern int MAX; +extern unsigned int MAX; +extern long int MAX; +extern unsigned long int MAX; +extern long long int MAX; +extern unsigned long long int MAX; // Floating-Point Constants -extern const float MIN; -extern const double MIN; -extern const long double MIN; -extern const float _Complex MIN; -extern const double _Complex MIN; -extern const long double _Complex MIN; +extern float MIN; +extern double MIN; +extern long double MIN; +extern float _Complex MIN; +extern double _Complex MIN; +extern long double _Complex MIN; -extern const float MAX; -extern const double MAX; -extern const long double MAX; -extern const float _Complex MAX; -extern const double _Complex MAX; -extern const long double _Complex MAX; +extern float MAX; +extern double MAX; +extern long double MAX; +extern float _Complex MAX; +extern double _Complex MAX; +extern long double _Complex MAX; -extern const float PI; // pi -extern const float PI_2; // pi / 2 -extern const float PI_4; // pi / 4 -extern const float _1_PI; // 1 / pi -extern const float _2_PI; // 2 / pi -extern const float _2_SQRT_PI; // 2 / sqrt(pi) +extern float PI; // pi +extern float PI_2; // pi / 2 +extern float PI_4; // pi / 4 +extern float _1_PI; // 1 / pi +extern float _2_PI; // 2 / pi +extern float _2_SQRT_PI; // 2 / sqrt(pi) -extern const double PI; // pi -extern const double PI_2; // pi / 2 -extern const double PI_4; // pi / 4 -extern const double _1_PI; // 1 / pi -extern const double _2_PI; // 2 / pi -extern const double _2_SQRT_PI; // 2 / sqrt(pi) +extern double PI; // pi +extern double PI_2; // pi / 2 +extern double PI_4; // pi / 4 +extern double _1_PI; // 1 / pi +extern double _2_PI; // 2 / pi +extern double _2_SQRT_PI; // 2 / sqrt(pi) -extern const long double PI; // pi -extern const long double PI_2; // pi / 2 -extern const long double PI_4; // pi / 4 -extern const long double _1_PI; // 1 / pi -extern const long double _2_PI; // 2 / pi -extern const long double _2_SQRT_PI; // 2 / sqrt(pi) +extern long double PI; // pi +extern long double PI_2; // pi / 2 +extern long double PI_4; // pi / 4 +extern long double _1_PI; // 1 / pi +extern long double _2_PI; // 2 / pi +extern long double _2_SQRT_PI; // 2 / sqrt(pi) -extern const float _Complex PI; // pi -extern const float _Complex PI_2; // pi / 2 -extern const float _Complex PI_4; // pi / 4 -extern const float _Complex _1_PI; // 1 / pi -extern const float _Complex _2_PI; // 2 / pi -extern const float _Complex _2_SQRT_PI; // 2 / sqrt(pi) +extern float _Complex PI; // pi +extern float _Complex PI_2; // pi / 2 +extern float _Complex PI_4; // pi / 4 +extern float _Complex _1_PI; // 1 / pi +extern float _Complex _2_PI; // 2 / pi +extern float _Complex _2_SQRT_PI; // 2 / sqrt(pi) -extern const double _Complex PI; // pi -extern const double _Complex PI_2; // pi / 2 -extern const double _Complex PI_4; // pi / 4 -extern const double _Complex _1_PI; // 1 / pi -extern const double _Complex _2_PI; // 2 / pi -extern const double _Complex _2_SQRT_PI; // 2 / sqrt(pi) +extern double _Complex PI; // pi +extern double _Complex PI_2; // pi / 2 +extern double _Complex PI_4; // pi / 4 +extern double _Complex _1_PI; // 1 / pi +extern double _Complex _2_PI; // 2 / pi +extern double _Complex _2_SQRT_PI; // 2 / sqrt(pi) -extern const long double _Complex PI; // pi -extern const long double _Complex PI_2; // pi / 2 -extern const long double _Complex PI_4; // pi / 4 -extern const long double _Complex _1_PI; // 1 / pi -extern const long double _Complex _2_PI; // 2 / pi -extern const long double _Complex _2_SQRT_PI; // 2 / sqrt(pi) +extern long double _Complex PI; // pi +extern long double _Complex PI_2; // pi / 2 +extern long double _Complex PI_4; // pi / 4 +extern long double _Complex _1_PI; // 1 / pi +extern long double _Complex _2_PI; // 2 / pi +extern long double _Complex _2_SQRT_PI; // 2 / sqrt(pi) -extern const float E; // e -extern const float LOG2_E; // log_2(e) -extern const float LOG10_E; // log_10(e) -extern const float LN_2; // log_e(2) -extern const float LN_10; // log_e(10) -extern const float SQRT_2; // sqrt(2) -extern const float _1_SQRT_2; // 1 / sqrt(2) +extern float E; // e +extern float LOG2_E; // log_2(e) +extern float LOG10_E; // log_10(e) +extern float LN_2; // log_e(2) +extern float LN_10; // log_e(10) +extern float SQRT_2; // sqrt(2) +extern float _1_SQRT_2; // 1 / sqrt(2) -extern const double E; // e -extern const double LOG2_E; // log_2(e) -extern const double LOG10_E; // log_10(e) -extern const double LN_2; // log_e(2) -extern const double LN_10; // log_e(10) -extern const double SQRT_2; // sqrt(2) -extern const double _1_SQRT_2; // 1 / sqrt(2) +extern double E; // e +extern double LOG2_E; // log_2(e) +extern double LOG10_E; // log_10(e) +extern double LN_2; // log_e(2) +extern double LN_10; // log_e(10) +extern double SQRT_2; // sqrt(2) +extern double _1_SQRT_2; // 1 / sqrt(2) -extern const long double E; // e -extern const long double LOG2_E; // log_2(e) -extern const long double LOG10_E; // log_10(e) -extern const long double LN_2; // log_e(2) -extern const long double LN_10; // log_e(10) -extern const long double SQRT_2; // sqrt(2) -extern const long double _1_SQRT_2; // 1/sqrt(2) +extern long double E; // e +extern long double LOG2_E; // log_2(e) +extern long double LOG10_E; // log_10(e) +extern long double LN_2; // log_e(2) +extern long double LN_10; // log_e(10) +extern long double SQRT_2; // sqrt(2) +extern long double _1_SQRT_2; // 1/sqrt(2) -extern const float _Complex E; // e -extern const float _Complex LOG2_E; // log_2(e) -extern const float _Complex LOG10_E; // log_10(e) -extern const float _Complex LN_2; // log_e(2) -extern const float _Complex LN_10; // log_e(10) -extern const float _Complex SQRT_2; // sqrt(2) -extern const float _Complex _1_SQRT_2; // 1 / sqrt(2) +extern float _Complex E; // e +extern float _Complex LOG2_E; // log_2(e) +extern float _Complex LOG10_E; // log_10(e) +extern float _Complex LN_2; // log_e(2) +extern float _Complex LN_10; // log_e(10) +extern float _Complex SQRT_2; // sqrt(2) +extern float _Complex _1_SQRT_2; // 1 / sqrt(2) -extern const double _Complex E; // e -extern const double _Complex LOG2_E; // log_2(e) -extern const double _Complex LOG10_E; // log_10(e) -extern const double _Complex LN_2; // log_e(2) -extern const double _Complex LN_10; // log_e(10) -extern const double _Complex SQRT_2; // sqrt(2) -extern const double _Complex _1_SQRT_2; // 1 / sqrt(2) +extern double _Complex E; // e +extern double _Complex LOG2_E; // log_2(e) +extern double _Complex LOG10_E; // log_10(e) +extern double _Complex LN_2; // log_e(2) +extern double _Complex LN_10; // log_e(10) +extern double _Complex SQRT_2; // sqrt(2) +extern double _Complex _1_SQRT_2; // 1 / sqrt(2) -extern const long double _Complex E; // e -extern const long double _Complex LOG2_E; // log_2(e) -extern const long double _Complex LOG10_E; // log_10(e) -extern const long double _Complex LN_2; // log_e(2) -extern const long double _Complex LN_10; // log_e(10) -extern const long double _Complex SQRT_2; // sqrt(2) -extern const long double _Complex _1_SQRT_2; // 1 / sqrt(2) +extern long double _Complex E; // e +extern long double _Complex LOG2_E; // log_2(e) +extern long double _Complex LOG10_E; // log_10(e) +extern long double _Complex LN_2; // log_e(2) +extern long double _Complex LN_10; // log_e(10) +extern long double _Complex SQRT_2; // sqrt(2) +extern long double _Complex _1_SQRT_2; // 1 / sqrt(2) // Local Variables: // Index: src/GenPoly/InstantiateGeneric.cc =================================================================== --- src/GenPoly/InstantiateGeneric.cc (revision b4b63e8f7b73b2f77b154650ba47a2df216a9713) +++ src/GenPoly/InstantiateGeneric.cc (revision dd53f757269164e57222b201af9b60c094c663de) @@ -172,5 +172,5 @@ InstantiationMap< AggregateDecl, AggregateDecl > instantiations; /// Set of types which are dtype-only generic (and therefore have static layout) - ScopedSet< AggregateDecl* > dtypeStatics; + std::set dtypeStatics; /// Namer for concrete types UniqueName typeNamer; @@ -505,10 +505,8 @@ void GenericInstantiator::beginScope() { instantiations.beginScope(); - dtypeStatics.beginScope(); } void GenericInstantiator::endScope() { instantiations.endScope(); - dtypeStatics.endScope(); } Index: tests/zombies/Rank2.c =================================================================== --- tests/zombies/Rank2.c (revision b4b63e8f7b73b2f77b154650ba47a2df216a9713) +++ tests/zombies/Rank2.c (revision dd53f757269164e57222b201af9b60c094c663de) @@ -1,4 +1,4 @@ -int ?=?( int *, int ); -forall(dtype DT) DT * ?=?( DT **, DT * ); +int ?=?( int &, int ); +forall(dtype DT) DT * ?=?( DT *&, DT * ); void a() { @@ -11,6 +11,6 @@ void h( int *null ); forall( otype T ) T id( T ); - forall( dtype T ) T *0; - int 0; +// forall( dtype T ) T *0; +// int 0; h( id( id( id( 0 ) ) ) ); } Index: tests/zombies/Tuple.c =================================================================== --- tests/zombies/Tuple.c (revision b4b63e8f7b73b2f77b154650ba47a2df216a9713) +++ tests/zombies/Tuple.c (revision dd53f757269164e57222b201af9b60c094c663de) @@ -46,5 +46,5 @@ [ 3, 5 ]; [ a, b ] = 3; -// [ a, b ] = [ 4.6 ]; + [ a, b ] = [ 4.6 ]; [ a, b ] = 4.6; [ a, b ] = [ c, d ] = [ 3, 5 ]; @@ -59,5 +59,5 @@ [ a, b ] = t1 = [ c, d ]; [ a, b ] = t1 = t2 = [ c, d ]; -// t1 = [ 3, 4 ] = [ 3, 4 ] = t1 = [ 3, 4 ]; + t1 = [ 3, 4 ] = [ 3, 4 ] = t1 = [ 3, 4 ]; s.[ f1, i.[ f2, f3 ], f4 ] = [ 11, 12, 13, 3.14159 ]; @@ -65,5 +65,5 @@ // [ a, , b, ] = h( 3, 3, 0, "abc" ); /* ignore some results */ sp->[ f4, f1 ] = sp->[ f1, f4 ]; - printf( "expecting 3, 17, 23, 4; got %d, %d, %d, %d\n", s.[ f4, i.[ f3, f2 ], f1 ] ); + printf( "expecting 3, 17, 23, 4; got %g, %d, %d, %d\n", s.[ f4, i.[ f3, f2 ], f1 ] ); rc = 0; } Index: tests/zombies/abstype.c =================================================================== --- tests/zombies/abstype.c (revision b4b63e8f7b73b2f77b154650ba47a2df216a9713) +++ tests/zombies/abstype.c (revision dd53f757269164e57222b201af9b60c094c663de) @@ -10,6 +10,6 @@ // Created On : Wed May 27 17:56:53 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Tue Jun 14 14:27:48 2016 -// Update Count : 9 +// Last Modified On : Wed Sep 30 13:55:47 2020 +// Update Count : 10 // @@ -21,5 +21,5 @@ } -forall( otype T ) lvalue T *?( T * ); +forall( otype T ) T *?( T * ); int ?++( int * ); int ?=?( int *, int ); Index: tests/zombies/constructors.c =================================================================== --- tests/zombies/constructors.c (revision b4b63e8f7b73b2f77b154650ba47a2df216a9713) +++ tests/zombies/constructors.c (revision dd53f757269164e57222b201af9b60c094c663de) @@ -1,40 +1,48 @@ -int fred() { +#include +#include + +int main() { // initialize basic structure struct S { int i, j, k; }; - void ?{}( S *s ) { s->i = 1, s->k = 2; } // default constructor - void ?{}( S *s, int i, int k ) { s->i = i, s->k = k; } // 2 parameter constructor - void ?{}( S *s, S c ) { *s = c; } // copy constructor - void ^?{}( S *s ) { s->i = 0, s->k = 0; } // default destructor - void ^?{}( S *s, int i ) { s->i = i, s->k = i; } // 1 parameter destructor + void ?{}( S & s ) { s.i = 1, s.k = 2; } // default constructor + void ?{}( S & s, int i, int k ) { s.i = i, s.k = k; } // 2 parameter constructor + void ?{}( S & s, S c ) { /* s @= c */ s.[i,j,k] = c.[i,j,k]; } // copy constructor + void ^?{}( S & s ) { s.i = 0, s.k = 0; } // default destructor + void ^?{}( S & s, int i ) { s.i = i, s.k = i; } // 1 parameter destructor { - S s1; // default constructor - S s2 = { 3, 7 }; // 2 parameter constructor - S s3 @= { .k:3, .i:7 }; // 2 parameter C initialization - ?{}( &s3, 2, 5 ); // explicit 2 parameter constructor - ^?{}( &s1 ); // explicit call to default destructor + S s1; // default constructor + S s2 = { 3, 7 }; // 2 parameter constructor + S s3 @= { .k:3, .i:7 }; // 2 parameter C initialization + ?{}( s3, 2, 5 ); // explicit 2 parameter constructor + ^?{}( s1 ); // explicit call to default destructor } // implicit call to default destructor for s2, explicit call s1, no call for s3 - S s4 @= {}; // no default construction - (&s4){ 2, 5 }; // explicit 2 parameter constructor - ^s4{ 3 }; // explicit call to 1 parameter destructor + S s4 @= {}; // no default construction + (s4){ 2, 5 }; // explicit 2 parameter constructor + ^s4{ 3 }; // explicit call to 1 parameter destructor // initialize pointer to a basic structure - void ?{}( S **s ) { *s = malloc(); (*s)->i = 1, (*s)->k = 2; } // default constructor - void ?{}( S **s, int i, int k ) { *s = malloc(); (*s)->i = i, (*s)->k = k; } // 2 parameter constructor - void ^?{}( S **s ) { (*s)->i = 0, (*s)->k = 0; free( *s ); *s = 0; } // default destructor + void ?{}( S *& s ) { s = malloc(); s->i = 1, (*s).k = 2; } // default constructor + void ?{}( S *& s, int i, int k ) { s = malloc(); (*s).i = i, (*s).k = k; } // 2 parameter constructor + void ^?{}( S *& s ) { (*s).i = 0, (*s).k = 0; free( s ); &s = 0p; } // default destructor { - S *ps1; // default constructor - S *ps2 = { 3, 7 }; // 2 parameter constructor - S *ps3 @= 0; // C initialization - S *ps4 @= {}; // no default construction + S * ps1; // default constructor + S * ps2 = { 3, 7 }; // 2 parameter constructor + sout | ps1 | ps2; + + S * ps3 @= 0p; // C initialization + S * ps4 @= { 3 }; // no default construction + sout | ps3 | ps4; + + ?{}( ps3, 2, 5 ); // explicit 2 parameter constructor + (ps4){ 2, 5 }; // explicit 2 parameter constructor + sout | ps3 | ps4; + + ^?{}( ps3 ); // explicit call to default destructor + ^ps4{}; // explicit call to default destructor + sout | ps3 | ps4; } // implicit call to default destructor for ps2 and ps1, checks ordering of explicit destructor calls - - ?{}( &ps3, 2, 5 ); // explicit 2 parameter constructor - (&ps4){ 2, 5 }; // explicit 2 parameter constructor - - ^?{}( &ps3 ); // explicit call to default destructor - ^ps4{}; // explicit call to default destructor // initialize complex structure @@ -44,17 +52,18 @@ }; - void ?{}( T *t ) {} // default constructor => implicitly call constructor for field s - void ?{}( T *t, int i, int k ) { (&t->s){ i, k }; } // 2 parameter constructor => explicitly call constructor for field s - void ?{}( T *t, S c ) { (&t->s){ c }; } // 1 parameter constructor => explicitly call copy constructor for field s - void ^?{}( T *s, int i ) {} // destructor => implicitly call destructor for field s + void ?{}( T & t ) {} // default constructor => implicitly call constructor for field s + void ?{}( T & t, int i, int k ) { (t.s){ i, k }; } // 2 parameter constructor => explicitly call constructor for field s + void ?{}( T & t, S c ) { (t.s){ c }; }// 1 parameter constructor => explicitly call copy constructor for field s + void ^?{}( T & s ) {} // destructor => implicitly call destructor for field s + void ^?{}( T & s, int i ) {}// destructor => implicitly call destructor for field s { - S s; // default constructor - T t1; // default constructor - T t2 = { s }; // 1 parameter constructor - ^?{}( &t1 ); // explicit call to default destructor => implicit call to t1.s's destructor + S s; // default constructor + T t1; // default constructor + T t2 = { s }; // 1 parameter constructor + ^?{}( t1, 3 ); // explicit call to default destructor => implicit call to t1.s's destructor + T t3; // default constructor + T t4 @= { { 1, 3 } }; // C initialization + (t4){ 2, 5 }; // explicit 2 parameter constructor } // implicit call to default destructor for t2 and implicit call for s; - T t3; // default constructor - T t4 @= { { 1, 3 } }; // C initialization - (&t4){ 2, 5 }; // explicit 2 parameter constructor T *pt = malloc(){ 3, 4 }; // common usage Index: tests/zombies/includes.c =================================================================== --- tests/zombies/includes.c (revision b4b63e8f7b73b2f77b154650ba47a2df216a9713) +++ tests/zombies/includes.c (revision dd53f757269164e57222b201af9b60c094c663de) @@ -10,6 +10,6 @@ // Created On : Wed May 27 17:56:53 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Wed Nov 15 23:06:24 2017 -// Update Count : 597 +// Last Modified On : Wed Sep 30 13:59:18 2020 +// Update Count : 598 // @@ -24,45 +24,46 @@ #if 1 #define _GNU_SOURCE -#include -#include -#include -#include -#include -#include -#include -#include -#include -//#include -// #include // keyword with -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include +// #include +// #include +// #include +// #include +// #include +// #include +// #include +// #include +// #include +// #include +// #include // keyword with +// #include +// #include +// #include +// #include +// #include +// #include +// #include + +// #include +// #include +// #include +// #include +// #include +// #include +// #include +// #include +// #include +// #include +// #include +// #include +// #include +// #include +// #include +// #include +// #include +// #include +// #include // #include // #include -// #include // evrpc.h depends on sys/queue.h +// #include // evrpc.h depends on sys/queue.h // #include // #include @@ -80,4 +81,5 @@ // #include // #include + // #include // #include @@ -89,5 +91,5 @@ // #include // #include -// #include // keyword thread (setjmp) +#include // keyword thread (setjmp) // #include // #include