Index: doc/proposals/concurrency/Makefile =================================================================== --- doc/proposals/concurrency/Makefile (revision 206de5ab2b76ee44636062f62bc9a1ff10a14888) +++ doc/proposals/concurrency/Makefile (revision e2b17a4439069fc5076a980015bdd7f368faf252) @@ -17,4 +17,6 @@ text/concurrency \ text/parallelism \ +text/together \ +text/future \ } Index: doc/proposals/concurrency/annex/glossary.tex =================================================================== --- doc/proposals/concurrency/annex/glossary.tex (revision 206de5ab2b76ee44636062f62bc9a1ff10a14888) +++ doc/proposals/concurrency/annex/glossary.tex (revision e2b17a4439069fc5076a980015bdd7f368faf252) @@ -101,2 +101,3 @@ \newacronym{api}{API}{Application Program Interface} \newacronym{raii}{RAII}{Ressource Acquisition Is Initialization} +\newacronym{numa}{NUMA}{Non-Uniform Memory Access} Index: doc/proposals/concurrency/text/cforall.tex =================================================================== --- doc/proposals/concurrency/text/cforall.tex (revision 206de5ab2b76ee44636062f62bc9a1ff10a14888) +++ doc/proposals/concurrency/text/cforall.tex (revision e2b17a4439069fc5076a980015bdd7f368faf252) @@ -15,17 +15,17 @@ int x, *p1 = &x, **p2 = &p1, ***p3 = &p2, &r1 = x, &&r2 = r1, &&&r3 = r2; -***p3 = 3; // change x -r3 = 3; // change x, ***r3 -**p3 = ...; // change p1 -&r3 = ...; // change r1, (&*)**r3 -*p3 = ...; // change p2 -&&r3 = ...; // change r2, (&(&*)*)*r3 -&&&r3 = p3; // change r3 to p3, (&(&(&*)*)*)r3 -int y, z, & ar[3] = { x, y, z }; // initialize array of references -&ar[1] = &z; // change reference array element -typeof( ar[1] ) p; // is int, i.e., the type of referenced object -typeof( &ar[1] ) q; // is int &, i.e., the type of reference -sizeof( ar[1] ) == sizeof( int ); // is true, i.e., the size of referenced object -sizeof( &ar[1] ) == sizeof( int *); // is true, i.e., the size of a reference +***p3 = 3; // change x +r3 = 3; // change x, ***r3 +**p3 = ...; // change p1 +&r3 = ...; // change r1, (&*)**r3 +*p3 = ...; // change p2 +&&r3 = ...; // change r2, (&(&*)*)*r3 +&&&r3 = p3; // change r3 to p3, (&(&(&*)*)*)r3 +int y, z, & ar[3] = { x, y, z }; // initialize array of references +&ar[1] = &z; // change reference array element +typeof( ar[1] ) p; // is int, i.e., the type of referenced object +typeof( &ar[1] ) q; // is int &, i.e., the type of reference +sizeof( ar[1] ) == sizeof( int ); // is true, i.e., the size of referenced object +sizeof( &ar[1] ) == sizeof( int *); // is true, i.e., the size of a reference \end{cfacode} The important thing to take away from this code snippet is that references offer a handle to an object much like pointers but which is automatically derefferenced when convinient. @@ -36,18 +36,18 @@ \begin{cfacode} // selection based on type and number of parameters -void f( void ); // (1) -void f( char ); // (2) -void f( int, double ); // (3) -f(); // select (1) -f( 'a' ); // select (2) -f( 3, 5.2 ); // select (3) +void f( void ); // (1) +void f( char ); // (2) +void f( int, double ); // (3) +f(); // select (1) +f( 'a' ); // select (2) +f( 3, 5.2 ); // select (3) // selection based on type and number of returns -char f( int ); // (1) -double f( int ); // (2) -[ int, double ] f( int ); // (3) -char c = f( 3 ); // select (1) -double d = f( 4 ); // select (2) -[ int, double ] t = f( 5 ); // select (3) +char f( int ); // (1) +double f( int ); // (2) +[ int, double ] f( int ); // (3) +char c = f( 3 ); // select (1) +double d = f( 4 ); // select (2) +[ int, double ] t = f( 5 ); // select (3) \end{cfacode} This feature is particularly important for concurrency since the runtime system relies on creating different types do represent concurrency objects. Therefore, overloading is necessary to prevent the need for long prefixes and other naming conventions that prevent clashes. As seen in chapter \ref{basics}, the main is an example of routine that benefits from overloading when concurrency in introduced. @@ -56,17 +56,17 @@ Overloading also extends to operators. The syntax for denoting operator-overloading is to name a routine with the symbol of the operator and question marks where the arguments of the operation would be, like so : \begin{cfacode} -int ++?( int op ); // unary prefix increment -int ?++( int op ); // unary postfix increment -int ?+?( int op1, int op2 ); // binary plus -int ?<=?( int op1, int op2 ); // binary less than -int ?=?( int & op1, int op2 ); // binary assignment -int ?+=?( int & op1, int op2 ); // binary plus-assignment +int ++?( int op ); // unary prefix increment +int ?++( int op ); // unary postfix increment +int ?+?( int op1, int op2 ); // binary plus +int ?<=?( int op1, int op2 ); // binary less than +int ?=?( int & op1, int op2 ); // binary assignment +int ?+=?( int & op1, int op2 ); // binary plus-assignment struct S { int i, j; }; -S ?+?( S op1, S op2 ) { // add two structures +S ?+?( S op1, S op2 ) { // add two structures return (S){ op1.i + op2.i, op1.j + op2.j }; } S s1 = { 1, 2 }, s2 = { 2, 3 }, s3; -s3 = s1 + s2; // compute sum: s3 == { 2, 5 } +s3 = s1 + s2; // compute sum: s3 == { 2, 5 } \end{cfacode} @@ -74,5 +74,5 @@ \section{Constructors/Destructors} -\CFA uses the following syntax for constructors and destructors : +Object life time is often a challenge in concurrency. \CFA uses the approach of giving concurrent meaning to object life time as a mean of synchronization and/or mutual exclusion. Since \CFA relies heavily on the life time of objects, Constructors \& Destructors are a the core of the features required for concurrency and parallelism. \CFA uses the following syntax for constructors and destructors : \begin{cfacode} struct S { @@ -80,18 +80,18 @@ int * ia; }; -void ?{}( S & s, int asize ) with s { // constructor operator - size = asize; // initialize fields +void ?{}( S & s, int asize ) with s { // constructor operator + size = asize; // initialize fields ia = calloc( size, sizeof( S ) ); } -void ^?{}( S & s ) with s { // destructor operator - free( ia ); // de-initialization fields +void ^?{}( S & s ) with s { // destructor operator + free( ia ); // de-initialization fields } int main() { - S x = { 10 }, y = { 100 }; // implict calls: ?{}( x, 10 ), ?{}( y, 100 ) - ... // use x and y - ^x{}; ^y{}; // explicit calls to de-initialize - x{ 20 }; y{ 200 }; // explicit calls to reinitialize - ... // reuse x and y -} // implict calls: ^?{}( y ), ^?{}( x ) + S x = { 10 }, y = { 100 }; // implict calls: ?{}( x, 10 ), ?{}( y, 100 ) + ... // use x and y + ^x{}; ^y{}; // explicit calls to de-initialize + x{ 20 }; y{ 200 }; // explicit calls to reinitialize + ... // reuse x and y +} // implict calls: ^?{}( y ), ^?{}( x ) \end{cfacode} The language guarantees that every object and all their fields are constructed. Like \CC construction is automatically done on declaration and destruction done when the declared variables reach the end of its scope. Index: doc/proposals/concurrency/text/concurrency.tex =================================================================== --- doc/proposals/concurrency/text/concurrency.tex (revision 206de5ab2b76ee44636062f62bc9a1ff10a14888) +++ doc/proposals/concurrency/text/concurrency.tex (revision e2b17a4439069fc5076a980015bdd7f368faf252) @@ -69,5 +69,5 @@ int f5(graph(monitor*) & mutex m); \end{cfacode} -The problem is to indentify which object(s) should be acquired. Furthermore, each object needs to be acquired only once. In the case of simple routines like \code{f1} and \code{f2} it is easy to identify an exhaustive list of objects to acquire on entry. Adding indirections (\code{f3}) still allows the compiler and programmer to indentify which object is acquired. However, adding in arrays (\code{f4}) makes it much harder. Array lengths are not necessarily known in C, and even then making sure objects are only acquired once becomes none-trivial. This can be extended to absurd limits like \code{f5}, which uses a graph of monitors. To keep everyone as sane as possible~\cite{Chicken}, this projects imposes the requirement that a routine may only acquire one monitor per parameter and it must be the type of the parameter with one level of indirection (ignoring potential qualifiers). Also note that while routine \code{f3} can be supported, meaning that monitor \code{**m} is be acquired, passing an array to this routine would be type safe and yet result in undefined behavior because only the first element of the array is acquired. This is specially true for non-copyable objects like monitors, where an array of pointers is simplest way to express a group of monitors. However, this ambiguity is part of the C type-system with respects to arrays. For this reason, \code{mutex} is disallowed in the context where arrays may be passed: +The problem is to indentify which object(s) should be acquired. Furthermore, each object needs to be acquired only once. In the case of simple routines like \code{f1} and \code{f2} it is easy to identify an exhaustive list of objects to acquire on entry. Adding indirections (\code{f3}) still allows the compiler and programmer to indentify which object is acquired. However, adding in arrays (\code{f4}) makes it much harder. Array lengths are not necessarily known in C, and even then making sure objects are only acquired once becomes none-trivial. This can be extended to absurd limits like \code{f5}, which uses a graph of monitors. To make the issue tractable, this projects imposes the requirement that a routine may only acquire one monitor per parameter and it must be the type of the parameter with one level of indirection (ignoring potential qualifiers). Also note that while routine \code{f3} can be supported, meaning that monitor \code{**m} is be acquired, passing an array to this routine would be type safe and yet result in undefined behavior because only the first element of the array is acquired. This is specially true for non-copyable objects like monitors, where an array of pointers is simplest way to express a group of monitors. However, this ambiguity is part of the C type-system with respects to arrays. For this reason, \code{mutex} is disallowed in the context where arrays may be passed: \begin{cfacode} @@ -608,5 +608,5 @@ % ====================================================================== % ====================================================================== -There are several challenges specific to \CFA when implementing internal scheduling. These challenges are direct results of \gls{group-acquire} and loose object definitions. These two constraints are to root cause of most design decisions in the implementation of internal scheduling. Furthermore, to avoid the head-aches of dynamically allocating memory in a concurrent environment, the internal-scheduling design is entirely free of mallocs and other dynamic memory allocation scheme. This is to avoid the chicken and egg problem of having a memory allocator that relies on the threading system and a threading system that relies on the runtime. This extra goal, means that memory management is a constant concern in the design of the system. +There are several challenges specific to \CFA when implementing internal scheduling. These challenges are direct results of \gls{group-acquire} and loose object definitions. These two constraints are to root cause of most design decisions in the implementation of internal scheduling. Furthermore, to avoid the head-aches of dynamically allocating memory in a concurrent environment, the internal-scheduling design is entirely free of mallocs and other dynamic memory allocation scheme. This is to avoid the chicken and egg problem \cite{Chicken} of having a memory allocator that relies on the threading system and a threading system that relies on the runtime. This extra goal, means that memory management is a constant concern in the design of the system. The main memory concern for concurrency is queues. All blocking operations are made by parking threads onto queues. These queues need to be intrinsic\cit to avoid the need memory allocation. This entails that all the fields needed to keep track of all needed information. Since internal scheduling can use an unbound amount of memory (depending on \gls{group-acquire}) statically defining information information in the intrusive fields of threads is insufficient. The only variable sized container that does not require memory allocation is the callstack, which is heavily used in the implementation of internal scheduling. Particularly the GCC extension variable length arrays which is used extensively. @@ -832,8 +832,5 @@ To support multi-monitor external scheduling means that some kind of entry-queues must be used that is aware of both monitors. However, acceptable routines must be aware of the entry queues which means they must be stored inside at least one of the monitors that will be acquired. This in turn adds the requirement a systematic algorithm of disambiguating which queue is relavant regardless of user ordering. The proposed algorithm is to fall back on monitors lock ordering and specify that the monitor that is acquired first is the lock with the relevant entry queue. This assumes that the lock acquiring order is static for the lifetime of all concerned objects but that is a reasonable constraint. This algorithm choice has two consequences, the entry queue of the highest priority monitor is no longer a true FIFO queue and the queue of the lowest priority monitor is both required and probably unused. The queue can no longer be a FIFO queue because instead of simply containing the waiting threads in order arrival, they also contain the second mutex. Therefore, another thread with the same highest priority monitor but a different lowest priority monitor may arrive first but enter the critical section after a thread with the correct pairing. Secondly, since it may not be known at compile time which monitor will be the lowest priority monitor, every monitor needs to have the correct queues even though it is probable that half the multi-monitor queues will go unused for the entire duration of the program. -% ====================================================================== -% ====================================================================== -\section{Other concurrency tools} -% ====================================================================== -% ====================================================================== -% \TODO + +\subsection{Internals} +The complete mask can be pushed to any one, we are in a context where we already have full ownership of (at least) every concerned monitor and therefore monitors will refuse all calls no matter what. Index: doc/proposals/concurrency/text/future.tex =================================================================== --- doc/proposals/concurrency/text/future.tex (revision e2b17a4439069fc5076a980015bdd7f368faf252) +++ doc/proposals/concurrency/text/future.tex (revision e2b17a4439069fc5076a980015bdd7f368faf252) @@ -0,0 +1,86 @@ +% ====================================================================== +% ====================================================================== +\chapter{Future Work} +% ====================================================================== +% ====================================================================== + +Concurrency and parallelism is still a very active field that strongly benefits from hardware advances. As such certain features that aren't necessarily mature enough in their current state could become relevant in the lifetime of \CFA. +\section{Non-Blocking IO} + + +\section{Other concurrency tools} + + +\section{Implicit threading} +% Finally, simpler applications can benefit greatly from having implicit parallelism. That is, parallelism that does not rely on the user to write concurrency. This type of parallelism can be achieved both at the language level and at the system level. +% +% \begin{center} +% \begin{tabular}[t]{|c|c|c|} +% Sequential & System Parallel & Language Parallel \\ +% \begin{lstlisting} +% void big_sum(int* a, int* b, +% int* out, +% size_t length) +% { +% for(int i = 0; i < length; ++i ) { +% out[i] = a[i] + b[i]; +% } +% } +% +% +% +% +% +% int* a[10000]; +% int* b[10000]; +% int* c[10000]; +% //... fill in a and b ... +% big_sum(a, b, c, 10000); +% \end{lstlisting} &\begin{lstlisting} +% void big_sum(int* a, int* b, +% int* out, +% size_t length) +% { +% range ar(a, a + length); +% range br(b, b + length); +% range or(out, out + length); +% parfor( ai, bi, oi, +% [](int* ai, int* bi, int* oi) { +% oi = ai + bi; +% }); +% } +% +% int* a[10000]; +% int* b[10000]; +% int* c[10000]; +% //... fill in a and b ... +% big_sum(a, b, c, 10000); +% \end{lstlisting}&\begin{lstlisting} +% void big_sum(int* a, int* b, +% int* out, +% size_t length) +% { +% for (ai, bi, oi) in (a, b, out) { +% oi = ai + bi; +% } +% } +% +% +% +% +% +% int* a[10000]; +% int* b[10000]; +% int* c[10000]; +% //... fill in a and b ... +% big_sum(a, b, c, 10000); +% \end{lstlisting} +% \end{tabular} +% \end{center} +% + + +\section{Multiple Paradigms} + + +\section{Transactions} Index: doc/proposals/concurrency/text/intro.tex =================================================================== --- doc/proposals/concurrency/text/intro.tex (revision 206de5ab2b76ee44636062f62bc9a1ff10a14888) +++ doc/proposals/concurrency/text/intro.tex (revision e2b17a4439069fc5076a980015bdd7f368faf252) @@ -3,5 +3,5 @@ % ====================================================================== -This proposal provides a minimal concurrency API that is simple, efficient and can be reused to build higher-level features. The simplest possible concurrency system is a thread and a lock but this low-level approach is hard to master. An easier approach for users is to support higher-level constructs as the basis of the concurrency, in \CFA. Indeed, for highly productive parallel programming, high-level approaches are much more popular~\cite{HPP:Study}. Examples are task based, message passing and implicit threading. Therefore a high-level approach is adapted in \CFA +This proposal provides a minimal concurrency API that is simple, efficient and can be reused to build higher-level features. The simplest possible concurrency system is a thread and a lock but this low-level approach is hard to master. An easier approach for users is to support higher-level constructs as the basis of the concurrency, in \CFA. Indeed, for highly productive concurrent programming, high-level approaches are much more popular~\cite{HPP:Study}. Examples are task based, message passing and implicit threading. Therefore a high-level approach is adopted in \CFA -There are actually two problems that need to be solved in the design of concurrency for a programming language: which concurrency and which parallelism tools are available to the users. While these two concepts are often combined, they are in fact distinct concepts that require different tools~\cite{Buhr05a}. Concurrency tools need to handle mutual exclusion and synchronization, while parallelism tools are about performance, cost and resource utilization. +There are actually two problems that need to be solved in the design of concurrency for a programming language: which concurrency and which parallelism tools are available to the programmers. While these two concepts are often combined, they are in fact distinct, requiring different tools~\cite{Buhr05a}. Concurrency tools need to handle mutual exclusion and synchronization, while parallelism tools are about performance, cost and resource utilization. Index: doc/proposals/concurrency/text/parallelism.tex =================================================================== --- doc/proposals/concurrency/text/parallelism.tex (revision 206de5ab2b76ee44636062f62bc9a1ff10a14888) +++ doc/proposals/concurrency/text/parallelism.tex (revision e2b17a4439069fc5076a980015bdd7f368faf252) @@ -11,107 +11,29 @@ \section{Paradigm} \subsection{User-level threads} -A direct improvement on the \gls{kthread} approach is to use \glspl{uthread}. These threads offer most of the same features that the operating system already provide but can be used on a much larger scale. This approach is the most powerfull solution as it allows all the features of multi-threading, while removing several of the more expensives costs of using kernel threads. The down side is that almost none of the low-level threading problems are hidden, users still have to think about data races, deadlocks and synchronization issues. These issues can be somewhat alleviated by a concurrency toolkit with strong garantees but the parallelism toolkit offers very little to reduce complexity in itself. +A direct improvement on the \gls{kthread} approach is to use \glspl{uthread}. These threads offer most of the same features that the operating system already provide but can be used on a much larger scale. This approach is the most powerfull solution as it allows all the features of multi-threading, while removing several of the more expensive costs of kernel threads. The down side is that almost none of the low-level threading problems are hidden; users still have to think about data races, deadlocks and synchronization issues. These issues can be somewhat alleviated by a concurrency toolkit with strong garantees but the parallelism toolkit offers very little to reduce complexity in itself. Examples of languages that support \glspl{uthread} are Erlang~\cite{Erlang} and \uC~\cite{uC++book}. \subsection{Fibers : user-level threads without preemption} -A popular varient of \glspl{uthread} is what is often reffered to as \glspl{fiber}. However, \glspl{fiber} do not present meaningful semantical differences with \glspl{uthread}. Advocates of \glspl{fiber} list their high performance and ease of implementation as majors strenghts of \glspl{fiber} but the performance difference between \glspl{uthread} and \glspl{fiber} is controversial and the ease of implementation, while true, is a weak argument in the context of language design. Therefore this proposal largely ignore fibers. +A popular varient of \glspl{uthread} is what is often refered to as \glspl{fiber}. However, \glspl{fiber} do not present meaningful semantical differences with \glspl{uthread}. Advocates of \glspl{fiber} list their high performance and ease of implementation as majors strenghts of \glspl{fiber} but the performance difference between \glspl{uthread} and \glspl{fiber} is controversial, and the ease of implementation, while true, is a weak argument in the context of language design. Therefore this proposal largely ignore fibers. An example of a language that uses fibers is Go~\cite{Go} \subsection{Jobs and thread pools} -The approach on the opposite end of the spectrum is to base parallelism on \glspl{pool}. Indeed, \glspl{pool} offer limited flexibility but at the benefit of a simpler user interface. In \gls{pool} based systems, users express parallelism as units of work and a dependency graph (either explicit or implicit) that tie them together. This approach means users need not worry about concurrency but significantly limits the interaction that can occur among jobs. Indeed, any \gls{job} that blocks also blocks the underlying worker, which effectively means the CPU utilization, and therefore throughput, suffers noticeably. It can be argued that a solution to this problem is to use more workers than available cores. However, unless the number of jobs and the number of workers are comparable, having a significant amount of blocked jobs always results in idles cores. +The approach on the opposite end of the spectrum is to base parallelism on \glspl{pool}. Indeed, \glspl{pool} offer limited flexibility but at the benefit of a simpler user interface. In \gls{pool} based systems, users express parallelism as units of work, called jobs, and a dependency graph (either explicit or implicit) that tie them together. This approach means users need not worry about concurrency but significantly limits the interaction that can occur among jobs. Indeed, any \gls{job} that blocks also blocks the underlying worker, which effectively means the CPU utilization, and therefore throughput, suffers noticeably. It can be argued that a solution to this problem is to use more workers than available cores. However, unless the number of jobs and the number of workers are comparable, having a significant amount of blocked jobs always results in idles cores. The gold standard of this implementation is Intel's TBB library~\cite{TBB}. \subsection{Paradigm performance} -While the choice between the three paradigms listed above may have significant performance implication, it is difficult to pindown the performance implications of chosing a model at the language level. Indeed, in many situations one of these paradigms may show better performance but it all strongly depends on the workload. Having a large amount of mostly independent units of work to execute almost guarantess that the \gls{pool} based system has the best performance thanks to the lower memory overhead. However, interactions between jobs can easily exacerbate contention. User-level threads allow fine-grain context switching, which results in better resource utilisation, but context switches will be more expansive and the extra control means users need to tweak more variables to get the desired performance. Furthermore, if the units of uninterrupted work are large enough the paradigm choice is largely amorticised by the actual work done. +While the choice between the three paradigms listed above may have significant performance implication, it is difficult to pindown the performance implications of chosing a model at the language level. Indeed, in many situations one of these paradigms may show better performance but it all strongly depends on the workload. Having a large amount of mostly independent units of work to execute almost guarantess that the \gls{pool} based system has the best performance thanks to the lower memory overhead (i.e., not thread stack per job). However, interactions among jobs can easily exacerbate contention. User-level threads allow fine-grain context switching, which results in better resource utilisation, but context switches is more expansive and the extra control means users need to tweak more variables to get the desired performance. Finally, if the units of uninterrupted work are large enough the paradigm choice is largely amortised by the actual work done. -\newpage \TODO -\subsection{The \protect\CFA\ Kernel : Processors, Clusters and Threads}\label{kernel} + +\section{The \protect\CFA\ Kernel : Processors, Clusters and Threads}\label{kernel} +\subsubsection{Future Work: Machine setup}\label{machine} +While this was not done in the context of this proposal, another important aspect of clusters is affinity. While many common desktop and laptop PCs have homogeneous CPUs, other devices often have more heteregenous setups. For example, system using \acrshort{numa} configurations may benefit from users being able to tie clusters and/or kernel threads to certains CPU cores. OS support for CPU affinity is now common \cit, which means it is both possible and desirable for \CFA to offer an abstraction mechanism for portable CPU affinity. + \subsection{Paradigms}\label{cfaparadigms} -Given these building blocks we can then reproduce the all three of the popular paradigms. Indeed, we get \glspl{uthread} as the default paradigm in \CFA. However, disabling \glspl{preemption} on the \gls{cfacluster} means \glspl{cfathread} effectively become \glspl{fiber}. Since several \glspl{cfacluster} with different scheduling policy can coexist in the same application, this allows \glspl{fiber} and \glspl{uthread} to coexist in the runtime of an application. - -% \subsection{High-level options}\label{tasks} -% -% \subsubsection{Thread interface} -% constructors destructors -% initializer lists -% monitors -% -% \subsubsection{Futures} -% -% \subsubsection{Implicit threading} -% Finally, simpler applications can benefit greatly from having implicit parallelism. That is, parallelism that does not rely on the user to write concurrency. This type of parallelism can be achieved both at the language level and at the system level. -% -% \begin{center} -% \begin{tabular}[t]{|c|c|c|} -% Sequential & System Parallel & Language Parallel \\ -% \begin{lstlisting} -% void big_sum(int* a, int* b, -% int* out, -% size_t length) -% { -% for(int i = 0; i < length; ++i ) { -% out[i] = a[i] + b[i]; -% } -% } -% -% -% -% -% -% int* a[10000]; -% int* b[10000]; -% int* c[10000]; -% //... fill in a and b ... -% big_sum(a, b, c, 10000); -% \end{lstlisting} &\begin{lstlisting} -% void big_sum(int* a, int* b, -% int* out, -% size_t length) -% { -% range ar(a, a + length); -% range br(b, b + length); -% range or(out, out + length); -% parfor( ai, bi, oi, -% [](int* ai, int* bi, int* oi) { -% oi = ai + bi; -% }); -% } -% -% int* a[10000]; -% int* b[10000]; -% int* c[10000]; -% //... fill in a and b ... -% big_sum(a, b, c, 10000); -% \end{lstlisting}&\begin{lstlisting} -% void big_sum(int* a, int* b, -% int* out, -% size_t length) -% { -% for (ai, bi, oi) in (a, b, out) { -% oi = ai + bi; -% } -% } -% -% -% -% -% -% int* a[10000]; -% int* b[10000]; -% int* c[10000]; -% //... fill in a and b ... -% big_sum(a, b, c, 10000); -% \end{lstlisting} -% \end{tabular} -% \end{center} -% -% \subsection{Machine setup}\label{machine} -% Threads are all good and well but wee still some OS support to fully utilize available hardware. -% -% \textbf{\large{Work in progress...}} Do wee need something beyond specifying the number of kernel threads? +Given these building blocks, it is possible to reproduce all three of the popular paradigms. Indeed, \glspl{uthread} is the default paradigm in \CFA. However, disabling \glspl{preemption} on the \gls{cfacluster} means \glspl{cfathread} effectively become \glspl{fiber}. Since several \glspl{cfacluster} with different scheduling policy can coexist in the same application, this allows \glspl{fiber} and \glspl{uthread} to coexist in the runtime of an application. Finally, it is possible to build executors for thread pools from \glspl{uthread} or \glspl{fiber}. Index: doc/proposals/concurrency/text/together.tex =================================================================== --- doc/proposals/concurrency/text/together.tex (revision e2b17a4439069fc5076a980015bdd7f368faf252) +++ doc/proposals/concurrency/text/together.tex (revision e2b17a4439069fc5076a980015bdd7f368faf252) @@ -0,0 +1,76 @@ +% ====================================================================== +% ====================================================================== +\chapter{Putting it all together} +% ====================================================================== +% ====================================================================== + + +\section{Threads as monitors} +As it was sbtely alluded in section \ref{threads}, \code{threads} in \CFA are in factor monitors. This means that all the monitors features are available when using threads. For example, here is a very simple two thread pipeline that could be used for a simulator of a game engine : +\begin{cfacode} +// Visualization declaration +thread Renderer {} renderer; +Frame * simulate( Simulator & this ); + +// Simulation declaration +thread Simulator{} simulator; +void render( Renderer & this ); + +// Blocking call used as communication +void draw( Renderer & mutex this, Frame * frame ); + +// Simualation loop +void main( Simulator & this ) { + while( true ) { + Frame * frame = simulate( this ); + draw( renderer, frame ); + } +} + +// Rendering loop +void main( Renderer & this ) { + while( true ) { + waitfor( draw, this ); + render( this ); + } +} +\end{cfacode} +One of the obvious complaints of the previous code snippet (other than its toy-like simplicity) is that it does not handle exit conditions and just goes on for ever. Luckily, the monitor semantics can also be used to clearly enforce a shutdown order in a concise manner : +\begin{cfacode} +// Visualization declaration +thread Renderer {} renderer; +Frame * simulate( Simulator & this ); + +// Simulation declaration +thread Simulator{} simulator; +void render( Renderer & this ); + +// Blocking call used as communication +void draw( Renderer & mutex this, Frame * frame ); + +// Simualation loop +void main( Simulator & this ) { + while( true ) { + Frame * frame = simulate( this ); + draw( renderer, frame ); + + // Exit main loop after the last frame + if( frame->is_last ) break; + } +} + +// Rendering loop +void main( Renderer & this ) { + while( true ) { + waitfor( draw, this ); + or waitfor( ^?{}, this ) { + // Add an exit condition + break; + } + + render( this ); + } +} +\end{cfacode} + +\section{Fibers \& Threads} Index: doc/proposals/concurrency/thesis.tex =================================================================== --- doc/proposals/concurrency/thesis.tex (revision 206de5ab2b76ee44636062f62bc9a1ff10a14888) +++ doc/proposals/concurrency/thesis.tex (revision e2b17a4439069fc5076a980015bdd7f368faf252) @@ -1,10 +1,10 @@ % requires tex packages: texlive-base texlive-latex-base tex-common texlive-humanities texlive-latex-extra texlive-fonts-recommended -% inline code ©...© (copyright symbol) emacs: C-q M-) -% red highlighting ®...® (registered trademark symbol) emacs: C-q M-. -% blue highlighting ß...ß (sharp s symbol) emacs: C-q M-_ -% green highlighting ¢...¢ (cent symbol) emacs: C-q M-" -% LaTex escape §...§ (section symbol) emacs: C-q M-' -% keyword escape ¶...¶ (pilcrow symbol) emacs: C-q M-^ +% inline code �...� (copyright symbol) emacs: C-q M-) +% red highlighting �...� (registered trademark symbol) emacs: C-q M-. +% blue highlighting �...� (sharp s symbol) emacs: C-q M-_ +% green highlighting �...� (cent symbol) emacs: C-q M-" +% LaTex escape �...� (section symbol) emacs: C-q M-' +% keyword escape �...� (pilcrow symbol) emacs: C-q M-^ % math escape $...$ (dollar symbol) @@ -27,5 +27,5 @@ \usepackage{multicol} \usepackage[acronym]{glossaries} -\usepackage{varioref} +\usepackage{varioref} \usepackage{listings} % format program code \usepackage[flushmargin]{footmisc} % support label/reference in footnote @@ -103,11 +103,9 @@ \input{parallelism} -\chapter{Putting it all together} +\input{together} + +\input{future} \chapter{Conclusion} - -\chapter{Future work} -Concurrency and parallelism is still a very active field that strongly benefits from hardware advances. As such certain features that aren't necessarily mature enough in their current state could become relevant in the lifetime of \CFA. -\subsection{Transactions} \section*{Acknowledgements} Index: doc/proposals/concurrency/version =================================================================== --- doc/proposals/concurrency/version (revision 206de5ab2b76ee44636062f62bc9a1ff10a14888) +++ doc/proposals/concurrency/version (revision e2b17a4439069fc5076a980015bdd7f368faf252) @@ -1,1 +1,1 @@ -0.9.180 +0.10.2 Index: src/Parser/DeclarationNode.cc =================================================================== --- src/Parser/DeclarationNode.cc (revision 206de5ab2b76ee44636062f62bc9a1ff10a14888) +++ src/Parser/DeclarationNode.cc (revision e2b17a4439069fc5076a980015bdd7f368faf252) @@ -9,7 +9,7 @@ // Author : Rodolfo G. Esteves // Created On : Sat May 16 12:34:05 2015 -// Last Modified By : Andrew Beach -// Last Modified On : Thr Aug 10 17:02:00 2017 -// Update Count : 1021 +// Last Modified By : Peter A. Buhr +// Last Modified On : Sat Sep 23 18:16:48 2017 +// Update Count : 1024 // @@ -40,6 +40,6 @@ using namespace std; -// These must remain in the same order as the corresponding DeclarationNode enumerations. -const char * DeclarationNode::basicTypeNames[] = { "void", "_Bool", "char", "int", "float", "double", "long double", "NoBasicTypeNames" }; +// These must harmonize with the corresponding DeclarationNode enumerations. +const char * DeclarationNode::basicTypeNames[] = { "void", "_Bool", "char", "int", "float", "double", "long double", "int128", "float80", "float128", "NoBasicTypeNames" }; const char * DeclarationNode::complexTypeNames[] = { "_Complex", "_Imaginary", "NoComplexTypeNames" }; const char * DeclarationNode::signednessNames[] = { "signed", "unsigned", "NoSignednessNames" }; Index: src/Parser/ExpressionNode.cc =================================================================== --- src/Parser/ExpressionNode.cc (revision 206de5ab2b76ee44636062f62bc9a1ff10a14888) +++ src/Parser/ExpressionNode.cc (revision e2b17a4439069fc5076a980015bdd7f368faf252) @@ -10,6 +10,6 @@ // Created On : Sat May 16 13:17:07 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Sep 14 23:09:34 2017 -// Update Count : 690 +// Last Modified On : Tue Sep 26 11:23:36 2017 +// Update Count : 780 // @@ -60,4 +60,37 @@ static inline bool checkX( char c ) { return c == 'x' || c == 'X'; } +static const char * lnthsInt[2][6] = { + { "int8_t", "int16_t", "int32_t", "int64_t", "size_t", }, + { "uint8_t", "uint16_t", "uint32_t", "uint64_t", "size_t", } +}; // lnthsInt + +static inline void checkLNInt( string & str, int & lnth, int & size ) { + string::size_type posn = str.find_first_of( "lL" ), start = posn; + if ( posn == string::npos ) return; + size = 4; // assume largest size + posn += 1; // advance to size + if ( str[posn] == '8' ) { // 8 + lnth = 0; + } else if ( str[posn] == '1' ) { + posn += 1; + if ( str[posn] == '6' ) { // 16 + lnth = 1; + } else { // 128 + posn += 1; + lnth = 5; + } // if + } else { + if ( str[posn] == '3' ) { // 32 + lnth = 2; + } else if ( str[posn] == '6' ) { // 64 + lnth = 3; + } else { + assertf( false, "internal error, bad integral length %s", str.c_str() ); + } // if + posn += 1; + } // if + str.erase( start, posn - start + 1 ); // remove length suffix +} // checkLNInt + static void sepNumeric( string & str, string & units ) { string::size_type posn = str.find_first_of( "`" ); @@ -69,15 +102,17 @@ Expression * build_constantInteger( string & str ) { - static const BasicType::Kind kind[2][5] = { + static const BasicType::Kind kind[2][6] = { // short (h) must be before char (hh) - { BasicType::ShortSignedInt, BasicType::SignedChar, BasicType::SignedInt, BasicType::LongSignedInt, BasicType::LongLongSignedInt }, - { BasicType::ShortUnsignedInt, BasicType::UnsignedChar, BasicType::UnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongUnsignedInt }, + { BasicType::ShortSignedInt, BasicType::SignedChar, BasicType::SignedInt, BasicType::LongSignedInt, BasicType::LongLongSignedInt, BasicType::SignedInt128, }, + { BasicType::ShortUnsignedInt, BasicType::UnsignedChar, BasicType::UnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::UnsignedInt128, }, }; - string units; // units + string units; sepNumeric( str, units ); // separate constant from units bool dec = true, Unsigned = false; // decimal, unsigned constant - int size; // 0 => short, 1 => char, 2 => int, 3 => long int, 4 => long long int, 5 => size_t + int size; // 0 => short, 1 => char, 2 => int, 3 => long int, 4 => long long int, 5 => int128 + int lnth = -1; // literal length + unsigned long long int v; // converted integral value size_t last = str.length() - 1; // last character of constant @@ -140,4 +175,6 @@ } // if str.erase( last - size - 1, size + 1 ); // remove 'h'/"hh" + } else { // suffix "ln" ? + checkLNInt( str, lnth, size ); } // if } else if ( checkL( str[ last ] ) ) { // suffix 'l' ? @@ -163,14 +200,22 @@ str.erase( last - size, size + 1 ); // remove 'h'/"hh" } else if ( checkZ( str[last] ) ) { // suffix 'z' ? - size = 5; + lnth = 4; str.erase( last, 1 ); // remove 'z' - } // if - + } else { // suffix "ln" ? + checkLNInt( str, lnth, size ); + } // if + + assert( 0 <= size && size < 6 ); ret = new ConstantExpr( Constant( new BasicType( noQualifiers, kind[Unsigned][size] ), str, v ) ); - if ( Unsigned && size < 2 ) { // less than int ? - // int i = -1uh => 65535 not -1, so cast is necessary for unsigned, which eliminates warnings for large values. + if ( size < 2 ) { // hh or h, less than int ? + // int i = -1uh => 65535 not -1, so cast is necessary for unsigned, which unfortunately eliminates warnings for large values. ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][size] ) ); - } else if ( size == 5 ) { // explicit cast to size_t - ret = new CastExpr( ret, new TypeInstType( Type::Qualifiers(), "size_t", false ) ); + } else if ( lnth != -1 ) { // explicit length ? + if ( lnth == 5 ) { // int128 ? + size = 5; + ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][size] ) ); + } else { + ret = new CastExpr( ret, new TypeInstType( Type::Qualifiers(), lnthsInt[Unsigned][lnth], false ) ); + } // if } // if CLEANUP: @@ -182,4 +227,26 @@ return ret; } // build_constantInteger + + +static inline void checkLNFloat( string & str, int & lnth, int & size ) { + string::size_type posn = str.find_first_of( "lL" ), start = posn; + if ( posn == string::npos ) return; + size = 2; // assume largest size + lnth = 0; + posn += 1; // advance to size + if ( str[posn] == '3' ) { // 32 + size = 0; + } else if ( str[posn] == '6' ) { // 64 + size = 1; + } else if ( str[posn] == '8' || str[posn] == '1' ) { // 80, 128 + size = 2; + if ( str[posn] == '1' ) posn += 1; + } else { + assertf( false, "internal error, bad floating point length %s", str.c_str() ); + } // if + posn += 1; + str.erase( start, posn - start + 1 ); // remove length suffix +} // checkLNFloat + Expression * build_constantFloat( string & str ) { @@ -189,9 +256,10 @@ }; - string units; // units + string units; sepNumeric( str, units ); // separate constant from units bool complx = false; // real, complex - int size = 1; // 0 => float, 1 => double (default), 2 => long double + int size = 1; // 0 => float, 1 => double, 2 => long double + int lnth = -1; // literal length // floating-point constant has minimum of 2 characters: 1. or .1 size_t last = str.length() - 1; @@ -211,4 +279,7 @@ } else if ( checkL( str[last] ) ) { // long double ? size = 2; + } else { + size = 1; // double (default) + checkLNFloat( str, lnth, size ); } // if if ( ! complx && checkI( str[last - 1] ) ) { // imaginary ? @@ -216,5 +287,9 @@ } // if + assert( 0 <= size && size < 3 ); Expression * ret = new ConstantExpr( Constant( new BasicType( noQualifiers, kind[complx][size] ), str, v ) ); + if ( lnth != -1 ) { // explicit length ? + ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[complx][size] ) ); + } // if if ( units.length() != 0 ) { ret = new UntypedExpr( new NameExpr( units ), { ret } ); Index: src/Parser/ParseNode.h =================================================================== --- src/Parser/ParseNode.h (revision 206de5ab2b76ee44636062f62bc9a1ff10a14888) +++ src/Parser/ParseNode.h (revision e2b17a4439069fc5076a980015bdd7f368faf252) @@ -10,6 +10,6 @@ // Created On : Sat May 16 13:28:16 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Sep 14 23:09:39 2017 -// Update Count : 815 +// Last Modified On : Sat Sep 23 18:11:22 2017 +// Update Count : 821 // @@ -47,6 +47,4 @@ #define YYLTYPE_IS_DECLARED 1 /* alert the parser that we have our own definition */ -extern char * yyfilename; -extern int yylineno; extern YYLTYPE yylloc; @@ -197,18 +195,18 @@ class DeclarationNode : public ParseNode { public: - enum BasicType { Void, Bool, Char, Int, Float, Double, LongDouble, NoBasicType }; + // These enumerations must harmonize with their names. + enum BasicType { Void, Bool, Char, Int, Float, Double, LongDouble, Int128, Float80, Float128, NoBasicType }; + static const char * basicTypeNames[]; enum ComplexType { Complex, Imaginary, NoComplexType }; + static const char * complexTypeNames[]; enum Signedness { Signed, Unsigned, NoSignedness }; + static const char * signednessNames[]; enum Length { Short, Long, LongLong, NoLength }; + static const char * lengthNames[]; enum Aggregate { Struct, Union, Trait, Coroutine, Monitor, Thread, NoAggregate }; + static const char * aggregateNames[]; enum TypeClass { Otype, Dtype, Ftype, Ttype, NoTypeClass }; + static const char * typeClassNames[]; enum BuiltinType { Valist, Zero, One, NoBuiltinType }; - - static const char * basicTypeNames[]; - static const char * complexTypeNames[]; - static const char * signednessNames[]; - static const char * lengthNames[]; - static const char * aggregateNames[]; - static const char * typeClassNames[]; static const char * builtinTypeNames[]; Index: src/Parser/TypeData.cc =================================================================== --- src/Parser/TypeData.cc (revision 206de5ab2b76ee44636062f62bc9a1ff10a14888) +++ src/Parser/TypeData.cc (revision e2b17a4439069fc5076a980015bdd7f368faf252) @@ -10,6 +10,6 @@ // Created On : Sat May 16 15:12:51 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Fri Sep 1 23:13:38 2017 -// Update Count : 569 +// Last Modified On : Mon Sep 25 18:33:41 2017 +// Update Count : 587 // @@ -98,4 +98,5 @@ } // TypeData::TypeData + TypeData::~TypeData() { delete base; @@ -161,4 +162,5 @@ } // switch } // TypeData::~TypeData + TypeData * TypeData::clone() const { @@ -235,4 +237,5 @@ } // TypeData::clone + void TypeData::print( ostream &os, int indent ) const { for ( int i = 0; i < Type::NumTypeQualifier; i += 1 ) { @@ -398,4 +401,5 @@ } // switch } // TypeData::print + template< typename ForallList > @@ -430,5 +434,6 @@ } // if } // for -} +} // buildForall + Type * typebuild( const TypeData * td ) { @@ -477,4 +482,5 @@ } // typebuild + TypeData * typeextractAggregate( const TypeData * td, bool toplevel ) { TypeData * ret = nullptr; @@ -504,8 +510,14 @@ } // typeextractAggregate + Type::Qualifiers buildQualifiers( const TypeData * td ) { return td->qualifiers; } // buildQualifiers + +static string genTSError( string msg, DeclarationNode::BasicType basictype ) { + throw SemanticError( string( "invalid type specifier \"" ) + msg + "\" for type \"" + DeclarationNode::basicTypeNames[basictype] + "\"." ); +} // genTSError + Type * buildBasicType( const TypeData * td ) { BasicType::Kind ret; @@ -513,8 +525,10 @@ switch ( td->basictype ) { case DeclarationNode::Void: - if ( td->signedness != DeclarationNode::NoSignedness && td->length != DeclarationNode::NoLength ) { - throw SemanticError( "invalid type specifier \"void\" in type: ", td ); - } // if - + if ( td->signedness != DeclarationNode::NoSignedness ) { + genTSError( DeclarationNode::signednessNames[ td->signedness ], td->basictype ); + } // if + if ( td->length != DeclarationNode::NoLength ) { + genTSError( DeclarationNode::lengthNames[ td->length ], td->basictype ); + } // if return new VoidType( buildQualifiers( td ) ); break; @@ -522,8 +536,8 @@ case DeclarationNode::Bool: if ( td->signedness != DeclarationNode::NoSignedness ) { - throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::signednessNames[ td->signedness ] + " in type: ", td ); + genTSError( DeclarationNode::signednessNames[ td->signedness ], td->basictype ); } // if if ( td->length != DeclarationNode::NoLength ) { - throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthNames[ td->length ] + " in type: ", td ); + genTSError( DeclarationNode::lengthNames[ td->length ], td->basictype ); } // if @@ -538,5 +552,5 @@ if ( td->length != DeclarationNode::NoLength ) { - throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthNames[ td->length ] + " in type: ", td ); + genTSError( DeclarationNode::lengthNames[ td->length ], td->basictype ); } // if @@ -557,5 +571,14 @@ break; + case DeclarationNode::Int128: + ret = td->signedness == 1 ? BasicType::UnsignedInt128 : BasicType::SignedInt128; + if ( td->length != DeclarationNode::NoLength ) { + genTSError( DeclarationNode::lengthNames[ td->length ], td->basictype ); + } // if + break; + case DeclarationNode::Float: + case DeclarationNode::Float80: + case DeclarationNode::Float128: case DeclarationNode::Double: case DeclarationNode::LongDouble: // not set until below @@ -568,11 +591,11 @@ FloatingPoint: ; if ( td->signedness != DeclarationNode::NoSignedness ) { - throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::signednessNames[ td->signedness ] + " in type: ", td ); + genTSError( DeclarationNode::signednessNames[ td->signedness ], td->basictype ); } // if if ( td->length == DeclarationNode::Short || td->length == DeclarationNode::LongLong ) { - throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthNames[ td->length ] + " in type: ", td ); + genTSError( DeclarationNode::lengthNames[ td->length ], td->basictype ); } // if if ( td->basictype == DeclarationNode::Float && td->length == DeclarationNode::Long ) { - throw SemanticError( "invalid type specifier \"long\" in type: ", td ); + genTSError( DeclarationNode::lengthNames[ td->length ], td->basictype ); } // if if ( td->length == DeclarationNode::Long ) { @@ -593,5 +616,5 @@ goto Integral; default: - assert(false); + assertf( false, "unknown basic type" ); return nullptr; } // switch @@ -601,4 +624,5 @@ return bt; } // buildBasicType + PointerType * buildPointer( const TypeData * td ) { @@ -612,4 +636,5 @@ return pt; } // buildPointer + ArrayType * buildArray( const TypeData * td ) { @@ -626,4 +651,5 @@ } // buildArray + ReferenceType * buildReference( const TypeData * td ) { ReferenceType * rt; @@ -637,4 +663,5 @@ } // buildReference + AggregateDecl * buildAggregate( const TypeData * td, std::list< Attribute * > attributes, LinkageSpec::Spec linkage ) { assert( td->kind == TypeData::Aggregate ); @@ -665,4 +692,5 @@ return at; } // buildAggregate + ReferenceToType * buildComAggInst( const TypeData * type, std::list< Attribute * > attributes, LinkageSpec::Spec linkage ) { @@ -722,4 +750,5 @@ } // buildAggInst + ReferenceToType * buildAggInst( const TypeData * td ) { assert( td->kind == TypeData::AggregateInst ); @@ -761,4 +790,5 @@ } // buildAggInst + NamedTypeDecl * buildSymbolic( const TypeData * td, const string & name, Type::StorageClasses scs, LinkageSpec::Spec linkage ) { assert( td->kind == TypeData::Symbolic ); @@ -775,4 +805,5 @@ } // buildSymbolic + EnumDecl * buildEnum( const TypeData * td, std::list< Attribute * > attributes, LinkageSpec::Spec linkage ) { assert( td->kind == TypeData::Enum ); @@ -790,4 +821,5 @@ } // buildEnum + TypeInstType * buildSymbolicInst( const TypeData * td ) { assert( td->kind == TypeData::SymbolicInst ); @@ -797,4 +829,5 @@ return ret; } // buildSymbolicInst + TupleType * buildTuple( const TypeData * td ) { @@ -807,4 +840,5 @@ } // buildTuple + TypeofType * buildTypeof( const TypeData * td ) { assert( td->kind == TypeData::Typeof ); @@ -813,4 +847,5 @@ return new TypeofType( buildQualifiers( td ), td->typeexpr->build() ); } // buildTypeof + Declaration * buildDecl( const TypeData * td, const string &name, Type::StorageClasses scs, Expression * bitfieldWidth, Type::FuncSpecifiers funcSpec, LinkageSpec::Spec linkage, Expression *asmName, Initializer * init, std::list< Attribute * > attributes ) { @@ -836,4 +871,5 @@ return nullptr; } // buildDecl + FunctionType * buildFunction( const TypeData * td ) { @@ -857,4 +893,5 @@ return ft; } // buildFunction + // Transform KR routine declarations into C99 routine declarations: Index: src/Parser/lex.ll =================================================================== --- src/Parser/lex.ll (revision 206de5ab2b76ee44636062f62bc9a1ff10a14888) +++ src/Parser/lex.ll (revision e2b17a4439069fc5076a980015bdd7f368faf252) @@ -10,6 +10,6 @@ * Created On : Sat Sep 22 08:58:10 2001 * Last Modified By : Peter A. Buhr - * Last Modified On : Sun Sep 10 22:29:15 2017 - * Update Count : 620 + * Last Modified On : Sat Sep 23 17:29:28 2017 + * Update Count : 632 */ @@ -93,5 +93,6 @@ // numeric constants, CFA: '_' in constant hex_quad {hex}("_"?{hex}){3} -length ("ll"|"LL"|[lL])|("hh"|"HH"|[hH]) +size_opt (8|16|32|64|128)? +length ("ll"|"LL"|[lL]{size_opt})|("hh"|"HH"|[hH]) integer_suffix_opt ("_"?(([uU]({length}?[iI]?)|([iI]{length}))|([iI]({length}?[uU]?)|([uU]{length}))|({length}([iI]?[uU]?)|([uU][iI]))|[zZ]))?{user_suffix_opt} @@ -109,5 +110,7 @@ // GCC: D (double) and iI (imaginary) suffixes, and DL (long double) exponent "_"?[eE]"_"?[+-]?{decimal_digits} -floating_suffix ([fFdDlL]?[iI]?)|([iI][lLfFdD]) +floating_size 32|64|80|128 +floating_length ([fFdDlL]|[lL]{floating_size}) +floating_suffix ({floating_length}?[iI]?)|([iI]{floating_length}) floating_suffix_opt ("_"?({floating_suffix}|"DL"))?{user_suffix_opt} decimal_digits ({decimal})|({decimal}({decimal}|"_")*{decimal}) @@ -234,5 +237,8 @@ finally { KEYWORD_RETURN(FINALLY); } // CFA float { KEYWORD_RETURN(FLOAT); } -__float128 { KEYWORD_RETURN(FLOAT); } // GCC +__float80 { KEYWORD_RETURN(FLOAT80); } // GCC +float80 { KEYWORD_RETURN(FLOAT80); } // GCC +__float128 { KEYWORD_RETURN(FLOAT128); } // GCC +float128 { KEYWORD_RETURN(FLOAT128); } // GCC for { KEYWORD_RETURN(FOR); } forall { KEYWORD_RETURN(FORALL); } // CFA @@ -249,6 +255,6 @@ __inline__ { KEYWORD_RETURN(INLINE); } // GCC int { KEYWORD_RETURN(INT); } -__int128 { KEYWORD_RETURN(INT); } // GCC -__int128_t { KEYWORD_RETURN(INT); } // GCC +__int128 { KEYWORD_RETURN(INT128); } // GCC +int128 { KEYWORD_RETURN(INT128); } // GCC __label__ { KEYWORD_RETURN(LABEL); } // GCC long { KEYWORD_RETURN(LONG); } @@ -285,5 +291,4 @@ __typeof { KEYWORD_RETURN(TYPEOF); } // GCC __typeof__ { KEYWORD_RETURN(TYPEOF); } // GCC -__uint128_t { KEYWORD_RETURN(INT); } // GCC union { KEYWORD_RETURN(UNION); } unsigned { KEYWORD_RETURN(UNSIGNED); } Index: src/Parser/parser.yy =================================================================== --- src/Parser/parser.yy (revision 206de5ab2b76ee44636062f62bc9a1ff10a14888) +++ src/Parser/parser.yy (revision e2b17a4439069fc5076a980015bdd7f368faf252) @@ -10,6 +10,6 @@ // Created On : Sat Sep 1 20:22:55 2001 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Sep 14 23:07:12 2017 -// Update Count : 2815 +// Last Modified On : Sat Sep 23 17:43:15 2017 +// Update Count : 2829 // @@ -43,5 +43,5 @@ #define YYDEBUG_LEXER_TEXT (yylval) // lexer loads this up each time #define YYDEBUG 1 // get the pretty debugging code to compile -#define YYERROR_VERBOSE +#define YYERROR_VERBOSE // more information in syntax errors #undef __GNUC_MINOR__ @@ -117,25 +117,22 @@ bool forall = false; // aggregate have one or more forall qualifiers ? -# define YYLLOC_DEFAULT(Cur, Rhs, N) \ -do \ - if (N) { \ - (Cur).first_line = YYRHSLOC(Rhs, 1).first_line; \ - (Cur).first_column = YYRHSLOC(Rhs, 1).first_column; \ - (Cur).last_line = YYRHSLOC(Rhs, N).last_line; \ - (Cur).last_column = YYRHSLOC(Rhs, N).last_column; \ - (Cur).filename = YYRHSLOC(Rhs, 1).filename; \ - } else { \ - (Cur).first_line = (Cur).last_line = \ - YYRHSLOC(Rhs, 0).last_line; \ - (Cur).first_column = (Cur).last_column = \ - YYRHSLOC(Rhs, 0).last_column; \ - (Cur).filename = YYRHSLOC(Rhs, 0).filename; \ - } \ -while (0) +// https://www.gnu.org/software/bison/manual/bison.html#Location-Type +#define YYLLOC_DEFAULT(Cur, Rhs, N) \ +if ( N ) { \ + (Cur).first_line = YYRHSLOC( Rhs, 1 ).first_line; \ + (Cur).first_column = YYRHSLOC( Rhs, 1 ).first_column; \ + (Cur).last_line = YYRHSLOC( Rhs, N ).last_line; \ + (Cur).last_column = YYRHSLOC( Rhs, N ).last_column; \ + (Cur).filename = YYRHSLOC( Rhs, 1 ).filename; \ +} else { \ + (Cur).first_line = (Cur).last_line = YYRHSLOC( Rhs, 0 ).last_line; \ + (Cur).first_column = (Cur).last_column = YYRHSLOC( Rhs, 0 ).last_column; \ + (Cur).filename = YYRHSLOC( Rhs, 0 ).filename; \ +} %} %define parse.error verbose -// Types declaration +// Types declaration for productions %union { @@ -173,4 +170,5 @@ %token VOID CHAR SHORT INT LONG FLOAT DOUBLE SIGNED UNSIGNED %token BOOL COMPLEX IMAGINARY // C99 +%token INT128 FLOAT80 FLOAT128 // GCC %token ZERO_T ONE_T // CFA %token VALIST // GCC @@ -1606,28 +1604,34 @@ basic_type_name: - CHAR + VOID + { $$ = DeclarationNode::newBasicType( DeclarationNode::Void ); } + | BOOL // C99 + { $$ = DeclarationNode::newBasicType( DeclarationNode::Bool ); } + | CHAR { $$ = DeclarationNode::newBasicType( DeclarationNode::Char ); } + | INT + { $$ = DeclarationNode::newBasicType( DeclarationNode::Int ); } + | INT128 + { $$ = DeclarationNode::newBasicType( DeclarationNode::Int128 ); } + | FLOAT + { $$ = DeclarationNode::newBasicType( DeclarationNode::Float ); } + | FLOAT80 + { $$ = DeclarationNode::newBasicType( DeclarationNode::Float80 ); } + | FLOAT128 + { $$ = DeclarationNode::newBasicType( DeclarationNode::Float128 ); } | DOUBLE { $$ = DeclarationNode::newBasicType( DeclarationNode::Double ); } - | FLOAT - { $$ = DeclarationNode::newBasicType( DeclarationNode::Float ); } - | INT - { $$ = DeclarationNode::newBasicType( DeclarationNode::Int ); } - | LONG - { $$ = DeclarationNode::newLength( DeclarationNode::Long ); } - | SHORT - { $$ = DeclarationNode::newLength( DeclarationNode::Short ); } + | COMPLEX // C99 + { $$ = DeclarationNode::newComplexType( DeclarationNode::Complex ); } + | IMAGINARY // C99 + { $$ = DeclarationNode::newComplexType( DeclarationNode::Imaginary ); } | SIGNED { $$ = DeclarationNode::newSignedNess( DeclarationNode::Signed ); } | UNSIGNED { $$ = DeclarationNode::newSignedNess( DeclarationNode::Unsigned ); } - | VOID - { $$ = DeclarationNode::newBasicType( DeclarationNode::Void ); } - | BOOL // C99 - { $$ = DeclarationNode::newBasicType( DeclarationNode::Bool ); } - | COMPLEX // C99 - { $$ = DeclarationNode::newComplexType( DeclarationNode::Complex ); } - | IMAGINARY // C99 - { $$ = DeclarationNode::newComplexType( DeclarationNode::Imaginary ); } + | SHORT + { $$ = DeclarationNode::newLength( DeclarationNode::Short ); } + | LONG + { $$ = DeclarationNode::newLength( DeclarationNode::Long ); } | ZERO_T { $$ = DeclarationNode::newBuiltinType( DeclarationNode::Zero ); } Index: src/ResolvExpr/CommonType.cc =================================================================== --- src/ResolvExpr/CommonType.cc (revision 206de5ab2b76ee44636062f62bc9a1ff10a14888) +++ src/ResolvExpr/CommonType.cc (revision e2b17a4439069fc5076a980015bdd7f368faf252) @@ -10,6 +10,6 @@ // Created On : Sun May 17 06:59:27 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Mar 16 16:24:31 2017 -// Update Count : 7 +// Last Modified On : Mon Sep 25 15:18:17 2017 +// Update Count : 9 // @@ -150,26 +150,28 @@ static const BasicType::Kind combinedType[ BasicType::NUMBER_OF_BASIC_TYPES ][ BasicType::NUMBER_OF_BASIC_TYPES ] = { -/* Bool Char SignedChar UnsignedChar ShortSignedInt ShortUnsignedInt SignedInt UnsignedInt LongSignedInt LongUnsignedInt LongLongSignedInt LongLongUnsignedInt Float Double LongDouble FloatComplex DoubleComplex LongDoubleComplex FloatImaginary DoubleImaginary LongDoubleImaginary */ - /* Bool */ { BasicType::Bool, BasicType::Char, BasicType::SignedChar, BasicType::UnsignedChar, BasicType::ShortSignedInt, BasicType::ShortUnsignedInt, BasicType::SignedInt, BasicType::UnsignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex }, - /* Char */ { BasicType::Char, BasicType::Char, BasicType::UnsignedChar, BasicType::UnsignedChar, BasicType::ShortSignedInt, BasicType::ShortUnsignedInt, BasicType::SignedInt, BasicType::UnsignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex }, - /* SignedChar */ { BasicType::SignedChar, BasicType::UnsignedChar, BasicType::SignedChar, BasicType::UnsignedChar, BasicType::ShortSignedInt, BasicType::ShortUnsignedInt, BasicType::SignedInt, BasicType::UnsignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex }, - /* UnsignedChar */ { BasicType::UnsignedChar, BasicType::UnsignedChar, BasicType::UnsignedChar, BasicType::UnsignedChar, BasicType::ShortSignedInt, BasicType::ShortUnsignedInt, BasicType::SignedInt, BasicType::UnsignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex }, - /* ShortSignedInt */ { BasicType::ShortSignedInt, BasicType::ShortSignedInt, BasicType::ShortSignedInt, BasicType::ShortSignedInt, BasicType::ShortSignedInt, BasicType::ShortUnsignedInt, BasicType::SignedInt, BasicType::UnsignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex }, - /* ShortUnsignedInt */ { BasicType::ShortUnsignedInt, BasicType::ShortUnsignedInt, BasicType::ShortUnsignedInt, BasicType::ShortUnsignedInt, BasicType::ShortUnsignedInt, BasicType::ShortUnsignedInt, BasicType::SignedInt, BasicType::UnsignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex }, - /* SignedInt */ { BasicType::SignedInt, BasicType::SignedInt, BasicType::SignedInt, BasicType::SignedInt, BasicType::SignedInt, BasicType::SignedInt, BasicType::SignedInt, BasicType::UnsignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex }, - /* UnsignedInt */ { BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex }, - /* LongSignedInt */ { BasicType::LongSignedInt, BasicType::LongSignedInt, BasicType::LongSignedInt, BasicType::LongSignedInt, BasicType::LongSignedInt, BasicType::LongSignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex }, - /* LongUnsignedInt */ { BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex }, - /* LongLongSignedInt */ { BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex }, - /* LongLongUnsignedInt */ { BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex }, - /* Float */ { BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex }, - /* Double */ { BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::LongDouble, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex }, - /* LongDouble */ { BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex }, - /* FloatComplex */ { BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex }, - /* DoubleComplex */ { BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex }, - /* LongDoubleComplex */ { BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex }, - /* FloatImaginary */ { BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatImaginary, BasicType::DoubleImaginary, BasicType::LongDoubleImaginary }, - /* DoubleImaginary */ { BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::DoubleImaginary, BasicType::DoubleImaginary, BasicType::LongDoubleImaginary }, - /* LongDoubleImaginary */ { BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleImaginary, BasicType::LongDoubleImaginary, BasicType::LongDoubleImaginary } +/* Bool Char SignedChar UnsignedChar ShortSignedInt ShortUnsignedInt SignedInt UnsignedInt LongSignedInt LongUnsignedInt LongLongSignedInt LongLongUnsignedInt Float Double LongDouble FloatComplex DoubleComplex LongDoubleComplex FloatImaginary DoubleImaginary LongDoubleImaginary SignedInt128 UnsignedInt128 */ + /* Bool */ { BasicType::Bool, BasicType::Char, BasicType::SignedChar, BasicType::UnsignedChar, BasicType::ShortSignedInt, BasicType::ShortUnsignedInt, BasicType::SignedInt, BasicType::UnsignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, }, + /* Char */ { BasicType::Char, BasicType::Char, BasicType::UnsignedChar, BasicType::UnsignedChar, BasicType::ShortSignedInt, BasicType::ShortUnsignedInt, BasicType::SignedInt, BasicType::UnsignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, }, + /* SignedChar */ { BasicType::SignedChar, BasicType::UnsignedChar, BasicType::SignedChar, BasicType::UnsignedChar, BasicType::ShortSignedInt, BasicType::ShortUnsignedInt, BasicType::SignedInt, BasicType::UnsignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, }, + /* UnsignedChar */ { BasicType::UnsignedChar, BasicType::UnsignedChar, BasicType::UnsignedChar, BasicType::UnsignedChar, BasicType::ShortSignedInt, BasicType::ShortUnsignedInt, BasicType::SignedInt, BasicType::UnsignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, }, + /* ShortSignedInt */ { BasicType::ShortSignedInt, BasicType::ShortSignedInt, BasicType::ShortSignedInt, BasicType::ShortSignedInt, BasicType::ShortSignedInt, BasicType::ShortUnsignedInt, BasicType::SignedInt, BasicType::UnsignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, }, + /* ShortUnsignedInt */ { BasicType::ShortUnsignedInt, BasicType::ShortUnsignedInt, BasicType::ShortUnsignedInt, BasicType::ShortUnsignedInt, BasicType::ShortUnsignedInt, BasicType::ShortUnsignedInt, BasicType::SignedInt, BasicType::UnsignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, }, + /* SignedInt */ { BasicType::SignedInt, BasicType::SignedInt, BasicType::SignedInt, BasicType::SignedInt, BasicType::SignedInt, BasicType::SignedInt, BasicType::SignedInt, BasicType::UnsignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, }, + /* UnsignedInt */ { BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, }, + /* LongSignedInt */ { BasicType::LongSignedInt, BasicType::LongSignedInt, BasicType::LongSignedInt, BasicType::LongSignedInt, BasicType::LongSignedInt, BasicType::LongSignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, }, + /* LongUnsignedInt */ { BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, }, + /* LongLongSignedInt */ { BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, }, + /* LongLongUnsignedInt */ { BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, }, + /* Float */ { BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::Float, BasicType::Float, }, + /* Double */ { BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::LongDouble, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::Double, BasicType::Double, }, + /* LongDouble */ { BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDouble, BasicType::LongDouble, }, + /* FloatComplex */ { BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::FloatComplex, }, + /* DoubleComplex */ { BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, }, + /* LongDoubleComplex */ { BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, }, + /* FloatImaginary */ { BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatImaginary, BasicType::DoubleImaginary, BasicType::LongDoubleImaginary, BasicType::FloatImaginary, BasicType::FloatImaginary, }, + /* DoubleImaginary */ { BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::DoubleImaginary, BasicType::DoubleImaginary, BasicType::LongDoubleImaginary, BasicType::DoubleImaginary, BasicType::DoubleImaginary, }, + /* LongDoubleImaginary */ { BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleImaginary, BasicType::LongDoubleImaginary, BasicType::LongDoubleImaginary }, + /* SignedInt128 */ { BasicType::SignedInt128, BasicType::SignedInt128, BasicType::SignedInt128, BasicType::SignedInt128, BasicType::SignedInt128, BasicType::SignedInt128, BasicType::SignedInt128, BasicType::SignedInt128, BasicType::SignedInt128, BasicType::SignedInt128, BasicType::SignedInt128, BasicType::SignedInt128, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, }, + /* UnsignedInt128 */ { BasicType::UnsignedInt128, BasicType::UnsignedInt128, BasicType::UnsignedInt128, BasicType::UnsignedInt128, BasicType::UnsignedInt128, BasicType::UnsignedInt128, BasicType::UnsignedInt128, BasicType::UnsignedInt128, BasicType::UnsignedInt128, BasicType::UnsignedInt128, BasicType::UnsignedInt128, BasicType::UnsignedInt128, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::UnsignedInt128, BasicType::UnsignedInt128, }, }; Index: src/ResolvExpr/ConversionCost.cc =================================================================== --- src/ResolvExpr/ConversionCost.cc (revision 206de5ab2b76ee44636062f62bc9a1ff10a14888) +++ src/ResolvExpr/ConversionCost.cc (revision e2b17a4439069fc5076a980015bdd7f368faf252) @@ -10,6 +10,6 @@ // Created On : Sun May 17 07:06:19 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Wed Mar 2 17:35:46 2016 -// Update Count : 6 +// Last Modified On : Mon Sep 25 15:43:34 2017 +// Update Count : 10 // @@ -219,28 +219,31 @@ */ - static const int costMatrix[ BasicType::NUMBER_OF_BASIC_TYPES ][ BasicType::NUMBER_OF_BASIC_TYPES ] = - { - /* Src \ Dest: Bool Char SChar UChar Short UShort Int UInt Long ULong LLong ULLong Float Double LDbl FCplex DCplex LDCplex FImag DImag LDImag */ - /* Bool */ { 0, 1, 1, 2, 3, 4, 5, 6, 6, 7, 8, 9, 10, 11, 12, 11, 12, 13, -1, -1, -1 }, - /* Char */ { -1, 0, -1, 1, 2, 3, 4, 5, 5, 6, 7, 8, 9, 10, 11, 10, 11, 12, -1, -1, -1 }, - /* SChar */ { -1, -1, 0, 1, 2, 3, 4, 5, 5, 6, 7, 8, 9, 10, 11, 10, 11, 12, -1, -1, -1 }, - /* UChar */ { -1, -1, -1, 0, 1, 2, 3, 4, 4, 5, 6, 7, 8, 9, 10, 9, 10, 11, -1, -1, -1 }, - /* Short */ { -1, -1, -1, -1, 0, 1, 2, 3, 3, 4, 5, 6, 7, 8, 9, 8, 9, 10, -1, -1, -1 }, - /* UShort */{ -1, -1, -1, -1, -1, 0, 1, 2, 2, 3, 4, 5, 6, 7, 8, 7, 8, 9, -1, -1, -1 }, - /* Int */ { -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 3, 4, 5, 6, 7, 6, 7, 8, -1, -1, -1 }, - /* UInt */ { -1, -1, -1, -1, -1, -1, -1, 0, -1, 1, 2, 3, 4, 5, 6, 5, 6, 7, -1, -1, -1 }, - /* Long */ { -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 5, 6, 7, -1, -1, -1 }, - /* ULong */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 5, 4, 5, 6, -1, -1, -1 }, - /* LLong */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 3, 4, 5, -1, -1, -1 }, - /* ULLong */{ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 3, 2, 3, 4, -1, -1, -1 }, - /* Float */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 1, 2, 3, -1, -1, -1 }, - /* Double */{ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, -1, 1, 2, -1, -1, -1 }, - /* LDbl */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, -1, 1, -1, -1, -1 }, - /* FCplex */{ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, -1, -1, -1 }, - /* DCplex */{ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, -1, -1, -1 }, - /* LDCplex */{ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, -1, -1 }, - /* FImag */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 2, 3, 0, 1, 2 }, - /* DImag */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 2, -1, 0, 1 }, - /* LDImag */{ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, -1, -1, 0 } + static const int costMatrix[ BasicType::NUMBER_OF_BASIC_TYPES ][ BasicType::NUMBER_OF_BASIC_TYPES ] = { + /* Src \ Dest: Bool Char SChar UChar Short UShort Int UInt Long ULong LLong ULLong Float Double LDbl FCplex DCplex LDCplex FImag DImag LDImag I128, U128 */ + /* Bool */ { 0, 1, 1, 2, 3, 4, 5, 6, 6, 7, 8, 9, 12, 13, 14, 12, 13, 14, -1, -1, -1, 10, 11, }, + /* Char */ { -1, 0, -1, 1, 2, 3, 4, 5, 5, 6, 7, 8, 11, 12, 13, 11, 12, 13, -1, -1, -1, 9, 10, }, + /* SChar */ { -1, -1, 0, 1, 2, 3, 4, 5, 5, 6, 7, 8, 11, 12, 13, 11, 12, 13, -1, -1, -1, 9, 10, }, + /* UChar */ { -1, -1, -1, 0, 1, 2, 3, 4, 4, 5, 6, 7, 10, 11, 12, 10, 11, 12, -1, -1, -1, 8, 9, }, + /* Short */ { -1, -1, -1, -1, 0, 1, 2, 3, 3, 4, 5, 6, 9, 10, 11, 9, 10, 11, -1, -1, -1, 7, 8, }, + /* UShort */{ -1, -1, -1, -1, -1, 0, 1, 2, 2, 3, 4, 5, 8, 9, 10, 8, 9, 10, -1, -1, -1, 6, 7, }, + /* Int */ { -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 3, 4, 7, 8, 9, 7, 8, 9, -1, -1, -1, 5, 6, }, + /* UInt */ { -1, -1, -1, -1, -1, -1, -1, 0, -1, 1, 2, 3, 6, 7, 8, 6, 7, 8, -1, -1, -1, 4, 5, }, + /* Long */ { -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 3, 6, 7, 8, 6, 7, 8, -1, -1, -1, 4, 5, }, + /* ULong */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 5, 6, 7, 5, 6, 7, -1, -1, -1, 3, 4, }, + /* LLong */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 4, 5, 6, 4, 5, 6, -1, -1, -1, 2, 3, }, + /* ULLong */{ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 3, 4, 5, 3, 4, 5, -1, -1, -1, 1, 2, }, + + /* Float */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 1, 2, 3, -1, -1, -1, -1, -1, }, + /* Double */{ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, -1, 1, 2, -1, -1, -1, -1, -1, }, + /* LDbl */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, -1, 1, -1, -1, -1, -1, -1, }, + /* FCplex */{ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, -1, -1, -1, -1, -1, }, + /* DCplex */{ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, -1, -1, -1, -1, -1, }, + /* LDCplex */{ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, -1, -1, -1, -1, }, + /* FImag */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 2, 3, 0, 1, 2, -1, -1, }, + /* DImag */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 2, -1, 0, 1, -1, -1, }, + /* LDImag */{ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, -1, -1, 0, -1, -1, }, + + /* I128 */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2, 3, 4, 3, 4, 5, -1, -1, -1, 0, 1, }, + /* U128 */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 2, 3, 2, 3, 4, -1, -1, -1, -1, 0, }, }; Index: src/SymTab/Mangler.cc =================================================================== --- src/SymTab/Mangler.cc (revision 206de5ab2b76ee44636062f62bc9a1ff10a14888) +++ src/SymTab/Mangler.cc (revision e2b17a4439069fc5076a980015bdd7f368faf252) @@ -9,7 +9,7 @@ // Author : Richard C. Bilson // Created On : Sun May 17 21:40:29 2015 -// Last Modified By : Andrew Beach -// Last Modified On : Wed Jun 28 15:31:00 2017 -// Update Count : 21 +// Last Modified By : Peter A. Buhr +// Last Modified On : Mon Sep 25 15:49:26 2017 +// Update Count : 23 // #include "Mangler.h" @@ -115,4 +115,6 @@ "Id", // DoubleImaginary "Ir", // LongDoubleImaginary + "w", // SignedInt128 + "Uw", // UnsignedInt128 }; Index: src/SynTree/BasicType.cc =================================================================== --- src/SynTree/BasicType.cc (revision 206de5ab2b76ee44636062f62bc9a1ff10a14888) +++ src/SynTree/BasicType.cc (revision e2b17a4439069fc5076a980015bdd7f368faf252) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon Sep 11 12:52:05 2017 -// Update Count : 9 +// Last Modified On : Mon Sep 25 14:14:03 2017 +// Update Count : 11 // @@ -43,4 +43,6 @@ case LongLongSignedInt: case LongLongUnsignedInt: + case SignedInt128: + case UnsignedInt128: return true; case Float: Index: src/SynTree/Type.cc =================================================================== --- src/SynTree/Type.cc (revision 206de5ab2b76ee44636062f62bc9a1ff10a14888) +++ src/SynTree/Type.cc (revision e2b17a4439069fc5076a980015bdd7f368faf252) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon Sep 11 13:21:25 2017 -// Update Count : 37 +// Last Modified On : Mon Sep 25 15:16:32 2017 +// Update Count : 38 // #include "Type.h" @@ -45,4 +45,6 @@ "double _Imaginary", "long double _Imaginary", + "__int128", + "unsigned __int128", }; Index: src/SynTree/Type.h =================================================================== --- src/SynTree/Type.h (revision 206de5ab2b76ee44636062f62bc9a1ff10a14888) +++ src/SynTree/Type.h (revision e2b17a4439069fc5076a980015bdd7f368faf252) @@ -9,7 +9,7 @@ // Author : Richard C. Bilson // Created On : Mon May 18 07:44:20 2015 -// Last Modified By : Andrew Beach -// Last Modified On : Wed Aug 9 14:25:00 2017 -// Update Count : 152 +// Last Modified By : Peter A. Buhr +// Last Modified On : Mon Sep 25 14:14:01 2017 +// Update Count : 154 // @@ -225,4 +225,6 @@ DoubleImaginary, LongDoubleImaginary, + SignedInt128, + UnsignedInt128, NUMBER_OF_BASIC_TYPES } kind; Index: src/benchmark/Makefile.am =================================================================== --- src/benchmark/Makefile.am (revision 206de5ab2b76ee44636062f62bc9a1ff10a14888) +++ src/benchmark/Makefile.am (revision e2b17a4439069fc5076a980015bdd7f368faf252) @@ -48,4 +48,13 @@ @rm -f a.out .result.log +ctxswitch-pthread$(EXEEXT): + @BACKEND_CC@ ${AM_CFLAGS} ${CFLAGS} ${ccflags} -lrt -pthread -DN=50000000 PthrdCtxSwitch.c + @rm -f .result.log + @for number in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20; do \ + ./a.out | tee -a .result.log ; \ + done + @./stat.py .result.log + @rm -f a.out .result.log + sched-int$(EXEEXT): ${CC} ${AM_CFLAGS} ${CFLAGS} ${ccflags} @CFA_FLAGS@ -nodebug -lrt -DN=50000000 SchedInt.c Index: src/benchmark/Makefile.in =================================================================== --- src/benchmark/Makefile.in (revision 206de5ab2b76ee44636062f62bc9a1ff10a14888) +++ src/benchmark/Makefile.in (revision e2b17a4439069fc5076a980015bdd7f368faf252) @@ -598,4 +598,13 @@ @rm -f a.out .result.log +ctxswitch-pthread$(EXEEXT): + @BACKEND_CC@ ${AM_CFLAGS} ${CFLAGS} ${ccflags} -lrt -pthread -DN=50000000 PthrdCtxSwitch.c + @rm -f .result.log + @for number in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20; do \ + ./a.out | tee -a .result.log ; \ + done + @./stat.py .result.log + @rm -f a.out .result.log + sched-int$(EXEEXT): ${CC} ${AM_CFLAGS} ${CFLAGS} ${ccflags} @CFA_FLAGS@ -nodebug -lrt -DN=50000000 SchedInt.c Index: src/benchmark/PthrdCtxSwitch.c =================================================================== --- src/benchmark/PthrdCtxSwitch.c (revision e2b17a4439069fc5076a980015bdd7f368faf252) +++ src/benchmark/PthrdCtxSwitch.c (revision e2b17a4439069fc5076a980015bdd7f368faf252) @@ -0,0 +1,19 @@ +#include +#include +#define _GNU_SOURCE +#include + +#include "bench.h" + +int main() { + const unsigned int NoOfTimes = N; + long long int StartTime, EndTime; + + StartTime = Time(); + for ( volatile unsigned int i = 0; i < NoOfTimes; i += 1 ) { + pthread_yield(); + } + EndTime = Time(); + + printf("%lld\n", ( EndTime - StartTime ) / NoOfTimes ); +} Index: src/benchmark/bench.h =================================================================== --- src/benchmark/bench.h (revision 206de5ab2b76ee44636062f62bc9a1ff10a14888) +++ src/benchmark/bench.h (revision e2b17a4439069fc5076a980015bdd7f368faf252) @@ -10,5 +10,4 @@ } #endif - static inline unsigned long long int Time() { Index: src/benchmark/create_cfaThrd.c =================================================================== --- src/benchmark/create_cfaThrd.c (revision 206de5ab2b76ee44636062f62bc9a1ff10a14888) +++ src/benchmark/create_cfaThrd.c (revision e2b17a4439069fc5076a980015bdd7f368faf252) @@ -4,5 +4,5 @@ thread MyThread {}; -void main(MyThread * this) {} +void main(MyThread & this) {} int main(int argc, char* argv[]) { Index: src/driver/cfa.cc =================================================================== --- src/driver/cfa.cc (revision 206de5ab2b76ee44636062f62bc9a1ff10a14888) +++ src/driver/cfa.cc (revision e2b17a4439069fc5076a980015bdd7f368faf252) @@ -9,7 +9,7 @@ // Author : Peter A. Buhr // Created On : Tue Aug 20 13:44:49 2002 -// Last Modified By : Andrew Beach -// Last Modified On : Thr Aug 17 15:24:00 2017 -// Update Count : 156 +// Last Modified By : Peter A. Buhr +// Last Modified On : Tue Sep 26 23:12:38 2017 +// Update Count : 159 // @@ -346,4 +346,6 @@ args[nargs] = "-fgnu89-inline"; nargs += 1; + args[nargs] = "-D__int8_t_defined"; // prevent gcc type-size attributes + nargs += 1; args[nargs] = ( *new string( string("-B") + Bprefix + "/" ) ).c_str(); nargs += 1; Index: src/prelude/extras.c =================================================================== --- src/prelude/extras.c (revision 206de5ab2b76ee44636062f62bc9a1ff10a14888) +++ src/prelude/extras.c (revision e2b17a4439069fc5076a980015bdd7f368faf252) @@ -1,3 +1,4 @@ #include // size_t, ptrdiff_t +#include // intX_t, uintX_t, where X is 8, 16, 32, 64 #include // char16_t, char32_t #include // wchar_t Index: src/prelude/extras.regx =================================================================== --- src/prelude/extras.regx (revision 206de5ab2b76ee44636062f62bc9a1ff10a14888) +++ src/prelude/extras.regx (revision e2b17a4439069fc5076a980015bdd7f368faf252) @@ -1,4 +1,12 @@ typedef.* size_t; typedef.* ptrdiff_t; +typedef.* int8_t; +typedef.* int16_t; +typedef.* int32_t; +typedef.* int64_t; +typedef.* uint8_t; +typedef.* uint16_t; +typedef.* uint32_t; +typedef.* uint64_t; typedef.* char16_t; typedef.* char32_t; Index: src/prelude/prelude.cf =================================================================== --- src/prelude/prelude.cf (revision 206de5ab2b76ee44636062f62bc9a1ff10a14888) +++ src/prelude/prelude.cf (revision e2b17a4439069fc5076a980015bdd7f368faf252) @@ -7,6 +7,6 @@ // Created On : Sat Nov 29 07:23:41 2014 // Last Modified By : Peter A. Buhr -// Last Modified On : Wed Aug 30 07:56:07 2017 -// Update Count : 93 +// Last Modified On : Mon Sep 25 18:12:15 2017 +// Update Count : 95 // @@ -558,4 +558,6 @@ signed long long int ?+=?( signed long long int &, signed long long int ), ?+=?( volatile signed long long int &, signed long long int ); unsigned long long int ?+=?( unsigned long long int &, unsigned long long int ), ?+=?( volatile unsigned long long int &, unsigned long long int ); +signed int128 ?+=?( signed int128 &, signed int128 ), ?+=?( volatile signed int128 &, signed int128 ); +unsigned int128 ?+=?( unsigned int128 &, unsigned int128 ), ?+=?( volatile unsigned int128 &, unsigned int128 ); _Bool ?-=?( _Bool &, _Bool ), ?-=?( volatile _Bool &, _Bool ); Index: src/tests/.expect/64/literals.txt =================================================================== --- src/tests/.expect/64/literals.txt (revision 206de5ab2b76ee44636062f62bc9a1ff10a14888) +++ src/tests/.expect/64/literals.txt (revision e2b17a4439069fc5076a980015bdd7f368faf252) @@ -150,4 +150,5 @@ } + { signed int _index1 = ((signed int )0); @@ -157,4 +158,5 @@ } + } static inline void ___constructor__F_R9sofstream9sofstream_autogen___1(struct ofstream *___dst__R9sofstream_1, struct ofstream ___src__9sofstream_1){ @@ -171,4 +173,5 @@ } + { signed int _index3 = ((signed int )0); @@ -178,4 +181,5 @@ } + } static inline void ___destructor__F_R9sofstream_autogen___1(struct ofstream *___dst__R9sofstream_1){ @@ -187,4 +191,5 @@ } + { signed int _index5 = ((signed int )(((signed int )__sepSize__C13e__anonymous0_1)-1)); @@ -194,4 +199,5 @@ } + ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1) /* ^?{} */); ((void)((*___dst__R9sofstream_1).__sawNL__b_1) /* ^?{} */); @@ -239,4 +245,5 @@ } + { signed int _index9 = ((signed int )0); @@ -246,4 +253,5 @@ } + } static inline void ___constructor__F_R9sofstreamPvb_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1){ @@ -260,4 +268,5 @@ } + { signed int _index11 = ((signed int )0); @@ -267,4 +276,5 @@ } + } static inline void ___constructor__F_R9sofstreamPvbb_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1){ @@ -281,4 +291,5 @@ } + { signed int _index13 = ((signed int )0); @@ -288,4 +299,5 @@ } + } static inline void ___constructor__F_R9sofstreamPvbbb_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1, _Bool __sawNL__b_1){ @@ -302,4 +314,5 @@ } + { signed int _index15 = ((signed int )0); @@ -309,4 +322,5 @@ } + } static inline void ___constructor__F_R9sofstreamPvbbbPCc_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1, _Bool __sawNL__b_1, const char *__sepCur__PCc_1){ @@ -323,4 +337,5 @@ } + { signed int _index17 = ((signed int )0); @@ -330,4 +345,5 @@ } + } static inline void ___constructor__F_R9sofstreamPvbbbPCcA0c_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1, _Bool __sawNL__b_1, const char *__sepCur__PCc_1, char __separator__A0c_1[((unsigned long int )__sepSize__C13e__anonymous0_1)]){ @@ -344,4 +360,5 @@ } + { signed int _index19 = ((signed int )0); @@ -351,4 +368,5 @@ } + } static inline void ___constructor__F_R9sofstreamPvbbbPCcA0cA0c_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1, _Bool __sawNL__b_1, const char *__sepCur__PCc_1, char __separator__A0c_1[((unsigned long int )__sepSize__C13e__anonymous0_1)], char __tupleSeparator__A0c_1[((unsigned long int )__sepSize__C13e__anonymous0_1)]){ @@ -365,4 +383,5 @@ } + { signed int _index21 = ((signed int )0); @@ -372,4 +391,5 @@ } + } _Bool __sepPrt__Fb_P9sofstream__1(struct ofstream *__anonymous_object1294); @@ -708,10 +728,10 @@ ((void)0123456789.e-09L); ((void)0123456789.e-09DL); - ((void)(-0123456789.e-09)); - ((void)(-0123456789.e-09f)); - ((void)(-0123456789.e-09l)); - ((void)(-0123456789.e-09F)); - ((void)(-0123456789.e-09L)); - ((void)(-0123456789.e-09DL)); + ((void)(+0123456789.e-09)); + ((void)(+0123456789.e-09f)); + ((void)(+0123456789.e-09l)); + ((void)(+0123456789.e-09F)); + ((void)(+0123456789.e-09L)); + ((void)(+0123456789.e-09DL)); ((void)(-0123456789.e-09)); ((void)(-0123456789.e-09f)); @@ -852,10 +872,10 @@ ((void)0123456789.0123456789E-09L); ((void)0123456789.0123456789E-09DL); - ((void)(-0123456789.0123456789E-09)); - ((void)(-0123456789.0123456789E-09f)); - ((void)(-0123456789.0123456789E-09l)); - ((void)(-0123456789.0123456789E-09F)); - ((void)(-0123456789.0123456789E-09L)); - ((void)(-0123456789.0123456789E-09DL)); + ((void)(+0123456789.0123456789E-09)); + ((void)(+0123456789.0123456789E-09f)); + ((void)(+0123456789.0123456789E-09l)); + ((void)(+0123456789.0123456789E-09F)); + ((void)(+0123456789.0123456789E-09L)); + ((void)(+0123456789.0123456789E-09DL)); ((void)(-0123456789.0123456789E-09)); ((void)(-0123456789.0123456789E-09f)); @@ -899,9 +919,9 @@ ((void)0x0123456789.p-09F); ((void)0x0123456789.p-09L); - ((void)(-0x0123456789.p-09)); - ((void)(-0x0123456789.p-09f)); - ((void)(-0x0123456789.p-09l)); - ((void)(-0x0123456789.p-09F)); - ((void)(-0x0123456789.p-09L)); + ((void)(+0x0123456789.p-09)); + ((void)(+0x0123456789.p-09f)); + ((void)(+0x0123456789.p-09l)); + ((void)(+0x0123456789.p-09F)); + ((void)(+0x0123456789.p-09L)); ((void)(-0x0123456789.p-09)); ((void)(-0x0123456789.p-09f)); @@ -944,9 +964,9 @@ ((void)0x.0123456789P-09F); ((void)0x.0123456789P-09L); - ((void)(-0x.0123456789P-09)); - ((void)(-0x.0123456789P-09f)); - ((void)(-0x.0123456789P-09l)); - ((void)(-0x.0123456789P-09F)); - ((void)(-0x.0123456789P-09L)); + ((void)(+0x.0123456789P-09)); + ((void)(+0x.0123456789P-09f)); + ((void)(+0x.0123456789P-09l)); + ((void)(+0x.0123456789P-09F)); + ((void)(+0x.0123456789P-09L)); ((void)(-0x.0123456789P-09)); ((void)(-0x.0123456789P-09f)); @@ -989,4 +1009,9 @@ ((void)0X0123456789.0123456789P-09F); ((void)0X0123456789.0123456789P-09L); + ((void)(+0X0123456789.0123456789P-09)); + ((void)(+0X0123456789.0123456789P-09f)); + ((void)(+0X0123456789.0123456789P-09l)); + ((void)(+0X0123456789.0123456789P-09F)); + ((void)(+0X0123456789.0123456789P-09L)); ((void)(-0X0123456789.0123456789P-09)); ((void)(-0X0123456789.0123456789P-09f)); @@ -994,13 +1019,240 @@ ((void)(-0X0123456789.0123456789P-09F)); ((void)(-0X0123456789.0123456789P-09L)); - ((void)(-0X0123456789.0123456789P-09)); - ((void)(-0X0123456789.0123456789P-09f)); - ((void)(-0X0123456789.0123456789P-09l)); - ((void)(-0X0123456789.0123456789P-09F)); - ((void)(-0X0123456789.0123456789P-09L)); + ((void)((signed char )01234567)); + ((void)((signed short int )01234567)); + ((void)((signed int )01234567)); + ((void)((signed long int )01234567)); + ((void)((__int128 )01234567)); + ((void)((unsigned char )01234567u)); + ((void)((signed short int )01234567u)); + ((void)((unsigned int )01234567u)); + ((void)((signed long int )01234567u)); + ((void)((__int128 )01234567u)); + ((void)(+((signed int )((signed char )01234567)))); + ((void)(+((signed int )((signed short int )01234567)))); + ((void)(+((signed int )01234567))); + ((void)(+((signed long int )01234567))); + ((void)(+((float )((__int128 )01234567)))); + ((void)(+((signed int )((unsigned char )01234567u)))); + ((void)(+((signed int )((signed short int )01234567u)))); + ((void)(+((unsigned int )01234567u))); + ((void)(+((signed long int )01234567u))); + ((void)(+((float )((__int128 )01234567u)))); + ((void)(-((signed int )((signed char )01234567)))); + ((void)(-((signed int )((signed short int )01234567)))); + ((void)(-((signed int )01234567))); + ((void)(-((signed long int )01234567))); + ((void)(-((float )((__int128 )01234567)))); + ((void)(-((signed int )((unsigned char )01234567u)))); + ((void)(-((signed int )((signed short int )01234567u)))); + ((void)(-((unsigned int )01234567u))); + ((void)(-((signed long int )01234567u))); + ((void)(-((float )((__int128 )01234567u)))); + ((void)((signed char )1234567890)); + ((void)((signed short int )1234567890)); + ((void)((signed int )1234567890)); + ((void)((signed long int )1234567890)); + ((void)((__int128 )1234567890)); + ((void)((signed char )1234567890U)); + ((void)((unsigned short int )1234567890U)); + ((void)((signed int )1234567890U)); + ((void)((unsigned long int )1234567890u)); + ((void)((unsigned __int128 )1234567890u)); + ((void)(+((signed int )((signed char )1234567890)))); + ((void)(+((signed int )((signed short int )1234567890)))); + ((void)(+((signed int )1234567890))); + ((void)(+((signed long int )1234567890))); + ((void)(+((float )((__int128 )1234567890)))); + ((void)(+((signed int )((signed char )1234567890U)))); + ((void)(+((signed int )((unsigned short int )1234567890U)))); + ((void)(+((signed int )1234567890U))); + ((void)(+((unsigned long int )1234567890u))); + ((void)(+((float )((unsigned __int128 )1234567890u)))); + ((void)(-((signed int )((signed char )1234567890)))); + ((void)(-((signed int )((signed short int )1234567890)))); + ((void)(-((signed int )1234567890))); + ((void)(-((signed long int )1234567890))); + ((void)(-((float )((__int128 )1234567890)))); + ((void)(-((signed int )((signed char )1234567890U)))); + ((void)(-((signed int )((unsigned short int )1234567890U)))); + ((void)(-((signed int )1234567890U))); + ((void)(-((unsigned long int )1234567890u))); + ((void)(-((float )((unsigned __int128 )1234567890u)))); + ((void)((signed char )0x0123456789abcdef)); + ((void)((signed short int )0x0123456789abcdef)); + ((void)((signed int )0x0123456789abcdef)); + ((void)((signed long int )0x0123456789abcdef)); + ((void)((signed char )0x0123456789abcdefu)); + ((void)((unsigned short int )0x0123456789abcdefu)); + ((void)((signed int )0x0123456789abcdefu)); + ((void)((unsigned long int )0x0123456789abcdefu)); + ((void)(+((signed int )((signed char )0x0123456789abcdef)))); + ((void)(+((signed int )((signed short int )0x0123456789abcdef)))); + ((void)(+((signed int )0x0123456789abcdef))); + ((void)(+((signed long int )0x0123456789abcdef))); + ((void)(+((signed int )((signed char )0x0123456789abcdefu)))); + ((void)(+((signed int )((unsigned short int )0x0123456789abcdefu)))); + ((void)(+((signed int )0x0123456789abcdefu))); + ((void)(+((unsigned long int )0x0123456789abcdefu))); + ((void)(-((signed int )((signed char )0x0123456789abcdef)))); + ((void)(-((signed int )((signed short int )0x0123456789abcdef)))); + ((void)(-((signed int )0x0123456789abcdef))); + ((void)(-((signed long int )0x0123456789abcdef))); + ((void)(-((signed int )((signed char )0x0123456789abcdefu)))); + ((void)(-((signed int )((unsigned short int )0x0123456789abcdefu)))); + ((void)(-((signed int )0x0123456789abcdefu))); + ((void)(-((unsigned long int )0x0123456789abcdefu))); + ((void)((signed char )0x0123456789ABCDEF)); + ((void)((signed short int )0x0123456789ABCDEF)); + ((void)((signed int )0x0123456789ABCDEF)); + ((void)((signed long int )0x0123456789ABCDEF)); + ((void)((signed char )0x0123456789ABCDEFu)); + ((void)((unsigned short int )0x0123456789ABCDEFu)); + ((void)((signed int )0x0123456789ABCDEFu)); + ((void)((unsigned long int )0x0123456789ABCDEFu)); + ((void)(+((signed int )((signed char )0x0123456789ABCDEF)))); + ((void)(+((signed int )((signed short int )0x0123456789ABCDEF)))); + ((void)(+((signed int )0x0123456789ABCDEF))); + ((void)(+((signed long int )0x0123456789ABCDEF))); + ((void)(+((signed int )((signed char )0x0123456789ABCDEFu)))); + ((void)(+((signed int )((unsigned short int )0x0123456789ABCDEFu)))); + ((void)(+((signed int )0x0123456789ABCDEFu))); + ((void)(+((unsigned long int )0x0123456789ABCDEFu))); + ((void)(-((signed int )((signed char )0x0123456789ABCDEF)))); + ((void)(-((signed int )((signed short int )0x0123456789ABCDEF)))); + ((void)(-((signed int )0x0123456789ABCDEF))); + ((void)(-((signed long int )0x0123456789ABCDEF))); + ((void)(-((signed int )((signed char )0x0123456789ABCDEFu)))); + ((void)(-((signed int )((unsigned short int )0x0123456789ABCDEFu)))); + ((void)(-((signed int )0x0123456789ABCDEFu))); + ((void)(-((unsigned long int )0x0123456789ABCDEFu))); + ((void)((signed char )0X0123456789abcdef)); + ((void)((signed short int )0X0123456789abcdef)); + ((void)((signed int )0X0123456789abcdef)); + ((void)((signed long int )0X0123456789abcdef)); + ((void)((signed char )0X0123456789abcdefu)); + ((void)((unsigned short int )0X0123456789abcdefu)); + ((void)((signed int )0X0123456789abcdefu)); + ((void)((unsigned long int )0X0123456789abcdefu)); + ((void)(+((signed int )((signed char )0X0123456789abcdef)))); + ((void)(+((signed int )((signed short int )0X0123456789abcdef)))); + ((void)(+((signed int )0X0123456789abcdef))); + ((void)(+((signed long int )0X0123456789abcdef))); + ((void)(+((signed int )((signed char )0X0123456789abcdefu)))); + ((void)(+((signed int )((unsigned short int )0X0123456789abcdefu)))); + ((void)(+((signed int )0X0123456789abcdefu))); + ((void)(+((unsigned long int )0X0123456789abcdefu))); + ((void)(-((signed int )((signed char )0X0123456789abcdef)))); + ((void)(-((signed int )((signed short int )0X0123456789abcdef)))); + ((void)(-((signed int )0X0123456789abcdef))); + ((void)(-((signed long int )0X0123456789abcdef))); + ((void)(-((signed int )((signed char )0X0123456789abcdefu)))); + ((void)(-((signed int )((unsigned short int )0X0123456789abcdefu)))); + ((void)(-((signed int )0X0123456789abcdefu))); + ((void)(-((unsigned long int )0X0123456789abcdefu))); + ((void)((signed char )0X0123456789ABCDEF)); + ((void)((signed short int )0X0123456789ABCDEF)); + ((void)((signed int )0X0123456789ABCDEF)); + ((void)((signed long int )0X0123456789ABCDEF)); + ((void)((signed char )0X0123456789ABCDEFu)); + ((void)((unsigned short int )0X0123456789ABCDEFu)); + ((void)((signed int )0X0123456789ABCDEFu)); + ((void)((unsigned long int )0X0123456789ABCDEFu)); + ((void)(+((signed int )((signed char )0X0123456789ABCDEF)))); + ((void)(+((signed int )((signed short int )0X0123456789ABCDEF)))); + ((void)(+((signed int )0X0123456789ABCDEF))); + ((void)(+((signed long int )0X0123456789ABCDEF))); + ((void)(+((signed int )((signed char )0X0123456789ABCDEFu)))); + ((void)(+((signed int )((unsigned short int )0X0123456789ABCDEFu)))); + ((void)(+((signed int )0X0123456789ABCDEFu))); + ((void)(+((unsigned long int )0X0123456789ABCDEFu))); + ((void)(-((signed int )((signed char )0X0123456789ABCDEF)))); + ((void)(-((signed int )((signed short int )0X0123456789ABCDEF)))); + ((void)(-((signed int )0X0123456789ABCDEF))); + ((void)(-((signed long int )0X0123456789ABCDEF))); + ((void)(-((signed int )((signed char )0X0123456789ABCDEFu)))); + ((void)(-((signed int )((unsigned short int )0X0123456789ABCDEFu)))); + ((void)(-((signed int )0X0123456789ABCDEFu))); + ((void)(-((unsigned long int )0X0123456789ABCDEFu))); + ((void)((float )0123456789.)); + ((void)((double )0123456789.)); + ((void)((long double )0123456789.)); + ((void)((long double )0123456789.)); + ((void)(+((float )0123456789.))); + ((void)(+((double )0123456789.))); + ((void)(+((long double )0123456789.))); + ((void)(+((long double )0123456789.))); + ((void)(-((float )0123456789.))); + ((void)(-((double )0123456789.))); + ((void)(-((long double )0123456789.))); + ((void)(-((long double )0123456789.))); + ((void)((float )0123456789.e09)); + ((void)((double )0123456789.e09)); + ((void)((long double )0123456789.e09)); + ((void)((long double )0123456789.e09)); + ((void)(+((float )0123456789.e+09))); + ((void)(+((double )0123456789.e+09))); + ((void)(+((long double )0123456789.e+09))); + ((void)(+((long double )0123456789.e+09))); + ((void)(-((float )0123456789.e-09))); + ((void)(-((double )0123456789.e-09))); + ((void)(-((long double )0123456789.e-09))); + ((void)(-((long double )0123456789.e-09))); + ((void)((float ).0123456789e09)); + ((void)((double ).0123456789e09)); + ((void)((long double ).0123456789e09)); + ((void)((long double ).0123456789e09)); + ((void)(+((float ).0123456789E+09))); + ((void)(+((double ).0123456789E+09))); + ((void)(+((long double ).0123456789E+09))); + ((void)(+((long double ).0123456789E+09))); + ((void)(-((float ).0123456789E-09))); + ((void)(-((double ).0123456789E-09))); + ((void)(-((long double ).0123456789E-09))); + ((void)(-((long double ).0123456789E-09))); + ((void)((float )0123456789.0123456789)); + ((void)((double )0123456789.0123456789)); + ((void)((long double )0123456789.0123456789)); + ((void)((long double )0123456789.0123456789)); + ((void)(+((float )0123456789.0123456789E09))); + ((void)(+((double )0123456789.0123456789E09))); + ((void)(+((long double )0123456789.0123456789E09))); + ((void)(+((long double )0123456789.0123456789E09))); + ((void)(-((float )0123456789.0123456789E+09))); + ((void)(-((double )0123456789.0123456789E+09))); + ((void)(-((long double )0123456789.0123456789E+09))); + ((void)(-((long double )0123456789.0123456789E+09))); + ((void)((float )0123456789.0123456789E-09)); + ((void)((double )0123456789.0123456789E-09)); + ((void)((long double )0123456789.0123456789E-09)); + ((void)((long double )0123456789.0123456789E-09)); + ((void)((float )0x0123456789.p09)); + ((void)((double )0x0123456789.p09)); + ((void)((long double )0x0123456789.p09)); + ((void)((long double )0x0123456789.p09)); + ((void)(+((float )0x0123456789.p09))); + ((void)(+((double )0x0123456789.p09))); + ((void)(+((long double )0x0123456789.p09))); + ((void)(+((long double )0x0123456789.p09))); + ((void)(-((float )0x0123456789.p09))); + ((void)(-((double )0x0123456789.p09))); + ((void)(-((long double )0x0123456789.p09))); + ((void)(-((long double )0x0123456789.p09))); + ((void)((float )0x0123456789.p+09)); + ((void)((double )0x0123456789.p+09)); + ((void)((long double )0x0123456789.p+09)); + ((void)((long double )0x0123456789.p+09)); + ((void)(+((float )0x0123456789.p-09))); + ((void)(+((double )0x0123456789.p-09))); + ((void)(+((long double )0x0123456789.p-09))); + ((void)(+((long double )0x0123456789.p-09))); + ((void)(-((float )0x.0123456789p09))); + ((void)(-((double )0x.0123456789p09))); + ((void)(-((long double )0x.0123456789p09))); + ((void)(-((long double )0x.0123456789p09))); ((void)__f__F_c__1('a')); - ((void)__f__F_Sc__1(20)); + ((void)__f__F_Sc__1(((signed char )20))); ((void)__f__F_Uc__1(((unsigned char )21u))); - ((void)__f__F_s__1(22)); + ((void)__f__F_s__1(((signed short int )22))); ((void)__f__F_Us__1(((unsigned short int )23u))); ((void)__f__F_Ul__1(((unsigned long int )24))); Index: src/tests/literals.c =================================================================== --- src/tests/literals.c (revision 206de5ab2b76ee44636062f62bc9a1ff10a14888) +++ src/tests/literals.c (revision e2b17a4439069fc5076a980015bdd7f368faf252) @@ -10,9 +10,10 @@ // Created On : Sat Sep 9 16:34:38 2017 // Last Modified By : Peter A. Buhr -// Last Modified On : Tue Sep 12 07:45:46 2017 -// Update Count : 88 +// Last Modified On : Mon Sep 25 20:26:00 2017 +// Update Count : 132 // #ifdef __CFA__ +#include #include @@ -72,5 +73,5 @@ 0123456789.e-09; 0123456789.e-09f; 0123456789.e-09l; 0123456789.e-09F; 0123456789.e-09L; 0123456789.e-09DL; - -0123456789.e-09; -0123456789.e-09f; -0123456789.e-09l; -0123456789.e-09F; -0123456789.e-09L; -0123456789.e-09DL; + +0123456789.e-09; +0123456789.e-09f; +0123456789.e-09l; +0123456789.e-09F; +0123456789.e-09L; +0123456789.e-09DL; -0123456789.e-09; -0123456789.e-09f; -0123456789.e-09l; -0123456789.e-09F; -0123456789.e-09L; -0123456789.e-09DL; @@ -104,5 +105,5 @@ 0123456789.0123456789E-09; 0123456789.0123456789E-09f; 0123456789.0123456789E-09l; 0123456789.0123456789E-09F; 0123456789.0123456789E-09L; 0123456789.0123456789E-09DL; - -0123456789.0123456789E-09; -0123456789.0123456789E-09f; -0123456789.0123456789E-09l; -0123456789.0123456789E-09F; -0123456789.0123456789E-09L; -0123456789.0123456789E-09DL; + +0123456789.0123456789E-09; +0123456789.0123456789E-09f; +0123456789.0123456789E-09l; +0123456789.0123456789E-09F; +0123456789.0123456789E-09L; +0123456789.0123456789E-09DL; -0123456789.0123456789E-09; -0123456789.0123456789E-09f; -0123456789.0123456789E-09l; -0123456789.0123456789E-09F; -0123456789.0123456789E-09L; -0123456789.0123456789E-09DL; @@ -118,5 +119,5 @@ 0x0123456789.p-09; 0x0123456789.p-09f; 0x0123456789.p-09l; 0x0123456789.p-09F; 0x0123456789.p-09L; - -0x0123456789.p-09; -0x0123456789.p-09f; -0x0123456789.p-09l; -0x0123456789.p-09F; -0x0123456789.p-09L; + +0x0123456789.p-09; +0x0123456789.p-09f; +0x0123456789.p-09l; +0x0123456789.p-09F; +0x0123456789.p-09L; -0x0123456789.p-09; -0x0123456789.p-09f; -0x0123456789.p-09l; -0x0123456789.p-09F; -0x0123456789.p-09L; @@ -130,5 +131,5 @@ 0x.0123456789P-09; 0x.0123456789P-09f; 0x.0123456789P-09l; 0x.0123456789P-09F; 0x.0123456789P-09L; - -0x.0123456789P-09; -0x.0123456789P-09f; -0x.0123456789P-09l; -0x.0123456789P-09F; -0x.0123456789P-09L; + +0x.0123456789P-09; +0x.0123456789P-09f; +0x.0123456789P-09l; +0x.0123456789P-09F; +0x.0123456789P-09L; -0x.0123456789P-09; -0x.0123456789P-09f; -0x.0123456789P-09l; -0x.0123456789P-09F; -0x.0123456789P-09L; @@ -142,10 +143,65 @@ 0X0123456789.0123456789P-09; 0X0123456789.0123456789P-09f; 0X0123456789.0123456789P-09l; 0X0123456789.0123456789P-09F; 0X0123456789.0123456789P-09L; + +0X0123456789.0123456789P-09; +0X0123456789.0123456789P-09f; +0X0123456789.0123456789P-09l; +0X0123456789.0123456789P-09F; +0X0123456789.0123456789P-09L; -0X0123456789.0123456789P-09; -0X0123456789.0123456789P-09f; -0X0123456789.0123456789P-09l; -0X0123456789.0123456789P-09F; -0X0123456789.0123456789P-09L; - -0X0123456789.0123456789P-09; -0X0123456789.0123456789P-09f; -0X0123456789.0123456789P-09l; -0X0123456789.0123456789P-09F; -0X0123456789.0123456789P-09L; + +#ifdef __CFA__ +// fixed-size length + + // octal + 01234567_l8; 01234567_l16; 01234567_l32; 01234567_l64; 01234567_l128; 01234567_l8u; 01234567_ul16; 01234567_l32u; 01234567_ul64; 01234567_ul128; + +01234567_l8; +01234567_l16; +01234567_l32; +01234567_l64; +01234567_l128; +01234567_l8u; +01234567_ul16; +01234567_l32u; +01234567_ul64; +01234567_ul128; + -01234567_l8; -01234567_l16; -01234567_l32; -01234567_l64; -01234567_l128; -01234567_l8u; -01234567_ul16; -01234567_l32u; -01234567_ul64; -01234567_ul128; + + // decimal + 1234567890L8; 1234567890L16; 1234567890l32; 1234567890l64; 1234567890l128; 1234567890UL8; 1234567890L16U; 1234567890Ul32; 1234567890l64u; 1234567890l128u; + +1234567890L8; +1234567890L16; +1234567890l32; +1234567890l64; +1234567890l128; +1234567890UL8; +1234567890L16U; +1234567890Ul32; +1234567890l64u; +1234567890l128u; + -1234567890L8; -1234567890L16; -1234567890l32; -1234567890l64; -1234567890l128; -1234567890UL8; -1234567890L16U; -1234567890Ul32; -1234567890l64u; -1234567890l128u; + + // hexadecimal + 0x0123456789abcdef_l8; 0x0123456789abcdef_l16; 0x0123456789abcdefl32; 0x0123456789abcdefl64; 0x0123456789abcdef_ul8; 0x0123456789abcdef_l16u; 0x0123456789abcdeful32; 0x0123456789abcdefl64u; + +0x0123456789abcdef_l8; +0x0123456789abcdef_l16; +0x0123456789abcdefl32; +0x0123456789abcdefl64; +0x0123456789abcdef_ul8; +0x0123456789abcdef_l16u; +0x0123456789abcdeful32; +0x0123456789abcdefl64u; + -0x0123456789abcdef_l8; -0x0123456789abcdef_l16; -0x0123456789abcdefl32; -0x0123456789abcdefl64; -0x0123456789abcdef_ul8; -0x0123456789abcdef_l16u; -0x0123456789abcdeful32; -0x0123456789abcdefl64u; + + 0x0123456789ABCDEF_l8; 0x0123456789ABCDEF_l16; 0x0123456789ABCDEFl32; 0x0123456789ABCDEFl64; 0x0123456789ABCDEF_ul8; 0x0123456789ABCDEF_l16u; 0x0123456789ABCDEFul32; 0x0123456789ABCDEFl64u; + +0x0123456789ABCDEF_l8; +0x0123456789ABCDEF_l16; +0x0123456789ABCDEFl32; +0x0123456789ABCDEFl64; +0x0123456789ABCDEF_ul8; +0x0123456789ABCDEF_l16u; +0x0123456789ABCDEFul32; +0x0123456789ABCDEFl64u; + -0x0123456789ABCDEF_l8; -0x0123456789ABCDEF_l16; -0x0123456789ABCDEFl32; -0x0123456789ABCDEFl64; -0x0123456789ABCDEF_ul8; -0x0123456789ABCDEF_l16u; -0x0123456789ABCDEFul32; -0x0123456789ABCDEFl64u; + + 0X0123456789abcdef_l8; 0X0123456789abcdef_l16; 0X0123456789abcdefl32; 0X0123456789abcdefl64; 0X0123456789abcdef_ul8; 0X0123456789abcdef_l16u; 0X0123456789abcdeful32; 0X0123456789abcdefl64u; + +0X0123456789abcdef_l8; +0X0123456789abcdef_l16; +0X0123456789abcdefl32; +0X0123456789abcdefl64; +0X0123456789abcdef_ul8; +0X0123456789abcdef_l16u; +0X0123456789abcdeful32; +0X0123456789abcdefl64u; + -0X0123456789abcdef_l8; -0X0123456789abcdef_l16; -0X0123456789abcdefl32; -0X0123456789abcdefl64; -0X0123456789abcdef_ul8; -0X0123456789abcdef_l16u; -0X0123456789abcdeful32; -0X0123456789abcdefl64u; + + 0X0123456789ABCDEF_l8; 0X0123456789ABCDEF_l16; 0X0123456789ABCDEFl32; 0X0123456789ABCDEFl64; 0X0123456789ABCDEF_ul8; 0X0123456789ABCDEF_l16u; 0X0123456789ABCDEFul32; 0X0123456789ABCDEFl64u; + +0X0123456789ABCDEF_l8; +0X0123456789ABCDEF_l16; +0X0123456789ABCDEFl32; +0X0123456789ABCDEFl64; +0X0123456789ABCDEF_ul8; +0X0123456789ABCDEF_l16u; +0X0123456789ABCDEFul32; +0X0123456789ABCDEFl64u; + -0X0123456789ABCDEF_l8; -0X0123456789ABCDEF_l16; -0X0123456789ABCDEFl32; -0X0123456789ABCDEFl64; -0X0123456789ABCDEF_ul8; -0X0123456789ABCDEF_l16u; -0X0123456789ABCDEFul32; -0X0123456789ABCDEFl64u; + + // floating + 0123456789.l32; 0123456789.l64; 0123456789.l80; 0123456789.l128; + +0123456789.l32; +0123456789.l64; +0123456789.l80; +0123456789.l128; + -0123456789.l32; -0123456789.l64; -0123456789.l80; -0123456789.l128; + + 0123456789.e09L32; 0123456789.e09L64; 0123456789.e09L80; 0123456789.e09L128; + +0123456789.e+09L32; +0123456789.e+09L64; +0123456789.e+09L80; +0123456789.e+09L128; + -0123456789.e-09L32; -0123456789.e-09L64; -0123456789.e-09L80; -0123456789.e-09L128; + + .0123456789e09L32; .0123456789e09L64; .0123456789e09L80; .0123456789e09L128; + +.0123456789E+09L32; +.0123456789E+09L64; +.0123456789E+09L80; +.0123456789E+09L128; + -.0123456789E-09L32; -.0123456789E-09L64; -.0123456789E-09L80; -.0123456789E-09L128; + + 0123456789.0123456789L32; 0123456789.0123456789L64; 0123456789.0123456789L80; 0123456789.0123456789L128; + +0123456789.0123456789E09L32; +0123456789.0123456789E09L64; +0123456789.0123456789E09L80; +0123456789.0123456789E09L128; + -0123456789.0123456789E+09L32; -0123456789.0123456789E+09L64; -0123456789.0123456789E+09L80; -0123456789.0123456789E+09L128; + 0123456789.0123456789E-09L32; 0123456789.0123456789E-09L64; 0123456789.0123456789E-09L80; 0123456789.0123456789E-09L128; + + 0x0123456789.p09l32; 0x0123456789.p09l64; 0x0123456789.p09l80; 0x0123456789.p09l128; + +0x0123456789.p09l32; +0x0123456789.p09l64; +0x0123456789.p09l80; +0x0123456789.p09l128; + -0x0123456789.p09l32; -0x0123456789.p09l64; -0x0123456789.p09l80; -0x0123456789.p09l128; + + 0x0123456789.p+09l32; 0x0123456789.p+09L64; 0x0123456789.p+09L80; 0x0123456789.p+09L128; + +0x0123456789.p-09l32; +0x0123456789.p-09L64; +0x0123456789.p-09L80; +0x0123456789.p-09L128; + -0x.0123456789p09l32; -0x.0123456789p09L64; -0x.0123456789p09L80; -0x.0123456789p09L128; // char, short, int suffix overloading -#ifdef __CFA__ f( 'a' ); f( 20_hh );