Changeset 29207bf


Ignore:
Timestamp:
Dec 8, 2018, 4:06:32 PM (3 years ago)
Author:
Aaron Moss <a3moss@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, deferred_resn, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, no_list, persistent-indexer
Children:
5ebb1368, 90cfc16
Parents:
47ed726 (diff), 3d99498 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

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

Files:
1 added
3 deleted
36 edited
87 moved

Legend:

Unmodified
Added
Removed
  • benchmark/Makefile.am

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

    r47ed726 r29207bf  
    2121%  toplas: ACM Trans. on Prog. Lang. & Sys.
    2222%  tcs: Theoretical Computer Science
    23 @string{ieeepds="IEEE Transactions on Parallel and Distributed Systems"}
    24 % @string{ieeepds="IEEE Trans. Parallel Distrib. Syst."}
    25 @string{ieeese="IEEE Transactions on Software Engineering"}
    26 % @string{ieeese="IEEE Trans. Softw. Eng."}
    27 @string{spe="Software---\-Practice and Experience"}
    28 % @string{spe="Softw. Pract. Exp."}
    29 @string{ccpe="Concurrency and Computation: Practice and Experience"}
    30 % @string{ccpe="Concurrency Comput: Pract Experience"}
    31 @string{sigplan="SIGPLAN Notices"}
    32 % @string{sigplan="SIGPLAN Not."}
    33 @string{joop="Journal of Object-Oriented Programming"}
    34 % @string{joop="J. of Object-Oriented Program."}
     23
     24string{ieeepds="IEEE Transactions on Parallel and Distributed Systems"}
     25@string{ieeepds="IEEE Trans. Parallel Distrib. Syst."}
     26string{ieeese="IEEE Transactions on Software Engineering"}
     27@string{ieeese="IEEE Trans. Softw. Eng."}
     28string{spe="Software---\-Practice and Experience"}
     29@string{spe="Softw. Pract. Exper."}
     30string{ccpe="Concurrency and Computation: Practice and Experience"}
     31@string{ccpe="Concurrency Comput.: Pract. Exper."}
     32string{sigplan="SIGPLAN Notices"}
     33@string{sigplan="SIGPLAN Not."}
     34string{joop="Journal of Object-Oriented Programming"}
     35@string{joop="J. of Object-Oriented Program."}
    3536@string{popl="Conference Record of the ACM Symposium on Principles of Programming Languages"}
    3637@string{osr="Operating Systems Review"}
    3738@string{pldi="Programming Language Design and Implementation"}
    3839@string{toplas="Transactions on Programming Languages and Systems"}
    39 @string{mathann="Mathematische Annalen"}
    40 % @string{mathann="Math. Ann."}
     40string{mathann="Mathematische Annalen"}
     41@string{mathann="Math. Ann."}
    4142
    4243% A
     
    566567}
    567568
     569@inproceedings {Qin18,
     570    author      = {Henry Qin and Qian Li and Jacqueline Speiser and Peter Kraft and John Ousterhout},
     571    title       = {Arachne: Core-Aware Thread Management},
     572    booktitle   = {13th {USENIX} Symp. on Oper. Sys. Design and Impl. ({OSDI} 18)},
     573    year        = {2018},
     574    address     = {Carlsbad, CA},
     575    pages       = {145-160},
     576    publisher   = {{USENIX} Association},
     577    note        = {\href{https://www.usenix.org/conference/osdi18/presentation/qin}{https://\-www.usenix.org/\-conference/\-osdi18/\-presentation/\-qin}},
     578}
     579
    568580@article{Kessels82,
    569581    keywords    = {concurrency, critical section},
     
    653665    author      = {Joung, Yuh-Jzer},
    654666    title       = {Asynchronous group mutual exclusion},
    655     journal     = {Distributed Computing},
     667    journal     = {Dist. Comput.},
     668    optjournal  = {Distributed Computing},
    656669    year        = {2000},
    657670    month       = {Nov},
     
    796809        time computable inheritance hierarchy.
    797810    },
    798     comment = {
     811    comment     = {
    799812        Classes are predicates; if object {\tt o} is in class {\tt C}, then
    800813        {\tt C} is true of {\tt o}.  Classes are combined with {\tt :AND},
     
    950963
    951964@article{Moss18,
    952     keywords    = {type systems, tuples, Cforall},
     965    keywords    = {type systems, polymorphism, tuples, Cforall},
    953966    contributer = {pabuhr@plg},
    954967    author      = {Aaron Moss and Robert Schluntz and Peter A. Buhr},
    955968    title       = {\textsf{C}$\mathbf{\forall}$ : Adding Modern Programming Language Features to C},
     969    journal     = spe,
     970    volume      = 48,
     971    number      = 12,
     972    month       = dec,
    956973    year        = 2018,
    957     month       = aug,
    958     journal     = spe,
     974    pages       = {2111-2146},
    959975    note        = {\href{http://dx.doi.org/10.1002/spe.2624}{http://\-dx.doi.org/\-10.1002/\-spe.2624}},
    960976}
     
    9891005    journal     = {Dr. Dobb's Journal of Software Tools},
    9901006    year        = 1989,
    991     month       = feb, volume = 14, number = 2, pages = {45-51},
     1007    month       = feb,
     1008    volume      = 14,
     1009    number      = 2,
     1010    pages       = {45-51},
    9921011    comment     = {
    9931012       A light-weight multitasking kernel for MS-DOS.  A task\_control
     
    15071526}
    15081527
    1509 @techreport{uC++,
     1528@manual{uC++,
    15101529    keywords    = {C++, concurrency, light-weight process, shared memory},
    15111530    contributer = {pabuhr@plg},
     1531    key         = {uC++},
    15121532    author      = {Peter A. Buhr},
    15131533    title       = {$\mu${C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Annotated Reference Manual, Version 7.0.0},
    1514     institution = {School of Computer Science, University of Waterloo},
    1515     address     = {Waterloo, Ontario, Canada, N2L 3G1},
    1516     month       = dec,
    1517     year        = 2017,
     1534    organization= {University of Waterloo},
     1535    month       = sep,
     1536    year        = 2018,
    15181537    note        = {\href{https://plg.uwaterloo.ca/~usystem/pub/uSystem/uC++.pdf}{https://\-plg.uwaterloo.ca/\-$\sim$usystem/\-pub/\-uSystem/uC++.pdf}},
    15191538}
     
    15861605    author      = {Sun, Xianda},
    15871606    title       = {Concurrent High-performance Persistent Hash Table In {J}ava},
    1588     school      = {School of Computer Science, University of Waterloo},
     1607    school      = {School of Computer Sc., University of Waterloo},
    15891608    year        = 2015,
    15901609    optaddress  = {Waterloo, Ontario, Canada, N2L 3G1},
     
    19361955    note        = {Svensk Standard SS 63 61 14},
    19371956    year        = 1987,
    1938     abstract    = {
    1939         Standard for the programming language SIMULA.  Written in English.
    1940     }
     1957    abstract    = {Standard for the programming language SIMULA. Written in English.}
    19411958}
    19421959
    19431960@article{Galil91,
    1944   keywords = {union-find},
    1945   contributer = {a3moss@uwaterloo.ca},
    1946   title={Data structures and algorithms for disjoint set union problems},
    1947   author={Galil, Zvi and Italiano, Giuseppe F},
    1948   journal={ACM Computing Surveys (CSUR)},
    1949   volume={23},
    1950   number={3},
    1951   pages={319--344},
    1952   year={1991},
    1953   publisher={ACM}
     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},
    19541971}
    19551972
     
    20942111
    20952112@book{Aho74,
    2096   keywords = {algorithms, textbook, union-find},
    2097   contributer = {a3moss@uwaterloo.ca},
    2098   title = {The Design and Analysis of Computer Algorithms},
    2099   author = {Aho, Alfred V and Hopcroft, John E and Ullman, Jeffrey D},
    2100   year = {1974},
    2101   publisher = {Addison-Wesley},
    2102   address = {Reading, MA, USA}
     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}
    21032120}
    21042121
     
    29002917    month       = oct,
    29012918    year        = 1988,
    2902     pages       = {143--149}
    2903 }
    2904 
    2905 @InProceedings{Patwary10,
    2906 keywords = {union-find},
    2907 contributer = {a3moss@uwaterloo.ca},
    2908 author={Patwary, Md. Mostofa Ali and Blair, Jean and Manne, Fredrik},
    2909 editor={Festa, Paola},
    2910 title={Experiments on Union-Find Algorithms for the Disjoint-Set Data Structure},
    2911 booktitle={Experimental Algorithms},
    2912 year=2010,
    2913 publisher={Springer Berlin Heidelberg},
    2914 address={Berlin, Heidelberg},
    2915 pages={411--423},
    2916 isbn={978-3-642-13193-6}
     2919    pages       = {143-149}
     2920}
     2921
     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}
    29172934}
    29182935
     
    32603277    keywords    = {Go programming language},
    32613278    contributer = {pabuhr@plg},
     3279    author      = {Robert Griesemer and Rob Pike and Ken Thompson},
    32623280    title       = {{Go} Programming Language},
    3263     author      = {Robert Griesemer and Rob Pike and Ken Thompson},
    32643281    organization= {Google},
    32653282    year        = 2009,
     
    34533470    month       = sep,
    34543471    publisher   = {John Wiley \& Sons},
    3455     note        = {\href{https://doi-org.proxy.lib.uwaterloo.ca/10.1002/cpe.4475}{https://\-doi-org.proxy.lib.uwaterloo.ca/\-10.1002/\-cpe.4475}},
     3472    note        = {\href{https://doi.org/10.1002/cpe.4475}{https://\-doi.org/\-10.1002/\-cpe.4475}},
    34563473}
    34573474
     
    35943611
    35953612@article{Galler64,
    3596   keywords={union-find, original},
    3597   contributer={a3moss@uwaterloo.ca},
    3598   title={An improved equivalence algorithm},
    3599   author={Galler, Bernard A and Fisher, Michael J},
    3600   journal={Communications of the ACM},
    3601   volume={7},
    3602   number={5},
    3603   pages={301--303},
    3604   year={1964},
    3605   publisher={ACM}
     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}
    36063623}
    36073624
     
    39483965    author      = {Peter A. Buhr and Martin Karsten and Jun Shih},
    39493966    title       = {{\small\textsf{KDB}}: A Multi-threaded Debugger for Multi-threaded Applications},
    3950     booktitle   = {Proceedings of SPDT'96: SIGMETRICS Symposium on Parallel and Distributed Tools},
     3967    booktitle   = {Proc. of SPDT'96: SIGMETRICS Symp. on Parallel and Distributed Tools},
    39513968    publisher   = {ACM Press},
    39523969    address     = {Philadelphia, Pennsylvania, U.S.A.},
     
    54405457
    54415458@inproceedings{Conchon07,
    5442   keywords = {persistent array, union-find},
    5443   contributer = {a3moss@uwaterloo.ca},
    5444   title={A persistent union-find data structure},
    5445   author={Conchon, Sylvain and Filli{\^a}tre, Jean-Christophe},
    5446   booktitle={Proceedings of the 2007 workshop on Workshop on ML},
    5447   pages={37--46},
    5448   year={2007},
    5449   organization={ACM}
     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}
    54505467}
    54515468
     
    56645681    author      = {Peter A. Buhr and Robert Denda},
    56655682    title       = {{$\mu$Profiler} : Profiling User-Level Threads in a Shared-Memory Programming Environment},
    5666     booktitle   = {Proceedings of the Second International Symposium on Computing in Object-Oriented Parallel Environments (ISCOPE'98)},
     5683    booktitle   = {Proc. of 2nd Inter. Symp. on Computing in Object-Oriented Parallel Environments},
    56675684    series      = {Lecture Notes in Computer Science},
    56685685    publisher   = {Springer-Verlag},
     
    60356052    issn        = {0164-0925},
    60366053    pages       = {429-475},
    6037     url         = {http://doi.acm.org.proxy.lib.uwaterloo.ca/10.1145/1133651.1133653},
     6054    url         = {http://doi.acm.org/10.1145/1133651.1133653},
    60386055    doi         = {10.1145/1133651.1133653},
    60396056    acmid       = {1133653},
     
    63026319    contributer = {pabuhr@plg},
    63036320    key         = {Rust},
    6304     title       = {The {R}ust Programming Language},
    6305     address     = {The Rust Project Developers},
     6321    title       = {{R}ust Programming Language},
     6322    optaddress  = {Rust Project Developers},
    63066323    year        = 2015,
    63076324    note        = {\href{https://doc.rust-lang.org/reference.html}{https://\-doc.rust-lang\-.org/\-reference.html}},
     
    63726389
    63736390@article{Baker78,
    6374  keywords = {Algol display, FUNARG's, Lisp 1.5, deep binding, environment trees, multiprogramming, shallow binding},
    6375  contributer = {a3moss@uwaterloo.ca},
    6376  author = {Baker,Jr., Henry G.},
    6377  title = {Shallow Binding in Lisp 1.5},
    6378  journal = {Commun. ACM},
    6379  issue_date = {July 1978},
    6380  volume = {21},
    6381  number = {7},
    6382  month = jul,
    6383  year = {1978},
    6384  issn = {0001-0782},
    6385  pages = {565--569},
    6386  numpages = {5},
    6387  url = {http://doi.acm.org.proxy.lib.uwaterloo.ca/10.1145/359545.359566},
    6388  doi = {10.1145/359545.359566},
    6389  acmid = {359566},
    6390  publisher = {ACM},
    6391  address = {New York, NY, USA}
     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}
    63926409}
    63936410
    63946411@article{Baker91,
    6395  keywords = {shallow binding, functional arrays},
    6396  contributer = {a3moss@uwaterloo.ca},
    6397  author = {Baker, Henry G.},
    6398  title = {Shallow Binding Makes Functional Arrays Fast},
    6399  journal = {SIGPLAN Not.},
    6400  issue_date = {Aug. 1991},
    6401  volume = {26},
    6402  number = {8},
    6403  month = aug,
    6404  year = {1991},
    6405  issn = {0362-1340},
    6406  pages = {145--147},
    6407  numpages = {3},
    6408  url = {http://doi.acm.org.proxy.lib.uwaterloo.ca/10.1145/122598.122614},
    6409  doi = {10.1145/122598.122614},
    6410  acmid = {122614},
    6411  publisher = {ACM},
    6412  address = {New York, NY, USA},
     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},
    64136430}
    64146431
     
    75807597
    75817598@article{Tarjan84,
    7582  keywords = {union-find},
    7583  contributer = {a3moss@uwaterloo.ca},
    7584  author = {Tarjan, Robert E. and van Leeuwen, Jan},
    7585  title = {Worst-case Analysis of Set Union Algorithms},
    7586  journal = {J. ACM},
    7587  issue_date = {April 1984},
    7588  volume = {31},
    7589  number = {2},
    7590  month = mar,
    7591  year = {1984},
    7592  issn = {0004-5411},
    7593  pages = {245--281},
    7594  numpages = {37},
    7595  url = {http://doi.acm.org/10.1145/62.2160},
    7596  doi = {10.1145/62.2160},
    7597  acmid = {2160},
    7598  publisher = {ACM},
    7599  address = {New York, NY, USA},
     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},
    76007617}
    76017618
  • doc/user/Makefile

    r47ed726 r29207bf  
    7979## Define the default recipes.
    8080
    81 ${Build}:
     81${Build} :
    8282        mkdir -p ${Build}
    8383
  • doc/user/user.tex

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

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

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

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

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

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

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

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

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

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

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

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

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

    r47ed726 r29207bf  
    1 alloc.c:265:1 error: No reasonable alternatives for expression Applying untyped:
     1alloc.cfa:265:1 error: No reasonable alternatives for expression Applying untyped:
    22  Name: ?=?
    33...to:
     
    1919
    2020
    21 alloc.c:266:1 error: No reasonable alternatives for expression Applying untyped:
     21alloc.cfa:266:1 error: No reasonable alternatives for expression Applying untyped:
    2222  Name: ?=?
    2323...to:
     
    3939
    4040
    41 alloc.c:267:1 error: No reasonable alternatives for expression Applying untyped:
     41alloc.cfa:267:1 error: No reasonable alternatives for expression Applying untyped:
    4242  Name: ?=?
    4343...to:
     
    5050
    5151
    52 alloc.c:268:1 error: No reasonable alternatives for expression Applying untyped:
     52alloc.cfa:268:1 error: No reasonable alternatives for expression Applying untyped:
    5353  Name: ?=?
    5454...to:
  • tests/.expect/castError.txt

    r47ed726 r29207bf  
    1 castError.c:7:1 error: Cannot choose between 3 alternatives for expression
     1castError.cfa:7:1 error: Cannot choose between 3 alternatives for expression
    22Cast of:
    33  Name: f
    44... to:
    5   charAlternatives are:
     5  char Alternatives are:
    66Cost ( 1, 0, 0, 0 ): Cast of:
    77     Variable Expression: f: function
  • tests/.expect/completeTypeError.txt

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

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

    r47ed726 r29207bf  
    33empty
    44
     5zero
    56A
    6 A A
    77A A A A A A A A A A
    88B B B B B
     
    1010D D D D D
    1111E E E E E
    12 0 1 2 3 4 5 6 7 8 9
     12
    13130 1 2 3 4 5 6 7 8 9
    14141 3 5 7 9
     
    18182 4 6 8 10
    191910 8 6 4 2
     20
     21
     22N N N N N N N N N N
     230 1 2 3 4 5 6 7 8 9
     2410 9 8 7 6 5 4 3 2 1
     25
     26
    20273 6 9
     28
     29
    2130(0 0)(1 1)(2 2)(3 3)(4 4)(5 5)(6 6)(7 7)(8 8)(9 9)
    2231(0 0)(1 1)(2 2)(3 3)(4 4)(5 5)(6 6)(7 7)(8 8)(9 9)
     32
    2333(0 0)(1 1)(2 2)(3 3)(4 4)(5 5)(6 6)(7 7)(8 8)(9 9)
    2434(0 0)(1 1)(2 2)(3 3)(4 4)(5 5)(6 6)(7 7)(8 8)(9 9)
     35(0 0)(1 1)(2 2)(3 3)(4 4)(5 5)(6 6)(7 7)(8 8)(9 9)(10 10)
     36(0 0)(1 1)(2 2)(3 3)(4 4)(5 5)(6 6)(7 7)(8 8)(9 9)(10 10)
     37
     38(10 10)(9 9)(8 8)(7 7)(6 6)(5 5)(4 4)(3 3)(2 2)(1 1)
     39(10 10)(9 9)(8 8)(7 7)(6 6)(5 5)(4 4)(3 3)(2 2)(1 1)
     40(10 10)(9 9)(8 8)(7 7)(6 6)(5 5)(4 4)(3 3)(2 2)(1 1)(0 0)
     41(10 10)(9 9)(8 8)(7 7)(6 6)(5 5)(4 4)(3 3)(2 2)(1 1)(0 0)
  • tests/.expect/nested-types-ERR1.txt

    r47ed726 r29207bf  
    1 nested-types.c:70:1 error: Use of undefined type T
     1nested-types.cfa:70:1 error: Use of undefined type T
  • tests/.expect/nested-types-ERR2.txt

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

    r47ed726 r29207bf  
    1 scopeErrors.c:2:1 error: duplicate object definition for thisIsAnError: signed int
    2 scopeErrors.c:20:1 error: duplicate function definition for butThisIsAnError: function
     1scopeErrors.cfa:2:1 error: duplicate object definition for thisIsAnError: signed int
     2scopeErrors.cfa:20:1 error: duplicate function definition for butThisIsAnError: function
    33... with parameters
    44  double
  • tests/.expect/typedefRedef-ERR1.txt

    r47ed726 r29207bf  
    1 typedefRedef.c:4:1 error: Cannot redefine typedef: Foo
    2 typedefRedef.c:60:1 error: Cannot redefine typedef: ARR
     1typedefRedef.cfa:4:1 error: Cannot redefine typedef: Foo
     2typedefRedef.cfa:60:1 error: Cannot redefine typedef: ARR
  • tests/KRfunctions.cfa

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

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

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

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

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

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

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

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

    r47ed726 r29207bf  
    66
    77#define __kick_rate 150000ul
    8 #include "long_tests.h"
     8#include "long_tests.hfa"
    99
    1010#ifndef PREEMPTION_RATE
  • tests/concurrent/examples/matrixSum.c

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

    r47ed726 r29207bf  
    33#include <time.hfa>
    44
    5 #include "long_tests.h"
     5#include "long_tests.hfa"
    66
    77#ifndef PREEMPTION_RATE
  • tests/concurrent/signal/block.c

    r47ed726 r29207bf  
    1414#include <time.hfa>
    1515
    16 #include "long_tests.h"
     16#include "long_tests.hfa"
    1717
    1818#ifndef PREEMPTION_RATE
  • tests/concurrent/signal/disjoint.c

    r47ed726 r29207bf  
    55#include <time.hfa>
    66
    7 #include "long_tests.h"
     7#include "long_tests.hfa"
    88
    99#ifndef PREEMPTION_RATE
  • tests/concurrent/signal/wait.c

    r47ed726 r29207bf  
    1313
    1414#define __kick_rate 12000ul
    15 #include "long_tests.h"
     15#include "long_tests.hfa"
    1616
    1717#ifndef PREEMPTION_RATE
  • tests/counter.cfa

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

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

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

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

    r47ed726 r29207bf  
    88#include <stdbool.h>
    99
    10 #include "except-mac.h"
     10#include "except-mac.hfa"
    1111TRIVIAL_EXCEPTION(yin)
    1212TRIVIAL_EXCEPTION(yang)
  • tests/except-1.cfa

    r47ed726 r29207bf  
    55#include <stdio.h>
    66
    7 #include "except-mac.h"
     7#include "except-mac.hfa"
    88TRIVIAL_EXCEPTION(yin)
    99TRIVIAL_EXCEPTION(yang)
  • tests/except-2.cfa

    r47ed726 r29207bf  
    33
    44#include <stdlib.hfa>
    5 #include "except-mac.h"
     5#include "except-mac.hfa"
    66
    77TRIVIAL_EXCEPTION(yin)
  • tests/except-3.cfa

    r47ed726 r29207bf  
    22
    33#include <stdio.h>
    4 #include "except-mac.h"
     4#include "except-mac.hfa"
    55TRIVIAL_EXCEPTION(myth)
    66
  • tests/extension.cfa

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    r47ed726 r29207bf  
    33#include <time.hfa>
    44
    5 #include "long_tests.h"
     5#include "long_tests.hfa"
    66
    77#ifndef PREEMPTION_RATE
  • tests/preempt_longrun/enter3.c

    r47ed726 r29207bf  
    55
    66#define __kick_rate 75000ul
    7 #include "long_tests.h"
     7#include "long_tests.hfa"
    88
    99#ifndef PREEMPTION_RATE
  • tests/preempt_longrun/processor.c

    r47ed726 r29207bf  
    55#include <unistd.h>
    66
    7 #include "long_tests.h"
     7#include "long_tests.hfa"
    88
    99#ifndef PREEMPTION_RATE
  • tests/preempt_longrun/yield.c

    r47ed726 r29207bf  
    44
    55#define __kick_rate 550000ul
    6 #include "long_tests.h"
     6#include "long_tests.hfa"
    77
    88#ifndef PREEMPTION_RATE
  • tests/quotedKeyword.cfa

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

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

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

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

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

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

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

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

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

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

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

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