Index: Jenkins/FullBuild =================================================================== --- Jenkins/FullBuild (revision ff98952225b16a68fb22c007b5495c78ef23158e) +++ Jenkins/FullBuild (revision 4a3685479ce3ea742a9282c31d31ce031849e49c) @@ -161,5 +161,5 @@ """ - def email_to = "pabuhr@uwaterloo.ca, rschlunt@uwaterloo.ca, a3moss@uwaterloo.ca, tdelisle@uwaterloo.ca, brice.dobry@huawei.com, ajbeach@edu.uwaterloo.ca" + def email_to = "cforall@lists.uwaterloo.ca" //send email notification Index: Jenkinsfile =================================================================== --- Jenkinsfile (revision ff98952225b16a68fb22c007b5495c78ef23158e) +++ Jenkinsfile (revision 4a3685479ce3ea742a9282c31d31ce031849e49c) @@ -28,5 +28,5 @@ wrap([$class: 'TimestamperBuildWrapper']) { - notify_server() + notify_server(0) prepare_build() @@ -34,4 +34,6 @@ checkout() + notify_server(0) + build() @@ -46,5 +48,5 @@ publish() - notify_server() + notify_server(45) } } @@ -171,6 +173,6 @@ } -def notify_server() { - sh 'curl --silent -X POST http://plg2:8082/jenkins/notify > /dev/null || true' +def notify_server(int wait) { + sh """curl --silent --data "wait=${wait}" -X POST http://plg2:8082/jenkins/notify > /dev/null || true""" return } @@ -374,5 +376,5 @@ """ - def email_to = "pabuhr@uwaterloo.ca, rschlunt@uwaterloo.ca, a3moss@uwaterloo.ca, tdelisle@uwaterloo.ca, brice.dobry@huawei.com, ajbeach@edu.uwaterloo.ca" + def email_to = "cforall@lists.uwaterloo.ca" //send email notification Index: doc/LaTeXmacros/lstlang.sty =================================================================== --- doc/LaTeXmacros/lstlang.sty (revision ff98952225b16a68fb22c007b5495c78ef23158e) +++ doc/LaTeXmacros/lstlang.sty (revision 4a3685479ce3ea742a9282c31d31ce031849e49c) @@ -8,6 +8,6 @@ %% Created On : Sat May 13 16:34:42 2017 %% Last Modified By : Peter A. Buhr -%% Last Modified On : Sat May 13 16:49:09 2017 -%% Update Count : 4 +%% Last Modified On : Fri May 26 12:47:09 2017 +%% Update Count : 8 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% @@ -118,4 +118,12 @@ } +% uC++ programming language, based on ANSI C++ +\lstdefinelanguage{uC++}[ANSI]{C++}{ + morekeywords={ + _Accept, _AcceptReturn, _AcceptWait, _Actor, _At, _CatchResume, _Cormonitor, _Coroutine, _Disable, + _Else, _Enable, _Event, _Finally, _Monitor, _Mutex, _Nomutex, _PeriodicTask, _RealTimeTask, + _Resume, _Select, _SporadicTask, _Task, _Timeout, _When, _With, _Throw}, +} + % Local Variables: % % tab-width: 4 % Index: doc/bibliography/cfa.bib =================================================================== --- doc/bibliography/cfa.bib (revision ff98952225b16a68fb22c007b5495c78ef23158e) +++ doc/bibliography/cfa.bib (revision 4a3685479ce3ea742a9282c31d31ce031849e49c) @@ -3035,4 +3035,14 @@ year = 1992, pages = {T1-53}, +} + +@manual{GMP, + keywords = {GMP arbitrary-precision library}, + contributer = {pabuhr@plg}, + title = {{GNU} Multiple Precision Arithmetic Library}, + author = {GMP}, + organization= {GNU}, + year = 2016, + note = {\href{https://gmplib.org}{https://\-gmplib.org}}, } Index: doc/proposals/user_conversions.md =================================================================== --- doc/proposals/user_conversions.md (revision 4a3685479ce3ea742a9282c31d31ce031849e49c) +++ doc/proposals/user_conversions.md (revision 4a3685479ce3ea742a9282c31d31ce031849e49c) @@ -0,0 +1,205 @@ +## User-defined Conversions ## +C's implicit "usual arithmetic conversions" define a structure among the +built-in types consisting of _unsafe_ narrowing conversions and a hierarchy of +_safe_ widening conversions. +There is also a set of _explicit_ conversions that are only allowed through a +cast expression. +Based on Glen's notes on conversions [1], I propose that safe and unsafe +conversions be expressed as constructor variants, though I make explicit +(cast) conversions a constructor variant as well rather than a dedicated +operator. +Throughout this article, I will use the following operator names for +constructors and conversion functions from `From` to `To`: + + void ?{} ( To*, To ); // copy constructor + void ?{} ( To*, From ); // explicit constructor + void ?{explicit} ( To*, From ); // explicit cast conversion + void ?{safe} ( To*, From ); // implicit safe conversion + void ?{unsafe} ( To*, From ); // implicit unsafe conversion + +[1] http://plg.uwaterloo.ca/~cforall/Conversions/index.html + +Glen's design made no distinction between constructors and unsafe implicit +conversions; this is elegant, but interacts poorly with tuples. +Essentially, without making this distinction, a constructor like the following +would add an interpretation of any two `int`s as a `Coord`, needlessly +multiplying the space of possible interpretations of all functions: + + void ?{}( Coord *this, int x, int y ); + +That said, it would certainly be possible to make a multiple-argument implicit +conversion, as below, though the argument above suggests this option should be +used infrequently: + + void ?{unsafe}( Coord *this, int x, int y ); + +An alternate possibility would be to only count two-arg constructors +`void ?{} ( To*, From )` as unsafe conversions; under this semantics, safe and +explicit conversions should also have a compiler-enforced restriction to +ensure that they are two-arg functions (this restriction may be valuable +regardless). + +Regardless of syntax, there should be a type assertion that expresses `From` +is convertable to `To`. +If user-defined conversions are not added to the language, +`void ?{} ( To*, From )` may be a suitable representation, relying on +conversions on the argument types to account for transitivity. +On the other hand, `To*` should perhaps match its target type exactly, so +another assertion syntax specific to conversions may be required, e.g. +`From -> To`. + +### Constructor Idiom ### +Basing our notion of conversions off otherwise normal Cforall functions means +that we can use the full range of Cforall features for conversions, including +polymorphism. +Glen [1] defines a _constructor idiom_ that can be used to create chains of +safe conversions without duplicating code; given a type `Safe` which members +of another type `From` can be directly converted to, the constructor idiom +allows us to write a conversion for any type `To` which `Safe` converts to: + + forall(otype To | { void ?{safe}( To*, Safe ) }) + void ?{safe}( To *this, From that ) { + Safe tmp = /* some expression involving that */; + *this = tmp; // uses assertion parameter + } + +This idiom can also be used with only minor variations for a parallel set of +unsafe conversions. + +What selective non-use of the constructor idiom gives us is the ability to +define a conversion that may only be the *last* conversion in a chain of such. +Constructing a conversion graph able to unambiguously represent the full +hierarchy of implicit conversions in C is provably impossible using only +single-step conversions with no additional information (see Appendix A), but +this mechanism is sufficiently powerful (see [1], though the design there has +some minor bugs; the general idea is to use the constructor idiom to define +two chains of conversions, one among the signed integral types, another among +the unsigned, and to use monomorphic conversions to allow conversions between +signed and unsigned integer types). + +### Appendix A: Partial and Total Orders ### +The `<=` relation on integers is a commonly known _total order_, and +intuitions based on how it works generally apply well to other total orders. +Formally, a total order is some binary relation `<=` over a set `S` such that +for any two members `a` and `b` of `S`, `a <= b` or `b <= a` (if both, `a` and +`b` must be equal, the _antisymmetry_ property); total orders also have a +_transitivity_ property, that if `a <= b` and `b <= c`, then `a <= c`. +If `a` and `b` are distinct elements and `a <= b`, we may write `a < b`. + +A _partial order_ is a generalization of this concept where the `<=` relation +is not required to be defined over all pairs of elements in `S` (though there +is a _reflexivity_ requirement that for all `a` in `S`, `a <= a`); in other +words, it is possible for two elements `a` and `b` of `S` to be +_incomparable_, unable to be ordered with respect to one another (any `a` and +`b` for which either `a <= b` or `b <= a` are called _comparable_). +Antisymmetry and transitivity are also required for a partial order, so all +total orders are also partial orders by definition. +One fairly natural partial order is the "subset of" relation over sets from +the same universe; `{ }` is a subset of both `{ 1 }` and `{ 2 }`, which are +both subsets of `{ 1, 2 }`, but neither `{ 1 }` nor `{ 2 }` is a subset of the +other - they are incomparable under this relation. + +We can compose two (or more) partial orders to produce a new partial order on +tuples drawn from both (or all the) sets. +For example, given `a` and `c` from set `S` and `b` and `d` from set `R`, +where both `S` and `R` both have partial orders defined on them, we can define +a ordering relation between `(a, b)` and `(c, d)`. +One common order is the _lexicographical order_, where `(a, b) <= (c, d)` iff +`a < c` or both `a = c` and `b <= d`; this can be thought of as ordering by +the first set and "breaking ties" by the second set. +Another common order is the _product order_, which can be roughly thought of +as "all the components are ordered the same way"; formally `(a, b) <= (c, d)` +iff `a <= c` and `b <= d`. +One difference between the lexicographical order and the product order is that +in the lexicographical order if both `a` and `c` and `b` and `d` are +comparable then `(a, b)` and `(c, d)` will be comparable, while in the product +order you can have `a <= c` and `d <= b` (both comparable) which will make +`(a, b)` and `(c, d)` incomparable. +The product order, on the other hand, has the benefit of not prioritizing one +order over the other. + +Any partial order has a natural representation as a directed acyclic graph +(DAG). +Each element `a` of the set becomes a node of the DAG, with an arc pointing to +its _covering_ elements, any element `b` such that `a < b` but where there is +no `c` such that `a < c` and `c < b`. +Intuitively, the covering elements are the "next ones larger", where you can't +fit another element between the two. +Under this construction, `a < b` is equivalent to "there is a path from `a` to +`b` in the DAG", and the lack of cycles in the directed graph is ensured by +the antisymmetry property of the partial order. + +Partial orders can be generalized to _preorders_ by removing the antisymmetry +property. +In a preorder the relation is generally called `<~`, and it is possible for +two distict elements `a` and `b` to have `a <~ b` and `b <~ a` - in this case +we write `a ~ b`; `a <~ b` and not `a ~ b` is written `a < b`. +Preorders may also be represented as directed graphs, but in this case the +graph may contain cycles. + +### Appendix B: Building a Conversion Graph from Un-annotated Single Steps ### +The short answer is that it's impossible. + +The longer answer is that it has to do with what's essentially a diamond +inheritance problem. +In C, `int` converts to `unsigned int` and also `long` "safely"; both convert +to `unsigned long` safely, and it's possible to chain the conversions to +convert `int` to `unsigned long`. +There are two constraints here; one is that the `int` to `unsigned long` +conversion needs to cost more than the other two (because the types aren't as +"close" in a very intuitive fashion), and the other is that the system needs a +way to choose which path to take to get to the destination type. +Now, a fairly natural solution for this would be to just say "C knows how to +convert from `int` to `unsigned long`, so we just put in a direct conversion +and make the compiler smart enough to figure out the costs" - this is the +approach taken by the existing compipler, but given that in a user-defined +conversion proposal the users can build an arbitrary graph of conversions, +this case still needs to be handled. + +We can define a preorder over the types by saying that `a <~ b` if there +exists a chain of conversions from `a` to `b` (see Appendix A for description +of preorders and related constructs). +This preorder corresponds roughly to a more usual type-theoretic concept of +subtyping ("if I can convert `a` to `b`, `a` is a more specific type than +`b`"); however, since this graph is arbitrary, it may contain cycles, so if +there is also a path to convert `b` to `a` they are in some sense equivalently +specific. + +Now, to compare the cost of two conversion chains `(s, x1, x2, ... xn)` and +`(s, y1, y2, ... ym)`, we have both the length of the chains (`n` versus `m`) +and this conversion preorder over the destination types `xn` and `ym`. +We could define a preorder by taking chain length and breaking ties by the +conversion preorder, but this would lead to unexpected behaviour when closing +diamonds with an arm length of longer than 1. +Consider a set of types `A`, `B1`, `B2`, `C` with the arcs `A->B1`, `B1->B2`, +`B2->C`, and `A->C`. +If we are comparing conversions from `A` to both `B2` and `C`, we expect the +conversion to `B2` to be chosen because it's the more specific type under the +conversion preorder, but since its chain length is longer than the conversion +to `C`, it loses and `C` is chosen. +However, taking the conversion preorder and breaking ties or ambiguities by +chain length also doesn't work, because of cases like the following example +where the transitivity property is broken and we can't find a global maximum: + + `X->Y1->Y2`, `X->Z1->Z2->Z3->W`, `X->W` + +In this set of arcs, if we're comparing conversions from `X` to each of `Y2`, +`Z3` and `W`, converting to `Y2` is cheaper than converting to `Z3`, because +there are no conversions between `Y2` and `Z3`, and `Y2` has the shorter chain +length. +Also, comparing conversions from `X` to `Z3` and to `W`, we find that the +conversion to `Z3` is cheaper, because `Z3 < W` by the conversion preorder, +and so is considered to be the nearer type. +By transitivity, then, the conversion from `X` to `Y2` should be cheaper than +the conversion from `X` to `W`, but in this case the `X` and `W` are +incomparable by the conversion preorder, so the tie is broken by the shorter +path from `X` to `W` in favour of `W`, contradicting the transitivity property +for this proposed order. + +Without transitivity, we would need to compare all pairs of conversions, which +would be expensive, and possibly not yield a minimal-cost conversion even if +all pairs were comparable. +In short, this ordering is infeasible, and by extension I believe any ordering +composed solely of single-step conversions between types with no further +user-supplied information will be insufficiently powerful to express the +built-in conversions between C's types. Index: doc/user/user.tex =================================================================== --- doc/user/user.tex (revision ff98952225b16a68fb22c007b5495c78ef23158e) +++ doc/user/user.tex (revision 4a3685479ce3ea742a9282c31d31ce031849e49c) @@ -11,6 +11,6 @@ %% Created On : Wed Apr 6 14:53:29 2016 %% Last Modified By : Peter A. Buhr -%% Last Modified On : Sun May 21 23:36:42 2017 -%% Update Count : 1822 +%% Last Modified On : Wed May 24 22:21:42 2017 +%% Update Count : 1994 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% @@ -151,5 +151,5 @@ Like \Index*[C++]{\CC}, there may be both an old and new ways to achieve the same effect. -For example, the following programs compare the \CFA and C I/O mechanisms. +For example, the following programs compare the \CFA, C, nad \CC I/O mechanisms, where the programs output the same result. \begin{quote2} \begin{tabular}{@{}l@{\hspace{1.5em}}l@{\hspace{1.5em}}l@{}} @@ -183,5 +183,4 @@ \end{tabular} \end{quote2} -The programs output the same result. While the \CFA I/O looks similar to the \Index*[C++]{\CC} output style, there are important differences, such as automatic spacing between variables as in \Index*{Python} (see~\VRef{s:IOLibrary}). @@ -1426,5 +1425,28 @@ -\section{Type/Routine Nesting} +\section{Unnamed Structure Fields} + +C requires each field of a structure to have a name, except for a bit field associated with a basic type, \eg: +\begin{cfa} +struct { + int f1; §\C{// named field}§ + int f2 : 4; §\C{// named field with bit field size}§ + int : 3; §\C{// unnamed field for basic type with bit field size}§ + int ; §\C{// disallowed, unnamed field}§ + int *; §\C{// disallowed, unnamed field}§ + int (*)(int); §\C{// disallowed, unnamed field}§ +}; +\end{cfa} +This requirement is relaxed by making the field name optional for all field declarations; therefore, all the field declarations in the example are allowed. +As for unnamed bit fields, an unnamed field is used for padding a structure to a particular size. +A list of unnamed fields is also supported, \eg: +\begin{cfa} +struct { + int , , ; §\C{// 3 unnamed fields}§ +} +\end{cfa} + + +\section{Nesting} Nesting of types and routines is useful for controlling name visibility (\newterm{name hiding}). @@ -1796,27 +1818,4 @@ -\section{Unnamed Structure Fields} - -C requires each field of a structure to have a name, except for a bit field associated with a basic type, \eg: -\begin{cfa} -struct { - int f1; §\C{// named field}§ - int f2 : 4; §\C{// named field with bit field size}§ - int : 3; §\C{// unnamed field for basic type with bit field size}§ - int ; §\C{// disallowed, unnamed field}§ - int *; §\C{// disallowed, unnamed field}§ - int (*)(int); §\C{// disallowed, unnamed field}§ -}; -\end{cfa} -This requirement is relaxed by making the field name optional for all field declarations; therefore, all the field declarations in the example are allowed. -As for unnamed bit fields, an unnamed field is used for padding a structure to a particular size. -A list of unnamed fields is also supported, \eg: -\begin{cfa} -struct { - int , , ; §\C{// 3 unnamed fields}§ -} -\end{cfa} - - \section{Field Tuples} @@ -1861,58 +1860,33 @@ While C provides ©continue© and ©break© statements for altering control flow, both are restricted to one level of nesting for a particular control structure. -Unfortunately, this restriction forces programmers to use ©goto© to achieve the equivalent control-flow for more than one level of nesting. -To prevent having to switch to the ©goto©, \CFA extends the ©continue©\index{continue@©continue©}\index{continue@©continue©!labelled}\index{labelled!continue@©continue©} and ©break©\index{break@©break©}\index{break@©break©!labelled}\index{labelled!break@©break©} with a target label to support static multi-level exit\index{multi-level exit}\index{static multi-level exit}~\cite{Buhr85,Java}. +Unfortunately, this restriction forces programmers to use \Indexc{goto} to achieve the equivalent control-flow for more than one level of nesting. +To prevent having to switch to the ©goto©, \CFA extends the \Indexc{continue}\index{continue@©continue©!labelled}\index{labelled!continue@©continue©} and \Indexc{break}\index{break@©break©!labelled}\index{labelled!break@©break©} with a target label to support static multi-level exit\index{multi-level exit}\index{static multi-level exit}~\cite{Buhr85,Java}. For both ©continue© and ©break©, the target label must be directly associated with a ©for©, ©while© or ©do© statement; for ©break©, the target label can also be associated with a ©switch©, ©if© or compound (©{}©) statement. - -The following example shows the labelled ©continue© specifying which control structure is the target for the next loop iteration: -\begin{quote2} -\begin{tabular}{@{}l@{\hspace{3em}}l@{}} -\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}} & \multicolumn{1}{c}{\textbf{C}} \\ -\begin{cfa} -®L1:® do { - ®L2:® while ( ... ) { - ®L3:® for ( ... ) { - ... continue ®L1®; ... // continue do - ... continue ®L2®; ... // continue while - ... continue ®L3®; ... // continue for - } // for - } // while -} while ( ... ); -\end{cfa} -& -\begin{cfa} -do { - while ( ... ) { - for ( ... ) { - ... goto L1; ... - ... goto L2; ... - ... goto L3; ... - L3: ; } - L2: ; } -L1: ; } while ( ... ); -\end{cfa} -\end{tabular} -\end{quote2} -The innermost loop has three restart points, which cause the next loop iteration to begin. - -The following example shows the labelled ©break© specifying which control structure is the target for exit: -\begin{quote2} -\begin{tabular}{@{}l@{\hspace{3em}}l@{}} -\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}} & \multicolumn{1}{c}{\textbf{C}} \\ -\begin{cfa} -®L1:® { +\VRef[Figure]{f:MultiLevelResumeTermination} shows the labelled ©continue© and ©break©, specifying which control structure is the target for exit, and the corresponding C program using only ©goto©. +The innermost loop has 7 exit points, which cause resumption or termination of one or more of the 7 \Index{nested control-structure}s. + +\begin{figure} +\begin{tabular}{@{\hspace{\parindentlnth}}l@{\hspace{1.5em}}l@{}} +\multicolumn{1}{c@{\hspace{1.5em}}}{\textbf{\CFA}} & \multicolumn{1}{c}{\textbf{C}} \\ +\begin{cfa} +®LC:® { ... §declarations§ ... - ®L2:® switch ( ... ) { + ®LS:® switch ( ... ) { case 3: - ®L3:® if ( ... ) { - ®L4:® for ( ... ) { - ... break ®L1®; ... // exit compound statement - ... break ®L2®; ... // exit switch - ... break ®L3®; ... // exit if - ... break ®L4®; ... // exit loop + ®LIF:® if ( ... ) { + ®LF:® for ( ... ) { + ®LW:® while ( ... ) { + ... break ®LC®; ... // terminate compound + ... break ®LS®; ... // terminate switch + ... break ®LIF®; ... // terminate if + ... continue ®LF;® ... // resume loop + ... break ®LF®; ... // terminate loop + ... continue ®LW®; ... // resume loop + ... break ®LW®; ... // terminate loop + } // while } // for } else { - ... break ®L3®; ... // exit if + ... break ®LIF®; ... // terminate if } // if } // switch @@ -1925,31 +1899,37 @@ switch ( ... ) { case 3: - if ( ... ) { + if ( ... ) { for ( ... ) { - ... goto L1; ... - ... goto L2; ... - ... goto L3; ... - ... goto L4; ... - } L4: ; + for ( ... ) { + ... goto ®LC®; ... + ... goto ®LS®; ... + ... goto ®LIF®; ... + ... goto ®LFC®; ... + ... goto ®LFB®; ... + ... goto ®LWC®; ... + ... goto ®LWB®; ... + ®LWC®: ; } ®LWB:® ; + ®LFC:® ; } ®LFB:® ; } else { - ... goto L3; ... - } L3: ; - } L2: ; -} L1: ; + ... goto ®LIF®; ... + } ®L3:® ; + } ®LS:® ; +} ®LC:® ; \end{cfa} \end{tabular} -\end{quote2} -The innermost loop has four exit points, which cause termination of one or more of the four \Index{nested control structure}s. - -Both ©continue© and ©break© with target labels are simply a ©goto©\index{goto@©goto©!restricted} restricted in the following ways: +\caption{Multi-level Resume/Termination} +\label{f:MultiLevelResumeTermination} +\end{figure} + +Both labelled ©continue© and ©break© are a ©goto©\index{goto@©goto©!restricted} restricted in the following ways: \begin{itemize} \item -They cannot be used to create a loop. -This means that only the looping construct can be used to create a loop. -This restriction is important since all situations that can result in repeated execution of statements in a program are clearly delineated. -\item -Since they always transfer out of containing control structures, they cannot be used to branch into a control structure. +They cannot create a loop, which means only the looping constructs cause looping. +This restriction means all situations resulting in repeated execution are clearly delineated. +\item +They cannot branch into a control structure. +This restriction prevents missing initialization at the start of a control structure resulting in undefined behaviour. \end{itemize} -The advantage of the labelled ©continue©/©break© is allowing static multi-level exits without having to use the ©goto© statement and tying control flow to the target control structure rather than an arbitrary point in a program. +The advantage of the labelled ©continue©/©break© is allowing static multi-level exits without having to use the ©goto© statement, and tying control flow to the target control structure rather than an arbitrary point in a program. Furthermore, the location of the label at the \emph{beginning} of the target control structure informs the reader that complex control-flow is occurring in the body of the control structure. With ©goto©, the label is at the end of the control structure, which fails to convey this important clue early enough to the reader. @@ -2268,5 +2248,5 @@ \index{input/output library} -The goal for the \CFA I/O is to make I/O as simple as possible in the common cases, while fully supporting polymorphism and user defined types in a consistent way. +The goal of \CFA I/O is to simplify the common cases\index{I/O!common case}, while fully supporting polymorphism and user defined types in a consistent way. The common case is printing out a sequence of variables separated by whitespace. \begin{quote2} @@ -2274,5 +2254,5 @@ \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}} & \multicolumn{1}{c}{\textbf{\CC}} \\ \begin{cfa} -int x = 0, y = 1, z = 2; +int x = 1, y = 2, z = 3; sout | x ®|® y ®|® z | endl; \end{cfa} @@ -2281,10 +2261,25 @@ cout << x ®<< " "® << y ®<< " "® << z << endl; +\end{cfa} +\\ +\begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt] +1 2 3 +\end{cfa} +& +\begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt] +1 2 3 \end{cfa} \end{tabular} \end{quote2} The \CFA form has half as many characters as the \CC form, and is similar to \Index*{Python} I/O with respect to implicit separators. - -The logical-or operator is used because it is the lowest-priority overloadable operator, other than assignment. +A tuple prints all the tuple's values, each separated by ©", "©. +\begin{cfa}[mathescape=off,aboveskip=0pt,belowskip=0pt] +[int, int] t1 = [1, 2], t2 = [3, 4]; +sout | t1 | t2 | endl; §\C{// print tuples}§ +\end{cfa} +\begin{cfa}[mathescape=off,showspaces=true,belowskip=0pt] +1, 2, 3, 4 +\end{cfa} +\CFA uses the logical-or operator for I/O because it is the lowest-priority overloadable operator, other than assignment. Therefore, fewer output expressions require parenthesis. \begin{quote2} @@ -2299,5 +2294,10 @@ & \begin{cfa} -cout << x * 3 << y + 1 << (z << 2) << (x == y) << (x | y) << (x || y) << (x > z ? 1 : 2) << endl; +cout << x * 3 << y + 1 << ®(®z << 2®)® << ®(®x == y®)® << (x | y) << (x || y) << (x > z ? 1 : 2) << endl; +\end{cfa} +\\ +& +\begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt] +3 3 12 0 3 1 2 \end{cfa} \end{tabular} @@ -2305,4 +2305,5 @@ Finally, the logical-or operator has a link with the Shell pipe-operator for moving data, where data flows in the correct direction for input but the opposite direction for output. + The implicit separator\index{I/O separator} character (space/blank) is a separator not a terminator. The rules for implicitly adding the separator are: @@ -2316,4 +2317,5 @@ 1 2 3 \end{cfa} + \item A separator does not appear before or after a character literal or variable. @@ -2322,6 +2324,7 @@ 123 \end{cfa} -\item -A separator does not appear before or after a null (empty) C string + +\item +A separator does not appear before or after a null (empty) C string. \begin{cfa} sout | 1 | "" | 2 | "" | 3 | endl; @@ -2329,6 +2332,7 @@ \end{cfa} which is a local mechanism to disable insertion of the separator character. -\item -A separator does not appear before a C string starting with the (extended) \Index{ASCII}\index{ASCII!extended} characters: \lstinline[mathescape=off]@([{=$£¥¡¿«@ + +\item +A separator does not appear before a C string starting with the (extended) \Index{ASCII}\index{ASCII!extended} characters: \lstinline[mathescape=off,basicstyle=\tt]@([{=$£¥¡¿«@ %$ \begin{cfa}[mathescape=off] @@ -2337,29 +2341,64 @@ \end{cfa} %$ -\begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt] -x (1 x [2 x {3 x =4 x $5 x £6 x ¥7 x ¡8 x ¿9 x «10 +\begin{cfa}[mathescape=off,basicstyle=\tt,showspaces=true,aboveskip=0pt,belowskip=0pt] +x ®(®1 x ®[®2 x ®{®3 x ®=®4 x ®$®5 x ®£®6 x ®¥®7 x ®¡®8 x ®¿®9 x ®«®10 \end{cfa} %$ +where \lstinline[basicstyle=\tt]@¡¿@ are inverted opening exclamation and question marks, and \lstinline[basicstyle=\tt]@«@ is an opening citation mark. + \item {\lstset{language=CFA,deletedelim=**[is][]{¢}{¢}} -A seperator does not appear after a C string ending with the (extended) \Index{ASCII}\index{ASCII!extended} characters: ©,.;!?)]}%¢»© +A seperator does not appear after a C string ending with the (extended) \Index{ASCII}\index{ASCII!extended} characters: \lstinline[basicstyle=\tt]@,.;!?)]}%¢»@ \begin{cfa}[belowskip=0pt] sout | 1 | ", x" | 2 | ". x" | 3 | "; x" | 4 | "! x" | 5 | "? x" | 6 | "% x" | 7 | "¢ x" | 8 | "» x" | 9 | ") x" | 10 | "] x" | 11 | "} x" | endl; \end{cfa} -\begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt] -1, x 2. x 3; x 4! x 5? x 6% x 7§\textcent§ x 8» x 9) x 10] x 11} x +\begin{cfa}[basicstyle=\tt,showspaces=true,aboveskip=0pt,belowskip=0pt] +1®,® x 2®.® x 3®;® x 4®!® x 5®?® x 6®%® x 7§\color{red}\textcent§ x 8®»® x 9®)® x 10®]® x 11®}® x \end{cfa}}% -\item -A seperator does not appear before or after a C string begining/ending with the \Index{ASCII} quote or whitespace characters: \lstinline[showspaces=true]@`'": \t\v\f\r\n@ +where \lstinline[basicstyle=\tt]@»@ is a closing citation mark. + +\item +A seperator does not appear before or after a C string begining/ending with the \Index{ASCII} quote or whitespace characters: \lstinline[basicstyle=\tt,showspaces=true]@`'": \t\v\f\r\n@ \begin{cfa}[belowskip=0pt] sout | "x`" | 1 | "`x'" | 2 | "'x\"" | 3 | "\"x:" | 4 | ":x " | 5 | " x\t" | 6 | "\tx" | endl; \end{cfa} -\begin{cfa}[mathescape=off,showspaces=true,showtabs=true,aboveskip=0pt,belowskip=0pt] -x`1`x'2'x"3"x:4:x 5 x 6 x +\begin{cfa}[basicstyle=\tt,showspaces=true,showtabs=true,aboveskip=0pt,belowskip=0pt] +x®`®1®`®x§\color{red}\texttt{'}§2§\color{red}\texttt{'}§x§\color{red}\texttt{"}§3§\color{red}\texttt{"}§x®:®4®:®x® ®5® ®x® ®6® ®x +\end{cfa} + +\item +If a space is desired before or after one of the special string start/end characters, simply insert a space. +\begin{cfa}[belowskip=0pt] +sout | "x (§\color{red}\texttt{\textvisiblespace}§" | 1 | "§\color{red}\texttt{\textvisiblespace}§) x" | 2 | "§\color{red}\texttt{\textvisiblespace}§, x" | 3 | "§\color{red}\texttt{\textvisiblespace}§:x:§\color{red}\texttt{\textvisiblespace}§" | 4 | endl; +\end{cfa} +\begin{cfa}[basicstyle=\tt,showspaces=true,showtabs=true,aboveskip=0pt,belowskip=0pt] +x (® ®1® ®) x 2® ®, x 3® ®:x:® ®4 \end{cfa} \end{enumerate} -The following \CC-style \Index{manipulator}s allow control over implicit seperation. +The following routines and \CC-style \Index{manipulator}s control implicit seperation. +\begin{enumerate} +\item +Routines \Indexc{sepSet}\index{manipulator!sepSet@©sepSet©} and \Indexc{sepGet}\index{manipulator!sepGet@©sepGet©} set and get the separator string. +The separator string can be at most 16 characters including the ©'\0'© string terminator (15 printable characters). +\begin{cfa}[mathescape=off,aboveskip=0pt,belowskip=0pt] +sepSet( sout, ", $" ); §\C{// set separator from " " to ", \$"}§ +sout | 1 | 2 | 3 | " \"" | ®sepGet( sout )® | "\"" | endl; +\end{cfa} +%$ +\begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt] +1, $2, $3 ®", $"® +\end{cfa} +%$ +\begin{cfa}[mathescape=off,aboveskip=0pt,belowskip=0pt] +sepSet( sout, " " ); §\C{// reset separator to " "}§ +sout | 1 | 2 | 3 | " \"" | ®sepGet( sout )® | "\"" | endl; +\end{cfa} +\begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt] +1 2 3 ®" "® +\end{cfa} + +\item Manipulators \Indexc{sepOn}\index{manipulator!sepOn@©sepOn©} and \Indexc{sepOff}\index{manipulator!sepOff@©sepOff©} \emph{locally} toggle printing the separator, \ie the seperator is adjusted only with respect to the next printed item. \begin{cfa}[mathescape=off,belowskip=0pt] @@ -2375,4 +2414,6 @@ 12 3 \end{cfa} + +\item Manipulators \Indexc{sepDisable}\index{manipulator!sepDisable@©sepDisable©} and \Indexc{sepEnable}\index{manipulator!sepEnable@©sepEnable©} \emph{globally} toggle printing the separator, \ie the seperator is adjusted with respect to all subsequent printed items, unless locally adjusted. \begin{cfa}[mathescape=off,aboveskip=0pt,belowskip=0pt] @@ -2394,51 +2435,33 @@ 1 2 3 \end{cfa} -Printing a tuple outputs all the tuple's values separated by ©", "©: + +\item +Routine \Indexc{sepSetTuple}\index{manipulator!sepSetTuple@©sepSetTuple©} and \Indexc{sepGetTuple}\index{manipulator!sepGetTuple@©sepGetTuple©} get and set the tuple separator-string. +The tuple separator-string can be at most 16 characters including the ©'\0'© string terminator (15 printable characters). \begin{cfa}[mathescape=off,aboveskip=0pt,belowskip=0pt] -sout | [2, 3] | [4, 5] | endl; §\C{// print tuple}§ +sepSetTuple( sout, " " ); §\C{// set tuple separator from ", " to " "}§ +sout | t1 | t2 | " \"" | ®sepGetTuple( sout )® | "\"" | endl; +\end{cfa} +\begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt] +1 2 3 4 ®" "® +\end{cfa} +\begin{cfa}[mathescape=off,aboveskip=0pt,belowskip=0pt] +sepSetTuple( sout, ", " ); §\C{// reset tuple separator to ", "}§ +sout | t1 | t2 | " \"" | ®sepGetTuple( sout )® | "\"" | endl; +\end{cfa} +\begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt] +1, 2, 3, 4 ®", "® +\end{cfa} + +\item +The tuple separator can also be turned on and off. +\begin{cfa}[mathescape=off,aboveskip=0pt,belowskip=0pt] +sout | sepOn | t1 | sepOff | t2 | endl; §\C{// locally turn on/off implicit separation}§ \end{cfa} \begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt] -2, 3, 4, 5 -\end{cfa} -The tuple separator can also be turned on and off: -\begin{cfa}[mathescape=off,aboveskip=0pt,belowskip=0pt] -sout | sepOn | [2, 3] | sepOff | [4, 5] | endl; §\C{// locally turn on/off implicit separation}§ -\end{cfa} -\begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt] -, 2, 34, 5 +, 1, 23, 4 \end{cfa} Notice a tuple seperator starts the line because the next item is a tuple. -Finally, the stream routines \Indexc{sepGet}\index{manipulator!sepGet@©sepGet©} and \Indexc{sepSet}\index{manipulator!sepSet@©sepSet©} get and set the basic separator-string. -\begin{cfa}[mathescape=off,aboveskip=0pt,aboveskip=0pt,belowskip=0pt] -sepSet( sout, ", $" ); §\C{// set separator from " " to ", \$"}§ -sout | 1 | 2 | 3 | " \"" | sepGet( sout ) | "\"" | endl; -\end{cfa} -%$ -\begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt] -1, $2, $3 ", $" -\end{cfa} -%$ -\begin{cfa}[mathescape=off,aboveskip=0pt,aboveskip=0pt,belowskip=0pt] -sepSet( sout, " " ); §\C{// reset separator to " "}§ -sout | 1 | 2 | 3 | " \"" | sepGet( sout ) | "\"" | endl; -\end{cfa} -\begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt] -1 2 3 " " -\end{cfa} -and the stream routines \Indexc{sepGetTuple}\index{manipulator!sepGetTuple@©sepGetTuple©} and \Indexc{sepSetTuple}\index{manipulator!sepSetTuple@©sepSetTuple©} get and set the tuple separator-string. -\begin{cfa}[mathescape=off,aboveskip=0pt,aboveskip=0pt,belowskip=0pt] -sepSetTuple( sout, " " ); §\C{// set tuple separator from ", " to " "}§ -sout | [2, 3] | [4, 5] | " \"" | sepGetTuple( sout ) | "\"" | endl; -\end{cfa} -\begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt] -2 3 4 5 " " -\end{cfa} -\begin{cfa}[mathescape=off,aboveskip=0pt,aboveskip=0pt,belowskip=0pt] -sepSetTuple( sout, ", " ); §\C{// reset tuple separator to ", "}§ -sout | [2, 3] | [4, 5] | " \"" | sepGetTuple( sout ) | "\"" | endl; -\end{cfa} -\begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt] -2, 3, 4, 5 ", " -\end{cfa} +\end{enumerate} \begin{comment} @@ -2446,6 +2469,9 @@ int main( void ) { - int x = 0, y = 1, z = 2; - sout | x * 3 | y + 1 | z << 2 | x == y | (x | y) | (x || y) | (x > z ? 1 : 2) | endl | endl; + int x = 1, y = 2, z = 3; + sout | x | y | z | endl; + [int, int] t1 = [1, 2], t2 = [3, 4]; + sout | t1 | t2 | endl; // print tuple + sout | x * 3 | y + 1 | z << 2 | x == y | (x | y) | (x || y) | (x > z ? 1 : 2) | endl; sout | 1 | 2 | 3 | endl; sout | '1' | '2' | '3' | endl; @@ -2456,13 +2482,5 @@ | 7 | "¢ x" | 8 | "» x" | 9 | ") x" | 10 | "] x" | 11 | "} x" | endl; sout | "x`" | 1 | "`x'" | 2 | "'x\"" | 3 | "\"x:" | 4 | ":x " | 5 | " x\t" | 6 | "\tx" | endl; - - sout | sepOn | 1 | 2 | 3 | sepOn | endl; // separator at start of line - sout | 1 | sepOff | 2 | 3 | endl; // locally turn off implicit separator - sout | sepDisable | 1 | 2 | 3 | endl; // globally turn off implicit separation - sout | 1 | sepOn | 2 | 3 | endl; // locally turn on implicit separator - sout | sepEnable | 1 | 2 | 3 | endl; // globally turn on implicit separation - - sout | [2, 3] | [4, 5] | endl; // print tuple - sout | sepOn | [2, 3] | sepOff | [4, 5] | endl; // locally turn on/off implicit separation + sout | "x ( " | 1 | " ) x" | 2 | " , x" | 3 | " :x: " | 4 | endl; sepSet( sout, ", $" ); // set separator from " " to ", $" @@ -2471,12 +2489,23 @@ sout | 1 | 2 | 3 | " \"" | sepGet( sout ) | "\"" | endl; + sout | sepOn | 1 | 2 | 3 | sepOn | endl; // separator at start of line + sout | 1 | sepOff | 2 | 3 | endl; // locally turn off implicit separator + + sout | sepDisable | 1 | 2 | 3 | endl; // globally turn off implicit separation + sout | 1 | sepOn | 2 | 3 | endl; // locally turn on implicit separator + sout | sepEnable | 1 | 2 | 3 | endl; // globally turn on implicit separation + sepSetTuple( sout, " " ); // set tuple separator from ", " to " " - sout | [2, 3] | [4, 5] | " \"" | sepGetTuple( sout ) | "\"" | endl; + sout | t1 | t2 | " \"" | sepGetTuple( sout ) | "\"" | endl; sepSetTuple( sout, ", " ); // reset tuple separator to ", " - sout | [2, 3] | [4, 5] | " \"" | sepGetTuple( sout ) | "\"" | endl; + sout | t1 | t2 | " \"" | sepGetTuple( sout ) | "\"" | endl; + + sout | t1 | t2 | endl; // print tuple + sout | sepOn | t1 | sepOff | t2 | endl; // locally turn on/off implicit separation } // Local Variables: // // tab-width: 4 // +// fill-column: 100 // // End: // \end{comment} @@ -2972,5 +3001,5 @@ generic (type T | bool ??( T, T ); } ) -T max( const T t1, const T t2 );§\indexc{max}§ +T max( T t1, T t2 );§\indexc{max}§ forall( otype T | { T min( T, T ); T max( T, T ); } ) @@ -5232,5 +5307,5 @@ \label{s:Math Library} -The \CFA math-library wraps many existing explicitly-polymorphic C math-routines into implicitly-polymorphic versions. +The \CFA math-library wraps explicitly-polymorphic C math-routines into implicitly-polymorphic versions. @@ -5239,11 +5314,4 @@ \leavevmode \begin{cfa}[aboveskip=0pt,belowskip=0pt] -float fabs( float );§\indexc{fabs}§ -double fabs( double ); -long double fabs( long double ); -float cabs( float _Complex ); -double cabs( double _Complex ); -long double cabs( long double _Complex ); - float ?%?( float, float );§\indexc{fmod}§ float fmod( float, float ); @@ -5600,4 +5668,258 @@ +\section{Multi-precision Integers} +\label{s:MultiPrecisionIntegers} + +\CFA has an interface to the \Index{GMP} \Index{multi-precision} signed-integers~\cite{GMP}, similar to the \CC interface provided by GMP. +The \CFA interface wraps GMP routines into operator routines to make programming with multi-precision integers identical to using fixed-sized integers. +The \CFA type name for multi-precision signed-integers is \Indexc{Int}. + +\begin{cfa} +void ?{}( Int * this ); §\C{// constructor}§ +void ?{}( Int * this, Int init ); +void ?{}( Int * this, zero_t ); +void ?{}( Int * this, one_t ); +void ?{}( Int * this, signed long int init ); +void ?{}( Int * this, unsigned long int init ); +void ?{}( Int * this, const char * val ); +void ^?{}( Int * this ); + +Int ?=?( Int * lhs, Int rhs ); §\C{// assignment}§ +Int ?=?( Int * lhs, long int rhs ); +Int ?=?( Int * lhs, unsigned long int rhs ); +Int ?=?( Int * lhs, const char * rhs ); + +char ?=?( char * lhs, Int rhs ); +short int ?=?( short int * lhs, Int rhs ); +int ?=?( int * lhs, Int rhs ); +long int ?=?( long int * lhs, Int rhs ); +unsigned char ?=?( unsigned char * lhs, Int rhs ); +unsigned short int ?=?( unsigned short int * lhs, Int rhs ); +unsigned int ?=?( unsigned int * lhs, Int rhs ); +unsigned long int ?=?( unsigned long int * lhs, Int rhs ); + +long int narrow( Int val ); +unsigned long int narrow( Int val ); + +int ?==?( Int oper1, Int oper2 ); §\C{// comparison}§ +int ?==?( Int oper1, long int oper2 ); +int ?==?( long int oper2, Int oper1 ); +int ?==?( Int oper1, unsigned long int oper2 ); +int ?==?( unsigned long int oper2, Int oper1 ); + +int ?!=?( Int oper1, Int oper2 ); +int ?!=?( Int oper1, long int oper2 ); +int ?!=?( long int oper1, Int oper2 ); +int ?!=?( Int oper1, unsigned long int oper2 ); +int ?!=?( unsigned long int oper1, Int oper2 ); + +int ??( Int oper1, Int oper2 ); +int ?>?( Int oper1, long int oper2 ); +int ?>?( long int oper1, Int oper2 ); +int ?>?( Int oper1, unsigned long int oper2 ); +int ?>?( unsigned long int oper1, Int oper2 ); + +int ?>=?( Int oper1, Int oper2 ); +int ?>=?( Int oper1, long int oper2 ); +int ?>=?( long int oper1, Int oper2 ); +int ?>=?( Int oper1, unsigned long int oper2 ); +int ?>=?( unsigned long int oper1, Int oper2 ); + +Int +?( Int oper ); §\C{// arithmetic}§ +Int -?( Int oper ); +Int ~?( Int oper ); + +Int ?&?( Int oper1, Int oper2 ); +Int ?&?( Int oper1, long int oper2 ); +Int ?&?( long int oper1, Int oper2 ); +Int ?&?( Int oper1, unsigned long int oper2 ); +Int ?&?( unsigned long int oper1, Int oper2 ); +Int ?&=?( Int * lhs, Int rhs ); + +Int ?|?( Int oper1, Int oper2 ); +Int ?|?( Int oper1, long int oper2 ); +Int ?|?( long int oper1, Int oper2 ); +Int ?|?( Int oper1, unsigned long int oper2 ); +Int ?|?( unsigned long int oper1, Int oper2 ); +Int ?|=?( Int * lhs, Int rhs ); + +Int ?^?( Int oper1, Int oper2 ); +Int ?^?( Int oper1, long int oper2 ); +Int ?^?( long int oper1, Int oper2 ); +Int ?^?( Int oper1, unsigned long int oper2 ); +Int ?^?( unsigned long int oper1, Int oper2 ); +Int ?^=?( Int * lhs, Int rhs ); + +Int ?+?( Int addend1, Int addend2 ); +Int ?+?( Int addend1, long int addend2 ); +Int ?+?( long int addend2, Int addend1 ); +Int ?+?( Int addend1, unsigned long int addend2 ); +Int ?+?( unsigned long int addend2, Int addend1 ); +Int ?+=?( Int * lhs, Int rhs ); +Int ?+=?( Int * lhs, long int rhs ); +Int ?+=?( Int * lhs, unsigned long int rhs ); +Int ++?( Int * lhs ); +Int ?++( Int * lhs ); + +Int ?-?( Int minuend, Int subtrahend ); +Int ?-?( Int minuend, long int subtrahend ); +Int ?-?( long int minuend, Int subtrahend ); +Int ?-?( Int minuend, unsigned long int subtrahend ); +Int ?-?( unsigned long int minuend, Int subtrahend ); +Int ?-=?( Int * lhs, Int rhs ); +Int ?-=?( Int * lhs, long int rhs ); +Int ?-=?( Int * lhs, unsigned long int rhs ); +Int --?( Int * lhs ); +Int ?--( Int * lhs ); + +Int ?*?( Int multiplicator, Int multiplicand ); +Int ?*?( Int multiplicator, long int multiplicand ); +Int ?*?( long int multiplicand, Int multiplicator ); +Int ?*?( Int multiplicator, unsigned long int multiplicand ); +Int ?*?( unsigned long int multiplicand, Int multiplicator ); +Int ?*=?( Int * lhs, Int rhs ); +Int ?*=?( Int * lhs, long int rhs ); +Int ?*=?( Int * lhs, unsigned long int rhs ); + +Int ?/?( Int dividend, Int divisor ); +Int ?/?( Int dividend, unsigned long int divisor ); +Int ?/?( unsigned long int dividend, Int divisor ); +Int ?/?( Int dividend, long int divisor ); +Int ?/?( long int dividend, Int divisor ); +Int ?/=?( Int * lhs, Int rhs ); +Int ?/=?( Int * lhs, long int rhs ); +Int ?/=?( Int * lhs, unsigned long int rhs ); + +[ Int, Int ] div( Int dividend, Int divisor ); +[ Int, Int ] div( Int dividend, unsigned long int divisor ); + +Int ?%?( Int dividend, Int divisor ); +Int ?%?( Int dividend, unsigned long int divisor ); +Int ?%?( unsigned long int dividend, Int divisor ); +Int ?%?( Int dividend, long int divisor ); +Int ?%?( long int dividend, Int divisor ); +Int ?%=?( Int * lhs, Int rhs ); +Int ?%=?( Int * lhs, long int rhs ); +Int ?%=?( Int * lhs, unsigned long int rhs ); + +Int ?<>?( Int shiften, mp_bitcnt_t shift ); +Int ?>>=?( Int * lhs, mp_bitcnt_t shift ); + +Int abs( Int oper ); §\C{// number functions}§ +Int fact( unsigned long int N ); +Int gcd( Int oper1, Int oper2 ); +Int pow( Int base, unsigned long int exponent ); +Int pow( unsigned long int base, unsigned long int exponent ); +void srandom( gmp_randstate_t state ); +Int random( gmp_randstate_t state, mp_bitcnt_t n ); +Int random( gmp_randstate_t state, Int n ); +Int random( gmp_randstate_t state, mp_size_t max_size ); +int sgn( Int oper ); +Int sqrt( Int oper ); + +forall( dtype istype | istream( istype ) ) istype * ?|?( istype * is, Int * mp ); §\C{// I/O}§ +forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype * os, Int mp ); +\end{cfa} + +The following factorial programs contrast using GMP with the \CFA and C interfaces, where the output from these programs appears in \VRef[Figure]{f:MultiPrecisionFactorials}. +(Compile with flag \Indexc{-lgmp} to link with the GMP library.) +\begin{quote2} +\begin{tabular}{@{}l@{\hspace{\parindentlnth}}|@{\hspace{\parindentlnth}}l@{}} +\multicolumn{1}{c|@{\hspace{\parindentlnth}}}{\textbf{\CFA}} & \multicolumn{1}{@{\hspace{\parindentlnth}}c}{\textbf{C}} \\ +\hline +\begin{cfa} +#include +int main( void ) { + sout | "Factorial Numbers" | endl; + Int fact; + fact = 1; + sout | 0 | fact | endl; + for ( unsigned int i = 1; i <= 40; i += 1 ) { + fact *= i; + sout | i | fact | endl; + } +} +\end{cfa} +& +\begin{cfa} +#include +int main( void ) { + ®gmp_printf®( "Factorial Numbers\n" ); + ®mpz_t® fact; + ®mpz_init_set_ui®( fact, 1 ); + ®gmp_printf®( "%d %Zd\n", 0, fact ); + for ( unsigned int i = 1; i <= 40; i += 1 ) { + ®mpz_mul_ui®( fact, fact, i ); + ®gmp_printf®( "%d %Zd\n", i, fact ); + } +} +\end{cfa} +\end{tabular} +\end{quote2} + +\begin{figure} +\begin{cfa} +Factorial Numbers +0 1 +1 1 +2 2 +3 6 +4 24 +5 120 +6 720 +7 5040 +8 40320 +9 362880 +10 3628800 +11 39916800 +12 479001600 +13 6227020800 +14 87178291200 +15 1307674368000 +16 20922789888000 +17 355687428096000 +18 6402373705728000 +19 121645100408832000 +20 2432902008176640000 +21 51090942171709440000 +22 1124000727777607680000 +23 25852016738884976640000 +24 620448401733239439360000 +25 15511210043330985984000000 +26 403291461126605635584000000 +27 10888869450418352160768000000 +28 304888344611713860501504000000 +29 8841761993739701954543616000000 +30 265252859812191058636308480000000 +31 8222838654177922817725562880000000 +32 263130836933693530167218012160000000 +33 8683317618811886495518194401280000000 +34 295232799039604140847618609643520000000 +35 10333147966386144929666651337523200000000 +36 371993326789901217467999448150835200000000 +37 13763753091226345046315979581580902400000000 +38 523022617466601111760007224100074291200000000 +39 20397882081197443358640281739902897356800000000 +40 815915283247897734345611269596115894272000000000 +\end{cfa} +\caption{Multi-precision Factorials} +\label{f:MultiPrecisionFactorials} +\end{figure} + + \section{Rational Numbers} \label{s:RationalNumbers} @@ -5612,21 +5934,16 @@ }; // Rational -// constants -extern struct Rational 0; -extern struct Rational 1; - -// constructors -Rational rational(); +Rational rational(); §\C{// constructors}§ Rational rational( long int n ); Rational rational( long int n, long int d ); - -// getter/setter for numerator/denominator -long int numerator( Rational r ); +void ?{}( Rational * r, zero_t ); +void ?{}( Rational * r, one_t ); + +long int numerator( Rational r ); §\C{// numerator/denominator getter/setter}§ long int numerator( Rational r, long int n ); long int denominator( Rational r ); long int denominator( Rational r, long int d ); -// comparison -int ?==?( Rational l, Rational r ); +int ?==?( Rational l, Rational r ); §\C{// comparison}§ int ?!=?( Rational l, Rational r ); int ?=?( Rational l, Rational r ); -// arithmetic -Rational -?( Rational r ); +Rational -?( Rational r ); §\C{// arithmetic}§ Rational ?+?( Rational l, Rational r ); Rational ?-?( Rational l, Rational r ); @@ -5642,10 +5958,8 @@ Rational ?/?( Rational l, Rational r ); -// conversion -double widen( Rational r ); +double widen( Rational r ); §\C{// conversion}§ Rational narrow( double f, long int md ); -// I/O -forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, Rational * ); +forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, Rational * ); // I/O forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, Rational ); \end{cfa} Index: doc/working/resolver_design.md =================================================================== --- doc/working/resolver_design.md (revision ff98952225b16a68fb22c007b5495c78ef23158e) +++ doc/working/resolver_design.md (revision 4a3685479ce3ea742a9282c31d31ce031849e49c) @@ -41,4 +41,13 @@ ensure that they are two-arg functions (this restriction may be valuable regardless). + +Regardless of syntax, there should be a type assertion that expresses `From` +is convertable to `To`. +If user-defined conversions are not added to the language, +`void ?{} ( To*, From )` may be a suitable representation, relying on +conversions on the argument types to account for transitivity. +On the other hand, `To*` should perhaps match its target type exactly, so +another assertion syntax specific to conversions may be required, e.g. +`From -> To`. ### Constructor Idiom ### Index: src/CodeGen/CodeGenerator.cc =================================================================== --- src/CodeGen/CodeGenerator.cc (revision ff98952225b16a68fb22c007b5495c78ef23158e) +++ src/CodeGen/CodeGenerator.cc (revision 4a3685479ce3ea742a9282c31d31ce031849e49c) @@ -324,10 +324,5 @@ printDesignators( init->get_designators() ); output << "{ "; - if ( init->begin() == init->end() ) { - // illegal to leave initializer list empty for scalar initializers, but always legal to have 0 - output << "0"; - } else { - genCommaList( init->begin(), init->end() ); - } // if + genCommaList( init->begin(), init->end() ); output << " }"; } Index: src/InitTweak/GenInit.cc =================================================================== --- src/InitTweak/GenInit.cc (revision ff98952225b16a68fb22c007b5495c78ef23158e) +++ src/InitTweak/GenInit.cc (revision 4a3685479ce3ea742a9282c31d31ce031849e49c) @@ -315,5 +315,5 @@ for ( auto & tyDecl : functionDecl->get_functionType()->get_forall() ) { for ( DeclarationWithType *& assertion : tyDecl->get_assertions() ) { - assertion = assertion->acceptMutator( *this ); + handleDWT( assertion ); } } Index: src/MakeLibCfa.cc =================================================================== --- src/MakeLibCfa.cc (revision ff98952225b16a68fb22c007b5495c78ef23158e) +++ src/MakeLibCfa.cc (revision 4a3685479ce3ea742a9282c31d31ce031849e49c) @@ -75,25 +75,8 @@ case CodeGen::OT_POSTFIXASSIGN: case CodeGen::OT_INFIXASSIGN: + case CodeGen::OT_CTOR: + case CodeGen::OT_DTOR: funcDecl->get_statements()->get_kids().push_back( new ReturnStmt( std::list< Label >(), newExpr ) ); break; - case CodeGen::OT_CTOR: - // ctors don't return a value - if ( funcDecl->get_functionType()->get_parameters().size() == 1 ) { - // intrinsic default constructors should do nothing - // delete newExpr; - break; - } else { - assert( funcDecl->get_functionType()->get_parameters().size() == 2 ); - // anything else is a single parameter constructor that is effectively a C-style assignment - // delete newExpr->get_function(); - assert(newExpr->get_args().size()==2); - newExpr->set_function( new NameExpr( "?=?" ) ); - funcDecl->get_statements()->get_kids().push_back( new ExprStmt( std::list< Label >(), newExpr ) ); - } - break; - case CodeGen::OT_DTOR: - // intrinsic destructors should do nothing - // delete newExpr; - break; case CodeGen::OT_CONSTANT: case CodeGen::OT_LABELADDRESS: Index: src/Parser/DeclarationNode.cc =================================================================== --- src/Parser/DeclarationNode.cc (revision ff98952225b16a68fb22c007b5495c78ef23158e) +++ src/Parser/DeclarationNode.cc (revision 4a3685479ce3ea742a9282c31d31ce031849e49c) @@ -57,4 +57,5 @@ variable.tyClass = NoTypeClass; variable.assertions = nullptr; + variable.initializer = nullptr; // attr.name = nullptr; @@ -70,4 +71,5 @@ // delete variable.name; delete variable.assertions; + delete variable.initializer; delete type; @@ -101,4 +103,5 @@ newnode->variable.tyClass = variable.tyClass; newnode->variable.assertions = maybeClone( variable.assertions ); + newnode->variable.initializer = maybeClone( variable.initializer ); // newnode->attr.name = attr.name ? new string( *attr.name ) : nullptr; @@ -857,4 +860,10 @@ } +DeclarationNode * DeclarationNode::addTypeInitializer( DeclarationNode * init ) { + assertf( variable.tyClass != NoTypeClass, "Called addTypeInitializer on something that isn't a type variable." ); + variable.initializer = init; + return this; +} + DeclarationNode * DeclarationNode::cloneType( string * newName ) { DeclarationNode * newnode = new DeclarationNode; @@ -1014,5 +1023,5 @@ assertf( sizeof(kindMap)/sizeof(kindMap[0] == NoTypeClass-1), "DeclarationNode::build: kindMap is out of sync." ); assertf( variable.tyClass < sizeof(kindMap)/sizeof(kindMap[0]), "Variable's tyClass is out of bounds." ); - TypeDecl * ret = new TypeDecl( *name, Type::StorageClasses(), nullptr, kindMap[ variable.tyClass ] ); + TypeDecl * ret = new TypeDecl( *name, Type::StorageClasses(), nullptr, kindMap[ variable.tyClass ], variable.initializer ? variable.initializer->buildType() : nullptr ); buildList( variable.assertions, ret->get_assertions() ); return ret; Index: src/Parser/ParseNode.h =================================================================== --- src/Parser/ParseNode.h (revision ff98952225b16a68fb22c007b5495c78ef23158e) +++ src/Parser/ParseNode.h (revision 4a3685479ce3ea742a9282c31d31ce031849e49c) @@ -274,4 +274,5 @@ DeclarationNode * addIdList( DeclarationNode * list ); // old-style functions DeclarationNode * addInitializer( InitializerNode * init ); + DeclarationNode * addTypeInitializer( DeclarationNode * init ); DeclarationNode * cloneType( std::string * newName ); @@ -301,4 +302,5 @@ DeclarationNode::TypeClass tyClass; DeclarationNode * assertions; + DeclarationNode * initializer; }; Variable_t variable; Index: src/Parser/lex.ll =================================================================== --- src/Parser/lex.ll (revision ff98952225b16a68fb22c007b5495c78ef23158e) +++ src/Parser/lex.ll (revision 4a3685479ce3ea742a9282c31d31ce031849e49c) @@ -10,6 +10,6 @@ * Created On : Sat Sep 22 08:58:10 2001 * Last Modified By : Peter A. Buhr - * Last Modified On : Thu May 18 09:03:49 2017 - * Update Count : 513 + * Last Modified On : Mon May 22 07:46:30 2017 + * Update Count : 525 */ @@ -377,30 +377,30 @@ "?"{op_binary_over}"?" { IDENTIFIER_RETURN(); } // binary /* - This rule handles ambiguous cases with operator identifiers, e.g., "int *?*?()", where the string "*?*?" - can be lexed as "*"/"?*?" or "*?"/"*?". Since it is common practise to put a unary operator juxtaposed - to an identifier, e.g., "*i", users will be annoyed if they cannot do this with respect to operator - identifiers. Even with this special hack, there are 5 general cases that cannot be handled. The first - case is for the function-call identifier "?()": - - int * ?()(); // declaration: space required after '*' - * ?()(); // expression: space required after '*' - - Without the space, the string "*?()" is ambiguous without N character look ahead; it requires scanning - ahead to determine if there is a '(', which is the start of an argument/parameter list. - - The 4 remaining cases occur in expressions: - - i++?i:0; // space required before '?' - i--?i:0; // space required before '?' - i?++i:0; // space required after '?' - i?--i:0; // space required after '?' - - In the first two cases, the string "i++?" is ambiguous, where this string can be lexed as "i"/"++?" or - "i++"/"?"; it requires scanning ahead to determine if there is a '(', which is the start of an argument - list. In the second two cases, the string "?++x" is ambiguous, where this string can be lexed as - "?++"/"x" or "?"/"++x"; it requires scanning ahead to determine if there is a '(', which is the start of - an argument list. + This rule handles ambiguous cases with operator identifiers, e.g., "int *?*?()", where the string "*?*?" can be + lexed as "*?"/"*?" or "*"/"?*?". Since it is common practise to put a unary operator juxtaposed to an identifier, + e.g., "*i", users will be annoyed if they cannot do this with respect to operator identifiers. Therefore, there is + a lexical look-ahead for the second case, with backtracking to return the leading unary operator and then + reparsing the trailing operator identifier. Otherwise a space is needed between the unary operator and operator + identifier to disambiguate this common case. + + A similar issue occurs with the dereference, *?(...), and routine-call, ?()(...) identifiers. The ambiguity + occurs when the deference operator has no parameters, *?() and *?()(...), requiring arbitrary whitespace + look-ahead for the routine-call parameter-list to disambiguate. However, the dereference operator must have a + parameter/argument to dereference *?(...). Hence, always interpreting the string *?() as * ?() does not preclude + any meaningful program. + + The remaining cases are with the increment/decrement operators and conditional expression: + + i++? ...(...); + i?++ ...(...); + + requiring arbitrary whitespace look-ahead for the operator parameter-list, even though that interpretation is an + incorrect expression (juxtaposed identifiers). Therefore, it is necessary to disambiguate these cases with a + space: + + i++ ? i : 0; + i? ++i : 0; */ -{op_unary}"?"({op_unary_pre_post}|"[?]"|{op_binary_over}"?") { +{op_unary}"?"({op_unary_pre_post}|"()"|"[?]"|{op_binary_over}"?") { // 1 or 2 character unary operator ? int i = yytext[1] == '?' ? 1 : 2; Index: src/Parser/parser.yy =================================================================== --- src/Parser/parser.yy (revision ff98952225b16a68fb22c007b5495c78ef23158e) +++ src/Parser/parser.yy (revision 4a3685479ce3ea742a9282c31d31ce031849e49c) @@ -10,6 +10,6 @@ // Created On : Sat Sep 1 20:22:55 2001 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu May 18 18:06:17 2017 -// Update Count : 2338 +// Last Modified On : Thu May 25 15:21:59 2017 +// Update Count : 2398 // @@ -159,6 +159,6 @@ } -%type identifier no_01_identifier no_attr_identifier zero_one -%type identifier_or_type_name no_attr_identifier_or_type_name no_01_identifier_or_type_name attr_name +%type identifier no_attr_identifier zero_one +%type identifier_or_type_name no_attr_identifier_or_type_name attr_name %type string_literal %type string_literal_list @@ -207,5 +207,5 @@ %type bit_subrange_size_opt bit_subrange_size -%type basic_declaration_specifier basic_type_name basic_type_specifier direct_type_name indirect_type_name +%type basic_declaration_specifier basic_type_name basic_type_specifier direct_type indirect_type %type trait_declaration trait_declaration_list trait_declaring_list trait_specifier @@ -261,15 +261,15 @@ %type type_declarator type_declarator_name type_declaring_list -%type typedef typedef_type_specifier typedef_declaration typedef_declaration_specifier typedef_expression +%type type_declaration_specifier type_type_specifier type_name typegen_name +%type typedef typedef_declaration typedef_expression %type variable_type_redeclarator type_ptr type_array type_function %type type_parameter_redeclarator type_parameter_ptr type_parameter_array type_parameter_function -%type typegen_declaration_specifier typegen_type_specifier typegen_name - -%type type_name type_name_no_function -%type type_parameter type_parameter_list - -%type type_name_list + +%type type type_no_function +%type type_parameter type_parameter_list type_initializer_opt + +%type type_list %type type_qualifier type_qualifier_name type_qualifier_list_opt type_qualifier_list @@ -351,15 +351,8 @@ IDENTIFIER | ATTR_IDENTIFIER // CFA - | zero_one // CFA - ; - -no_01_identifier: - IDENTIFIER - | ATTR_IDENTIFIER // CFA ; no_attr_identifier: IDENTIFIER - | zero_one // CFA ; @@ -367,5 +360,5 @@ ZERO | ONE - ; + ; string_literal: @@ -395,5 +388,5 @@ | '(' compound_statement ')' // GCC, lambda expression { $$ = new ExpressionNode( build_valexpr( $2 ) ); } - | primary_expression '{' argument_expression_list '}' // CFA + | primary_expression '{' argument_expression_list '}' // CFA, constructor call { Token fn; @@ -401,4 +394,8 @@ $$ = new ExpressionNode( new ConstructorExpr( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( $1 )->set_last( $3 ) ) ) ); } + | type_name '.' no_attr_identifier // CFA, nested type + { $$ = nullptr; } // FIX ME + | type_name '.' '[' push field_list pop ']' // CFA, nested type / tuple field selector + { $$ = nullptr; } // FIX ME ; @@ -431,5 +428,5 @@ | postfix_expression DECR { $$ = new ExpressionNode( build_unary_ptr( OperKinds::DecrPost, $1 ) ); } - | '(' type_name_no_function ')' '{' initializer_list comma_opt '}' // C99, compound-literal + | '(' type_no_function ')' '{' initializer_list comma_opt '}' // C99, compound-literal { $$ = new ExpressionNode( build_compoundLiteral( $2, new InitializerNode( $5, true ) ) ); } | '^' primary_expression '{' argument_expression_list '}' // CFA @@ -483,9 +480,9 @@ | no_attr_identifier fraction_constants { - if( (*$1) == "0" || (*$1) == "1" ) { - $$ = new ExpressionNode( build_field_name_fraction_constants( build_constantZeroOne( *$1 ), $2 ) ); - } else { - $$ = new ExpressionNode( build_field_name_fraction_constants( build_varref( $1 ), $2 ) ); - } + $$ = new ExpressionNode( build_field_name_fraction_constants( build_varref( $1 ), $2 ) ); + } + | zero_one fraction_constants + { + $$ = new ExpressionNode( build_field_name_fraction_constants( build_constantZeroOne( *$1 ), $2 ) ); } ; @@ -535,11 +532,11 @@ | SIZEOF unary_expression { $$ = new ExpressionNode( build_sizeOfexpr( $2 ) ); } - | SIZEOF '(' type_name_no_function ')' + | SIZEOF '(' type_no_function ')' { $$ = new ExpressionNode( build_sizeOftype( $3 ) ); } | ALIGNOF unary_expression // GCC, variable alignment { $$ = new ExpressionNode( build_alignOfexpr( $2 ) ); } - | ALIGNOF '(' type_name_no_function ')' // GCC, type alignment + | ALIGNOF '(' type_no_function ')' // GCC, type alignment { $$ = new ExpressionNode( build_alignOftype( $3 ) ); } - | OFFSETOF '(' type_name_no_function ',' no_attr_identifier ')' + | OFFSETOF '(' type_no_function ',' no_attr_identifier ')' { $$ = new ExpressionNode( build_offsetOf( $3, build_varref( $5 ) ) ); } | ATTR_IDENTIFIER @@ -547,5 +544,5 @@ | ATTR_IDENTIFIER '(' argument_expression ')' { $$ = new ExpressionNode( build_attrexpr( build_varref( $1 ), $3 ) ); } - | ATTR_IDENTIFIER '(' type_name ')' + | ATTR_IDENTIFIER '(' type ')' { $$ = new ExpressionNode( build_attrtype( build_varref( $1 ), $3 ) ); } // | ANDAND IDENTIFIER // GCC, address of label @@ -569,7 +566,7 @@ cast_expression: unary_expression - | '(' type_name_no_function ')' cast_expression + | '(' type_no_function ')' cast_expression { $$ = new ExpressionNode( build_cast( $2, $4 ) ); } -// | '(' type_name_no_function ')' tuple +// | '(' type_no_function ')' tuple // { $$ = new ExpressionNode( build_cast( $2, $4 ) ); } ; @@ -658,6 +655,4 @@ | logical_OR_expression '?' /* empty */ ':' conditional_expression // GCC, omitted first operand { $$ = new ExpressionNode( build_cond( $1, $1, $4 ) ); } -// | logical_OR_expression '?' comma_expression ':' tuple // CFA, tuple expression -// { $$ = new ExpressionNode( build_cond( $1, $3, $5 ) ); } ; @@ -671,6 +666,4 @@ | unary_expression assignment_operator assignment_expression { $$ = new ExpressionNode( build_binary_ptr( $2, $1, $3 ) ); } -// | tuple assignment_opt // CFA, tuple expression -// { $$ = ( $2 == 0 ) ? $1 : new ExpressionNode( build_binary_ptr( OperKinds::Assign, $1, $2 ) ); } ; @@ -1352,6 +1345,5 @@ basic_declaration_specifier | sue_declaration_specifier - | typedef_declaration_specifier - | typegen_declaration_specifier + | type_declaration_specifier ; @@ -1364,6 +1356,5 @@ basic_declaration_specifier | sue_declaration_specifier_nobody - | typedef_declaration_specifier - | typegen_declaration_specifier + | type_declaration_specifier ; @@ -1371,6 +1362,5 @@ basic_type_specifier | sue_type_specifier - | typedef_type_specifier - | typegen_type_specifier + | type_type_specifier ; @@ -1383,6 +1373,5 @@ basic_type_specifier | sue_type_specifier_nobody - | typedef_type_specifier - | typegen_type_specifier + | type_type_specifier ; @@ -1519,26 +1508,26 @@ basic_type_specifier: - direct_type_name - | type_qualifier_list_opt indirect_type_name type_qualifier_list_opt + direct_type + | type_qualifier_list_opt indirect_type type_qualifier_list_opt { $$ = $2->addQualifiers( $1 )->addQualifiers( $3 ); } ; -direct_type_name: +direct_type: // A semantic check is necessary for conflicting type qualifiers. basic_type_name | type_qualifier_list basic_type_name { $$ = $2->addQualifiers( $1 ); } - | direct_type_name type_qualifier + | direct_type type_qualifier { $$ = $1->addQualifiers( $2 ); } - | direct_type_name basic_type_name + | direct_type basic_type_name { $$ = $1->addType( $2 ); } ; -indirect_type_name: - TYPEOF '(' type_name ')' // GCC: typeof(x) y; +indirect_type: + TYPEOF '(' type ')' // GCC: typeof(x) y; { $$ = $3; } | TYPEOF '(' comma_expression ')' // GCC: typeof(a+b) y; { $$ = DeclarationNode::newTypeof( $3 ); } - | ATTR_TYPEGENname '(' type_name ')' // CFA: e.g., @type(x) y; + | ATTR_TYPEGENname '(' type ')' // CFA: e.g., @type(x) y; { $$ = DeclarationNode::newAttr( $1, $3 ); } | ATTR_TYPEGENname '(' comma_expression ')' // CFA: e.g., @type(a+b) y; @@ -1584,21 +1573,41 @@ ; -typedef_declaration_specifier: - typedef_type_specifier - | declaration_qualifier_list typedef_type_specifier +type_declaration_specifier: + type_type_specifier + | declaration_qualifier_list type_type_specifier { $$ = $2->addQualifiers( $1 ); } - | typedef_declaration_specifier storage_class // remaining OBSOLESCENT (see 2) + | type_declaration_specifier storage_class // remaining OBSOLESCENT (see 2) { $$ = $1->addQualifiers( $2 ); } - | typedef_declaration_specifier storage_class type_qualifier_list + | type_declaration_specifier storage_class type_qualifier_list { $$ = $1->addQualifiers( $2 )->addQualifiers( $3 ); } ; -typedef_type_specifier: // typedef types +type_type_specifier: // typedef types + type_name + | type_qualifier_list type_name + { $$ = $2->addQualifiers( $1 ); } + | type_type_specifier type_qualifier + { $$ = $1->addQualifiers( $2 ); } + ; + +type_name: TYPEDEFname { $$ = DeclarationNode::newFromTypedef( $1 ); } - | type_qualifier_list TYPEDEFname - { $$ = DeclarationNode::newFromTypedef( $2 )->addQualifiers( $1 ); } - | typedef_type_specifier type_qualifier - { $$ = $1->addQualifiers( $2 ); } + | '.' TYPEDEFname + { $$ = DeclarationNode::newFromTypedef( $2 ); } // FIX ME + | type_name '.' TYPEDEFname + { $$ = DeclarationNode::newFromTypedef( $3 ); } // FIX ME + | typegen_name + | '.' typegen_name + { $$ = $2; } // FIX ME + | type_name '.' typegen_name + { $$ = $3; } // FIX ME + ; + +typegen_name: // CFA + TYPEGENname '(' ')' + { $$ = DeclarationNode::newFromTypeGen( $1, nullptr ); } + | TYPEGENname '(' type_list ')' + { $$ = DeclarationNode::newFromTypeGen( $1, $3 ); } ; @@ -1624,5 +1633,5 @@ '{' field_declaration_list '}' { $$ = DeclarationNode::newAggregate( $1, $3, nullptr, $6, true )->addQualifiers( $2 ); } - | aggregate_key attribute_list_opt '(' type_name_list ')' '{' field_declaration_list '}' // CFA + | aggregate_key attribute_list_opt '(' type_list ')' '{' field_declaration_list '}' // CFA { $$ = DeclarationNode::newAggregate( $1, new string( DeclarationNode::anonymous.newName() ), $4, $7, false )->addQualifiers( $2 ); } | aggregate_type_nobody @@ -1630,10 +1639,15 @@ aggregate_type_nobody: // struct, union - {...} - aggregate_key attribute_list_opt no_attr_identifier_or_type_name + aggregate_key attribute_list_opt no_attr_identifier { typedefTable.makeTypedef( *$3 ); $$ = DeclarationNode::newAggregate( $1, $3, nullptr, nullptr, false )->addQualifiers( $2 ); } - | aggregate_key attribute_list_opt typegen_name // CFA, S/R conflict + | aggregate_key attribute_list_opt TYPEDEFname + { + typedefTable.makeTypedef( *$3 ); + $$ = DeclarationNode::newAggregate( $1, $3, nullptr, nullptr, false )->addQualifiers( $2 ); + } + | aggregate_key attribute_list_opt typegen_name // CFA { $$ = $3->addQualifiers( $2 ); } ; @@ -1873,10 +1887,4 @@ ; -no_01_identifier_or_type_name: - no_01_identifier - | TYPEDEFname - | TYPEGENname - ; - no_attr_identifier_or_type_name: no_attr_identifier @@ -1885,5 +1893,5 @@ ; -type_name_no_function: // sizeof, alignof, cast (constructor) +type_no_function: // sizeof, alignof, cast (constructor) cfa_abstract_declarator_tuple // CFA | type_specifier @@ -1892,6 +1900,6 @@ ; -type_name: // typeof, assertion - type_name_no_function +type: // typeof, assertion + type_no_function | cfa_abstract_function // CFA ; @@ -1933,5 +1941,5 @@ designation: designator_list ':' // C99, CFA uses ":" instead of "=" - | no_attr_identifier_or_type_name ':' // GCC, field name + | no_attr_identifier ':' // GCC, field name { $$ = new ExpressionNode( build_varref( $1 ) ); } ; @@ -1945,5 +1953,5 @@ designator: - '.' no_attr_identifier_or_type_name // C99, field name + '.' no_attr_identifier // C99, field name { $$ = new ExpressionNode( build_varref( $2 ) ); } | '[' push assignment_expression pop ']' // C99, single array element @@ -1976,31 +1984,16 @@ // on type arguments of polymorphic functions. -typegen_declaration_specifier: // CFA - typegen_type_specifier - | declaration_qualifier_list typegen_type_specifier - { $$ = $2->addQualifiers( $1 ); } - | typegen_declaration_specifier storage_class // remaining OBSOLESCENT (see 2) - { $$ = $1->addQualifiers( $2 ); } - | typegen_declaration_specifier storage_class type_qualifier_list - { $$ = $1->addQualifiers( $2 )->addQualifiers( $3 ); } - ; - -typegen_type_specifier: // CFA - typegen_name - | type_qualifier_list typegen_name - { $$ = $2->addQualifiers( $1 ); } - | typegen_type_specifier type_qualifier - { $$ = $1->addQualifiers( $2 ); } - ; - -typegen_name: // CFA - TYPEGENname '(' type_name_list ')' - { $$ = DeclarationNode::newFromTypeGen( $1, $3 ); } - ; - type_parameter_list: // CFA - type_parameter assignment_opt - | type_parameter_list ',' type_parameter assignment_opt + type_parameter + { $$ = $1; } + | type_parameter_list ',' type_parameter { $$ = $1->appendList( $3 ); } + ; + +type_initializer_opt: // CFA + // empty + { $$ = nullptr; } + | '=' type + { $$ = $2; } ; @@ -2008,6 +2001,6 @@ type_class no_attr_identifier_or_type_name { typedefTable.addToEnclosingScope( *$2, TypedefTable::TD ); } - assertion_list_opt - { $$ = DeclarationNode::newTypeParam( $1, $2 )->addAssertions( $4 ); } + type_initializer_opt assertion_list_opt + { $$ = DeclarationNode::newTypeParam( $1, $2 )->addTypeInitializer( $4 )->addAssertions( $5 ); } | type_specifier identifier_parameter_declarator ; @@ -2032,5 +2025,5 @@ assertion: // CFA - '|' no_attr_identifier_or_type_name '(' type_name_list ')' + '|' no_attr_identifier_or_type_name '(' type_list ')' { typedefTable.openTrait( *$2 ); @@ -2039,15 +2032,15 @@ | '|' '{' push trait_declaration_list '}' { $$ = $4; } - | '|' '(' push type_parameter_list pop ')' '{' push trait_declaration_list '}' '(' type_name_list ')' + | '|' '(' push type_parameter_list pop ')' '{' push trait_declaration_list '}' '(' type_list ')' { $$ = nullptr; } ; -type_name_list: // CFA - type_name +type_list: // CFA + type { $$ = new ExpressionNode( build_typevalue( $1 ) ); } | assignment_expression - | type_name_list ',' type_name + | type_list ',' type { $$ = (ExpressionNode *)( $1->set_last( new ExpressionNode( build_typevalue( $3 ) ) ) ); } - | type_name_list ',' assignment_expression + | type_list ',' assignment_expression { $$ = (ExpressionNode *)( $1->set_last( $3 )); } ; @@ -2065,5 +2058,5 @@ type_declarator_name assertion_list_opt { $$ = $1->addAssertions( $2 ); } - | type_declarator_name assertion_list_opt '=' type_name + | type_declarator_name assertion_list_opt '=' type { $$ = $1->addAssertions( $2 )->addType( $4 ); } ; @@ -2075,5 +2068,5 @@ $$ = DeclarationNode::newTypeDecl( $1, 0 ); } - | no_01_identifier_or_type_name '(' push type_parameter_list pop ')' + | no_attr_identifier_or_type_name '(' push type_parameter_list pop ')' { typedefTable.addToEnclosingScope( *$1, TypedefTable::TG ); @@ -2101,5 +2094,5 @@ ; -trait_declaration_list: // CFA +trait_declaration_list: // CFA trait_declaration | trait_declaration_list push trait_declaration @@ -2107,5 +2100,5 @@ ; -trait_declaration: // CFA +trait_declaration: // CFA cfa_trait_declaring_list pop ';' | trait_declaring_list pop ';' Index: src/ResolvExpr/AlternativeFinder.cc =================================================================== --- src/ResolvExpr/AlternativeFinder.cc (revision ff98952225b16a68fb22c007b5495c78ef23158e) +++ src/ResolvExpr/AlternativeFinder.cc (revision 4a3685479ce3ea742a9282c31d31ce031849e49c) @@ -627,4 +627,5 @@ TypeEnvironment resultEnv; makeUnifiableVars( funcType, openVars, resultNeed ); + resultEnv.add( funcType->get_forall() ); // add all type variables as open variables now so that those not used in the parameter list are still considered open AltList instantiatedActuals; // filled by instantiate function if ( targetType && ! targetType->isVoid() && ! funcType->get_returnVals().empty() ) { Index: src/ResolvExpr/CastCost.cc =================================================================== --- src/ResolvExpr/CastCost.cc (revision ff98952225b16a68fb22c007b5495c78ef23158e) +++ src/ResolvExpr/CastCost.cc (revision 4a3685479ce3ea742a9282c31d31ce031849e49c) @@ -5,5 +5,5 @@ // file "LICENCE" distributed with Cforall. // -// CastCost.cc -- +// CastCost.cc -- // // Author : Richard C. Bilson @@ -26,5 +26,5 @@ public: CastCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env ); - + virtual void visit( BasicType *basicType ); virtual void visit( PointerType *pointerType ); @@ -36,5 +36,9 @@ NamedTypeDecl *namedType; if ( env.lookup( destAsTypeInst->get_name(), eqvClass ) ) { - return castCost( src, eqvClass.type, indexer, env ); + if ( eqvClass.type ) { + return castCost( src, eqvClass.type, indexer, env ); + } else { + return Cost::infinity; + } } else if ( ( namedType = indexer.lookupType( destAsTypeInst->get_name() ) ) ) { TypeDecl *type = dynamic_cast< TypeDecl* >( namedType ); Index: src/ResolvExpr/ConversionCost.cc =================================================================== --- src/ResolvExpr/ConversionCost.cc (revision ff98952225b16a68fb22c007b5495c78ef23158e) +++ src/ResolvExpr/ConversionCost.cc (revision 4a3685479ce3ea742a9282c31d31ce031849e49c) @@ -30,5 +30,9 @@ /// std::cout << "type inst " << destAsTypeInst->get_name(); if ( env.lookup( destAsTypeInst->get_name(), eqvClass ) ) { - return conversionCost( src, eqvClass.type, indexer, env ); + if ( eqvClass.type ) { + return conversionCost( src, eqvClass.type, indexer, env ); + } else { + return Cost::infinity; + } } else if ( ( namedType = indexer.lookupType( destAsTypeInst->get_name() ) ) ) { /// std::cout << " found" << std::endl; Index: src/ResolvExpr/Resolver.cc =================================================================== --- src/ResolvExpr/Resolver.cc (revision ff98952225b16a68fb22c007b5495c78ef23158e) +++ src/ResolvExpr/Resolver.cc (revision 4a3685479ce3ea742a9282c31d31ce031849e49c) @@ -124,5 +124,5 @@ } // if #endif - assert( finder.get_alternatives().size() == 1 ); + assertf( finder.get_alternatives().size() == 1, "findSingleExpression: must have exactly one alternative at the end." ); Alternative &choice = finder.get_alternatives().front(); Expression *newExpr = choice.expr->clone(); @@ -397,5 +397,5 @@ // // cerr << type << endl; // // } // for - + // // O(N^2) checks of d-types with f-types // // find the minimum cost Index: src/ResolvExpr/Unify.cc =================================================================== --- src/ResolvExpr/Unify.cc (revision ff98952225b16a68fb22c007b5495c78ef23158e) +++ src/ResolvExpr/Unify.cc (revision 4a3685479ce3ea742a9282c31d31ce031849e49c) @@ -344,5 +344,5 @@ std::cerr << "unifyInexact type 1 is "; type1->print( std::cerr ); - std::cerr << "type 2 is "; + std::cerr << " type 2 is "; type2->print( std::cerr ); std::cerr << std::endl; @@ -595,5 +595,5 @@ TypeExpr *otherParam = dynamic_cast< TypeExpr* >(*jt); assertf(otherParam, "Aggregate parameters should be type expressions"); - + Type* paramTy = param->get_type(); Type* otherParamTy = otherParam->get_type(); Index: src/SymTab/FixFunction.cc =================================================================== --- src/SymTab/FixFunction.cc (revision ff98952225b16a68fb22c007b5495c78ef23158e) +++ src/SymTab/FixFunction.cc (revision 4a3685479ce3ea742a9282c31d31ce031849e49c) @@ -24,6 +24,8 @@ DeclarationWithType * FixFunction::mutate(FunctionDecl *functionDecl) { - ObjectDecl *pointer = new ObjectDecl( functionDecl->get_name(), functionDecl->get_storageClasses(), functionDecl->get_linkage(), 0, new PointerType( Type::Qualifiers(), functionDecl->get_type()->clone() ), 0, functionDecl->get_attributes() ); + ObjectDecl *pointer = new ObjectDecl( functionDecl->get_name(), functionDecl->get_storageClasses(), functionDecl->get_linkage(), 0, new PointerType( Type::Qualifiers(), functionDecl->get_type() ), 0, functionDecl->get_attributes() ); functionDecl->get_attributes().clear(); + // can't delete function type because it may contain assertions, but can't transfer ownership without a clone since set_type checks for nullptr + functionDecl->set_type( functionDecl->get_type()->clone() ); delete functionDecl; return pointer; Index: src/SymTab/Indexer.cc =================================================================== --- src/SymTab/Indexer.cc (revision ff98952225b16a68fb22c007b5495c78ef23158e) +++ src/SymTab/Indexer.cc (revision 4a3685479ce3ea742a9282c31d31ce031849e49c) @@ -124,8 +124,9 @@ }; // properties for this type - bool userDefinedFunc = false; // any user-defined function found - bool userDefinedCtor = false; // any user-defined constructor found - bool userDefinedDtor = false; // any user-defined destructor found - bool userDefinedCopyFunc = false; // user-defined copy ctor found + bool existsUserDefinedFunc = false; // any user-defined function found + bool existsUserDefinedCtor = false; // any user-defined constructor found + bool existsUserDefinedDtor = false; // any user-defined destructor found + bool existsUserDefinedCopyFunc = false; // user-defined copy ctor found + bool existsUserDefinedDefaultCtor = false; // user-defined default ctor found std::list< DeclBall > decls; @@ -138,8 +139,9 @@ bool isCopyFunc = InitTweak::isCopyFunction( function, function->get_name() ); decls.push_back( DeclBall{ function, isUserDefinedFunc, isDefaultCtor, isDtor, isCopyFunc } ); - userDefinedFunc = userDefinedFunc || isUserDefinedFunc; - userDefinedCtor = userDefinedCtor || (isUserDefinedFunc && InitTweak::isConstructor( function->get_name() ) ); - userDefinedDtor = userDefinedDtor || (isUserDefinedFunc && isDtor); - userDefinedCopyFunc = userDefinedCopyFunc || (isUserDefinedFunc && isCopyFunc); + existsUserDefinedFunc = existsUserDefinedFunc || isUserDefinedFunc; + existsUserDefinedCtor = existsUserDefinedCtor || (isUserDefinedFunc && InitTweak::isConstructor( function->get_name() ) ); + existsUserDefinedDtor = existsUserDefinedDtor || (isUserDefinedFunc && isDtor); + existsUserDefinedCopyFunc = existsUserDefinedCopyFunc || (isUserDefinedFunc && isCopyFunc); + existsUserDefinedDefaultCtor = existsUserDefinedDefaultCtor || (isUserDefinedFunc && isDefaultCtor); return *this; } @@ -163,13 +165,19 @@ } - // if a type contains user defined ctor/dtors, then special rules trigger, which determine - // the set of ctor/dtors that are seen by the requester. In particular, if the user defines + // if a type contains user defined ctor/dtor/assign, then special rules trigger, which determine + // the set of ctor/dtor/assign that are seen by the requester. In particular, if the user defines // a default ctor, then the generated default ctor should never be seen, likewise for copy ctor // and dtor. If the user defines any ctor/dtor, then no generated field ctors should be seen. - // If the user defines any ctor then the generated default ctor should not be seen. + // If the user defines any ctor then the generated default ctor should not be seen (intrinsic default + // ctor must be overridden exactly). for ( std::pair< const std::string, ValueType > & pair : funcMap ) { ValueType & val = pair.second; for ( ValueType::DeclBall ball : val.decls ) { - if ( ! val.userDefinedFunc || ball.isUserDefinedFunc || (! val.userDefinedCtor && ball.isDefaultCtor) || (! val.userDefinedCopyFunc && ball.isCopyFunc) || (! val.userDefinedDtor && ball.isDtor) ) { + bool noUserDefinedFunc = ! val.existsUserDefinedFunc; + bool isUserDefinedFunc = ball.isUserDefinedFunc; + bool isAcceptableDefaultCtor = (! val.existsUserDefinedCtor || (! val.existsUserDefinedDefaultCtor && ball.decl->get_linkage() == LinkageSpec::Intrinsic)) && ball.isDefaultCtor; // allow default constructors only when no user-defined constructors exist, except in the case of intrinsics, which require exact overrides + bool isAcceptableCopyFunc = ! val.existsUserDefinedCopyFunc && ball.isCopyFunc; // handles copy ctor and assignment operator + bool isAcceptableDtor = ! val.existsUserDefinedDtor && ball.isDtor; + if ( noUserDefinedFunc || isUserDefinedFunc || isAcceptableDefaultCtor || isAcceptableCopyFunc || isAcceptableDtor ) { // decl conforms to the rules described above, so it should be seen by the requester out.push_back( ball.decl ); @@ -277,4 +285,5 @@ addType( typeDecl ); acceptAll( typeDecl->get_assertions(), *this ); + acceptNewScope( typeDecl->get_init(), *this ); } Index: src/SymTab/Validate.cc =================================================================== --- src/SymTab/Validate.cc (revision ff98952225b16a68fb22c007b5495c78ef23158e) +++ src/SymTab/Validate.cc (revision 4a3685479ce3ea742a9282c31d31ce031849e49c) @@ -506,4 +506,5 @@ void LinkReferenceToTypes::visit( StructDecl *structDecl ) { // visit struct members first so that the types of self-referencing members are updated properly + // xxx - need to ensure that type parameters match up between forward declarations and definition (most importantly, number of type parameters and and their defaults) Parent::visit( structDecl ); if ( ! structDecl->get_members().empty() ) { @@ -844,4 +845,29 @@ if ( params != NULL ) { std::list< Expression * > & args = inst->get_parameters(); + + // insert defaults arguments when a type argument is missing (currently only supports missing arguments at the end of the list). + // A substitution is used to ensure that defaults are replaced correctly, e.g., + // forall(otype T, otype alloc = heap_allocator(T)) struct vector; + // vector(int) v; + // after insertion of default values becomes + // vector(int, heap_allocator(T)) + // and the substitution is built with T=int so that after substitution, the result is + // vector(int, heap_allocator(int)) + TypeSubstitution sub; + auto paramIter = params->begin(); + for ( size_t i = 0; paramIter != params->end(); ++paramIter, ++i ) { + if ( i < args.size() ) { + TypeExpr * expr = safe_dynamic_cast< TypeExpr * >( *std::next( args.begin(), i ) ); + sub.add( (*paramIter)->get_name(), expr->get_type()->clone() ); + } else if ( i == args.size() ) { + Type * defaultType = (*paramIter)->get_init(); + if ( defaultType ) { + args.push_back( new TypeExpr( defaultType->clone() ) ); + sub.add( (*paramIter)->get_name(), defaultType->clone() ); + } + } + } + + sub.apply( inst ); if ( args.size() < params->size() ) throw SemanticError( "Too few type arguments in generic type ", inst ); if ( args.size() > params->size() ) throw SemanticError( "Too many type arguments in generic type ", inst ); Index: src/SynTree/Declaration.h =================================================================== --- src/SynTree/Declaration.h (revision ff98952225b16a68fb22c007b5495c78ef23158e) +++ src/SynTree/Declaration.h (revision 4a3685479ce3ea742a9282c31d31ce031849e49c) @@ -194,8 +194,12 @@ }; - TypeDecl( const std::string &name, Type::StorageClasses scs, Type *type, Kind kind ); + TypeDecl( const std::string &name, Type::StorageClasses scs, Type *type, Kind kind, Type * init = nullptr ); TypeDecl( const TypeDecl &other ); + virtual ~TypeDecl(); Kind get_kind() const { return kind; } + + Type * get_init() const { return init; } + TypeDecl * set_init( Type * newValue ) { init = newValue; return this; } bool isComplete() const { return kind == Any || sized; } @@ -209,6 +213,9 @@ virtual void accept( Visitor &v ) { v.visit( this ); } virtual TypeDecl *acceptMutator( Mutator &m ) { return m.mutate( this ); } + virtual void print( std::ostream &os, int indent = 0 ) const; + private: Kind kind; + Type * init; bool sized; }; Index: src/SynTree/Mutator.cc =================================================================== --- src/SynTree/Mutator.cc (revision ff98952225b16a68fb22c007b5495c78ef23158e) +++ src/SynTree/Mutator.cc (revision 4a3685479ce3ea742a9282c31d31ce031849e49c) @@ -77,4 +77,5 @@ TypeDecl *Mutator::mutate( TypeDecl *typeDecl ) { handleNamedTypeDecl( typeDecl ); + typeDecl->set_init( maybeMutate( typeDecl->get_init(), *this ) ); return typeDecl; } Index: src/SynTree/TypeDecl.cc =================================================================== --- src/SynTree/TypeDecl.cc (revision ff98952225b16a68fb22c007b5495c78ef23158e) +++ src/SynTree/TypeDecl.cc (revision 4a3685479ce3ea742a9282c31d31ce031849e49c) @@ -18,8 +18,12 @@ #include "Common/utility.h" -TypeDecl::TypeDecl( const std::string &name, Type::StorageClasses scs, Type *type, Kind kind ) : Parent( name, scs, type ), kind( kind ), sized( kind == Any || kind == Ttype ) { +TypeDecl::TypeDecl( const std::string &name, Type::StorageClasses scs, Type *type, Kind kind, Type * init ) : Parent( name, scs, type ), kind( kind ), init( init ), sized( kind == Any || kind == Ttype ) { } -TypeDecl::TypeDecl( const TypeDecl &other ) : Parent( other ), kind( other.kind ), sized( other.sized ) { +TypeDecl::TypeDecl( const TypeDecl &other ) : Parent( other ), kind( other.kind ), init( maybeClone( other.init ) ), sized( other.sized ) { +} + +TypeDecl::~TypeDecl() { + delete init; } @@ -34,4 +38,13 @@ } +void TypeDecl::print( std::ostream &os, int indent ) const { + NamedTypeDecl::print( os, indent ); + if ( init ) { + os << std::endl << std::string( indent, ' ' ) << "with type initializer: "; + init->print( os, indent + 2 ); + } +} + + std::ostream & operator<<( std::ostream & os, const TypeDecl::Data & data ) { return os << data.kind << ", " << data.isComplete; Index: src/SynTree/Visitor.cc =================================================================== --- src/SynTree/Visitor.cc (revision ff98952225b16a68fb22c007b5495c78ef23158e) +++ src/SynTree/Visitor.cc (revision 4a3685479ce3ea742a9282c31d31ce031849e49c) @@ -67,4 +67,5 @@ void Visitor::visit( TypeDecl *typeDecl ) { handleNamedTypeDecl( static_cast< NamedTypeDecl* >( typeDecl ) ); + maybeAccept( typeDecl->get_init(), *this ); } Index: src/Tuples/TupleExpansion.cc =================================================================== --- src/Tuples/TupleExpansion.cc (revision ff98952225b16a68fb22c007b5495c78ef23158e) +++ src/Tuples/TupleExpansion.cc (revision 4a3685479ce3ea742a9282c31d31ce031849e49c) @@ -332,5 +332,5 @@ TypeInstType * isTtype( Type * type ) { if ( TypeInstType * inst = dynamic_cast< TypeInstType * >( type ) ) { - if ( inst->get_baseType()->get_kind() == TypeDecl::Ttype ) { + if ( inst->get_baseType() && inst->get_baseType()->get_kind() == TypeDecl::Ttype ) { return inst; } Index: src/libcfa/Makefile.am =================================================================== --- src/libcfa/Makefile.am (revision ff98952225b16a68fb22c007b5495c78ef23158e) +++ src/libcfa/Makefile.am (revision 4a3685479ce3ea742a9282c31d31ce031849e49c) @@ -41,5 +41,6 @@ CC = ${abs_top_srcdir}/src/driver/cfa -headers = limits stdlib math iostream fstream iterator rational assert containers/pair containers/vector +headers = assert fstream iostream iterator limits math rational stdlib \ + containers/maybe containers/pair containers/result containers/vector # not all platforms support concurrency, add option do disable it Index: src/libcfa/Makefile.in =================================================================== --- src/libcfa/Makefile.in (revision ff98952225b16a68fb22c007b5495c78ef23158e) +++ src/libcfa/Makefile.in (revision 4a3685479ce3ea742a9282c31d31ce031849e49c) @@ -98,10 +98,10 @@ libcfa_d_a_LIBADD = am__libcfa_d_a_SOURCES_DIST = libcfa-prelude.c interpose.c \ - libhdr/libdebug.c limits.c stdlib.c math.c iostream.c \ - fstream.c iterator.c rational.c assert.c containers/pair.c \ - containers/vector.c concurrency/coroutine.c \ - concurrency/thread.c concurrency/kernel.c \ - concurrency/monitor.c concurrency/CtxSwitch-@MACHINE_TYPE@.S \ - concurrency/invoke.c + libhdr/libdebug.c assert.c fstream.c iostream.c iterator.c \ + limits.c math.c rational.c stdlib.c containers/maybe.c \ + containers/pair.c containers/result.c containers/vector.c \ + concurrency/coroutine.c concurrency/thread.c \ + concurrency/kernel.c concurrency/monitor.c \ + concurrency/CtxSwitch-@MACHINE_TYPE@.S concurrency/invoke.c am__dirstamp = $(am__leading_dot)dirstamp @BUILD_CONCURRENCY_TRUE@am__objects_1 = concurrency/libcfa_d_a-coroutine.$(OBJEXT) \ @@ -109,10 +109,12 @@ @BUILD_CONCURRENCY_TRUE@ concurrency/libcfa_d_a-kernel.$(OBJEXT) \ @BUILD_CONCURRENCY_TRUE@ concurrency/libcfa_d_a-monitor.$(OBJEXT) -am__objects_2 = libcfa_d_a-limits.$(OBJEXT) \ - libcfa_d_a-stdlib.$(OBJEXT) libcfa_d_a-math.$(OBJEXT) \ - libcfa_d_a-iostream.$(OBJEXT) libcfa_d_a-fstream.$(OBJEXT) \ - libcfa_d_a-iterator.$(OBJEXT) libcfa_d_a-rational.$(OBJEXT) \ - libcfa_d_a-assert.$(OBJEXT) \ +am__objects_2 = libcfa_d_a-assert.$(OBJEXT) \ + libcfa_d_a-fstream.$(OBJEXT) libcfa_d_a-iostream.$(OBJEXT) \ + libcfa_d_a-iterator.$(OBJEXT) libcfa_d_a-limits.$(OBJEXT) \ + libcfa_d_a-math.$(OBJEXT) libcfa_d_a-rational.$(OBJEXT) \ + libcfa_d_a-stdlib.$(OBJEXT) \ + containers/libcfa_d_a-maybe.$(OBJEXT) \ containers/libcfa_d_a-pair.$(OBJEXT) \ + containers/libcfa_d_a-result.$(OBJEXT) \ containers/libcfa_d_a-vector.$(OBJEXT) $(am__objects_1) @BUILD_CONCURRENCY_TRUE@am__objects_3 = concurrency/CtxSwitch-@MACHINE_TYPE@.$(OBJEXT) \ @@ -127,19 +129,21 @@ libcfa_a_LIBADD = am__libcfa_a_SOURCES_DIST = libcfa-prelude.c interpose.c \ - libhdr/libdebug.c limits.c stdlib.c math.c iostream.c \ - fstream.c iterator.c rational.c assert.c containers/pair.c \ - containers/vector.c concurrency/coroutine.c \ - concurrency/thread.c concurrency/kernel.c \ - concurrency/monitor.c concurrency/CtxSwitch-@MACHINE_TYPE@.S \ - concurrency/invoke.c + libhdr/libdebug.c assert.c fstream.c iostream.c iterator.c \ + limits.c math.c rational.c stdlib.c containers/maybe.c \ + containers/pair.c containers/result.c containers/vector.c \ + concurrency/coroutine.c concurrency/thread.c \ + concurrency/kernel.c concurrency/monitor.c \ + concurrency/CtxSwitch-@MACHINE_TYPE@.S concurrency/invoke.c @BUILD_CONCURRENCY_TRUE@am__objects_5 = concurrency/libcfa_a-coroutine.$(OBJEXT) \ @BUILD_CONCURRENCY_TRUE@ concurrency/libcfa_a-thread.$(OBJEXT) \ @BUILD_CONCURRENCY_TRUE@ concurrency/libcfa_a-kernel.$(OBJEXT) \ @BUILD_CONCURRENCY_TRUE@ concurrency/libcfa_a-monitor.$(OBJEXT) -am__objects_6 = libcfa_a-limits.$(OBJEXT) libcfa_a-stdlib.$(OBJEXT) \ - libcfa_a-math.$(OBJEXT) libcfa_a-iostream.$(OBJEXT) \ - libcfa_a-fstream.$(OBJEXT) libcfa_a-iterator.$(OBJEXT) \ - libcfa_a-rational.$(OBJEXT) libcfa_a-assert.$(OBJEXT) \ +am__objects_6 = libcfa_a-assert.$(OBJEXT) libcfa_a-fstream.$(OBJEXT) \ + libcfa_a-iostream.$(OBJEXT) libcfa_a-iterator.$(OBJEXT) \ + libcfa_a-limits.$(OBJEXT) libcfa_a-math.$(OBJEXT) \ + libcfa_a-rational.$(OBJEXT) libcfa_a-stdlib.$(OBJEXT) \ + containers/libcfa_a-maybe.$(OBJEXT) \ containers/libcfa_a-pair.$(OBJEXT) \ + containers/libcfa_a-result.$(OBJEXT) \ containers/libcfa_a-vector.$(OBJEXT) $(am__objects_5) @BUILD_CONCURRENCY_TRUE@am__objects_7 = concurrency/CtxSwitch-@MACHINE_TYPE@.$(OBJEXT) \ @@ -179,9 +183,9 @@ DIST_SOURCES = $(am__libcfa_d_a_SOURCES_DIST) \ $(am__libcfa_a_SOURCES_DIST) -am__nobase_cfa_include_HEADERS_DIST = limits stdlib math iostream \ - fstream iterator rational assert containers/pair \ - containers/vector concurrency/coroutine concurrency/thread \ - concurrency/kernel concurrency/monitor ${shell echo stdhdr/*} \ - gmp concurrency/invoke.h +am__nobase_cfa_include_HEADERS_DIST = assert fstream iostream iterator \ + limits math rational stdlib containers/maybe containers/pair \ + containers/result containers/vector concurrency/coroutine \ + concurrency/thread concurrency/kernel concurrency/monitor \ + ${shell echo stdhdr/*} gmp concurrency/invoke.h HEADERS = $(nobase_cfa_include_HEADERS) ETAGS = etags @@ -313,6 +317,7 @@ EXTRA_FLAGS = -g -Wall -Werror -Wno-unused-function -I${abs_top_srcdir}/src/libcfa/libhdr -imacros libcfa-prelude.c @CFA_FLAGS@ AM_CCASFLAGS = @CFA_FLAGS@ -headers = limits stdlib math iostream fstream iterator rational assert \ - containers/pair containers/vector $(am__append_3) +headers = assert fstream iostream iterator limits math rational stdlib \ + containers/maybe containers/pair containers/result \ + containers/vector $(am__append_3) libobjs = ${headers:=.o} libsrc = libcfa-prelude.c interpose.c libhdr/libdebug.c ${headers:=.c} \ @@ -404,5 +409,9 @@ @$(MKDIR_P) containers/$(DEPDIR) @: > containers/$(DEPDIR)/$(am__dirstamp) +containers/libcfa_d_a-maybe.$(OBJEXT): containers/$(am__dirstamp) \ + containers/$(DEPDIR)/$(am__dirstamp) containers/libcfa_d_a-pair.$(OBJEXT): containers/$(am__dirstamp) \ + containers/$(DEPDIR)/$(am__dirstamp) +containers/libcfa_d_a-result.$(OBJEXT): containers/$(am__dirstamp) \ containers/$(DEPDIR)/$(am__dirstamp) containers/libcfa_d_a-vector.$(OBJEXT): containers/$(am__dirstamp) \ @@ -434,5 +443,9 @@ libhdr/libcfa_a-libdebug.$(OBJEXT): libhdr/$(am__dirstamp) \ libhdr/$(DEPDIR)/$(am__dirstamp) +containers/libcfa_a-maybe.$(OBJEXT): containers/$(am__dirstamp) \ + containers/$(DEPDIR)/$(am__dirstamp) containers/libcfa_a-pair.$(OBJEXT): containers/$(am__dirstamp) \ + containers/$(DEPDIR)/$(am__dirstamp) +containers/libcfa_a-result.$(OBJEXT): containers/$(am__dirstamp) \ containers/$(DEPDIR)/$(am__dirstamp) containers/libcfa_a-vector.$(OBJEXT): containers/$(am__dirstamp) \ @@ -466,7 +479,11 @@ -rm -f concurrency/libcfa_d_a-monitor.$(OBJEXT) -rm -f concurrency/libcfa_d_a-thread.$(OBJEXT) + -rm -f containers/libcfa_a-maybe.$(OBJEXT) -rm -f containers/libcfa_a-pair.$(OBJEXT) + -rm -f containers/libcfa_a-result.$(OBJEXT) -rm -f containers/libcfa_a-vector.$(OBJEXT) + -rm -f containers/libcfa_d_a-maybe.$(OBJEXT) -rm -f containers/libcfa_d_a-pair.$(OBJEXT) + -rm -f containers/libcfa_d_a-result.$(OBJEXT) -rm -f containers/libcfa_d_a-vector.$(OBJEXT) -rm -f libhdr/libcfa_a-libdebug.$(OBJEXT) @@ -507,7 +524,11 @@ @AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_d_a-monitor.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_d_a-thread.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@containers/$(DEPDIR)/libcfa_a-maybe.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@containers/$(DEPDIR)/libcfa_a-pair.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@containers/$(DEPDIR)/libcfa_a-result.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@containers/$(DEPDIR)/libcfa_a-vector.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@containers/$(DEPDIR)/libcfa_d_a-maybe.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@containers/$(DEPDIR)/libcfa_d_a-pair.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@containers/$(DEPDIR)/libcfa_d_a-result.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@containers/$(DEPDIR)/libcfa_d_a-vector.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@libhdr/$(DEPDIR)/libcfa_a-libdebug.Po@am__quote@ @@ -581,4 +602,60 @@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o libhdr/libcfa_d_a-libdebug.obj `if test -f 'libhdr/libdebug.c'; then $(CYGPATH_W) 'libhdr/libdebug.c'; else $(CYGPATH_W) '$(srcdir)/libhdr/libdebug.c'; fi` +libcfa_d_a-assert.o: assert.c +@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-assert.o -MD -MP -MF $(DEPDIR)/libcfa_d_a-assert.Tpo -c -o libcfa_d_a-assert.o `test -f 'assert.c' || echo '$(srcdir)/'`assert.c +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-assert.Tpo $(DEPDIR)/libcfa_d_a-assert.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='assert.c' object='libcfa_d_a-assert.o' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o libcfa_d_a-assert.o `test -f 'assert.c' || echo '$(srcdir)/'`assert.c + +libcfa_d_a-assert.obj: assert.c +@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-assert.obj -MD -MP -MF $(DEPDIR)/libcfa_d_a-assert.Tpo -c -o libcfa_d_a-assert.obj `if test -f 'assert.c'; then $(CYGPATH_W) 'assert.c'; else $(CYGPATH_W) '$(srcdir)/assert.c'; fi` +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-assert.Tpo $(DEPDIR)/libcfa_d_a-assert.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='assert.c' object='libcfa_d_a-assert.obj' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o libcfa_d_a-assert.obj `if test -f 'assert.c'; then $(CYGPATH_W) 'assert.c'; else $(CYGPATH_W) '$(srcdir)/assert.c'; fi` + +libcfa_d_a-fstream.o: fstream.c +@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-fstream.o -MD -MP -MF $(DEPDIR)/libcfa_d_a-fstream.Tpo -c -o libcfa_d_a-fstream.o `test -f 'fstream.c' || echo '$(srcdir)/'`fstream.c +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-fstream.Tpo $(DEPDIR)/libcfa_d_a-fstream.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='fstream.c' object='libcfa_d_a-fstream.o' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o libcfa_d_a-fstream.o `test -f 'fstream.c' || echo '$(srcdir)/'`fstream.c + +libcfa_d_a-fstream.obj: fstream.c +@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-fstream.obj -MD -MP -MF $(DEPDIR)/libcfa_d_a-fstream.Tpo -c -o libcfa_d_a-fstream.obj `if test -f 'fstream.c'; then $(CYGPATH_W) 'fstream.c'; else $(CYGPATH_W) '$(srcdir)/fstream.c'; fi` +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-fstream.Tpo $(DEPDIR)/libcfa_d_a-fstream.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='fstream.c' object='libcfa_d_a-fstream.obj' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o libcfa_d_a-fstream.obj `if test -f 'fstream.c'; then $(CYGPATH_W) 'fstream.c'; else $(CYGPATH_W) '$(srcdir)/fstream.c'; fi` + +libcfa_d_a-iostream.o: iostream.c +@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-iostream.o -MD -MP -MF $(DEPDIR)/libcfa_d_a-iostream.Tpo -c -o libcfa_d_a-iostream.o `test -f 'iostream.c' || echo '$(srcdir)/'`iostream.c +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-iostream.Tpo $(DEPDIR)/libcfa_d_a-iostream.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='iostream.c' object='libcfa_d_a-iostream.o' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o libcfa_d_a-iostream.o `test -f 'iostream.c' || echo '$(srcdir)/'`iostream.c + +libcfa_d_a-iostream.obj: iostream.c +@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-iostream.obj -MD -MP -MF $(DEPDIR)/libcfa_d_a-iostream.Tpo -c -o libcfa_d_a-iostream.obj `if test -f 'iostream.c'; then $(CYGPATH_W) 'iostream.c'; else $(CYGPATH_W) '$(srcdir)/iostream.c'; fi` +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-iostream.Tpo $(DEPDIR)/libcfa_d_a-iostream.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='iostream.c' object='libcfa_d_a-iostream.obj' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o libcfa_d_a-iostream.obj `if test -f 'iostream.c'; then $(CYGPATH_W) 'iostream.c'; else $(CYGPATH_W) '$(srcdir)/iostream.c'; fi` + +libcfa_d_a-iterator.o: iterator.c +@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-iterator.o -MD -MP -MF $(DEPDIR)/libcfa_d_a-iterator.Tpo -c -o libcfa_d_a-iterator.o `test -f 'iterator.c' || echo '$(srcdir)/'`iterator.c +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-iterator.Tpo $(DEPDIR)/libcfa_d_a-iterator.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='iterator.c' object='libcfa_d_a-iterator.o' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o libcfa_d_a-iterator.o `test -f 'iterator.c' || echo '$(srcdir)/'`iterator.c + +libcfa_d_a-iterator.obj: iterator.c +@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-iterator.obj -MD -MP -MF $(DEPDIR)/libcfa_d_a-iterator.Tpo -c -o libcfa_d_a-iterator.obj `if test -f 'iterator.c'; then $(CYGPATH_W) 'iterator.c'; else $(CYGPATH_W) '$(srcdir)/iterator.c'; fi` +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-iterator.Tpo $(DEPDIR)/libcfa_d_a-iterator.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='iterator.c' object='libcfa_d_a-iterator.obj' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o libcfa_d_a-iterator.obj `if test -f 'iterator.c'; then $(CYGPATH_W) 'iterator.c'; else $(CYGPATH_W) '$(srcdir)/iterator.c'; fi` + libcfa_d_a-limits.o: limits.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-limits.o -MD -MP -MF $(DEPDIR)/libcfa_d_a-limits.Tpo -c -o libcfa_d_a-limits.o `test -f 'limits.c' || echo '$(srcdir)/'`limits.c @@ -595,4 +672,32 @@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o libcfa_d_a-limits.obj `if test -f 'limits.c'; then $(CYGPATH_W) 'limits.c'; else $(CYGPATH_W) '$(srcdir)/limits.c'; fi` +libcfa_d_a-math.o: math.c +@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-math.o -MD -MP -MF $(DEPDIR)/libcfa_d_a-math.Tpo -c -o libcfa_d_a-math.o `test -f 'math.c' || echo '$(srcdir)/'`math.c +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-math.Tpo $(DEPDIR)/libcfa_d_a-math.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='math.c' object='libcfa_d_a-math.o' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o libcfa_d_a-math.o `test -f 'math.c' || echo '$(srcdir)/'`math.c + +libcfa_d_a-math.obj: math.c +@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-math.obj -MD -MP -MF $(DEPDIR)/libcfa_d_a-math.Tpo -c -o libcfa_d_a-math.obj `if test -f 'math.c'; then $(CYGPATH_W) 'math.c'; else $(CYGPATH_W) '$(srcdir)/math.c'; fi` +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-math.Tpo $(DEPDIR)/libcfa_d_a-math.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='math.c' object='libcfa_d_a-math.obj' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o libcfa_d_a-math.obj `if test -f 'math.c'; then $(CYGPATH_W) 'math.c'; else $(CYGPATH_W) '$(srcdir)/math.c'; fi` + +libcfa_d_a-rational.o: rational.c +@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-rational.o -MD -MP -MF $(DEPDIR)/libcfa_d_a-rational.Tpo -c -o libcfa_d_a-rational.o `test -f 'rational.c' || echo '$(srcdir)/'`rational.c +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-rational.Tpo $(DEPDIR)/libcfa_d_a-rational.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='rational.c' object='libcfa_d_a-rational.o' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o libcfa_d_a-rational.o `test -f 'rational.c' || echo '$(srcdir)/'`rational.c + +libcfa_d_a-rational.obj: rational.c +@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-rational.obj -MD -MP -MF $(DEPDIR)/libcfa_d_a-rational.Tpo -c -o libcfa_d_a-rational.obj `if test -f 'rational.c'; then $(CYGPATH_W) 'rational.c'; else $(CYGPATH_W) '$(srcdir)/rational.c'; fi` +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-rational.Tpo $(DEPDIR)/libcfa_d_a-rational.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='rational.c' object='libcfa_d_a-rational.obj' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o libcfa_d_a-rational.obj `if test -f 'rational.c'; then $(CYGPATH_W) 'rational.c'; else $(CYGPATH_W) '$(srcdir)/rational.c'; fi` + libcfa_d_a-stdlib.o: stdlib.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-stdlib.o -MD -MP -MF $(DEPDIR)/libcfa_d_a-stdlib.Tpo -c -o libcfa_d_a-stdlib.o `test -f 'stdlib.c' || echo '$(srcdir)/'`stdlib.c @@ -609,87 +714,17 @@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o libcfa_d_a-stdlib.obj `if test -f 'stdlib.c'; then $(CYGPATH_W) 'stdlib.c'; else $(CYGPATH_W) '$(srcdir)/stdlib.c'; fi` -libcfa_d_a-math.o: math.c -@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-math.o -MD -MP -MF $(DEPDIR)/libcfa_d_a-math.Tpo -c -o libcfa_d_a-math.o `test -f 'math.c' || echo '$(srcdir)/'`math.c -@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-math.Tpo $(DEPDIR)/libcfa_d_a-math.Po -@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='math.c' object='libcfa_d_a-math.o' libtool=no @AMDEPBACKSLASH@ -@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o libcfa_d_a-math.o `test -f 'math.c' || echo '$(srcdir)/'`math.c - -libcfa_d_a-math.obj: math.c -@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-math.obj -MD -MP -MF $(DEPDIR)/libcfa_d_a-math.Tpo -c -o libcfa_d_a-math.obj `if test -f 'math.c'; then $(CYGPATH_W) 'math.c'; else $(CYGPATH_W) '$(srcdir)/math.c'; fi` -@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-math.Tpo $(DEPDIR)/libcfa_d_a-math.Po -@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='math.c' object='libcfa_d_a-math.obj' libtool=no @AMDEPBACKSLASH@ -@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o libcfa_d_a-math.obj `if test -f 'math.c'; then $(CYGPATH_W) 'math.c'; else $(CYGPATH_W) '$(srcdir)/math.c'; fi` - -libcfa_d_a-iostream.o: iostream.c -@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-iostream.o -MD -MP -MF $(DEPDIR)/libcfa_d_a-iostream.Tpo -c -o libcfa_d_a-iostream.o `test -f 'iostream.c' || echo '$(srcdir)/'`iostream.c -@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-iostream.Tpo $(DEPDIR)/libcfa_d_a-iostream.Po -@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='iostream.c' object='libcfa_d_a-iostream.o' libtool=no @AMDEPBACKSLASH@ -@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o libcfa_d_a-iostream.o `test -f 'iostream.c' || echo '$(srcdir)/'`iostream.c - -libcfa_d_a-iostream.obj: iostream.c -@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-iostream.obj -MD -MP -MF $(DEPDIR)/libcfa_d_a-iostream.Tpo -c -o libcfa_d_a-iostream.obj `if test -f 'iostream.c'; then $(CYGPATH_W) 'iostream.c'; else $(CYGPATH_W) '$(srcdir)/iostream.c'; fi` -@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-iostream.Tpo $(DEPDIR)/libcfa_d_a-iostream.Po -@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='iostream.c' object='libcfa_d_a-iostream.obj' libtool=no @AMDEPBACKSLASH@ -@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o libcfa_d_a-iostream.obj `if test -f 'iostream.c'; then $(CYGPATH_W) 'iostream.c'; else $(CYGPATH_W) '$(srcdir)/iostream.c'; fi` - -libcfa_d_a-fstream.o: fstream.c -@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-fstream.o -MD -MP -MF $(DEPDIR)/libcfa_d_a-fstream.Tpo -c -o libcfa_d_a-fstream.o `test -f 'fstream.c' || echo '$(srcdir)/'`fstream.c -@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-fstream.Tpo $(DEPDIR)/libcfa_d_a-fstream.Po -@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='fstream.c' object='libcfa_d_a-fstream.o' libtool=no @AMDEPBACKSLASH@ -@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o libcfa_d_a-fstream.o `test -f 'fstream.c' || echo '$(srcdir)/'`fstream.c - -libcfa_d_a-fstream.obj: fstream.c -@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-fstream.obj -MD -MP -MF $(DEPDIR)/libcfa_d_a-fstream.Tpo -c -o libcfa_d_a-fstream.obj `if test -f 'fstream.c'; then $(CYGPATH_W) 'fstream.c'; else $(CYGPATH_W) '$(srcdir)/fstream.c'; fi` -@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-fstream.Tpo $(DEPDIR)/libcfa_d_a-fstream.Po -@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='fstream.c' object='libcfa_d_a-fstream.obj' libtool=no @AMDEPBACKSLASH@ -@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o libcfa_d_a-fstream.obj `if test -f 'fstream.c'; then $(CYGPATH_W) 'fstream.c'; else $(CYGPATH_W) '$(srcdir)/fstream.c'; fi` - -libcfa_d_a-iterator.o: iterator.c -@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-iterator.o -MD -MP -MF $(DEPDIR)/libcfa_d_a-iterator.Tpo -c -o libcfa_d_a-iterator.o `test -f 'iterator.c' || echo '$(srcdir)/'`iterator.c -@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-iterator.Tpo $(DEPDIR)/libcfa_d_a-iterator.Po -@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='iterator.c' object='libcfa_d_a-iterator.o' libtool=no @AMDEPBACKSLASH@ -@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o libcfa_d_a-iterator.o `test -f 'iterator.c' || echo '$(srcdir)/'`iterator.c - -libcfa_d_a-iterator.obj: iterator.c -@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-iterator.obj -MD -MP -MF $(DEPDIR)/libcfa_d_a-iterator.Tpo -c -o libcfa_d_a-iterator.obj `if test -f 'iterator.c'; then $(CYGPATH_W) 'iterator.c'; else $(CYGPATH_W) '$(srcdir)/iterator.c'; fi` -@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-iterator.Tpo $(DEPDIR)/libcfa_d_a-iterator.Po -@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='iterator.c' object='libcfa_d_a-iterator.obj' libtool=no @AMDEPBACKSLASH@ -@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o libcfa_d_a-iterator.obj `if test -f 'iterator.c'; then $(CYGPATH_W) 'iterator.c'; else $(CYGPATH_W) '$(srcdir)/iterator.c'; fi` - -libcfa_d_a-rational.o: rational.c -@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-rational.o -MD -MP -MF $(DEPDIR)/libcfa_d_a-rational.Tpo -c -o libcfa_d_a-rational.o `test -f 'rational.c' || echo '$(srcdir)/'`rational.c -@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-rational.Tpo $(DEPDIR)/libcfa_d_a-rational.Po -@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='rational.c' object='libcfa_d_a-rational.o' libtool=no @AMDEPBACKSLASH@ -@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o libcfa_d_a-rational.o `test -f 'rational.c' || echo '$(srcdir)/'`rational.c - -libcfa_d_a-rational.obj: rational.c -@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-rational.obj -MD -MP -MF $(DEPDIR)/libcfa_d_a-rational.Tpo -c -o libcfa_d_a-rational.obj `if test -f 'rational.c'; then $(CYGPATH_W) 'rational.c'; else $(CYGPATH_W) '$(srcdir)/rational.c'; fi` -@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-rational.Tpo $(DEPDIR)/libcfa_d_a-rational.Po -@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='rational.c' object='libcfa_d_a-rational.obj' libtool=no @AMDEPBACKSLASH@ -@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o libcfa_d_a-rational.obj `if test -f 'rational.c'; then $(CYGPATH_W) 'rational.c'; else $(CYGPATH_W) '$(srcdir)/rational.c'; fi` - -libcfa_d_a-assert.o: assert.c -@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-assert.o -MD -MP -MF $(DEPDIR)/libcfa_d_a-assert.Tpo -c -o libcfa_d_a-assert.o `test -f 'assert.c' || echo '$(srcdir)/'`assert.c -@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-assert.Tpo $(DEPDIR)/libcfa_d_a-assert.Po -@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='assert.c' object='libcfa_d_a-assert.o' libtool=no @AMDEPBACKSLASH@ -@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o libcfa_d_a-assert.o `test -f 'assert.c' || echo '$(srcdir)/'`assert.c - -libcfa_d_a-assert.obj: assert.c -@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-assert.obj -MD -MP -MF $(DEPDIR)/libcfa_d_a-assert.Tpo -c -o libcfa_d_a-assert.obj `if test -f 'assert.c'; then $(CYGPATH_W) 'assert.c'; else $(CYGPATH_W) '$(srcdir)/assert.c'; fi` -@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-assert.Tpo $(DEPDIR)/libcfa_d_a-assert.Po -@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='assert.c' object='libcfa_d_a-assert.obj' libtool=no @AMDEPBACKSLASH@ -@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o libcfa_d_a-assert.obj `if test -f 'assert.c'; then $(CYGPATH_W) 'assert.c'; else $(CYGPATH_W) '$(srcdir)/assert.c'; fi` +containers/libcfa_d_a-maybe.o: containers/maybe.c +@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT containers/libcfa_d_a-maybe.o -MD -MP -MF containers/$(DEPDIR)/libcfa_d_a-maybe.Tpo -c -o containers/libcfa_d_a-maybe.o `test -f 'containers/maybe.c' || echo '$(srcdir)/'`containers/maybe.c +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) containers/$(DEPDIR)/libcfa_d_a-maybe.Tpo containers/$(DEPDIR)/libcfa_d_a-maybe.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='containers/maybe.c' object='containers/libcfa_d_a-maybe.o' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o containers/libcfa_d_a-maybe.o `test -f 'containers/maybe.c' || echo '$(srcdir)/'`containers/maybe.c + +containers/libcfa_d_a-maybe.obj: containers/maybe.c +@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT containers/libcfa_d_a-maybe.obj -MD -MP -MF containers/$(DEPDIR)/libcfa_d_a-maybe.Tpo -c -o containers/libcfa_d_a-maybe.obj `if test -f 'containers/maybe.c'; then $(CYGPATH_W) 'containers/maybe.c'; else $(CYGPATH_W) '$(srcdir)/containers/maybe.c'; fi` +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) containers/$(DEPDIR)/libcfa_d_a-maybe.Tpo containers/$(DEPDIR)/libcfa_d_a-maybe.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='containers/maybe.c' object='containers/libcfa_d_a-maybe.obj' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o containers/libcfa_d_a-maybe.obj `if test -f 'containers/maybe.c'; then $(CYGPATH_W) 'containers/maybe.c'; else $(CYGPATH_W) '$(srcdir)/containers/maybe.c'; fi` containers/libcfa_d_a-pair.o: containers/pair.c @@ -707,4 +742,18 @@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o containers/libcfa_d_a-pair.obj `if test -f 'containers/pair.c'; then $(CYGPATH_W) 'containers/pair.c'; else $(CYGPATH_W) '$(srcdir)/containers/pair.c'; fi` +containers/libcfa_d_a-result.o: containers/result.c +@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT containers/libcfa_d_a-result.o -MD -MP -MF containers/$(DEPDIR)/libcfa_d_a-result.Tpo -c -o containers/libcfa_d_a-result.o `test -f 'containers/result.c' || echo '$(srcdir)/'`containers/result.c +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) containers/$(DEPDIR)/libcfa_d_a-result.Tpo containers/$(DEPDIR)/libcfa_d_a-result.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='containers/result.c' object='containers/libcfa_d_a-result.o' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o containers/libcfa_d_a-result.o `test -f 'containers/result.c' || echo '$(srcdir)/'`containers/result.c + +containers/libcfa_d_a-result.obj: containers/result.c +@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT containers/libcfa_d_a-result.obj -MD -MP -MF containers/$(DEPDIR)/libcfa_d_a-result.Tpo -c -o containers/libcfa_d_a-result.obj `if test -f 'containers/result.c'; then $(CYGPATH_W) 'containers/result.c'; else $(CYGPATH_W) '$(srcdir)/containers/result.c'; fi` +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) containers/$(DEPDIR)/libcfa_d_a-result.Tpo containers/$(DEPDIR)/libcfa_d_a-result.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='containers/result.c' object='containers/libcfa_d_a-result.obj' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o containers/libcfa_d_a-result.obj `if test -f 'containers/result.c'; then $(CYGPATH_W) 'containers/result.c'; else $(CYGPATH_W) '$(srcdir)/containers/result.c'; fi` + containers/libcfa_d_a-vector.o: containers/vector.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT containers/libcfa_d_a-vector.o -MD -MP -MF containers/$(DEPDIR)/libcfa_d_a-vector.Tpo -c -o containers/libcfa_d_a-vector.o `test -f 'containers/vector.c' || echo '$(srcdir)/'`containers/vector.c @@ -819,4 +868,60 @@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o libhdr/libcfa_a-libdebug.obj `if test -f 'libhdr/libdebug.c'; then $(CYGPATH_W) 'libhdr/libdebug.c'; else $(CYGPATH_W) '$(srcdir)/libhdr/libdebug.c'; fi` +libcfa_a-assert.o: assert.c +@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-assert.o -MD -MP -MF $(DEPDIR)/libcfa_a-assert.Tpo -c -o libcfa_a-assert.o `test -f 'assert.c' || echo '$(srcdir)/'`assert.c +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-assert.Tpo $(DEPDIR)/libcfa_a-assert.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='assert.c' object='libcfa_a-assert.o' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o libcfa_a-assert.o `test -f 'assert.c' || echo '$(srcdir)/'`assert.c + +libcfa_a-assert.obj: assert.c +@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-assert.obj -MD -MP -MF $(DEPDIR)/libcfa_a-assert.Tpo -c -o libcfa_a-assert.obj `if test -f 'assert.c'; then $(CYGPATH_W) 'assert.c'; else $(CYGPATH_W) '$(srcdir)/assert.c'; fi` +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-assert.Tpo $(DEPDIR)/libcfa_a-assert.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='assert.c' object='libcfa_a-assert.obj' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o libcfa_a-assert.obj `if test -f 'assert.c'; then $(CYGPATH_W) 'assert.c'; else $(CYGPATH_W) '$(srcdir)/assert.c'; fi` + +libcfa_a-fstream.o: fstream.c +@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-fstream.o -MD -MP -MF $(DEPDIR)/libcfa_a-fstream.Tpo -c -o libcfa_a-fstream.o `test -f 'fstream.c' || echo '$(srcdir)/'`fstream.c +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-fstream.Tpo $(DEPDIR)/libcfa_a-fstream.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='fstream.c' object='libcfa_a-fstream.o' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o libcfa_a-fstream.o `test -f 'fstream.c' || echo '$(srcdir)/'`fstream.c + +libcfa_a-fstream.obj: fstream.c +@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-fstream.obj -MD -MP -MF $(DEPDIR)/libcfa_a-fstream.Tpo -c -o libcfa_a-fstream.obj `if test -f 'fstream.c'; then $(CYGPATH_W) 'fstream.c'; else $(CYGPATH_W) '$(srcdir)/fstream.c'; fi` +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-fstream.Tpo $(DEPDIR)/libcfa_a-fstream.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='fstream.c' object='libcfa_a-fstream.obj' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o libcfa_a-fstream.obj `if test -f 'fstream.c'; then $(CYGPATH_W) 'fstream.c'; else $(CYGPATH_W) '$(srcdir)/fstream.c'; fi` + +libcfa_a-iostream.o: iostream.c +@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-iostream.o -MD -MP -MF $(DEPDIR)/libcfa_a-iostream.Tpo -c -o libcfa_a-iostream.o `test -f 'iostream.c' || echo '$(srcdir)/'`iostream.c +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-iostream.Tpo $(DEPDIR)/libcfa_a-iostream.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='iostream.c' object='libcfa_a-iostream.o' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o libcfa_a-iostream.o `test -f 'iostream.c' || echo '$(srcdir)/'`iostream.c + +libcfa_a-iostream.obj: iostream.c +@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-iostream.obj -MD -MP -MF $(DEPDIR)/libcfa_a-iostream.Tpo -c -o libcfa_a-iostream.obj `if test -f 'iostream.c'; then $(CYGPATH_W) 'iostream.c'; else $(CYGPATH_W) '$(srcdir)/iostream.c'; fi` +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-iostream.Tpo $(DEPDIR)/libcfa_a-iostream.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='iostream.c' object='libcfa_a-iostream.obj' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o libcfa_a-iostream.obj `if test -f 'iostream.c'; then $(CYGPATH_W) 'iostream.c'; else $(CYGPATH_W) '$(srcdir)/iostream.c'; fi` + +libcfa_a-iterator.o: iterator.c +@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-iterator.o -MD -MP -MF $(DEPDIR)/libcfa_a-iterator.Tpo -c -o libcfa_a-iterator.o `test -f 'iterator.c' || echo '$(srcdir)/'`iterator.c +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-iterator.Tpo $(DEPDIR)/libcfa_a-iterator.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='iterator.c' object='libcfa_a-iterator.o' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o libcfa_a-iterator.o `test -f 'iterator.c' || echo '$(srcdir)/'`iterator.c + +libcfa_a-iterator.obj: iterator.c +@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-iterator.obj -MD -MP -MF $(DEPDIR)/libcfa_a-iterator.Tpo -c -o libcfa_a-iterator.obj `if test -f 'iterator.c'; then $(CYGPATH_W) 'iterator.c'; else $(CYGPATH_W) '$(srcdir)/iterator.c'; fi` +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-iterator.Tpo $(DEPDIR)/libcfa_a-iterator.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='iterator.c' object='libcfa_a-iterator.obj' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o libcfa_a-iterator.obj `if test -f 'iterator.c'; then $(CYGPATH_W) 'iterator.c'; else $(CYGPATH_W) '$(srcdir)/iterator.c'; fi` + libcfa_a-limits.o: limits.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-limits.o -MD -MP -MF $(DEPDIR)/libcfa_a-limits.Tpo -c -o libcfa_a-limits.o `test -f 'limits.c' || echo '$(srcdir)/'`limits.c @@ -833,4 +938,32 @@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o libcfa_a-limits.obj `if test -f 'limits.c'; then $(CYGPATH_W) 'limits.c'; else $(CYGPATH_W) '$(srcdir)/limits.c'; fi` +libcfa_a-math.o: math.c +@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-math.o -MD -MP -MF $(DEPDIR)/libcfa_a-math.Tpo -c -o libcfa_a-math.o `test -f 'math.c' || echo '$(srcdir)/'`math.c +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-math.Tpo $(DEPDIR)/libcfa_a-math.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='math.c' object='libcfa_a-math.o' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o libcfa_a-math.o `test -f 'math.c' || echo '$(srcdir)/'`math.c + +libcfa_a-math.obj: math.c +@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-math.obj -MD -MP -MF $(DEPDIR)/libcfa_a-math.Tpo -c -o libcfa_a-math.obj `if test -f 'math.c'; then $(CYGPATH_W) 'math.c'; else $(CYGPATH_W) '$(srcdir)/math.c'; fi` +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-math.Tpo $(DEPDIR)/libcfa_a-math.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='math.c' object='libcfa_a-math.obj' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o libcfa_a-math.obj `if test -f 'math.c'; then $(CYGPATH_W) 'math.c'; else $(CYGPATH_W) '$(srcdir)/math.c'; fi` + +libcfa_a-rational.o: rational.c +@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-rational.o -MD -MP -MF $(DEPDIR)/libcfa_a-rational.Tpo -c -o libcfa_a-rational.o `test -f 'rational.c' || echo '$(srcdir)/'`rational.c +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-rational.Tpo $(DEPDIR)/libcfa_a-rational.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='rational.c' object='libcfa_a-rational.o' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o libcfa_a-rational.o `test -f 'rational.c' || echo '$(srcdir)/'`rational.c + +libcfa_a-rational.obj: rational.c +@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-rational.obj -MD -MP -MF $(DEPDIR)/libcfa_a-rational.Tpo -c -o libcfa_a-rational.obj `if test -f 'rational.c'; then $(CYGPATH_W) 'rational.c'; else $(CYGPATH_W) '$(srcdir)/rational.c'; fi` +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-rational.Tpo $(DEPDIR)/libcfa_a-rational.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='rational.c' object='libcfa_a-rational.obj' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o libcfa_a-rational.obj `if test -f 'rational.c'; then $(CYGPATH_W) 'rational.c'; else $(CYGPATH_W) '$(srcdir)/rational.c'; fi` + libcfa_a-stdlib.o: stdlib.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-stdlib.o -MD -MP -MF $(DEPDIR)/libcfa_a-stdlib.Tpo -c -o libcfa_a-stdlib.o `test -f 'stdlib.c' || echo '$(srcdir)/'`stdlib.c @@ -847,87 +980,17 @@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o libcfa_a-stdlib.obj `if test -f 'stdlib.c'; then $(CYGPATH_W) 'stdlib.c'; else $(CYGPATH_W) '$(srcdir)/stdlib.c'; fi` -libcfa_a-math.o: math.c -@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-math.o -MD -MP -MF $(DEPDIR)/libcfa_a-math.Tpo -c -o libcfa_a-math.o `test -f 'math.c' || echo '$(srcdir)/'`math.c -@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-math.Tpo $(DEPDIR)/libcfa_a-math.Po -@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='math.c' object='libcfa_a-math.o' libtool=no @AMDEPBACKSLASH@ -@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o libcfa_a-math.o `test -f 'math.c' || echo '$(srcdir)/'`math.c - -libcfa_a-math.obj: math.c -@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-math.obj -MD -MP -MF $(DEPDIR)/libcfa_a-math.Tpo -c -o libcfa_a-math.obj `if test -f 'math.c'; then $(CYGPATH_W) 'math.c'; else $(CYGPATH_W) '$(srcdir)/math.c'; fi` -@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-math.Tpo $(DEPDIR)/libcfa_a-math.Po -@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='math.c' object='libcfa_a-math.obj' libtool=no @AMDEPBACKSLASH@ -@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o libcfa_a-math.obj `if test -f 'math.c'; then $(CYGPATH_W) 'math.c'; else $(CYGPATH_W) '$(srcdir)/math.c'; fi` - -libcfa_a-iostream.o: iostream.c -@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-iostream.o -MD -MP -MF $(DEPDIR)/libcfa_a-iostream.Tpo -c -o libcfa_a-iostream.o `test -f 'iostream.c' || echo '$(srcdir)/'`iostream.c -@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-iostream.Tpo $(DEPDIR)/libcfa_a-iostream.Po -@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='iostream.c' object='libcfa_a-iostream.o' libtool=no @AMDEPBACKSLASH@ -@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o libcfa_a-iostream.o `test -f 'iostream.c' || echo '$(srcdir)/'`iostream.c - -libcfa_a-iostream.obj: iostream.c -@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-iostream.obj -MD -MP -MF $(DEPDIR)/libcfa_a-iostream.Tpo -c -o libcfa_a-iostream.obj `if test -f 'iostream.c'; then $(CYGPATH_W) 'iostream.c'; else $(CYGPATH_W) '$(srcdir)/iostream.c'; fi` -@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-iostream.Tpo $(DEPDIR)/libcfa_a-iostream.Po -@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='iostream.c' object='libcfa_a-iostream.obj' libtool=no @AMDEPBACKSLASH@ -@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o libcfa_a-iostream.obj `if test -f 'iostream.c'; then $(CYGPATH_W) 'iostream.c'; else $(CYGPATH_W) '$(srcdir)/iostream.c'; fi` - -libcfa_a-fstream.o: fstream.c -@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-fstream.o -MD -MP -MF $(DEPDIR)/libcfa_a-fstream.Tpo -c -o libcfa_a-fstream.o `test -f 'fstream.c' || echo '$(srcdir)/'`fstream.c -@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-fstream.Tpo $(DEPDIR)/libcfa_a-fstream.Po -@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='fstream.c' object='libcfa_a-fstream.o' libtool=no @AMDEPBACKSLASH@ -@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o libcfa_a-fstream.o `test -f 'fstream.c' || echo '$(srcdir)/'`fstream.c - -libcfa_a-fstream.obj: fstream.c -@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-fstream.obj -MD -MP -MF $(DEPDIR)/libcfa_a-fstream.Tpo -c -o libcfa_a-fstream.obj `if test -f 'fstream.c'; then $(CYGPATH_W) 'fstream.c'; else $(CYGPATH_W) '$(srcdir)/fstream.c'; fi` -@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-fstream.Tpo $(DEPDIR)/libcfa_a-fstream.Po -@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='fstream.c' object='libcfa_a-fstream.obj' libtool=no @AMDEPBACKSLASH@ -@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o libcfa_a-fstream.obj `if test -f 'fstream.c'; then $(CYGPATH_W) 'fstream.c'; else $(CYGPATH_W) '$(srcdir)/fstream.c'; fi` - -libcfa_a-iterator.o: iterator.c -@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-iterator.o -MD -MP -MF $(DEPDIR)/libcfa_a-iterator.Tpo -c -o libcfa_a-iterator.o `test -f 'iterator.c' || echo '$(srcdir)/'`iterator.c -@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-iterator.Tpo $(DEPDIR)/libcfa_a-iterator.Po -@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='iterator.c' object='libcfa_a-iterator.o' libtool=no @AMDEPBACKSLASH@ -@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o libcfa_a-iterator.o `test -f 'iterator.c' || echo '$(srcdir)/'`iterator.c - -libcfa_a-iterator.obj: iterator.c -@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-iterator.obj -MD -MP -MF $(DEPDIR)/libcfa_a-iterator.Tpo -c -o libcfa_a-iterator.obj `if test -f 'iterator.c'; then $(CYGPATH_W) 'iterator.c'; else $(CYGPATH_W) '$(srcdir)/iterator.c'; fi` -@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-iterator.Tpo $(DEPDIR)/libcfa_a-iterator.Po -@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='iterator.c' object='libcfa_a-iterator.obj' libtool=no @AMDEPBACKSLASH@ -@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o libcfa_a-iterator.obj `if test -f 'iterator.c'; then $(CYGPATH_W) 'iterator.c'; else $(CYGPATH_W) '$(srcdir)/iterator.c'; fi` - -libcfa_a-rational.o: rational.c -@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-rational.o -MD -MP -MF $(DEPDIR)/libcfa_a-rational.Tpo -c -o libcfa_a-rational.o `test -f 'rational.c' || echo '$(srcdir)/'`rational.c -@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-rational.Tpo $(DEPDIR)/libcfa_a-rational.Po -@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='rational.c' object='libcfa_a-rational.o' libtool=no @AMDEPBACKSLASH@ -@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o libcfa_a-rational.o `test -f 'rational.c' || echo '$(srcdir)/'`rational.c - -libcfa_a-rational.obj: rational.c -@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-rational.obj -MD -MP -MF $(DEPDIR)/libcfa_a-rational.Tpo -c -o libcfa_a-rational.obj `if test -f 'rational.c'; then $(CYGPATH_W) 'rational.c'; else $(CYGPATH_W) '$(srcdir)/rational.c'; fi` -@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-rational.Tpo $(DEPDIR)/libcfa_a-rational.Po -@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='rational.c' object='libcfa_a-rational.obj' libtool=no @AMDEPBACKSLASH@ -@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o libcfa_a-rational.obj `if test -f 'rational.c'; then $(CYGPATH_W) 'rational.c'; else $(CYGPATH_W) '$(srcdir)/rational.c'; fi` - -libcfa_a-assert.o: assert.c -@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-assert.o -MD -MP -MF $(DEPDIR)/libcfa_a-assert.Tpo -c -o libcfa_a-assert.o `test -f 'assert.c' || echo '$(srcdir)/'`assert.c -@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-assert.Tpo $(DEPDIR)/libcfa_a-assert.Po -@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='assert.c' object='libcfa_a-assert.o' libtool=no @AMDEPBACKSLASH@ -@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o libcfa_a-assert.o `test -f 'assert.c' || echo '$(srcdir)/'`assert.c - -libcfa_a-assert.obj: assert.c -@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-assert.obj -MD -MP -MF $(DEPDIR)/libcfa_a-assert.Tpo -c -o libcfa_a-assert.obj `if test -f 'assert.c'; then $(CYGPATH_W) 'assert.c'; else $(CYGPATH_W) '$(srcdir)/assert.c'; fi` -@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-assert.Tpo $(DEPDIR)/libcfa_a-assert.Po -@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='assert.c' object='libcfa_a-assert.obj' libtool=no @AMDEPBACKSLASH@ -@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o libcfa_a-assert.obj `if test -f 'assert.c'; then $(CYGPATH_W) 'assert.c'; else $(CYGPATH_W) '$(srcdir)/assert.c'; fi` +containers/libcfa_a-maybe.o: containers/maybe.c +@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT containers/libcfa_a-maybe.o -MD -MP -MF containers/$(DEPDIR)/libcfa_a-maybe.Tpo -c -o containers/libcfa_a-maybe.o `test -f 'containers/maybe.c' || echo '$(srcdir)/'`containers/maybe.c +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) containers/$(DEPDIR)/libcfa_a-maybe.Tpo containers/$(DEPDIR)/libcfa_a-maybe.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='containers/maybe.c' object='containers/libcfa_a-maybe.o' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o containers/libcfa_a-maybe.o `test -f 'containers/maybe.c' || echo '$(srcdir)/'`containers/maybe.c + +containers/libcfa_a-maybe.obj: containers/maybe.c +@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT containers/libcfa_a-maybe.obj -MD -MP -MF containers/$(DEPDIR)/libcfa_a-maybe.Tpo -c -o containers/libcfa_a-maybe.obj `if test -f 'containers/maybe.c'; then $(CYGPATH_W) 'containers/maybe.c'; else $(CYGPATH_W) '$(srcdir)/containers/maybe.c'; fi` +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) containers/$(DEPDIR)/libcfa_a-maybe.Tpo containers/$(DEPDIR)/libcfa_a-maybe.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='containers/maybe.c' object='containers/libcfa_a-maybe.obj' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o containers/libcfa_a-maybe.obj `if test -f 'containers/maybe.c'; then $(CYGPATH_W) 'containers/maybe.c'; else $(CYGPATH_W) '$(srcdir)/containers/maybe.c'; fi` containers/libcfa_a-pair.o: containers/pair.c @@ -944,4 +1007,18 @@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o containers/libcfa_a-pair.obj `if test -f 'containers/pair.c'; then $(CYGPATH_W) 'containers/pair.c'; else $(CYGPATH_W) '$(srcdir)/containers/pair.c'; fi` + +containers/libcfa_a-result.o: containers/result.c +@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT containers/libcfa_a-result.o -MD -MP -MF containers/$(DEPDIR)/libcfa_a-result.Tpo -c -o containers/libcfa_a-result.o `test -f 'containers/result.c' || echo '$(srcdir)/'`containers/result.c +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) containers/$(DEPDIR)/libcfa_a-result.Tpo containers/$(DEPDIR)/libcfa_a-result.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='containers/result.c' object='containers/libcfa_a-result.o' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o containers/libcfa_a-result.o `test -f 'containers/result.c' || echo '$(srcdir)/'`containers/result.c + +containers/libcfa_a-result.obj: containers/result.c +@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT containers/libcfa_a-result.obj -MD -MP -MF containers/$(DEPDIR)/libcfa_a-result.Tpo -c -o containers/libcfa_a-result.obj `if test -f 'containers/result.c'; then $(CYGPATH_W) 'containers/result.c'; else $(CYGPATH_W) '$(srcdir)/containers/result.c'; fi` +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) containers/$(DEPDIR)/libcfa_a-result.Tpo containers/$(DEPDIR)/libcfa_a-result.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='containers/result.c' object='containers/libcfa_a-result.obj' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o containers/libcfa_a-result.obj `if test -f 'containers/result.c'; then $(CYGPATH_W) 'containers/result.c'; else $(CYGPATH_W) '$(srcdir)/containers/result.c'; fi` containers/libcfa_a-vector.o: containers/vector.c Index: src/libcfa/concurrency/monitor =================================================================== --- src/libcfa/concurrency/monitor (revision ff98952225b16a68fb22c007b5495c78ef23158e) +++ src/libcfa/concurrency/monitor (revision 4a3685479ce3ea742a9282c31d31ce031849e49c) @@ -59,4 +59,5 @@ unsigned short count; //Number of criterions in the criteria __condition_node_t * next; //Intrusive linked list Next field + uintptr_t user_info; //Custom user info accessible before signalling }; @@ -85,5 +86,9 @@ } -void wait( condition * this ); -void signal( condition * this ); +void wait( condition * this, uintptr_t user_info = 0 ); +bool signal( condition * this ); +bool signal_block( condition * this ); +static inline bool is_empty( condition * this ) { return !this->blocked.head; } +uintptr_t front( condition * this ); + #endif //MONITOR_H Index: src/libcfa/concurrency/monitor.c =================================================================== --- src/libcfa/concurrency/monitor.c (revision ff98952225b16a68fb22c007b5495c78ef23158e) +++ src/libcfa/concurrency/monitor.c (revision 4a3685479ce3ea742a9282c31d31ce031849e49c) @@ -62,4 +62,5 @@ //Some one else has the monitor, wait in line for it append( &this->entry_queue, thrd ); + LIB_DEBUG_PRINT_SAFE("%p Blocking on entry\n", thrd); ScheduleInternal( &this->lock ); @@ -97,4 +98,6 @@ unlock( &this->lock ); + LIB_DEBUG_PRINT_SAFE("Next owner is %p\n", new_owner); + //We need to wake-up the thread ScheduleThread( new_owner ); @@ -134,12 +137,28 @@ } -void debug_break() __attribute__(( noinline )) -{ - +void ?{}(__condition_node_t * this, thread_desc * waiting_thread, unsigned short count, uintptr_t user_info ) { + this->waiting_thread = waiting_thread; + this->count = count; + this->next = NULL; + this->user_info = user_info; +} + +void ?{}(__condition_criterion_t * this ) { + this->ready = false; + this->target = NULL; + this->owner = NULL; + this->next = NULL; +} + +void ?{}(__condition_criterion_t * this, monitor_desc * target, __condition_node_t * owner ) { + this->ready = false; + this->target = target; + this->owner = owner; + this->next = NULL; } //----------------------------------------------------------------------------- // Internal scheduling -void wait( condition * this ) { +void wait( condition * this, uintptr_t user_info = 0 ) { LIB_DEBUG_PRINT_SAFE("Waiting\n"); @@ -149,4 +168,5 @@ assertf( this->monitors != NULL, "Waiting with no monitors (%p)", this->monitors ); assertf( this->monitor_count != 0, "Waiting with 0 monitors (%i)", this->monitor_count ); + assertf( this->monitor_count < 32u, "Excessive monitor count (%i)", this->monitor_count ); unsigned short count = this->monitor_count; @@ -156,15 +176,9 @@ LIB_DEBUG_PRINT_SAFE("count %i\n", count); - __condition_node_t waiter; - waiter.waiting_thread = this_thread(); - waiter.count = count; - waiter.next = NULL; + __condition_node_t waiter = { this_thread(), count, user_info }; __condition_criterion_t criteria[count]; for(int i = 0; i < count; i++) { - criteria[i].ready = false; - criteria[i].target = this->monitors[i]; - criteria[i].owner = &waiter; - criteria[i].next = NULL; + (&criteria[i]){ this->monitors[i], &waiter }; LIB_DEBUG_PRINT_SAFE( "Criterion %p\n", &criteria[i] ); } @@ -184,6 +198,4 @@ } - debug_break(); - for( int i = 0; i < count; i++) { thread_desc * new_owner = next_thread( this->monitors[i] ); @@ -191,6 +203,4 @@ } - debug_break(); - LIB_DEBUG_PRINT_SAFE("Will unblock: "); for(int i = 0; i < thread_count; i++) { @@ -201,5 +211,4 @@ // Everything is ready to go to sleep ScheduleInternal( locks, count, threads, thread_count ); - //WE WOKE UP @@ -212,8 +221,8 @@ } -void signal( condition * this ) { - if( !this->blocked.head ) { +bool signal( condition * this ) { + if( is_empty( this ) ) { LIB_DEBUG_PRINT_SAFE("Nothing to signal\n"); - return; + return false; } @@ -224,4 +233,5 @@ unsigned short count = this->monitor_count; + //Some more checking in debug LIB_DEBUG_DO( thread_desc * this_thrd = this_thread(); @@ -237,8 +247,12 @@ ); + //Lock all the monitors lock_all( this->monitors, NULL, count ); LIB_DEBUG_PRINT_SAFE("Signalling"); + //Pop the head of the waiting queue __condition_node_t * node = pop_head( &this->blocked ); + + //Add the thread to the proper AS stack for(int i = 0; i < count; i++) { __condition_criterion_t * crit = &node->criteria[i]; @@ -250,5 +264,70 @@ LIB_DEBUG_PRINT_SAFE("\n"); + //Release unlock_all( this->monitors, count ); + + return true; +} + +bool signal_block( condition * this ) { + if( !this->blocked.head ) { + LIB_DEBUG_PRINT_SAFE("Nothing to signal\n"); + return false; + } + + //Check that everything is as expected + assertf( this->monitors != NULL, "Waiting with no monitors (%p)", this->monitors ); + assertf( this->monitor_count != 0, "Waiting with 0 monitors (%i)", this->monitor_count ); + + unsigned short count = this->monitor_count; + unsigned int recursions[ count ]; //Save the current recursion levels to restore them later + spinlock * locks [ count ]; //We need to pass-in an array of locks to ScheduleInternal + + lock_all( this->monitors, locks, count ); + + //create creteria + __condition_node_t waiter = { this_thread(), count, 0 }; + + __condition_criterion_t criteria[count]; + for(int i = 0; i < count; i++) { + (&criteria[i]){ this->monitors[i], &waiter }; + LIB_DEBUG_PRINT_SAFE( "Criterion %p\n", &criteria[i] ); + push( &criteria[i].target->signal_stack, &criteria[i] ); + } + + waiter.criteria = criteria; + + //save contexts + save_recursion( this->monitors, recursions, count ); + + //Find the thread to run + thread_desc * signallee = pop_head( &this->blocked )->waiting_thread; + for(int i = 0; i < count; i++) { + set_owner( this->monitors[i], signallee ); + } + + LIB_DEBUG_PRINT_SAFE( "Waiting on signal block\n" ); + + //Everything is ready to go to sleep + ScheduleInternal( locks, count, &signallee, 1 ); + + LIB_DEBUG_PRINT_SAFE( "Back from signal block\n" ); + + //We are back, restore the owners and recursions + lock_all( locks, count ); + restore_recursion( this->monitors, recursions, count ); + unlock_all( locks, count ); + + return true; +} + +uintptr_t front( condition * this ) { + LIB_DEBUG_DO( + if( is_empty(this) ) { + abortf( "Attempt to access user data on an empty condition.\n" + "Possible cause is not checking if the condition is empty before reading stored data." ); + } + ); + return this->blocked.head->user_info; } @@ -335,4 +414,5 @@ for( int i = 0; i < count; i++ ) { + LIB_DEBUG_PRINT_SAFE( "Checking %p for %p\n", &criteria[i], target ); if( &criteria[i] == target ) { Index: src/libcfa/concurrency/thread =================================================================== --- src/libcfa/concurrency/thread (revision ff98952225b16a68fb22c007b5495c78ef23158e) +++ src/libcfa/concurrency/thread (revision 4a3685479ce3ea742a9282c31d31ce031849e49c) @@ -82,4 +82,5 @@ void yield(); +void yield( unsigned times ); #endif //THREADS_H Index: src/libcfa/concurrency/thread.c =================================================================== --- src/libcfa/concurrency/thread.c (revision ff98952225b16a68fb22c007b5495c78ef23158e) +++ src/libcfa/concurrency/thread.c (revision 4a3685479ce3ea742a9282c31d31ce031849e49c) @@ -87,4 +87,10 @@ } +void yield( unsigned times ) { + for( unsigned i = 0; i < times; i++ ) { + yield(); + } +} + void ThreadCtxSwitch(coroutine_desc* src, coroutine_desc* dst) { // set state of current coroutine to inactive Index: src/libcfa/containers/maybe =================================================================== --- src/libcfa/containers/maybe (revision 4a3685479ce3ea742a9282c31d31ce031849e49c) +++ src/libcfa/containers/maybe (revision 4a3685479ce3ea742a9282c31d31ce031849e49c) @@ -0,0 +1,66 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// maybe -- May contain a value. +// +// Author : Andrew Beach +// Created On : Wed May 24 14:43:00 2017 +// Last Modified By : Andrew Beach +// Last Modified On : Thr May 25 16:36:00 2017 +// Update Count : 1 +// + + +#ifndef MAYBE_H +#define MAYBE_H + +#include + +// DO NOT USE DIRECTLY! +forall(otype T) +struct maybe { + bool has_value; + T value; +}; + + +forall(otype T) +void ?{}(maybe(T) * this); + +forall(otype T) +void ?{}(maybe(T) * this, T value); + +forall(otype T) +void ?{}(maybe(T) * this, maybe(T) other); + +forall(otype T) +void ^?{}(maybe(T) * this); + +forall(otype T) +maybe(T) ?=?(maybe(T) * this, maybe(T) other); + +forall(otype T) +bool ?!=?(maybe(T) this, zero_t); + +forall(otype T) +maybe(T) maybe_value(T value); + +forall(otype T) +maybe(T) maybe_none(); + +forall(otype T) +bool has_value(maybe(T) * this); + +forall(otype T) +T get(maybe(T) * this); + +forall(otype T) +void set(maybe(T) * this, T value); + +forall(otype T) +void set_none(maybe(T) * this); + +#endif // MAYBE_H Index: src/libcfa/containers/maybe.c =================================================================== --- src/libcfa/containers/maybe.c (revision 4a3685479ce3ea742a9282c31d31ce031849e49c) +++ src/libcfa/containers/maybe.c (revision 4a3685479ce3ea742a9282c31d31ce031849e49c) @@ -0,0 +1,101 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// maybe.c -- May contain a value. +// +// Author : Andrew Beach +// Created On : Wed May 24 15:40:00 2017 +// Last Modified By : Andrew Beach +// Last Modified On : Thr May 25 15:24:00 2017 +// Update Count : 1 +// + +#include +#include + + +forall(otype T) +void ?{}(maybe(T) * this) { + this->has_value = false; +} + +forall(otype T) +void ?{}(maybe(T) * this, T value) { + this->has_value = true; + (&this->value){value}; +} + +forall(otype T) +void ?{}(maybe(T) * this, maybe(T) other) { + this->has_value = other.has_value; + if (other.has_value) { + (&this->value){other.value}; + } +} + +forall(otype T) +maybe(T) ?=?(maybe(T) * this, maybe(T) that) { + if (this->has_value & that.has_value) { + this->value = that.value; + } else if (this->has_value) { + ^(&this->value){}; + this->has_value = false; + } else if (that.has_value) { + this->has_value = true; + (&this->value){that.value}; + } +} + +forall(otype T) +void ^?{}(maybe(T) * this) { + if (this->has_value) { + ^(&this->value){}; + } +} + +forall(otype T) +bool ?!=?(maybe(T) this, zero_t) { + return this.has_value; +} + +forall(otype T) +maybe(T) maybe_value(T value) { + return (maybe(T)){value}; +} + +forall(otype T) +maybe(T) maybe_none() { + return (maybe(T)){}; +} + +forall(otype T) +bool has_value(maybe(T) * this) { + return this->has_value; +} + +forall(otype T) +T get(maybe(T) * this) { + assertf(this->has_value, "attempt to get from maybe without value"); + return this->value; +} + +forall(otype T) +void set(maybe(T) * this, T value) { + if (this->has_value) { + this->value = value; + } else { + this->has_value = true; + (&this->value){value}; + } +} + +forall(otype T) +void set_none(maybe(T) * this) { + if (this->has_value) { + this->has_value = false; + ^(&this->value){}; + } +} Index: src/libcfa/containers/result =================================================================== --- src/libcfa/containers/result (revision 4a3685479ce3ea742a9282c31d31ce031849e49c) +++ src/libcfa/containers/result (revision 4a3685479ce3ea742a9282c31d31ce031849e49c) @@ -0,0 +1,78 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// result -- Contains the expected value or an error value. +// +// Author : Andrew Beach +// Created On : Wed May 24 14:45:00 2017 +// Last Modified By : Andrew Beach +// Last Modified On : Thr May 25 16:39:00 2017 +// Update Count : 1 +// + + +#ifndef RESULT_H +#define RESULT_H + +#include + +// DO NOT USE DIRECTLY! +forall(otype T, otype E) +union inner_result{ + T value; + E error; +}; + +forall(otype T, otype E) +struct result { + bool has_value; + inner_result(T, E); +}; + + +forall(otype T, otype E) +void ?{}(result(T, E) * this); + +forall(otype T, otype E) +void ?{}(result(T, E) * this, one_t, T value); + +forall(otype T, otype E) +void ?{}(result(T, E) * this, zero_t, E error); + +forall(otype T, otype E) +void ?{}(result(T, E) * this, result(T, E) other); + +forall(otype T, otype E) +void ^?{}(result(T, E) * this); + +forall(otype T, otype E) +result(T, E) ?=?(result(T, E) * this, result(T, E) other); + +forall(otype T, otype E) +bool ?!=?(result(T, E) this, zero_t); + +forall(otype T, otype E) +result(T, E) result_value(T value); + +forall(otype T, otype E) +result(T, E) result_error(E error); + +forall(otype T, otype E) +bool has_value(result(T, E) * this); + +forall(otype T, otype E) +T get(result(T, E) * this); + +forall(otype T, otype E) +E get_error(result(T, E) * this); + +forall(otype T, otype E) +void set(result(T, E) * this, T value); + +forall(otype T, otype E) +void set_error(result(T, E) * this, E error); + +#endif // RESULT_H Index: src/libcfa/containers/result.c =================================================================== --- src/libcfa/containers/result.c (revision 4a3685479ce3ea742a9282c31d31ce031849e49c) +++ src/libcfa/containers/result.c (revision 4a3685479ce3ea742a9282c31d31ce031849e49c) @@ -0,0 +1,126 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// result.c -- Contains the expected value or an error value. +// +// Author : Andrew Beach +// Created On : Wed May 24 15:40:00 2017 +// Last Modified By : Andrew Beach +// Last Modified On : Thr May 25 15:27:00 2017 +// Update Count : 1 +// + +#include +#include + + +forall(otype T, otype E) +void ?{}(result(T, E) * this) { + this->has_value = false; + (&this->error){}; +} + +forall(otype T, otype E) +void ?{}(result(T, E) * this, one_t, T value) { + this->has_value = true; + (&this->value){value}; +} + +forall(otype T, otype E) +void ?{}(result(T, E) * this, zero_t, E error) { + this->has_value = false; + (&this->error){error}; +} + +forall(otype T, otype E) +void ?{}(result(T, E) * this, result(T, E) other) { + this->has_value = other.has_value; + if (other.has_value) { + (&this->value){other.value}; + } else { + (&this->error){other.error}; + } +} + +forall(otype T, otype E) +result(T, E) ?=?(result(T, E) * this, result(T, E) that) { + if (this->has_value & that.has_value) { + this->value = that.value; + } else if (this->has_value) { + ^(&this->value){}; + this->has_value = false; + (&this->error){that.error}; + } else if (that.has_value) { + ^(&this->error){}; + this->has_value = true; + (&this->value){that.value}; + } else { + this->error = that.error; + } +} + +forall(otype T, otype E) +void ^?{}(result(T, E) * this) { + if (this->has_value) { + ^(&this->value){}; + } else { + ^(&this->error){}; + } +} + +forall(otype T, otype E) +bool ?!=?(result(T, E) this, zero_t) { + return !this.has_value; +} + +forall(otype T, otype E) +result(T, E) result_value(T value) { + return (result(T, E)){1, value}; +} + +forall(otype T, otype E) +result(T, E) result_error(E error) { + return (result(T, E)){0, error}; +} + +forall(otype T, otype E) +bool has_value(result(T, E) * this) { + return this->has_value; +} + +forall(otype T, otype E) +T get(result(T, E) * this) { + assertf(this->has_value, "attempt to get from result without value"); + return this->value; +} + +forall(otype T, otype E) +E get_error(result(T, E) * this) { + assertf(this->has_value, "attempt to get from result without error"); + return this->error; +} + +forall(otype T, otype E) +void set(result(T, E) * this, T value) { + if (this->has_value) { + this->value = value; + } else { + ^(&this->error){}; + this->has_value = true; + (&this->value){value}; + } +} + +forall(otype T, otype E) +void set_error(result(T, E) * this, E error) { + if (this->has_value) { + ^(&this->value){}; + this->has_value = false; + (&this->error){error}; + } else { + this->error = error; + } +} Index: src/libcfa/containers/vector =================================================================== --- src/libcfa/containers/vector (revision ff98952225b16a68fb22c007b5495c78ef23158e) +++ src/libcfa/containers/vector (revision 4a3685479ce3ea742a9282c31d31ce031849e49c) @@ -22,4 +22,34 @@ //------------------------------------------------------------------------------ +//Allocator +forall(otype T) +struct heap_allocator +{ + T* storage; + size_t capacity; +}; + +forall(otype T) +void ?{}(heap_allocator(T)* this); + +forall(otype T) +void ?{}(heap_allocator(T)* this, heap_allocator(T) rhs); + +forall(otype T) +heap_allocator(T) ?=?(heap_allocator(T)* this, heap_allocator(T) rhs); + +forall(otype T) +void ^?{}(heap_allocator(T)* this); + +forall(otype T) +void realloc_storage(heap_allocator(T)* this, size_t size); + +forall(otype T) +static inline T* data(heap_allocator(T)* this) +{ + return this->storage; +} + +//------------------------------------------------------------------------------ //Declaration trait allocator_c(otype T, otype allocator_t) @@ -29,5 +59,5 @@ }; -forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +forall(otype T, otype allocator_t = heap_allocator(T) | allocator_c(T, allocator_t)) struct vector; @@ -46,5 +76,5 @@ void ^?{}(vector(T, allocator_t)* this); -forall(otype T, otype allocator_t | allocator_c(T, allocator_t)) +forall(otype T, otype allocator_t = heap_allocator(T) | allocator_c(T, allocator_t)) struct vector { @@ -136,34 +166,4 @@ // } -//------------------------------------------------------------------------------ -//Allocator -forall(otype T) -struct heap_allocator -{ - T* storage; - size_t capacity; -}; - -forall(otype T) -void ?{}(heap_allocator(T)* this); - -forall(otype T) -void ?{}(heap_allocator(T)* this, heap_allocator(T) rhs); - -forall(otype T) -heap_allocator(T) ?=?(heap_allocator(T)* this, heap_allocator(T) rhs); - -forall(otype T) -void ^?{}(heap_allocator(T)* this); - -forall(otype T) -void realloc_storage(heap_allocator(T)* this, size_t size); - -forall(otype T) -static inline T* data(heap_allocator(T)* this) -{ - return this->storage; -} - #endif // VECTOR_H Index: src/libcfa/math =================================================================== --- src/libcfa/math (revision ff98952225b16a68fb22c007b5495c78ef23158e) +++ src/libcfa/math (revision 4a3685479ce3ea742a9282c31d31ce031849e49c) @@ -10,6 +10,6 @@ // Created On : Mon Apr 18 23:37:04 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Sun Apr 24 12:45:02 2016 -// Update Count : 59 +// Last Modified On : Wed May 24 17:40:39 2017 +// Update Count : 60 // @@ -20,11 +20,4 @@ #include // fpclassify, isfinite, isnormal, isnan, isinf } // extern "C" - -float fabs( float ); -// extern "C" { double fabs( double ); } -long double fabs( long double ); -float cabs( float _Complex ); -// extern "C" { double cabs( double _Complex ); } -long double cabs( long double _Complex ); float ?%?( float, float ); Index: src/libcfa/math.c =================================================================== --- src/libcfa/math.c (revision ff98952225b16a68fb22c007b5495c78ef23158e) +++ src/libcfa/math.c (revision 4a3685479ce3ea742a9282c31d31ce031849e49c) @@ -10,6 +10,6 @@ // Created On : Tue Apr 19 22:23:08 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Sun Apr 24 08:52:31 2016 -// Update Count : 75 +// Last Modified On : Tue May 23 22:52:13 2017 +// Update Count : 76 // @@ -19,9 +19,4 @@ #include } // extern "C" - -float fabs( float x ) { return fabsf( x ); } -long double fabs( long double x ) { return fabsl( x ); } -float cabs( float _Complex x ) { return cabsf( x ); } -long double cabs( long double _Complex x ) { return cabsl( x ); } float ?%?( float x, float y ) { return fmodf( x, y ); } Index: src/libcfa/stdlib =================================================================== --- src/libcfa/stdlib (revision ff98952225b16a68fb22c007b5495c78ef23158e) +++ src/libcfa/stdlib (revision 4a3685479ce3ea742a9282c31d31ce031849e49c) @@ -10,6 +10,6 @@ // Created On : Thu Jan 28 17:12:35 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Tue May 9 08:42:44 2017 -// Update Count : 107 +// Last Modified On : Wed May 24 18:06:27 2017 +// Update Count : 115 // @@ -28,5 +28,4 @@ //--------------------------------------- -extern "C" { void * malloc( size_t ); } // use default C routine for void * forall( dtype T | sized(T) ) T * malloc( void ); forall( dtype T | sized(T) ) T * malloc( char fill ); @@ -42,9 +41,4 @@ forall( dtype T | sized(T) ) T * memalign( size_t alignment ); // deprecated forall( dtype T | sized(T) ) int posix_memalign( T ** ptr, size_t alignment ); - -extern "C" { -void * memset( void * ptr, int fill, size_t size ); -void free( void * ptr ); -} // extern "C" forall( dtype T, ttype Params | sized(T) | { void ?{}(T *, Params); } ) T * new( Params p ); @@ -109,5 +103,5 @@ double abs( double _Complex ); long double abs( long double _Complex ); -forall ( otype T | { void ?{}( T *, zero_t ); int ? #include @@ -20,2 +35,7 @@ #endif // __CFA } + +// Local Variables: // +// tab-width: 4 // +// compile-command: "cfa complex.c" // +// End: // Index: c/tests/constant0-1.c =================================================================== --- src/tests/constant0-1.c (revision ff98952225b16a68fb22c007b5495c78ef23158e) +++ (revision ) @@ -1,79 +1,0 @@ -// Constant test declaration - -// value - -int 0; -const int 0; -int 1; -const int 1; -struct { int i; } 0; -const struct { int i; } 1; - -#ifdef DUPS - -int 0; -const int 0; -int 1; -const int 1; -int (0), (1); -int ((0)), ((1)); -const int 0, 1; -const int (0), (1); -struct { int i; } 0; -const struct { int i; } 1; - -#endif // DUPS - -#ifndef NEWDECL - -// pointer - -int *0, *1; -int * const (0), * const 1; -struct { int i; } *0; -const struct { int i; } *0; -int (*(* const x)), **0; - -#ifdef DUPS - -int *0, *1; -int *(0), *(1); -int (*0), (*1); -int ((*0)), ((*1)); -int * const (0), * const 1; -int (* const 0), (* const 1); -int ((* const 0)), ((* const 1)); -int (*(* const x)), *(*0); -int (*(* const x)), (*(*0)); -struct { int i; } *0; -const struct { int i; } *0; -int (*(* const x)), **0; - -#endif // DUPS - -#else - -// Cforall style - -* int x, 0; -const * int x, 0; -* struct { int i; } 0; -const * struct { int i; } 0; -const * * int x, 0; - -#ifdef DUPS - -* int x, 0; -const * int x, 0; - -#endif // DUPS - -#endif // NEWDECL - -int main() { -#ifndef NEWDECL - int 1, * 0; -#else - * int x, 0; -#endif // NEWDECL -} Index: src/tests/gmp.c =================================================================== --- src/tests/gmp.c (revision ff98952225b16a68fb22c007b5495c78ef23158e) +++ src/tests/gmp.c (revision 4a3685479ce3ea742a9282c31d31ce031849e49c) @@ -10,6 +10,6 @@ // Created On : Tue Apr 19 08:55:51 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon May 22 09:05:09 2017 -// Update Count : 538 +// Last Modified On : Wed May 24 22:05:38 2017 +// Update Count : 540 // @@ -88,5 +88,5 @@ sout | (int)0 | fact | endl; for ( unsigned int i = 1; i <= 40; i += 1 ) { - fact = fact * i; // general case + fact *= i; // general case sout | i | fact | endl; } // for @@ -94,5 +94,5 @@ // Local Variables: // -// mode: c // // tab-width: 4 // +// compile-command: "cfa gmp.c -l gmp" // // End: // Index: src/tests/libcfa_vector.c =================================================================== --- src/tests/libcfa_vector.c (revision ff98952225b16a68fb22c007b5495c78ef23158e) +++ src/tests/libcfa_vector.c (revision 4a3685479ce3ea742a9282c31d31ce031849e49c) @@ -27,5 +27,5 @@ int main() { - vector( int, heap_allocator(int) ) iv; + vector( int ) iv; assert( empty( &iv ) ); Index: src/tests/math.c =================================================================== --- src/tests/math.c (revision ff98952225b16a68fb22c007b5495c78ef23158e) +++ src/tests/math.c (revision 4a3685479ce3ea742a9282c31d31ce031849e49c) @@ -10,6 +10,6 @@ // Created On : Fri Apr 22 14:59:21 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Sun Apr 24 13:24:20 2016 -// Update Count : 70 +// Last Modified On : Wed May 24 13:04:33 2017 +// Update Count : 71 // @@ -22,5 +22,4 @@ long double l; - sout | "fabs:" | fabs( -1.0F ) | fabs( -1.0D ) | fabs( -1.0L ) | cabs( -1.0F+1.0FI ) | cabs( -1.0D+1.0DI ) | cabs( -1.0DL+1.0LI ) | endl; sout | "fmod:" | 5.0F % -2.0F | fmod( 5.0F, -2.0F ) | 5.0D % -2.0D | fmod( 5.0D, -2.0D ) | 5.0L % -2.0L | fmod( 5.0L, -2.0L ) | endl; sout | "remainder:" | remainder( 2.0F, 3.0F ) | remainder( 2.0D, 3.0D ) | remainder( 2.0L, 3.0L ) | endl; Index: src/tests/numericConstants.c =================================================================== --- src/tests/numericConstants.c (revision ff98952225b16a68fb22c007b5495c78ef23158e) +++ src/tests/numericConstants.c (revision 4a3685479ce3ea742a9282c31d31ce031849e49c) @@ -1,2 +1,17 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// numericConstants.c -- +// +// Author : Peter A. Buhr +// Created On : Wed May 24 22:10:36 2017 +// Last Modified By : Peter A. Buhr +// Last Modified On : Wed May 24 22:11:36 2017 +// Update Count : 2 +// + int main() { 1; // decimal @@ -48,3 +63,8 @@ 0x_ff.ffp0; // hex real 0x_1.ffff_ffff_p_128_l; -} +} // main + +// Local Variables: // +// tab-width: 4 // +// compile-command: "cfa minmax.c" // +// End: // Index: src/tests/rational.c =================================================================== --- src/tests/rational.c (revision ff98952225b16a68fb22c007b5495c78ef23158e) +++ src/tests/rational.c (revision 4a3685479ce3ea742a9282c31d31ce031849e49c) @@ -10,6 +10,6 @@ // Created On : Mon Mar 28 08:43:12 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon May 15 21:32:22 2017 -// Update Count : 64 +// Last Modified On : Wed May 17 15:46:35 2017 +// Update Count : 65 // Index: src/tests/sched-int-block.c =================================================================== --- src/tests/sched-int-block.c (revision 4a3685479ce3ea742a9282c31d31ce031849e49c) +++ src/tests/sched-int-block.c (revision 4a3685479ce3ea742a9282c31d31ce031849e49c) @@ -0,0 +1,114 @@ +#include +#include +#include +#include +#include + +static const unsigned N = 100_000; + +enum state_t { WAITED, SIGNAL, BARGE }; + +monitor global_data_t { + thread_desc * last_thread; + thread_desc * last_signaller; +}; + +void ?{} ( global_data_t * this ) { + this->last_thread = NULL; + this->last_signaller = NULL; +} + +void ^?{} ( global_data_t * this ) {} + +global_data_t globalA, globalB; + +condition cond; + +volatile bool done; + +//------------------------------------------------------------------------------ +void wait_op( global_data_t * mutex a, global_data_t * mutex b, unsigned i ) { + wait( &cond, (uintptr_t)this_thread() ); + + yield( ((unsigned)rand48()) % 10 ); + + if(a->last_thread != a->last_signaller || b->last_thread != b->last_signaller ) { + sout | "ERROR Barging detected, expected" | a->last_signaller | b->last_signaller | "got" | a->last_thread | b->last_thread | endl; + abort(); + } + + a->last_thread = b->last_thread = this_thread(); + + yield( ((unsigned)rand48()) % 10 ); +} + +thread Waiter {}; +void main( Waiter* this ) { + for( int i = 0; i < N; i++ ) { + wait_op( &globalA, &globalB, i ); + } +} + +//------------------------------------------------------------------------------ +void signal_op( global_data_t * mutex a, global_data_t * mutex b ) { + yield( ((unsigned)rand48()) % 10 ); + + a->last_thread = b->last_thread = a->last_signaller = b->last_signaller = this_thread(); + + if( !is_empty( &cond ) ) { + + thread_desc * next = front( &cond ); + + if( ! signal_block( &cond ) ) { + sout | "ERROR expected to be able to signal" | endl; + abort(); + } + + yield( ((unsigned)rand48()) % 10 ); + + if(a->last_thread != next || b->last_thread != next) { + sout | "ERROR Barging detected, expected" | next | "got" | a->last_thread | b->last_thread | endl; + abort(); + } + } + +} + +thread Signaller {}; +void main( Signaller* this ) { + while( !done ) { + signal_op( &globalA, &globalB ); + } +} + +//------------------------------------------------------------------------------ +void barge_op( global_data_t * mutex a ) { + a->last_thread = this_thread(); +} + +thread Barger {}; +void main( Barger* this ) { + for( unsigned i = 0; !done; i++ ) { + //Choose some monitor to barge into with some irregular pattern + bool choose_a = (i % 13) > (i % 17); + barge_op( choose_a ? &globalA : &globalB ); + } +} + +//------------------------------------------------------------------------------ + +int main(int argc, char* argv[]) { + rand48seed(0); + done = false; + processor p; + { + Signaller s[4]; + Barger b[13]; + sout | "Starting waiters" | endl; + { + Waiter w[3]; + } + sout | "Waiters done" | endl; + done = true; + } +} Index: src/tests/sched-int-disjoint.c =================================================================== --- src/tests/sched-int-disjoint.c (revision ff98952225b16a68fb22c007b5495c78ef23158e) +++ src/tests/sched-int-disjoint.c (revision 4a3685479ce3ea742a9282c31d31ce031849e49c) @@ -78,8 +78,5 @@ signal( &cond, a, &data ); - int pauses = (unsigned)rand48() % 10; - for(int i = 0; i < pauses; i++) { - yield(); - } + yield( (unsigned)rand48() % 10 ); //This is technically a mutual exclusion violation but the mutex monitor protects us Index: src/tests/test.py =================================================================== --- src/tests/test.py (revision ff98952225b16a68fb22c007b5495c78ef23158e) +++ src/tests/test.py (revision 4a3685479ce3ea742a9282c31d31ce031849e49c) @@ -253,5 +253,5 @@ # for each test to run try : - results = pool.map_async(partial(run_test_worker, generate=generate, dry_run=dry_run, debug=debug), tests ).get(3600) + results = pool.map_async(partial(run_test_worker, generate=generate, dry_run=dry_run, debug=debug), tests, chunksize = 1 ).get(3600) except KeyboardInterrupt: pool.terminate() Index: tools/cfa.nanorc =================================================================== --- tools/cfa.nanorc (revision ff98952225b16a68fb22c007b5495c78ef23158e) +++ tools/cfa.nanorc (revision 4a3685479ce3ea742a9282c31d31ce031849e49c) @@ -12,5 +12,5 @@ color green "\<(float|double|bool|char|int|short|long|sizeof|enum|void|auto)\>" color green "\<(static|const|struct|union|typedef|extern|(un)?signed|inline)\>" -color green "\<((s?size)|((u_?)?int(8|16|32|64|ptr)))_t\>" +color green "\<((s?size)|one|zero|((u_?)?int(8|16|32|64|ptr)))_t\>" # Declarations @@ -39,4 +39,6 @@ # Values +# Booleans +color blue "\<(true|false)\>" # Characters color brightmagenta "'([^'\]|(\\")|(\\['abfnrtv\\]))'"