Index: doc/bibliography/pl.bib =================================================================== --- doc/bibliography/pl.bib (revision b2e88418a9a140cb8c4fa54dea5e578f4f29cf9d) +++ doc/bibliography/pl.bib (revision f4abc582d3b6b606b643e66534b4f6671f8ecbdf) @@ -1439,10 +1439,10 @@ contributer = {pabuhr@plg}, author = {Peter A. Buhr}, - title = {$\mu${C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Annotated Reference Manual, Version 6.1.0}, + title = {$\mu${C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Annotated Reference Manual, Version 7.0.0}, institution = {School of Computer Science, University of Waterloo}, address = {Waterloo, Ontario, Canada, N2L 3G1}, - month = jul, - year = 2015, - note = {\href{http://plg.uwaterloo.ca/~usystem/pub/uSystem/u++-6.1.0.sh}{http://\-plg.\-uwaterloo.\-ca/\-$\sim$usystem/\-pub/\-uSystem/\-u++-6.1.0.sh}}, + month = dec, + year = 2017, + note = {\href{http://plg.uwaterloo.ca/~usystem/pub/uSystem/u++-7.0.0.sh}{http://\-plg.\-uwaterloo.\-ca/\-$\sim$usystem/\-pub/\-uSystem/\-u++-7.0.0.sh}}, } Index: doc/papers/general/Paper.tex =================================================================== --- doc/papers/general/Paper.tex (revision b2e88418a9a140cb8c4fa54dea5e578f4f29cf9d) +++ doc/papers/general/Paper.tex (revision f4abc582d3b6b606b643e66534b4f6671f8ecbdf) @@ -13,4 +13,6 @@ \usepackage{pslatex} % reduce size of san serif font \usepackage[plainpages=false,pdfpagelabels,pdfpagemode=UseNone,pagebackref=true,breaklinks=true,colorlinks=true,linkcolor=blue,citecolor=blue,urlcolor=blue]{hyperref} +\urlstyle{sf} +\usepackage{breakurl} \setlength{\textheight}{9in} @@ -56,4 +58,5 @@ \setlength{\parindentlnth}{\parindent} +\newcommand{\LstBasicStyle}[1]{{\lst@basicstyle{\lst@basicstyle{#1}}}} \newcommand{\LstKeywordStyle}[1]{{\lst@basicstyle{\lst@keywordstyle{#1}}}} \newcommand{\LstCommentStyle}[1]{{\lst@basicstyle{\lst@commentstyle{#1}}}} @@ -229,4 +232,8 @@ All of the features discussed in this paper are working, unless a feature states it is a future feature for completion. +Finally, it is impossible to describe a programming language without usages before definitions. +Therefore, syntax and semantics appear before explanations; +hence, patience is necessary until details are presented. + \section{Polymorphic Functions} @@ -261,13 +268,15 @@ \end{cfa} \CFA maximizes the ability to reuse names to aggressively address the naming problem. -In some cases, hundreds of names can be reduced to tens, resulting in a significant cognitive reduction for a programmer. +In some cases, hundreds of names can be reduced to tens, resulting in a significant cognitive reduction. In the above, the name @max@ has a consistent meaning, and a programmer only needs to remember the single concept: maximum. To prevent significant ambiguities, \CFA uses the return type in selecting overloads, \eg in the assignment to @m@, the compiler use @m@'s type to unambiguously select the most appropriate call to function @max@ (as does Ada). As is shown later, there are a number of situations where \CFA takes advantage of available type information to disambiguate, where other programming languages generate ambiguities. -\Celeven added @_Generic@ expressions, which can be used in preprocessor macros to provide a form of ad-hoc polymorphism; however, this polymorphism is both functionally and ergonomically inferior to \CFA name overloading. -The macro wrapping the generic expression imposes some limitations; as an example, it could not implement the example above, because the variables @max@ would collide with the functions @max@. -Ergonomic limitations of @_Generic@ include the necessity to put a fixed list of supported types in a single place and manually dispatch to appropriate overloads, as well as possible namespace pollution from the functions dispatched to, which must all have distinct names. -Though name-overloading removes a major use-case for @_Generic@ expressions, \CFA implements @_Generic@ for backwards-compatibility purposes. \TODO{actually implement that} +\Celeven added @_Generic@ expressions, which is used in preprocessor macros to provide a form of ad-hoc polymorphism; +however, this polymorphism is both functionally and ergonomically inferior to \CFA name overloading. +The macro wrapping the generic expression imposes some limitations; +\eg, it cannot implement the example above, because the variables @max@ are ambiguous with the functions @max@. +Ergonomic limitations of @_Generic@ include the necessity to put a fixed list of supported types in a single place and manually dispatch to appropriate overloads, as well as possible namespace pollution from the dispatch functions, which must all have distinct names. +For backwards compatibility, \CFA supports @_Generic@ expressions, but it is an unnecessary mechanism. \TODO{actually implement that} % http://fanf.livejournal.com/144696.html @@ -284,10 +293,10 @@ int forty_two = identity( 42 ); $\C{// T is bound to int, forty\_two == 42}$ \end{cfa} -The @identity@ function above can be applied to any complete \newterm{object type} (or @otype@). +This @identity@ function can be applied to any complete \newterm{object type} (or @otype@). The type variable @T@ is transformed into a set of additional implicit parameters encoding sufficient information about @T@ to create and return a variable of that type. The \CFA implementation passes the size and alignment of the type represented by an @otype@ parameter, as well as an assignment operator, constructor, copy constructor and destructor. If this extra information is not needed, \eg for a pointer, the type parameter can be declared as a \newterm{data type} (or @dtype@). -In \CFA, the polymorphism runtime-cost is spread over each polymorphic call, due to passing more arguments to polymorphic functions; +In \CFA, the polymorphic runtime-cost is spread over each polymorphic call, because more arguments are passed to polymorphic functions; the experiments in Section~\ref{sec:eval} show this overhead is similar to \CC virtual-function calls. A design advantage is that, unlike \CC template-functions, \CFA polymorphic-functions are compatible with C \emph{separate compilation}, preventing compilation and code bloat. @@ -301,5 +310,5 @@ which works for any type @T@ with a matching addition operator. The polymorphism is achieved by creating a wrapper function for calling @+@ with @T@ bound to @double@, then passing this function to the first call of @twice@. -There is now the option of using the same @twice@ and converting the result to @int@ on assignment, or creating another @twice@ with type parameter @T@ bound to @int@ because \CFA uses the return type~\cite{Cormack81,Baker82,Ada}, in its type analysis. +There is now the option of using the same @twice@ and converting the result to @int@ on assignment, or creating another @twice@ with type parameter @T@ bound to @int@ because \CFA uses the return type~\cite{Cormack81,Baker82,Ada} in its type analysis. The first approach has a late conversion from @double@ to @int@ on the final assignment, while the second has an eager conversion to @int@. \CFA minimizes the number of conversions and their potential to lose information, so it selects the first approach, which corresponds with C-programmer intuition. @@ -310,9 +319,8 @@ \begin{cfa} void * bsearch( const void * key, const void * base, size_t nmemb, size_t size, - int (* compar)( const void *, const void * )); - -int comp( const void * t1, const void * t2 ) { return *(double *)t1 < *(double *)t2 ? -1 : - *(double *)t2 < *(double *)t1 ? 1 : 0; } - + int (* compar)( const void *, const void * )); +int comp( const void * t1, const void * t2 ) { + return *(double *)t1 < *(double *)t2 ? -1 : *(double *)t2 < *(double *)t1 ? 1 : 0; +} double key = 5.0, vals[10] = { /* 10 sorted float values */ }; double * val = (double *)bsearch( &key, vals, 10, sizeof(vals[0]), comp ); $\C{// search sorted array}$ @@ -322,10 +330,10 @@ forall( otype T | { int ?@ because of lexical scoping. +Object-oriented nesting of member functions in a \lstinline[language=C++]@class@ allows eliding \lstinline[language=C++]@this->@ because of lexical scoping. However, for other aggregate parameters, qualification is necessary: \begin{cfa} @@ -1299,5 +1460,5 @@ 'with' '(' $\emph{expression-list}$ ')' $\emph{compound-statement}$ \end{cfa} -and may appear as the body of a routine or nested within a routine body. +and may appear as the body of a function or nested within a function body. Each expression in the expression-list provides a type and object. The type must be an aggregate type. @@ -1326,5 +1487,5 @@ Qualification or a cast is used to disambiguate. -There is an interesting problem between parameters and the routine @with@, \eg: +There is an interesting problem between parameters and the function-body @with@, \eg: \begin{cfa} void ?{}( S & s, int i ) with ( s ) { $\C{// constructor}$ @@ -1332,5 +1493,5 @@ } \end{cfa} -Here, the assignment @s.i = i@ means @s.i = s.i@, which is meaningless, and there is no mechanism to qualify the parameter @i@, making the assignment impossible using the routine @with@. +Here, the assignment @s.i = i@ means @s.i = s.i@, which is meaningless, and there is no mechanism to qualify the parameter @i@, making the assignment impossible using the function-body @with@. To solve this problem, parameters are treated like an initialized aggregate: \begin{cfa} @@ -1340,8 +1501,8 @@ } params; \end{cfa} -and implicitly opened \emph{after} a routine open, to give them higher priority: -\begin{cfa} -void ?{}( S & s, int i ) with ( s ) `with( $\emph{\color{red}params}$ )` { - s.i = i; j = 3; m = 5.5; +and implicitly opened \emph{after} a function-body open, to give them higher priority: +\begin{cfa} +void ?{}( S & s, int `i` ) with ( s ) `with( $\emph{\color{red}params}$ )` { + s.i = `i`; j = 3; m = 5.5; } \end{cfa} @@ -1368,125 +1529,4 @@ -\subsection{Exception Handling} - -The following framework for \CFA exception handling is in place, excluding a run-time type information and dynamic casts. -\CFA provides two forms of exception handling: \newterm{fix-up} and \newterm{recovery} (see Figure~\ref{f:CFAExceptionHandling}). -Both mechanisms provide dynamic call to a handler using dynamic name-lookup, where fix-up has dynamic return and recovery has static return from the handler. -\CFA restricts exception types to those defined by aggregate type @exception@. -The form of the raise dictates the set of handlers examined during propagation: \newterm{resumption propagation} (@resume@) only examines resumption handlers (@catchResume@); \newterm{terminating propagation} (@throw@) only examines termination handlers (@catch@). -If @resume@ or @throw@ have no exception type, it is a reresume/rethrow, meaning the currently exception continues propagation. -If there is no current exception, the reresume/rethrow results in a runtime error. - -\begin{figure} -\begin{cquote} -\lstDeleteShortInline@% -\begin{tabular}{@{}l@{\hspace{2\parindentlnth}}l@{}} -\multicolumn{1}{c@{\hspace{2\parindentlnth}}}{\textbf{Resumption}} & \multicolumn{1}{c}{\textbf{Termination}} \\ -\begin{cfa} -`exception R { int fix; };` -void f() { - R r; - ... `resume( r );` ... - ... r.fix // control does return here after handler -} -`try` { - ... f(); ... -} `catchResume( R r )` { - ... r.fix = ...; // return correction to raise -} // dynamic return to _Resume -\end{cfa} -& -\begin{cfa} -`exception T {};` -void f() { - - ... `throw( T{} );` ... - // control does NOT return here after handler -} -`try` { - ... f(); ... -} `catch( T t )` { - ... // recover and continue -} // static return to next statement -\end{cfa} -\end{tabular} -\lstMakeShortInline@% -\end{cquote} -\caption{\CFA Exception Handling} -\label{f:CFAExceptionHandling} -\end{figure} - -The set of exception types in a list of catch clause may include both a resumption and termination handler: -\begin{cfa} -try { - ... resume( `R{}` ); ... -} catchResume( `R` r ) { ... throw( R{} ); ... } $\C{\color{red}// H1}$ - catch( `R` r ) { ... } $\C{\color{red}// H2}$ - -\end{cfa} -The resumption propagation raises @R@ and the stack is not unwound; -the exception is caught by the @catchResume@ clause and handler H1 is invoked. -The termination propagation in handler H1 raises @R@ and the stack is unwound; -the exception is caught by the @catch@ clause and handler H2 is invoked. -The termination handler is available because the resumption propagation did not unwind the stack. - -An additional feature is conditional matching in a catch clause: -\begin{cfa} -try { - ... write( `datafile`, ... ); ... $\C{// may throw IOError}$ - ... write( `logfile`, ... ); ... -} catch ( IOError err; `err.file == datafile` ) { ... } $\C{// handle datafile error}$ - catch ( IOError err; `err.file == logfile` ) { ... } $\C{// handle logfile error}$ - catch ( IOError err ) { ... } $\C{// handler error from other files}$ -\end{cfa} -where the throw inserts the failing file-handle in the I/O exception. -Conditional catch cannot be trivially mimicked by other mechanisms because once an exception is caught, handler clauses in that @try@ statement are no longer eligible.. - -The resumption raise can specify an alternate stack on which to raise an exception, called a \newterm{nonlocal raise}: -\begin{cfa} -resume( $\emph{exception-type}$, $\emph{alternate-stack}$ ) -resume( $\emph{alternate-stack}$ ) -\end{cfa} -These overloads of @resume@ raise the specified exception or the currently propagating exception (reresume) at another coroutine or task~\cite{Delisle18}. -Nonlocal raise is restricted to resumption to provide the exception handler the greatest flexibility because processing the exception does not unwind its stack, allowing it to continue after the handle returns. - -To facilitate nonlocal exception, \CFA provides dynamic enabling and disabling of nonlocal exception-propagation. -The constructs for controlling propagation of nonlocal exceptions are the @enable@ and the @disable@ blocks: -\begin{cquote} -\lstDeleteShortInline@% -\begin{tabular}{@{}l@{\hspace{2\parindentlnth}}l@{}} -\begin{cfa} -enable $\emph{exception-type-list}$ { - // allow non-local resumption -} -\end{cfa} -& -\begin{cfa} -disable $\emph{exception-type-list}$ { - // disallow non-local resumption -} -\end{cfa} -\end{tabular} -\lstMakeShortInline@% -\end{cquote} -The arguments for @enable@/@disable@ specify the exception types allowed to be propagated or postponed, respectively. -Specifying no exception type is shorthand for specifying all exception types. -Both @enable@ and @disable@ blocks can be nested, turning propagation on/off on entry, and on exit, the specified exception types are restored to their prior state. - -Finally, \CFA provides a Java like @finally@ clause after the catch clauses: -\begin{cfa} -try { - ... f(); ... -// catchResume or catch clauses -} `finally` { - // house keeping -} -\end{cfa} -The finally clause is always executed, i.e., if the try block ends normally or if an exception is raised. -If an exception is raised and caught, the handler is run before the finally clause. -Like a destructor (see Section~\ref{s:ConstructorsDestructors}), a finally clause can raise an exception but not if there is an exception being propagated. -Mimicking the @finally@ clause with mechanisms like RAII is non-trivially when there are multiple types and local accesses. - - \section{Declarations} @@ -1516,14 +1556,14 @@ Is this an array of 5 pointers to integers or a pointer to an array of 5 integers? If there is any doubt, it implies productivity and safety issues even for basic programs. -Another example of confusion results from the fact that a routine name and its parameters are embedded within the return type, mimicking the way the return value is used at the routine's call site. -For example, a routine returning a pointer to an array of integers is defined and used in the following way: +Another example of confusion results from the fact that a function name and its parameters are embedded within the return type, mimicking the way the return value is used at the function's call site. +For example, a function returning a pointer to an array of integers is defined and used in the following way: \begin{cfa} int `(*`f`())[`5`]` {...}; $\C{// definition}$ ... `(*`f`())[`3`]` += 1; $\C{// usage}$ \end{cfa} -Essentially, the return type is wrapped around the routine name in successive layers (like an onion). +Essentially, the return type is wrapped around the function name in successive layers (like an onion). While attempting to make the two contexts consistent is a laudable goal, it has not worked out in practice. -\CFA provides its own type, variable and routine declarations, using a different syntax. +\CFA provides its own type, variable and function declarations, using a different syntax~\cite[pp.~856--859]{Buhr94a}. The new declarations place qualifiers to the left of the base type, while C declarations place qualifiers to the right. The qualifiers have the same meaning but are ordered left to right to specify a variable's type. @@ -1553,5 +1593,5 @@ \end{cquote} The only exception is bit field specification, which always appear to the right of the base type. -% Specifically, the character @*@ is used to indicate a pointer, square brackets @[@\,@]@ are used to represent an array or function return value, and parentheses @()@ are used to indicate a routine parameter. +% Specifically, the character @*@ is used to indicate a pointer, square brackets @[@\,@]@ are used to represent an array or function return value, and parentheses @()@ are used to indicate a function parameter. However, unlike C, \CFA type declaration tokens are distributed across all variables in the declaration list. For instance, variables @x@ and @y@ of type pointer to integer are defined in \CFA as follows: @@ -1639,8 +1679,8 @@ \lstMakeShortInline@% \end{cquote} -Specifiers must appear at the start of a \CFA routine declaration\footnote{\label{StorageClassSpecifier} +Specifiers must appear at the start of a \CFA function declaration\footnote{\label{StorageClassSpecifier} The placement of a storage-class specifier other than at the beginning of the declaration specifiers in a declaration is an obsolescent feature.~\cite[\S~6.11.5(1)]{C11}}. -The new declaration syntax can be used in other contexts where types are required, \eg casts and the pseudo-routine @sizeof@: +The new declaration syntax can be used in other contexts where types are required, \eg casts and the pseudo-function @sizeof@: \begin{cquote} \lstDeleteShortInline@% @@ -1660,5 +1700,5 @@ \end{cquote} -The syntax of the new routine prototype declaration follows directly from the new routine definition syntax; +The syntax of the new function-prototype declaration follows directly from the new function-definition syntax; as well, parameter names are optional, \eg: \begin{cfa} @@ -1669,6 +1709,6 @@ [ * int, int ] j ( int ); $\C{// returning pointer to int and int, with int parameter}$ \end{cfa} -This syntax allows a prototype declaration to be created by cutting and pasting source text from the routine definition header (or vice versa). -Like C, it is possible to declare multiple routine-prototypes in a single declaration, where the return type is distributed across \emph{all} routine names in the declaration list, \eg: +This syntax allows a prototype declaration to be created by cutting and pasting source text from the function-definition header (or vice versa). +Like C, it is possible to declare multiple function-prototypes in a single declaration, where the return type is distributed across \emph{all} function names in the declaration list, \eg: \begin{cquote} \lstDeleteShortInline@% @@ -1685,16 +1725,16 @@ \lstMakeShortInline@% \end{cquote} -where \CFA allows the last routine in the list to define its body. - -The syntax for pointers to \CFA routines specifies the pointer name on the right, \eg: -\begin{cfa} -* [ int x ] () fp; $\C{// pointer to routine returning int with no parameters}$ -* [ * int ] ( int y ) gp; $\C{// pointer to routine returning pointer to int with int parameter}$ -* [ ] ( int, char ) hp; $\C{// pointer to routine returning no result with int and char parameters}$ -* [ * int, int ] ( int ) jp; $\C{// pointer to routine returning pointer to int and int, with int parameter}$ -\end{cfa} -Note, a routine name cannot be specified: -\begin{cfa} -* [ int x ] f () fp; $\C{// routine name "f" is disallowed}$ +where \CFA allows the last function in the list to define its body. + +The syntax for pointers to \CFA functions specifies the pointer name on the right, \eg: +\begin{cfa} +* [ int x ] () fp; $\C{// pointer to function returning int with no parameters}$ +* [ * int ] ( int y ) gp; $\C{// pointer to function returning pointer to int with int parameter}$ +* [ ] ( int, char ) hp; $\C{// pointer to function returning no result with int and char parameters}$ +* [ * int, int ] ( int ) jp; $\C{// pointer to function returning pointer to int and int, with int parameter}$ +\end{cfa} +Note, a function name cannot be specified: +\begin{cfa} +* [ int x ] f () fp; $\C{// function name "f" is disallowed}$ \end{cfa} @@ -1916,18 +1956,11 @@ Destruction parameters are useful for specifying storage-management actions, such as de-initialize but not deallocate.}. \begin{cfa} -struct VLA { - int len, * data; -}; -void ?{}( VLA & vla ) with ( vla ) { $\C{// default constructor}$ - len = 10; data = alloc( len ); $\C{// shallow copy}$ -} -void ^?{}( VLA & vla ) with ( vla ) { $\C{// destructor}$ - free( data ); -} +struct VLA { int len, * data; }; +void ?{}( VLA & vla ) with ( vla ) { len = 10; data = alloc( len ); } $\C{// default constructor}$ +void ^?{}( VLA & vla ) with ( vla ) { free( data ); } $\C{// destructor}$ { VLA x; $\C{// implicit: ?\{\}( x );}$ } $\C{// implicit: ?\^{}\{\}( x );}$ \end{cfa} -(Note, the example is purposely kept simple by using shallow-copy semantics.) @VLA@ is a \newterm{managed type}\footnote{ A managed type affects the runtime environment versus a self-contained type.}: a type requiring a non-trivial constructor or destructor, or with a field of a managed type. @@ -1937,11 +1970,12 @@ \CFA also provides syntax for \newterm{initialization} and \newterm{copy}: \begin{cfa} -void ?{}( VLA & vla, int size, char fill ) with ( vla ) { $\C{// initialization}$ +void ?{}( VLA & vla, int size, char fill ) with ( vla ) { $\C{// initialization}$ len = size; data = alloc( len, fill ); } -void ?{}( VLA & vla, VLA other ) { $\C{// copy}$ +void ?{}( VLA & vla, VLA other ) { $\C{// copy, shallow}$ vla.len = other.len; vla.data = other.data; } \end{cfa} +(Note, the example is purposely simplified using shallow-copy semantics.) An initialization constructor-call has the same syntax as a C initializer, except the initialization values are passed as arguments to a matching constructor (number and type of paremeters). \begin{cfa} @@ -1957,6 +1991,6 @@ \begin{cfa} { - VLA x, y = { 20, 0x01 }, z = y; - // implicit: ?{}( x ); ?{}( y, 20, 0x01 ); ?{}( z, y ); z points to y + VLA x, y = { 20, 0x01 }, z = y; $\C{// z points to y}$ + // ?{}( x ); ?{}( y, 20, 0x01 ); ?{}( z, y ); ^x{}; $\C{// deallocate x}$ x{}; $\C{// reallocate x}$ @@ -1965,5 +1999,5 @@ y{ x }; $\C{// reallocate y, points to x}$ x{}; $\C{// reallocate x, not pointing to y}$ - // implicit: ^?{}(z); ^?{}(y); ^?{}(x); + // ^?{}(z); ^?{}(y); ^?{}(x); } \end{cfa} @@ -1996,5 +2030,41 @@ C already includes limited polymorphism for literals -- @0@ can be either an integer or a pointer literal, depending on context, while the syntactic forms of literals of the various integer and float types are very similar, differing from each other only in suffix. In keeping with the general \CFA approach of adding features while respecting the ``C-style'' of doing things, C's polymorphic constants and typed literal syntax are extended to interoperate with user-defined types, while maintaining a backwards-compatible semantics. -A trivial example is allowing the underscore to separate prefixes, digits, and suffixes in all \CFA constants, as in Ada, \eg @0x`_`1.ffff`_`ffff`_`p`_`128`_`l@. + +A simple example is allowing the underscore, as in Ada, to separate prefixes, digits, and suffixes in all \CFA constants, \eg @0x`_`1.ffff`_`ffff`_`p`_`128`_`l@, where the underscore is also the standard separator in C identifiers. +\CC uses a single quote as a separator but it is restricted among digits, precluding its use in the literal prefix or suffix, \eg @0x1.ffff@@`'@@ffffp128l@, and causes problems with most IDEs, which must be extended to deal with this alternate use of the single quote. + + +\subsection{Integral Suffixes} + +Additional integral suffixes are added to cover all the integral types and lengths. +\begin{cquote} +\lstDeleteShortInline@% +\begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{\hspace{\parindentlnth}}l@{}} +\begin{cfa} +20_`hh` // signed char +21_`hhu` // unsigned char +22_`h` // signed short int +23_`uh` // unsigned short int +24_`z` // size_t +\end{cfa} +& +\begin{cfa} +20_`L8` // int8_t +21_`ul8` // uint8_t +22_`l16` // int16_t +23_`ul16` // uint16_t +24_`l32` // int32_t +\end{cfa} +& +\begin{cfa} +25_`ul32` // uint32_t +26_`l64` // int64_t +27_`l64u` // uint64_t +26_`L128` // int128 +27_`L128u` // unsigned int128 +\end{cfa} +\end{tabular} +\lstMakeShortInline@% +\end{cquote} @@ -2013,62 +2083,83 @@ -\subsection{Integral Suffixes} - -Additional integral suffixes are added to cover all the integral types and lengths. -\begin{cquote} +\subsection{User Literals} + +For readability, it is useful to associate units to scale literals, \eg weight (stone, pound, kilogram) or time (seconds, minutes, hours). +The left of Figure~\ref{f:UserLiteral} shows the \CFA alternative call-syntax (literal argument before function name), using the backquote, to convert basic literals into user literals. +The backquote is a small character, making the unit (function name) predominate. +For examples, the multi-precision integers in Section~\ref{s:MultiPrecisionIntegers} make use of user literals: +{\lstset{language=CFA,moredelim=**[is][\color{red}]{|}{|},deletedelim=**[is][]{`}{`}} +\begin{cfa} +y = 9223372036854775807L|`mp| * 18446744073709551615UL|`mp|; +y = "12345678901234567890123456789"|`mp| + "12345678901234567890123456789"|`mp|; +\end{cfa} +Because \CFA uses a standard function, all types and literals are applicable, as well as overloading and conversions. +}% + +The right of Figure~\ref{f:UserLiteral} shows the equivalent \CC version using the underscore for the call-syntax. +However, \CC restricts the types, \eg @unsigned long long int@ and @long double@ to represent integral and floating literals. +After which, user literals must match (no conversions); +hence, it is necessary to overload the unit with all appropriate types. + +\begin{figure} +\centering +\lstset{language=CFA,moredelim=**[is][\color{red}]{|}{|},deletedelim=**[is][]{`}{`}} \lstDeleteShortInline@% -\begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{\hspace{\parindentlnth}}l@{}} -\begin{cfa} -20_hh // signed char -21_hhu // unsigned char -22_h // signed short int -23_uh // unsigned short int -24z // size_t -\end{cfa} -& -\begin{cfa} -20_L8 // int8_t -21_ul8 // uint8_t -22_l16 // int16_t -23_ul16 // uint16_t -24_l32 // int32_t -\end{cfa} -& -\begin{cfa} -25_ul32 // uint32_t -26_l64 // int64_t -27_l64u // uint64_t -26_L128 // int128 -27_L128u // unsigned int128 +\begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}} +\multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}} & \multicolumn{1}{c}{\textbf{\CC}} \\ +\begin{cfa} +struct W { + double stones; +}; +void ?{}( W & w ) { w.stones = 0; } +void ?{}( W & w, double w ) { w.stones = w; } +W ?+?( W l, W r ) { + return (W){ l.stones + r.stones }; +} +W |?`st|( double w ) { return (W){ w }; } +W |?`lb|( double w ) { return (W){ w / 14.0 }; } +W |?`kg|( double w ) { return (W) { w * 0.16 }; } + + + +int main() { + W w, heavy = { 20 }; + w = 155|`lb|; + w = 0b_1111|`st|; + w = 0_233|`lb|; + w = 0x_9b_u|`kg|; + w = 5.5|`st| + 8|`kg| + 25.01|`lb| + heavy; +} +\end{cfa} +& +\begin{cfa} +struct W { + double stones; + W() { stones = 0.0; } + W( double w ) { stones = w; } +}; +W operator+( W l, W r ) { + return W( l.stones + r.stones ); +} +W |operator"" _st|( unsigned long long int w ) { return W( w ); } +W |operator"" _lb|( unsigned long long int w ) { return W( w / 14.0 ); } +W |operator"" _kg|( unsigned long long int w ) { return W( w * 0.16 ); } +W |operator"" _st|( long double w ) { return W( w ); } +W |operator"" _lb|( long double w ) { return W( w / 14.0 ); } +W |operator"" _kg|( long double w ) { return W( w * 0.16 ); } +int main() { + W w, heavy = { 20 }; + w = 155|_lb|; + w = 0b1111|_lb|; // error, binary unsupported + w = 0${\color{red}\LstBasicStyle{'}}$233|_lb|; // quote separator + w = 0x9b|_kg|; + w = 5.5d|_st| + 8|_kg| + 25.01|_lb| + heavy; +} \end{cfa} \end{tabular} \lstMakeShortInline@% -\end{cquote} - - -\subsection{Units} - -Alternative call syntax (literal argument before routine name) to convert basic literals into user literals. - -{\lstset{language=CFA,moredelim=**[is][\color{red}]{|}{|},deletedelim=**[is][]{`}{`}} -\begin{cfa} -struct Weight { double stones; }; -void ?{}( Weight & w ) { w.stones = 0; } $\C{// operations}$ -void ?{}( Weight & w, double w ) { w.stones = w; } -Weight ?+?( Weight l, Weight r ) { return (Weight){ l.stones + r.stones }; } - -Weight |?`st|( double w ) { return (Weight){ w }; } $\C{// backquote for units}$ -Weight |?`lb|( double w ) { return (Weight){ w / 14.0 }; } -Weight |?`kg|( double w ) { return (Weight) { w * 0.1575}; } - -int main() { - Weight w, heavy = { 20 }; $\C{// 20 stone}$ - w = 155|`lb|; - w = 0x_9b_u|`lb|; $\C{// hexadecimal unsigned weight (155)}$ - w = 0_233|`lb|; $\C{// octal weight (155)}$ - w = 5|`st| + 8|`kg| + 25|`lb| + heavy; -} -\end{cfa} -}% +\caption{User Literal} +\label{f:UserLiteral} +\end{figure} @@ -2080,5 +2171,5 @@ In many cases, the interface is an inline wrapper providing overloading during compilation but zero cost at runtime. The following sections give a glimpse of the interface reduction to many C libraries. -In many cases, @signed@/@unsigned@ @char@, @short@, and @_Complex@ routines are available (but not shown) to ensure expression computations remain in a single type, as conversions can distort results. +In many cases, @signed@/@unsigned@ @char@, @short@, and @_Complex@ functions are available (but not shown) to ensure expression computations remain in a single type, as conversions can distort results. @@ -2108,11 +2199,10 @@ \begin{cquote} \lstDeleteShortInline@% -\begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}} -\multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}} & \multicolumn{1}{c}{\textbf{C}} \\ +\lstset{basicstyle=\linespread{0.9}\sf\small} +\begin{tabular}{@{}l@{\hspace{0.5\parindentlnth}}l@{}} +\multicolumn{1}{c@{\hspace{0.5\parindentlnth}}}{\textbf{\CFA}} & \multicolumn{1}{c}{\textbf{C}} \\ \begin{cfa} MIN - MAX - PI E @@ -2120,8 +2210,6 @@ & \begin{cfa} -SCHAR_MIN, CHAR_MIN, SHRT_MIN, INT_MIN, LONG_MIN, LLONG_MIN, - FLT_MIN, DBL_MIN, LDBL_MIN -SCHAR_MAX, UCHAR_MAX, SHRT_MAX, INT_MAX, LONG_MAX, LLONG_MAX, - FLT_MAX, DBL_MAX, LDBL_MAX +SCHAR_MIN, CHAR_MIN, SHRT_MIN, INT_MIN, LONG_MIN, LLONG_MIN, FLT_MIN, DBL_MIN, LDBL_MIN +SCHAR_MAX, UCHAR_MAX, SHRT_MAX, INT_MAX, LONG_MAX, LLONG_MAX, FLT_MAX, DBL_MAX, LDBL_MAX M_PI, M_PIl M_E, M_El @@ -2134,6 +2222,6 @@ \subsection{Math} -C library @math.h@ provides many mathematical routines. -\CFA routine overloading is used to condense these mathematical routines, \eg: +C library @math.h@ provides many mathematical functions. +\CFA function overloading is used to condense these mathematical functions, \eg: \begin{cquote} \lstDeleteShortInline@% @@ -2154,5 +2242,5 @@ \lstMakeShortInline@% \end{cquote} -The result is a significant reduction in names to access math routines, \eg: +The result is a significant reduction in names to access math functions, \eg: \begin{cquote} \lstDeleteShortInline@% @@ -2173,14 +2261,14 @@ \lstMakeShortInline@% \end{cquote} -While \Celeven has type-generic math~\cite[\S~7.25]{C11} in @tgmath.h@ to provide a similar mechanism, these macros are limited, matching a routine name with a single set of floating type(s). +While \Celeven has type-generic math~\cite[\S~7.25]{C11} in @tgmath.h@ to provide a similar mechanism, these macros are limited, matching a function name with a single set of floating type(s). For example, it is impossible to overload @atan@ for both one and two arguments; instead the names @atan@ and @atan2@ are required (see Section~\ref{s:NameOverloading}). -The key observation is that only a restricted set of type-generic macros are provided for a limited set of routine names, which do not generalize across the type system, as in \CFA. +The key observation is that only a restricted set of type-generic macros are provided for a limited set of function names, which do not generalize across the type system, as in \CFA. \subsection{Standard} -C library @stdlib.h@ provides many general routines. -\CFA routine overloading is used to condense these utility routines, \eg: +C library @stdlib.h@ provides many general functions. +\CFA function overloading is used to condense these utility functions, \eg: \begin{cquote} \lstDeleteShortInline@% @@ -2201,5 +2289,5 @@ \lstMakeShortInline@% \end{cquote} -The result is a significant reduction in names to access utility routines, \eg: +The result is a significant reduction in names to access utility functions, \eg: \begin{cquote} \lstDeleteShortInline@% @@ -2220,5 +2308,5 @@ \lstMakeShortInline@% \end{cquote} -In additon, there are polymorphic routines, like @min@ and @max@, which work on any type with operators @??@. +In additon, there are polymorphic functions, like @min@ and @max@, which work on any type with operators @??@. The following shows one example where \CFA \emph{extends} an existing standard C interface to reduce complexity and provide safety. @@ -2226,70 +2314,18 @@ \begin{description}[topsep=3pt,itemsep=2pt,parsep=0pt] \item[fill] -after allocation the storage is filled with a specified character. +an allocation with a specified character. \item[resize] -an existing allocation is decreased or increased in size. +an existing allocation to decreased or increased its size. In either case, new storage may or may not be allocated and, if there is a new allocation, as much data from the existing allocation is copied. For an increase in storage size, new storage after the copied data may be filled. \item[alignment] -an allocation starts on a specified memory boundary, \eg, an address multiple of 64 or 128 for cache-line purposes. +an allocation on a specified memory boundary, \eg, an address multiple of 64 or 128 for cache-line purposes. \item[array] -the allocation size is scaled to the specified number of array elements. +allocation of the specified number of elements. An array may be filled, resized, or aligned. \end{description} -Table~\ref{t:StorageManagementOperations} shows the capabilities provided by C/\Celeven allocation-routines and how all the capabilities can be combined into two \CFA routines. - -\CFA storage-management routines extend the C equivalents by overloading, providing shallow type-safety, and removing the need to specify the base allocation-size. -The following example contrasts \CFA and C storage-allocation operation performing the same operations with the same type safety: -\begin{cquote} -\begin{cfa}[aboveskip=0pt] -size_t dim = 10; $\C{// array dimension}$ -char fill = '\xff'; $\C{// initialization fill value}$ -int * ip; -\end{cfa} -\lstDeleteShortInline@% -\begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}} -\multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}} & \multicolumn{1}{c}{\textbf{C}} \\ -\begin{cfa} -ip = alloc(); -ip = alloc( fill ); -ip = alloc( dim ); -ip = alloc( dim, fill ); -ip = alloc( ip, 2 * dim ); -ip = alloc( ip, 4 * dim, fill ); - -ip = align_alloc( 16 ); -ip = align_alloc( 16, fill ); -ip = align_alloc( 16, dim ); -ip = align_alloc( 16, dim, fill ); -\end{cfa} -& -\begin{cfa} -ip = (int *)malloc( sizeof( int ) ); -ip = (int *)malloc( sizeof( int ) ); memset( ip, fill, sizeof( int ) ); -ip = (int *)malloc( dim * sizeof( int ) ); -ip = (int *)malloc( sizeof( int ) ); memset( ip, fill, dim * sizeof( int ) ); -ip = (int *)realloc( ip, 2 * dim * sizeof( int ) ); -ip = (int *)realloc( ip, 4 * dim * sizeof( int ) ); memset( ip, fill, 4 * dim * sizeof( int ) ); - -ip = memalign( 16, sizeof( int ) ); -ip = memalign( 16, sizeof( int ) ); memset( ip, fill, sizeof( int ) ); -ip = memalign( 16, dim * sizeof( int ) ); -ip = memalign( 16, dim * sizeof( int ) ); memset( ip, fill, dim * sizeof( int ) ); -\end{cfa} -\end{tabular} -\lstMakeShortInline@% -\end{cquote} -Variadic @new@ (see Section~\ref{sec:variadic-tuples}) cannot support the same overloading because extra parameters are for initialization. -Hence, there are @new@ and @anew@ routines for single and array variables, and the fill value is the arguments to the constructor, \eg: -\begin{cfa} -struct S { int i, j; }; -void ?{}( S & s, int i, int j ) { s.i = i; s.j = j; } -S * s = new( 2, 3 ); $\C{// allocate storage and run constructor}$ -S * as = anew( dim, 2, 3 ); $\C{// each array element initialized to 2, 3}$ -\end{cfa} -Note, \CC can only initialization array elements via the default constructor. - -Finally, the \CFA memory-allocator has \newterm{sticky properties} for dynamic storage: fill and alignment are remembered with an object's storage in the heap. -When a @realloc@ is performed, the sticky properties are respected, so that new storage is correctly aligned and initialized with the fill character. +Table~\ref{t:StorageManagementOperations} shows the capabilities provided by C/\Celeven allocation-functions and how all the capabilities can be combined into two \CFA functions. +\CFA storage-management functions extend the C equivalents by overloading, providing shallow type-safety, and removing the need to specify the base allocation-size. +Figure~\ref{f:StorageAllocation} contrasts \CFA and C storage-allocation performing the same operations with the same type safety. \begin{table} @@ -2317,4 +2353,62 @@ \end{table} +\begin{figure} +\centering +\begin{cquote} +\begin{cfa}[aboveskip=0pt] +size_t dim = 10; $\C{// array dimension}$ +char fill = '\xff'; $\C{// initialization fill value}$ +int * ip; +\end{cfa} +\lstDeleteShortInline@% +\begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}} +\multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}} & \multicolumn{1}{c}{\textbf{C}} \\ +\begin{cfa} +ip = alloc(); +ip = alloc( fill ); +ip = alloc( dim ); +ip = alloc( dim, fill ); +ip = alloc( ip, 2 * dim ); +ip = alloc( ip, 4 * dim, fill ); + +ip = align_alloc( 16 ); +ip = align_alloc( 16, fill ); +ip = align_alloc( 16, dim ); +ip = align_alloc( 16, dim, fill ); +\end{cfa} +& +\begin{cfa} +ip = (int *)malloc( sizeof( int ) ); +ip = (int *)malloc( sizeof( int ) ); memset( ip, fill, sizeof( int ) ); +ip = (int *)malloc( dim * sizeof( int ) ); +ip = (int *)malloc( sizeof( int ) ); memset( ip, fill, dim * sizeof( int ) ); +ip = (int *)realloc( ip, 2 * dim * sizeof( int ) ); +ip = (int *)realloc( ip, 4 * dim * sizeof( int ) ); memset( ip, fill, 4 * dim * sizeof( int ) ); + +ip = memalign( 16, sizeof( int ) ); +ip = memalign( 16, sizeof( int ) ); memset( ip, fill, sizeof( int ) ); +ip = memalign( 16, dim * sizeof( int ) ); +ip = memalign( 16, dim * sizeof( int ) ); memset( ip, fill, dim * sizeof( int ) ); +\end{cfa} +\end{tabular} +\lstMakeShortInline@% +\end{cquote} +\caption{\CFA versus C Storage-Allocation} +\label{f:StorageAllocation} +\end{figure} + +Variadic @new@ (see Section~\ref{sec:variadic-tuples}) cannot support the same overloading because extra parameters are for initialization. +Hence, there are @new@ and @anew@ functions for single and array variables, and the fill value is the arguments to the constructor, \eg: +\begin{cfa} +struct S { int i, j; }; +void ?{}( S & s, int i, int j ) { s.i = i; s.j = j; } +S * s = new( 2, 3 ); $\C{// allocate storage and run constructor}$ +S * as = anew( dim, 2, 3 ); $\C{// each array element initialized to 2, 3}$ +\end{cfa} +Note, \CC can only initialization array elements via the default constructor. + +Finally, the \CFA memory-allocator has \newterm{sticky properties} for dynamic storage: fill and alignment are remembered with an object's storage in the heap. +When a @realloc@ is performed, the sticky properties are respected, so that new storage is correctly aligned and initialized with the fill character. + \subsection{I/O} @@ -2376,5 +2470,4 @@ \end{cfa} \\ -\textbf{output:} & \begin{cfa}[showspaces=true,aboveskip=0pt] @@ -2404,5 +2497,5 @@ }% \end{itemize} -There are routines to set and get the separator string, and manipulators to toggle separation on and off in the middle of output. +There are functions to set and get the separator string, and manipulators to toggle separation on and off in the middle of output. @@ -2411,5 +2504,5 @@ \CFA has an interface to the GMP multi-precision signed-integers~\cite{GMP}, similar to the \CC interface provided by GMP. -The \CFA interface wraps GMP routines into operator routines to make programming with multi-precision integers identical to using fixed-sized integers. +The \CFA interface wraps GMP functions into operator functions to make programming with multi-precision integers identical to using fixed-sized integers. The \CFA type name for multi-precision signed-integers is @Int@ and the header file is @gmp@. The following multi-precision factorial programs contrast using GMP with the \CFA and C interfaces. @@ -2456,5 +2549,5 @@ Since all these languages share a subset essentially comprising standard C, maximal-performance benchmarks would show little runtime variance, other than in length and clarity of source code. A more illustrative benchmark measures the costs of idiomatic usage of each language's features. -Figure~\ref{fig:BenchmarkTest} shows the \CFA benchmark tests for a generic stack based on a singly linked-list, a generic pair-data-structure, and a variadic @print@ routine similar to that in Section~\ref{sec:variadic-tuples}. +Figure~\ref{fig:BenchmarkTest} shows the \CFA benchmark tests for a generic stack based on a singly linked-list, a generic pair-data-structure, and a variadic @print@ function similar to that in Section~\ref{sec:variadic-tuples}. The benchmark test is similar for C and \CC. The experiment uses element types @int@ and @pair(_Bool, char)@, and pushes $N=40M$ elements on a generic stack, copies the stack, clears one of the stacks, finds the maximum value in the other stack, and prints $N/2$ (to reduce graph height) constants. @@ -2463,22 +2556,21 @@ \begin{cfa}[xleftmargin=3\parindentlnth,aboveskip=0pt,belowskip=0pt] int main( int argc, char * argv[] ) { - ofstream out = { "cfa-out.txt" }; int max = 0, val = 42; - stack( int ) si, t; + stack( int ) si, ti; REPEAT_TIMED( "push_int", N, push( si, val ); ) - TIMED( "copy_int", t = si; ) + TIMED( "copy_int", ti = si; ) TIMED( "clear_int", clear( si ); ) - REPEAT_TIMED( "pop_int", N, int x = pop( t ); max = max( x, max ); ) - REPEAT_TIMED( "print_int", N/2, out | val | ':' | val | endl; ) + REPEAT_TIMED( "pop_int", N, + int x = pop( ti ); if ( x > max ) max = x; ) pair( _Bool, char ) max = { (_Bool)0, '\0' }, val = { (_Bool)1, 'a' }; - stack( pair( _Bool, char ) ) s, t; - - REPEAT_TIMED( "push_pair", N, push( s, val ); ) - TIMED( "copy_pair", t = s; ) - TIMED( "clear_pair", clear( s ); ) - REPEAT_TIMED( "pop_pair", N, pair(_Bool, char) x = pop( t ); max = max( x, max ); ) - REPEAT_TIMED( "print_pair", N/2, out | val | ':' | val | endl; ) + stack( pair( _Bool, char ) ) sp, tp; + + REPEAT_TIMED( "push_pair", N, push( sp, val ); ) + TIMED( "copy_pair", tp = sp; ) + TIMED( "clear_pair", clear( sp ); ) + REPEAT_TIMED( "pop_pair", N, + pair(_Bool, char) x = pop( tp ); if ( x > max ) max = x; ) } \end{cfa} @@ -2551,11 +2643,11 @@ \CC is the most similar language to \CFA; both are extensions to C with source and runtime backwards compatibility. -The fundamental difference is in their engineering approach to C compatibility and programmer expectation. -While \CC provides good backwards compatibility with C, it has a steep learning curve for many of its extensions. +The fundamental difference is the engineering approach to maintain C compatibility and programmer expectation. +While \CC provides good compatibility with C, it has a steep learning curve for many of its extensions. For example, polymorphism is provided via three disjoint mechanisms: overloading, inheritance, and templates. The overloading is restricted because resolution does not use the return type, inheritance requires learning object-oriented programming and coping with a restricted nominal-inheritance hierarchy, templates cannot be separately compiled resulting in compilation/code bloat and poor error messages, and determining how these mechanisms interact and which to use is confusing. In contrast, \CFA has a single facility for polymorphic code supporting type-safe separate-compilation of polymorphic functions and generic (opaque) types, which uniformly leverage the C procedural paradigm. -The key mechanism to support separate compilation is \CFA's \emph{explicit} use of assumed properties for a type. -Until \CC concepts~\cite{C++Concepts} are standardized (anticipated for \CCtwenty), \CC provides no way to specify the requirements of a generic function in code beyond compilation errors during template expansion; +The key mechanism to support separate compilation is \CFA's \emph{explicit} use of assumed type properties. +Until \CC concepts~\cite{C++Concepts} are standardized (anticipated for \CCtwenty), \CC provides no way to specify the requirements of a generic function beyond compilation errors during template expansion; furthermore, \CC concepts are restricted to template polymorphism. @@ -2608,4 +2700,22 @@ +\subsection{Control Structures / Declarations / Literals} + +Java has default fall through like C/\CC. +Pascal/Ada/Go/Rust do not have default fall through. +\Csharp does not have fall through but still requires a break. +Python uses dictionary mapping. \\ +\CFA choose is like Rust match. + +Java has labelled break/continue. \\ +Languages with and without exception handling. + +Alternative C declarations. \\ +Different references \\ +Constructors/destructors + +0/1 Literals \\ +user defined: D, Objective-C + \section{Conclusion and Future Work} @@ -2613,5 +2723,5 @@ While other programming languages purport to be a better C, they are in fact new and interesting languages in their own right, but not C extensions. The purpose of this paper is to introduce \CFA, and showcase language features that illustrate the \CFA type-system and approaches taken to achieve the goal of evolutionary C extension. -The contributions are a powerful type-system using parametric polymorphism and overloading, generic types, and tuples, which all have complex interactions. +The contributions are a powerful type-system using parametric polymorphism and overloading, generic types, tuples, advanced control structures, and extended declarations, which all have complex interactions. The work is a challenging design, engineering, and implementation exercise. On the surface, the project may appear as a rehash of similar mechanisms in \CC. @@ -2620,5 +2730,5 @@ Finally, we demonstrate that \CFA performance for some idiomatic cases is better than C and close to \CC, showing the design is practically applicable. -There is ongoing work on a wide range of \CFA feature extensions, including arrays with size, exceptions, concurrent primitives, modules, and user-defined conversions. +There is ongoing work on a wide range of \CFA feature extensions, including arrays with size, user-defined conversions, concurrent primitives, and modules. (While all examples in the paper compile and run, a public beta-release of \CFA will take another 8--12 months to finalize these additional extensions.) In addition, there are interesting future directions for the polymorphism design. @@ -2633,6 +2743,7 @@ \section{Acknowledgments} -The authors would like to recognize the design assistance of Glen Ditchfield, Richard Bilson, and Thierry Delisle on the features described in this paper, and thank Magnus Madsen for feedback in the writing. -%This work is supported in part by a corporate partnership with \grantsponsor{Huawei}{Huawei Ltd.}{http://www.huawei.com}, and Aaron Moss and Peter Buhr are funded by the \grantsponsor{Natural Sciences and Engineering Research Council} of Canada. +The authors would like to recognize the design assistance of Glen Ditchfield, Richard Bilson, Thierry Delisle, and Andrew Beach on the features described in this paper, and thank Magnus Madsen for feedback in the writing. +This work is supported through a corporate partnership with Huawei Ltd.\ (\url{http://www.huawei.com}), and Aaron Moss and Peter Buhr are partially funded by the Natural Sciences and Engineering Research Council of Canada. + % the first author's \grantsponsor{NSERC-PGS}{NSERC PGS D}{http://www.nserc-crsng.gc.ca/Students-Etudiants/PG-CS/BellandPostgrad-BelletSuperieures_eng.asp} scholarship. @@ -2666,5 +2777,7 @@ stack_node(T) ** crnt = &s.head; for ( stack_node(T) * next = t.head; next; next = next->next ) { - *crnt = malloc(){ next->value }; + stack_node(T) * new_node = ((stack_node(T)*)malloc()); + (*new_node){ next->value }; /***/ + *crnt = new_node; stack_node(T) * acrnt = *crnt; crnt = &acrnt->next; @@ -2681,13 +2794,14 @@ forall(otype T) _Bool empty( const stack(T) & s ) { return s.head == 0; } forall(otype T) void push( stack(T) & s, T value ) { - s.head = malloc(){ value, s.head }; + stack_node(T) * new_node = ((stack_node(T)*)malloc()); + (*new_node){ value, s.head }; /***/ + s.head = new_node; } forall(otype T) T pop( stack(T) & s ) { stack_node(T) * n = s.head; s.head = n->next; - T x = n->value; - ^n{}; - free( n ); - return x; + T v = n->value; + delete( n ); + return v; } forall(otype T) void clear( stack(T) & s ) { @@ -2845,99 +2959,4 @@ -\begin{comment} -\subsubsection{bench.h} -(\texttt{bench.hpp} is similar.) - -\lstinputlisting{evaluation/bench.h} - -\subsection{C} - -\subsubsection{c-stack.h} ~ - -\lstinputlisting{evaluation/c-stack.h} - -\subsubsection{c-stack.c} ~ - -\lstinputlisting{evaluation/c-stack.c} - -\subsubsection{c-pair.h} ~ - -\lstinputlisting{evaluation/c-pair.h} - -\subsubsection{c-pair.c} ~ - -\lstinputlisting{evaluation/c-pair.c} - -\subsubsection{c-print.h} ~ - -\lstinputlisting{evaluation/c-print.h} - -\subsubsection{c-print.c} ~ - -\lstinputlisting{evaluation/c-print.c} - -\subsubsection{c-bench.c} ~ - -\lstinputlisting{evaluation/c-bench.c} - -\subsection{\CFA} - -\subsubsection{cfa-stack.h} ~ - -\lstinputlisting{evaluation/cfa-stack.h} - -\subsubsection{cfa-stack.c} ~ - -\lstinputlisting{evaluation/cfa-stack.c} - -\subsubsection{cfa-print.h} ~ - -\lstinputlisting{evaluation/cfa-print.h} - -\subsubsection{cfa-print.c} ~ - -\lstinputlisting{evaluation/cfa-print.c} - -\subsubsection{cfa-bench.c} ~ - -\lstinputlisting{evaluation/cfa-bench.c} - -\subsection{\CC} - -\subsubsection{cpp-stack.hpp} ~ - -\lstinputlisting[language=c++]{evaluation/cpp-stack.hpp} - -\subsubsection{cpp-print.hpp} ~ - -\lstinputlisting[language=c++]{evaluation/cpp-print.hpp} - -\subsubsection{cpp-bench.cpp} ~ - -\lstinputlisting[language=c++]{evaluation/cpp-bench.cpp} - -\subsection{\CCV} - -\subsubsection{object.hpp} ~ - -\lstinputlisting[language=c++]{evaluation/object.hpp} - -\subsubsection{cpp-vstack.hpp} ~ - -\lstinputlisting[language=c++]{evaluation/cpp-vstack.hpp} - -\subsubsection{cpp-vstack.cpp} ~ - -\lstinputlisting[language=c++]{evaluation/cpp-vstack.cpp} - -\subsubsection{cpp-vprint.hpp} ~ - -\lstinputlisting[language=c++]{evaluation/cpp-vprint.hpp} - -\subsubsection{cpp-vbench.cpp} ~ - -\lstinputlisting[language=c++]{evaluation/cpp-vbench.cpp} -\end{comment} - \end{document} Index: doc/papers/general/evaluation/Makefile =================================================================== --- doc/papers/general/evaluation/Makefile (revision b2e88418a9a140cb8c4fa54dea5e578f4f29cf9d) +++ doc/papers/general/evaluation/Makefile (revision f4abc582d3b6b606b643e66534b4f6671f8ecbdf) @@ -2,7 +2,11 @@ CFA = cfa DEPFLAGS = -MMD -MP +ifdef DBG +CFLAGS = -O0 -ggdb -DN=500 +else CFLAGS = -O2 ifdef N CFLAGS += -DN=$(N) +endif endif CXXFLAGS = $(CFLAGS) --std=c++14 @@ -27,14 +31,14 @@ $(COMPILE.cfa) $(OUTPUT_OPTION) -c $< -COBJS = c-stack.o c-pair.o c-print.o c-bench.o +COBJS = c-stack.o c-pair.o c-bench.o CPPOBJS = cpp-bench.o CPPVOBJS = cpp-vstack.o cpp-vbench.o -CFAOBJS = cfa-stack.o cfa-pair.o cfa-print.o cfa-bench.o +CFAOBJS = cfa-stack.o cfa-pair.o cfa-bench.o ${COBJS} ${CPPOBJS} ${CPPVOBJS} ${CFAOBJS} : ${MAKEFILE_NAME} CFILES = bench.h $(patsubst c-bench.h,,$(COBJS:.o=.h)) $(COBJS:.o=.c) -CPPFILES = bench.hpp cpp-stack.hpp cpp-pair.hpp cpp-print.hpp $(CPPOBJS:.o=.cpp) -CPPVFILES = bench.hpp object.hpp cpp-vprint.hpp $(patsubst cpp-vbench.hpp,,$(CPPVOBJS:.o=.hpp)) $(CPPVOBJS:.o=.cpp) +CPPFILES = bench.hpp cpp-stack.hpp cpp-pair.hpp $(CPPOBJS:.o=.cpp) +CPPVFILES = bench.hpp object.hpp $(patsubst cpp-vbench.hpp,,$(CPPVOBJS:.o=.hpp)) $(CPPVOBJS:.o=.cpp) CFAFILES = bench.h $(patsubst cfa-bench.h,,$(CFAOBJS:.o=.h)) $(CFAOBJS:.o=.c) Index: doc/papers/general/evaluation/bench.h =================================================================== --- doc/papers/general/evaluation/bench.h (revision b2e88418a9a140cb8c4fa54dea5e578f4f29cf9d) +++ doc/papers/general/evaluation/bench.h (revision f4abc582d3b6b606b643e66534b4f6671f8ecbdf) @@ -5,5 +5,8 @@ long ms_between(clock_t start, clock_t end) { return (end - start) / (CLOCKS_PER_SEC / 1000); } +#ifndef N #define N 40000000 +#endif + #define TIMED(name, code) { \ volatile clock_t _start, _end; \ Index: doc/papers/general/evaluation/bench.hpp =================================================================== --- doc/papers/general/evaluation/bench.hpp (revision b2e88418a9a140cb8c4fa54dea5e578f4f29cf9d) +++ doc/papers/general/evaluation/bench.hpp (revision f4abc582d3b6b606b643e66534b4f6671f8ecbdf) @@ -6,5 +6,8 @@ long ms_between(clock_t start, clock_t end) { return (end - start) / (CLOCKS_PER_SEC / 1000); } +#ifndef N static const int N = 40000000; +#endif + #define TIMED(name, code) { \ volatile clock_t _start, _end; \ Index: doc/papers/general/evaluation/c-bench.c =================================================================== --- doc/papers/general/evaluation/c-bench.c (revision b2e88418a9a140cb8c4fa54dea5e578f4f29cf9d) +++ doc/papers/general/evaluation/c-bench.c (revision f4abc582d3b6b606b643e66534b4f6671f8ecbdf) @@ -4,5 +4,4 @@ #include "c-pair.h" #include "c-stack.h" -#include "c-print.h" _Bool* new_bool( _Bool b ) { @@ -39,5 +38,4 @@ int main(int argc, char** argv) { - FILE * out = fopen("/dev/null", "w"); int maxi = 0, vali = 42; struct stack si = new_stack(), ti; @@ -50,5 +48,4 @@ if ( *xi > maxi ) { maxi = *xi; } free(xi); ) - REPEAT_TIMED( "print_int", N/2, print( out, "dsds", vali, ":", vali, "\n" ); /***/ ) struct pair * maxp = new_pair( new_bool(0), new_char('\0') ), @@ -67,7 +64,5 @@ free_pair_bool_char( xp ); /***/ } ) - REPEAT_TIMED( "print_pair", N/2, print( out, "pbcspbcs", *valp, ":", *valp, "\n" ); /***/ ) free_pair_bool_char( maxp ); /***/ free_pair_bool_char( valp ); /***/ - fclose(out); } Index: doc/papers/general/evaluation/cfa-bench.c =================================================================== --- doc/papers/general/evaluation/cfa-bench.c (revision b2e88418a9a140cb8c4fa54dea5e578f4f29cf9d) +++ doc/papers/general/evaluation/cfa-bench.c (revision f4abc582d3b6b606b643e66534b4f6671f8ecbdf) @@ -1,27 +1,23 @@ -#include -#include #include "bench.h" #include "cfa-stack.h" #include "cfa-pair.h" -#include "cfa-print.h" int main( int argc, char * argv[] ) { - ofstream out = { "/dev/null" }; int max = 0, val = 42; - stack( int ) si, t; + stack( int ) si, ti; REPEAT_TIMED( "push_int", N, push( si, val ); ) - TIMED( "copy_int", t = si; ) + TIMED( "copy_int", ti = si; ) TIMED( "clear_int", clear( si ); ) - REPEAT_TIMED( "pop_int", N, int x = pop( t ); max = max( x, max ); ) - REPEAT_TIMED( "print_int", N/2, out | val | ':' | val | endl; ) + REPEAT_TIMED( "pop_int", N, + int x = pop( ti ); if ( x > max ) max = x; ) - pair( _Bool, char ) max = { (_Bool)0, '\0' }, val = { (_Bool)1, 'a' }; - stack( pair( _Bool, char ) ) s, t; + pair( _Bool, char ) max = { (_Bool)0 /***/, '\0' }, val = { (_Bool)1 /***/, 'a' }; + stack( pair( _Bool, char ) ) sp, tp; - REPEAT_TIMED( "push_pair", N, push( s, val ); ) - TIMED( "copy_pair", t = s; ) - TIMED( "clear_pair", clear( s ); ) - REPEAT_TIMED( "pop_pair", N, pair(_Bool, char) x = pop( t ); max = max( x, max ); ) - REPEAT_TIMED( "print_pair", N/2, out | val | ':' | val | endl; ) + REPEAT_TIMED( "push_pair", N, push( sp, val ); ) + TIMED( "copy_pair", tp = sp; ) + TIMED( "clear_pair", clear( sp ); ) + REPEAT_TIMED( "pop_pair", N, + pair(_Bool, char) x = pop( tp ); if ( x > max ) max = x; ) } Index: doc/papers/general/evaluation/cfa-pair.c =================================================================== --- doc/papers/general/evaluation/cfa-pair.c (revision b2e88418a9a140cb8c4fa54dea5e578f4f29cf9d) +++ doc/papers/general/evaluation/cfa-pair.c (revision f4abc582d3b6b606b643e66534b4f6671f8ecbdf) @@ -36,7 +36,7 @@ } -forall(otype R, otype S) -forall(dtype ostype | ostream( ostype ) | { ostype & ?|?( ostype &, R ); ostype & ?|?( ostype &, S ); }) -ostype & ?|?( ostype & os, pair(R, S) p ) { - return os | '[' | p.first | ',' | p.second | ']'; -} // ?|? +// forall(otype R, otype S) +// forall(dtype ostype | ostream( ostype ) | { ostype & ?|?( ostype &, R ); ostype & ?|?( ostype &, S ); }) +// ostype & ?|?( ostype & os, pair(R, S) p ) { +// return os | '[' | p.first | ',' | p.second | ']'; +// } // ?|? Index: doc/papers/general/evaluation/cfa-pair.h =================================================================== --- doc/papers/general/evaluation/cfa-pair.h (revision b2e88418a9a140cb8c4fa54dea5e578f4f29cf9d) +++ doc/papers/general/evaluation/cfa-pair.h (revision f4abc582d3b6b606b643e66534b4f6671f8ecbdf) @@ -30,5 +30,5 @@ int ?>=?(pair(R, S) p, pair(R, S) q); -forall(otype R, otype S) -forall(dtype ostype | ostream( ostype ) | { ostype & ?|?( ostype &, pair(R, S) ); }) -ostype & ?|?( ostype & os, pair(R, S) ); +// forall(otype R, otype S) +// forall(dtype ostype | ostream( ostype ) | { ostype & ?|?( ostype &, R ); ostype & ?|?( ostype &, S ); }) +// ostype & ?|?( ostype & os, pair(R, S) ); Index: doc/papers/general/evaluation/cfa-stack.c =================================================================== --- doc/papers/general/evaluation/cfa-stack.c (revision b2e88418a9a140cb8c4fa54dea5e578f4f29cf9d) +++ doc/papers/general/evaluation/cfa-stack.c (revision f4abc582d3b6b606b643e66534b4f6671f8ecbdf) @@ -6,8 +6,4 @@ stack_node(T) * next; }; -forall(otype T) void ?{}( stack_node(T) & node, T value, stack_node(T) * next ) { - node.value = value; - node.next = next; -} forall(otype T) void ?{}( stack(T) & s ) { (s.head){ 0 }; } @@ -16,10 +12,8 @@ stack_node(T) ** crnt = &s.head; for ( stack_node(T) * next = t.head; next; next = next->next ) { - // *crnt = new( next->value, (stack_node(T)*)0 ); - stack_node(T)* new_node = ((stack_node(T)*)malloc()); - (*new_node){ next->value }; /***/ + stack_node(T)* new_node = (stack_node(T)*)malloc(); /***/ + (*new_node){ next->value }; *crnt = new_node; - stack_node(T) * acrnt = *crnt; - crnt = &acrnt->next; + crnt = &(*crnt)->next; } *crnt = 0; @@ -38,7 +32,6 @@ forall(otype T) void push( stack(T) & s, T value ) { - // s.head = new( value, s.head ); - stack_node(T)* new_node = ((stack_node(T)*)malloc()); - (*new_node){ value, s.head }; /***/ + stack_node(T)* new_node = (stack_node(T)*)malloc(); /***/ + (*new_node){ value, s.head }; s.head = new_node; } @@ -48,5 +41,6 @@ s.head = n->next; T v = n->value; - delete( n ); + ^(*n){}; + free( n ); return v; } @@ -56,5 +50,6 @@ stack_node(T) * crnt = next; next = crnt->next; - delete( crnt ); + ^(*crnt){}; + free(crnt); } s.head = 0; Index: doc/papers/general/evaluation/cpp-bench.cpp =================================================================== --- doc/papers/general/evaluation/cpp-bench.cpp (revision b2e88418a9a140cb8c4fa54dea5e578f4f29cf9d) +++ doc/papers/general/evaluation/cpp-bench.cpp (revision f4abc582d3b6b606b643e66534b4f6671f8ecbdf) @@ -1,11 +1,8 @@ #include -#include #include "bench.hpp" #include "cpp-stack.hpp" #include "cpp-pair.hpp" -#include "cpp-print.hpp" int main(int argc, char** argv) { - std::ofstream out{"/dev/null"}; int maxi = 0, vali = 42; stack si, ti; @@ -15,5 +12,4 @@ TIMED( "clear_int", si.clear(); ) REPEAT_TIMED( "pop_int", N, maxi = std::max( maxi, ti.pop() ); ) - REPEAT_TIMED( "print_int", N/2, print( out, vali, ":", vali, "\n" ); ) pair maxp = { false, '\0' }, valp = { true, 'a' }; @@ -24,4 +20,3 @@ TIMED( "clear_pair", sp.clear(); ) REPEAT_TIMED( "pop_pair", N, maxp = std::max( maxp, tp.pop() ); ) - REPEAT_TIMED( "print_pair", N/2, print( out, valp, ":", valp, "\n" ); ) } Index: doc/papers/general/evaluation/cpp-vbench.cpp =================================================================== --- doc/papers/general/evaluation/cpp-vbench.cpp (revision b2e88418a9a140cb8c4fa54dea5e578f4f29cf9d) +++ doc/papers/general/evaluation/cpp-vbench.cpp (revision f4abc582d3b6b606b643e66534b4f6671f8ecbdf) @@ -1,11 +1,8 @@ #include -#include #include "bench.hpp" #include "cpp-vstack.hpp" -#include "cpp-vprint.hpp" #include "object.hpp" int main(int argc, char** argv) { - std::ofstream out{"/dev/null"}; integer maxi{ 0 }, vali{ 42 }; stack si, ti; @@ -15,5 +12,4 @@ TIMED( "clear_int", si.clear(); ) REPEAT_TIMED( "pop_int", N, maxi = std::max( maxi, ti.pop()->as() ); /***/ ) - REPEAT_TIMED( "print_int", N/2, print( out, vali, c_string{":"}, vali, c_string{"\n"} ); ) ptr maxp = make( make(false), make('\0') ); @@ -27,4 +23,3 @@ ptr xp = as_ptr( tp.pop() ); /***/ if ( *xp > *maxp ) { maxp = std::move(xp); } ) - REPEAT_TIMED( "print_pair", N/2, print( out, valp, c_string{":"}, valp, c_string{"\n"} ); ) } Index: doc/papers/general/evaluation/timing.dat =================================================================== --- doc/papers/general/evaluation/timing.dat (revision b2e88418a9a140cb8c4fa54dea5e578f4f29cf9d) +++ doc/papers/general/evaluation/timing.dat (revision f4abc582d3b6b606b643e66534b4f6671f8ecbdf) @@ -1,11 +1,10 @@ "400 million repetitions" "C" "\\CFA{}" "\\CC{}" "\\CC{obj}" -"push\nint" 3002 2459 1520 3305 -"copy\nint" 2985 2057 1521 3152 -"clear\nint" 1374 827 718 1469 -"pop\nint" 1416 1221 717 5467 -"print\nint" 5656 6758 3120 3121 -"push\npair" 4214 2752 946 6826 -"copy\npair" 6127 2105 993 7330 -"clear\npair" 2881 885 711 3564 -"pop\npair" 3046 5434 783 26538 -"print\npair" 7514 10714 8717 16525 +"push\nint" 2976 2225 1522 3266 +"copy\nnt" 2932 7072 1526 3110 +"clear\nint" 1380 731 750 1488 +"pop\nint" 1444 1196 756 5156 +"push\npair" 3695 2257 953 6840 +"copy\npair" 6034 6650 994 7224 +"clear\npair" 2832 848 742 3297 +"pop\npair" 3009 5348 797 25235 + Index: src/Common/SemanticError.h =================================================================== --- src/Common/SemanticError.h (revision b2e88418a9a140cb8c4fa54dea5e578f4f29cf9d) +++ src/Common/SemanticError.h (revision f4abc582d3b6b606b643e66534b4f6671f8ecbdf) @@ -72,7 +72,4 @@ } - - - // Local Variables: // // tab-width: 4 // Index: src/Parser/ExpressionNode.cc =================================================================== --- src/Parser/ExpressionNode.cc (revision b2e88418a9a140cb8c4fa54dea5e578f4f29cf9d) +++ src/Parser/ExpressionNode.cc (revision f4abc582d3b6b606b643e66534b4f6671f8ecbdf) @@ -10,6 +10,6 @@ // Created On : Sat May 16 13:17:07 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Wed Sep 27 22:51:55 2017 -// Update Count : 781 +// Last Modified On : Sat Mar 3 18:22:33 2018 +// Update Count : 796 // @@ -58,4 +58,5 @@ static inline bool checkD( char c ) { return c == 'd' || c == 'D'; } static inline bool checkI( char c ) { return c == 'i' || c == 'I'; } +static inline bool checkB( char c ) { return c == 'b' || c == 'B'; } static inline bool checkX( char c ) { return c == 'x' || c == 'X'; } @@ -116,5 +117,5 @@ unsigned long long int v; // converted integral value - size_t last = str.length() - 1; // last character of constant + size_t last = str.length() - 1; // last subscript of constant Expression * ret; @@ -129,8 +130,18 @@ } // if - if ( str[0] == '0' ) { // octal/hex constant ? + // Cannot be "0" + + if ( str[0] == '0' ) { // radix character ? dec = false; - if ( last != 0 && checkX( str[1] ) ) { // hex constant ? + if ( checkX( str[1] ) ) { // hex constant ? sscanf( (char *)str.c_str(), "%llx", &v ); + //printf( "%llx %llu\n", v, v ); + } else if ( checkB( str[1] ) ) { // binary constant ? + v = 0; + for ( unsigned int i = 2;; i += 1 ) { // compute value + if ( str[i] == '1' ) v |= 1; + if ( i == last ) break; + v <<= 1; + } // for //printf( "%llx %llu\n", v, v ); } else { // octal constant Index: src/Parser/lex.ll =================================================================== --- src/Parser/lex.ll (revision b2e88418a9a140cb8c4fa54dea5e578f4f29cf9d) +++ src/Parser/lex.ll (revision f4abc582d3b6b606b643e66534b4f6671f8ecbdf) @@ -10,6 +10,6 @@ * Created On : Sat Sep 22 08:58:10 2001 * Last Modified By : Peter A. Buhr - * Last Modified On : Thu Feb 22 18:11:27 2018 - * Update Count : 637 + * Last Modified On : Sat Mar 3 18:38:16 2018 + * Update Count : 640 */ @@ -77,4 +77,5 @@ %} +binary [0-1] octal [0-7] nonzero [1-9] @@ -103,4 +104,8 @@ nonzero_digits ({nonzero})|({nonzero}({decimal}|"_")*{decimal}) decimal_constant {nonzero_digits}{integer_suffix_opt} + +binary_digits ({binary})|({binary}({binary}|"_")*{binary}) +binary_prefix "0"[bB]"_"? +binary_constant {binary_prefix}{binary_digits}{integer_suffix_opt} hex_digits ({hex})|({hex}({hex}|"_")*{hex}) @@ -315,6 +320,7 @@ /* numeric constants */ +{binary_constant} { NUMERIC_RETURN(INTEGERconstant); } +{octal_constant} { NUMERIC_RETURN(INTEGERconstant); } {decimal_constant} { NUMERIC_RETURN(INTEGERconstant); } -{octal_constant} { NUMERIC_RETURN(INTEGERconstant); } {hex_constant} { NUMERIC_RETURN(INTEGERconstant); } {floating_decimal} { NUMERIC_RETURN(FLOATING_DECIMALconstant); } // must appear before floating_constant Index: src/libcfa/concurrency/kernel =================================================================== --- src/libcfa/concurrency/kernel (revision b2e88418a9a140cb8c4fa54dea5e578f4f29cf9d) +++ src/libcfa/concurrency/kernel (revision f4abc582d3b6b606b643e66534b4f6671f8ecbdf) @@ -79,9 +79,13 @@ // Processor +coroutine processorCtx_t { + struct processor * proc; +}; + // Wrapper around kernel threads struct processor { // Main state // Coroutine ctx who does keeps the state of the processor - struct processorCtx_t * runner; + struct processorCtx_t runner; // Cluster from which to get threads Index: src/libcfa/concurrency/kernel.c =================================================================== --- src/libcfa/concurrency/kernel.c (revision b2e88418a9a140cb8c4fa54dea5e578f4f29cf9d) +++ src/libcfa/concurrency/kernel.c (revision f4abc582d3b6b606b643e66534b4f6671f8ecbdf) @@ -124,4 +124,5 @@ //----------------------------------------------------------------------------- // Processor coroutine +void ?{}(processorCtx_t & this) {} // Construct the processor context of the main processor @@ -130,5 +131,4 @@ this.__cor.starter = NULL; this.proc = proc; - proc->runner = &this; } @@ -137,5 +137,4 @@ (this.__cor){ info }; this.proc = proc; - proc->runner = &this; } @@ -150,4 +149,5 @@ preemption_alarm = NULL; pending_preemption = false; + runner.proc = &this; start( &this ); @@ -161,6 +161,6 @@ pending_preemption = false; kernel_thread = pthread_self(); - - this.runner = &runner; + runner.proc = &this; + __cfaabi_dbg_print_safe("Kernel : constructing main processor context %p\n", &runner); runner{ &this }; @@ -196,4 +196,5 @@ void main(processorCtx_t & runner) { processor * this = runner.proc; + verify(this); __cfaabi_dbg_print_safe("Kernel : core %p starting\n", this); @@ -241,5 +242,5 @@ void runThread(processor * this, thread_desc * dst) { assert(dst->curr_cor); - coroutine_desc * proc_cor = get_coroutine(*this->runner); + coroutine_desc * proc_cor = get_coroutine(this->runner); coroutine_desc * thrd_cor = dst->curr_cor; @@ -256,5 +257,5 @@ void returnToKernel() { - coroutine_desc * proc_cor = get_coroutine(*this_processor->runner); + coroutine_desc * proc_cor = get_coroutine(this_processor->runner); coroutine_desc * thrd_cor = this_thread->curr_cor = this_coroutine; ThreadCtxSwitch(thrd_cor, proc_cor); @@ -317,14 +318,14 @@ machine_context_t ctx; info.context = &ctx; - processorCtx_t proc_cor_storage = { proc, &info }; - - __cfaabi_dbg_print_safe("Coroutine : created stack %p\n", proc_cor_storage.__cor.stack.base); + (proc->runner){ proc, &info }; + + __cfaabi_dbg_print_safe("Coroutine : created stack %p\n", get_coroutine(proc->runner)->stack.base); //Set global state - this_coroutine = &proc->runner->__cor; + this_coroutine = get_coroutine(proc->runner); this_thread = NULL; //We now have a proper context from which to schedule threads - __cfaabi_dbg_print_safe("Kernel : core %p created (%p, %p)\n", proc, proc->runner, &ctx); + __cfaabi_dbg_print_safe("Kernel : core %p created (%p, %p)\n", proc, &proc->runner, &ctx); // SKULLDUGGERY: Since the coroutine doesn't have its own stack, we can't @@ -332,10 +333,10 @@ // back to here. Instead directly call the main since we already are on the // appropriate stack. - proc_cor_storage.__cor.state = Active; - main( proc_cor_storage ); - proc_cor_storage.__cor.state = Halted; + get_coroutine(proc->runner)->state = Active; + main( proc->runner ); + get_coroutine(proc->runner)->state = Halted; // Main routine of the core returned, the core is now fully terminated - __cfaabi_dbg_print_safe("Kernel : core %p main ended (%p)\n", proc, proc->runner); + __cfaabi_dbg_print_safe("Kernel : core %p main ended (%p)\n", proc, &proc->runner); return NULL; @@ -352,10 +353,10 @@ void kernel_first_resume(processor * this) { coroutine_desc * src = this_coroutine; - coroutine_desc * dst = get_coroutine(*this->runner); + coroutine_desc * dst = get_coroutine(this->runner); verify( !preemption_state.enabled ); create_stack(&dst->stack, dst->stack.size); - CtxStart(this->runner, CtxInvokeCoroutine); + CtxStart(&this->runner, CtxInvokeCoroutine); verify( !preemption_state.enabled ); @@ -411,12 +412,4 @@ verify( !preemption_state.enabled ); lock( ready_queue_lock __cfaabi_dbg_ctx2 ); - //TEMP hack to find a bug - if(this_processor != mainProcessor) { - if(ready_queue.head == mainThread) { - unlock( ready_queue_lock ); - return NULL; - } - } - thread_desc * head = pop_head( ready_queue ); unlock( ready_queue_lock ); @@ -584,5 +577,5 @@ // Destroy the main processor and its context in reverse order of construction // These were manually constructed so we need manually destroy them - ^(*mainProcessor->runner){}; + ^(mainProcessor->runner){}; ^(mainProcessor){}; Index: src/libcfa/concurrency/kernel_private.h =================================================================== --- src/libcfa/concurrency/kernel_private.h (revision b2e88418a9a140cb8c4fa54dea5e578f4f29cf9d) +++ src/libcfa/concurrency/kernel_private.h (revision f4abc582d3b6b606b643e66534b4f6671f8ecbdf) @@ -52,8 +52,4 @@ //----------------------------------------------------------------------------- // Processor -coroutine processorCtx_t { - processor * proc; -}; - void main(processorCtx_t *); void start(processor * this); Index: src/tests/.expect/literals.x64.txt =================================================================== --- src/tests/.expect/literals.x64.txt (revision b2e88418a9a140cb8c4fa54dea5e578f4f29cf9d) +++ src/tests/.expect/literals.x64.txt (revision f4abc582d3b6b606b643e66534b4f6671f8ecbdf) @@ -522,4 +522,28 @@ signed int __main__Fi___1(){ __attribute__ ((unused)) signed int ___retval_main__i_1; + ((void)0b01101011); + ((void)0b01101011u); + ((void)0b01101011l); + ((void)0b01101011ll); + ((void)0b01101011ul); + ((void)0b01101011lu); + ((void)0b01101011ull); + ((void)0b01101011llu); + ((void)(+0b01101011)); + ((void)(+0b01101011u)); + ((void)(+0b01101011l)); + ((void)(+0b01101011ll)); + ((void)(+0b01101011ul)); + ((void)(+0b01101011lu)); + ((void)(+0b01101011ull)); + ((void)(+0b01101011llu)); + ((void)(-0b01101011)); + ((void)(-0b01101011u)); + ((void)(-0b01101011l)); + ((void)(-0b01101011ll)); + ((void)(-0b01101011ul)); + ((void)(-0b01101011lu)); + ((void)(-0b01101011ull)); + ((void)(-0b01101011llu)); ((void)01234567); ((void)01234567u); @@ -1017,4 +1041,34 @@ ((void)(-0X0123456789.0123456789P-09F)); ((void)(-0X0123456789.0123456789P-09L)); + ((void)((signed char )0b01101011)); + ((void)((signed short int )0b01101011)); + ((void)((signed int )0b01101011)); + ((void)((signed long int )0b01101011)); + ((void)((__int128 )0b01101011)); + ((void)((unsigned char )0b01101011u)); + ((void)((signed short int )0b01101011u)); + ((void)((unsigned int )0b01101011u)); + ((void)((signed long int )0b01101011u)); + ((void)((__int128 )0b01101011u)); + ((void)(+((signed int )((signed char )0b01101011)))); + ((void)(+((signed int )((signed short int )0b01101011)))); + ((void)(+((signed int )0b01101011))); + ((void)(+((signed long int )0b01101011))); + ((void)(+((float )((__int128 )0b01101011)))); + ((void)(+((signed int )((unsigned char )0b01101011u)))); + ((void)(+((signed int )((signed short int )0b01101011u)))); + ((void)(+((unsigned int )0b01101011u))); + ((void)(+((signed long int )0b01101011u))); + ((void)(+((float )((__int128 )0b01101011u)))); + ((void)(-((signed int )((signed char )0b01101011)))); + ((void)(-((signed int )((signed short int )0b01101011)))); + ((void)(-((signed int )0b01101011))); + ((void)(-((signed long int )0b01101011))); + ((void)(-((float )((__int128 )0b01101011)))); + ((void)(-((signed int )((unsigned char )0b01101011u)))); + ((void)(-((signed int )((signed short int )0b01101011u)))); + ((void)(-((unsigned int )0b01101011u))); + ((void)(-((signed long int )0b01101011u))); + ((void)(-((float )((__int128 )0b01101011u)))); ((void)((signed char )01234567)); ((void)((signed short int )01234567)); Index: src/tests/.expect/literals.x86.txt =================================================================== --- src/tests/.expect/literals.x86.txt (revision b2e88418a9a140cb8c4fa54dea5e578f4f29cf9d) +++ src/tests/.expect/literals.x86.txt (revision f4abc582d3b6b606b643e66534b4f6671f8ecbdf) @@ -522,4 +522,28 @@ signed int __main__Fi___1(){ __attribute__ ((unused)) signed int ___retval_main__i_1; + ((void)0b01101011); + ((void)0b01101011u); + ((void)0b01101011l); + ((void)0b01101011ll); + ((void)0b01101011ul); + ((void)0b01101011lu); + ((void)0b01101011ull); + ((void)0b01101011llu); + ((void)(+0b01101011)); + ((void)(+0b01101011u)); + ((void)(+0b01101011l)); + ((void)(+0b01101011ll)); + ((void)(+0b01101011ul)); + ((void)(+0b01101011lu)); + ((void)(+0b01101011ull)); + ((void)(+0b01101011llu)); + ((void)(-0b01101011)); + ((void)(-0b01101011u)); + ((void)(-0b01101011l)); + ((void)(-0b01101011ll)); + ((void)(-0b01101011ul)); + ((void)(-0b01101011lu)); + ((void)(-0b01101011ull)); + ((void)(-0b01101011llu)); ((void)01234567); ((void)01234567u); @@ -1017,4 +1041,34 @@ ((void)(-0X0123456789.0123456789P-09F)); ((void)(-0X0123456789.0123456789P-09L)); + ((void)((signed char )0b01101011)); + ((void)((signed short int )0b01101011)); + ((void)((signed int )0b01101011)); + ((void)((signed long long int )0b01101011)); + ((void)((__int128 )0b01101011)); + ((void)((unsigned char )0b01101011u)); + ((void)((signed short int )0b01101011u)); + ((void)((unsigned int )0b01101011u)); + ((void)((signed long long int )0b01101011u)); + ((void)((__int128 )0b01101011u)); + ((void)(+((signed int )((signed char )0b01101011)))); + ((void)(+((signed int )((signed short int )0b01101011)))); + ((void)(+((signed int )0b01101011))); + ((void)(+((signed long long int )0b01101011))); + ((void)(+((float )((__int128 )0b01101011)))); + ((void)(+((signed int )((unsigned char )0b01101011u)))); + ((void)(+((signed int )((signed short int )0b01101011u)))); + ((void)(+((unsigned int )0b01101011u))); + ((void)(+((signed long long int )0b01101011u))); + ((void)(+((float )((__int128 )0b01101011u)))); + ((void)(-((signed int )((signed char )0b01101011)))); + ((void)(-((signed int )((signed short int )0b01101011)))); + ((void)(-((signed int )0b01101011))); + ((void)(-((signed long long int )0b01101011))); + ((void)(-((float )((__int128 )0b01101011)))); + ((void)(-((signed int )((unsigned char )0b01101011u)))); + ((void)(-((signed int )((signed short int )0b01101011u)))); + ((void)(-((unsigned int )0b01101011u))); + ((void)(-((signed long long int )0b01101011u))); + ((void)(-((float )((__int128 )0b01101011u)))); ((void)((signed char )01234567)); ((void)((signed short int )01234567)); Index: src/tests/.expect/user_literals.txt =================================================================== --- src/tests/.expect/user_literals.txt (revision b2e88418a9a140cb8c4fa54dea5e578f4f29cf9d) +++ src/tests/.expect/user_literals.txt (revision f4abc582d3b6b606b643e66534b4f6671f8ecbdf) @@ -1,8 +1,9 @@ 11.0714285714286 -11.07225 +15 11.0714285714286 +24.8 +11.248 11.0714285714286 -11.0714285714286 -22.0457142857143 +28.0657142857143 secs 1 secs 23 Index: src/tests/Makefile.am =================================================================== --- src/tests/Makefile.am (revision b2e88418a9a140cb8c4fa54dea5e578f4f29cf9d) +++ src/tests/Makefile.am (revision f4abc582d3b6b606b643e66534b4f6671f8ecbdf) @@ -123,5 +123,5 @@ ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@} +# Warnings warnings/self-assignment: warnings/self-assignment.c @CFA_BINDIR@/@CFA_NAME@ - ${CC} ${AM_CFLAGS} ${CFLAGS} ${<} -o ${@} - echo > ${@} + ${CC} ${AM_CFLAGS} ${CFLAGS} ${<} 2> ${@} -fsyntax-only Index: src/tests/Makefile.in =================================================================== --- src/tests/Makefile.in (revision b2e88418a9a140cb8c4fa54dea5e578f4f29cf9d) +++ src/tests/Makefile.in (revision f4abc582d3b6b606b643e66534b4f6671f8ecbdf) @@ -800,7 +800,7 @@ ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@} +# Warnings warnings/self-assignment: warnings/self-assignment.c @CFA_BINDIR@/@CFA_NAME@ - ${CC} ${AM_CFLAGS} ${CFLAGS} ${<} -o ${@} - echo > ${@} + ${CC} ${AM_CFLAGS} ${CFLAGS} ${<} 2> ${@} -fsyntax-only # Tell versions [3.59,3.63) of GNU make to not export all variables. Index: src/tests/literals.c =================================================================== --- src/tests/literals.c (revision b2e88418a9a140cb8c4fa54dea5e578f4f29cf9d) +++ src/tests/literals.c (revision f4abc582d3b6b606b643e66534b4f6671f8ecbdf) @@ -10,6 +10,6 @@ // Created On : Sat Sep 9 16:34:38 2017 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon Sep 25 20:26:00 2017 -// Update Count : 132 +// Last Modified On : Sun Mar 4 10:41:31 2018 +// Update Count : 134 // @@ -31,4 +31,9 @@ // integer literals + // binary + 0b01101011; 0b01101011u; 0b01101011l; 0b01101011ll; 0b01101011ul; 0b01101011lu; 0b01101011ull; 0b01101011llu; + +0b01101011; +0b01101011u; +0b01101011l; +0b01101011ll; +0b01101011ul; +0b01101011lu; +0b01101011ull; +0b01101011llu; + -0b01101011; -0b01101011u; -0b01101011l; -0b01101011ll; -0b01101011ul; -0b01101011lu; -0b01101011ull; -0b01101011llu; + // octal 01234567; 01234567u; 01234567l; 01234567ll; 01234567ul; 01234567lu; 01234567ull; 01234567llu; @@ -148,4 +153,9 @@ #ifdef __CFA__ // fixed-size length + + // binary + 0b01101011_l8; 0b01101011_l16; 0b01101011_l32; 0b01101011_l64; 0b01101011_l128; 0b01101011_l8u; 0b01101011_ul16; 0b01101011_l32u; 0b01101011_ul64; 0b01101011_ul128; + +0b01101011_l8; +0b01101011_l16; +0b01101011_l32; +0b01101011_l64; +0b01101011_l128; +0b01101011_l8u; +0b01101011_ul16; +0b01101011_l32u; +0b01101011_ul64; +0b01101011_ul128; + -0b01101011_l8; -0b01101011_l16; -0b01101011_l32; -0b01101011_l64; -0b01101011_l128; -0b01101011_l8u; -0b01101011_ul16; -0b01101011_l32u; -0b01101011_ul64; -0b01101011_ul128; // octal Index: src/tests/user_literals.c =================================================================== --- src/tests/user_literals.c (revision b2e88418a9a140cb8c4fa54dea5e578f4f29cf9d) +++ src/tests/user_literals.c (revision f4abc582d3b6b606b643e66534b4f6671f8ecbdf) @@ -10,6 +10,6 @@ // Created On : Wed Sep 6 21:40:50 2017 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Dec 7 09:12:36 2017 -// Update Count : 50 +// Last Modified On : Sun Mar 4 11:14:02 2018 +// Update Count : 52 // @@ -31,30 +31,31 @@ -struct Weight { - double stones; -}; -void ?{}( Weight & w ) { w.stones = 0; } // operations +struct Weight { double stones; }; +void ?{}( Weight & w ) { w.stones = 0; } void ?{}( Weight & w, double w ) { w.stones = w; } -Weight ?+?( Weight l, Weight r ) { return (Weight){ l.stones + r.stones }; } +Weight ?+?( Weight l, Weight r ) { + return (Weight){ l.stones + r.stones }; +} ofstream & ?|?( ofstream & os, Weight w ) { return os | w.stones; } Weight ?`st( double w ) { return (Weight){ w }; } // backquote for user literals Weight ?`lb( double w ) { return (Weight){ w / 14.0 }; } -Weight ?`kg( double w ) { return (Weight) { w * 0.1575}; } - +Weight ?`kg( double w ) { return (Weight) { w * 0.16 }; } int main() { - Weight w, hw = { 14 }; // 14 stone - w = 11`st + 1`lb; + Weight w, heavy = { 20 }; // 20 stone + w = 155`lb; + sout | w | endl; + w = 0b_1111`st; + sout | w | endl; + w = 0_233`lb; // octal weight (155) + sout | w | endl; + w = 0x_9b_u`kg; sout | w | endl; w = 70.3`kg; sout | w | endl; - w = 155`lb; + w = 11`st + 1`lb; sout | w | endl; - w = 0x_9b_u`lb; // hexadecimal unsigned weight (155) - sout | w | endl; - w = 0_233`lb; // octal weight (155) - sout | w | endl; - w = 5`st + 8`kg + 25`lb + hw; + w = 5`st + 8`kg + 25`lb + heavy; sout | w | endl; Index: src/tests/warnings/.expect/self-assignment.txt =================================================================== --- src/tests/warnings/.expect/self-assignment.txt (revision b2e88418a9a140cb8c4fa54dea5e578f4f29cf9d) +++ src/tests/warnings/.expect/self-assignment.txt (revision f4abc582d3b6b606b643e66534b4f6671f8ecbdf) @@ -0,0 +1,25 @@ +warnings/self-assignment.c:29:1 warning: self assignment of expression: Cast of: + Variable Expression: j: signed int +... to: + reference to signed int +warnings/self-assignment.c:30:1 warning: self assignment of expression: Cast of: + Variable Expression: s: instance of struct S with body 1 +... to: + reference to instance of struct S with body 1 +warnings/self-assignment.c:31:1 warning: self assignment of expression: Cast of: + Member Expression, with field: + i: signed int + ... from aggregate: + Variable Expression: s: instance of struct S with body 1 +... to: + reference to signed int +warnings/self-assignment.c:32:1 warning: self assignment of expression: Cast of: + Member Expression, with field: + i: signed int + ... from aggregate: + Member Expression, with field: + s: instance of struct S with body 1 + ... from aggregate: + Variable Expression: t: instance of struct T with body 1 +... to: + reference to signed int