Changeset 90cfc16


Ignore:
Timestamp:
Dec 11, 2018, 2:42:27 PM (6 years ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, no_list, persistent-indexer, pthread-emulation, qualifiedEnum
Children:
5307c33, 85acec94
Parents:
1f690b3 (diff), 29207bf (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Files:
1 added
3 deleted
38 edited
87 moved

Legend:

Unmodified
Added
Removed

  • benchmark/Makefile.am

    r1f690b3 r90cfc16  
    1111## Created On       : Sun May 31 09:08:15 2015
    1212## Last Modified By : Peter A. Buhr
    13 ## Last Modified On : Mon Jan 25 22:31:42 2016
    14 ## Update Count     : 25
     13## Last Modified On : Tue Nov  6 09:01:23 2018
     14## Update Count     : 26
    1515###############################################################################
    1616
    … …  
    304304
    305305compile-attributes$(EXEEXT):
    306         @$(CFACOMPILE) -fsyntax-only -w $(testdir)/attributes.c
     306        @$(CFACOMPILE) -fsyntax-only -w $(testdir)/attributes.cfa
    307307
    308308compile-empty$(EXEEXT):

  • doc/bibliography/pl.bib

    r1f690b3 r90cfc16  
    2121%  toplas: ACM Trans. on Prog. Lang. & Sys.
    2222%  tcs: Theoretical Computer Science
    23 @string{ieeepds="IEEE Transactions on Parallel and Distributed Systems"}
    24 % @string{ieeepds="IEEE Trans. Parallel Distrib. Syst."}
    25 @string{ieeese="IEEE Transactions on Software Engineering"}
    26 % @string{ieeese="IEEE Trans. Softw. Eng."}
    27 @string{spe="Software---\-Practice and Experience"}
    28 % @string{spe="Softw. Pract. Exp."}
    29 @string{ccpe="Concurrency and Computation: Practice and Experience"}
    30 % @string{ccpe="Concurrency Comput: Pract Experience"}
    31 @string{sigplan="SIGPLAN Notices"}
    32 % @string{sigplan="SIGPLAN Not."}
    33 @string{joop="Journal of Object-Oriented Programming"}
    34 % @string{joop="J. of Object-Oriented Program."}
     23
     24string{ieeepds="IEEE Transactions on Parallel and Distributed Systems"}
     25@string{ieeepds="IEEE Trans. Parallel Distrib. Syst."}
     26string{ieeese="IEEE Transactions on Software Engineering"}
     27@string{ieeese="IEEE Trans. Softw. Eng."}
     28string{spe="Software---\-Practice and Experience"}
     29@string{spe="Softw. Pract. Exper."}
     30string{ccpe="Concurrency and Computation: Practice and Experience"}
     31@string{ccpe="Concurrency Comput.: Pract. Exper."}
     32string{sigplan="SIGPLAN Notices"}
     33@string{sigplan="SIGPLAN Not."}
     34string{joop="Journal of Object-Oriented Programming"}
     35@string{joop="J. of Object-Oriented Program."}
    3536@string{popl="Conference Record of the ACM Symposium on Principles of Programming Languages"}
    3637@string{osr="Operating Systems Review"}
    3738@string{pldi="Programming Language Design and Implementation"}
    3839@string{toplas="Transactions on Programming Languages and Systems"}
    39 @string{mathann="Mathematische Annalen"}
    40 % @string{mathann="Math. Ann."}
     40string{mathann="Mathematische Annalen"}
     41@string{mathann="Math. Ann."}
    4142
    4243% A
    … …  
    566567}
    567568
     569@inproceedings {Qin18,
     570    author      = {Henry Qin and Qian Li and Jacqueline Speiser and Peter Kraft and John Ousterhout},
     571    title       = {Arachne: Core-Aware Thread Management},
     572    booktitle   = {13th {USENIX} Symp. on Oper. Sys. Design and Impl. ({OSDI} 18)},
     573    year        = {2018},
     574    address     = {Carlsbad, CA},
     575    pages       = {145-160},
     576    publisher   = {{USENIX} Association},
     577    note        = {\href{https://www.usenix.org/conference/osdi18/presentation/qin}{https://\-www.usenix.org/\-conference/\-osdi18/\-presentation/\-qin}},
     578}
     579
    568580@article{Kessels82,
    569581    keywords    = {concurrency, critical section},
    … …  
    653665    author      = {Joung, Yuh-Jzer},
    654666    title       = {Asynchronous group mutual exclusion},
    655     journal     = {Distributed Computing},
     667    journal     = {Dist. Comput.},
     668    optjournal  = {Distributed Computing},
    656669    year        = {2000},
    657670    month       = {Nov},
    … …  
    796809        time computable inheritance hierarchy.
    797810    },
    798     comment = {
     811    comment     = {
    799812        Classes are predicates; if object {\tt o} is in class {\tt C}, then
    800813        {\tt C} is true of {\tt o}.  Classes are combined with {\tt :AND},
    … …  
    950963
    951964@article{Moss18,
    952     keywords    = {type systems, tuples, Cforall},
     965    keywords    = {type systems, polymorphism, tuples, Cforall},
    953966    contributer = {pabuhr@plg},
    954967    author      = {Aaron Moss and Robert Schluntz and Peter A. Buhr},
    955968    title       = {\textsf{C}$\mathbf{\forall}$ : Adding Modern Programming Language Features to C},
     969    journal     = spe,
     970    volume      = 48,
     971    number      = 12,
     972    month       = dec,
    956973    year        = 2018,
    957     month       = aug,
    958     journal     = spe,
     974    pages       = {2111-2146},
    959975    note        = {\href{http://dx.doi.org/10.1002/spe.2624}{http://\-dx.doi.org/\-10.1002/\-spe.2624}},
    960976}
    … …  
    9891005    journal     = {Dr. Dobb's Journal of Software Tools},
    9901006    year        = 1989,
    991     month       = feb, volume = 14, number = 2, pages = {45-51},
     1007    month       = feb,
     1008    volume      = 14,
     1009    number      = 2,
     1010    pages       = {45-51},
    9921011    comment     = {
    9931012       A light-weight multitasking kernel for MS-DOS.  A task\_control
    … …  
    15071526}
    15081527
    1509 @techreport{uC++,
     1528@manual{uC++,
    15101529    keywords    = {C++, concurrency, light-weight process, shared memory},
    15111530    contributer = {pabuhr@plg},
     1531    key         = {uC++},
    15121532    author      = {Peter A. Buhr},
    15131533    title       = {$\mu${C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Annotated Reference Manual, Version 7.0.0},
    1514     institution = {School of Computer Science, University of Waterloo},
    1515     address     = {Waterloo, Ontario, Canada, N2L 3G1},
    1516     month       = dec,
    1517     year        = 2017,
     1534    organization= {University of Waterloo},
     1535    month       = sep,
     1536    year        = 2018,
    15181537    note        = {\href{https://plg.uwaterloo.ca/~usystem/pub/uSystem/uC++.pdf}{https://\-plg.uwaterloo.ca/\-$\sim$usystem/\-pub/\-uSystem/uC++.pdf}},
    15191538}
    … …  
    15861605    author      = {Sun, Xianda},
    15871606    title       = {Concurrent High-performance Persistent Hash Table In {J}ava},
    1588     school      = {School of Computer Science, University of Waterloo},
     1607    school      = {School of Computer Sc., University of Waterloo},
    15891608    year        = 2015,
    15901609    optaddress  = {Waterloo, Ontario, Canada, N2L 3G1},
    … …  
    19361955    note        = {Svensk Standard SS 63 61 14},
    19371956    year        = 1987,
    1938     abstract    = {
    1939         Standard for the programming language SIMULA.  Written in English.
    1940     }
     1957    abstract    = {Standard for the programming language SIMULA. Written in English.}
     1958}
     1959
     1960@article{Galil91,
     1961    keywords    = {union-find},
     1962    contributer = {a3moss@uwaterloo.ca},
     1963    title       = {Data structures and algorithms for disjoint set union problems},
     1964    author      = {Galil, Zvi and Italiano, Giuseppe F},
     1965    journal     = {ACM Computing Surveys (CSUR)},
     1966    volume      = 23,
     1967    number      = 3,
     1968    pages       = {319--344},
     1969    year        = 1991,
     1970    publisher   = {ACM},
    19411971}
    19421972
    … …  
    20782108    year        = {1998},
    20792109    pages       = {393-407},
     2110}
     2111
     2112@book{Aho74,
     2113    keywords    = {algorithms, textbook, union-find},
     2114    contributer = {a3moss@uwaterloo.ca},
     2115    title       = {The Design and Analysis of Computer Algorithms},
     2116    author      = {Aho, Alfred V and Hopcroft, John E and Ullman, Jeffrey D},
     2117    year        = {1974},
     2118    publisher   = {Addison-Wesley},
     2119    address     = {Reading, MA, USA}
    20802120}
    20812121
    … …  
    28802920}
    28812921
     2922@inproceedings{Patwary10,
     2923    keywords    = {union-find},
     2924    contributer = {a3moss@uwaterloo.ca},
     2925    author      = {Patwary, Md. Mostofa Ali and Blair, Jean and Manne, Fredrik},
     2926    editor      = {Festa, Paola},
     2927    title       = {Experiments on Union-Find Algorithms for the Disjoint-Set Data Structure},
     2928    booktitle   = {Experimental Algorithms},
     2929    year        = 2010,
     2930    publisher   = {Springer Berlin Heidelberg},
     2931    address     = {Berlin, Heidelberg},
     2932    pages       = {411--423},
     2933    isbn        = {978-3-642-13193-6}
     2934}
     2935
    28822936% F
    28832937
    … …  
    32233277    keywords    = {Go programming language},
    32243278    contributer = {pabuhr@plg},
     3279    author      = {Robert Griesemer and Rob Pike and Ken Thompson},
    32253280    title       = {{Go} Programming Language},
    3226     author      = {Robert Griesemer and Rob Pike and Ken Thompson},
    32273281    organization= {Google},
    32283282    year        = 2009,
    … …  
    34163470    month       = sep,
    34173471    publisher   = {John Wiley \& Sons},
    3418     note        = {\href{https://doi-org.proxy.lib.uwaterloo.ca/10.1002/cpe.4475}{https://\-doi-org.proxy.lib.uwaterloo.ca/\-10.1002/\-cpe.4475}},
     3472    note        = {\href{https://doi.org/10.1002/cpe.4475}{https://\-doi.org/\-10.1002/\-cpe.4475}},
    34193473}
    34203474
    … …  
    35543608    publisher   = {ACM Press},
    35553609    address     = {New York, NY, USA},
     3610}
     3611
     3612@article{Galler64,
     3613    keywords    = {union-find, original},
     3614    contributer = {a3moss@uwaterloo.ca},
     3615    title       = {An improved equivalence algorithm},
     3616    author      = {Galler, Bernard A and Fisher, Michael J},
     3617    journal     = {Communications of the ACM},
     3618    volume      = {7},
     3619    number      = {5},
     3620    pages       = {301--303},
     3621    year        = {1964},
     3622    publisher   = {ACM}
    35563623}
    35573624
    … …  
    38983965    author      = {Peter A. Buhr and Martin Karsten and Jun Shih},
    38993966    title       = {{\small\textsf{KDB}}: A Multi-threaded Debugger for Multi-threaded Applications},
    3900     booktitle   = {Proceedings of SPDT'96: SIGMETRICS Symposium on Parallel and Distributed Tools},
     3967    booktitle   = {Proc. of SPDT'96: SIGMETRICS Symp. on Parallel and Distributed Tools},
    39013968    publisher   = {ACM Press},
    39023969    address     = {Philadelphia, Pennsylvania, U.S.A.},
    … …  
    53895456}
    53905457
     5458@inproceedings{Conchon07,
     5459    keywords    = {persistent array, union-find},
     5460    contributer = {a3moss@uwaterloo.ca},
     5461    title       = {A persistent union-find data structure},
     5462    author      = {Conchon, Sylvain and Filli{\^a}tre, Jean-Christophe},
     5463    booktitle   = {Proceedings of the 2007 workshop on Workshop on ML},
     5464    pages       = {37--46},
     5465    year        = {2007},
     5466    organization= {ACM}
     5467}
     5468
    53915469@article{poly,
    53925470    keywords    = {Poly, Standard ML, Russell, persistence},
    … …  
    56035681    author      = {Peter A. Buhr and Robert Denda},
    56045682    title       = {{$\mu$Profiler} : Profiling User-Level Threads in a Shared-Memory Programming Environment},
    5605     booktitle   = {Proceedings of the Second International Symposium on Computing in Object-Oriented Parallel Environments (ISCOPE'98)},
     5683    booktitle   = {Proc. of 2nd Inter. Symp. on Computing in Object-Oriented Parallel Environments},
    56065684    series      = {Lecture Notes in Computer Science},
    56075685    publisher   = {Springer-Verlag},
    … …  
    59746052    issn        = {0164-0925},
    59756053    pages       = {429-475},
    5976     url         = {http://doi.acm.org.proxy.lib.uwaterloo.ca/10.1145/1133651.1133653},
     6054    url         = {http://doi.acm.org/10.1145/1133651.1133653},
    59776055    doi         = {10.1145/1133651.1133653},
    59786056    acmid       = {1133653},
    … …  
    62416319    contributer = {pabuhr@plg},
    62426320    key         = {Rust},
    6243     title       = {The {R}ust Programming Language},
    6244     address     = {The Rust Project Developers},
     6321    title       = {{R}ust Programming Language},
     6322    optaddress  = {Rust Project Developers},
    62456323    year        = 2015,
    62466324    note        = {\href{https://doc.rust-lang.org/reference.html}{https://\-doc.rust-lang\-.org/\-reference.html}},
    … …  
    63086386    publisher   = {Springer},
    63096387    note        = {Lecture Notes in Computer Science v. 173},
     6388}
     6389
     6390@article{Baker78,
     6391    keywords    = {Algol display, FUNARG's, Lisp 1.5, deep binding, environment trees, multiprogramming, shallow binding},
     6392    contributer = {a3moss@uwaterloo.ca},
     6393    author      = {Baker,Jr., Henry G.},
     6394    title       = {Shallow Binding in Lisp 1.5},
     6395    journal     = {Commun. ACM},
     6396    issue_date  = {July 1978},
     6397    volume      = 21,
     6398    number      = 7,
     6399    month       = jul,
     6400    year        = 1978,
     6401    issn        = {0001-0782},
     6402    pages       = {565--569},
     6403    numpages    = {5},
     6404    url         = {http://doi.acm.org/10.1145/359545.359566},
     6405    doi         = {10.1145/359545.359566},
     6406    acmid       = {359566},
     6407    publisher   = {ACM},
     6408    address     = {New York, NY, USA}
     6409}
     6410
     6411@article{Baker91,
     6412    keywords    = {shallow binding, functional arrays},
     6413    contributer = {a3moss@uwaterloo.ca},
     6414    author      = {Baker, Henry G.},
     6415    title       = {Shallow Binding Makes Functional Arrays Fast},
     6416    journal     = {SIGPLAN Not.},
     6417    issue_date  = {Aug. 1991},
     6418    volume      = 26,
     6419    number      = 8,
     6420    month       = aug,
     6421    year        = 1991,
     6422    issn        = {0362-1340},
     6423    pages       = {145--147},
     6424    numpages    = {3},
     6425    url         = {http://doi.acm.org/10.1145/122598.122614},
     6426    doi         = {10.1145/122598.122614},
     6427    acmid       = {122614},
     6428    publisher   = {ACM},
     6429    address     = {New York, NY, USA},
    63106430}
    63116431
    … …  
    74767596}
    74777597
     7598@article{Tarjan84,
     7599    keywords    = {union-find},
     7600    contributer = {a3moss@uwaterloo.ca},
     7601    author      = {Tarjan, Robert E. and van Leeuwen, Jan},
     7602    title       = {Worst-case Analysis of Set Union Algorithms},
     7603    journal     = {J. ACM},
     7604    issue_date  = {April 1984},
     7605    volume      = 31,
     7606    number      = 2,
     7607    month       = mar,
     7608    year        = 1984,
     7609    issn        = {0004-5411},
     7610    pages       = {245--281},
     7611    numpages    = {37},
     7612    url         = {http://doi.acm.org/10.1145/62.2160},
     7613    doi         = {10.1145/62.2160},
     7614    acmid       = {2160},
     7615    publisher   = {ACM},
     7616    address     = {New York, NY, USA},
     7617}
     7618
    74787619% X
    74797620

  • doc/theses/aaron_moss_PhD/phd/thesis.tex

    r1f690b3 r90cfc16  
    2323% \usepackage[pdftex]{graphicx} % For including graphics N.B. pdftex graphics driver
    2424\usepackage{graphicx}
     25
     26\usepackage{amsthm} % for theorem environment
     27\newtheorem{theorem}{Theorem}
    2528
    2629\usepackage{footmisc} % for double refs to the same footnote

  • doc/theses/aaron_moss_PhD/phd/type-environment.tex

    r1f690b3 r90cfc16  
    55As discussed in Chapter~\ref{resolution-chap}, being able to efficiently determine which type variables are bound to which concrete types or whether two type environments are compatible is a core requirement of the resolution algorithm.
    66Furthermore, expression resolution involves a search through many related possible solutions, so being able to re-use shared subsets of type environment data and to switch between environments quickly is desirable for performance.
    7 In this chapter I discuss and empirically compare a number of type environment data structure variants, including some novel variations on the union-find\cit{} data structure introduced in this thesis.
    8 
    9 \section{Definitions}
     7In this chapter I discuss and empirically compare a number of type environment data structure variants, including some novel variations on the union-find\cite{Galler64} data structure introduced in this thesis.
     8
     9\section{Definitions} \label{env-defn-sec}
    1010
    1111For purposes of this chapter, a \emph{type environment} $T$ is a set of \emph{type classes} $\myset{T_1, T_2, \cdots, T_{|T|}}$.
    … …  
    2424        $add(T_i, v_{i,j})$ &                                                           & Add variable to class                 \\
    2525        $bind(T_i, b_i)$ &                                                                      & Set or update class bound             \\
    26         $remove(T, T_i)$ &                                                                      & Remove class from environment \\
    2726        $unify(T, T_i, T_j)$ & $\rightarrow \top | \bot$        & Combine two type classes              \\
     27        $split(T, T_i)$ & $\rightarrow T'$                                      & Revert the last $unify$ operation on $T_i$            \\
    2828        $combine(T, T')$ & $\rightarrow \top | \bot$            & Merge two environments                \\
    2929        $save(T)$ & $\rightarrow H$                                                     & Get handle for current state  \\
    … …  
    4040The $add(T_i, v_{i,j})$ operation adds a new type variable $v_{i,j}$ to class $T_i$; again, $v_{i,j}$ cannot exist elsewhere in $T$.
    4141$bind(T_i, b_i)$ mutates the bound for a type class, setting or updating the current bound.
    42 The final basic mutation operation is $remove(T, T_i)$, which removes a class $T_i$ and all its type variables from an environment $T$.
    4342
    4443The $unify$ operation is the fundamental non-trivial operation a type environment data structure must support.
    4544$unify(T, T_i, T_j)$ merges a type class $T_j$ into another $T_i$, producing a failure result and leaving $T$ in an invalid state if this merge fails.
    4645It is always possible to unify the type variables of both classes by simply taking the union of both sets; given the disjointness property, no checks for set containment are required, and the variable sets can simply be concatenated if supported by the underlying data structure.
    47 $unify$ depends on an internal $unify_bound$ operation which may fail.
    48 In \CFACC{}, $unify_bound(b_i, b_j) \rightarrow b'_i|\bot$ checks that the type classes contain the same sort of variable, takes the tighter of the two conversion permissions, and checks if the bound types can be unified.
    49 If the bound types cannot be unified (\eg{} !struct A! with !int*!), then $unify_bound$ fails, while other combinations of bound types may result in recursive calls.
    50 For instance, unifying !R*! with !S*! for type variables !R! and !S! will result in a call to $unify(T, find($!R!$), find($!S!$))$, while unifying !R*! with !int*! will result in a call to $unify_bound$ on !int! and the bound type of the class containing !R!.
     46$unify$ depends on an internal $unifyBound$ operation which may fail.
     47In \CFACC{}, $unifyBound(b_i, b_j) \rightarrow b'_i|\bot$ checks that the type classes contain the same sort of variable, takes the tighter of the two conversion permissions, and checks if the bound types can be unified.
     48If the bound types cannot be unified (\eg{} !struct A! with !int*!), then $unifyBound$ fails, while other combinations of bound types may result in recursive calls.
     49For instance, unifying !R*! with !S*! for type variables !R! and !S! will result in a call to $unify(T, find($!R!$), find($!S!$))$, while unifying !R*! with !int*! will result in a call to $unifyBound$ on !int! and the bound type of the class containing !R!.
    5150As such, a call to $unify(T, T_i, T_j)$ may touch every type class in $T$, not just $T_i$ and $T_j$, collapsing the entirety of $T$ into a single type class in extreme cases.
     51For more information on \CFA{} unification, see \cite{Bilson03}.
     52The inverse of $unify$ is $split(T, T_i)$, which produces a new environment $T'$ which is the same as $T$ except that $T_i$ has been replaced by two classes corresponding to the arguments to the previous call to $unify$ on $T_i$.
     53If there has been no call to $unify$ on $T_i$ (\ie{} $T_i$ is a single-element class) $T_i$ is absent in $T'$.
    5254
    5355Given the nature of the expression resolution problem as backtracking search, caching and concurrency are both useful tools to decrease runtime.
    … …  
    5759The invalid state of $T$ on failure is not important, given that a combination failure will result in the resolution algorithm backtracking to a different environment.
    5860$combine$ proceeds by calls to $insert$, $add$, and $unify$ as needed, and can be roughly thought of as calling $unify$ on every pair of classes in $T$ that have variables $v'_{i,j}$ and $v'_{i,k}$ in the same class $T'_i$ in $T'$.
    59 Like for $unify$, $combine$ can always find a mutually-consistent division of type variables into classes (in the extreme case, all type variables from $T$ and $T'$ in a single type class), but may fail due to inconsistent bounds on merged type classes.
     61Like $unify$, $combine$ can always find a mutually-consistent partition of type variables into classes (in the extreme case, all type variables from $T$ and $T'$ in a single type class), but may fail due to inconsistent bounds on merged type classes.
    6062
    6163Finally, the backtracking access patterns of the compiler can be exploited to reduce memory usage or runtime through use of an appropriately designed data structure.
    6264The set of mutations to a type environment across the execution of the resolution algorithm produce an implicit tree of related environments, and the backtracking search typically focuses only on one leaf of the tree at once, or at most a small number of closely-related nodes as arguments to $combine$.
    6365As such, the ability to save and restore particular type environment states is useful, and supported by the $save(T) \rightarrow H$ and $backtrack(T, H)$ operations, which produce a handle for the current environment state and mutate an environment back to a previous state, respectively.
    64 These operations can be naively implemented by a deep copy of $T$ into $H$ and vice versa, but have more efficient implementations in persistency-aware data structures.
     66These operations can be naively implemented by a deep copy of $T$ into $H$ and vice versa, but have more efficient implementations in persistency-aware data structures.
     67
     68\section{Approaches}
     69
     70\subsection{Na\"{\i}ve}
     71
     72The type environment data structure used in Bilson's\cite{Bilson03} original implementation of \CFACC{} is a straightforward translation of the definitions in Section~\ref{env-defn-sec} to \CC{} code; a !TypeEnvironment! contains a list of !EqvClass! type equivalence classes, each of which contains the type bound information and a tree-based sorted set of type variables.
     73This approach has the benefit of being easy to understand and not imposing life-cycle or inheritance constraints on its use, but, as can be seen in Table~\ref{env-bounds-table}, does not support many of the desired operations with any particular efficiency.
     74Some variations on this structure may improve performance somewhat; for instance, replacing the !EqvClass! variable storage with a hash-based set would reduce search and update times from $O(\log n)$ to amortized $O(1)$, while adding an index for the type variables in the entire environment would remove the need to check each type class individually to maintain the disjointness property.
     75These improvements do not change the fundamental issues with this data structure, however.
     76
     77\subsection{Incremental Inheritance}
     78
     79One more invasive modification to this data structure which I investigated is to support swifter combinations of closely-related environments in the backtracking tree by storing a reference to a \emph{parent} environment within each environment, and having that environment only store type classes which have been modified with respect to the parent.
     80This approach provides constant-time copying of environments, as a new environment simply consists of an empty list of type classes and a reference to its (logically identical) parent; since many type environments are no different than their parent, this speeds backtracking in this common case.
     81Since all mutations made to a child environment are by definition compatible with the parent environment, two descendants of a common ancestor environment can be combined by iteratively combining the changes made in one environment then that environment's parent until the common ancestor is reached, again re-using storage and reducing computation in many cases.
     82
     83For this environment I also employed a lazily-generated index of type variables to their containing class, which could be in either the current environment or an ancestor.
     84Any mutation of a type class in an ancestor environment would cause that class to be copied into the current environment before mutation, as well as added to the index, ensuring that all local changes to the type environment are listed in its index.
     85However, not adding type variables to the index until lookup or mutation preserves the constant-time environment copy operation in the common case in which the copy is not mutated from its parent during its life-cycle.
     86
     87This approach imposes some performance penalty on $combine$ if related environments are not properly linked together, as the entire environment needs to be combined rather than just the diff, but is correct as long as the ``null parent'' base case is properly handled.
     88The life-cycle issues are somewhat more complex, as many environments may descend from a common parent, and all of these need their parent to stay alive for purposes of lookup.
     89These issues can be solved by ``flattening'' parent nodes into their children before the parents leave scope, but given the tree structure of the inheritance graph it is more straightforward to store the parent nodes in reference-counted or otherwise automatically garbage-collected heap storage.
     90
     91\subsection{Union-Find} \label{env-union-find-approach}
     92
     93Given the nature of the classes of type variables as disjoint sets, another natural approach to implementing a type environment is the union-find disjoint set data structure\cite{Galler64}.
     94Union-find efficiently implements two operations over a partition of a collection of elements into disjoint sets; $find(x)$ locates the \emph{representative} of $x$, the element which canonically names its set, while $union(r, s)$ merges two sets represented by $r$ and $s$, respectively.
     95The union-find data structure is based on providing each element with a reference to its parent element, such that the root of a tree of elements is the representative of the set of elements contained in the tree.
     96$find$ is then implemented by a search up to the parent, generally combined with a \emph{path compression} step that links nodes more directly to their ancestors to speed up subsequent searches.
     97$union$ involves making the representative of one set a child of the representative of the other, generally employing a rank- or size-based heuristic to ensure that the tree remains somewhat balanced.
     98If both path compression and a balancing heuristic are employed, both $union$ and $find$ run in amortized $O(\alpha(n))$ worst-case time; this bound by the inverse Ackermann function is a small constant for all practical values of $n$.
     99
     100The union-find $find$ and $union$ operations have obvious applicability to the $find$ and $unify$ type environment operations in Table~\ref{env-op-table}, but the union-find data structure must be augmented to fully implement the type environment operations.
     101In particular, the type class bound cannot be easily included in the union-find data structure, as the requirement to make it the class representative breaks the balancing properties of $union$, and requires too-close integration of the type environment $unifyBound$ internal operation.
     102This issue can be solved by including a side map from class representatives to the type class bound.
     103If placeholder values are inserted in this map for type classes without bounds than this also has the useful property that the key set of the map provides an easily obtainable list of all the class representatives, a list which cannot be derived from the union-find data structure without a linear search for class representatives through all elements.
     104
     105\subsection{Union-Find with Classes} \label{env-union-find-classes-approach}
     106
     107Another type environment operation not supported directly by the union-find data structure is $report$, which lists the type variables in a given class, and similarly $split$, which reverts a $unify$ operation.
     108Since the union-find data structure stores only links from children to parents and not vice-versa, there is no way to reconstruct a class from one of its elements without a linear search over the entire data structure, with $find$ called on each element to check its membership in the class.
     109The situation is even worse for the $split$ operation, which would require extra information to maintain the order that each child was added to its parent node.
     110Unfortunately, the literature\cite{Tarjan84,Galil91,Patwary10} on union-find does not present a way to keep references to children without breaking the asymptotic time bounds of the algorithm; I have discovered a method to do so which, despite its simplicity, seems to be novel.
     111
     112\TODO{port figure from slideshow}
     113
     114The core idea of this ``union-find with classes'' data structure and algorithm is to keep the members of each class stored in a circularly-linked list.
     115Aho, Hopcroft, and Ullman also include a circularly-linked list in their 1974 textbook~\cite{Aho74}.
     116However, the algorithm presented by Aho~\etal{} has an entirely flat class hierarchy, where all elements are direct children of the representative, giving constant-time $find$ at the cost of linear-time $union$ operations.
     117In my version, the list data structure does not affect the layout of the union-find tree, maintaining the same asymptotic bounds as union-find.
     118In more detail, each element is given a !next! pointer to another element in the same class; this !next! pointer initially points to the element itself.
     119When two classes are unified, the !next! pointers of the representatives of those classes are swapped, splicing the two circularly-linked lists together.
     120Importantly, though this approach requires an extra pointer per element, it does maintain the linear space bound of union-find, and because it only requires updating the two root nodes in $union$ it does not asymptotically increase runtime either.
     121The basic approach is compatible with all path-compression techniques, and allows the members of any class to be retrieved in time linear in the size of the class simply by following the !next! pointers from any element.
     122
     123If the path-compression optimization is abandoned, union-find with classes also encodes a reversible history of all the $union$ operations applied to a given class.
     124Theorem~\ref{env-reverse-thm} demonstrates that the !next! pointer of the representative of a class always points to a leaf from the last-added subtree.
     125This property is sufficient to reverse the most-recent $union$ operation by finding the ancestor of that leaf that is an immediate child of the representative, breaking its parent link, and swapping the !next! pointers back\footnote{Union-by-size may be a more appropriate approach than union-by-rank in this instance, as adding two known sizes is a reversible operation, but the rank increment operation cannot be reliably reversed.}.
     126Once the $union$ operation has been reversed, Theorem~\ref{env-reverse-thm} still holds for the reduced class, and the process can be repeated recursively until the entire set is split into its component elements.
     127
     128\begin{theorem} \label{env-reverse-thm}
     129The !next! pointer of a class representative in the union-find with classes algorithm without path compression points to a leaf from the most-recently-added subtree.
     130\end{theorem}
     131
     132\begin{proof}
     133        By induction on the height of the tree. \\
     134        \emph{Base case:} A height 1 tree by definition includes only a single item. In such a case, the representative's !next! pointer points to itself by construction, and the representative is the most-recently-added (and only) leaf in the tree. \\
     135        \emph{Inductive case:} By construction, a tree $T$ of height greater than 1 has children of the root (representative) node that were representative nodes of classes merged by $union$. By definition, the most-recently-added subtree $T'$ has a smaller height than $T$, thus by the inductive hypothesis before the most-recent $union$ operation the !next! pointer of the root of $T'$ pointed to one of the leaf nodes of $T'$; by construction the !next! pointer of the root of $T$ points to this leaf after the $union$ operation.
     136\end{proof}
     137
     138On its own, union-find, like the na\"{\i}ve approach, has no special constraints on life-cycle or inheritance, but it can be used as a building block in more sophisticated type environment data structures.
     139
     140\subsection{Persistent Union-Find}
     141
     142Given the backtracking nature of the resolution algorithm discussed in Section~\ref{env-defn-sec}, the abilities to quickly switch between related versions of a type environment and to de-duplicate shared data between environments are both assets to performance.
     143Conchon and Filli\^{a}tre~\cite{Conchon07} present a persistent union-find data structure based on the persistent array of Baker~\cite{Baker78,Baker91}.
     144
     145\TODO{port figure from slideshow}
     146
     147In Baker's persistent array, an array reference contains either a pointer to the array or a pointer to an \emph{edit node}; these edit nodes contain an array index, the value in that index, and another array reference pointing either to the array or a different edit node.
     148In this manner, a tree of edits is formed, rooted at the actual array.
     149Read from the actual array at the root can be performed in constant time, as with a non-persistent array.
     150The persistent array can be mutated in constant time by directly modifying the underlying array, then replacing its array reference with an edit node containing the mutated index, the previous value at that index, and a reference to the mutated array. If the current array reference is not the root, mutation consists simply of constructing a new edit node encoding the change and referring to the current array reference. 
     151The mutation algorithm at the root is in some sense a special case of the key operation on persistent arrays, $reroot$.
     152
     153A rerooting operation takes any array reference and makes it the root node of the array.
     154This is accomplished by tracing the path from some edit node to the root node of the array (always the underlying array), recursively applying the edits to the underlying array and replacing each edit node's successor with the inverse edit.
     155In this way, any previous state of the persistent array can be restored in time proportional to the number of edits to the current state of the array.
     156While $reroot$ does maintain the same value mapping in every version of the persistent array, the internal mutations it performs means that it is not thread-safe, and must be used behind a lock in a concurrent context.
     157Also, the root node with the actual array may in principle be anywhere in the tree, and does not provide information to report its leaf nodes, so some form of automatic garbage collection is generally required for the data structure.
     158Since the graph of edit nodes is tree-structured, reference counting approaches suffice for garbage collection; Conchon and Filli\^{a}tre~\cite{Conchon07} also observe that if the only $reroot$ operations are for backtracking then the tail of inverse edit nodes may be elided, suggesting the possibility of stack-based memory management.
     159
     160While Conchon and Filli\^{a}tre~\cite{Conchon07} implement their persistent union-find data structure over a universe of integer elements in the fixed range $[1,N]$, the type environment problem needs more flexibility.
     161In particular, an arbitrary number of type variables must be added to the environment.
     162As such, a persistent hash table is a more suitable structure than a persistent array, providing the same expected asymptotic time bounds while allowing a dynamic number of elements.
     163Besides replacing the underlying array with a hash table, the other major change in this approach is to replace the two types of array references, !Array! and !Edit!, with four node types, !Table!,  !Edit!, !Add!, and !Remove!, where !Add! adds a new key-value pair, !Remove! removes a key, and !Edit! mutates an existing key-value pair.
     164In this variant of \CFACC{}, this persistent hash table is used as the side map discussed in Section~\ref{env-union-find-approach} for class bounds.
     165The actual union-find data structure is slightly modified from this approach, with a !Base! node containing the root union-find data structure, !Add! nodes adding new elements, !AddTo! nodes defining the union of two type classes, and !Remove! and !RemoveFrom! nodes as inverses of the previous two elements, for purposes of maintaining the edit list.
     166Making !AddTo! and !RemoveFrom! single nodes shortens the edit path for improved performance, while also providing semantic information missing from the raw array updates in Conchon and Filli\^{a}tre's data structure.
     167The single-node approach, does, however, break under most path-compression algorithms; !RemoveFrom! can be applied to the underlying data structure using the ``leaf of last union'' approach discussed in in Section~\ref{env-union-find-classes-approach}; this was judged an acceptable trade-off for the added semantic information and shortened paths.
     168
     169Maintaining explicit information on $union$ operations in the persistent union-find edit tree in the form of !AddTo! and !RemoveFrom! nodes exposes a new option for combining type environments.
     170If the type environments are part of the same edit tree, one environment $T'$ can be combined with another $T$ by only testing the edits on the path from $T'$ to $T$ in both the persistent union-find data structure describing the classes and the persistent hash table containing the class bounds.
     171This is generally more efficient than testing the compatibility of all type classes in $T'$, as only those that are actually different than those in $T$ must be considered.
     172
     173The procedure for $combine(T, T')$ based on edit paths is as follows:
     174The shared edit trees for classes and bindings are rerooted at $T$, and the path from $T'$ to $T$ is followed to create a list of actual edits.
     175By tracking the state of each element, redundant changes such as an !Edit! followed by an !Edit! can be reduced to their form in $T'$ by dropping the later (more like $T$) !Edit! for the same key; !Add! and !Remove! cancel similarly.
     176This procedure is repeated for both the class edit tree and the binding edit tree.
     177When the list of net changes to the environment has been produced, the additive changes are applied to $T$.
     178For example, if a type class exists in $T'$ but not $T$, the corresponding !Add! edit will be applied to $T$, but in the reverse situation the !Remove! edit will not be applied to $T$, as the intention is to produce a new environment representing the union of the two sets of type classes; similarly, !AddTo! edits are applied to unify type-classes in $T$ that are united in $T'$, but !RemoveFrom! edits that split type classes are not.
     179The new environment, $T''$ can always be constructed with a consistent partitioning of type variables; in the extreme case, all variables from both $T$ and $T'$ will be united in a single type class in $T''$.
     180Where $combine$ can fail is in unifying the bound types; if any class in $T'$ has a class bound which does not unify with the merged class in $T''$ than $combine$ fails.
     181
     182\section{Analysis}
     183
     184In this section I present asymptotic analyses of the various approaches to a type environment data structure discussed in the previous section.
     185
     186\begin{table}
     187\caption[Type environment operation bounds]{Worst-case analysis of type environment operations. $n$ is the number of type classes, $m$ the maximum size of a type class, and $p$ the edit distance between two environments or a single environment and the empty environment; $u(n)$ captures the recursive cost of class unification.}
     188\label{env-bounds-table}
     189\centering
     190\begin{tabular}{rllll}
     191        \hline
     192                                & \textbf{Na\"{\i}ve}   & \textbf{Incremental}  & \textbf{Union-Find}           & \textbf{U-F with Classes}             \\
     193        \hline
     194        $find$          & $O(n)$                                & $O(p)$                                & $O(\alpha(m))$                        & $O(\log m)$                                   \\
     195        $report$        & $O(m)$                                & $O(m)$                                & $O(n \log m)$                         & $O(m)$                                                \\
     196        $bound$         & $O(1)$                                & $O(1)$                                & $O(1)$                                        & $O(1)$                                                \\
     197        $insert$        & $O(1)$                                & $O(1)$                                & $O(1)$                                        & $O(1)$                                                \\
     198        $add$           & $O(1)$                                & $O(1)$                                & $O(1)$                                        & $O(1)$                                                \\
     199        $bind$          & $O(1)$                                & $O(1)$                                & $O(1)$                                        & $O(1)$                                                \\
     200        $unify$         & $O(m + u(n))$                 & $O(m + u(n))$                 & $O(\log m + u(n))$            & $O(\log m + u(n))$                    \\
     201        $split$         & ---                                   & ---                                   & ---                                           & $O(\log m)$                                   \\
     202        $combine$       & $O(nm \cdot u(n))$    & $O(pm \cdot u(n))$    & $O(n \log m \cdot u(n))$      & $O(p \log m \cdot u(n))$              \\
     203        $save$          & $O(nm)$                               & $O(1)$                                & $O(nm)$                                       & $O(1)$                                                \\
     204        $backtrack$     & $O(nm)$                               & $O(pm)$                               & $O(nm)$                                       & $O(p)$                                                \\
     205        \hline
     206\end{tabular}
     207\end{table}
    65208
    66209% Future work: design multi-threaded version of C&F persistent map --- core idea is some sort of thread-boundary edit node

  • doc/user/Makefile

    r1f690b3 r90cfc16  
    7979## Define the default recipes.
    8080
    81 ${Build}:
     81${Build} :
    8282        mkdir -p ${Build}
    8383

  • doc/user/user.tex

    r1f690b3 r90cfc16  
    1111%% Created On       : Wed Apr  6 14:53:29 2016
    1212%% Last Modified By : Peter A. Buhr
    13 %% Last Modified On : Fri Aug 31 07:54:50 2018
    14 %% Update Count     : 3396
     13%% Last Modified On : Wed Nov  7 17:00:49 2018
     14%% Update Count     : 3399
    1515%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    1616
    … …  
    547547
    548548
    549 %\subsection{\texorpdfstring{\protect\lstinline@for@ Statement}{for Statement}}
    550 \subsection{\texorpdfstring{\LstKeywordStyle{for} Statement}{for Statement}}
     549\subsection{Loop Control}
    551550
    552551The ©for©/©while©/©do-while© loop-control allows empty or simplified ranges.
    … …  
    557556the down-to range ©-~=©\index{-~=@©-~=©} means inclusive range [N,M].
    558557©0© is the implicit start value;
    559 ©1© is the implicit increment value for an up-to range and ©-1© for an implicit down-to range.
     558©1© is the implicit increment value.
     559The up-to range uses ©+=© for increment;
     560the down-to range uses ©-=© for decrement.
    560561The loop index is polymorphic in the type of the start value or comparison value when start is implicitly ©0©.
    561562\begin{cquote}
    562563\begin{tabular}{@{}ll|l@{}}
    563 \multicolumn{2}{c|}{for control} & \multicolumn{1}{c}{output} \\
     564\multicolumn{2}{c|}{loop control} & \multicolumn{1}{c}{output} \\
    564565\hline
    565566\begin{cfa}
    … …  
    571572for ( ®10® ) { sout | "A"; }
    572573for ( ®1 ~= 10 ~ 2® ) { sout | "B"; }
    573 for ( ®10 -~= 1 ~ -2® ) { sout | "C"; }
     574for ( ®10 -~= 1 ~ 2® ) { sout | "C"; }
    574575for ( ®0.5 ~ 5.5® ) { sout | "D"; }
    575576for ( ®5.5 -~ 0.5® ) { sout | "E"; }
    576577for ( ®i; 10® ) { sout | i; }
    577578for ( ®i; 1 ~= 10 ~ 2® ) { sout | i; }
    578 for ( ®i; 10 -~= 1 ~ -2® ) { sout | i; }
     579for ( ®i; 10 -~= 1 ~ 2® ) { sout | i; }
    579580for ( ®i; 0.5 ~ 5.5® ) { sout | i; }
    580581for ( ®i; 5.5 -~ 0.5® ) { sout | i; }
    581582for ( ®ui; 2u ~= 10u ~ 2u® ) { sout | ui; }
    582 for ( ®ui; 10u -~= 2u ~ -2u® ) { sout | ui; }
    583 int start = 3, comp = 10, inc = 2;
     583for ( ®ui; 10u -~= 2u ~ 2u® ) { sout | ui; }
     584enum { N = 10 };
     585for ( ®N® ) { sout | "N"; }
     586for ( ®i; N® ) { sout | i; }
     587for ( ®i; N -~ 0® ) { sout | i; }
     588const int start = 3, comp = 10, inc = 2;
    584589for ( ®i; start ~ comp ~ inc + 1® ) { sout | i; }
    585590\end{cfa}
    586591&
    587592\begin{cfa}
     593sout | endl;
     594sout | endl;
     595sout | endl;
     596sout | "zero" | endl;
    588597sout | endl;
    589598sout | endl;
    … …  
    598607sout | endl;
    599608sout | endl;
     609sout | endl | endl;
     610
    600611sout | endl;
    601612sout | endl;
    602 sout | endl;
    603 sout | endl;
    604 sout | endl;
     613sout | endl | endl;
    605614
    606615sout | endl;
    … …  
    611620empty
    612621empty
    613 
     622zero
    614623A
    615624A A A A A A A A A A
    … …  
    6256342 4 6 8 10
    62663510 8 6 4 2
     636
     637N N N N N N N N N N
     6380 1 2 3 4 5 6 7 8 9
     63910 9 8 7 6 5 4 3 2 1
    627640
    6286413 6 9

  • libcfa/src/iostream.cfa

    r1f690b3 r90cfc16  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Aug 11 13:56:43 2018
    13 // Update Count     : 473
     12// Last Modified On : Fri Nov  2 07:17:05 2018
     13// Update Count     : 474
    1414//
    1515
    … …  
    410410// Local Variables: //
    411411// tab-width: 4 //
    412 // compile-command: "cfa iostream.c" //
     412// compile-command: "cfa iostream.cfa" //
    413413// End: //

  • libcfa/src/iterator.cfa

    r1f690b3 r90cfc16  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Jul  7 08:38:23 2017
    13 // Update Count     : 28
     12// Last Modified On : Fri Nov  2 07:17:37 2018
     13// Update Count     : 29
    1414//
    1515
    … …  
    3333// Local Variables: //
    3434// tab-width: 4 //
    35 // compile-command: "cfa iterator.c" //
     35// compile-command: "cfa iterator.cfa" //
    3636// End: //

  • src/Parser/DeclarationNode.cc

    r1f690b3 r90cfc16  
    1010// Created On       : Sat May 16 12:34:05 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Jul 20 14:56:54 2018
    13 // Update Count     : 1107
     12// Last Modified On : Thu Nov  1 20:54:26 2018
     13// Update Count     : 1108
    1414//
    1515
    … …  
    402402}
    403403
    404 DeclarationNode * DeclarationNode::newTypeof( ExpressionNode * expr ) {
    405         DeclarationNode * newnode = new DeclarationNode;
    406         newnode->type = new TypeData( TypeData::Typeof );
     404DeclarationNode * DeclarationNode::newTypeof( ExpressionNode * expr, bool basetypeof ) {
     405        DeclarationNode * newnode = new DeclarationNode;
     406        newnode->type = new TypeData( basetypeof ? TypeData::Basetypeof : TypeData::Typeof );
    407407        newnode->type->typeexpr = expr;
    408408        return newnode;

  • src/Parser/ParseNode.h

    r1f690b3 r90cfc16  
    1010// Created On       : Sat May 16 13:28:16 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Aug  4 09:39:40 2018
    13 // Update Count     : 853
     12// Last Modified On : Thu Nov  1 20:54:53 2018
     13// Update Count     : 854
    1414//
    1515
    … …  
    249249        static DeclarationNode * newBitfield( ExpressionNode * size );
    250250        static DeclarationNode * newTuple( DeclarationNode * members );
    251         static DeclarationNode * newTypeof( ExpressionNode * expr );
     251        static DeclarationNode * newTypeof( ExpressionNode * expr, bool basetypeof = false );
    252252        static DeclarationNode * newAttr( const std::string *, ExpressionNode * expr ); // @ attributes
    253253        static DeclarationNode * newAttr( const std::string *, DeclarationNode * type ); // @ attributes

  • src/Parser/TypeData.cc

    r1f690b3 r90cfc16  
    1010// Created On       : Sat May 16 15:12:51 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Jul 20 14:39:31 2018
    13 // Update Count     : 622
     12// Last Modified On : Fri Nov  2 07:54:26 2018
     13// Update Count     : 624
    1414//
    1515
    … …  
    9696                break;
    9797          case Typeof:
     98          case Basetypeof:
    9899                // typeexpr = new Typeof_t;
    99100                typeexpr = nullptr;
    … …  
    166167                break;
    167168          case Typeof:
     169          case Basetypeof:
    168170                // delete typeexpr->expr;
    169171                delete typeexpr;
    … …  
    245247                break;
    246248          case Typeof:
     249          case Basetypeof:
    247250                newtype->typeexpr = maybeClone( typeexpr );
    248251                break;
    … …  
    419422                } // if
    420423                break;
     424          case Basetypeof:
     425                os << "base-";
     426                #if defined(__GNUC__) && __GNUC__ >= 7
     427                        __attribute__((fallthrough));
     428                #endif
    421429          case Typeof:
    422430                os << "type-of expression ";
    … …  
    457465          case Tuple:
    458466          case Typeof:
     467          case Basetypeof:
    459468          case Builtin:
    460469                assertf(false, "Tried to get leaf name from kind without a name: %d", kind);
    … …  
    513522        switch ( td->kind ) {
    514523          case TypeData::Unknown:
    515                 // fill in implicit int
    516                 return new BasicType( buildQualifiers( td ), BasicType::SignedInt );
     524                        // fill in implicit int
     525                        return new BasicType( buildQualifiers( td ), BasicType::SignedInt );
    517526          case TypeData::Basic:
    518                 return buildBasicType( td );
     527                        return buildBasicType( td );
    519528          case TypeData::Pointer:
    520                 return buildPointer( td );
     529                        return buildPointer( td );
    521530          case TypeData::Array:
    522                 return buildArray( td );
     531                        return buildArray( td );
    523532          case TypeData::Reference:
    524                 return buildReference( td );
     533                        return buildReference( td );
    525534          case TypeData::Function:
    526                 return buildFunction( td );
     535                        return buildFunction( td );
    527536          case TypeData::AggregateInst:
    528                 return buildAggInst( td );
     537                        return buildAggInst( td );
    529538          case TypeData::EnumConstant:
    530                 // the name gets filled in later -- by SymTab::Validate
    531                 return new EnumInstType( buildQualifiers( td ), "" );
     539                        // the name gets filled in later -- by SymTab::Validate
     540                        return new EnumInstType( buildQualifiers( td ), "" );
    532541          case TypeData::SymbolicInst:
    533                 return buildSymbolicInst( td );
     542                        return buildSymbolicInst( td );
    534543          case TypeData::Tuple:
    535                 return buildTuple( td );
     544                        return buildTuple( td );
    536545          case TypeData::Typeof:
    537                 return buildTypeof( td );
     546          case TypeData::Basetypeof:
     547                        return buildTypeof( td );
    538548          case TypeData::Builtin:
    539                 if(td->builtintype == DeclarationNode::Zero) {
    540                         return new ZeroType( noQualifiers );
    541                 }
    542                 else if(td->builtintype == DeclarationNode::One) {
    543                         return new OneType( noQualifiers );
    544                 }
    545                 else {
    546                         return new VarArgsType( buildQualifiers( td ) );
    547                 }
     549                        if (td->builtintype == DeclarationNode::Zero) {
     550                                return new ZeroType( noQualifiers );
     551                        }
     552                        else if (td->builtintype == DeclarationNode::One) {
     553                                return new OneType( noQualifiers );
     554                        }
     555                        else {
     556                                return new VarArgsType( buildQualifiers( td ) );
     557                        }
    548558          case TypeData::GlobalScope:
    549                 return new GlobalScopeType();
     559                        return new GlobalScopeType();
    550560                case TypeData::Qualified:
    551                 return new QualifiedType( buildQualifiers( td ), typebuild( td->qualified.parent ), typebuild( td->qualified.child ) );
     561                        return new QualifiedType( buildQualifiers( td ), typebuild( td->qualified.parent ), typebuild( td->qualified.child ) );
    552562          case TypeData::Symbolic:
    553563          case TypeData::Enum:
    554564          case TypeData::Aggregate:
    555                 assert( false );
     565                        assert( false );
    556566        } // switch
    557567
    … …  
    929939
    930940TypeofType * buildTypeof( const TypeData * td ) {
    931         assert( td->kind == TypeData::Typeof );
     941        assert( td->kind == TypeData::Typeof || td->kind == TypeData::Basetypeof );
    932942        assert( td->typeexpr );
    933943        // assert( td->typeexpr->expr );
    934         return new TypeofType( buildQualifiers( td ), td->typeexpr->build() );
     944        return new TypeofType{
     945                buildQualifiers( td ), td->typeexpr->build(), td->kind == TypeData::Basetypeof };
    935946} // buildTypeof
    936947

  • src/Parser/TypeData.h

    r1f690b3 r90cfc16  
    1010// Created On       : Sat May 16 15:18:36 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Jul 20 13:56:40 2018
    13 // Update Count     : 195
     12// Last Modified On : Thu Nov  1 20:56:46 2018
     13// Update Count     : 196
    1414//
    1515
    … …  
    2727struct TypeData {
    2828        enum Kind { Basic, Pointer, Reference, Array, Function, Aggregate, AggregateInst, Enum, EnumConstant, Symbolic,
    29                                 SymbolicInst, Tuple, Typeof, Builtin, GlobalScope, Qualified, Unknown };
     29                                SymbolicInst, Tuple, Typeof, Basetypeof, Builtin, GlobalScope, Qualified, Unknown };
    3030
    3131        struct Aggregate_t {

  • src/Parser/lex.ll

    r1f690b3 r90cfc16  
    1010 * Created On       : Sat Sep 22 08:58:10 2001
    1111 * Last Modified By : Peter A. Buhr
    12  * Last Modified On : Wed Aug 29 15:02:41 2018
    13  * Update Count     : 686
     12 * Last Modified On : Thu Nov  1 20:57:35 2018
     13 * Update Count     : 687
    1414 */
    1515
    … …  
    209209__attribute__   { KEYWORD_RETURN(ATTRIBUTE); }                  // GCC
    210210auto                    { KEYWORD_RETURN(AUTO); }
     211basetypeof              { KEYWORD_RETURN(BASETYPEOF); }                 // CFA
    211212_Bool                   { KEYWORD_RETURN(BOOL); }                               // C99
    212213break                   { KEYWORD_RETURN(BREAK); }

  • src/Parser/parser.yy

    r1f690b3 r90cfc16  
    1010// Created On       : Sat Sep  1 20:22:55 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Aug 30 17:02:25 2018
    13 // Update Count     : 4029
     12// Last Modified On : Thu Nov  8 18:08:23 2018
     13// Update Count     : 4052
    1414//
    1515
    … …  
    186186} // fieldDecl
    187187
    188 ExpressionNode *forInc( const OperKinds op ) {
    189         return new ExpressionNode( build_constantInteger( *new string( op == OperKinds::LThan || op == OperKinds::LEThan ? "1" : "-1" ) ) );
    190 } // forInc
    191 
    192188ForCtrl * forCtrl( ExpressionNode * type, string * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
    193         ConstantExpr *constant = dynamic_cast<ConstantExpr *>(type->get_expr());
     189        ConstantExpr * constant = dynamic_cast<ConstantExpr *>(type->get_expr());
    194190        if ( constant && (constant->get_constant()->get_value() == "0" || constant->get_constant()->get_value() == "1") ) {
    195191        type = new ExpressionNode( new CastExpr( maybeMoveBuild< Expression >(type), new BasicType( Type::Qualifiers(), BasicType::SignedInt ) ) );
    196192        } // if
    197193        return new ForCtrl(
    198                 distAttr( DeclarationNode::newTypeof( type ), DeclarationNode::newName( index )->addInitializer( new InitializerNode( start ) ) ),
     194                distAttr( DeclarationNode::newTypeof( type, true ), DeclarationNode::newName( index )->addInitializer( new InitializerNode( start ) ) ),
    199195                new ExpressionNode( build_binary_val( compop, new ExpressionNode( build_varref( new string( *index ) ) ), comp ) ),
    200                 new ExpressionNode( build_binary_val( OperKinds::PlusAssn, new ExpressionNode( build_varref( new string( *index ) ) ), inc ) ) );
     196                new ExpressionNode( build_binary_val( compop == OperKinds::LThan || compop == OperKinds::LEThan ? // choose += or -= for upto/downto
     197                                                                                          OperKinds::PlusAssn : OperKinds::MinusAssn, new ExpressionNode( build_varref( new string( *index ) ) ), inc ) ) );
     198} // forCtrl
     199
     200ForCtrl * forCtrl( ExpressionNode * type, ExpressionNode * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
     201        if ( NameExpr * identifier = dynamic_cast<NameExpr *>(index->get_expr()) ) {
     202                return forCtrl( type, new string( identifier->name ), start, compop, comp, inc );
     203        } else {
     204                SemanticError( yylloc, "Expression disallowed. Only loop-index name allowed" ); return nullptr;
     205        } // if
    201206} // forCtrl
    202207
    … …  
    261266%token ZERO_T ONE_T                                                                             // CFA
    262267%token VALIST                                                                                   // GCC
    263 %token TYPEOF LABEL                                                                             // GCC
     268%token TYPEOF BASETYPEOF LABEL                                                  // GCC
    264269%token ENUM STRUCT UNION
    265270%token EXCEPTION                                                                                // CFA
    … …  
    636641                { $$ = new ExpressionNode( build_fieldSel( $1, build_tuple( $4 ) ) ); }
    637642        | postfix_expression ARROW no_attr_identifier
    638                 {
    639                         $$ = new ExpressionNode( build_pfieldSel( $1, *$3 == "0" || *$3 == "1" ? build_constantInteger( *$3 ) : build_varref( $3 ) ) );
    640                 }
     643                { $$ = new ExpressionNode( build_pfieldSel( $1, build_varref( $3 ) ) ); }
    641644        | postfix_expression ARROW INTEGERconstant                      // CFA, tuple index
    642645                { $$ = new ExpressionNode( build_pfieldSel( $1, build_constantInteger( *$3 ) ) ); }
    … …  
    11371140        | FOR '(' push for_control_expression ')' statement pop
    11381141                { $$ = new StatementNode( build_for( $4, $6 ) ); }
     1142        | FOR '(' ')' statement                                                         // CFA => for ( ;; )
     1143                { $$ = new StatementNode( build_for( new ForCtrl( (ExpressionNode * )nullptr, (ExpressionNode * )nullptr, (ExpressionNode * )nullptr ), $4 ) ); }
    11391144        ;
    11401145
    11411146for_control_expression:
    1142         comma_expression_opt                                                            // CFA
    1143                 {
    1144                         if ( ! $1 ) {                                                           // => for ( ;; )
    1145                                 $$ = new ForCtrl( (ExpressionNode * )nullptr, (ExpressionNode * )nullptr, (ExpressionNode * )nullptr );
    1146                         } else {
    1147                                 $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), new ExpressionNode( build_constantInteger( *new string( "0" ) ) ),
    1148                                                           OperKinds::LThan, $1->clone(), forInc( OperKinds::LThan ) );
    1149                         } // if
    1150                 }
     1147        comma_expression                                                                        // CFA
     1148                { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), new ExpressionNode( build_constantInteger( *new string( "0" ) ) ),
     1149                                                OperKinds::LThan, $1->clone(), new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
    11511150        | constant_expression inclexcl constant_expression      // CFA
    1152                 { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), $1->clone(), $2, $3, forInc( $2 ) ); }
     1151                { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), $1->clone(), $2, $3, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
    11531152        | constant_expression inclexcl constant_expression '~' constant_expression // CFA
    11541153                { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), $1->clone(), $2, $3, $5 ); }
    1155         | comma_expression_opt ';' comma_expression                     // CFA
    1156                 {
    1157                         if ( ! $1 ) {
    1158                                 SemanticError( yylloc, "Missing loop index." ); $$ = nullptr;
    1159                         } else if ( ! $3 ) {
    1160                                 SemanticError( yylloc, "Missing loop range." ); $$ = nullptr;
    1161                         } else {
    1162                                 if ( NameExpr *identifier = dynamic_cast<NameExpr *>($1->get_expr()) ) {
    1163                                         $$ = forCtrl( $3, new string( identifier->name ), new ExpressionNode( build_constantInteger( *new string( "0" ) ) ),
    1164                                                                   OperKinds::LThan, $3->clone(), forInc( OperKinds::LThan ) );
    1165                                 } else {
    1166                                         SemanticError( yylloc, "Expression disallowed. Only loop-index name allowed" ); $$ = nullptr;
    1167                                 } // if
    1168                         } // if
    1169                 }
    1170         | comma_expression_opt ';' constant_expression inclexcl constant_expression // CFA
    1171                 {
    1172                         if ( ! $1 ) {
    1173                                 SemanticError( yylloc, "Missing loop index." ); $$ = nullptr;
    1174                         } else {
    1175                                 if ( NameExpr *identifier = dynamic_cast<NameExpr *>($1->get_expr()) ) {
    1176                                         $$ = forCtrl( $3, new string( identifier->name ), $3->clone(), $4, $5, forInc( $4 ) );
    1177                                 } else {
    1178                                         SemanticError( yylloc, "Expression disallowed. Only loop-index name allowed" ); $$ = nullptr;
    1179                                 } // if
    1180                         } // if
    1181                 }
    1182         | comma_expression_opt ';' constant_expression inclexcl constant_expression '~' constant_expression // CFA
    1183                 {
    1184                         if ( ! $1 ) {
    1185                                 SemanticError( yylloc, "Missing loop index." ); $$ = nullptr;
    1186                         } else {
    1187                                 if ( NameExpr *identifier = dynamic_cast<NameExpr *>($1->get_expr()) ) {
    1188                                         $$ = forCtrl( $3, new string( identifier->name ), $3->clone(), $4, $5, $7 );
    1189                                 } else {
    1190                                         SemanticError( yylloc, "Expression disallowed. Only loop-index name allowed" ); $$ = nullptr;
    1191                                 } // if
    1192                         } // if
    1193                 }
    1194         | comma_expression_opt ';' comma_expression_opt ';' comma_expression_opt
     1154        | comma_expression ';' comma_expression                         // CFA
     1155                { $$ = forCtrl( $3, $1, new ExpressionNode( build_constantInteger( *new string( "0" ) ) ),
     1156                                                OperKinds::LThan, $3->clone(), new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
     1157        | comma_expression ';' constant_expression inclexcl constant_expression // CFA
     1158                { $$ = forCtrl( $3, $1, $3->clone(), $4, $5, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
     1159        | comma_expression ';' constant_expression inclexcl constant_expression '~' constant_expression // CFA
     1160                { $$ = forCtrl( $3, $1, $3->clone(), $4, $5, $7 ); }
     1161        | comma_expression ';' comma_expression_opt ';' comma_expression_opt
    11951162                { $$ = new ForCtrl( $1, $3, $5 ); }
     1163        | ';' comma_expression_opt ';' comma_expression_opt
     1164                { $$ = new ForCtrl( (ExpressionNode * )nullptr, $2, $4 ); }
    11961165        | declaration comma_expression_opt ';' comma_expression_opt // C99, declaration has ';'
    11971166                { $$ = new ForCtrl( $1, $2, $4 ); }
    … …  
    18551824
    18561825indirect_type:
    1857         TYPEOF '(' type ')'                                                                     // GCC: typeof(x) y;
     1826        TYPEOF '(' type ')'                                                                     // GCC: typeof( x ) y;
    18581827                { $$ = $3; }
    1859         | TYPEOF '(' comma_expression ')'                                       // GCC: typeof(a+b) y;
     1828        | TYPEOF '(' comma_expression ')'                                       // GCC: typeof( a+b ) y;
    18601829                { $$ = DeclarationNode::newTypeof( $3 ); }
    1861         | ATTR_TYPEGENname '(' type ')'                                         // CFA: e.g., @type(x) y;
     1830        | BASETYPEOF '(' type ')'                                                       // CFA: basetypeof( x ) y;
     1831                { $$ = DeclarationNode::newTypeof( new ExpressionNode( new TypeExpr( maybeMoveBuildType( $3 ) ) ), true ); }
     1832        | BASETYPEOF '(' comma_expression ')'                           // CFA: basetypeof( a+b ) y;
     1833                { $$ = DeclarationNode::newTypeof( $3, true ); }
     1834        | ATTR_TYPEGENname '(' type ')'                                         // CFA: e.g., @type( x ) y;
    18621835                { $$ = DeclarationNode::newAttr( $1, $3 ); }
    1863         | ATTR_TYPEGENname '(' comma_expression ')'                     // CFA: e.g., @type(a+b) y;
     1836        | ATTR_TYPEGENname '(' comma_expression ')'                     // CFA: e.g., @type( a+b ) y;
    18641837                { $$ = DeclarationNode::newAttr( $1, $3 ); }
    18651838        | ZERO_T                                                                                        // CFA

  • src/ResolvExpr/AlternativeFinder.cc

    r1f690b3 r90cfc16  
    1010// Created On       : Sat May 16 23:52:08 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Feb 17 11:19:39 2018
    13 // Update Count     : 33
     12// Last Modified On : Thu Nov  1 21:00:56 2018
     13// Update Count     : 34
    1414//
    1515
    … …  
    13441344                /// Gets name from untyped member expression (member must be NameExpr)
    13451345                const std::string& get_member_name( UntypedMemberExpr *memberExpr ) {
     1346                        if ( dynamic_cast< ConstantExpr * >( memberExpr->get_member() ) ) {
     1347                                SemanticError( memberExpr, "Indexed access to struct fields unsupported: " );
     1348                        } // if
    13461349                        NameExpr * nameExpr = dynamic_cast< NameExpr * >( memberExpr->get_member() );
    13471350                        assert( nameExpr );

  • src/ResolvExpr/ResolveTypeof.cc

    r1f690b3 r90cfc16  
    6767                std::cerr << std::endl;
    6868#endif
    69                 if ( typeofType->expr ) {
     69                // pass on null expression
     70                if ( ! typeofType->expr ) return typeofType;
     71
     72                bool isBasetypeof = typeofType->is_basetypeof;
     73                auto oldQuals = typeofType->get_qualifiers().val;
     74
     75                Type* newType;
     76                if ( TypeExpr* tyExpr = dynamic_cast<TypeExpr*>(typeofType->expr) ) {
     77                        // typeof wrapping type
     78                        newType = tyExpr->type;
     79                        tyExpr->type = nullptr;
     80                        delete tyExpr;
     81                } else {
     82                        // typeof wrapping expression
    7083                        Expression * newExpr = resolveInVoidContext( typeofType->expr, indexer );
    7184                        assert( newExpr->result && ! newExpr->result->isVoid() );
    72                         Type * newType = newExpr->result;
     85                        newType = newExpr->result;
    7386                        newExpr->result = nullptr;
    7487                        delete typeofType;
    7588                        delete newExpr;
    76                         return newType;
    77                 } // if
    78                 return typeofType;
     89                }
     90
     91                // clear qualifiers for base, combine with typeoftype quals in any case
     92                if ( isBasetypeof ) {
     93                        // replace basetypeof(<enum>) by int
     94                        if ( dynamic_cast<EnumInstType*>(newType) ) {
     95                                Type* newerType =
     96                                        new BasicType{ newType->get_qualifiers(), BasicType::SignedInt,
     97                                        newType->attributes };
     98                                delete newType;
     99                                newType = newerType;
     100                        }
     101                        newType->get_qualifiers().val
     102                                = ( newType->get_qualifiers().val & ~Type::Qualifiers::Mask ) | oldQuals;
     103                } else {
     104                        newType->get_qualifiers().val |= oldQuals;
     105                }
     106               
     107                return newType;
    79108        }
    80109} // namespace ResolvExpr

  • src/SynTree/Type.h

    r1f690b3 r90cfc16  
    598598class TypeofType : public Type {
    599599  public:
    600         Expression *expr;
    601 
    602         TypeofType( const Type::Qualifiers & tq, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
     600        Expression *expr;    ///< expression to take the type of
     601        bool is_basetypeof;  ///< true iff is basetypeof type
     602
     603        TypeofType( const Type::Qualifiers & tq, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
     604        TypeofType( const Type::Qualifiers & tq, Expression *expr, bool is_basetypeof,
     605                const std::list< Attribute * > & attributes = std::list< Attribute * >() );
    603606        TypeofType( const TypeofType& );
    604607        virtual ~TypeofType();

  • src/SynTree/TypeofType.cc

    r1f690b3 r90cfc16  
    2323class Attribute;
    2424
    25 TypeofType::TypeofType( const Type::Qualifiers &tq, Expression *expr, const std::list< Attribute * > & attributes ) : Type( tq, attributes ), expr( expr ) {
    26 }
     25TypeofType::TypeofType( const Type::Qualifiers &tq, Expression *expr,
     26        const std::list< Attribute * > & attributes )
     27: Type( tq, attributes ), expr( expr ), is_basetypeof(false) {}
    2728
    28 TypeofType::TypeofType( const TypeofType &other ) : Type( other ), expr( maybeClone( other.expr ) ) {
    29 }
     29TypeofType::TypeofType( const Type::Qualifiers &tq, Expression *expr, bool is_basetypeof,
     30        const std::list< Attribute * > & attributes )
     31: Type( tq, attributes ), expr( expr ), is_basetypeof( is_basetypeof ) {}
     32
     33TypeofType::TypeofType( const TypeofType &other )
     34: Type( other ), expr( maybeClone( other.expr ) ), is_basetypeof( other.is_basetypeof ) {}
    3035
    3136TypeofType::~TypeofType() {
    … …  
    3540void TypeofType::print( std::ostream &os, Indenter indent ) const {
    3641        Type::print( os, indent );
     42        if ( is_basetypeof ) { os << "base-"; }
    3743        os << "type-of expression ";
    3844        if ( expr ) {

  • tests/.expect/alloc-ERROR.txt

    r1f690b3 r90cfc16  
    1 alloc.c:265:1 error: No reasonable alternatives for expression Applying untyped:
     1alloc.cfa:265:1 error: No reasonable alternatives for expression Applying untyped:
    22  Name: ?=?
    33...to:
    … …  
    1919
    2020
    21 alloc.c:266:1 error: No reasonable alternatives for expression Applying untyped:
     21alloc.cfa:266:1 error: No reasonable alternatives for expression Applying untyped:
    2222  Name: ?=?
    2323...to:
    … …  
    3939
    4040
    41 alloc.c:267:1 error: No reasonable alternatives for expression Applying untyped:
     41alloc.cfa:267:1 error: No reasonable alternatives for expression Applying untyped:
    4242  Name: ?=?
    4343...to:
    … …  
    5050
    5151
    52 alloc.c:268:1 error: No reasonable alternatives for expression Applying untyped:
     52alloc.cfa:268:1 error: No reasonable alternatives for expression Applying untyped:
    5353  Name: ?=?
    5454...to:

  • tests/.expect/castError.txt

    r1f690b3 r90cfc16  
    1 castError.c:7:1 error: Cannot choose between 3 alternatives for expression
     1castError.cfa:7:1 error: Cannot choose between 3 alternatives for expression
    22Cast of:
    33  Name: f
    44... to:
    5   charAlternatives are:
     5  char Alternatives are:
    66Cost ( 1, 0, 0, 0 ): Cast of:
    77     Variable Expression: f: function

  • tests/.expect/completeTypeError.txt

    r1f690b3 r90cfc16  
    1 completeTypeError.c:33:1 error: No reasonable alternatives for expression Applying untyped:
     1completeTypeError.cfa:33:1 error: No reasonable alternatives for expression Applying untyped:
    22  Name: *?
    33...to:
    44  Name: v
    55
    6 completeTypeError.c:34:1 error: No reasonable alternatives for expression Applying untyped:
     6completeTypeError.cfa:34:1 error: No reasonable alternatives for expression Applying untyped:
    77  Name: *?
    88...to:
    99  Name: y
    1010
    11 completeTypeError.c:35:1 error: No reasonable alternatives for expression Applying untyped:
     11completeTypeError.cfa:35:1 error: No reasonable alternatives for expression Applying untyped:
    1212  Name: foo
    1313...to:
    1414  Name: v
    1515
    16 completeTypeError.c:36:1 error: No reasonable alternatives for expression Applying untyped:
     16completeTypeError.cfa:36:1 error: No reasonable alternatives for expression Applying untyped:
    1717  Name: baz
    1818...to:
    1919  Name: v
    2020
    21 completeTypeError.c:37:1 error: No reasonable alternatives for expression Applying untyped:
     21completeTypeError.cfa:37:1 error: No reasonable alternatives for expression Applying untyped:
    2222  Name: quux
    2323...to:
    2424  Name: v
    2525
    26 completeTypeError.c:58:1 error: No reasonable alternatives for expression Applying untyped:
     26completeTypeError.cfa:58:1 error: No reasonable alternatives for expression Applying untyped:
    2727  Name: baz
    2828...to:
    2929  Name: y
    3030
    31 completeTypeError.c:59:1 error: No reasonable alternatives for expression Applying untyped:
     31completeTypeError.cfa:59:1 error: No reasonable alternatives for expression Applying untyped:
    3232  Name: quux
    3333...to:
    3434  Name: y
    3535
    36 completeTypeError.c:60:1 error: No reasonable alternatives for expression Applying untyped:
     36completeTypeError.cfa:60:1 error: No reasonable alternatives for expression Applying untyped:
    3737  Name: *?
    3838...to:
    3939  Name: y
    4040
    41 completeTypeError.c:72:1 error: No reasonable alternatives for expression Applying untyped:
     41completeTypeError.cfa:72:1 error: No reasonable alternatives for expression Applying untyped:
    4242  Name: baz
    4343...to:

  • tests/.expect/declarationErrors.txt

    r1f690b3 r90cfc16  
    1 declarationErrors.c:16:1 error: duplicate static in declaration of x1: static const volatile short int
     1declarationErrors.cfa:16:1 error: duplicate static in declaration of x1: static const volatile short int
    22
    3 declarationErrors.c:17:1 error: conflicting extern & static in declaration of x2: extern const volatile short int
     3declarationErrors.cfa:17:1 error: conflicting extern & static in declaration of x2: extern const volatile short int
    44
    5 declarationErrors.c:18:1 error: conflicting extern & auto, conflicting extern & static, conflicting extern & static, duplicate extern in declaration of x3: extern const volatile short int
     5declarationErrors.cfa:18:1 error: conflicting extern & auto, conflicting extern & static, conflicting extern & static, duplicate extern in declaration of x3: extern const volatile short int
    66
    7 declarationErrors.c:19:1 error: duplicate static in declaration of x4: static const volatile instance of const volatile struct __anonymous0
     7declarationErrors.cfa:19:1 error: duplicate static in declaration of x4: static const volatile instance of const volatile struct __anonymous0
    88  with members
    99    i: int
    … …  
    1111
    1212
    13 declarationErrors.c:20:1 error: duplicate const, duplicate static, duplicate volatile in declaration of x5: static const volatile instance of const volatile struct __anonymous1
     13declarationErrors.cfa:20:1 error: duplicate const, duplicate static, duplicate volatile in declaration of x5: static const volatile instance of const volatile struct __anonymous1
    1414  with members
    1515    i: int
    … …  
    1717
    1818
    19 declarationErrors.c:22:1 error: duplicate static in declaration of x6: static const volatile Int
     19declarationErrors.cfa:22:1 error: duplicate static in declaration of x6: static const volatile Int
    2020
    21 declarationErrors.c:24:1 error: duplicate const in declaration of f01: static inline function
     21declarationErrors.cfa:24:1 error: duplicate const in declaration of f01: static inline function
    2222  with no parameters
    2323  returning const volatile int
    2424
    2525
    26 declarationErrors.c:25:1 error: duplicate volatile in declaration of f02: static inline function
     26declarationErrors.cfa:25:1 error: duplicate volatile in declaration of f02: static inline function
    2727  with no parameters
    2828  returning const volatile int
    2929
    3030
    31 declarationErrors.c:26:1 error: duplicate const in declaration of f03: static inline function
     31declarationErrors.cfa:26:1 error: duplicate const in declaration of f03: static inline function
    3232  with no parameters
    3333  returning const volatile int
    3434
    3535
    36 declarationErrors.c:27:1 error: duplicate volatile in declaration of f04: static inline function
     36declarationErrors.cfa:27:1 error: duplicate volatile in declaration of f04: static inline function
    3737  with no parameters
    3838  returning const volatile int
    3939
    4040
    41 declarationErrors.c:28:1 error: duplicate const in declaration of f05: static inline function
     41declarationErrors.cfa:28:1 error: duplicate const in declaration of f05: static inline function
    4242  with no parameters
    4343  returning const volatile int
    4444
    4545
    46 declarationErrors.c:29:1 error: duplicate volatile in declaration of f06: static inline function
     46declarationErrors.cfa:29:1 error: duplicate volatile in declaration of f06: static inline function
    4747  with no parameters
    4848  returning const volatile int
    4949
    5050
    51 declarationErrors.c:30:1 error: duplicate const in declaration of f07: static inline function
     51declarationErrors.cfa:30:1 error: duplicate const in declaration of f07: static inline function
    5252  with no parameters
    5353  returning const volatile int
    5454
    5555
    56 declarationErrors.c:31:1 error: duplicate const, duplicate volatile in declaration of f08: static inline function
     56declarationErrors.cfa:31:1 error: duplicate const, duplicate volatile in declaration of f08: static inline function
    5757  with no parameters
    5858  returning const volatile int
    5959
    6060
    61 declarationErrors.c:33:1 error: duplicate const, duplicate volatile in declaration of f09: static inline function
     61declarationErrors.cfa:33:1 error: duplicate const, duplicate volatile in declaration of f09: static inline function
    6262  with no parameters
    6363  returning const volatile int
    6464
    6565
    66 declarationErrors.c:34:1 error: duplicate const, duplicate _Atomic, duplicate _Atomic, duplicate const, duplicate restrict, duplicate volatile in declaration of f09: static inline function
     66declarationErrors.cfa:34:1 error: duplicate const, duplicate _Atomic, duplicate _Atomic, duplicate const, duplicate restrict, duplicate volatile in declaration of f09: static inline function
    6767  with no parameters
    6868  returning const restrict volatile _Atomic int

  • tests/.expect/loopctrl.txt

    r1f690b3 r90cfc16  
    33empty
    44
     5zero
    56A
    6 A A
    77A A A A A A A A A A
    88B B B B B
    … …  
    1010D D D D D
    1111E E E E E
    12 0 1 2 3 4 5 6 7 8 9
     12
    13130 1 2 3 4 5 6 7 8 9
    14141 3 5 7 9
    … …  
    18182 4 6 8 10
    191910 8 6 4 2
     20
     21
     22N N N N N N N N N N
     230 1 2 3 4 5 6 7 8 9
     2410 9 8 7 6 5 4 3 2 1
     25
     26
    20273 6 9
     28
     29
    2130(0 0)(1 1)(2 2)(3 3)(4 4)(5 5)(6 6)(7 7)(8 8)(9 9)
    2231(0 0)(1 1)(2 2)(3 3)(4 4)(5 5)(6 6)(7 7)(8 8)(9 9)
     32
    2333(0 0)(1 1)(2 2)(3 3)(4 4)(5 5)(6 6)(7 7)(8 8)(9 9)
    2434(0 0)(1 1)(2 2)(3 3)(4 4)(5 5)(6 6)(7 7)(8 8)(9 9)
     35(0 0)(1 1)(2 2)(3 3)(4 4)(5 5)(6 6)(7 7)(8 8)(9 9)(10 10)
     36(0 0)(1 1)(2 2)(3 3)(4 4)(5 5)(6 6)(7 7)(8 8)(9 9)(10 10)
     37
     38(10 10)(9 9)(8 8)(7 7)(6 6)(5 5)(4 4)(3 3)(2 2)(1 1)
     39(10 10)(9 9)(8 8)(7 7)(6 6)(5 5)(4 4)(3 3)(2 2)(1 1)
     40(10 10)(9 9)(8 8)(7 7)(6 6)(5 5)(4 4)(3 3)(2 2)(1 1)(0 0)
     41(10 10)(9 9)(8 8)(7 7)(6 6)(5 5)(4 4)(3 3)(2 2)(1 1)(0 0)

  • tests/.expect/nested-types-ERR1.txt

    r1f690b3 r90cfc16  
    1 nested-types.c:70:1 error: Use of undefined type T
     1nested-types.cfa:70:1 error: Use of undefined type T

  • tests/.expect/nested-types-ERR2.txt

    r1f690b3 r90cfc16  
    1 nested-types.c:73:1 error: Use of undefined global type Z
    2 nested-types.c:74:1 error: Qualified type requires an aggregate on the left, but has: signed int
    3 nested-types.c:75:1 error: Undefined type in qualified type: Qualified Type:
     1nested-types.cfa:73:1 error: Use of undefined global type Z
     2nested-types.cfa:74:1 error: Qualified type requires an aggregate on the left, but has: signed int
     3nested-types.cfa:75:1 error: Undefined type in qualified type: Qualified Type:
    44  instance of struct S with body 1
    55  instance of type Z (not function type)

  • tests/.expect/scopeErrors.txt

    r1f690b3 r90cfc16  
    1 scopeErrors.c:2:1 error: duplicate object definition for thisIsAnError: signed int
    2 scopeErrors.c:20:1 error: duplicate function definition for butThisIsAnError: function
     1scopeErrors.cfa:2:1 error: duplicate object definition for thisIsAnError: signed int
     2scopeErrors.cfa:20:1 error: duplicate function definition for butThisIsAnError: function
    33... with parameters
    44  double

  • tests/.expect/typedefRedef-ERR1.txt

    r1f690b3 r90cfc16  
    1 typedefRedef.c:4:1 error: Cannot redefine typedef: Foo
    2 typedefRedef.c:60:1 error: Cannot redefine typedef: ARR
     1typedefRedef.cfa:4:1 error: Cannot redefine typedef: Foo
     2typedefRedef.cfa:60:1 error: Cannot redefine typedef: ARR

  • tests/KRfunctions.cfa

    r1f690b3 r90cfc16  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // KRfunctions.c --
     7// KRfunctions.cfa --
    88//
    99// Author           : Peter A. Buhr
    1010// Created On       : Thu Feb 16 15:23:17 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Aug 20 07:34:17 2017
    13 // Update Count     : 7
     12// Last Modified On : Tue Nov  6 17:50:34 2018
     13// Update Count     : 9
    1414//
    1515
    … …  
    4949// Local Variables: //
    5050// tab-width: 4 //
    51 // compile-command: "cfa KRfunctions.c" //
     51// compile-command: "cfa KRfunctions.cfa" //
    5252// End: //

  • tests/Makefile.am

    r1f690b3 r90cfc16  
    1111## Created On       : Sun May 31 09:08:15 2015
    1212## Last Modified By : Peter A. Buhr
    13 ## Last Modified On : Wed Jun  6 16:42:20 2018
    14 ## Update Count     : 49
     13## Last Modified On : Tue Nov 20 11:18:51 2018
     14## Update Count     : 68
    1515###############################################################################
    1616
    1717AUTOMAKE_OPTIONS = foreign    # do not require all the GNU file names
     18
     19include $(top_srcdir)/src/cfa.make
    1820
    1921debug=yes
    … …  
    3638
    3739AM_CFLAGS += ${DEBUG_FLAGS} ${INSTALL_FLAGS} ${ARCH_FLAGS}
    38 
    3940CC = @CFACC@
    4041
    … …  
    4243
    4344.PHONY: list .validate
    44 .INTERMEDIATE: .validate .validate.c
    45 EXTRA_PROGRAMS = fstream_test avl_test # build but do not install
    46 
    47 fstream_test_SOURCES = fstream_test.c
     45.INTERMEDIATE: .validate .validate.cfa
     46EXTRA_PROGRAMS = avl_test # build but do not install
    4847
    4948avl_test_SOURCES = avltree/avl_test.c avltree/avl0.c avltree/avl1.c avltree/avl2.c avltree/avl3.c avltree/avl4.c avltree/avl-private.c
    … …  
    6261        @+${TEST_PY} --list ${concurrent}
    6362
    64 .validate: .validate.c
    65         $(COMPILE) .validate.c -fsyntax-only -Wall -Wextra -Werror
     63.validate: .validate.cfa
     64        $(CFACOMPILE) .validate.cfa -fsyntax-only -Wall -Wextra -Werror
    6665
    67 .validate.c:
     66.validate.cfa:
     67        @echo "int main() { return 0; }" > ${@}
     68
     69dummy_hack.c:
    6870        @echo "int main() { return 0; }" > ${@}
    6971
    … …  
    7274
    7375#----------------------------------------------------------------------------------------------------------------
     76
    7477# implicit rule so not all test require a rule
    75 % : %.c $(CC)
    76         $(PRETTY_PATH) $(COMPILE) $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     78% : %.c $(CFACC)
     79        $(PRETTY_PATH) $(CFACOMPILE) $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    7780
    78 declarationSpecifier: declarationSpecifier.c $(CC)
    79         $(PRETTY_PATH) $(COMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     81% : %.cfa $(CFACC)
     82        $(PRETTY_PATH) $(CFACOMPILE) $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    8083
    81 gccExtensions : gccExtensions.c $(CC)
    82         $(PRETTY_PATH) $(COMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     84declarationSpecifier: declarationSpecifier.cfa $(CFACC)
     85        $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    8386
    84 extension : extension.c $(CC)
    85         $(PRETTY_PATH) $(COMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     87gccExtensions : gccExtensions.cfa $(CFACC)
     88        $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    8689
    87 attributes : attributes.c $(CC)
    88         $(PRETTY_PATH) $(COMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     90extension : extension.cfa $(CFACC)
     91        $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    8992
    90 functions: functions.c $(CC)
    91         $(PRETTY_PATH) $(COMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     93attributes : attributes.cfa $(CFACC)
     94        $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    9295
    93 KRfunctions : KRfunctions.c $(CC)
    94         $(PRETTY_PATH) $(COMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     96functions: functions.cfa $(CFACC)
     97        $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    9598
    96 sched-ext-parse : sched-ext-parse.c $(CC)
    97         $(PRETTY_PATH) $(COMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     99KRfunctions : KRfunctions.cfa $(CFACC)
     100        $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    98101
    99 gmp : gmp.c $(CC)
    100         $(PRETTY_PATH) $(COMPILE) -lgmp $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     102sched-ext-parse : sched-ext-parse.c $(CFACC)
     103        $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     104
     105gmp : gmp.cfa $(CFACC)
     106        $(PRETTY_PATH) $(CFACOMPILE) -lgmp $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    101107
    102108#builtins
    103 builtins/sync: builtins/sync.c $(CC)
    104         $(PRETTY_PATH) $(COMPILE) $(shell realpath --relative-to=${srcdir} ${<}) 2> $(abspath ${@}) -fsyntax-only
     109builtins/sync: builtins/sync.c $(CFACC)
     110        $(PRETTY_PATH) $(CFACOMPILE) $(shell realpath --relative-to=${srcdir} ${<}) 2> $(abspath ${@}) -fsyntax-only
    105111
    106112#------------------------------------------------------------------------------
     113
    107114#To make errors path independent we need to cd into the correct directories
    108 completeTypeError : completeTypeError.c $(CC)
    109         $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     115completeTypeError : completeTypeError.cfa $(CFACC)
     116        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    110117
    111 typedefRedef-ERR1: typedefRedef.c $(CC)
    112         $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     118typedefRedef-ERR1: typedefRedef.cfa $(CFACC)
     119        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    113120
    114 alloc-ERROR: alloc.c $(CC)
    115         $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     121alloc-ERROR: alloc.cfa $(CFACC)
     122        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    116123
    117 fallthrough-ERROR: fallthrough.c $(CC)
    118         $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     124fallthrough-ERROR: fallthrough.cfa $(CFACC)
     125        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    119126
    120 nested-types-ERR1: nested-types.c $(CC)
    121         $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     127nested-types-ERR1: nested-types.cfa $(CFACC)
     128        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    122129
    123 nested-types-ERR2: nested-types.c $(CC)
    124         $(PRETTY_PATH) $(COMPILE) -DERR2 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     130nested-types-ERR2: nested-types.cfa $(CFACC)
     131        $(PRETTY_PATH) $(CFACOMPILE) -DERR2 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    125132
    126133# Constructor/destructor tests
    127 raii/dtor-early-exit-ERR1: raii/dtor-early-exit.c $(CC)
    128         $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     134raii/dtor-early-exit-ERR1: raii/dtor-early-exit.c $(CFACC)
     135        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    129136
    130 raii/dtor-early-exit-ERR2: raii/dtor-early-exit.c $(CC)
    131         $(PRETTY_PATH) $(COMPILE) -DERR2 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     137raii/dtor-early-exit-ERR2: raii/dtor-early-exit.c $(CFACC)
     138        $(PRETTY_PATH) $(CFACOMPILE) -DERR2 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    132139
    133 raii/memberCtors-ERR1: raii/memberCtors.c $(CC)
    134         $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     140raii/memberCtors-ERR1: raii/memberCtors.c $(CFACC)
     141        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    135142
    136 raii/ctor-autogen-ERR1: raii/ctor-autogen.c $(CC)
    137         $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     143raii/ctor-autogen-ERR1: raii/ctor-autogen.c $(CFACC)
     144        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    138145
    139146# Warnings
    140 warnings/self-assignment: warnings/self-assignment.c $(CC)
    141         $(PRETTY_PATH) $(COMPILE) $(shell realpath --relative-to=${srcdir} ${<}) 2> $(abspath ${@}) -fsyntax-only
     147warnings/self-assignment: warnings/self-assignment.c $(CFACC)
     148        $(PRETTY_PATH) $(CFACOMPILE) $(shell realpath --relative-to=${srcdir} ${<}) 2> $(abspath ${@}) -fsyntax-only

  • tests/Makefile.in

    r1f690b3 r90cfc16  
    9191build_triplet = @build@
    9292host_triplet = @host@
    93 EXTRA_PROGRAMS = fstream_test$(EXEEXT) avl_test$(EXEEXT)
     93EXTRA_PROGRAMS = avl_test$(EXEEXT)
    9494subdir = tests
    9595ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
    … …  
    110110avl_test_OBJECTS = $(am_avl_test_OBJECTS)
    111111avl_test_LDADD = $(LDADD)
    112 am_fstream_test_OBJECTS = fstream_test.$(OBJEXT)
    113 fstream_test_OBJECTS = $(am_fstream_test_OBJECTS)
    114 fstream_test_LDADD = $(LDADD)
    115112AM_V_P = $(am__v_P_@AM_V@)
    116113am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
    … …  
    141138am__v_CCLD_0 = @echo "  CCLD    " $@;
    142139am__v_CCLD_1 =
    143 SOURCES = $(avl_test_SOURCES) $(fstream_test_SOURCES)
    144 DIST_SOURCES = $(avl_test_SOURCES) $(fstream_test_SOURCES)
     140SOURCES = $(avl_test_SOURCES)
     141DIST_SOURCES = $(avl_test_SOURCES)
    145142am__can_run_installinfo = \
    146143  case $$AM_UPDATE_INFO_DIR in \
    … …  
    168165CTAGS = ctags
    169166am__DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/config.py.in \
    170         $(srcdir)/test.py $(top_srcdir)/automake/depcomp
     167        $(srcdir)/test.py $(top_srcdir)/automake/depcomp \
     168        $(top_srcdir)/src/cfa.make
    171169DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
    172170ACLOCAL = @ACLOCAL@
    … …  
    297295top_srcdir = @top_srcdir@
    298296AUTOMAKE_OPTIONS = foreign    # do not require all the GNU file names
     297CFACOMPILE = $(CFACC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CFAFLAGS) $(CFAFLAGS) $(AM_CFLAGS) $(CFLAGS)
     298AM_V_CFA = $(am__v_CFA_@AM_V@)
     299am__v_CFA_ = $(am__v_CFA_@AM_DEFAULT_V@)
     300am__v_CFA_0 = @echo "  CFA     " $@;
     301am__v_CFA_1 =
    299302debug = yes
    300303installed = no
    … …  
    309312        ${INSTALL_FLAGS} ${ARCH_FLAGS}
    310313PRETTY_PATH = cd ${srcdir} &&
    311 fstream_test_SOURCES = fstream_test.c
    312314avl_test_SOURCES = avltree/avl_test.c avltree/avl0.c avltree/avl1.c avltree/avl2.c avltree/avl3.c avltree/avl4.c avltree/avl-private.c
    313315all: all-am
    314316
    315317.SUFFIXES:
    316 .SUFFIXES: .c .o .obj .validate
    317 $(srcdir)/Makefile.in:  $(srcdir)/Makefile.am $(am__configure_deps)
     318.SUFFIXES: .c .cfa .o .obj .validate
     319$(srcdir)/Makefile.in:  $(srcdir)/Makefile.am $(top_srcdir)/src/cfa.make $(am__configure_deps)
    318320        @for dep in $?; do \
    319321          case '$(am__configure_deps)' in \
    … …  
    335337            cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
    336338        esac;
     339$(top_srcdir)/src/cfa.make $(am__empty):
    337340
    338341$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
    … …  
    371374        $(AM_V_CCLD)$(LINK) $(avl_test_OBJECTS) $(avl_test_LDADD) $(LIBS)
    372375
    373 fstream_test$(EXEEXT): $(fstream_test_OBJECTS) $(fstream_test_DEPENDENCIES) $(EXTRA_fstream_test_DEPENDENCIES)
    374         @rm -f fstream_test$(EXEEXT)
    375         $(AM_V_CCLD)$(LINK) $(fstream_test_OBJECTS) $(fstream_test_LDADD) $(LIBS)
    376 
    377376mostlyclean-compile:
    378377        -rm -f *.$(OBJEXT)
    … …  
    382381        -rm -f *.tab.c
    383382
    384 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstream_test.Po@am__quote@
    385383@AMDEP_TRUE@@am__include@ @am__quote@avltree/$(DEPDIR)/avl-private.Po@am__quote@
    386384@AMDEP_TRUE@@am__include@ @am__quote@avltree/$(DEPDIR)/avl0.Po@am__quote@
    … …  
    530528
    531529distclean: distclean-am
    532         -rm -rf ./$(DEPDIR) avltree/$(DEPDIR)
     530        -rm -rf avltree/$(DEPDIR)
    533531        -rm -f Makefile
    534532distclean-am: clean-am distclean-compile distclean-generic \
    … …  
    576574
    577575maintainer-clean: maintainer-clean-am
    578         -rm -rf ./$(DEPDIR) avltree/$(DEPDIR)
     576        -rm -rf avltree/$(DEPDIR)
    579577        -rm -f Makefile
    580578maintainer-clean-am: distclean-am maintainer-clean-generic
    … …  
    612610
    613611
     612.cfa.o:
     613        $(AM_V_CFA)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\
     614        $(CFACOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
     615        $(am__mv) $$depbase.Tpo $$depbase.Po
     616
    614617.PHONY: list .validate
    615 .INTERMEDIATE: .validate .validate.c
     618.INTERMEDIATE: .validate .validate.cfa
    616619
    617620#----------------------------------------------------------------------------------------------------------------
    … …  
    628631        @+${TEST_PY} --list ${concurrent}
    629632
    630 .validate: .validate.c
    631         $(COMPILE) .validate.c -fsyntax-only -Wall -Wextra -Werror
    632 
    633 .validate.c:
     633.validate: .validate.cfa
     634        $(CFACOMPILE) .validate.cfa -fsyntax-only -Wall -Wextra -Werror
     635
     636.validate.cfa:
     637        @echo "int main() { return 0; }" > ${@}
     638
     639dummy_hack.c:
    634640        @echo "int main() { return 0; }" > ${@}
    635641
    … …  
    638644
    639645#----------------------------------------------------------------------------------------------------------------
     646
    640647# implicit rule so not all test require a rule
    641 % : %.c $(CC)
    642         $(PRETTY_PATH) $(COMPILE) $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    643 
    644 declarationSpecifier: declarationSpecifier.c $(CC)
    645         $(PRETTY_PATH) $(COMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    646 
    647 gccExtensions : gccExtensions.c $(CC)
    648         $(PRETTY_PATH) $(COMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    649 
    650 extension : extension.c $(CC)
    651         $(PRETTY_PATH) $(COMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    652 
    653 attributes : attributes.c $(CC)
    654         $(PRETTY_PATH) $(COMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    655 
    656 functions: functions.c $(CC)
    657         $(PRETTY_PATH) $(COMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    658 
    659 KRfunctions : KRfunctions.c $(CC)
    660         $(PRETTY_PATH) $(COMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    661 
    662 sched-ext-parse : sched-ext-parse.c $(CC)
    663         $(PRETTY_PATH) $(COMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    664 
    665 gmp : gmp.c $(CC)
    666         $(PRETTY_PATH) $(COMPILE) -lgmp $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     648% : %.c $(CFACC)
     649        $(PRETTY_PATH) $(CFACOMPILE) $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     650
     651% : %.cfa $(CFACC)
     652        $(PRETTY_PATH) $(CFACOMPILE) $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     653
     654declarationSpecifier: declarationSpecifier.cfa $(CFACC)
     655        $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     656
     657gccExtensions : gccExtensions.cfa $(CFACC)
     658        $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     659
     660extension : extension.cfa $(CFACC)
     661        $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     662
     663attributes : attributes.cfa $(CFACC)
     664        $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     665
     666functions: functions.cfa $(CFACC)
     667        $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     668
     669KRfunctions : KRfunctions.cfa $(CFACC)
     670        $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     671
     672sched-ext-parse : sched-ext-parse.c $(CFACC)
     673        $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     674
     675gmp : gmp.cfa $(CFACC)
     676        $(PRETTY_PATH) $(CFACOMPILE) -lgmp $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    667677
    668678#builtins
    669 builtins/sync: builtins/sync.c $(CC)
    670         $(PRETTY_PATH) $(COMPILE) $(shell realpath --relative-to=${srcdir} ${<}) 2> $(abspath ${@}) -fsyntax-only
     679builtins/sync: builtins/sync.c $(CFACC)
     680        $(PRETTY_PATH) $(CFACOMPILE) $(shell realpath --relative-to=${srcdir} ${<}) 2> $(abspath ${@}) -fsyntax-only
    671681
    672682#------------------------------------------------------------------------------
     683
    673684#To make errors path independent we need to cd into the correct directories
    674 completeTypeError : completeTypeError.c $(CC)
    675         $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    676 
    677 typedefRedef-ERR1: typedefRedef.c $(CC)
    678         $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    679 
    680 alloc-ERROR: alloc.c $(CC)
    681         $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    682 
    683 fallthrough-ERROR: fallthrough.c $(CC)
    684         $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    685 
    686 nested-types-ERR1: nested-types.c $(CC)
    687         $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    688 
    689 nested-types-ERR2: nested-types.c $(CC)
    690         $(PRETTY_PATH) $(COMPILE) -DERR2 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     685completeTypeError : completeTypeError.cfa $(CFACC)
     686        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     687
     688typedefRedef-ERR1: typedefRedef.cfa $(CFACC)
     689        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     690
     691alloc-ERROR: alloc.cfa $(CFACC)
     692        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     693
     694fallthrough-ERROR: fallthrough.cfa $(CFACC)
     695        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     696
     697nested-types-ERR1: nested-types.cfa $(CFACC)
     698        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     699
     700nested-types-ERR2: nested-types.cfa $(CFACC)
     701        $(PRETTY_PATH) $(CFACOMPILE) -DERR2 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    691702
    692703# Constructor/destructor tests
    693 raii/dtor-early-exit-ERR1: raii/dtor-early-exit.c $(CC)
    694         $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    695 
    696 raii/dtor-early-exit-ERR2: raii/dtor-early-exit.c $(CC)
    697         $(PRETTY_PATH) $(COMPILE) -DERR2 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    698 
    699 raii/memberCtors-ERR1: raii/memberCtors.c $(CC)
    700         $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    701 
    702 raii/ctor-autogen-ERR1: raii/ctor-autogen.c $(CC)
    703         $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     704raii/dtor-early-exit-ERR1: raii/dtor-early-exit.c $(CFACC)
     705        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     706
     707raii/dtor-early-exit-ERR2: raii/dtor-early-exit.c $(CFACC)
     708        $(PRETTY_PATH) $(CFACOMPILE) -DERR2 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     709
     710raii/memberCtors-ERR1: raii/memberCtors.c $(CFACC)
     711        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     712
     713raii/ctor-autogen-ERR1: raii/ctor-autogen.c $(CFACC)
     714        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    704715
    705716# Warnings
    706 warnings/self-assignment: warnings/self-assignment.c $(CC)
    707         $(PRETTY_PATH) $(COMPILE) $(shell realpath --relative-to=${srcdir} ${<}) 2> $(abspath ${@}) -fsyntax-only
     717warnings/self-assignment: warnings/self-assignment.c $(CFACC)
     718        $(PRETTY_PATH) $(CFACOMPILE) $(shell realpath --relative-to=${srcdir} ${<}) 2> $(abspath ${@}) -fsyntax-only
    708719
    709720# Tell versions [3.59,3.63) of GNU make to not export all variables.

  • tests/abs.cfa

    r1f690b3 r90cfc16  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // abs.c --
     7// abs.cfa --
    88//
    99// Author           : Peter A. Buhr
    1010// Created On       : Thu Jan 28 18:26:16 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Feb 22 22:31:03 2017
    13 // Update Count     : 52
     12// Last Modified On : Tue Nov  6 17:50:44 2018
     13// Update Count     : 54
    1414//
    1515
    … …  
    3333// Local Variables: //
    3434// tab-width: 4 //
    35 // compile-command: "cfa abs.c" //
     35// compile-command: "cfa abs.cfa" //
    3636// End: //

  • tests/alloc.cfa

    r1f690b3 r90cfc16  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // alloc.c --
     7// alloc.cfa --
    88//
    99// Author           : Peter A. Buhr
    1010// Created On       : Wed Feb  3 07:56:22 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Aug  9 06:21:35 2018
    13 // Update Count     : 337
     12// Last Modified On : Tue Nov  6 17:50:52 2018
     13// Update Count     : 339
    1414//
    1515
    … …  
    272272// Local Variables: //
    273273// tab-width: 4 //
    274 // compile-command: "cfa alloc.c" //
     274// compile-command: "cfa alloc.cfa" //
    275275// End: //

  • tests/ato.cfa

    r1f690b3 r90cfc16  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // ato.c --
     7// ato.cfa --
    88//
    99// Author           : Peter A. Buhr
    1010// Created On       : Thu Feb  4 08:10:57 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Nov 16 18:31:56 2017
    13 // Update Count     : 89
     12// Last Modified On : Tue Nov  6 17:51:03 2018
     13// Update Count     : 91
    1414//
    1515
    … …  
    120120// Local Variables: //
    121121// tab-width: 4 //
    122 // compile-command: "cfa ato.c" //
     122// compile-command: "cfa ato.cfa" //
    123123// End: //

  • tests/attributes.cfa

    r1f690b3 r90cfc16  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // attributes.c --
     7// attributes.cfa --
    88//
    99// Author           : Peter A. Buhr
    1010// Created On       : Mon Feb  6 16:07:02 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Jul 19 13:50:51 2018
    13 // Update Count     : 15
     12// Last Modified On : Tue Nov  6 17:51:12 2018
     13// Update Count     : 17
    1414//
    1515
    … …  
    154154// Local Variables: //
    155155// tab-width: 4 //
    156 // compile-command: "cfa attributes.c" //
     156// compile-command: "cfa attributes.cfa" //
    157157// End: //

  • tests/complex.cfa

    r1f690b3 r90cfc16  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // complex.c --
     7// complex.cfa --
    88//
    99// Author           : Peter A. Buhr
    1010// Created On       : Wed May 24 22:07:31 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed May 24 22:08:01 2017
    13 // Update Count     : 1
     12// Last Modified On : Tue Nov  6 17:51:22 2018
     13// Update Count     : 3
    1414//
    1515
    … …  
    3838// Local Variables: //
    3939// tab-width: 4 //
    40 // compile-command: "cfa complex.c" //
     40// compile-command: "cfa complex.cfa" //
    4141// End: //

  • tests/concurrent/coroutineYield.c

    r1f690b3 r90cfc16  
    66
    77#define __kick_rate 150000ul
    8 #include "long_tests.h"
     8#include "long_tests.hfa"
    99
    1010#ifndef PREEMPTION_RATE

  • tests/concurrent/examples/matrixSum.c

    r1f690b3 r90cfc16  
    66// file "LICENCE" distributed with Cforall.
    77//
    8 // matrixSum.c --
     8// matrixSum.cfa --
    99//
    1010// Author           : Peter A. Buhr
    1111// Created On       : Mon Oct  9 08:29:28 2017
    1212// Last Modified By : Peter A. Buhr
    13 // Last Modified On : Thu Aug  9 09:17:30 2018
    14 // Update Count     : 13
     13// Last Modified On : Tue Nov  6 17:51:32 2018
     14// Update Count     : 14
    1515//
    1616
    … …  
    5959// Local Variables: //
    6060// tab-width: 4 //
    61 // compile-command: "cfa matrixSum.c" //
     61// compile-command: "cfa matrixSum.cfa" //
    6262// End: //

  • tests/concurrent/preempt.c

    r1f690b3 r90cfc16  
    33#include <time.hfa>
    44
    5 #include "long_tests.h"
     5#include "long_tests.hfa"
    66
    77#ifndef PREEMPTION_RATE

  • tests/concurrent/signal/block.c

    r1f690b3 r90cfc16  
    1414#include <time.hfa>
    1515
    16 #include "long_tests.h"
     16#include "long_tests.hfa"
    1717
    1818#ifndef PREEMPTION_RATE

  • tests/concurrent/signal/disjoint.c

    r1f690b3 r90cfc16  
    55#include <time.hfa>
    66
    7 #include "long_tests.h"
     7#include "long_tests.hfa"
    88
    99#ifndef PREEMPTION_RATE

  • tests/concurrent/signal/wait.c

    r1f690b3 r90cfc16  
    1313
    1414#define __kick_rate 12000ul
    15 #include "long_tests.h"
     15#include "long_tests.hfa"
    1616
    1717#ifndef PREEMPTION_RATE

  • tests/counter.cfa

    r1f690b3 r90cfc16  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // counter.c --
     7// counter.cfa --
    88//
    99// Author           : Aaron B. Moss
    1010// Created On       : Thu Feb 22 15:27:00 2018
    11 // Last Modified By : Aaron B. Moss
    12 // Last Modified On : Thu Feb 22 15:27:00 2018
    13 // Update Count     : 1
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Tue Nov  6 17:50:23 2018
     13// Update Count     : 2
    1414//
    1515
    … …  
    3737// Local Variables: //
    3838// tab-width: 4 //
    39 // compile-command: "cfa counter.c" //
     39// compile-command: "cfa counter.cfa" //
    4040// End: //

  • tests/declarationErrors.cfa

    r1f690b3 r90cfc16  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // declarationErrors.c --
     7// declarationErrors.cfa --
    88//
    99// Author           : Peter A. Buhr
    1010// Created On       : Wed Aug 17 08:23:43 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Sep  9 22:57:52 2016
    13 // Update Count     : 31
     12// Last Modified On : Tue Nov  6 17:52:47 2018
     13// Update Count     : 32
    1414//
    1515
    … …  
    4242// Local Variables: //
    4343// tab-width: 4 //
    44 // compile-command: "cfa declarationErrors.c" //
     44// compile-command: "cfa declarationErrors.cfa" //
    4545// End: //

  • tests/declarationSpecifier.cfa

    r1f690b3 r90cfc16  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // declarationSpecifier.c --
     7// declarationSpecifier.cfa --
    88//
    99// Author           : Peter A. Buhr
    1010// Created On       : Wed Aug 17 08:21:04 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Aug 17 08:24:33 2016
    13 // Update Count     : 2
     12// Last Modified On : Tue Nov  6 17:52:59 2018
     13// Update Count     : 3
    1414//
    1515
    … …  
    9696// Local Variables: //
    9797// tab-width: 4 //
    98 // compile-command: "cfa declarationSpecifier.c" //
     98// compile-command: "cfa declarationSpecifier.cfa" //
    9999// End: //

  • tests/div.cfa

    r1f690b3 r90cfc16  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // div.c --
     7// div.cfa --
    88//
    99// Author           : Peter A. Buhr
    1010// Created On       : Tue Aug  8 16:28:43 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Dec  7 09:06:52 2017
    13 // Update Count     : 18
     12// Last Modified On : Tue Nov  6 17:53:10 2018
     13// Update Count     : 19
    1414//
    1515
    … …  
    3232// Local Variables: //
    3333// tab-width: 4 //
    34 // compile-command: "cfa div.c" //
     34// compile-command: "cfa div.cfa" //
    3535// End: //

  • tests/except-0.cfa

    r1f690b3 r90cfc16  
    88#include <stdbool.h>
    99
    10 #include "except-mac.h"
     10#include "except-mac.hfa"
    1111TRIVIAL_EXCEPTION(yin)
    1212TRIVIAL_EXCEPTION(yang)

  • tests/except-1.cfa

    r1f690b3 r90cfc16  
    55#include <stdio.h>
    66
    7 #include "except-mac.h"
     7#include "except-mac.hfa"
    88TRIVIAL_EXCEPTION(yin)
    99TRIVIAL_EXCEPTION(yang)

  • tests/except-2.cfa

    r1f690b3 r90cfc16  
    33
    44#include <stdlib.hfa>
    5 #include "except-mac.h"
     5#include "except-mac.hfa"
    66
    77TRIVIAL_EXCEPTION(yin)

  • tests/except-3.cfa

    r1f690b3 r90cfc16  
    22
    33#include <stdio.h>
    4 #include "except-mac.h"
     4#include "except-mac.hfa"
    55TRIVIAL_EXCEPTION(myth)
    66

  • tests/extension.cfa

    r1f690b3 r90cfc16  
    22// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
    33//
    4 // extension.c --
     4// extension.cfa --
    55//
    66// Author           : Peter A. Buhr
    77// Created On       : Mon Jul  4 20:42:43 2016
    88// Last Modified By : Peter A. Buhr
    9 // Last Modified On : Mon Feb  6 15:44:39 2017
    10 // Update Count     : 46
     9// Last Modified On : Tue Nov  6 17:53:21 2018
     10// Update Count     : 47
    1111//
    1212
    … …  
    5656// Local Variables: //
    5757// tab-width: 4 //
    58 // compile-command: "cfa extension.c" //
     58// compile-command: "cfa extension.cfa" //
    5959// End: //

  • tests/fallthrough.cfa

    r1f690b3 r90cfc16  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // fallthrough.c --
     7// fallthrough.cfa --
    88//
    99// Author           : Rob Schluntz
    1010// Created On       : Wed Mar 14 10:06:25 2018
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Aug 16 08:21:46 2018
    13 // Update Count     : 14
     12// Last Modified On : Thu Nov  8 09:09:09 2018
     13// Update Count     : 16
    1414//
     15
     16#include <fstream.hfa>
    1517
    1618void test(int choice) {
    1719        choose ( choice ) {
    1820                case 1:
    19                         printf("case 1\n");
     21                        sout | "case 1" | endl;
    2022                        fallthru;
    2123                case 2:
    22                         printf("case 2\n");
     24                        sout | "case 2" | endl;
    2325                        fallthru;
    24                         printf("did not fallthru\n");
     26                        sout | "did not fallthru" | endl;
    2527                        if ( 7 ) fallthru common2;
    2628                        fallthru common1;
    2729                case 3:
    28                         printf("case 3\n");
     30                        sout | "case 3" | endl;
    2931                        fallthru default;
    3032                        fallthru common1;
    3133                common1:
    32                         printf("common1\n");
     34                        sout | "common1" | endl;
    3335                // break
    3436                case 4:
    35                         printf("case 4\n");
     37                        sout | "case 4" | endl;
    3638                        fallthru common2;
    3739                case 5:
    38                         printf("case 5\n");
     40                        sout | "case 5" | endl;
    3941                        fallthru common2;
    4042                        fallthru default;
    4143                case 6:
    42                         printf("case 6\n");
     44                        sout | "case 6" | endl;
    4345                        fallthru common2;
    4446                common2:
    45                         printf("common2\n");
     47                        sout | "common2" | endl;
    4648                // break
    4749                default:
    48                         printf("default\n");
     50                        sout | "default" | endl;
    4951                        fallthru;
    5052        }
    5153
    52         printf("\n");
     54        sout | endl;
    5355
    5456        switch ( choice ) {
    5557          case 1:
    56                 printf("case 1\n");
     58                sout | "case 1" | endl;
    5759                switch ( choice ) {
    5860                  case 1:
    59                         printf("case 1\n");
     61                        sout | "case 1" | endl;
    6062                        for ( int i = 0; i < 4; i += 1 ) {
    6163                                printf("%d\n", i);
    … …  
    6567                break;
    6668          case 5:
    67                 printf("case 5\n");
     69                sout | "case 5" | endl;
    6870                if ( choice == 5 ) {
    6971                        if ( choice != 5 ) {
    70                                 printf("error\n");
     72                                sout | "error" | endl;
    7173                        } else {
    72                                 printf("check\n");
     74                                sout | "check" | endl;
    7375                                fallthru common;
    7476                        } // if
    … …  
    114116
    115117int main() {
    116         test(1);
    117         printf("\n");
    118         test(5);
     118        test( 1 );
     119        sout | endl;
     120        test( 5 );
    119121}
    120122
    121123// Local Variables: //
    122124// tab-width: 4 //
    123 // compile-command: "cfa fallthrough.c" //
     125// compile-command: "cfa fallthrough.cfa" //
    124126// End: //

  • tests/forall.cfa

    r1f690b3 r90cfc16  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // forall.c --
     7// forall.cfa --
    88//
    99// Author           : Peter A. Buhr
    1010// Created On       : Wed May  9 08:48:15 2018
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Jul 12 16:19:08 2018
    13 // Update Count     : 30
     12// Last Modified On : Tue Nov  6 17:53:43 2018
     13// Update Count     : 31
    1414//
    1515
    … …  
    219219// Local Variables: //
    220220// tab-width: 4 //
    221 // compile-command: "cfa forall.c" //
     221// compile-command: "cfa forall.cfa" //
    222222// End: //

  • tests/fstream_test.cfa

    r1f690b3 r90cfc16  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // fstream_test.c --
     7// fstream_test.cfa --
    88//
    99// Author           : Peter A. Buhr
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Aug 24 11:30:26 2017
    13 // Update Count     : 65
     12// Last Modified On : Tue Nov  6 17:53:56 2018
     13// Update Count     : 66
    1414//
    1515
    … …  
    3232// Local Variables: //
    3333// tab-width: 4 //
    34 // compile-command: "cfa fstream_test.c" //
     34// compile-command: "cfa fstream_test.cfa" //
    3535// End: //

  • tests/functions.cfa

    r1f690b3 r90cfc16  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // functions.c --
     7// functions.cfa --
    88//
    99// Author           : Peter A. Buhr
    1010// Created On       : Wed Aug 17 08:39:58 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Jan 17 22:44:12 2018
    13 // Update Count     : 12
     12// Last Modified On : Tue Nov  6 17:54:09 2018
     13// Update Count     : 13
    1414//
    1515
    … …  
    188188// Local Variables: //
    189189// tab-width: 4 //
    190 // compile-command: "cfa functions.c" //
     190// compile-command: "cfa functions.cfa" //
    191191// End: //

  • tests/gccExtensions.cfa

    r1f690b3 r90cfc16  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // gccExtensions.c --
     7// gccExtensions.cfa --
    88//
    99// Author           : Peter A. Buhr
    1010// Created On       : Sun Aug 14 17:28:17 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Aug 17 09:26:50 2016
    13 // Update Count     : 10
     12// Last Modified On : Tue Nov  6 17:54:20 2018
     13// Update Count     : 11
    1414//
    1515
    … …  
    120120// Local Variables: //
    121121// tab-width: 4 //
    122 // compile-command: "cfa gccExtensions.c" //
     122// compile-command: "cfa gccExtensions.cfa" //
    123123// End: //

  • tests/gmp.cfa

    r1f690b3 r90cfc16  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // gmp.c --
     7// gmp.cfa --
    88//
    99// Author           : Peter A. Buhr
    1010// Created On       : Tue Apr 19 08:55:51 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Aug 18 12:43:13 2018
    13 // Update Count     : 556
     12// Last Modified On : Tue Nov  6 17:54:34 2018
     13// Update Count     : 557
    1414//
    1515
    … …  
    107107// Local Variables: //
    108108// tab-width: 4 //
    109 // compile-command: "cfa gmp.c -lgmp" //
     109// compile-command: "cfa gmp.cfa -lgmp" //
    110110// End: //

  • tests/heap.cfa

    r1f690b3 r90cfc16  
     1//
     2// Cforall Version 1.0.0 Copyright (C) 2017 University of Waterloo
     3//
     4// The contents of this file are covered under the licence agreement in the
     5// file "LICENCE" distributed with Cforall.
     6//
     7// heap.cfa --
     8//
     9// Author           : Peter A. Buhr
     10// Created On       : Tue Nov  6 17:54:56 2018
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Thu Nov  8 09:03:54 2018
     13// Update Count     : 17
     14//
     15
    116#include <thread.hfa>
    2 #include <kernel.hfa>                                                                           // processor
    3 #include <stdlib.hfa>                                                                           // *allocs
     17#include <kernel.hfa>                                                                   // processor
     18#include <stdlib.hfa>                                                                   // *allocs
    419#include <malloc.h>                                                                             // malloc_*
    520
    … …  
    2237void main( Worker & ) {
    2338    enum { NoOfAllocs = 5000, NoOfMmaps = 10 };
    24     char *locns[NoOfAllocs];
     39    char * locns[NoOfAllocs];
    2540    int i;
    2641
    2742    // check alloc/free
    2843
    29     for ( int j = 0; j < 40; j += 1 ) {
    30                 for ( i = 0; i < NoOfAllocs; i += 1 ) {
     44    for ( j; 40 ) {
     45                for ( i; NoOfAllocs ) {
    3146                        locns[i] = alloc( i );
    3247                        //sout | (void *)locns[i] | endl;
    33                         for ( int k = 0; k < i; k += 1 ) locns[i][k] = '\345';
     48                        for ( k; i ) locns[i][k] = '\345';
    3449                } // for
    3550                //sout | (char *)sbrk(0) - start | " bytes" | endl;
    3651
    37                 for ( i = 0; i < NoOfAllocs; i += 1 ) {
     52                for ( i; NoOfAllocs ) {
    3853                        //sout | (void *)locns[i] | endl;
    39                         for ( int k = 0; k < i; k += 1 ) if ( locns[i][k] != '\345' ) abort( "new/delete corrupt storage1" );
     54                        for ( k; i ) if ( locns[i][k] != '\345' ) abort( "new/delete corrupt storage1" );
    4055                        free( locns[i] );
    4156                } // for
    4257                //sout | (char *)sbrk(0) - start | " bytes" | endl;
    4358
    44                 for ( i = 0; i < NoOfAllocs; i += 1 ) {
     59                for ( i; NoOfAllocs ) {
    4560                        locns[i] = alloc( i );
    4661                        //sout | (void *)locns[i] | endl;
    47                         for ( int k = 0; k < i; k += 1 ) locns[i][k] = '\345';
    48                 } // for
    49                 for ( i = NoOfAllocs - 1; i >=0 ; i -= 1 ) {
     62                        for ( k; i ) locns[i][k] = '\345';
     63                } // for
     64                for ( i; NoOfAllocs - 1 -~= 0 ) {
    5065                        //sout | (void *)locns[i] | endl;
    51                         for ( int k = 0; k < i; k += 1 ) if ( locns[i][k] != '\345' ) abort( "new/delete corrupt storage2" );
     66                        for ( k; i ) if ( locns[i][k] != '\345' ) abort( "new/delete corrupt storage2" );
    5267                        free( locns[i] );
    5368                } // for
    … …  
    5671    // check malloc/free (sbrk)
    5772
    58     for ( i = 0; i < NoOfAllocs; i += 1 ) {
     73    for ( i; NoOfAllocs ) {
    5974                size_t s = (i + 1) * 20;
    60                 char *area = (char *)malloc( s );
     75                char * area = (char *)malloc( s );
    6176                if ( area == 0 ) abort( "malloc/free out of memory" );
    6277                area[0] = '\345'; area[s - 1] = '\345';                 // fill first/last
    … …  
    6580    } // for
    6681
    67     for ( i = 0; i < NoOfAllocs; i += 1 ) {
    68                 size_t s = i + 1;                               // +1 to make initialization simpler
     82    for ( i; NoOfAllocs ) {
     83                size_t s = i + 1;                                                               // +1 to make initialization simpler
    6984                locns[i] = (char *)malloc( s );
    7085                if ( locns[i] == 0 ) abort( "malloc/free out of memory" );
    … …  
    7287                locns[i][malloc_usable_size( locns[i] ) - 1] = '\345'; // fill ultimate byte
    7388    } // for
    74     for ( i = 0; i < NoOfAllocs; i += 1 ) {
     89    for ( i; NoOfAllocs ) {
    7590                size_t s = i + 1;
    7691                if ( locns[i][0] != '\345' || locns[i][s - 1] != '\345' ||
    … …  
    8196    // check malloc/free (mmap)
    8297
    83     for ( i = 0; i < NoOfMmaps; i += 1 ) {
    84                 size_t s = i + default_mmap_start();                            // cross over point
    85                 char *area = (char *)malloc( s );
     98    for ( i; NoOfMmaps ) {
     99                size_t s = i + default_mmap_start();                    // cross over point
     100                char * area = (char *)malloc( s );
    86101                if ( area == 0 ) abort( "malloc/free out of memory" );
    87102                area[0] = '\345'; area[s - 1] = '\345';                 // fill first/last
    … …  
    90105    } // for
    91106
    92     for ( i = 0; i < NoOfMmaps; i += 1 ) {
    93                 size_t s = i + default_mmap_start();                            // cross over point
     107    for ( i; NoOfMmaps ) {
     108                size_t s = i + default_mmap_start();                    // cross over point
    94109                locns[i] = (char *)malloc( s );
    95110                if ( locns[i] == 0 ) abort( "malloc/free out of memory" );
    … …  
    97112                locns[i][malloc_usable_size( locns[i] ) - 1] = '\345'; // fill ultimate byte
    98113    } // for
    99     for ( i = 0; i < NoOfMmaps; i += 1 ) {
    100                 size_t s = i + default_mmap_start();                            // cross over point
     114    for ( i; NoOfMmaps ) {
     115                size_t s = i + default_mmap_start();                    // cross over point
    101116                if ( locns[i][0] != '\345' || locns[i][s - 1] != '\345' ||
    102117                         locns[i][malloc_usable_size( locns[i] ) - 1] != '\345' ) abort( "malloc/free corrupt storage" );
    … …  
    106121    // check calloc/free (sbrk)
    107122
    108     for ( i = 0; i < NoOfAllocs; i += 1 ) {
     123    for ( i; NoOfAllocs ) {
    109124                size_t s = (i + 1) * 20;
    110                 char *area = (char *)calloc( 5, s );
     125                char * area = (char *)calloc( 5, s );
    111126                if ( area == 0 ) abort( "calloc/free out of memory" );
    112127                if ( area[0] != '\0' || area[s - 1] != '\0' ||
    … …  
    118133    } // for
    119134
    120     for ( i = 0; i < NoOfAllocs; i += 1 ) {
     135    for ( i; NoOfAllocs ) {
    121136                size_t s = i + 1;
    122137                locns[i] = (char *)calloc( 5, s );
    … …  
    128143                locns[i][malloc_usable_size( locns[i] ) - 1] = '\345'; // fill ultimate byte
    129144    } // for
    130     for ( i = 0; i < NoOfAllocs; i += 1 ) {
     145    for ( i; NoOfAllocs ) {
    131146                size_t s = i + 1;
    132147                if ( locns[i][0] != '\345' || locns[i][s - 1] != '\345' ||
    … …  
    137152    // check calloc/free (mmap)
    138153
    139     for ( i = 0; i < NoOfMmaps; i += 1 ) {
    140                 size_t s = i + default_mmap_start();                            // cross over point
    141                 char *area = (char *)calloc( 1, s );
     154    for ( i; NoOfMmaps ) {
     155                size_t s = i + default_mmap_start();                    // cross over point
     156                char * area = (char *)calloc( 1, s );
    142157                if ( area == 0 ) abort( "calloc/free out of memory" );
    143158                if ( area[0] != '\0' || area[s - 1] != '\0' ) abort( "calloc/free corrupt storage4.1" );
    … …  
    149164    } // for
    150165
    151     for ( i = 0; i < NoOfMmaps; i += 1 ) {
    152                 size_t s = i + default_mmap_start();                            // cross over point
     166    for ( i; NoOfMmaps ) {
     167                size_t s = i + default_mmap_start();                    // cross over point
    153168                locns[i] = (char *)calloc( 1, s );
    154169                if ( locns[i] == 0 ) abort( "calloc/free out of memory" );
    … …  
    159174                locns[i][malloc_usable_size( locns[i] ) - 1] = '\345'; // fill ultimate byte
    160175    } // for
    161     for ( i = 0; i < NoOfMmaps; i += 1 ) {
    162                 size_t s = i + default_mmap_start();                            // cross over point
     176    for ( i; NoOfMmaps ) {
     177                size_t s = i + default_mmap_start();                    // cross over point
    163178                if ( locns[i][0] != '\345' || locns[i][s - 1] != '\345' ||
    164179                         locns[i][malloc_usable_size( locns[i] ) - 1] != '\345' ) abort( "calloc/free corrupt storage6" );
    … …  
    170185    enum { limit = 64 * 1024 };                                                 // check alignments up to here
    171186
    172     for ( size_t a = libAlign(); a <= limit; a += a ) { // generate powers of 2
     187        for ( a; libAlign() ~= limit ~ a ) {                            // generate powers of 2
    173188                //sout | alignments[a] | endl;
    174                 for ( int s = 1; s < NoOfAllocs; s += 1 ) {             // allocation of size 0 can return null
    175                         char *area = (char *)memalign( a, s );
     189                for ( s; 1 ~ NoOfAllocs ) {                                             // allocation of size 0 can return null
     190                        char * area = (char *)memalign( a, s );
    176191                        if ( area == 0 ) abort( "memalign/free out of memory" );
    177192                        //sout | i | " " | area | endl;
    … …  
    187202    // check memalign/free (mmap)
    188203
    189     for ( size_t a = libAlign(); a <= limit; a += a ) { // generate powers of 2
     204        for ( a; libAlign() ~= limit ~ a ) {                            // generate powers of 2
    190205                //sout | alignments[a] | endl;
    191                 for ( i = 1; i < NoOfMmaps; i += 1 ) {
    192                         size_t s = i + default_mmap_start();                    // cross over point
    193                         char *area = (char *)memalign( a, s );
     206                for ( i; 1 ~ NoOfMmaps ) {
     207                        size_t s = i + default_mmap_start();            // cross over point
     208                        char * area = (char *)memalign( a, s );
    194209                        if ( area == 0 ) abort( "memalign/free out of memory" );
    195210                        //sout | i | " " | area | endl;
    … …  
    205220    // check calloc/realloc/free (sbrk)
    206221
    207     for ( i = 1; i < 10000; i += 12 ) {
     222    for ( i; 1 ~ 10_000 ~ 12 ) {
    208223                // initial N byte allocation
    209                 char *area = (char *)calloc( 5, i );
     224                char * area = (char *)calloc( 5, i );
    210225                if ( area == 0 ) abort( "calloc/realloc/free out of memory" );
    211226                if ( area[0] != '\0' || area[i - 1] != '\0' ||
    … …  
    214229
    215230                // Do not start this loop index at 0 because realloc of 0 bytes frees the storage.
    216                 for ( int s = i; s < 256 * 1024; s += 26 ) {    // start at initial memory request
     231                for ( s; i ~ 256 * 1024 ~ 26 ) {                                // start at initial memory request
    217232                        area = (char *)realloc( area, s );                      // attempt to reuse storage
    218233                        if ( area == 0 ) abort( "calloc/realloc/free out of memory" );
    … …  
    226241    // check calloc/realloc/free (mmap)
    227242
    228     for ( i = 1; i < 1000; i += 12 ) {
     243    for ( i; 1 ~ 10_000 ~ 12 ) {
    229244                // initial N byte allocation
    230                 size_t s = i + default_mmap_start();                            // cross over point
    231                 char *area = (char *)calloc( 1, s );
     245                size_t s = i + default_mmap_start();                    // cross over point
     246                char * area = (char *)calloc( 1, s );
    232247                if ( area == 0 ) abort( "calloc/realloc/free out of memory" );
    233248                if ( area[0] != '\0' || area[s - 1] != '\0' ||
    … …  
    236251
    237252                // Do not start this loop index at 0 because realloc of 0 bytes frees the storage.
    238                 for ( int r = i; r < 256 * 1024; r += 26 ) {    // start at initial memory request
    239                         area = (char *)realloc( area, r );              // attempt to reuse storage
     253                for ( r; i ~ 256 * 1024 ~ 26 ) {                                // start at initial memory request
     254                        area = (char *)realloc( area, r );                      // attempt to reuse storage
    240255                        if ( area == 0 ) abort( "calloc/realloc/free out of memory" );
    241256                        if ( area[0] != '\0' || area[r - 1] != '\0' ||
    … …  
    249264
    250265    size_t amount = 2;
    251     for ( size_t a = libAlign(); a <= limit; a += a ) { // generate powers of 2
     266        for ( a; libAlign() ~= limit ~ a ) {                            // generate powers of 2
    252267                // initial N byte allocation
    253                 char *area = (char *)memalign( a, amount );             // aligned N-byte allocation
     268                char * area = (char *)memalign( a, amount );    // aligned N-byte allocation
    254269                if ( area == 0 ) abort( "memalign/realloc/free out of memory" ); // no storage ?
    255270                //sout | alignments[a] | " " | area | endl;
    … …  
    260275
    261276                // Do not start this loop index at 0 because realloc of 0 bytes frees the storage.
    262                 for ( int s = amount; s < 256 * 1024; s += 1 ) { // start at initial memory request
     277                for ( s; amount ~ 256 * 1024 ) {                                // start at initial memory request
    263278                        if ( area[0] != '\345' || area[s - 2] != '\345' ) abort( "memalign/realloc/free corrupt storage" );
    264279                        area = (char *)realloc( area, s );                      // attempt to reuse storage
    … …  
    275290    // check cmemalign/free
    276291
    277     for ( size_t a = libAlign(); a <= limit; a += a ) { // generate powers of 2
     292        for ( a; libAlign() ~= limit ~ a ) {                            // generate powers of 2
    278293                //sout | alignments[a] | endl;
    279                 for ( int s = 1; s < limit; s += 1 ) {                  // allocation of size 0 can return null
    280                         char *area = (char *)cmemalign( a, 1, s );
     294                for ( s; 1 ~ limit ) {                                                  // allocation of size 0 can return null
     295                        char * area = (char *)cmemalign( a, 1, s );
    281296                        if ( area == 0 ) abort( "cmemalign/free out of memory" );
    282297                        //sout | i | " " | area | endl;
    … …  
    295310
    296311    amount = 2;
    297     for ( size_t a = libAlign() + libAlign(); a <= limit; a += a ) { // generate powers of 2
     312        for ( a; libAlign() ~= limit ~ a ) {                            // generate powers of 2
    298313                // initial N byte allocation
    299                 char *area = (char *)cmemalign( a, 1, amount ); // aligned N-byte allocation
     314                char * area = (char *)cmemalign( a, 1, amount ); // aligned N-byte allocation
    300315                if ( area == 0 ) abort( "cmemalign/realloc/free out of memory" ); // no storage ?
    301316                //sout | alignments[a] | " " | area | endl;
    … …  
    309324
    310325                // Do not start this loop index at 0 because realloc of 0 bytes frees the storage.
    311                 for ( int s = amount; s < 256 * 1024; s += 1 ) { // start at initial memory request
     326                for ( s; amount ~ 256 * 1024 ) {                                // start at initial memory request
    312327                        if ( area[0] != '\345' || area[s - 2] != '\345' ) abort( "cmemalign/realloc/free corrupt storage2" );
    313328                        area = (char *)realloc( area, s );                      // attempt to reuse storage
    … …  
    339354// Local Variables: //
    340355// tab-width: 4 //
    341 // compile-command: "cfa -nodebug -O2 heap.c" //
     356// compile-command: "cfa -nodebug -O2 heap.cfa" //
    342357// End: //

  • tests/hello.cfa

    r1f690b3 r90cfc16  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // hello.c --
     7// hello.cfa --
    88//
    99// Author           : Peter A. Buhr
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Jun  5 08:12:27 2017
    13 // Update Count     : 15
     12// Last Modified On : Tue Nov  6 17:56:22 2018
     13// Update Count     : 16
    1414//
    1515
    … …  
    3333// Local Variables: //
    3434// tab-width: 4 //
    35 // compile-command: "cfa hello.c" //
     35// compile-command: "cfa hello.cfa" //
    3636// End: //

  • tests/identFuncDeclarator.cfa

    r1f690b3 r90cfc16  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // identFuncDeclarator.c --
     7// identFuncDeclarator.cfa --
    88//
    99// Author           : Peter A. Buhr
    1010// Created On       : Wed Aug 17 08:36:34 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Jan 17 22:39:13 2018
    13 // Update Count     : 2
     12// Last Modified On : Tue Nov  6 17:56:33 2018
     13// Update Count     : 3
    1414//
    1515
    … …  
    115115// Local Variables: //
    116116// tab-width: 4 //
    117 // compile-command: "cfa identFuncDeclarator.c" //
     117// compile-command: "cfa identFuncDeclarator.cfa" //
    118118// End: //

  • tests/identParamDeclarator.cfa

    r1f690b3 r90cfc16  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // identParamDeclarator.c --
     7// identParamDeclarator.cfa --
    88//
    99// Author           : Peter A. Buhr
    1010// Created On       : Wed Aug 17 08:37:56 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Jan 17 22:36:11 2018
    13 // Update Count     : 2
     12// Last Modified On : Tue Nov  6 17:56:44 2018
     13// Update Count     : 3
    1414//
    1515
    … …  
    163163// Local Variables: //
    164164// tab-width: 4 //
    165 // compile-command: "cfa identParamDeclarator.c" //
     165// compile-command: "cfa identParamDeclarator.cfa" //
    166166// End: //

  • tests/identity.cfa

    r1f690b3 r90cfc16  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // identity.c --
     7// identity.cfa --
    88//
    99// Author           : Peter A. Buhr
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Jun  8 08:21:32 2017
    13 // Update Count     : 18
     12// Last Modified On : Tue Nov  6 17:56:54 2018
     13// Update Count     : 19
    1414//
    1515
    … …  
    3939// Local Variables: //
    4040// tab-width: 4 //
    41 // compile-command: "cfa identity.c" //
     41// compile-command: "cfa identity.cfa" //
    4242// End: //

  • tests/ifwhileCtl.cfa

    r1f690b3 r90cfc16  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // ifwhileCtl.c --
     7// ifwhileCtl.cfa --
    88//
    99// Author           : Peter A. Buhr
    1010// Created On       : Sat Aug 26 10:13:11 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Jun  6 17:15:09 2018
    13 // Update Count     : 21
     12// Last Modified On : Tue Nov  6 17:57:07 2018
     13// Update Count     : 22
    1414//
    1515
    … …  
    7272// Local Variables: //
    7373// tab-width: 4 //
    74 // compile-command: "cfa ifwhileCtl.c" //
     74// compile-command: "cfa ifwhileCtl.cfa" //
    7575// End: //

  • tests/io1.cfa

    r1f690b3 r90cfc16  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // io1.c --
     7// io1.cfa --
    88//
    99// Author           : Peter A. Buhr
    1010// Created On       : Wed Mar  2 16:56:02 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu May 24 21:17:56 2018
    13 // Update Count     : 104
     12// Last Modified On : Tue Nov  6 17:57:17 2018
     13// Update Count     : 105
    1414//
    1515
    … …  
    7070// Local Variables: //
    7171// tab-width: 4 //
    72 // compile-command: "cfa io1.c" //
     72// compile-command: "cfa io1.cfa" //
    7373// End: //

  • tests/io2.cfa

    r1f690b3 r90cfc16  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // io2.c --
     7// io2.cfa --
    88//
    99// Author           : Peter A. Buhr
    1010// Created On       : Wed Mar  2 16:56:02 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu May 24 21:17:41 2018
    13 // Update Count     : 103
     12// Last Modified On : Tue Nov  6 17:57:28 2018
     13// Update Count     : 104
    1414//
    1515
    … …  
    134134// Local Variables: //
    135135// tab-width: 4 //
    136 // compile-command: "cfa io2.c" //
     136// compile-command: "cfa io2.cfa" //
    137137// End: //

  • tests/labelledExit.cfa

    r1f690b3 r90cfc16  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // labelledExit.c --
     7// labelledExit.cfa --
    88//
    99// Author           : Peter A. Buhr
    1010// Created On       : Wed Aug 10 07:29:39 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Aug 16 08:55:39 2018
    13 // Update Count     : 3
     12// Last Modified On : Tue Nov  6 17:57:42 2018
     13// Update Count     : 4
    1414//
    1515
    … …  
    159159// Local Variables: //
    160160// tab-width: 4 //
    161 // compile-command: "cfa labelledExit.c" //
     161// compile-command: "cfa labelledExit.cfa" //
    162162// End: //

  • tests/limits.cfa

    r1f690b3 r90cfc16  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // limits.c --
     7// limits.cfa --
    88//
    99// Author           : Peter A. Buhr
    1010// Created On       : Tue May 10 20:44:20 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Mar  1 16:21:55 2018
    13 // Update Count     : 7
     12// Last Modified On : Tue Nov  6 17:57:55 2018
     13// Update Count     : 8
    1414//
    1515
    … …  
    153153// Local Variables: //
    154154// tab-width: 4 //
    155 // compile-command: "cfa limits.c" //
     155// compile-command: "cfa limits.cfa" //
    156156// End: //

  • tests/literals.cfa

    r1f690b3 r90cfc16  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // literals.c --
     7// literals.cfa --
    88//
    99// Author           : Peter A. Buhr
    1010// Created On       : Sat Sep  9 16:34:38 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Jul  1 15:12:15 2018
    13 // Update Count     : 137
     12// Last Modified On : Tue Nov  6 17:58:07 2018
     13// Update Count     : 138
    1414//
    1515
    … …  
    324324// Local Variables: //
    325325// tab-width: 4 //
    326 // compile-command: "cfa literals.c" //
     326// compile-command: "cfa literals.cfa" //
    327327// End: //

  • tests/math1.cfa

    r1f690b3 r90cfc16  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // math1.c --
     7// math1.cfa --
    88//
    99// Author           : Peter A. Buhr
    1010// Created On       : Fri Apr 22 14:59:21 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu May 24 21:01:15 2018
    13 // Update Count     : 85
     12// Last Modified On : Tue Nov  6 17:58:37 2018
     13// Update Count     : 86
    1414//
    1515
    … …  
    5252// Local Variables: //
    5353// tab-width: 4 //
    54 // compile-command: "cfa math1.c" //
     54// compile-command: "cfa math1.cfa" //
    5555// End: //

  • tests/math2.cfa

    r1f690b3 r90cfc16  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // math2.c --
     7// math2.cfa --
    88//
    99// Author           : Peter A. Buhr
    1010// Created On       : Fri Apr 22 14:59:21 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu May 24 21:06:10 2018
    13 // Update Count     : 82
     12// Last Modified On : Tue Nov  6 17:58:55 2018
     13// Update Count     : 83
    1414//
    1515
    … …  
    4949// Local Variables: //
    5050// tab-width: 4 //
    51 // compile-command: "cfa math2.c" //
     51// compile-command: "cfa math2.cfa" //
    5252// End: //

  • tests/math3.cfa

    r1f690b3 r90cfc16  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // math3.c --
     7// math3.cfa --
    88//
    99// Author           : Peter A. Buhr
    1010// Created On       : Fri Apr 22 14:59:21 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu May 24 21:06:12 2018
    13 // Update Count     : 82
     12// Last Modified On : Tue Nov  6 17:59:05 2018
     13// Update Count     : 83
    1414//
    1515
    … …  
    4848// Local Variables: //
    4949// tab-width: 4 //
    50 // compile-command: "cfa math3.c" //
     50// compile-command: "cfa math3.cfa" //
    5151// End: //

  • tests/math4.cfa

    r1f690b3 r90cfc16  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // math4.c --
     7// math4.cfa --
    88//
    99// Author           : Peter A. Buhr
    1010// Created On       : Thu May 24 20:56:54 2018
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu May 24 20:58:06 2018
    13 // Update Count     : 2
     12// Last Modified On : Tue Nov  6 17:59:14 2018
     13// Update Count     : 3
    1414//
    1515
    … …  
    6969// Local Variables: //
    7070// tab-width: 4 //
    71 // compile-command: "cfa math3.c" //
     71// compile-command: "cfa math3.cfa" //
    7272// End: //

  • tests/minmax.cfa

    r1f690b3 r90cfc16  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // minmax.c --
     7// minmax.cfa --
    88//
    99// Author           : Peter A. Buhr
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Apr 10 17:29:09 2018
    13 // Update Count     : 50
     12// Last Modified On : Tue Nov  6 17:59:26 2018
     13// Update Count     : 51
    1414//
    1515
    … …  
    4949// Local Variables: //
    5050// tab-width: 4 //
    51 // compile-command: "cfa minmax.c" //
     51// compile-command: "cfa minmax.cfa" //
    5252// End: //

  • tests/nested-types.cfa

    r1f690b3 r90cfc16  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // nested-types.c --
     7// nested-types.cfa --
    88//
    99// Author           : Rob Schluntz
    1010// Created On       : Mon Jul 9 10:20:03 2018
    11 // Last Modified By : Rob Schluntz
    12 // Last Modified On : Mon Jul 9 10:20:03 2017
    13 // Update Count     : 1
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Tue Nov  6 17:59:40 2018
     13// Update Count     : 2
    1414//
    1515
    … …  
    8888// Local Variables: //
    8989// tab-width: 4 //
    90 // compile-command: "cfa nested-types.c" //
     90// compile-command: "cfa nested-types.cfa" //
    9191// End: //

  • tests/numericConstants.cfa

    r1f690b3 r90cfc16  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // numericConstants.c --
     7// numericConstants.cfa --
    88//
    99// Author           : Peter A. Buhr
    1010// Created On       : Wed May 24 22:10:36 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed May 24 22:11:36 2017
    13 // Update Count     : 2
     12// Last Modified On : Tue Nov  6 17:59:53 2018
     13// Update Count     : 3
    1414//
    1515
    … …  
    6767// Local Variables: //
    6868// tab-width: 4 //
    69 // compile-command: "cfa minmax.c" //
     69// compile-command: "cfa minmax.cfa" //
    7070// End: //

  • tests/preempt_longrun/create.c

    r1f690b3 r90cfc16  
    33#include <time.hfa>
    44
    5 #include "long_tests.h"
     5#include "long_tests.hfa"
    66
    77#ifndef PREEMPTION_RATE

  • tests/preempt_longrun/enter3.c

    r1f690b3 r90cfc16  
    55
    66#define __kick_rate 75000ul
    7 #include "long_tests.h"
     7#include "long_tests.hfa"
    88
    99#ifndef PREEMPTION_RATE

  • tests/preempt_longrun/processor.c

    r1f690b3 r90cfc16  
    55#include <unistd.h>
    66
    7 #include "long_tests.h"
     7#include "long_tests.hfa"
    88
    99#ifndef PREEMPTION_RATE

  • tests/preempt_longrun/yield.c

    r1f690b3 r90cfc16  
    44
    55#define __kick_rate 550000ul
    6 #include "long_tests.h"
     6#include "long_tests.hfa"
    77
    88#ifndef PREEMPTION_RATE

  • tests/quotedKeyword.cfa

    r1f690b3 r90cfc16  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // quoted_keyword.c -- test quoted keyword usage
     7// quotedKeyword.cfa -- test quoted keyword usage
    88//
    99// Author           : Peter A. Buhr
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Jun 30 14:03:59 2016
    13 // Update Count     : 19
     12// Last Modified On : Tue Nov  6 17:46:20 2018
     13// Update Count     : 22
    1414//
    1515
    … …  
    4646// Local Variables: //
    4747// tab-width: 4 //
    48 // compile-command: "cfa quoted_keyword.c" //
     48// compile-command: "cfa quotedKeyword.cfa" //
    4949// End: //

  • tests/random.cfa

    r1f690b3 r90cfc16  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // random.c --
     7// random.cfa --
    88//
    99// Author           : Peter A. Buhr
    1010// Created On       : Tue Jul  5 21:29:30 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Jan  2 12:19:34 2018
    13 // Update Count     : 19
     12// Last Modified On : Tue Nov  6 18:00:15 2018
     13// Update Count     : 20
    1414//
    1515
    … …  
    7676// Local Variables: //
    7777// tab-width: 4 //
    78 // compile-command: "cfa random.c" //
     78// compile-command: "cfa random.cfa" //
    7979// End: //

  • tests/rational.cfa

    r1f690b3 r90cfc16  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // rational.c -- test rational number package
     7// rational.cfa -- test rational number package
    88//
    99// Author           : Peter A. Buhr
    1010// Created On       : Mon Mar 28 08:43:12 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Oct 10 23:25:04 2017
    13 // Update Count     : 67
     12// Last Modified On : Tue Nov  6 18:00:27 2018
     13// Update Count     : 68
    1414//
    1515
    … …  
    9898// Local Variables: //
    9999// tab-width: 4 //
    100 // compile-command: "cfa rational.c" //
     100// compile-command: "cfa rational.cfa" //
    101101// End: //

  • tests/searchsort.cfa

    r1f690b3 r90cfc16  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // searchsort.c --
     7// searchsort.cfa --
    88//
    99// Author           : Peter A. Buhr
    1010// Created On       : Thu Feb  4 18:17:50 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Aug  9 07:54:57 2018
    13 // Update Count     : 101
     12// Last Modified On : Tue Nov  6 18:00:38 2018
     13// Update Count     : 102
    1414//
    1515
    … …  
    148148// Local Variables: //
    149149// tab-width: 4 //
    150 // compile-command: "cfa searchsort.c" //
     150// compile-command: "cfa searchsort.cfa" //
    151151// End: //

  • tests/stdincludes.cfa

    r1f690b3 r90cfc16  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // stdincludes.c --
     7// stdincludes.cfa --
    88//
    99// Author           : Peter A. Buhr
    1010// Created On       : Tue Aug 29 08:26:14 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Aug 30 07:56:39 2017
    13 // Update Count     : 5
     12// Last Modified On : Tue Nov  6 18:00:53 2018
     13// Update Count     : 6
    1414//
    1515
    … …  
    5151// Local Variables: //
    5252// tab-width: 4 //
    53 // compile-command: "cfa stdincludes.c" //
     53// compile-command: "cfa stdincludes.cfa" //
    5454// End: //

  • tests/sum.cfa

    r1f690b3 r90cfc16  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // sum.c -- test resolvers ability to deal with many variables with the same name and to use the minimum number of casts
    8 //    necessary to disambiguate overloaded variable names.
     7// sum.cfa -- test resolvers ability to deal with many variables with the same name and to use the minimum number of
     8//    casts necessary to disambiguate overloaded variable names.
    99//
    1010// Author           : Peter A. Buhr
    1111// Created On       : Wed May 27 17:56:53 2015
    1212// Last Modified By : Peter A. Buhr
    13 // Last Modified On : Thu Aug  2 08:03:09 2018
    14 // Update Count     : 279
     13// Last Modified On : Tue Nov  6 18:01:10 2018
     14// Update Count     : 280
    1515//
    1616
    … …  
    120120// Local Variables: //
    121121// tab-width: 4 //
    122 // compile-command: "cfa sum.c" //
     122// compile-command: "cfa sum.cfa" //
    123123// End: //

  • tests/swap.cfa

    r1f690b3 r90cfc16  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // swap.c --
     7// swap.cfa --
    88//
    99// Author           : Peter A. Buhr
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Dec  7 09:13:13 2017
    13 // Update Count     : 71
     12// Last Modified On : Tue Nov  6 18:01:23 2018
     13// Update Count     : 72
    1414//
    1515
    … …  
    9292// Local Variables: //
    9393// tab-width: 4 //
    94 // compile-command: "cfa swap.c" //
     94// compile-command: "cfa swap.cfa" //
    9595// End: //

  • tests/switch.cfa

    r1f690b3 r90cfc16  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // switch.c --
     7// switch.cfa --
    88//
    99// Author           : Peter A. Buhr
    1010// Created On       : Tue Jul 12 06:50:22 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Mar  8 07:33:05 2018
    13 // Update Count     : 36
     12// Last Modified On : Tue Nov  6 18:01:34 2018
     13// Update Count     : 37
    1414//
    1515
    … …  
    104104// Local Variables: //
    105105// tab-width: 4 //
    106 // compile-command: "cfa switch.c" //
     106// compile-command: "cfa switch.cfa" //
    107107// End: //

  • tests/time.cfa

    r1f690b3 r90cfc16  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // time.c --
     7// time.cfa --
    88//
    99// Author           : Peter A. Buhr
    1010// Created On       : Tue Mar 27 17:24:56 2018
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Apr  6 11:27:23 2018
    13 // Update Count     : 16
     12// Last Modified On : Tue Nov  6 18:01:45 2018
     13// Update Count     : 17
    1414//
    1515
    … …  
    6868// mode: c //
    6969// tab-width: 4 //
    70 // compile-command: "cfa time.c" //
     70// compile-command: "cfa time.cfa" //
    7171// End: //

  • tests/userLiterals.cfa

    r1f690b3 r90cfc16  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // user_literals.c --
     7// user_literals.cfa --
    88//
    99// Author           : Peter A. Buhr
    1010// Created On       : Wed Sep  6 21:40:50 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Apr 29 16:51:42 2018
    13 // Update Count     : 54
     12// Last Modified On : Tue Nov  6 18:02:03 2018
     13// Update Count     : 55
    1414//
    1515
    … …  
    9090// Local Variables: //
    9191// tab-width: 4 //
    92 // compile-command: "cfa user_literals.c" //
     92// compile-command: "cfa user_literals.cfa" //
    9393// End: //

  • tests/variableDeclarator.cfa

    r1f690b3 r90cfc16  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // variableDeclarator.c --
     7// variableDeclarator.cfa --
    88//
    99// Author           : Peter A. Buhr
    1010// Created On       : Wed Aug 17 08:41:42 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Aug 17 08:42:21 2016
    13 // Update Count     : 1
     12// Last Modified On : Tue Nov  6 18:02:16 2018
     13// Update Count     : 2
    1414//
    1515
    … …  
    182182// Local Variables: //
    183183// tab-width: 4 //
    184 // compile-command: "cfa variableDeclarator.c" //
     184// compile-command: "cfa variableDeclarator.cfa" //
    185185// End: //

  • tests/vector.cfa

    r1f690b3 r90cfc16  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // vector.c --
     7// vector.cfa --
    88//
    99// Author           : Thierry Delisle
    1010// Created On       : Mon Jul  4 23:36:19 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Jan 18 17:08:08 2018
    13 // Update Count     : 27
     12// Last Modified On : Tue Nov  6 18:02:26 2018
     13// Update Count     : 28
    1414//
    1515
    … …  
    6363// Local Variables: //
    6464// tab-width: 4 //
    65 // compile-command: "cfa vector.c" //
     65// compile-command: "cfa vector.cfa" //
    6666// End: //
Note: See TracChangeset for help on using the changeset viewer.