Changes in / [90cfc16:1f690b3]


Ignore:
Files:
90 added
88 deleted
38 edited

Legend:

Unmodified
Added
Removed

  • benchmark/Makefile.am

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

  • doc/bibliography/pl.bib

    r90cfc16 r1f690b3  
    2121%  toplas: ACM Trans. on Prog. Lang. & Sys.
    2222%  tcs: Theoretical Computer Science
    23 
    24 string{ieeepds="IEEE Transactions on Parallel and Distributed Systems"}
    25 @string{ieeepds="IEEE Trans. Parallel Distrib. Syst."}
    26 string{ieeese="IEEE Transactions on Software Engineering"}
    27 @string{ieeese="IEEE Trans. Softw. Eng."}
    28 string{spe="Software---\-Practice and Experience"}
    29 @string{spe="Softw. Pract. Exper."}
    30 string{ccpe="Concurrency and Computation: Practice and Experience"}
    31 @string{ccpe="Concurrency Comput.: Pract. Exper."}
    32 string{sigplan="SIGPLAN Notices"}
    33 @string{sigplan="SIGPLAN Not."}
    34 string{joop="Journal of Object-Oriented Programming"}
    35 @string{joop="J. of Object-Oriented Program."}
     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."}
    3635@string{popl="Conference Record of the ACM Symposium on Principles of Programming Languages"}
    3736@string{osr="Operating Systems Review"}
    3837@string{pldi="Programming Language Design and Implementation"}
    3938@string{toplas="Transactions on Programming Languages and Systems"}
    40 string{mathann="Mathematische Annalen"}
    41 @string{mathann="Math. Ann."}
     39@string{mathann="Mathematische Annalen"}
     40% @string{mathann="Math. Ann."}
    4241
    4342% A
    … …  
    567566}
    568567
    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 
    580568@article{Kessels82,
    581569    keywords    = {concurrency, critical section},
    … …  
    665653    author      = {Joung, Yuh-Jzer},
    666654    title       = {Asynchronous group mutual exclusion},
    667     journal     = {Dist. Comput.},
    668     optjournal  = {Distributed Computing},
     655    journal     = {Distributed Computing},
    669656    year        = {2000},
    670657    month       = {Nov},
    … …  
    809796        time computable inheritance hierarchy.
    810797    },
    811     comment     = {
     798    comment = {
    812799        Classes are predicates; if object {\tt o} is in class {\tt C}, then
    813800        {\tt C} is true of {\tt o}.  Classes are combined with {\tt :AND},
    … …  
    963950
    964951@article{Moss18,
    965     keywords    = {type systems, polymorphism, tuples, Cforall},
     952    keywords    = {type systems, tuples, Cforall},
    966953    contributer = {pabuhr@plg},
    967954    author      = {Aaron Moss and Robert Schluntz and Peter A. Buhr},
    968955    title       = {\textsf{C}$\mathbf{\forall}$ : Adding Modern Programming Language Features to C},
     956    year        = 2018,
     957    month       = aug,
    969958    journal     = spe,
    970     volume      = 48,
    971     number      = 12,
    972     month       = dec,
    973     year        = 2018,
    974     pages       = {2111-2146},
    975959    note        = {\href{http://dx.doi.org/10.1002/spe.2624}{http://\-dx.doi.org/\-10.1002/\-spe.2624}},
    976960}
    … …  
    1005989    journal     = {Dr. Dobb's Journal of Software Tools},
    1006990    year        = 1989,
    1007     month       = feb,
    1008     volume      = 14,
    1009     number      = 2,
    1010     pages       = {45-51},
     991    month       = feb, volume = 14, number = 2, pages = {45-51},
    1011992    comment     = {
    1012993       A light-weight multitasking kernel for MS-DOS.  A task\_control
    … …  
    15261507}
    15271508
    1528 @manual{uC++,
     1509@techreport{uC++,
    15291510    keywords    = {C++, concurrency, light-weight process, shared memory},
    15301511    contributer = {pabuhr@plg},
    1531     key         = {uC++},
    15321512    author      = {Peter A. Buhr},
    15331513    title       = {$\mu${C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Annotated Reference Manual, Version 7.0.0},
    1534     organization= {University of Waterloo},
    1535     month       = sep,
    1536     year        = 2018,
     1514    institution = {School of Computer Science, University of Waterloo},
     1515    address     = {Waterloo, Ontario, Canada, N2L 3G1},
     1516    month       = dec,
     1517    year        = 2017,
    15371518    note        = {\href{https://plg.uwaterloo.ca/~usystem/pub/uSystem/uC++.pdf}{https://\-plg.uwaterloo.ca/\-$\sim$usystem/\-pub/\-uSystem/uC++.pdf}},
    15381519}
    … …  
    16051586    author      = {Sun, Xianda},
    16061587    title       = {Concurrent High-performance Persistent Hash Table In {J}ava},
    1607     school      = {School of Computer Sc., University of Waterloo},
     1588    school      = {School of Computer Science, University of Waterloo},
    16081589    year        = 2015,
    16091590    optaddress  = {Waterloo, Ontario, Canada, N2L 3G1},
    … …  
    19551936    note        = {Svensk Standard SS 63 61 14},
    19561937    year        = 1987,
    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},
     1938    abstract    = {
     1939        Standard for the programming language SIMULA.  Written in English.
     1940    }
    19711941}
    19721942
    … …  
    21082078    year        = {1998},
    21092079    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}
    21202080}
    21212081
    … …  
    29202880}
    29212881
    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 
    29362882% F
    29372883
    … …  
    32773223    keywords    = {Go programming language},
    32783224    contributer = {pabuhr@plg},
     3225    title       = {{Go} Programming Language},
    32793226    author      = {Robert Griesemer and Rob Pike and Ken Thompson},
    3280     title       = {{Go} Programming Language},
    32813227    organization= {Google},
    32823228    year        = 2009,
    … …  
    34703416    month       = sep,
    34713417    publisher   = {John Wiley \& Sons},
    3472     note        = {\href{https://doi.org/10.1002/cpe.4475}{https://\-doi.org/\-10.1002/\-cpe.4475}},
     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}},
    34733419}
    34743420
    … …  
    36083554    publisher   = {ACM Press},
    36093555    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}
    36233556}
    36243557
    … …  
    39653898    author      = {Peter A. Buhr and Martin Karsten and Jun Shih},
    39663899    title       = {{\small\textsf{KDB}}: A Multi-threaded Debugger for Multi-threaded Applications},
    3967     booktitle   = {Proc. of SPDT'96: SIGMETRICS Symp. on Parallel and Distributed Tools},
     3900    booktitle   = {Proceedings of SPDT'96: SIGMETRICS Symposium on Parallel and Distributed Tools},
    39683901    publisher   = {ACM Press},
    39693902    address     = {Philadelphia, Pennsylvania, U.S.A.},
    … …  
    54565389}
    54575390
    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 
    54695391@article{poly,
    54705392    keywords    = {Poly, Standard ML, Russell, persistence},
    … …  
    56815603    author      = {Peter A. Buhr and Robert Denda},
    56825604    title       = {{$\mu$Profiler} : Profiling User-Level Threads in a Shared-Memory Programming Environment},
    5683     booktitle   = {Proc. of 2nd Inter. Symp. on Computing in Object-Oriented Parallel Environments},
     5605    booktitle   = {Proceedings of the Second International Symposium on Computing in Object-Oriented Parallel Environments (ISCOPE'98)},
    56845606    series      = {Lecture Notes in Computer Science},
    56855607    publisher   = {Springer-Verlag},
    … …  
    60525974    issn        = {0164-0925},
    60535975    pages       = {429-475},
    6054     url         = {http://doi.acm.org/10.1145/1133651.1133653},
     5976    url         = {http://doi.acm.org.proxy.lib.uwaterloo.ca/10.1145/1133651.1133653},
    60555977    doi         = {10.1145/1133651.1133653},
    60565978    acmid       = {1133653},
    … …  
    63196241    contributer = {pabuhr@plg},
    63206242    key         = {Rust},
    6321     title       = {{R}ust Programming Language},
    6322     optaddress  = {Rust Project Developers},
     6243    title       = {The {R}ust Programming Language},
     6244    address     = {The Rust Project Developers},
    63236245    year        = 2015,
    63246246    note        = {\href{https://doc.rust-lang.org/reference.html}{https://\-doc.rust-lang\-.org/\-reference.html}},
    … …  
    63866308    publisher   = {Springer},
    63876309    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},
    64306310}
    64316311
    … …  
    75967476}
    75977477
    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 
    76197478% X
    76207479

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

    r90cfc16 r1f690b3  
    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}
    2825
    2926\usepackage{footmisc} % for double refs to the same footnote

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

    r90cfc16 r1f690b3  
    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\cite{Galler64} data structure introduced in this thesis.
     7In 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.
    88
    9 \section{Definitions} \label{env-defn-sec}
     9\section{Definitions}
    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 \\
    2627        $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.
     42The final basic mutation operation is $remove(T, T_i)$, which removes a class $T_i$ and all its type variables from an environment $T$.
    4243
    4344The $unify$ operation is the fundamental non-trivial operation a type environment data structure must support.
    4445$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.
    4546It 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.
    46 $unify$ depends on an internal $unifyBound$ operation which may fail.
    47 In \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.
    48 If 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.
    49 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 $unifyBound$ on !int! and the bound type of the class containing !R!.
     47$unify$ depends on an internal $unify_bound$ operation which may fail.
     48In \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.
     49If 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.
     50For 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!.
    5051As 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.
    51 For more information on \CFA{} unification, see \cite{Bilson03}.
    52 The 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$.
    53 If there has been no call to $unify$ on $T_i$ (\ie{} $T_i$ is a single-element class) $T_i$ is absent in $T'$.
    5452
    5553Given the nature of the expression resolution problem as backtracking search, caching and concurrency are both useful tools to decrease runtime.
    … …  
    5957The 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.
    6058$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'$.
    61 Like $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.
     59Like 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.
    6260
    6361Finally, the backtracking access patterns of the compiler can be exploited to reduce memory usage or runtime through use of an appropriately designed data structure.
    6462The 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$.
    6563As 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.
    66 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.
    67 
    68 \section{Approaches}
    69 
    70 \subsection{Na\"{\i}ve}
    71 
    72 The 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.
    73 This 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.
    74 Some 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.
    75 These improvements do not change the fundamental issues with this data structure, however.
    76 
    77 \subsection{Incremental Inheritance}
    78 
    79 One 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.
    80 This 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.
    81 Since 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 
    83 For 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.
    84 Any 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.
    85 However, 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 
    87 This 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.
    88 The 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.
    89 These 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 
    93 Given 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}.
    94 Union-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.
    95 The 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.
    98 If 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 
    100 The 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.
    101 In 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.
    102 This issue can be solved by including a side map from class representatives to the type class bound.
    103 If 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 
    107 Another 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.
    108 Since 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.
    109 The 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.
    110 Unfortunately, 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 
    114 The 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.
    115 Aho, Hopcroft, and Ullman also include a circularly-linked list in their 1974 textbook~\cite{Aho74}.
    116 However, 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.
    117 In my version, the list data structure does not affect the layout of the union-find tree, maintaining the same asymptotic bounds as union-find.
    118 In 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.
    119 When two classes are unified, the !next! pointers of the representatives of those classes are swapped, splicing the two circularly-linked lists together.
    120 Importantly, 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.
    121 The 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 
    123 If 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.
    124 Theorem~\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.
    125 This 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.}.
    126 Once 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}
    129 The !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 
    138 On 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 
    142 Given 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.
    143 Conchon 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 
    147 In 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.
    148 In this manner, a tree of edits is formed, rooted at the actual array.
    149 Read from the actual array at the root can be performed in constant time, as with a non-persistent array.
    150 The 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. 
    151 The mutation algorithm at the root is in some sense a special case of the key operation on persistent arrays, $reroot$.
    152 
    153 A rerooting operation takes any array reference and makes it the root node of the array.
    154 This 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.
    155 In 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.
    156 While $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.
    157 Also, 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.
    158 Since 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 
    160 While 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.
    161 In particular, an arbitrary number of type variables must be added to the environment.
    162 As 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.
    163 Besides 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.
    164 In 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.
    165 The 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.
    166 Making !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.
    167 The 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 
    169 Maintaining 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.
    170 If 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.
    171 This 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 
    173 The procedure for $combine(T, T')$ based on edit paths is as follows:
    174 The 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.
    175 By 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.
    176 This procedure is repeated for both the class edit tree and the binding edit tree.
    177 When the list of net changes to the environment has been produced, the additive changes are applied to $T$.
    178 For 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.
    179 The 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''$.
    180 Where $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 
    184 In 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}
     64These 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.
    20865
    20966% Future work: design multi-threaded version of C&F persistent map --- core idea is some sort of thread-boundary edit node

  • doc/user/Makefile

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

  • doc/user/user.tex

    r90cfc16 r1f690b3  
    1111%% Created On       : Wed Apr  6 14:53:29 2016
    1212%% Last Modified By : Peter A. Buhr
    13 %% Last Modified On : Wed Nov  7 17:00:49 2018
    14 %% Update Count     : 3399
     13%% Last Modified On : Fri Aug 31 07:54:50 2018
     14%% Update Count     : 3396
    1515%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    1616
    … …  
    547547
    548548
    549 \subsection{Loop Control}
     549%\subsection{\texorpdfstring{\protect\lstinline@for@ Statement}{for Statement}}
     550\subsection{\texorpdfstring{\LstKeywordStyle{for} Statement}{for Statement}}
    550551
    551552The ©for©/©while©/©do-while© loop-control allows empty or simplified ranges.
    … …  
    556557the down-to range ©-~=©\index{-~=@©-~=©} means inclusive range [N,M].
    557558©0© is the implicit start value;
    558 ©1© is the implicit increment value.
    559 The up-to range uses ©+=© for increment;
    560 the down-to range uses ©-=© for decrement.
     559©1© is the implicit increment value for an up-to range and ©-1© for an implicit down-to range.
    561560The loop index is polymorphic in the type of the start value or comparison value when start is implicitly ©0©.
    562561\begin{cquote}
    563562\begin{tabular}{@{}ll|l@{}}
    564 \multicolumn{2}{c|}{loop control} & \multicolumn{1}{c}{output} \\
     563\multicolumn{2}{c|}{for control} & \multicolumn{1}{c}{output} \\
    565564\hline
    566565\begin{cfa}
    … …  
    572571for ( ®10® ) { sout | "A"; }
    573572for ( ®1 ~= 10 ~ 2® ) { sout | "B"; }
    574 for ( ®10 -~= 1 ~ 2® ) { sout | "C"; }
     573for ( ®10 -~= 1 ~ -2® ) { sout | "C"; }
    575574for ( ®0.5 ~ 5.5® ) { sout | "D"; }
    576575for ( ®5.5 -~ 0.5® ) { sout | "E"; }
    577576for ( ®i; 10® ) { sout | i; }
    578577for ( ®i; 1 ~= 10 ~ 2® ) { sout | i; }
    579 for ( ®i; 10 -~= 1 ~ 2® ) { sout | i; }
     578for ( ®i; 10 -~= 1 ~ -2® ) { sout | i; }
    580579for ( ®i; 0.5 ~ 5.5® ) { sout | i; }
    581580for ( ®i; 5.5 -~ 0.5® ) { sout | i; }
    582581for ( ®ui; 2u ~= 10u ~ 2u® ) { sout | ui; }
    583 for ( ®ui; 10u -~= 2u ~ 2u® ) { sout | ui; }
    584 enum { N = 10 };
    585 for ( ®N® ) { sout | "N"; }
    586 for ( ®i; N® ) { sout | i; }
    587 for ( ®i; N -~ 0® ) { sout | i; }
    588 const int start = 3, comp = 10, inc = 2;
     582for ( ®ui; 10u -~= 2u ~ -2u® ) { sout | ui; }
     583int start = 3, comp = 10, inc = 2;
    589584for ( ®i; start ~ comp ~ inc + 1® ) { sout | i; }
    590585\end{cfa}
    591586&
    592587\begin{cfa}
    593 sout | endl;
    594 sout | endl;
    595 sout | endl;
    596 sout | "zero" | endl;
    597588sout | endl;
    598589sout | endl;
    … …  
    607598sout | endl;
    608599sout | endl;
    609 sout | endl | endl;
    610 
    611600sout | endl;
    612601sout | endl;
    613 sout | endl | endl;
     602sout | endl;
     603sout | endl;
     604sout | endl;
    614605
    615606sout | endl;
    … …  
    620611empty
    621612empty
    622 zero
     613
    623614A
    624615A A A A A A A A A A
    … …  
    6346252 4 6 8 10
    63562610 8 6 4 2
    636 
    637 N N N N N N N N N N
    638 0 1 2 3 4 5 6 7 8 9
    639 10 9 8 7 6 5 4 3 2 1
    640627
    6416283 6 9

  • libcfa/src/iostream.cfa

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

  • libcfa/src/iterator.cfa

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

  • src/Parser/DeclarationNode.cc

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

  • src/Parser/ParseNode.h

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

  • src/Parser/TypeData.cc

    r90cfc16 r1f690b3  
    1010// Created On       : Sat May 16 15:12:51 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Nov  2 07:54:26 2018
    13 // Update Count     : 624
     12// Last Modified On : Fri Jul 20 14:39:31 2018
     13// Update Count     : 622
    1414//
    1515
    … …  
    9696                break;
    9797          case Typeof:
    98           case Basetypeof:
    9998                // typeexpr = new Typeof_t;
    10099                typeexpr = nullptr;
    … …  
    167166                break;
    168167          case Typeof:
    169           case Basetypeof:
    170168                // delete typeexpr->expr;
    171169                delete typeexpr;
    … …  
    247245                break;
    248246          case Typeof:
    249           case Basetypeof:
    250247                newtype->typeexpr = maybeClone( typeexpr );
    251248                break;
    … …  
    422419                } // if
    423420                break;
    424           case Basetypeof:
    425                 os << "base-";
    426                 #if defined(__GNUC__) && __GNUC__ >= 7
    427                         __attribute__((fallthrough));
    428                 #endif
    429421          case Typeof:
    430422                os << "type-of expression ";
    … …  
    465457          case Tuple:
    466458          case Typeof:
    467           case Basetypeof:
    468459          case Builtin:
    469460                assertf(false, "Tried to get leaf name from kind without a name: %d", kind);
    … …  
    522513        switch ( td->kind ) {
    523514          case TypeData::Unknown:
    524                         // fill in implicit int
    525                         return new BasicType( buildQualifiers( td ), BasicType::SignedInt );
     515                // fill in implicit int
     516                return new BasicType( buildQualifiers( td ), BasicType::SignedInt );
    526517          case TypeData::Basic:
    527                         return buildBasicType( td );
     518                return buildBasicType( td );
    528519          case TypeData::Pointer:
    529                         return buildPointer( td );
     520                return buildPointer( td );
    530521          case TypeData::Array:
    531                         return buildArray( td );
     522                return buildArray( td );
    532523          case TypeData::Reference:
    533                         return buildReference( td );
     524                return buildReference( td );
    534525          case TypeData::Function:
    535                         return buildFunction( td );
     526                return buildFunction( td );
    536527          case TypeData::AggregateInst:
    537                         return buildAggInst( td );
     528                return buildAggInst( td );
    538529          case TypeData::EnumConstant:
    539                         // the name gets filled in later -- by SymTab::Validate
    540                         return new EnumInstType( buildQualifiers( td ), "" );
     530                // the name gets filled in later -- by SymTab::Validate
     531                return new EnumInstType( buildQualifiers( td ), "" );
    541532          case TypeData::SymbolicInst:
    542                         return buildSymbolicInst( td );
     533                return buildSymbolicInst( td );
    543534          case TypeData::Tuple:
    544                         return buildTuple( td );
     535                return buildTuple( td );
    545536          case TypeData::Typeof:
    546           case TypeData::Basetypeof:
    547                         return buildTypeof( td );
     537                return buildTypeof( td );
    548538          case TypeData::Builtin:
    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                         }
     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                }
    558548          case TypeData::GlobalScope:
    559                         return new GlobalScopeType();
     549                return new GlobalScopeType();
    560550                case TypeData::Qualified:
    561                         return new QualifiedType( buildQualifiers( td ), typebuild( td->qualified.parent ), typebuild( td->qualified.child ) );
     551                return new QualifiedType( buildQualifiers( td ), typebuild( td->qualified.parent ), typebuild( td->qualified.child ) );
    562552          case TypeData::Symbolic:
    563553          case TypeData::Enum:
    564554          case TypeData::Aggregate:
    565                         assert( false );
     555                assert( false );
    566556        } // switch
    567557
    … …  
    939929
    940930TypeofType * buildTypeof( const TypeData * td ) {
    941         assert( td->kind == TypeData::Typeof || td->kind == TypeData::Basetypeof );
     931        assert( td->kind == TypeData::Typeof );
    942932        assert( td->typeexpr );
    943933        // assert( td->typeexpr->expr );
    944         return new TypeofType{
    945                 buildQualifiers( td ), td->typeexpr->build(), td->kind == TypeData::Basetypeof };
     934        return new TypeofType( buildQualifiers( td ), td->typeexpr->build() );
    946935} // buildTypeof
    947936

  • src/Parser/TypeData.h

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

  • src/Parser/lex.ll

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

  • src/Parser/parser.yy

    r90cfc16 r1f690b3  
    1010// Created On       : Sat Sep  1 20:22:55 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Nov  8 18:08:23 2018
    13 // Update Count     : 4052
     12// Last Modified On : Thu Aug 30 17:02:25 2018
     13// Update Count     : 4029
    1414//
    1515
    … …  
    186186} // fieldDecl
    187187
     188ExpressionNode *forInc( const OperKinds op ) {
     189        return new ExpressionNode( build_constantInteger( *new string( op == OperKinds::LThan || op == OperKinds::LEThan ? "1" : "-1" ) ) );
     190} // forInc
     191
    188192ForCtrl * forCtrl( ExpressionNode * type, string * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
    189         ConstantExpr * constant = dynamic_cast<ConstantExpr *>(type->get_expr());
     193        ConstantExpr *constant = dynamic_cast<ConstantExpr *>(type->get_expr());
    190194        if ( constant && (constant->get_constant()->get_value() == "0" || constant->get_constant()->get_value() == "1") ) {
    191195        type = new ExpressionNode( new CastExpr( maybeMoveBuild< Expression >(type), new BasicType( Type::Qualifiers(), BasicType::SignedInt ) ) );
    192196        } // if
    193197        return new ForCtrl(
    194                 distAttr( DeclarationNode::newTypeof( type, true ), DeclarationNode::newName( index )->addInitializer( new InitializerNode( start ) ) ),
     198                distAttr( DeclarationNode::newTypeof( type ), DeclarationNode::newName( index )->addInitializer( new InitializerNode( start ) ) ),
    195199                new ExpressionNode( build_binary_val( compop, new ExpressionNode( build_varref( new string( *index ) ) ), comp ) ),
    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 
    200 ForCtrl * 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
     200                new ExpressionNode( build_binary_val( OperKinds::PlusAssn, new ExpressionNode( build_varref( new string( *index ) ) ), inc ) ) );
    206201} // forCtrl
    207202
    … …  
    266261%token ZERO_T ONE_T                                                                             // CFA
    267262%token VALIST                                                                                   // GCC
    268 %token TYPEOF BASETYPEOF LABEL                                                  // GCC
     263%token TYPEOF LABEL                                                                             // GCC
    269264%token ENUM STRUCT UNION
    270265%token EXCEPTION                                                                                // CFA
    … …  
    641636                { $$ = new ExpressionNode( build_fieldSel( $1, build_tuple( $4 ) ) ); }
    642637        | postfix_expression ARROW no_attr_identifier
    643                 { $$ = new ExpressionNode( build_pfieldSel( $1, build_varref( $3 ) ) ); }
     638                {
     639                        $$ = new ExpressionNode( build_pfieldSel( $1, *$3 == "0" || *$3 == "1" ? build_constantInteger( *$3 ) : build_varref( $3 ) ) );
     640                }
    644641        | postfix_expression ARROW INTEGERconstant                      // CFA, tuple index
    645642                { $$ = new ExpressionNode( build_pfieldSel( $1, build_constantInteger( *$3 ) ) ); }
    … …  
    11401137        | FOR '(' push for_control_expression ')' statement pop
    11411138                { $$ = 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 ) ); }
    11441139        ;
    11451140
    11461141for_control_expression:
    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" ) ) ) ); }
     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                }
    11501151        | constant_expression inclexcl constant_expression      // CFA
    1151                 { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), $1->clone(), $2, $3, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
     1152                { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), $1->clone(), $2, $3, forInc( $2 ) ); }
    11521153        | constant_expression inclexcl constant_expression '~' constant_expression // CFA
    11531154                { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), $1->clone(), $2, $3, $5 ); }
    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
     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
    11621195                { $$ = new ForCtrl( $1, $3, $5 ); }
    1163         | ';' comma_expression_opt ';' comma_expression_opt
    1164                 { $$ = new ForCtrl( (ExpressionNode * )nullptr, $2, $4 ); }
    11651196        | declaration comma_expression_opt ';' comma_expression_opt // C99, declaration has ';'
    11661197                { $$ = new ForCtrl( $1, $2, $4 ); }
    … …  
    18241855
    18251856indirect_type:
    1826         TYPEOF '(' type ')'                                                                     // GCC: typeof( x ) y;
     1857        TYPEOF '(' type ')'                                                                     // GCC: typeof(x) y;
    18271858                { $$ = $3; }
    1828         | TYPEOF '(' comma_expression ')'                                       // GCC: typeof( a+b ) y;
     1859        | TYPEOF '(' comma_expression ')'                                       // GCC: typeof(a+b) y;
    18291860                { $$ = DeclarationNode::newTypeof( $3 ); }
    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;
     1861        | ATTR_TYPEGENname '(' type ')'                                         // CFA: e.g., @type(x) y;
    18351862                { $$ = DeclarationNode::newAttr( $1, $3 ); }
    1836         | ATTR_TYPEGENname '(' comma_expression ')'                     // CFA: e.g., @type( a+b ) y;
     1863        | ATTR_TYPEGENname '(' comma_expression ')'                     // CFA: e.g., @type(a+b) y;
    18371864                { $$ = DeclarationNode::newAttr( $1, $3 ); }
    18381865        | ZERO_T                                                                                        // CFA

  • src/ResolvExpr/AlternativeFinder.cc

    r90cfc16 r1f690b3  
    1010// Created On       : Sat May 16 23:52:08 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Nov  1 21:00:56 2018
    13 // Update Count     : 34
     12// Last Modified On : Sat Feb 17 11:19:39 2018
     13// Update Count     : 33
    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
    13491346                        NameExpr * nameExpr = dynamic_cast< NameExpr * >( memberExpr->get_member() );
    13501347                        assert( nameExpr );

  • src/ResolvExpr/ResolveTypeof.cc

    r90cfc16 r1f690b3  
    6767                std::cerr << std::endl;
    6868#endif
    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
     69                if ( typeofType->expr ) {
    8370                        Expression * newExpr = resolveInVoidContext( typeofType->expr, indexer );
    8471                        assert( newExpr->result && ! newExpr->result->isVoid() );
    85                         newType = newExpr->result;
     72                        Type * newType = newExpr->result;
    8673                        newExpr->result = nullptr;
    8774                        delete typeofType;
    8875                        delete newExpr;
    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;
     76                        return newType;
     77                } // if
     78                return typeofType;
    10879        }
    10980} // namespace ResolvExpr

  • src/SynTree/Type.h

    r90cfc16 r1f690b3  
    598598class TypeofType : public Type {
    599599  public:
    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 * >() );
     600        Expression *expr;
     601
     602        TypeofType( const Type::Qualifiers & tq, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
    606603        TypeofType( const TypeofType& );
    607604        virtual ~TypeofType();

  • src/SynTree/TypeofType.cc

    r90cfc16 r1f690b3  
    2323class Attribute;
    2424
    25 TypeofType::TypeofType( const Type::Qualifiers &tq, Expression *expr,
    26         const std::list< Attribute * > & attributes )
    27 : Type( tq, attributes ), expr( expr ), is_basetypeof(false) {}
     25TypeofType::TypeofType( const Type::Qualifiers &tq, Expression *expr, const std::list< Attribute * > & attributes ) : Type( tq, attributes ), expr( expr ) {
     26}
    2827
    29 TypeofType::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 
    33 TypeofType::TypeofType( const TypeofType &other )
    34 : Type( other ), expr( maybeClone( other.expr ) ), is_basetypeof( other.is_basetypeof ) {}
     28TypeofType::TypeofType( const TypeofType &other ) : Type( other ), expr( maybeClone( other.expr ) ) {
     29}
    3530
    3631TypeofType::~TypeofType() {
    … …  
    4035void TypeofType::print( std::ostream &os, Indenter indent ) const {
    4136        Type::print( os, indent );
    42         if ( is_basetypeof ) { os << "base-"; }
    4337        os << "type-of expression ";
    4438        if ( expr ) {

  • tests/.expect/alloc-ERROR.txt

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

  • tests/.expect/castError.txt

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

  • tests/.expect/completeTypeError.txt

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

  • tests/.expect/declarationErrors.txt

    r90cfc16 r1f690b3  
    1 declarationErrors.cfa:16:1 error: duplicate static in declaration of x1: static const volatile short int
     1declarationErrors.c:16:1 error: duplicate static in declaration of x1: static const volatile short int
    22
    3 declarationErrors.cfa:17:1 error: conflicting extern & static in declaration of x2: extern const volatile short int
     3declarationErrors.c:17:1 error: conflicting extern & static in declaration of x2: extern const volatile short int
    44
    5 declarationErrors.cfa:18:1 error: conflicting extern & auto, conflicting extern & static, conflicting extern & static, duplicate extern in declaration of x3: extern const volatile short int
     5declarationErrors.c: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.cfa:19:1 error: duplicate static in declaration of x4: static const volatile instance of const volatile struct __anonymous0
     7declarationErrors.c: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.cfa:20:1 error: duplicate const, duplicate static, duplicate volatile in declaration of x5: static const volatile instance of const volatile struct __anonymous1
     13declarationErrors.c: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.cfa:22:1 error: duplicate static in declaration of x6: static const volatile Int
     19declarationErrors.c:22:1 error: duplicate static in declaration of x6: static const volatile Int
    2020
    21 declarationErrors.cfa:24:1 error: duplicate const in declaration of f01: static inline function
     21declarationErrors.c: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.cfa:25:1 error: duplicate volatile in declaration of f02: static inline function
     26declarationErrors.c: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.cfa:26:1 error: duplicate const in declaration of f03: static inline function
     31declarationErrors.c: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.cfa:27:1 error: duplicate volatile in declaration of f04: static inline function
     36declarationErrors.c: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.cfa:28:1 error: duplicate const in declaration of f05: static inline function
     41declarationErrors.c: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.cfa:29:1 error: duplicate volatile in declaration of f06: static inline function
     46declarationErrors.c: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.cfa:30:1 error: duplicate const in declaration of f07: static inline function
     51declarationErrors.c: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.cfa:31:1 error: duplicate const, duplicate volatile in declaration of f08: static inline function
     56declarationErrors.c: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.cfa:33:1 error: duplicate const, duplicate volatile in declaration of f09: static inline function
     61declarationErrors.c: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.cfa:34:1 error: duplicate const, duplicate _Atomic, duplicate _Atomic, duplicate const, duplicate restrict, duplicate volatile in declaration of f09: static inline function
     66declarationErrors.c: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/nested-types-ERR1.txt

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

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

    r90cfc16 r1f690b3  
    1 nested-types.cfa:73:1 error: Use of undefined global type Z
    2 nested-types.cfa:74:1 error: Qualified type requires an aggregate on the left, but has: signed int
    3 nested-types.cfa:75:1 error: Undefined type in qualified type: Qualified Type:
     1nested-types.c:73:1 error: Use of undefined global type Z
     2nested-types.c:74:1 error: Qualified type requires an aggregate on the left, but has: signed int
     3nested-types.c: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

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

  • tests/.expect/typedefRedef-ERR1.txt

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

  • tests/Makefile.am

    r90cfc16 r1f690b3  
    1111## Created On       : Sun May 31 09:08:15 2015
    1212## Last Modified By : Peter A. Buhr
    13 ## Last Modified On : Tue Nov 20 11:18:51 2018
    14 ## Update Count     : 68
     13## Last Modified On : Wed Jun  6 16:42:20 2018
     14## Update Count     : 49
    1515###############################################################################
    1616
    1717AUTOMAKE_OPTIONS = foreign    # do not require all the GNU file names
    18 
    19 include $(top_srcdir)/src/cfa.make
    2018
    2119debug=yes
    … …  
    3836
    3937AM_CFLAGS += ${DEBUG_FLAGS} ${INSTALL_FLAGS} ${ARCH_FLAGS}
     38
    4039CC = @CFACC@
    4140
    … …  
    4342
    4443.PHONY: list .validate
    45 .INTERMEDIATE: .validate .validate.cfa
    46 EXTRA_PROGRAMS = avl_test # build but do not install
     44.INTERMEDIATE: .validate .validate.c
     45EXTRA_PROGRAMS = fstream_test avl_test # build but do not install
     46
     47fstream_test_SOURCES = fstream_test.c
    4748
    4849avl_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
    … …  
    6162        @+${TEST_PY} --list ${concurrent}
    6263
    63 .validate: .validate.cfa
    64         $(CFACOMPILE) .validate.cfa -fsyntax-only -Wall -Wextra -Werror
     64.validate: .validate.c
     65        $(COMPILE) .validate.c -fsyntax-only -Wall -Wextra -Werror
    6566
    66 .validate.cfa:
    67         @echo "int main() { return 0; }" > ${@}
    68 
    69 dummy_hack.c:
     67.validate.c:
    7068        @echo "int main() { return 0; }" > ${@}
    7169
    … …  
    7472
    7573#----------------------------------------------------------------------------------------------------------------
     74# implicit rule so not all test require a rule
     75% : %.c $(CC)
     76        $(PRETTY_PATH) $(COMPILE) $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    7677
    77 # implicit rule so not all test require a rule
    78 % : %.c $(CFACC)
    79         $(PRETTY_PATH) $(CFACOMPILE) $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     78declarationSpecifier: declarationSpecifier.c $(CC)
     79        $(PRETTY_PATH) $(COMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    8080
    81 % : %.cfa $(CFACC)
    82         $(PRETTY_PATH) $(CFACOMPILE) $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     81gccExtensions : gccExtensions.c $(CC)
     82        $(PRETTY_PATH) $(COMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    8383
    84 declarationSpecifier: declarationSpecifier.cfa $(CFACC)
    85         $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     84extension : extension.c $(CC)
     85        $(PRETTY_PATH) $(COMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    8686
    87 gccExtensions : gccExtensions.cfa $(CFACC)
    88         $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     87attributes : attributes.c $(CC)
     88        $(PRETTY_PATH) $(COMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    8989
    90 extension : extension.cfa $(CFACC)
    91         $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     90functions: functions.c $(CC)
     91        $(PRETTY_PATH) $(COMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    9292
    93 attributes : attributes.cfa $(CFACC)
    94         $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     93KRfunctions : KRfunctions.c $(CC)
     94        $(PRETTY_PATH) $(COMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    9595
    96 functions: functions.cfa $(CFACC)
    97         $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     96sched-ext-parse : sched-ext-parse.c $(CC)
     97        $(PRETTY_PATH) $(COMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    9898
    99 KRfunctions : KRfunctions.cfa $(CFACC)
    100         $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    101 
    102 sched-ext-parse : sched-ext-parse.c $(CFACC)
    103         $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    104 
    105 gmp : gmp.cfa $(CFACC)
    106         $(PRETTY_PATH) $(CFACOMPILE) -lgmp $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     99gmp : gmp.c $(CC)
     100        $(PRETTY_PATH) $(COMPILE) -lgmp $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    107101
    108102#builtins
    109 builtins/sync: builtins/sync.c $(CFACC)
    110         $(PRETTY_PATH) $(CFACOMPILE) $(shell realpath --relative-to=${srcdir} ${<}) 2> $(abspath ${@}) -fsyntax-only
     103builtins/sync: builtins/sync.c $(CC)
     104        $(PRETTY_PATH) $(COMPILE) $(shell realpath --relative-to=${srcdir} ${<}) 2> $(abspath ${@}) -fsyntax-only
    111105
    112106#------------------------------------------------------------------------------
     107#To make errors path independent we need to cd into the correct directories
     108completeTypeError : completeTypeError.c $(CC)
     109        $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    113110
    114 #To make errors path independent we need to cd into the correct directories
    115 completeTypeError : completeTypeError.cfa $(CFACC)
    116         $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     111typedefRedef-ERR1: typedefRedef.c $(CC)
     112        $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    117113
    118 typedefRedef-ERR1: typedefRedef.cfa $(CFACC)
    119         $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     114alloc-ERROR: alloc.c $(CC)
     115        $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    120116
    121 alloc-ERROR: alloc.cfa $(CFACC)
    122         $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     117fallthrough-ERROR: fallthrough.c $(CC)
     118        $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    123119
    124 fallthrough-ERROR: fallthrough.cfa $(CFACC)
    125         $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     120nested-types-ERR1: nested-types.c $(CC)
     121        $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    126122
    127 nested-types-ERR1: nested-types.cfa $(CFACC)
    128         $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    129 
    130 nested-types-ERR2: nested-types.cfa $(CFACC)
    131         $(PRETTY_PATH) $(CFACOMPILE) -DERR2 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     123nested-types-ERR2: nested-types.c $(CC)
     124        $(PRETTY_PATH) $(COMPILE) -DERR2 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    132125
    133126# Constructor/destructor tests
    134 raii/dtor-early-exit-ERR1: raii/dtor-early-exit.c $(CFACC)
    135         $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     127raii/dtor-early-exit-ERR1: raii/dtor-early-exit.c $(CC)
     128        $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    136129
    137 raii/dtor-early-exit-ERR2: raii/dtor-early-exit.c $(CFACC)
    138         $(PRETTY_PATH) $(CFACOMPILE) -DERR2 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     130raii/dtor-early-exit-ERR2: raii/dtor-early-exit.c $(CC)
     131        $(PRETTY_PATH) $(COMPILE) -DERR2 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    139132
    140 raii/memberCtors-ERR1: raii/memberCtors.c $(CFACC)
    141         $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     133raii/memberCtors-ERR1: raii/memberCtors.c $(CC)
     134        $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    142135
    143 raii/ctor-autogen-ERR1: raii/ctor-autogen.c $(CFACC)
    144         $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     136raii/ctor-autogen-ERR1: raii/ctor-autogen.c $(CC)
     137        $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    145138
    146139# Warnings
    147 warnings/self-assignment: warnings/self-assignment.c $(CFACC)
    148         $(PRETTY_PATH) $(CFACOMPILE) $(shell realpath --relative-to=${srcdir} ${<}) 2> $(abspath ${@}) -fsyntax-only
     140warnings/self-assignment: warnings/self-assignment.c $(CC)
     141        $(PRETTY_PATH) $(COMPILE) $(shell realpath --relative-to=${srcdir} ${<}) 2> $(abspath ${@}) -fsyntax-only

  • tests/Makefile.in

    r90cfc16 r1f690b3  
    9191build_triplet = @build@
    9292host_triplet = @host@
    93 EXTRA_PROGRAMS = avl_test$(EXEEXT)
     93EXTRA_PROGRAMS = fstream_test$(EXEEXT) avl_test$(EXEEXT)
    9494subdir = tests
    9595ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
    … …  
    110110avl_test_OBJECTS = $(am_avl_test_OBJECTS)
    111111avl_test_LDADD = $(LDADD)
     112am_fstream_test_OBJECTS = fstream_test.$(OBJEXT)
     113fstream_test_OBJECTS = $(am_fstream_test_OBJECTS)
     114fstream_test_LDADD = $(LDADD)
    112115AM_V_P = $(am__v_P_@AM_V@)
    113116am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
    … …  
    138141am__v_CCLD_0 = @echo "  CCLD    " $@;
    139142am__v_CCLD_1 =
    140 SOURCES = $(avl_test_SOURCES)
    141 DIST_SOURCES = $(avl_test_SOURCES)
     143SOURCES = $(avl_test_SOURCES) $(fstream_test_SOURCES)
     144DIST_SOURCES = $(avl_test_SOURCES) $(fstream_test_SOURCES)
    142145am__can_run_installinfo = \
    143146  case $$AM_UPDATE_INFO_DIR in \
    … …  
    165168CTAGS = ctags
    166169am__DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/config.py.in \
    167         $(srcdir)/test.py $(top_srcdir)/automake/depcomp \
    168         $(top_srcdir)/src/cfa.make
     170        $(srcdir)/test.py $(top_srcdir)/automake/depcomp
    169171DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
    170172ACLOCAL = @ACLOCAL@
    … …  
    295297top_srcdir = @top_srcdir@
    296298AUTOMAKE_OPTIONS = foreign    # do not require all the GNU file names
    297 CFACOMPILE = $(CFACC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CFAFLAGS) $(CFAFLAGS) $(AM_CFLAGS) $(CFLAGS)
    298 AM_V_CFA = $(am__v_CFA_@AM_V@)
    299 am__v_CFA_ = $(am__v_CFA_@AM_DEFAULT_V@)
    300 am__v_CFA_0 = @echo "  CFA     " $@;
    301 am__v_CFA_1 =
    302299debug = yes
    303300installed = no
    … …  
    312309        ${INSTALL_FLAGS} ${ARCH_FLAGS}
    313310PRETTY_PATH = cd ${srcdir} &&
     311fstream_test_SOURCES = fstream_test.c
    314312avl_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
    315313all: all-am
    316314
    317315.SUFFIXES:
    318 .SUFFIXES: .c .cfa .o .obj .validate
    319 $(srcdir)/Makefile.in:  $(srcdir)/Makefile.am $(top_srcdir)/src/cfa.make $(am__configure_deps)
     316.SUFFIXES: .c .o .obj .validate
     317$(srcdir)/Makefile.in:  $(srcdir)/Makefile.am $(am__configure_deps)
    320318        @for dep in $?; do \
    321319          case '$(am__configure_deps)' in \
    … …  
    337335            cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
    338336        esac;
    339 $(top_srcdir)/src/cfa.make $(am__empty):
    340337
    341338$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
    … …  
    374371        $(AM_V_CCLD)$(LINK) $(avl_test_OBJECTS) $(avl_test_LDADD) $(LIBS)
    375372
     373fstream_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
    376377mostlyclean-compile:
    377378        -rm -f *.$(OBJEXT)
    … …  
    381382        -rm -f *.tab.c
    382383
     384@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstream_test.Po@am__quote@
    383385@AMDEP_TRUE@@am__include@ @am__quote@avltree/$(DEPDIR)/avl-private.Po@am__quote@
    384386@AMDEP_TRUE@@am__include@ @am__quote@avltree/$(DEPDIR)/avl0.Po@am__quote@
    … …  
    528530
    529531distclean: distclean-am
    530         -rm -rf avltree/$(DEPDIR)
     532        -rm -rf ./$(DEPDIR) avltree/$(DEPDIR)
    531533        -rm -f Makefile
    532534distclean-am: clean-am distclean-compile distclean-generic \
    … …  
    574576
    575577maintainer-clean: maintainer-clean-am
    576         -rm -rf avltree/$(DEPDIR)
     578        -rm -rf ./$(DEPDIR) avltree/$(DEPDIR)
    577579        -rm -f Makefile
    578580maintainer-clean-am: distclean-am maintainer-clean-generic
    … …  
    610612
    611613
    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 
    617614.PHONY: list .validate
    618 .INTERMEDIATE: .validate .validate.cfa
     615.INTERMEDIATE: .validate .validate.c
    619616
    620617#----------------------------------------------------------------------------------------------------------------
    … …  
    631628        @+${TEST_PY} --list ${concurrent}
    632629
    633 .validate: .validate.cfa
    634         $(CFACOMPILE) .validate.cfa -fsyntax-only -Wall -Wextra -Werror
    635 
    636 .validate.cfa:
    637         @echo "int main() { return 0; }" > ${@}
    638 
    639 dummy_hack.c:
     630.validate: .validate.c
     631        $(COMPILE) .validate.c -fsyntax-only -Wall -Wextra -Werror
     632
     633.validate.c:
    640634        @echo "int main() { return 0; }" > ${@}
    641635
    … …  
    644638
    645639#----------------------------------------------------------------------------------------------------------------
    646 
    647640# implicit rule so not all test require a rule
    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 
    654 declarationSpecifier: declarationSpecifier.cfa $(CFACC)
    655         $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    656 
    657 gccExtensions : gccExtensions.cfa $(CFACC)
    658         $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    659 
    660 extension : extension.cfa $(CFACC)
    661         $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    662 
    663 attributes : attributes.cfa $(CFACC)
    664         $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    665 
    666 functions: functions.cfa $(CFACC)
    667         $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    668 
    669 KRfunctions : KRfunctions.cfa $(CFACC)
    670         $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    671 
    672 sched-ext-parse : sched-ext-parse.c $(CFACC)
    673         $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    674 
    675 gmp : gmp.cfa $(CFACC)
    676         $(PRETTY_PATH) $(CFACOMPILE) -lgmp $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     641% : %.c $(CC)
     642        $(PRETTY_PATH) $(COMPILE) $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     643
     644declarationSpecifier: declarationSpecifier.c $(CC)
     645        $(PRETTY_PATH) $(COMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     646
     647gccExtensions : gccExtensions.c $(CC)
     648        $(PRETTY_PATH) $(COMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     649
     650extension : extension.c $(CC)
     651        $(PRETTY_PATH) $(COMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     652
     653attributes : attributes.c $(CC)
     654        $(PRETTY_PATH) $(COMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     655
     656functions: functions.c $(CC)
     657        $(PRETTY_PATH) $(COMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     658
     659KRfunctions : KRfunctions.c $(CC)
     660        $(PRETTY_PATH) $(COMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     661
     662sched-ext-parse : sched-ext-parse.c $(CC)
     663        $(PRETTY_PATH) $(COMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     664
     665gmp : gmp.c $(CC)
     666        $(PRETTY_PATH) $(COMPILE) -lgmp $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    677667
    678668#builtins
    679 builtins/sync: builtins/sync.c $(CFACC)
    680         $(PRETTY_PATH) $(CFACOMPILE) $(shell realpath --relative-to=${srcdir} ${<}) 2> $(abspath ${@}) -fsyntax-only
     669builtins/sync: builtins/sync.c $(CC)
     670        $(PRETTY_PATH) $(COMPILE) $(shell realpath --relative-to=${srcdir} ${<}) 2> $(abspath ${@}) -fsyntax-only
    681671
    682672#------------------------------------------------------------------------------
    683 
    684673#To make errors path independent we need to cd into the correct directories
    685 completeTypeError : completeTypeError.cfa $(CFACC)
    686         $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    687 
    688 typedefRedef-ERR1: typedefRedef.cfa $(CFACC)
    689         $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    690 
    691 alloc-ERROR: alloc.cfa $(CFACC)
    692         $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    693 
    694 fallthrough-ERROR: fallthrough.cfa $(CFACC)
    695         $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    696 
    697 nested-types-ERR1: nested-types.cfa $(CFACC)
    698         $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    699 
    700 nested-types-ERR2: nested-types.cfa $(CFACC)
    701         $(PRETTY_PATH) $(CFACOMPILE) -DERR2 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     674completeTypeError : completeTypeError.c $(CC)
     675        $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     676
     677typedefRedef-ERR1: typedefRedef.c $(CC)
     678        $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     679
     680alloc-ERROR: alloc.c $(CC)
     681        $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     682
     683fallthrough-ERROR: fallthrough.c $(CC)
     684        $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     685
     686nested-types-ERR1: nested-types.c $(CC)
     687        $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     688
     689nested-types-ERR2: nested-types.c $(CC)
     690        $(PRETTY_PATH) $(COMPILE) -DERR2 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    702691
    703692# Constructor/destructor tests
    704 raii/dtor-early-exit-ERR1: raii/dtor-early-exit.c $(CFACC)
    705         $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    706 
    707 raii/dtor-early-exit-ERR2: raii/dtor-early-exit.c $(CFACC)
    708         $(PRETTY_PATH) $(CFACOMPILE) -DERR2 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    709 
    710 raii/memberCtors-ERR1: raii/memberCtors.c $(CFACC)
    711         $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    712 
    713 raii/ctor-autogen-ERR1: raii/ctor-autogen.c $(CFACC)
    714         $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     693raii/dtor-early-exit-ERR1: raii/dtor-early-exit.c $(CC)
     694        $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     695
     696raii/dtor-early-exit-ERR2: raii/dtor-early-exit.c $(CC)
     697        $(PRETTY_PATH) $(COMPILE) -DERR2 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     698
     699raii/memberCtors-ERR1: raii/memberCtors.c $(CC)
     700        $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     701
     702raii/ctor-autogen-ERR1: raii/ctor-autogen.c $(CC)
     703        $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    715704
    716705# Warnings
    717 warnings/self-assignment: warnings/self-assignment.c $(CFACC)
    718         $(PRETTY_PATH) $(CFACOMPILE) $(shell realpath --relative-to=${srcdir} ${<}) 2> $(abspath ${@}) -fsyntax-only
     706warnings/self-assignment: warnings/self-assignment.c $(CC)
     707        $(PRETTY_PATH) $(COMPILE) $(shell realpath --relative-to=${srcdir} ${<}) 2> $(abspath ${@}) -fsyntax-only
    719708
    720709# Tell versions [3.59,3.63) of GNU make to not export all variables.

  • tests/concurrent/coroutineYield.c

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

  • tests/concurrent/examples/matrixSum.c

    r90cfc16 r1f690b3  
    66// file "LICENCE" distributed with Cforall.
    77//
    8 // matrixSum.cfa --
     8// matrixSum.c --
    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 : Tue Nov  6 17:51:32 2018
    14 // Update Count     : 14
     13// Last Modified On : Thu Aug  9 09:17:30 2018
     14// Update Count     : 13
    1515//
    1616
    … …  
    5959// Local Variables: //
    6060// tab-width: 4 //
    61 // compile-command: "cfa matrixSum.cfa" //
     61// compile-command: "cfa matrixSum.c" //
    6262// End: //

  • tests/concurrent/preempt.c

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

  • tests/concurrent/signal/block.c

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

  • tests/concurrent/signal/disjoint.c

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

  • tests/concurrent/signal/wait.c

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

  • tests/preempt_longrun/create.c

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

  • tests/preempt_longrun/enter3.c

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

  • tests/preempt_longrun/processor.c

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

  • tests/preempt_longrun/yield.c

    r90cfc16 r1f690b3  
    44
    55#define __kick_rate 550000ul
    6 #include "long_tests.hfa"
     6#include "long_tests.h"
    77
    88#ifndef PREEMPTION_RATE
Note: See TracChangeset for help on using the changeset viewer.