Changes in / [85142648:970141d]


Ignore:
Files:
2 added
32 edited

Legend:

Unmodified
Added
Removed

  • .gitignore

    r85142648 r970141d  
    2121.deps
    2222.dirstamp
    23 bin
    24 lib
    25 include
    26 share
    27 build
     23/bin
     24/lib
     25/include
     26/share
     27/build
    2828*.class
    2929

  • Makefile.in

    r85142648 r970141d  
    294294FGREP = @FGREP@
    295295GREP = @GREP@
     296HAS_DISTCC = @HAS_DISTCC@
    296297HOST_FLAGS = @HOST_FLAGS@
    297298INSTALL = @INSTALL@

  • benchmark/Makefile.in

    r85142648 r970141d  
    244244FGREP = @FGREP@
    245245GREP = @GREP@
     246HAS_DISTCC = @HAS_DISTCC@
    246247HOST_FLAGS = @HOST_FLAGS@
    247248INSTALL = @INSTALL@

  • configure

    r85142648 r970141d  
    663663ac_ct_DUMPBIN
    664664DUMPBIN
    665 LD
    666665FGREP
    667666EGREP
    … …  
    701700LDFLAGS
    702701CXXFLAGS
    703 CXX
    704702CFA_FLAGS
    705703LIBCFA_TARGET_MAKEFILES
    … …  
    723721CFA_INCDIR
    724722CFA_PREFIX
     723HAS_DISTCC
     724LD
     725CXX
     726ENABLE_DISTCC_FALSE
     727ENABLE_DISTCC_TRUE
    725728DOendif
    726729DOifskipcompile
    … …  
    797800enable_silent_rules
    798801with_cfa_name
     802enable_distcc
    799803with_target_hosts
    800804enable_gprofiler
    … …  
    14591463  --enable-silent-rules   less verbose build output (undo: "make V=1")
    14601464  --disable-silent-rules  verbose build output (undo: "make V=0")
     1465  --enable-distcc     whether or not to enable distributed compilation
    14611466  --enable-gprofiler     whether or not to enable gprofiler tools (if available)
    14621467  --enable-demangler     whether or not to build the demangler (executable and library)
    … …  
    31803185
    31813186DOendif='endif'
     3187
     3188
     3189
     3190#==============================================================================
     3191# distcc support
     3192
     3193# Check whether --enable-distcc was given.
     3194if test "${enable_distcc+set}" = set; then :
     3195  enableval=$enable_distcc; enable_distcc=$enableval
     3196else
     3197  enable_distcc=no
     3198fi
     3199
     3200
     3201 if test x$enable_distcc = xyes; then
     3202  ENABLE_DISTCC_TRUE=
     3203  ENABLE_DISTCC_FALSE='#'
     3204else
     3205  ENABLE_DISTCC_TRUE='#'
     3206  ENABLE_DISTCC_FALSE=
     3207fi
     3208
     3209HAS_DISTCC="False"
     3210
     3211if test x$enable_distcc = xyes; then
     3212        CXX="distcc ${CXX}"
     3213        LD="distcc ${LD} -lstdc++"
     3214        HAS_DISTCC="True"
     3215        echo "Enabling distributed builds"
     3216fi
     3217
     3218
    31823219
    31833220
    … …  
    1701717054fi
    1701817055
     17056if test -z "${ENABLE_DISTCC_TRUE}" && test -z "${ENABLE_DISTCC_FALSE}"; then
     17057  as_fn_error $? "conditional \"ENABLE_DISTCC\" was never defined.
     17058Usually this means the macro was only invoked conditionally." "$LINENO" 5
     17059fi
    1701917060if test -z "${AMDEP_TRUE}" && test -z "${AMDEP_FALSE}"; then
    1702017061  as_fn_error $? "conditional \"AMDEP\" was never defined.

  • configure.ac

    r85142648 r970141d  
    5656AC_SUBST([DOendif])
    5757AM_SUBST_NOTMAKE([DOendif])
     58
     59#==============================================================================
     60# distcc support
     61
     62AC_ARG_ENABLE(distcc,
     63        [  --enable-distcc     whether or not to enable distributed compilation],
     64        enable_distcc=$enableval, enable_distcc=no)
     65
     66AM_CONDITIONAL([ENABLE_DISTCC], [test x$enable_distcc = xyes])
     67HAS_DISTCC="False"
     68
     69if test x$enable_distcc = xyes; then
     70        CXX="distcc ${CXX}"
     71        LD="distcc ${LD} -lstdc++"
     72        HAS_DISTCC="True"
     73        echo "Enabling distributed builds"
     74fi
     75
     76AC_SUBST(CXX)
     77AC_SUBST(LD)
     78AC_SUBST(HAS_DISTCC)
    5879
    5980#==============================================================================

  • doc/bibliography/pl.bib

    r85142648 r970141d  
    943943}
    944944
    945 @misc{Cforall,
    946     contributer = {pabuhr@plg},
    947     key         = {Cforall},
    948     author      = {{\textsf{C}{$\mathbf{\forall}$} Features}},
    949     howpublished= {\href{https://plg.uwaterloo.ca/~cforall/features}{https://\-plg.uwaterloo.ca/\-$\sim$cforall/\-features}},
    950 }
    951 
    952 @misc{CforallBenchMarks,
    953     contributer = {pabuhr@plg},
    954     key         = {Cforall Benchmarks},
    955     author      = {{\textsf{C}{$\mathbf{\forall}$} Benchmarks}},
    956     howpublished= {\href{https://plg.uwaterloo.ca/~cforall/benchmark.tar}{https://\-plg.uwaterloo.ca/\-$\sim$cforall/\-benchmark.tar}},
    957 }
    958 
    959 @mastersthesis{Esteves04,
    960     keywords    = {Cforall, parametric polymorphism, overloading},
    961     contributer = {pabuhr@plg},
    962     author      = {Rodolfo Gabriel Esteves},
    963     title       = {\textsf{C}$\mathbf{\forall}$, a Study in Evolutionary Design in Programming Languages},
    964     school      = {School of Computer Science, University of Waterloo},
    965     year        = 2004,
    966     address     = {Waterloo, Ontario, Canada, N2L 3G1},
    967     note        = {\href{http://plg.uwaterloo.ca/theses/EstevesThesis.pdf}{http://\-plg.uwaterloo.ca/\-theses/\-EstevesThesis.pdf}},
    968 }
    969 
    970 @misc{CFAStackEvaluation,
    971     contributer = {a3moss@plg},
    972     author      = {Aaron Moss},
    973     title       = {\textsf{C}$\mathbf{\forall}$ Stack Evaluation Programs},
    974     year        = 2018,
    975     howpublished= {\href{https://cforall.uwaterloo.ca/CFAStackEvaluation.zip}{https://cforall.uwaterloo.ca/\-CFAStackEvaluation.zip}},
    976 }
    977 
    978945@article{Moss18,
    979946    keywords    = {type systems, polymorphism, tuples, Cforall},
    … …  
    988955    pages       = {2111-2146},
    989956    note        = {\href{http://dx.doi.org/10.1002/spe.2624}{http://\-dx.doi.org/\-10.1002/\-spe.2624}},
     957}
     958
     959@misc{CforallBenchMarks,
     960    contributer = {pabuhr@plg},
     961    key         = {Cforall Benchmarks},
     962    author      = {{\textsf{C}{$\mathbf{\forall}$} Benchmarks}},
     963    howpublished= {\href{https://plg.uwaterloo.ca/~cforall/benchmark.tar}{https://\-plg.uwaterloo.ca/\-$\sim$cforall/\-benchmark.tar}},
     964}
     965
     966@misc{Cforall,
     967    contributer = {pabuhr@plg},
     968    key         = {Cforall},
     969    author      = {{\textsf{C}{$\mathbf{\forall}$} Features}},
     970    howpublished= {\href{https://plg.uwaterloo.ca/~cforall/features}{https://\-plg.uwaterloo.ca/\-$\sim$cforall/\-features}},
     971}
     972
     973@misc{CFAStackEvaluation,
     974    contributer = {a3moss@plg},
     975    author      = {Aaron Moss},
     976    title       = {\textsf{C}$\mathbf{\forall}$ Stack Evaluation Programs},
     977    year        = 2018,
     978    howpublished= {\href{https://cforall.uwaterloo.ca/CFAStackEvaluation.zip}{https://cforall.uwaterloo.ca/\-CFAStackEvaluation.zip}},
     979}
     980
     981@mastersthesis{Esteves04,
     982    keywords    = {Cforall, parametric polymorphism, overloading},
     983    contributer = {pabuhr@plg},
     984    author      = {Rodolfo Gabriel Esteves},
     985    title       = {\textsf{C}$\mathbf{\forall}$, a Study in Evolutionary Design in Programming Languages},
     986    school      = {School of Computer Science, University of Waterloo},
     987    year        = 2004,
     988    address     = {Waterloo, Ontario, Canada, N2L 3G1},
     989    note        = {\href{http://plg.uwaterloo.ca/theses/EstevesThesis.pdf}{http://\-plg.uwaterloo.ca/\-theses/\-EstevesThesis.pdf}},
     990}
     991
     992@phdthesis{Moss19,
     993    keywords    = {type system, generic type, resolution algorithm, type environment, Cforall},
     994    author      = {Aaron Moss},
     995    title       = {\textsf{C}$\mathbf{\forall}$ Type System Implementation},
     996    school      = {School of Computer Science, University of Waterloo},
     997    year        = 2019,
     998    optaddress  = {Waterloo, Ontario, Canada, N2L 3G1},
     999    note        = {\href{https://uwspace.uwaterloo.ca/handle/10012/14584}{https://\-uwspace.uwaterloo.ca/\-handle/\-10012/\-14584}},
    9901000}
    9911001
    … …  
    11011111
    11021112@techreport{Prokopec11,
    1103   keywords = {ctrie, concurrent map},
    1104   contributer = {a3moss@uwaterloo.ca},
    1105   title={Cache-aware lock-free concurrent hash tries},
    1106   author={Prokopec, Aleksandar and Bagwell, Phil and Odersky, Martin},
    1107   institution={EPFL},
    1108   year={2011}
     1113    keywords    = {ctrie, concurrent map},
     1114    contributer = {a3moss@uwaterloo.ca},
     1115    title       ={Cache-aware lock-free concurrent hash tries},
     1116    author      ={Prokopec, Aleksandar and Bagwell, Phil and Odersky, Martin},
     1117    institution ={EPFL},
     1118    year        ={2011}
    11091119}
    11101120
    … …  
    11581168
    11591169@phdthesis{Norrish98,
    1160   title={C formalised in HOL},
    1161   author={Norrish, Michael},
    1162   year={1998},
    1163   school={University of Cambridge}
     1170    title       = {C formalised in HOL},
     1171    author      = {Norrish, Michael},
     1172    year        = {1998},
     1173    school      = {University of Cambridge}
    11641174}
    11651175
    … …  
    11701180    title       = {Checked C: Making C Safe by Extension},
    11711181    booktitle   = {2018 IEEE Cybersecurity Development (SecDev)},
     1182    publisher   = {IEEE},
    11721183    year        = {2018},
    1173     month       = {September},
     1184    month       = sep,
    11741185    pages       = {53-60},
    1175     publisher   = {IEEE},
    11761186    url         = {https://www.microsoft.com/en-us/research/publication/checkedc-making-c-safe-by-extension/},
    11771187}
    … …  
    12851295
    12861296@inproceedings{Odersky01,
    1287  keywords = {Scala},
    1288  contributer = {a3moss@uwaterloo.ca},
    1289  author = {Odersky, Martin and Zenger, Christoph and Zenger, Matthias},
    1290  title = {Colored Local Type Inference},
    1291  booktitle = {Proceedings of the 28th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages},
    1292  series = {POPL '01},
    1293  year = {2001},
    1294  isbn = {1-58113-336-7},
    1295  location = {London, United Kingdom},
    1296  pages = {41--53},
    1297  numpages = {13},
    1298  url = {http://doi.acm.org/10.1145/360204.360207},
    1299  doi = {10.1145/360204.360207},
    1300  acmid = {360207},
    1301  publisher = {ACM},
    1302  address = {New York, NY, USA},
     1297    keywords    = {Scala},
     1298    contributer = {a3moss@uwaterloo.ca},
     1299    author      = {Odersky, Martin and Zenger, Christoph and Zenger, Matthias},
     1300    title       = {Colored Local Type Inference},
     1301    booktitle   = {Proceedings of the 28th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages},
     1302    series      = {POPL '01},
     1303    year        = {2001},
     1304    isbn        = {1-58113-336-7},
     1305    location    = {London, United Kingdom},
     1306    pages       = {41--53},
     1307    numpages    = {13},
     1308    url         = {http://doi.acm.org/10.1145/360204.360207},
     1309    doi         = {10.1145/360204.360207},
     1310    acmid       = {360207},
     1311    publisher   = {ACM},
     1312    address     = {New York, NY, USA},
    13031313}
    13041314
    … …  
    16931703
    16941704@inproceedings{Prokopec12,
    1695   keywords={ctrie, hash trie, concurrent map},
    1696   contributer={a3moss@uwaterloo.ca},
    1697   title={Concurrent tries with efficient non-blocking snapshots},
    1698   author={Prokopec, Aleksandar and Bronson, Nathan Grasso and Bagwell, Phil and Odersky, Martin},
    1699   booktitle={ACM SIGPLAN Notices},
    1700   volume={47},
    1701   number={8},
    1702   pages={151--160},
    1703   year={2012},
    1704   organization={ACM}
     1705    keywords    = {ctrie, hash trie, concurrent map},
     1706    contributer = {a3moss@uwaterloo.ca},
     1707    title       = {Concurrent tries with efficient non-blocking snapshots},
     1708    author      = {Prokopec, Aleksandar and Bronson, Nathan Grasso and Bagwell, Phil and Odersky, Martin},
     1709    booktitle   = {ACM SIGPLAN Notices},
     1710    volume      = {47},
     1711    number      = {8},
     1712    pages       = {151--160},
     1713    year        = {2012},
     1714    organization={ACM}
    17051715}
    17061716
    … …  
    17291739}
    17301740
    1731 @article{Delisle18b,
     1741@article{Delisle19,
    17321742    keywords    = {concurrency, Cforall},
    17331743    contributer = {pabuhr@plg},
    17341744    author      = {Thierry Delisle and Peter A. Buhr},
    1735     title       = {Concurrency in \textsf{C}$\mathbf{\forall}$},
    1736     year        = 2018,
     1745    title       = {Advanced Control-flow and Concurrency in \textsf{C}$\mathbf{\forall}$},
     1746    year        = 2019,
    17371747    journal     = spe,
    1738     pages       = {1-32},
     1748    pages       = {1-33},
    17391749    note        = {submitted},
    17401750}
    … …  
    25002510
    25012511@misc{Dotty-github,
    2502     keywords = {dotty,scala},
    2503     contributer = {a3moss@uwaterloo.ca},
    2504     author = {Martin Odersky},
    2505     title = {Dotty},
    2506     howpublished = {\href{https://github.com/lampepfl/dotty}{https://\-github.com/\-lampepfl/\-dotty}},
    2507     note = {Acessed: 2019-02-22}
     2512    keywords    = {dotty,scala},
     2513    contributer = {a3moss@uwaterloo.ca},
     2514    author      = {Martin Odersky},
     2515    title       = {Dotty},
     2516    howpublished= {\href{https://github.com/lampepfl/dotty}{https://\-github.com/\-lampepfl/\-dotty}},
     2517    note        = {Acessed: 2019-02-22}
    25082518}
    25092519
    … …  
    26562666    volume      = 10,
    26572667    number      = 3,
    2658     pages        = {120-123},
     2668    pages       = {120-123},
    26592669    comment     = {
    26602670        The ``two-pass'' algorithm.  An upward pass over a parse tree
    … …  
    32363246
    32373247@article{Leroy09,
    3238  keywords = {C formalization},
    3239  contributer = {a3moss@uwaterloo.ca},
    3240  author = {Leroy, Xavier},
    3241  title = {Formal Verification of a Realistic Compiler},
    3242  journal = {Commun. ACM},
    3243  issue_date = {July 2009},
    3244  volume = {52},
    3245  number = {7},
    3246  month = jul,
    3247  year = {2009},
    3248  issn = {0001-0782},
    3249  pages = {107--115},
    3250  numpages = {9},
    3251  url = {http://doi.acm.org/10.1145/1538788.1538814},
    3252  doi = {10.1145/1538788.1538814},
    3253  acmid = {1538814},
    3254  publisher = {ACM},
    3255  address = {New York, NY, USA},
     3248    keywords    = {C formalization},
     3249    contributer = {a3moss@uwaterloo.ca},
     3250    author      = {Leroy, Xavier},
     3251    title       = {Formal Verification of a Realistic Compiler},
     3252    journal     = {Commun. ACM},
     3253    issue_date  = {July 2009},
     3254    volume      = {52},
     3255    number      = {7},
     3256    month       = jul,
     3257    year        = {2009},
     3258    issn        = {0001-0782},
     3259    pages       = {107--115},
     3260    numpages    = {9},
     3261    url         = {http://doi.acm.org/10.1145/1538788.1538814},
     3262    doi         = {10.1145/1538788.1538814},
     3263    acmid       = {1538814},
     3264    publisher   = {ACM},
     3265    address     = {New York, NY, USA},
    32563266}
    32573267
    … …  
    41814191
    41824192@article{Morgado13,
    4183   keywords = {expression resolution},
    4184   contributer = {a3moss@uwaterloo.ca},
    4185   title={Iterative and core-guided {MaxSAT} solving: A survey and assessment},
    4186   author={Morgado, Antonio and Heras, Federico and Liffiton, Mark and Planes, Jordi and Marques-Silva, Joao},
    4187   journal={Constraints},
    4188   volume={18},
    4189   number={4},
    4190   pages={478--534},
    4191   year={2013},
    4192   publisher={Springer}
     4193    keywords    = {expression resolution},
     4194    contributer = {a3moss@uwaterloo.ca},
     4195    title       = {Iterative and core-guided {MaxSAT} solving: A survey and assessment},
     4196    author      = {Morgado, Antonio and Heras, Federico and Liffiton, Mark and Planes, Jordi and Marques-Silva, Joao},
     4197    journal     = {Constraints},
     4198    volume      = {18},
     4199    number      = {4},
     4200    pages       = {478--534},
     4201    year        = {2013},
     4202    publisher   = {Springer}
    41934203}
    41944204
    … …  
    43894399}
    43904400
    4391 
    43924401@article{Liskov86,
    43934402    keywords    = {synchronous communication, concurrency},
    … …  
    44484457
    44494458@article{Pierce00,
    4450  keywords = {Scala},
    4451  contributer = {a3moss@uwaterloo.ca},
    4452  author = {Pierce, Benjamin C. and Turner, David N.},
    4453  title = {Local Type Inference},
    4454  journal = {ACM Trans. Program. Lang. Syst.},
    4455  issue_date = {Jan. 2000},
    4456  volume = {22},
    4457  number = {1},
    4458  month = jan,
    4459  year = {2000},
    4460  issn = {0164-0925},
    4461  pages = {1--44},
    4462  numpages = {44},
    4463  url = {http://doi.acm.org/10.1145/345099.345100},
    4464  doi = {10.1145/345099.345100},
    4465  acmid = {345100},
    4466  publisher = {ACM},
    4467  address = {New York, NY, USA},
    4468  keywords = {polymorphism, subtyping, type inference},
     4459    keywords    = {Scala},
     4460    contributer = {a3moss@uwaterloo.ca},
     4461    author      = {Pierce, Benjamin C. and Turner, David N.},
     4462    title       = {Local Type Inference},
     4463    journal     = {ACM Trans. Program. Lang. Syst.},
     4464    issue_date  = {Jan. 2000},
     4465    volume      = {22},
     4466    number      = {1},
     4467    month       = jan,
     4468    year        = {2000},
     4469    issn        = {0164-0925},
     4470    pages       = {1--44},
     4471    numpages    = {44},
     4472    url         = {http://doi.acm.org/10.1145/345099.345100},
     4473    doi         = {10.1145/345099.345100},
     4474    acmid       = {345100},
     4475    publisher   = {ACM},
     4476    address     = {New York, NY, USA},
     4477    keywords    = {polymorphism, subtyping, type inference},
    44694478}
    44704479
    … …  
    54495458
    54505459@inproceedings{Krebbers14,
    5451  keywords = {c formalization},
    5452  contributer = {a3moss@uwaterloo.ca},
    5453  author = {Krebbers, Robbert},
    5454  title = {An Operational and Axiomatic Semantics for Non-determinism and Sequence Points in C},
    5455  booktitle = {Proceedings of the 41st ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages},
    5456  series = {POPL '14},
    5457  year = {2014},
    5458  isbn = {978-1-4503-2544-8},
    5459  location = {San Diego, California, USA},
    5460  pages = {101--112},
    5461  numpages = {12},
    5462  url = {http://doi.acm.org/10.1145/2535838.2535878},
    5463  doi = {10.1145/2535838.2535878},
    5464  acmid = {2535878},
    5465  publisher = {ACM},
    5466  address = {New York, NY, USA},
     5460    keywords    = {c formalization},
     5461    contributer = {a3moss@uwaterloo.ca},
     5462    author      = {Krebbers, Robbert},
     5463    title       = {An Operational and Axiomatic Semantics for Non-determinism and Sequence Points in C},
     5464    booktitle   = {Proceedings of the 41st ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages},
     5465    series      = {POPL '14},
     5466    year        = {2014},
     5467    isbn        = {978-1-4503-2544-8},
     5468    location    = {San Diego, California, USA},
     5469    pages       = {101--112},
     5470    numpages    = {12},
     5471    url         = {http://doi.acm.org/10.1145/2535838.2535878},
     5472    doi         = {10.1145/2535838.2535878},
     5473    acmid       = {2535878},
     5474    publisher   = {ACM},
     5475    address     = {New York, NY, USA},
    54675476}
    54685477
    … …  
    75317540
    75327541@article{SysVABI,
    7533   keywords = {System V ABI},
    7534   contributer = {a3moss@uwaterloo.ca},
    7535   title={System {V} application binary interface},
    7536   author={Matz, Michael and Hubicka, Jan and Jaeger, Andreas and Mitchell, Mark},
    7537   journal={AMD64 Architecture Processor Supplement, Draft v0},
    7538   volume={99},
    7539   year={2013}
     7542    keywords    = {System V ABI},
     7543    contributer = {a3moss@uwaterloo.ca},
     7544    title       = {System {V} application binary interface},
     7545    author      = {Matz, Michael and Hubicka, Jan and Jaeger, Andreas and Mitchell, Mark},
     7546    journal     = {AMD64 Architecture Processor Supplement, Draft v0},
     7547    volume      = {99},
     7548    year        = {2013}
    75407549}
    75417550
    … …  
    77647773
    77657774@techreport{Black90,
    7766   title={Typechecking polymorphism in {Emerald}},
    7767   author={Black, Andrew P and Hutchinson, Norman C},
    7768   year={1990},
    7769   institution={Cambridge Research Laboratory, Digital Equipment Corporation}
     7775    title       = {Typechecking polymorphism in {Emerald}},
     7776    author      = {Black, Andrew P and Hutchinson, Norman C},
     7777    year        = {1990},
     7778    institution = {Cambridge Research Laboratory, Digital Equipment Corporation}
    77707779}
    77717780

  • driver/Makefile.in

    r85142648 r970141d  
    231231FGREP = @FGREP@
    232232GREP = @GREP@
     233HAS_DISTCC = @HAS_DISTCC@
    233234HOST_FLAGS = @HOST_FLAGS@
    234235INSTALL = @INSTALL@

  • driver/cc1.cc

    r85142648 r970141d  
    1010// Created On       : Fri Aug 26 14:23:51 2005
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Sep  3 16:57:05 2018
    13 // Update Count     : 125
     12// Last Modified On : Mon Sep  9 17:50:53 2019
     13// Update Count     : 384
    1414//
    1515
    … …  
    1919#include <string>
    2020using std::string;
     21#include <algorithm>                                                                    // find
    2122#include <cstdio>                                                                               // stderr, stdout, perror, fprintf
    2223#include <cstdlib>                                                                              // getenv, exit, mkstemp
    2324#include <unistd.h>                                                                             // execvp, fork, unlink
    2425#include <sys/wait.h>                                                                   // wait
     26#include <fcntl.h>
     27
    2528
    2629#include "config.h"                                                                             // configure info
    … …  
    3033
    3134
    32 string compiler_name( CFA_BACKEND_CC );                                 // path/name of C compiler
    33 
    34 string D__GCC_BPREFIX__( "-D__GCC_BPREFIX__=" );
    35 string D__CFA_FLAGPREFIX__( "-D__CFA_FLAG__=" );
    36 
    37 char tmpname[] = P_tmpdir "/CFAXXXXXX";
    38 int tmpfilefd = -1;
    39 
    40 
    41 bool prefix( string arg, string pre ) {
     35static string compiler_path( CFA_BACKEND_CC );                  // C compiler path/name
     36static bool CFA_flag = false;                                                   // -CFA flag
     37static bool save_temps = false;                                                 // -save-temps flag
     38static string o_file;
     39static string bprefix;
     40
     41
     42static bool prefix( const string & arg, const string & pre ) {
    4243        return arg.substr( 0, pre.size() ) == pre;
    4344} // prefix
    4445
    45 enum { NumSuffixes = 2 };
    46 const string suffixes[NumSuffixes] = { "cfa", "hfa", };
    47 
    48 void suffix( string arg, const char * args[], int & nargs ) {
    49         //std::cerr << arg << std::endl;
     46static void suffix( const string & arg, const char * args[], int & nargs ) {
     47        enum { NumSuffixes = 3 };
     48        static const string suffixes[NumSuffixes] = { "cfa", "hfa", "ifa" };
     49
    5050        size_t dot = arg.find_last_of( "." );
    51         //std::cerr << dot << " " << (dot != string::npos ? arg.substr( dot + 1 ) : "fred" ) << std::endl;
    5251        if ( dot == string::npos ) return;
    53         string sx = arg.substr( dot + 1 );
    54         for ( int i = 0; i < NumSuffixes; i += 1 ) {
    55                 if ( sx == suffixes[i] ) {
    56                         args[nargs] = "-x";
    57                         nargs += 1;
    58                         args[nargs] = "c";
    59                         nargs += 1;
    60                         return;
    61                 } // if
    62         } // for
     52        const string * end = suffixes + NumSuffixes;
     53        if ( std::find( suffixes, end, arg.substr( dot + 1 ) ) != end ) {
     54                args[nargs++] = "-x";
     55                args[nargs++] = "c";
     56        } // if
    6357} // suffix
    6458
    6559
    66 void checkEnv( const char * args[], int & nargs ) {
    67         char *value;
    68 
    69         value = getenv( "__CFA_COMPILER__" );
    70         if ( value != NULL ) {
    71                 compiler_name = value;
    72                 #ifdef __DEBUG_H__
    73                 cerr << "env arg:\"" << compiler_name << "\"" << endl;
    74                 #endif // __DEBUG_H__
    75         } // if
    76 
    77         value = getenv( "__GCC_MACHINE__" );
    78         if ( value != NULL ) {
    79                 args[nargs] = ( *new string( value ) ).c_str(); // pass the argument along
    80                 #ifdef __DEBUG_H__
    81                 cerr << "env arg:\"" << args[nargs] << "\"" << endl;
    82                 #endif // __DEBUG_H__
    83                 nargs += 1;
    84         } // if
    85 
    86         value = getenv( "__GCC_VERSION__" );
    87         if ( value != NULL ) {
    88                 args[nargs] = ( *new string( value ) ).c_str(); // pass the argument along
    89                 #ifdef __DEBUG_H__
    90                 cerr << "env arg:\"" << args[nargs] << "\"" << endl;
    91                 #endif // __DEBUG_H__
    92                 nargs += 1;
    93         } // if
    94 } // checkEnv
    95 
    96 
    97 void rmtmpfile() {
     60static string __CFA_FLAGPREFIX__( "__CFA_FLAG" );               // "N__=" suffix
     61
     62static void checkEnv1( const char * args[], int & nargs ) { // stage 1
     63        extern char ** environ;
     64
     65        for ( int i = 0; environ[i]; i += 1 ) {
     66                string arg( environ[i] );
     67                #ifdef __DEBUG_H__
     68                cerr << "env arg:\"" << arg << "\"" << endl;
     69                #endif // __DEBUG_H__
     70
     71                if ( prefix( arg, __CFA_FLAGPREFIX__ ) ) {
     72                        string val( arg.substr( arg.find_first_of( "=" ) + 1 ) );
     73                        if ( prefix( val, "-compiler=" ) ) {
     74                                compiler_path = val.substr( 10 );
     75                        } // if
     76                } // if
     77        } // for
     78} // checkEnv1
     79
     80
     81static void checkEnv2( const char * args[], int & nargs ) { // stage 2
     82        extern char ** environ;
     83
     84        for ( int i = 0; environ[i]; i += 1 ) {
     85                string arg( environ[i] );
     86                #ifdef __DEBUG_H__
     87                cerr << "env arg:\"" << arg << "\"" << endl;
     88                #endif // __DEBUG_H__
     89
     90                if ( prefix( arg, __CFA_FLAGPREFIX__ ) ) {
     91                        string val( arg.substr( arg.find_first_of( "=" ) + 1 ) );
     92                        if ( prefix( val, "-compiler=" ) ) {
     93                                compiler_path = val.substr( 10 );
     94                        } else if ( val == "-CFA" ) {
     95                                CFA_flag = true;
     96                        } else if ( val == "-save-temps" ) {
     97                                save_temps = true;
     98                        } else if ( prefix( val, "-o=" ) ) {            // output file for -CFA
     99                                o_file = val.substr( 3 );
     100                        } else if ( prefix( val, "-B=" ) ) {            // location of cfa-cpp
     101                                bprefix = val.substr( 3 );
     102                        } else {                                                                        // normal flag for cfa-cpp
     103                                args[nargs++] = ( *new string( arg.substr( arg.find_first_of( "=" ) + 1 ) ) ).c_str();
     104                        } // if
     105                } // if
     106        } // for
     107} // checkEnv2
     108
     109
     110static char tmpname[] = P_tmpdir "/CFAXXXXXX.ifa";
     111static int tmpfilefd = -1;
     112static bool startrm = false;
     113
     114static void rmtmpfile() {
     115        if ( tmpfilefd == -1 ) return;                                          // RACE, file created ?
     116
     117        startrm = true;                                                                         // RACE with C-c C-c
    98118        if ( unlink( tmpname ) == -1 ) {                                        // remove tmpname
    99                 perror ( "CFA Translator error: cpp failed" );
    100                 exit( EXIT_FAILURE );
    101         } // if
    102         tmpfilefd = -1;                                                                         // mark closed
     119                perror ( "CC1 Translator error: failed, unlink" );
     120                exit( EXIT_FAILURE );
     121        } // if
     122        tmpfilefd = -1;                                                                         // mark removed
    103123} // rmtmpfile
    104124
    105125
    106 void sigTermHandler( __attribute__((unused)) int signal ) {
     126static void sigTermHandler( int ) {                                             // C-c C-c
     127        if ( startrm ) return;                                                          // return and let rmtmpfile finish, and then program finishes
     128
    107129        if ( tmpfilefd != -1 ) {                                                        // RACE, file created ?
    108                 rmtmpfile();                                                                    // remove
    109                 exit( EXIT_FAILURE );                                                   // terminate
    110         } // if
     130                rmtmpfile();                                                                    // remove tmpname
     131        } // if
     132        exit( EXIT_FAILURE );                                                           // terminate
    111133} // sigTermHandler
    112134
    113135
    114 void Stage1( const int argc, const char * const argv[] ) {
     136static void Stage1( const int argc, const char * const argv[] ) {
    115137        int code;
    116 
    117138        string arg;
    118         string bprefix;
    119 
    120         const char *cpp_in = NULL;
    121         const char *cpp_out = NULL;
    122 
    123         bool CFA_flag = false;
     139
     140        const char * cpp_in = nullptr;
     141        const char * cpp_out = nullptr;
     142
    124143        bool cpp_flag = false;
    125         const char *o_name = NULL;
    126 
    127         const char *args[argc + 100];                                           // leave space for 100 additional cpp command line values
     144        bool o_flag = false;
     145
     146        const char * args[argc + 100];                                          // leave space for 100 additional cpp command line values
    128147        int nargs = 1;                                                                          // number of arguments in args list; 0 => command name
    129         const char *cargs[20];                                                          // leave space for 20 additional cfa-cpp command line values
    130         int ncargs = 1;                                                                         // 0 => command name
    131 
    132         signal( SIGINT,  sigTermHandler );
    133         signal( SIGTERM, sigTermHandler );
    134148
    135149        #ifdef __DEBUG_H__
    136150        cerr << "Stage1" << endl;
    137151        #endif // __DEBUG_H__
    138         checkEnv( args, nargs );                                                        // arguments passed via environment variables
     152        checkEnv1( args, nargs );                                                       // arguments passed via environment variables
    139153        #ifdef __DEBUG_H__
    140154        for ( int i = 1; i < argc; i += 1 ) {
    … …  
    168182                                i += 1;                                                                 // and the argument
    169183                                cpp_flag = true;
    170                         } else if ( arg == "-D__CFA_PREPROCESS__" ) {
    171                                 CFA_flag = true;
    172                         } else if ( arg == "-D" && string( argv[i + 1] ) == "__CFA_PREPROCESS__" ) {
    173                                 i += 1;                                                                 // and the argument
    174                                 CFA_flag = true;
    175                         } else if ( prefix( arg, D__CFA_FLAGPREFIX__ ) ) {
    176                                 cargs[ncargs] = ( *new string( arg.substr( D__CFA_FLAGPREFIX__.size() ) ) ).c_str();
    177                                 ncargs += 1;
    178                         } else if ( arg == "-D" && prefix( argv[i + 1], D__CFA_FLAGPREFIX__.substr(2) ) ) {
    179                                 cargs[ncargs] = ( *new string( string( argv[i + 1] ).substr( D__CFA_FLAGPREFIX__.size() - 2 ) ) ).c_str();
    180                                 ncargs += 1;
    181                                 i += 1;                                                                 // and the argument
    182                         } else if ( prefix( arg, D__GCC_BPREFIX__ ) ) {
    183                                 bprefix = arg.substr( D__GCC_BPREFIX__.size() );
    184                         } else if ( arg == "-D" && prefix( argv[i + 1], D__GCC_BPREFIX__.substr(2) ) ) {
    185                                 bprefix = string( argv[i + 1] ).substr( D__GCC_BPREFIX__.size() - 2 );
    186                                 i += 1;                                                                 // and the argument
    187 
    188                         // all other flags
     184
     185                                // all other flags
    189186
    190187                        } else if ( arg == "-o" ) {
    191188                                i += 1;
    192                                 o_name = argv[i];
     189                                o_flag = true;
     190                                cpp_out = argv[i];
    193191                        } else {
    194                                 args[nargs] = argv[i];                                  // pass the flag along
    195                                 nargs += 1;
     192                                args[nargs++] = argv[i];                                // pass the flag along
    196193                                // CPP flags with an argument
    197194                                if ( arg == "-D" || arg == "-U" || arg == "-I" || arg == "-MF" || arg == "-MT" || arg == "-MQ" ||
    … …  
    199196                                         arg == "-iwithprefix" || arg == "-iwithprefixbefore" || arg == "-isystem" || arg == "-isysroot" ) {
    200197                                        i += 1;
    201                                         args[nargs] = argv[i];                          // pass the argument along
    202                                         nargs += 1;
     198                                        args[nargs++] = argv[i];                        // pass the argument along
    203199                                        #ifdef __DEBUG_H__
    204200                                        cerr << "argv[" << i << "]:\"" << argv[i] << "\"" << endl;
    205201                                        #endif // __DEBUG_H__
    206202                                } else if ( arg == "-MD" || arg == "-MMD" ) {
    207                                         args[nargs] = "-MF";                            // insert before file
    208                                         nargs += 1;
     203                                        args[nargs++] = "-MF";                          // insert before file
    209204                                        i += 1;
    210                                         args[nargs] = argv[i];                          // pass the argument along
    211                                         nargs += 1;
     205                                        args[nargs++] = argv[i];                        // pass the argument along
    212206                                        #ifdef __DEBUG_H__
    213207                                        cerr << "argv[" << i << "]:\"" << argv[i] << "\"" << endl;
    … …  
    216210                        } // if
    217211                } else {                                                                                // obtain input and possibly output files
    218                         if ( cpp_in == NULL ) {
     212                        if ( cpp_in == nullptr ) {
    219213                                cpp_in = argv[i];
    220214                                #ifdef __DEBUG_H__
    221215                                cerr << "cpp_in:\"" << cpp_in << "\"" << endl;
    222216                                #endif // __DEBUG_H__
    223                         } else if ( cpp_out == NULL ) {
     217                        } else if ( cpp_out == nullptr ) {
    224218                                cpp_out = argv[i];
    225219                                #ifdef __DEBUG_H__
    … …  
    238232                cerr << " " << args[i];
    239233        } // for
    240         if ( cpp_in != NULL ) cerr << " " << cpp_in;
    241         if ( cpp_out != NULL ) cerr << " " << cpp_out;
     234        if ( cpp_in != nullptr ) cerr << " " << cpp_in;
     235        if ( cpp_out != nullptr ) cerr << " " << cpp_out;
    242236        cerr << endl;
    243237        #endif // __DEBUG_H__
    244238
    245         if ( cpp_in == NULL ) {
     239        if ( cpp_in == nullptr ) {
    246240                cerr << "Usage: " << argv[0] << " input-file [output-file] [options]" << endl;
    247241                exit( EXIT_FAILURE );
    … …  
    252246                // output or -o. The call to cfa has a -E so it does not have to be added to the argument list.
    253247
    254                 args[0] = compiler_name.c_str();
     248                args[0] = compiler_path.c_str();
    255249                suffix( cpp_in, args, nargs );                                  // check suffix
    256                 args[nargs] = cpp_in;
    257                 nargs += 1;
    258                 if ( o_name != NULL ) {                                                 // location for output
    259                         args[nargs] = "-o";
    260                         nargs += 1;
    261                         args[nargs] = o_name;
    262                         nargs += 1;
    263                 } // if
    264                 args[nargs] = NULL;                                                             // terminate argument list
     250                args[nargs++] = cpp_in;
     251                if ( o_flag ) {                                                                 // location for output
     252                        args[nargs++] = "-o";
     253                } // if
     254                args[nargs++] = cpp_out;
     255                args[nargs] = nullptr;                                                  // terminate argument list
    265256
    266257                #ifdef __DEBUG_H__
    267258                cerr << "nargs: " << nargs << endl;
    268                 for ( int i = 0; args[i] != NULL; i += 1 ) {
     259                for ( int i = 0; args[i] != nullptr; i += 1 ) {
    269260                        cerr << args[i] << " ";
    270261                } // for
    … …  
    272263                #endif // __DEBUG_H__
    273264
    274                 execvp( args[0], (char *const *)args );                 // should not return
    275                 perror( "CFA Translator error: cpp level, execvp" );
    276                 exit( EXIT_FAILURE );
    277         } // if
    278 
    279         // Create a temporary file to store output of the C preprocessor.
    280 
    281         tmpfilefd = mkstemp( tmpname );
    282         if ( tmpfilefd == -1 ) {
    283                 perror( "CFA Translator error: cpp level, mkstemp" );
    284                 exit( EXIT_FAILURE );
    285         } // if
    286 
    287         #ifdef __DEBUG_H__
    288         cerr << "tmpname:" << tmpname << " tmpfilefd:" << tmpfilefd << endl;
    289         #endif // __DEBUG_H__
    290 
    291         // Run the C preprocessor and save the output in tmpfile.
     265                execvp( args[0], (char * const *)args );                // should not return
     266                perror( "CC1 Translator error: stage 1, execvp" );
     267                exit( EXIT_FAILURE );
     268        } // if
     269
     270        // Run the C preprocessor and save the output in the given file.
    292271
    293272        if ( fork() == 0 ) {                                                             // child process ?
    … …  
    295274                // an error (e.g., cannot find include file). Whereas, output is always generated, even when there is an error,
    296275                // when cpp writes to stdout. Hence, stdout is redirected into the temporary file.
    297                 if ( freopen( tmpname, "w", stdout ) == NULL ) { // redirect stdout to tmpname
    298                         perror( "CFA Translator error: cpp level, freopen" );
     276                if ( freopen( cpp_out, "w", stdout ) == nullptr ) { // redirect stdout to output file
     277                        perror( "CC1 Translator error: stage 1, freopen" );
    299278                        exit( EXIT_FAILURE );
    300279                } // if
    301280
    302                 args[0] = compiler_name.c_str();
     281                args[0] = compiler_path.c_str();
    303282                suffix( cpp_in, args, nargs );                                  // check suffix
    304                 args[nargs] = cpp_in;                                                   // input to cpp
    305                 nargs += 1;
    306                 args[nargs] = NULL;                                                             // terminate argument list
     283                args[nargs++] = cpp_in;                                                 // input to cpp
     284                args[nargs] = nullptr;                                                  // terminate argument list
    307285
    308286                #ifdef __DEBUG_H__
    309287                cerr << "cpp nargs: " << nargs << endl;
    310                 for ( int i = 0; args[i] != NULL; i += 1 ) {
     288                for ( int i = 0; args[i] != nullptr; i += 1 ) {
    311289                        cerr << args[i] << " ";
    312290                } // for
    … …  
    314292                #endif // __DEBUG_H__
    315293
    316                 execvp( args[0], (char *const *)args );                 // should not return
    317                 perror( "CFA Translator error: cpp level, execvp" );
     294                execvp( args[0], (char * const *)args );                // should not return
     295                perror( "CC1 Translator error: stage 1 cpp, execvp" );
     296                cerr << " invoked " << args[0] << endl;
    318297                exit( EXIT_FAILURE );
    319298        } // if
    … …  
    325304        #endif // __DEBUG_H__
    326305
    327         if ( WIFSIGNALED(code) != 0 ) {                                         // child failed ?
    328                 rmtmpfile();                                                                    // remove tmpname
    329                 cerr << "CFA Translator error: cpp failed with signal " << WTERMSIG(code) << endl;
    330                 exit( EXIT_FAILURE );
    331         } // if
    332 
    333         if ( WEXITSTATUS(code) != 0 ) {                                         // child error ?
    334                 rmtmpfile();                                                                    // remove tmpname
    335                 exit( WEXITSTATUS( code ) );                                    // do not continue
    336         } // if
    337 
    338         // If -CFA flag specified, run the cfa-cpp preprocessor on the temporary file, and output is written to standard
    339         // output.  Otherwise, run the cfa-cpp preprocessor on the temporary file and save the result into the output file.
    340 
    341         if ( fork() == 0 ) {                                                            // child runs CFA
    342                 cargs[0] = ( *new string( bprefix + "cfa-cpp" ) ).c_str();
    343 
    344                 // Source file-name used to generate routine names containing global initializations for TU.
    345                 cargs[ncargs] = ( *new string( "-F" ) ).c_str();
    346                 ncargs += 1;
    347                 cargs[ncargs] = ( *new string( string( cpp_in ) ) ).c_str();
    348                 ncargs += 1;
    349 
    350                 cargs[ncargs] = tmpname;
    351                 ncargs += 1;
    352                 if ( o_name != NULL ) {
    353                         cargs[ncargs] = o_name;
    354                         ncargs += 1;
    355                 } else if ( ! CFA_flag ) {                                              // run cfa-cpp ?
    356                         cargs[ncargs] = cpp_out;
    357                         ncargs += 1;
    358                 } // if
    359                 cargs[ncargs] = NULL;                                                   // terminate argument list
    360 
    361                 #ifdef __DEBUG_H__
    362                 cerr << "cfa-cpp ncargs: " << (o_name ? o_name : "No -o") << " " << CFA_flag << " " << ncargs << endl;
    363                 for ( int i = 0; cargs[i] != NULL; i += 1 ) {
    364                         cerr << cargs[i] << " ";
    365                 } // for
    366                 cerr << endl;
    367                 #endif // __DEBUG_H__
    368 
    369                 execvp( cargs[0], (char * const *)cargs );              // should not return
    370                 perror( "CFA Translator error: cpp level, execvp" );
    371                 exit( EXIT_FAILURE );
    372         } // if
    373 
    374         wait( &code );                                                                          // wait for child to finish
    375 
    376         #ifdef __DEBUG_H__
    377         cerr << "return code from cfa-cpp:" << WEXITSTATUS(code) << endl;
    378         #endif // __DEBUG_H__
    379 
    380         // Must unlink here because file must exist across execvp.
    381         rmtmpfile();                                                                            // remove tmpname
    382 
    383306        if ( WIFSIGNALED(code) ) {                                                      // child failed ?
    384                 cerr << "CFA Translator error: cfa-cpp failed with signal " << WTERMSIG(code) << endl;
    385                 exit( EXIT_FAILURE );
    386         } // if
    387 
    388         exit( WEXITSTATUS(code) );
     307                cerr << "CC1 Translator error: stage 1, child failed " << WTERMSIG(code) << endl;
     308                exit( EXIT_FAILURE );
     309        } // if
     310
     311        exit( WEXITSTATUS(code) );                                                      // bad cpp result stops top-level gcc
    389312} // Stage1
    390313
    391314
    392 void Stage2( const int argc, const char * const * argv ) {
     315static void Stage2( const int argc, const char * const * argv ) {
     316        int code;
    393317        string arg;
    394318
    395         const char *cpp_in = NULL;
    396 
    397         const char *args[argc + 100];                                           // leave space for 100 additional cfa command line values
     319        const char * cpp_in = nullptr;
     320        const char * cpp_out = nullptr;
     321
     322        const char * args[argc + 100];                                          // leave space for 100 additional cfa command line values
    398323        int nargs = 1;                                                                          // number of arguments in args list; 0 => command name
     324        const char * cargs[20];                                                         // leave space for 20 additional cfa-cpp command line values
     325        int ncargs = 1;                                                                         // 0 => command name
    399326
    400327        #ifdef __DEBUG_H__
    401328        cerr << "Stage2" << endl;
    402329        #endif // __DEBUG_H__
    403         checkEnv( args, nargs );                                                        // arguments passed via environment variables
     330        checkEnv2( cargs, ncargs );                                                     // arguments passed via environment variables
    404331        #ifdef __DEBUG_H__
    405332        for ( int i = 1; i < argc; i += 1 ) {
    … …  
    430357
    431358                        } else {
    432                                 args[nargs] = argv[i];                                  // pass the flag along
    433                                 nargs += 1;
     359                                args[nargs++] = argv[i];                                // pass the flag along
    434360                                if ( arg == "-o" ) {
    435361                                        i += 1;
    436                                         args[nargs] = argv[i];                          // pass the argument along
    437                                         nargs += 1;
     362                                        cpp_out = argv[i];
     363                                        args[nargs++] = argv[i];                        // pass the argument along
    438364                                        #ifdef __DEBUG_H__
    439365                                        cerr << "arg:\"" << argv[i] << "\"" << endl;
    … …  
    442368                        } // if
    443369                } else {                                                                                // obtain input and possibly output files
    444                         if ( cpp_in == NULL ) {
     370                        if ( cpp_in == nullptr ) {
    445371                                cpp_in = argv[i];
    446372                                #ifdef __DEBUG_H__
    447373                                cerr << "cpp_in:\"" << cpp_in << "\"" << endl;
    448374                                #endif // __DEBUG_H__
     375                        } else if ( cpp_out == nullptr ) {
     376                                cpp_out = argv[i];
     377                                #ifdef __DEBUG_H__
     378                                cerr << "cpp_out:\"" << cpp_out << "\""<< endl;
     379                                #endif // __DEBUG_H__
    449380                        } else {
    450                                 cerr << "Usage: " << argv[0] << " input-file [output-file] [options]" << endl;
     381                                cerr << "Usage: " << argv[0] << " more than two files specified" << endl;
    451382                                exit( EXIT_FAILURE );
    452383                        } // if
    453384                } // if
    454385        } // for
     386
     387        if ( cpp_in == nullptr ) {
     388                cerr << "Usage: " << argv[0] << " missing input file" << endl;
     389                exit( EXIT_FAILURE );
     390        } // if
     391        if ( cpp_out == nullptr ) {
     392                cerr << "Usage: " << argv[0] << " missing output file" << endl;
     393                exit( EXIT_FAILURE );
     394        } // if
     395
     396        // Create a temporary file, if needed, to store output of the cfa-cpp preprocessor. Cannot be created in forked
     397        // process because variables tmpname and tmpfilefd are cloned.
     398
     399        string cfa_cpp_out;
     400
     401        if ( ! CFA_flag ) {                                                                     // run compiler ?
     402                if ( save_temps ) {
     403                        cfa_cpp_out = cpp_in;
     404                        size_t dot = cfa_cpp_out.find_last_of( "." );
     405                        if ( dot == string::npos ) {
     406                                cerr << "CC1 Translator error: stage 2, bad file name " << endl;
     407                                exit( EXIT_FAILURE );
     408                        } // if
     409
     410                        cfa_cpp_out = cfa_cpp_out.substr( 0, dot ) + ".ifa";
     411                        if ( creat( cfa_cpp_out.c_str(), 0666 ) == -1 ) {
     412                                perror( "CC1 Translator error: stage 2, creat" );
     413                                exit( EXIT_FAILURE );
     414                        } // if
     415                } else {
     416                        tmpfilefd = mkstemps( tmpname, 4 );
     417                        if ( tmpfilefd == -1 ) {
     418                                perror( "CC1 Translator error: stage 2, mkstemp" );
     419                                exit( EXIT_FAILURE );
     420                        } // if
     421                        cfa_cpp_out = tmpname;
     422                } // if
     423                #ifdef __DEBUG_H__
     424                cerr << "cfa_cpp_out: " << cfa_cpp_out << endl;
     425                #endif // __DEBUG_H__
     426        } // if
     427
     428        // If -CFA flag specified, run the cfa-cpp preprocessor on the temporary file, and output is written to standard
     429        // output.  Otherwise, run the cfa-cpp preprocessor on the temporary file and save the result into the output file.
     430
     431        if ( fork() == 0 ) {                                                            // child runs CFA
     432                cargs[0] = ( *new string( bprefix + "cfa-cpp" ) ).c_str();
     433                cargs[ncargs++] = cpp_in;
     434
     435                if ( CFA_flag ) {                                                               // run cfa-cpp ?
     436                        if ( o_file.size() != 0 ) {                                     // location for output
     437                                cargs[ncargs++] = ( *new string( o_file.c_str() ) ).c_str();
     438                        } // if
     439                } else {
     440                        cargs[ncargs++] = cfa_cpp_out.c_str();
     441                } // if
     442                cargs[ncargs] = nullptr;                                                // terminate argument list
     443
     444                #ifdef __DEBUG_H__
     445                for ( int i = 0; cargs[i] != nullptr; i += 1 ) {
     446                        cerr << cargs[i] << " ";
     447                } // for
     448                cerr << endl;
     449                #endif // __DEBUG_H__
     450
     451                execvp( cargs[0], (char * const *)cargs );              // should not return
     452                perror( "CC1 Translator error: stage 2 cfa-cpp, execvp" );
     453                cerr << " invoked " << cargs[0] << endl;
     454                exit( EXIT_FAILURE );
     455        } // if
     456
     457        wait( &code );                                                                          // wait for child to finish
     458
     459        if ( WIFSIGNALED(code) ) {                                                      // child failed ?
     460                rmtmpfile();                                                                    // remove tmpname
     461                cerr << "CC1 Translator error: stage 2, child failed " << WTERMSIG(code) << endl;
     462                exit( EXIT_FAILURE );
     463        } // if
     464
     465        if ( CFA_flag ) {                                                                       // no tmpfile created
     466                exit( WEXITSTATUS( code ) );                                    // stop regardless of success or failure
     467        } // if
     468
     469        #ifdef __DEBUG_H__
     470        cerr << "return code from cfa-cpp:" << WEXITSTATUS(code) << endl;
     471        #endif // __DEBUG_H__
     472
     473        if ( WEXITSTATUS(code) ) {                                                      // child error ?
     474                rmtmpfile();                                                                    // remove tmpname
     475                exit( WEXITSTATUS( code ) );                                    // do not continue
     476        } // if
    455477
    456478        #ifdef __DEBUG_H__
    … …  
    459481                cerr << " " << args[i];
    460482        } // for
    461         cerr << endl;
    462         if ( cpp_in != NULL ) cerr << " " << cpp_in;
    463         #endif // __DEBUG_H__
    464 
    465         args[0] = compiler_name.c_str();
    466         args[nargs] = "-S";                                                                     // only compile and put assembler output in specified file
    467         nargs += 1;
    468         args[nargs] = cpp_in;
    469         nargs += 1;
    470         args[nargs] = NULL;                                                                     // terminate argument list
    471 
    472         #ifdef __DEBUG_H__
    473         cerr << "stage2 nargs: " << nargs << endl;
    474         for ( int i = 0; args[i] != NULL; i += 1 ) {
    475                 cerr << args[i] << " ";
    476         } // for
    477         cerr << endl;
    478         #endif // __DEBUG_H__
    479 
    480         execvp( args[0], (char * const *)args );                        // should not return
    481         perror( "CFA Translator error: cpp level, execvp" );
    482         exit( EXIT_FAILURE );                                                           // tell gcc not to go any further
     483        cerr << " " << cpp_in << endl;
     484        #endif // __DEBUG_H__
     485
     486        if ( fork() == 0 ) {                                                            // child runs CFA
     487                args[0] = compiler_path.c_str();
     488                args[nargs++] = "-S";                                                   // only compile and put assembler output in specified file
     489                args[nargs++] = "-x";
     490                args[nargs++] = "cpp-output";
     491
     492                args[nargs++] = cfa_cpp_out.c_str();
     493                args[nargs] = nullptr;                                                  // terminate argument list
     494
     495                #ifdef __DEBUG_H__
     496                cerr << "stage2 nargs: " << nargs << endl;
     497                for ( int i = 0; args[i] != nullptr; i += 1 ) {
     498                        cerr << args[i] << " ";
     499                } // for
     500                cerr << endl;
     501                #endif // __DEBUG_H__
     502
     503                execvp( args[0], (char * const *)args );                // should not return
     504                perror( "CC1 Translator error: stage 2 cc1, execvp" );
     505                cerr << " invoked " << cargs[0] << endl;
     506                exit( EXIT_FAILURE );                                                   // tell gcc not to go any further
     507        } // if
     508
     509        wait( &code );                                                                          // wait for child to finish
     510        rmtmpfile();                                                                            // remove tmpname
     511
     512        if ( WIFSIGNALED(code) ) {                                                      // child failed ?
     513                cerr << "CC1 Translator error: stage 2, child failed " << WTERMSIG(code) << endl;
     514                exit( EXIT_FAILURE );
     515        } // if
     516
     517        #ifdef __DEBUG_H__
     518        cerr << "return code from gcc cc1:" << WEXITSTATUS(code) << endl;
     519        #endif // __DEBUG_H__
     520
     521        exit( WEXITSTATUS( code ) );                                            // stop regardless of success or failure
    483522} // Stage2
    484523
    485524
     525// This program is called twice because of the -no-integrated-cpp. The calls are differentiated by the first
     526// command-line argument. The first call replaces the traditional cpp pass to preprocess the C program. The second call
     527// is to the compiler, which is broken into two steps: preprocess again with cfa-cpp and then call gcc to compile the
     528// doubly preprocessed program.
     529
    486530int main( const int argc, const char * const argv[], __attribute__((unused)) const char * const env[] ) {
    487531        #ifdef __DEBUG_H__
    488         for ( int i = 0; env[i] != NULL; i += 1 ) {
     532        for ( int i = 0; env[i] != nullptr; i += 1 ) {
    489533                cerr << env[i] << endl;
    490534        } // for
    491535        #endif // __DEBUG_H__
    492536
    493         string arg = argv[1];
     537        signal( SIGINT,  sigTermHandler );
     538        signal( SIGTERM, sigTermHandler );
     539
     540        string arg( argv[1] );
    494541
    495542        // Currently, stage 1 starts with flag -E and stage 2 with flag -fpreprocessed.

  • driver/cfa.cc

    r85142648 r970141d  
    1010// Created On       : Tue Aug 20 13:44:49 2002
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Aug 10 08:44:15 2019
    13 // Update Count     : 311
     12// Last Modified On : Tue Sep 10 17:00:15 2019
     13// Update Count     : 420
    1414//
    1515
    … …  
    2828#include "config.h"                                                                             // configure info
    2929
    30 
    3130using std::cerr;
    3231using std::endl;
    … …  
    3433using std::to_string;
    3534
    36 
    37 //#define __DEBUG_H__
    38 
    39 
    40 bool prefix( string arg, string pre ) {
     35// #define __DEBUG_H__
     36
     37static string __CFA_FLAGPREFIX__( "__CFA_FLAG" );               // "N__=" suffix
     38
     39void Putenv( char * argv[], string arg ) {
     40        // environment variables must have unique names
     41        static int flags = 0;
     42
     43        if ( putenv( (char *)( *new string( string( __CFA_FLAGPREFIX__ + to_string( flags++ ) + "__=" ) + arg ) ).c_str() ) ) {
     44                cerr << argv[0] << " error, cannot set environment variable." << endl;
     45                exit( EXIT_FAILURE );
     46        } // if
     47} // Putenv
     48
     49// check if string has prefix
     50bool prefix( const string & arg, const string & pre ) {
    4151        return arg.substr( 0, pre.size() ) == pre;
    4252} // prefix
    4353
    44 bool suffix( string arg ) {
     54inline bool ends_with(const string & str, const string & sfix) {
     55        if (sfix.size() > str.size()) return false;
     56        return std::equal(str.rbegin(), str.rbegin() + sfix.size(), sfix.rbegin(), sfix.rend());
     57}
     58
     59bool suffix( const string & arg ) {                                             // check if string has suffix
    4560        enum { NumSuffixes = 3 };
    4661        static const string suffixes[NumSuffixes] = { "cfa", "hfa", "ifa" };
    47         //std::cerr << arg << std::endl;
     62
    4863        size_t dot = arg.find_last_of( "." );
    49         //std::cerr << dot << " " << (dot != string::npos ? arg.substr( dot + 1 ) : "fred" ) << std::endl;
    5064        if ( dot == string::npos ) return false;
    5165        const string * end = suffixes + NumSuffixes;
    … …  
    5468
    5569
    56 void shuffle( const char * args[], int S, int E, int N ) {
    57         // S & E index 1 passed the end so adjust with -1
    58         #ifdef __DEBUG_H__
    59         cerr << "shuffle:" << S << " " << E << " " << N << endl;
    60         #endif // __DEBUG_H__
    61         for ( int j = E-1 + N; j > S-1 + N; j -=1 ) {
    62                 #ifdef __DEBUG_H__
    63                 cerr << "\t" << j << " " << j-N << endl;
    64                 #endif // __DEBUG_H__
    65                 args[j] = args[j-N];
    66         } // for
    67 } // shuffle
    68 
    69 static inline bool dirExists( const string & path ) {
     70static inline bool dirExists( const string & path ) {   // check if directory exists
    7071    struct stat info;
    71     if(stat( path.c_str(), &info ) != 0)
    72         return false;
    73     else if(info.st_mode & S_IFDIR)
    74         return true;
    75     else
    76         return false;
    77 } //dirExists
    78 
    79 
     72    if ( stat( path.c_str(), &info ) != 0 ) return false;
     73        return (info.st_mode & S_IFDIR) != 0;
     74} // dirExists
     75
     76static inline string dir(const string & path) {
     77        return path.substr(0, path.find_last_of('/'));
     78}
     79
     80
     81#define xstr(s) str(s)
    8082#define str(s) #s
    8183
    8284int main( int argc, char * argv[] ) {
    8385        string Version( CFA_VERSION_LONG );                                     // current version number from CONFIG
    84         string Major( str( CFA_VERSION_MAJOR ) ), Minor( str( CFA_VERSION_MINOR ) ), Patch( str( CFA_VERSION_PATCH ) );
     86        string Major( xstr( CFA_VERSION_MAJOR ) ), Minor( xstr( CFA_VERSION_MINOR ) ), Patch( xstr( CFA_VERSION_PATCH ) );
    8587
    8688        string installincdir( CFA_INCDIR );                                     // fixed location of include files
    … …  
    9092        string heading;                                                                         // banner printed at start of cfa compilation
    9193        string arg;                                                                                     // current command-line argument during command-line parsing
    92         string Bprefix;                                                                         // path where gcc looks for compiler command steps
     94        string bprefix;                                                                         // path where gcc looks for compiler steps
    9395        string langstd;                                                                         // language standard
    9496
    … …  
    9799
    98100        bool x_flag = false;                                                            // -x flag
    99         bool nonoptarg = false;                                                         // indicates non-option argument specified
    100         bool link = true;                                                                       // linking as well as compiling
     101        bool nonoptarg = false;                                                         // no non-option arguments specified, i.e., no file names
     102        bool link = true;                                                                       // link stage occurring
    101103        bool verbose = false;                                                           // -v flag
    102104        bool quiet = false;                                                                     // -quiet flag
    … …  
    111113        bool m32 = false;                                                                       // -m32 flag
    112114        bool m64 = false;                                                                       // -m64 flag
    113         bool intree = false;
     115        bool intree = false;                                                            // build in tree
     116        bool compiling_libs = false;
     117        bool disttree = false;
     118        int o_file = 0;                                                                         // -o filename position
    114119
    115120        const char *args[argc + 100];                                           // cfa command line values, plus some space for additional flags
    … …  
    135140
    136141                        if ( arg == "-Xlinker" || arg == "-o" ) {
    137                                 args[nargs] = argv[i];                                  // pass the argument along
    138                                 nargs += 1;
     142                                args[nargs++] = argv[i];                                // pass argument along
    139143                                i += 1;
    140144                                if ( i == argc ) continue;                              // next argument available ?
    141                                 args[nargs] = argv[i];                                  // pass the argument along
    142                                 nargs += 1;
     145                                args[nargs++] = argv[i];                                // pass argument along
     146                                if ( arg == "-o" ) o_file = i;                  // remember file
    143147                        } else if ( arg == "-XCFA" ) {                          // CFA pass through
    144148                                i += 1;
    145                                 args[nargs] = ( *new string( string("-D__CFA_FLAG__=") + argv[i] ) ).c_str();
    146                                 nargs += 1;
     149                                Putenv( argv, argv[i] );
    147150
    148151                                // CFA specific arguments
    … …  
    151154                                CFA_flag = true;                                                // strip the -CFA flag
    152155                                link = false;
    153                                 args[nargs] = "-E";                                             // replace the argument with -E
    154                                 nargs += 1;
     156                                args[nargs++] = "-fsyntax-only";                // stop after stage 2
    155157                        } else if ( arg == "-debug" ) {
    156158                                debug = true;                                                   // strip the debug flag
    157159                        } else if ( arg == "-nodebug" ) {
    158                                 debug = false;                                                  // strip the debug flag
     160                                debug = false;                                                  // strip the nodebug flag
    159161                        } else if ( arg == "-nolib" ) {
    160162                                nolib = true;                                                   // strip the nodebug flag
    … …  
    171173                        } else if ( arg == "-in-tree" ) {
    172174                                intree = true;
     175                        } else if ( arg == "-dist-tree" ) {
     176                                disttree = true;
     177                        } else if ( arg == "-cfalib") {
     178                                compiling_libs = true;
    173179                        } else if ( arg == "-compiler" ) {
    174180                                // use the user specified compiler
    … …  
    176182                                if ( i == argc ) continue;                              // next argument available ?
    177183                                compiler_path = argv[i];
    178                                 if ( putenv( (char *)( *new string( string( "__CFA_COMPILER__=" ) + argv[i]) ).c_str() ) != 0 ) {
    179                                         cerr << argv[0] << " error, cannot set environment variable." << endl;
    180                                         exit( EXIT_FAILURE );
    181                                 } // if
     184                                Putenv( argv, arg + "=" + argv[i] );
    182185
    183186                                // C specific arguments
    … …  
    185188                        } else if ( arg == "-v" ) {
    186189                                verbose = true;                                                 // verbosity required
    187                                 args[nargs] = argv[i];                                  // pass the argument along
    188                                 nargs += 1;
     190                                args[nargs++] = argv[i];                                // pass argument along
    189191                        } else if ( arg == "-g" ) {
    190192                                debugging = true;                                               // symbolic debugging required
    191                                 args[nargs] = argv[i];                                  // pass the argument along
    192                                 nargs += 1;
     193                                args[nargs++] = argv[i];                                // pass argument along
     194                        } else if ( arg == "-save-temps" ) {
     195                                args[nargs++] = argv[i];                                // pass argument along
     196                                Putenv( argv, arg );                                    // save cfa-cpp output
    193197                        } else if ( prefix( arg, "-x" ) ) {                     // file suffix ?
    194198                                string lang;
    195                                 args[nargs] = argv[i];                                  // pass the argument along
    196                                 nargs += 1;
     199                                args[nargs++] = argv[i];                                // pass argument along
    197200                                if ( arg.length() == 2 ) {                              // separate argument ?
    198201                                        i += 1;
    199202                                        if ( i == argc ) continue;                      // next argument available ?
    200203                                        lang = argv[i];
    201                                         args[nargs] = argv[i];                          // pass the argument along
    202                                         nargs += 1;
     204                                        args[nargs++] = argv[i];                        // pass argument along
    203205                                } else {
    204206                                        lang = arg.substr( 2 );
    … …  
    207209                        } else if ( prefix( arg, "-std=" ) || prefix( arg, "--std=" ) ) {
    208210                                std_flag = true;                                                // -std=XX provided
    209                                 args[nargs] = argv[i];                                  // pass the argument along
    210                                 nargs += 1;
     211                                args[nargs++] = argv[i];                                // pass argument along
    211212                        } else if ( arg == "-w" ) {
    212                                 args[nargs] = argv[i];                                  // pass the argument along
    213                                 nargs += 1;
    214                                 args[nargs] = ( *new string( string("-D__CFA_FLAG__=") + arg ) ).c_str(); // add the argument for cfa-cpp
    215                                 nargs += 1;
     213                                args[nargs++] = argv[i];                                // pass argument along
     214                                Putenv( argv, arg );
    216215                        } else if ( prefix( arg, "-W" ) ) {                     // check before next tests
    217216                                if ( arg == "-Werror" || arg == "-Wall" ) {
    218                                         args[nargs] = argv[i];                          // pass the argument along
    219                                         nargs += 1;
    220                                         args[nargs] = ( *new string( string("-D__CFA_FLAG__=") + arg ) ).c_str(); // add the argument for cfa-cpp
    221                                         nargs += 1;
     217                                        args[nargs++] = argv[i];                        // pass argument along
     218                                        Putenv( argv, argv[i] );
    222219                                } else {
    223220                                        unsigned int adv = prefix( arg, "-Wno-" ) ? 5 : 2;
    224                                         args[nargs] = argv[i];                          // conditionally pass the argument along
    225                                         const char * warning = argv[i] + adv;    // extract warning
     221                                        args[nargs] = argv[i];                          // conditionally pass argument along
     222                                        const char * warning = argv[i] + adv; // extract warning
    226223                                        if ( SemanticWarning_Exist( warning ) ) { // replace the argument for cfa-cpp
    227                                                 args[nargs] = ( *new string( string("-D__CFA_FLAG__=") + arg ) ).c_str();
     224                                                Putenv( argv, arg );
    228225                                        } // if
    229226                                        nargs += 1;
    230227                                } // if
    231228                        } else if ( prefix( arg, "-B" ) ) {
    232                                 Bprefix = arg.substr(2);                                // strip the -B flag
    233                                 args[nargs] = ( *new string( string("-D__GCC_BPREFIX__=") + Bprefix ) ).c_str();
    234                                 nargs += 1;
    235                         } else if ( prefix( arg, "-b" ) ) {
    236                                 if ( arg.length() == 2 ) {                              // separate argument ?
    237                                         i += 1;
    238                                         if ( i == argc ) continue;                      // next argument available ?
    239                                         arg += argv[i];                                         // concatenate argument
    240                                 } // if
    241                                 // later versions of gcc require the -b option to appear at the start of the command line
    242                                 shuffle( args, sargs, nargs, 1 );               // make room at front of argument list
    243                                 args[sargs] = ( *new string( arg ) ).c_str(); // pass the argument along
    244                                 if ( putenv( (char *)( *new string( string( "__GCC_MACHINE__=" ) + arg ) ).c_str() ) != 0 ) {
    245                                         cerr << argv[0] << " error, cannot set environment variable." << endl;
    246                                         exit( EXIT_FAILURE );
    247                                 } // if
    248                                 sargs += 1;
    249                                 nargs += 1;
    250                         } else if ( prefix( arg, "-V" ) ) {
    251                                 if ( arg.length() == 2 ) {                              // separate argument ?
    252                                         i += 1;
    253                                         if ( i == argc ) continue;                      // next argument available ?
    254                                         arg += argv[i];                                         // concatenate argument
    255                                 } // if
    256                                 // later versions of gcc require the -V option to appear at the start of the command line
    257                                 shuffle( args, sargs, nargs, 1 );               // make room at front of argument list
    258                                 args[sargs] = ( *new string( arg ) ).c_str(); // pass the argument along
    259                                 if ( putenv( (char *)( *new string( string( "__GCC_VERSION__=" ) + arg ) ).c_str() ) != 0 ) {
    260                                         cerr << argv[0] << " error, cannot set environment variable." << endl;
    261                                         exit( EXIT_FAILURE );
    262                                 } // if
    263                                 sargs += 1;
    264                                 nargs += 1;
     229                                bprefix = arg.substr(2);                                // strip the -B flag
    265230                        } else if ( arg == "-c" || arg == "-S" || arg == "-E" || arg == "-M" || arg == "-MM" ) {
    266                                 args[nargs] = argv[i];                                  // pass the argument along
    267                                 nargs += 1;
     231                                args[nargs++] = argv[i];                                // pass argument along
    268232                                if ( arg == "-E" || arg == "-M" || arg == "-MM" ) {
    269233                                        cpp_flag = true;                                        // cpp only
    … …  
    272236                        } else if ( arg[1] == 'l' ) {
    273237                                // if the user specifies a library, load it after user code
    274                                 libs[nlibs] = argv[i];
    275                                 nlibs += 1;
     238                                libs[nlibs++] = argv[i];
    276239                        } else if ( arg == "-m32" ) {
    277240                                m32 = true;
    278241                                m64 = false;
    279                                 args[nargs] = argv[i];
    280                                 nargs += 1;
     242                                args[nargs++] = argv[i];
    281243                        } else if ( arg == "-m64" ) {
    282244                                m64 = true;
    283245                                m32 = false;
    284                                 args[nargs] = argv[i];
    285                                 nargs += 1;
     246                                args[nargs++] = argv[i];
    286247                        } else {
    287248                                // concatenate any other arguments
    288                                 args[nargs] = argv[i];
    289                                 nargs += 1;
     249                                args[nargs++] = argv[i];
    290250                        } // if
    291251                } else {
    292252                        bool cfa = suffix( arg );                                       // check suffix
    293253                        if ( ! x_flag && cfa ) {                                        // no explicit suffix and cfa suffix ?
    294                                 args[nargs] = "-x";
    295                                 nargs += 1;
    296                                 args[nargs] = "c";
    297                                 nargs += 1;
     254                                args[nargs++] = "-x";
     255                                args[nargs++] = "c";
    298256                        } // if
    299                         args[nargs] = argv[i];                                          // concatenate file
    300                         nargs += 1;
     257                        args[nargs++] = argv[i];                                        // concatenate files
    301258                        if ( ! x_flag && cfa ) {                                        // no explicit suffix and cfa suffix ?
    302                                 args[nargs] = "-x";
    303                                 nargs += 1;
    304                                 args[nargs] = "none";
    305                                 nargs += 1;
     259                                args[nargs++] = "-x";
     260                                args[nargs++] = "none";
    306261                        } // if
    307262                        nonoptarg = true;
    … …  
    310265
    311266        #ifdef __x86_64__
    312         args[nargs] = "-mcx16";                                                         // allow double-wide CAA
    313         nargs += 1;
     267        args[nargs++] = "-mcx16";                                                       // allow double-wide CAA
    314268        #endif // __x86_64__
    315269
    … …  
    322276        #endif // __DEBUG_H__
    323277
     278        // -E flag stops at cc1 stage 1, so cfa-cpp in cc1 stage 2 is never executed.
    324279        if ( cpp_flag && CFA_flag ) {
    325                 cerr << argv[0] << " error, cannot use -E and -CFA flags together." << endl;
    326                 exit( EXIT_FAILURE );
     280                CFA_flag = false;
     281                cerr << argv[0] << " warning, both -E and -CFA flags specified, using -E and ignoring -CFA." << endl;
    327282        } // if
    328283
    329284        // add the CFA include-library paths, which allow direct access to header files without directory qualification
    330         if( !intree ) {
    331                 args[nargs] = "-I" CFA_INCDIR;
    332                 nargs += 1;
     285        if ( ! intree ) {
     286                args[nargs++] = "-I" CFA_INCDIR;
    333287                if ( ! noincstd_flag ) {                                                // do not use during build
    334                         args[nargs] = "-I" CFA_INCDIR "stdhdr";
    335                         nargs += 1;
    336                 } // if
    337                 args[nargs] = "-I" CFA_INCDIR "concurrency";
    338                 nargs += 1;
    339                 args[nargs] = "-I" CFA_INCDIR "containers";
    340                 nargs += 1;
    341         } else {
    342                 args[nargs] = "-I" TOP_SRCDIR "libcfa/src";
    343                 nargs += 1;
     288                        args[nargs++] = "-I" CFA_INCDIR "stdhdr";
     289                } // if
     290                args[nargs++] = "-I" CFA_INCDIR "concurrency";
     291                args[nargs++] = "-I" CFA_INCDIR "containers";
     292        } else {
     293                args[nargs++] = "-I" TOP_SRCDIR "libcfa/src";
    344294                if ( ! noincstd_flag ) {                                                // do not use during build
    345                         args[nargs] = "-I" TOP_SRCDIR "libcfa/src" "/stdhdr";
    346                         nargs += 1;
    347                 } // if
    348                 args[nargs] = "-I" TOP_SRCDIR "libcfa/src" "/concurrency";
    349                 nargs += 1;
    350                 args[nargs] = "-I" TOP_SRCDIR "libcfa/src" "/containers";
    351                 nargs += 1;
    352         }
     295                        args[nargs++] = "-I" TOP_SRCDIR "libcfa/src" "/stdhdr";
     296                } // if
     297                args[nargs++] = "-I" TOP_SRCDIR "libcfa/src" "/concurrency";
     298                args[nargs++] = "-I" TOP_SRCDIR "libcfa/src" "/containers";
     299        } // if
    353300
    354301        // add stdbool to get defines for bool/true/false
    355         args[nargs] = "-imacros";
    356         nargs += 1;
    357         args[nargs] = "stdbool.h";
    358         nargs += 1;
     302        args[nargs++] = "-imacros";
     303        args[nargs++] = "stdbool.h";
    359304
    360305        string libbase;
    361         if( !intree ) {
     306        if ( ! intree ) {
    362307                libbase = CFA_LIBDIR;
    363308        } else {
    364309                libbase = TOP_BUILDDIR "libcfa/";
    365                 args[nargs] = "-D__CFA_FLAG__=-t";
    366                 nargs += 1;
    367         }
    368 
    369         string arch = m32 ? CFA_32_CPU : (m64 ? CFA_64_CPU : CFA_DEFAULT_CPU);
     310        } // if
     311
     312        if( compiling_libs ) {
     313                Putenv( argv, "-t" );
     314        } // if
     315
     316        string arch( m32 ? CFA_32_CPU : (m64 ? CFA_64_CPU : CFA_DEFAULT_CPU) );
    370317        if ( ! m32 && ! m64 ) {
    371318                if ( arch == "x86" ) {
    372                         args[nargs] = "-m32";
    373                         nargs += 1;
     319                        args[nargs++] = "-m32";
    374320                } else if ( arch == "x64" ) {
    375                         args[nargs] = "-m64";
    376                         nargs += 1;
     321                        args[nargs++] = "-m64";
    377322                }  // if
    378323        } // if
     324
    379325        const char * config = nolib ? "nolib" : (debug ? "debug": "nodebug");
    380326        string libdir = libbase + arch + "-" + config;
    381327
    382         if ( ! nolib && ! dirExists( libdir ) ) {
    383                 cerr << argv[0] << " internal error, configuration " << config << " not installed." << endl;
    384                 cerr << "Was looking for " << libdir << endl;
    385                 libdir = libbase + arch + "-" + "nolib";
    386         } // if
    387 
    388         if ( ! dirExists( libdir ) ) {
    389                 cerr << argv[0] << " internal error, cannot find prelude directory." << endl;
    390                 cerr << "Was looking for " << libdir << endl;
    391                 exit( EXIT_FAILURE );
    392         } // if
    393 
    394         args[nargs] = ( *new string( string("-D__CFA_FLAG__=--prelude-dir=" ) + libdir + (intree ? "/prelude" : "")) ).c_str();
    395         nargs += 1;
     328        if (!disttree) {
     329                if ( ! nolib && ! dirExists( libdir ) ) {
     330                        cerr << argv[0] << " internal error, configuration " << config << " not installed." << endl;
     331                        cerr << "Was looking for " << libdir << endl;
     332                        for(int i = 1; i < argc; i++) {
     333                                cerr << argv[i] << " ";
     334                        }
     335                        cerr << endl;
     336                        libdir = libbase + arch + "-" + "nolib";
     337                } // if
     338
     339                if ( ! dirExists( libdir ) ) {
     340                        cerr << argv[0] << " internal error, cannot find prelude directory." << endl;
     341                        cerr << "Was looking for " << libdir << endl;
     342                        exit( EXIT_FAILURE );
     343                } // if
     344        } // if
     345
     346        if(disttree) {
     347                Putenv( argv, "--prelude-dir=" + dir(argv[0]) );
     348        } else if(intree) {
     349                Putenv( argv, "--prelude-dir=" + libdir + "/prelude" );
     350        } else {
     351                Putenv( argv, "--prelude-dir=" + libdir );
     352        }
    396353
    397354        for ( int i = 0; i < nlibs; i += 1 ) {                          // copy non-user libraries after all user libraries
    398                 args[nargs] = libs[i];
    399                 nargs += 1;
     355                args[nargs++] = libs[i];
    400356        } // for
    401357
    402358        if ( link ) {
    403                 args[nargs] = "-Xlinker";
    404                 nargs += 1;
    405                 args[nargs] = "--undefined=__cfaabi_dbg_bits_write";
    406                 nargs += 1;
    407                 args[nargs] = "-Xlinker";
    408                 nargs += 1;
    409                 args[nargs] = "--undefined=__cfaabi_interpose_startup";
    410                 nargs += 1;
    411                 args[nargs] = "-Xlinker";
    412                 nargs += 1;
    413                 args[nargs] = "--undefined=__cfaabi_appready_startup";
    414                 nargs += 1;
    415 
    416                 // include the cfa library in case it's needed
    417                 args[nargs] = ( *new string( string("-L" ) + libdir + (intree ? "/src/.libs" : "")) ).c_str();
    418                 nargs += 1;
    419                 args[nargs] = ( *new string( string("-Wl,-rpath," ) + libdir + (intree ? "/src/.libs" : "")) ).c_str();
    420                 nargs += 1;
    421                 args[nargs] = "-Wl,--push-state,--as-needed";
    422                 nargs += 1;
    423                 args[nargs] = "-lcfathread";
    424                 nargs += 1;
    425                 args[nargs] = "-Wl,--pop-state";
    426                 nargs += 1;
    427                 args[nargs] = "-lcfa";
    428                 nargs += 1;
    429                 args[nargs] = "-lpthread";
    430                 nargs += 1;
    431                 args[nargs] = "-ldl";
    432                 nargs += 1;
    433                 args[nargs] = "-lrt";
    434                 nargs += 1;
    435                 args[nargs] = "-lm";
    436                 nargs += 1;
    437         } // if
    438 
    439         // Add exception flags (unconditionally)
    440         args[nargs] = "-fexceptions";
    441         nargs += 1;
    442 
    443         // add the correct set of flags based on the type of compile this is
    444 
    445         args[nargs] = ( *new string( string("-D__CFA_MAJOR__=") + Major ) ).c_str();
    446         nargs += 1;
    447         args[nargs] = ( *new string( string("-D__CFA_MINOR__=") + Minor ) ).c_str();
    448         nargs += 1;
    449         args[nargs] = ( *new string( string("-D__CFA_PATCH__=") + Patch ) ).c_str();
    450         nargs += 1;
    451         args[nargs] = "-D__CFA__";
    452         nargs += 1;
    453         args[nargs] = "-D__CFORALL__";
    454         nargs += 1;
    455         args[nargs] = "-D__cforall";
    456         nargs += 1;
     359                args[nargs++] = "-Xlinker";
     360                args[nargs++] = "--undefined=__cfaabi_dbg_bits_write";
     361                args[nargs++] = "-Xlinker";
     362                args[nargs++] = "--undefined=__cfaabi_interpose_startup";
     363                args[nargs++] = "-Xlinker";
     364                args[nargs++] = "--undefined=__cfaabi_appready_startup";
     365
     366                // include the cfa library in case it is needed
     367                args[nargs++] = ( *new string( string("-L" ) + libdir + (intree ? "/src/.libs" : "")) ).c_str();
     368                args[nargs++] = ( *new string( string("-Wl,-rpath," ) + libdir + (intree ? "/src/.libs" : "")) ).c_str();
     369                args[nargs++] = "-Wl,--push-state,--as-needed";
     370                args[nargs++] = "-lcfathread";
     371                args[nargs++] = "-Wl,--pop-state";
     372                args[nargs++] = "-lcfa";
     373                args[nargs++] = "-lpthread";
     374                args[nargs++] = "-ldl";
     375                args[nargs++] = "-lrt";
     376                args[nargs++] = "-lm";
     377        } // if
     378
     379        args[nargs++] = "-fexceptions";                                         // add exception flags (unconditionally)
     380
     381        // add flags based on the type of compile
     382
     383        args[nargs++] = ( *new string( string("-D__CFA_MAJOR__=") + Major ) ).c_str();
     384        args[nargs++] = ( *new string( string("-D__CFA_MINOR__=") + Minor ) ).c_str();
     385        args[nargs++] = ( *new string( string("-D__CFA_PATCH__=") + Patch ) ).c_str();
     386        args[nargs++] = "-D__CFA__";
     387        args[nargs++] = "-D__CFORALL__";
     388        args[nargs++] = "-D__cforall";
    457389
    458390        if ( cpp_flag ) {
    459                 args[nargs] = "-D__CPP__";
    460                 nargs += 1;
    461         } // if
    462 
    463         shuffle( args, sargs, nargs, 1 );                                       // make room at front of argument list
    464         nargs += 1;
     391                args[nargs++] = "-D__CPP__";
     392        } // if
     393
    465394        if ( CFA_flag ) {
    466                 args[sargs] = "-D__CFA_FLAG__=-N";
    467                 args[nargs] = "-D__CFA_PREPROCESS_";
    468                 nargs += 1;
    469         } else {
    470                 args[sargs] = "-D__CFA_FLAG__=-L";
    471         } // if
    472         sargs += 1;
     395                Putenv( argv, "-N" );
     396                Putenv( argv, "-CFA" );
     397                // -CFA implies cc1 stage 2, but gcc does not pass the -o file to this stage because it believe the file is for
     398                // the linker. Hence, the -o file is explicit passed to cc1 stage 2 and used as cfa-cpp's output file.
     399                if ( o_file ) Putenv( argv, string( "-o=" ) + argv[o_file] );
     400        } else {
     401                Putenv( argv, "-L" );
     402        } // if
    473403
    474404        if ( debug ) {
    475405                heading += " (debug)";
    476                 args[nargs] = "-D__CFA_DEBUG__";
    477                 nargs += 1;
     406                args[nargs++] = "-D__CFA_DEBUG__";
    478407        } else {
    479408                heading += " (no debug)";
    480409        } // if
    481410
    482         if ( Bprefix.length() == 0 ) {
    483                 Bprefix = ! intree ? installlibdir : srcdriverdir;
    484                 if ( Bprefix[Bprefix.length() - 1] != '/' ) Bprefix += '/';
    485                 args[nargs] = ( *new string( string("-D__GCC_BPREFIX__=") + Bprefix ) ).c_str();
    486                 nargs += 1;
    487         } // if
    488 
    489         args[nargs] = "-Xlinker";                                                       // used by backtrace
    490         nargs += 1;
    491         args[nargs] = "-export-dynamic";
    492         nargs += 1;
     411        if ( bprefix.length() == 0 ) {
     412                if(disttree) {
     413                        bprefix = dir(argv[0]);
     414                } else if(intree) {
     415                        bprefix = srcdriverdir;
     416                } else {
     417                        bprefix = installlibdir;
     418                }
     419                if ( bprefix[bprefix.length() - 1] != '/' ) bprefix += '/';
     420                Putenv( argv, string("-B=") + bprefix );
     421        } // if
     422
     423        args[nargs++] = "-Xlinker";                                                     // used by backtrace
     424        args[nargs++] = "-export-dynamic";
    493425
    494426        // execute the compilation command
    … …  
    504436
    505437        if ( prefix( compiler_name, "gcc" ) ) {                         // allow suffix on gcc name
    506                 args[nargs] = "-no-integrated-cpp";
    507                 nargs += 1;
    508                 args[nargs] = "-Wno-deprecated";
    509                 nargs += 1;
    510 #ifdef HAVE_CAST_FUNCTION_TYPE
    511                 args[nargs] = "-Wno-cast-function-type";
    512                 nargs += 1;
    513 #endif // HAVE_CAST_FUNCTION_TYPE
     438                args[nargs++] = "-no-integrated-cpp";
     439                args[nargs++] = "-Wno-deprecated";
     440                #ifdef HAVE_CAST_FUNCTION_TYPE
     441                args[nargs++] = "-Wno-cast-function-type";
     442                #endif // HAVE_CAST_FUNCTION_TYPE
    514443                if ( ! std_flag ) {                                                             // default c11, if none specified
    515                         args[nargs] = "-std=gnu11";
    516                         nargs += 1;
    517                 } // if
    518                 args[nargs] = "-fgnu89-inline";
    519                 nargs += 1;
    520                 args[nargs] = "-D__int8_t_defined";                             // prevent gcc type-size attributes
    521                 nargs += 1;
    522                 args[nargs] = ( *new string( string("-B") + Bprefix ) ).c_str();
    523                 nargs += 1;
     444                        args[nargs++] = "-std=gnu11";
     445                } // if
     446                args[nargs++] = "-fgnu89-inline";
     447                args[nargs++] = "-D__int8_t_defined";                   // prevent gcc type-size attributes
     448                args[nargs++] = ( *new string( string("-B") + bprefix ) ).c_str();
    524449        } else {
    525450                cerr << argv[0] << " error, compiler \"" << compiler_name << "\" unsupported." << endl;
    … …  
    527452        } // if
    528453
    529         args[nargs] = NULL;                                                                     // terminate with NULL
     454        args[nargs] = nullptr;                                                          // terminate
    530455
    531456        #ifdef __DEBUG_H__
    532457        cerr << "nargs: " << nargs << endl;
    533458        cerr << "args:" << endl;
    534         for ( int i = 0; args[i] != NULL; i += 1 ) {
     459        for ( int i = 0; args[i] != nullptr; i += 1 ) {
    535460                cerr << " \"" << args[i] << "\"" << endl;
    536461        } // for
     462        cerr << endl;
    537463        #endif // __DEBUG_H__
    538464
    539465        if ( ! quiet ) {
    540466                cerr << "CFA " << "Version " << Version << heading << endl;
    541 
    542467                if ( help ) {
    543468                        cerr <<
    … …  
    554479                if ( argc == 2 ) exit( EXIT_SUCCESS );                  // if only the -v flag is specified, do not invoke gcc
    555480
    556                 for ( int i = 0; args[i] != NULL; i += 1 ) {
     481                for ( int i = 0; args[i] != nullptr; i += 1 ) {
    557482                        cerr << args[i] << " ";
    558483                } // for
    … …  
    568493
    569494        execvp( args[0], (char *const *)args );                         // should not return
    570         perror( "CFA Translator error: cfa level, execvp" );
     495        perror( "CFA Translator error: execvp" );
    571496        exit( EXIT_FAILURE );
    572497} // main

  • libcfa/Makefile.in

    r85142648 r970141d  
    231231CFACC = @CFACC@
    232232CFACPP = @CFACPP@
     233CFADIR_HASH = @CFADIR_HASH@
    233234CFA_BINDIR = @CFA_BINDIR@
    234235CFA_INCDIR = @CFA_INCDIR@
    … …  
    274275LIPO = @LIPO@
    275276LN_S = @LN_S@
     277LOCAL_CC1 = @LOCAL_CC1@
     278LOCAL_CFACC = @LOCAL_CFACC@
    276279LTLIBOBJS = @LTLIBOBJS@
    277280LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@
    … …  
    293296PACKAGE_VERSION = @PACKAGE_VERSION@
    294297PATH_SEPARATOR = @PATH_SEPARATOR@
     298PRELUDEFLAG = @PRELUDEFLAG@
    295299RANLIB = @RANLIB@
    296300SED = @SED@

  • libcfa/configure

    r85142648 r970141d  
    707707CONFIG_CFLAGS
    708708ARCH_FLAGS
     709PRELUDEFLAG
     710CFADIR_HASH
     711LOCAL_CC1
     712LOCAL_CFACC
    709713CFACPP
    710714CFACC
     715ENABLE_DISTCC_FALSE
     716ENABLE_DISTCC_TRUE
    711717CFA_VERSION
    712718DRIVER_DIR
    … …  
    783789enable_option_checking
    784790enable_silent_rules
     791enable_distcc
    785792with_cfa_name
    786793enable_shared
    … …  
    14451452  --enable-silent-rules   less verbose build output (undo: "make V=1")
    14461453  --disable-silent-rules  verbose build output (undo: "make V=0")
     1454  --enable-distcc     whether or not to enable distributed compilation
    14471455  --enable-shared[=PKGS]  build shared libraries [default=yes]
    14481456  --enable-static[=PKGS]  build static libraries [default=yes]
    … …  
    29412949
    29422950
    2943 CFACC=${DRIVER_DIR}cfa
     2951# Check whether --enable-distcc was given.
     2952if test "${enable_distcc+set}" = set; then :
     2953  enableval=$enable_distcc; enable_distcc=$enableval
     2954else
     2955  enable_distcc=no
     2956fi
     2957
     2958
     2959echo -n "checking for distributated build... "
     2960if test x$enable_distcc = xno; then
     2961        CFACC=${DRIVER_DIR}cfa
     2962        PRELUDEFLAG='-in-tree'
     2963        echo "no"
     2964else
     2965        tools="$(readlink -m $ac_confdir/)/../tools/build"
     2966        config=$(basename $(readlink -f .))
     2967        echo "$tools/distcc_hash $config"
     2968        CFADIR_HASH=$($tools/distcc_hash $config)
     2969        CFACC="distcc ~/.cfadistcc/${CFADIR_HASH}/cfa"
     2970        PRELUDEFLAG='-dist-tree'
     2971        echo "yes (hash=${CFADIR_HASH})"
     2972fi
    29442973CFACPP=${DRIVER_DIR}cfa-cpp
     2974LOCAL_CFACC=${DRIVER_DIR}cfa
     2975LOCAL_CC1=${DRIVER_DIR}cc1
     2976
     2977 if test x$enable_distcc = xyes; then
     2978  ENABLE_DISTCC_TRUE=
     2979  ENABLE_DISTCC_FALSE='#'
     2980else
     2981  ENABLE_DISTCC_TRUE='#'
     2982  ENABLE_DISTCC_FALSE=
     2983fi
     2984
     2985
     2986
     2987
     2988
     2989
    29452990
    29462991
    … …  
    1698217027fi
    1698317028
     17029if test -z "${ENABLE_DISTCC_TRUE}" && test -z "${ENABLE_DISTCC_FALSE}"; then
     17030  as_fn_error $? "conditional \"ENABLE_DISTCC\" was never defined.
     17031Usually this means the macro was only invoked conditionally." "$LINENO" 5
     17032fi
    1698417033if test -z "${BUILDLIB_TRUE}" && test -z "${BUILDLIB_FALSE}"; then
    1698517034  as_fn_error $? "conditional \"BUILDLIB\" was never defined.

  • libcfa/configure.ac

    r85142648 r970141d  
    2727AC_ARG_VAR(CFA_VERSION, [The long version of cfa])
    2828
    29 CFACC=${DRIVER_DIR}cfa
     29AC_ARG_ENABLE(distcc,
     30        [  --enable-distcc     whether or not to enable distributed compilation],
     31        enable_distcc=$enableval, enable_distcc=no)
     32
     33echo -n "checking for distributated build... "
     34if test x$enable_distcc = xno; then
     35        CFACC=${DRIVER_DIR}cfa
     36        PRELUDEFLAG='-in-tree'
     37        echo "no"
     38else
     39        tools="$(readlink -m $ac_confdir/)/../tools/build"
     40        config=$(basename $(readlink -f .))
     41        echo "$tools/distcc_hash $config"
     42        CFADIR_HASH=$($tools/distcc_hash $config)
     43        CFACC="distcc ~/.cfadistcc/${CFADIR_HASH}/cfa"
     44        PRELUDEFLAG='-dist-tree'
     45        echo "yes (hash=${CFADIR_HASH})"
     46fi
    3047CFACPP=${DRIVER_DIR}cfa-cpp
     48LOCAL_CFACC=${DRIVER_DIR}cfa
     49LOCAL_CC1=${DRIVER_DIR}cc1
     50
     51AM_CONDITIONAL([ENABLE_DISTCC], [test x$enable_distcc = xyes])
     52
    3153AC_SUBST(CFACC)
    3254AC_SUBST(CFACPP)
     55AC_SUBST(LOCAL_CFACC)
     56AC_SUBST(LOCAL_CC1)
     57AC_SUBST(CFADIR_HASH)
    3358AC_SUBST(CFA_VERSION)
     59AC_SUBST(PRELUDEFLAG)
    3460
    3561#==============================================================================

  • libcfa/prelude/Makefile.am

    r85142648 r970141d  
    2323cfalib_DATA = gcc-builtins.cf builtins.cf extras.cf prelude.cfa bootloader.c
    2424
    25 CC = @CFACC@
     25CC = @LOCAL_CFACC@
    2626AM_CFLAGS = -g -Wall -Wno-unused-function -fPIC @ARCH_FLAGS@ @CONFIG_CFLAGS@
    2727AM_CFAFLAGS = @CONFIG_CFAFLAGS@
    … …  
    5454
    5555# create forward declarations for cfa builtins
    56 builtins.cf : builtins.c ${CC}
     56builtins.cf : builtins.c @LOCAL_CFACC@
    5757        ${AM_V_GEN}gcc ${AM_CFLAGS} -E -P ${<} -o ${@} -MD -MP -MF $(DEPDIR)/builtins.Po -D__cforall
    5858        ${AM_V_at}sed -i 's/builtins.o/builtins.cf/g' $(DEPDIR)/builtins.Po
    … …  
    6868MOSTLYCLEANFILES = bootloader.c builtins.cf extras.cf gcc-builtins.c gcc-builtins.cf prelude.cfa
    6969MAINTAINERCLEANFILES = ${addprefix ${libdir}/,${cfalib_DATA}} ${addprefix ${libdir}/,${lib_LIBRARIES}}
     70
     71if ENABLE_DISTCC
     72distribution: @LOCAL_CFACC@ @LOCAL_CC1@ @CFACPP@ gcc-builtins.cf builtins.cf extras.cf prelude.cfa bootloader.c $(srcdir)/../../tools/build/push2dist.sh
     73        ${AM_V_GEN}$(srcdir)/../../tools/build/push2dist.sh @CFADIR_HASH@
     74        @echo "Dummy file to track distribution to remote hosts" > ${@}
     75
     76all: all-am distribution
     77endif ENABLE_DISTCC

  • libcfa/prelude/Makefile.in

    r85142648 r970141d  
    167167AUTOMAKE = @AUTOMAKE@
    168168AWK = @AWK@
    169 CC = @CFACC@
     169CC = @LOCAL_CFACC@
    170170CCAS = @CCAS@
    171171CCASDEPMODE = @CCASDEPMODE@
    … …  
    174174CFACC = @CFACC@
    175175CFACPP = @CFACPP@
     176CFADIR_HASH = @CFADIR_HASH@
    176177CFA_BINDIR = @CFA_BINDIR@
    177178CFA_INCDIR = @CFA_INCDIR@
    … …  
    217218LIPO = @LIPO@
    218219LN_S = @LN_S@
     220LOCAL_CC1 = @LOCAL_CC1@
     221LOCAL_CFACC = @LOCAL_CFACC@
    219222LTLIBOBJS = @LTLIBOBJS@
    220223LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@
    … …  
    236239PACKAGE_VERSION = @PACKAGE_VERSION@
    237240PATH_SEPARATOR = @PATH_SEPARATOR@
     241PRELUDEFLAG = @PRELUDEFLAG@
    238242RANLIB = @RANLIB@
    239243SED = @SED@
    … …  
    555559
    556560# create forward declarations for cfa builtins
    557 builtins.cf : builtins.c ${CC}
     561builtins.cf : builtins.c @LOCAL_CFACC@
    558562        ${AM_V_GEN}gcc ${AM_CFLAGS} -E -P ${<} -o ${@} -MD -MP -MF $(DEPDIR)/builtins.Po -D__cforall
    559563        ${AM_V_at}sed -i 's/builtins.o/builtins.cf/g' $(DEPDIR)/builtins.Po
    … …  
    566570maintainer-clean-local :
    567571        rm -rf $(DEPDIR)
     572
     573@ENABLE_DISTCC_TRUE@distribution: @LOCAL_CFACC@ @LOCAL_CC1@ @CFACPP@ gcc-builtins.cf builtins.cf extras.cf prelude.cfa bootloader.c $(srcdir)/../../tools/build/push2dist.sh
     574@ENABLE_DISTCC_TRUE@    ${AM_V_GEN}$(srcdir)/../../tools/build/push2dist.sh @CFADIR_HASH@
     575@ENABLE_DISTCC_TRUE@    @echo "Dummy file to track distribution to remote hosts" > ${@}
     576
     577@ENABLE_DISTCC_TRUE@all: all-am distribution
    568578
    569579# Tell versions [3.59,3.63) of GNU make to not export all variables.

  • libcfa/src/Makefile.am

    r85142648 r970141d  
    3232# use -no-include-stdhdr to prevent rebuild cycles
    3333# The built sources must not depend on the installed headers
    34 AM_CFAFLAGS = -quiet -in-tree -I$(srcdir)/stdhdr $(if $(findstring ${gdbwaittarget}, ${@}), -XCFA --gdb) @CONFIG_CFAFLAGS@
     34AM_CFAFLAGS = -quiet -cfalib @PRELUDEFLAG@ -I$(srcdir)/stdhdr $(if $(findstring ${gdbwaittarget}, ${@}), -XCFA --gdb) @CONFIG_CFAFLAGS@
    3535AM_CFLAGS = -g -Wall -Wno-unused-function -fPIC @ARCH_FLAGS@ @CONFIG_CFLAGS@
    3636AM_CCASFLAGS = -g -Wall -Wno-unused-function @ARCH_FLAGS@ @CONFIG_CFLAGS@
    … …  
    6464# add dependency of cfa files
    6565libobjs = $(addsuffix .lo, $(basename $(filter %.cfa,$(libsrc))))
    66 $(libobjs) : @CFACC@ @CFACPP@ prelude.cfa
     66$(libobjs) : @LOCAL_CFACC@ @CFACPP@ prelude.cfa
    6767
    6868thread_libobjs = $(addsuffix .lo, $(basename $(filter %.cfa,$(thread_libsrc))))
    69 $(thread_libobjs) : @CFACC@ @CFACPP@ prelude.cfa
     69$(thread_libobjs) : @LOCAL_CFACC@ @CFACPP@ prelude.cfa
    7070
    7171
    … …  
    8686
    8787
    88 prelude.o : prelude.cfa extras.cf gcc-builtins.cf builtins.cf @CFACC@ @CFACPP@
    89         ${AM_V_GEN}$(CFACOMPILE) -quiet -in-tree -XCFA -l ${<} -c -o ${@}
     88if ENABLE_DISTCC
    9089
    91 prelude.lo: prelude.cfa extras.cf gcc-builtins.cf builtins.cf @CFACC@ @CFACPP@
     90../prelude/distribution: @LOCAL_CFACC@ @LOCAL_CC1@ @CFACPP@ ../prelude/gcc-builtins.cf ../prelude/builtins.cf ../prelude/extras.cf ../prelude/prelude.cfa ../prelude/bootloader.c $(srcdir)/../../tools/build/push2dist.sh
     91        @+make -C ../prelude distribution
     92
     93prelude.o prelude.lo $(libobjs) $(thread_libobjs) : ../prelude/distribution
     94
     95endif ENABLE_DISTCC
     96
     97prelude.o : prelude.cfa extras.cf gcc-builtins.cf builtins.cf @LOCAL_CFACC@ @CFACPP@
     98        ${AM_V_GEN}$(CFACOMPILE) -quiet @PRELUDEFLAG@ -XCFA -l ${<} -c -o ${@}
     99
     100prelude.lo: prelude.cfa extras.cf gcc-builtins.cf builtins.cf @LOCAL_CFACC@ @CFACPP@
    92101        ${AM_V_GEN}$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile \
    93         $(CFACOMPILE) -quiet -in-tree -XCFA -l ${<} -c -o ${@}
    94 
     102        $(CFACOMPILE) -quiet @PRELUDEFLAG@ -XCFA -l ${<} -c -o ${@}
    95103
    96104#----------------------------------------------------------------------------------------------------------------

  • libcfa/src/Makefile.in

    r85142648 r970141d  
    284284CFACC = @CFACC@
    285285CFACPP = @CFACPP@
     286CFADIR_HASH = @CFADIR_HASH@
    286287CFA_BINDIR = @CFA_BINDIR@
    287288CFA_INCDIR = @CFA_INCDIR@
    … …  
    327328LIPO = @LIPO@
    328329LN_S = @LN_S@
     330LOCAL_CC1 = @LOCAL_CC1@
     331LOCAL_CFACC = @LOCAL_CFACC@
    329332LTLIBOBJS = @LTLIBOBJS@
    330333LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@
    … …  
    346349PACKAGE_VERSION = @PACKAGE_VERSION@
    347350PATH_SEPARATOR = @PATH_SEPARATOR@
     351PRELUDEFLAG = @PRELUDEFLAG@
    348352RANLIB = @RANLIB@
    349353SED = @SED@
    … …  
    441445# use -no-include-stdhdr to prevent rebuild cycles
    442446# The built sources must not depend on the installed headers
    443 AM_CFAFLAGS = -quiet -in-tree -I$(srcdir)/stdhdr $(if $(findstring ${gdbwaittarget}, ${@}), -XCFA --gdb) @CONFIG_CFAFLAGS@
     447AM_CFAFLAGS = -quiet -cfalib @PRELUDEFLAG@ -I$(srcdir)/stdhdr $(if $(findstring ${gdbwaittarget}, ${@}), -XCFA --gdb) @CONFIG_CFAFLAGS@
    444448AM_CFLAGS = -g -Wall -Wno-unused-function -fPIC @ARCH_FLAGS@ @CONFIG_CFLAGS@
    445449AM_CCASFLAGS = -g -Wall -Wno-unused-function @ARCH_FLAGS@ @CONFIG_CFLAGS@
    … …  
    937941        $(LTCFACOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
    938942        $(am__mv) $$depbase.Tpo $$depbase.Plo
    939 $(libobjs) : @CFACC@ @CFACPP@ prelude.cfa
    940 $(thread_libobjs) : @CFACC@ @CFACPP@ prelude.cfa
     943$(libobjs) : @LOCAL_CFACC@ @CFACPP@ prelude.cfa
     944$(thread_libobjs) : @LOCAL_CFACC@ @CFACPP@ prelude.cfa
    941945
    942946-include $(libdeps)
    … …  
    944948-include $(thread_libdeps)
    945949
    946 prelude.o : prelude.cfa extras.cf gcc-builtins.cf builtins.cf @CFACC@ @CFACPP@
    947         ${AM_V_GEN}$(CFACOMPILE) -quiet -in-tree -XCFA -l ${<} -c -o ${@}
    948 
    949 prelude.lo: prelude.cfa extras.cf gcc-builtins.cf builtins.cf @CFACC@ @CFACPP@
     950@ENABLE_DISTCC_TRUE@../prelude/distribution: @LOCAL_CFACC@ @LOCAL_CC1@ @CFACPP@ ../prelude/gcc-builtins.cf ../prelude/builtins.cf ../prelude/extras.cf ../prelude/prelude.cfa ../prelude/bootloader.c $(srcdir)/../../tools/build/push2dist.sh
     951@ENABLE_DISTCC_TRUE@    @+make -C ../prelude distribution
     952
     953@ENABLE_DISTCC_TRUE@prelude.o prelude.lo $(libobjs) $(thread_libobjs) : ../prelude/distribution
     954
     955prelude.o : prelude.cfa extras.cf gcc-builtins.cf builtins.cf @LOCAL_CFACC@ @CFACPP@
     956        ${AM_V_GEN}$(CFACOMPILE) -quiet @PRELUDEFLAG@ -XCFA -l ${<} -c -o ${@}
     957
     958prelude.lo: prelude.cfa extras.cf gcc-builtins.cf builtins.cf @LOCAL_CFACC@ @CFACPP@
    950959        ${AM_V_GEN}$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile \
    951         $(CFACOMPILE) -quiet -in-tree -XCFA -l ${<} -c -o ${@}
     960        $(CFACOMPILE) -quiet @PRELUDEFLAG@ -XCFA -l ${<} -c -o ${@}
    952961
    953962#----------------------------------------------------------------------------------------------------------------

  • libcfa/src/fstream.cfa

    r85142648 r970141d  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Jul 15 18:11:26 2019
    13 // Update Count     : 349
     12// Last Modified On : Tue Sep 10 22:19:56 2019
     13// Update Count     : 354
    1414//
    1515
    … …  
    164164} // fmt
    165165
    166 static ofstream soutFile = { (FILE *)(&_IO_2_1_stdout_) };
     166static ofstream soutFile = { (FILE *)stdout };
    167167ofstream & sout = soutFile, & stdout = soutFile;
    168 static ofstream serrFile = { (FILE *)(&_IO_2_1_stderr_) };
     168static ofstream serrFile = { (FILE *)stderr };
    169169ofstream & serr = serrFile, & stderr = serrFile;
    170170
    171 static ofstream exitFile = { (FILE *)(&_IO_2_1_stdout_) };
     171static ofstream exitFile = { (FILE *)stdout };
    172172ofstream & exit = exitFile;
    173 static ofstream abortFile = { (FILE *)(&_IO_2_1_stderr_) };
     173static ofstream abortFile = { (FILE *)stderr };
    174174ofstream & abort = abortFile;
    175175
    … …  
    265265} // fmt
    266266
    267 
    268 static ifstream sinFile = { (FILE *)(&_IO_2_1_stdin_) };
     267static ifstream sinFile = { (FILE *)stdin };
    269268ifstream & sin = sinFile, & stdin = sinFile;
    270269

  • longrun_tests/Makefile.in

    r85142648 r970141d  
    378378FGREP = @FGREP@
    379379GREP = @GREP@
     380HAS_DISTCC = @HAS_DISTCC@
    380381HOST_FLAGS = @HOST_FLAGS@
    381382INSTALL = @INSTALL@

  • src/Makefile.in

    r85142648 r970141d  
    441441FGREP = @FGREP@
    442442GREP = @GREP@
     443HAS_DISTCC = @HAS_DISTCC@
    443444HOST_FLAGS = @HOST_FLAGS@
    444445INSTALL = @INSTALL@

  • src/ResolvExpr/Unify.cc

    r85142648 r970141d  
    99// Author           : Richard C. Bilson
    1010// Created On       : Sun May 17 12:27:10 2015
    11 // Last Modified By : Aaron B. Moss
    12 // Last Modified On : Mon Jun 18 11:58:00 2018
    13 // Update Count     : 43
     11// Last Modified By : Andrew Beach
     12// Last Modified On : Wed Sep  4 10:00:00 2019
     13// Update Count     : 44
    1414//
    1515
    … …  
    278278#endif
    279279                        if ( ( common = commonType( type1, type2, widen.first, widen.second, indexer, env, openVars ) ) ) {
    280                                 common->get_qualifiers() = tq1 | tq2;
     280                                common->tq = tq1.unify( tq2 );
    281281#ifdef DEBUG
    282282                                std::cerr << "unifyInexact: common type is ";
    … …  
    295295                                if ( ( tq1 > tq2 || widen.first ) && ( tq2 > tq1 || widen.second ) ) {
    296296                                        common = type1->clone();
    297                                         common->get_qualifiers() = tq1 | tq2;
     297                                        common->tq = tq1.unify( tq2 );
    298298                                        result = true;
    299299                                } else {
    … …  
    302302                        } else {
    303303                                common = type1->clone();
    304                                 common->get_qualifiers() = tq1 | tq2;
     304                                common->tq = tq1.unify( tq2 );
    305305                                result = true;
    306306                        } // if

  • src/SynTree/Expression.cc

    r85142648 r970141d  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Andrew Beach
    12 // Last Modified On : Tue Aug 13 11:31:00 2019
    13 // Update Count     : 63
     12// Last Modified On : Thr Aug 15 13:43:00 2019
     13// Update Count     : 64
    1414//
    1515
    … …  
    646646                result = new VoidType( Type::Qualifiers() );
    647647        }
     648}
     649bool StmtExpr::get_lvalue() const {
     650        return result->get_lvalue();
    648651}
    649652void StmtExpr::print( std::ostream & os, Indenter indent ) const {

  • src/SynTree/Expression.h

    r85142648 r970141d  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Andrew Beach
    12 // Last Modified On : Wed Aug 14 14:24:00 2019
    13 // Update Count     : 53
     12// Last Modified On : Thr Aug 15 13:46:00 2019
     13// Update Count     : 54
    1414//
    1515
    … …  
    777777        virtual ~StmtExpr();
    778778
     779        bool get_lvalue() const final;
     780
    779781        CompoundStmt * get_statements() const { return statements; }
    780782        StmtExpr * set_statements( CompoundStmt * newValue ) { statements = newValue; return this; }

  • src/SynTree/Type.h

    r85142648 r970141d  
    99// Author           : Richard C. Bilson
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Feb 14 17:11:24 2019
    13 // Update Count     : 169
     11// Last Modified By : Andrew Beach
     12// Last Modified On : Wed Sep  4 09:58:00 2019
     13// Update Count     : 170
    1414//
    1515
    … …  
    131131                bool operator>( Qualifiers other ) const { return *this != other && *this >= other; }
    132132                BFCommon( Qualifiers, NumTypeQualifier )
     133
     134                Qualifiers unify( Qualifiers const & other ) const {
     135                        int or_flags = Mask & (val | other.val);
     136                        int and_flags = val & other.val;
     137                        return Qualifiers( or_flags | and_flags );
     138                }
    133139        }; // Qualifiers
    134140

  • src/main.cc

    r85142648 r970141d  
    1010// Created On       : Fri May 15 23:12:02 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Jun  5 20:35:13 2019
    13 // Update Count     : 601
     12// Last Modified On : Fri Aug 23 06:50:08 2019
     13// Update Count     : 607
    1414//
    1515
    … …  
    9696DeclarationNode * parseTree = nullptr;                                  // program parse tree
    9797
    98 static bool waiting_for_gdb = false; // flag to set cfa-cpp to wait for gdb on start
     98static bool waiting_for_gdb = false;                                    // flag to set cfa-cpp to wait for gdb on start
    9999
    100100static std::string PreludeDirector = "";
    101101
    102 static void parse_cmdline( int argc, char *argv[], const char *& filename );
     102static void parse_cmdline( int argc, char *argv[] );
    103103static void parse( FILE * input, LinkageSpec::Spec linkage, bool shouldExit = false );
    104104static void dump( list< Declaration * > & translationUnit, ostream & out = cout );
    … …  
    172172        FILE * input;                                                                           // use FILE rather than istream because yyin is FILE
    173173        ostream * output = & cout;
    174         const char * filename = nullptr;
    175174        list< Declaration * > translationUnit;
    176175
    … …  
    184183        // } // for
    185184
    186         parse_cmdline( argc, argv, filename );                          // process command-line arguments
     185        parse_cmdline( argc, argv );                                            // process command-line arguments
    187186        CodeGen::FixMain::setReplaceMain( !nomainp );
    188187
    189         if(waiting_for_gdb) {
     188        if ( waiting_for_gdb ) {
    190189                std::cerr << "Waiting for gdb" << std::endl;
    191190                std::cerr << "run :" << std::endl;
    192191                std::cerr << "  gdb attach " << getpid() << std::endl;
    193192                raise(SIGSTOP);
    194         }
     193        } // if
    195194
    196195        try {
    … …  
    198197                if ( optind < argc ) {                                                  // any commands after the flags ? => input file name
    199198                        input = fopen( argv[ optind ], "r" );
    200                         assertf( input, "cannot open %s\n", argv[ optind ] );
    201                         // if running cfa-cpp directly, might forget to pass -F option (and really shouldn't have to)
    202                         if ( filename == nullptr ) filename = argv[ optind ];
    203                         // prelude filename comes in differently
    204                         if ( libcfap ) filename = "prelude.cfa";
     199                        assertf( input, "cannot open %s because %s\n", argv[ optind ], strerror( errno ) );
    205200                        optind += 1;
    206201                } else {                                                                                // no input file name
    207202                        input = stdin;
    208                         std::cerr << "Input from stdin" << std::endl;
    209                         // if running cfa-cpp directly, might forget to pass -F option. Since this takes from stdin, pass
    210                         // a fake name along
    211                         if ( filename == nullptr ) filename = "stdin";
    212203                } // if
    213204
    … …  
    447438
    448439
    449 static const char optstring[] = ":hlLmNnpP:S:tgwW:D:F:";
     440static const char optstring[] = ":hlLmNnpP:S:twW:D:";
    450441
    451442enum { PreludeDir = 128 };
    … …  
    466457        { "", no_argument, nullptr, 0 },                                        // -W
    467458        { "", no_argument, nullptr, 0 },                                        // -D
    468         { "", no_argument, nullptr, 0 },                                        // -F
    469459        { nullptr, 0, nullptr, 0 }
    470460}; // long_opts
    … …  
    486476        "",                                                                                                     // -W
    487477        "",                                                                                                     // -D
    488         "",                                                                                                     // -F
    489478}; // description
    490479
    … …  
    521510
    522511static void usage( char *argv[] ) {
    523     cout << "Usage: " << argv[0] << " options are:" << endl;
     512    cout << "Usage: " << argv[0] << " [options] [input-file (default stdin)] [output-file (default stdout)], where options are:" << endl;
    524513        int i = 0, j = 1;                                                                       // j skips starting colon
    525514        for ( ; long_opts[i].name != 0 && optstring[j] != '\0'; i += 1, j += 1 ) {
    … …  
    547536} // usage
    548537
    549 static void parse_cmdline( int argc, char * argv[], const char *& filename ) {
     538static void parse_cmdline( int argc, char * argv[] ) {
    550539        opterr = 0;                                                                                     // (global) prevent getopt from printing error messages
    551540
    … …  
    621610                  case 'D':                                                                             // ignore -Dxxx, forwarded by cpp, hidden
    622611                        break;
    623                   case 'F':                                                                             // source file-name without suffix, hidden
    624                         filename = optarg;
    625                         break;
    626612                  case '?':                                                                             // unknown option
    627613                        if ( optopt ) {                                                         // short option ?

  • tests/Makefile.am

    r85142648 r970141d  
    3535
    3636# applies to both programs
     37# since automake doesn't have support for CFA we have to
    3738AM_CFLAGS = $(if $(test), 2> $(test), ) \
    3839        -g \
    … …  
    4243        -DIN_DIR="${abs_srcdir}/.in/"
    4344
    44 AM_CFLAGS += ${DEBUG_FLAGS} ${INSTALL_FLAGS} ${ARCH_FLAGS}
    45 CC = @CFACC@
     45# adjust CC to current flags
     46CC = $(if $(DISTCC_CFA_PATH),distcc $(DISTCC_CFA_PATH) -dist-tree -in-tree,@CFACC@ ${DEBUG_FLAGS} ${INSTALL_FLAGS} ${ARCH_FLAGS})
     47CFACC = $(CC)
     48
     49# get local binary for depedencies
     50CFACCBIN = @CFACC@
     51
     52# adjusted CC but without the actual distcc call
     53CFACCLOCAL = $(if $(DISTCC_CFA_PATH),$(DISTCC_CFA_PATH) -dist-tree -in-tree,@CFACC@ ${DEBUG_FLAGS} ${INSTALL_FLAGS} ${ARCH_FLAGS})
    4654
    4755PRETTY_PATH=mkdir -p $(dir $(abspath ${@})) && cd ${srcdir} &&
    … …  
    5765#----------------------------------------------------------------------------------------------------------------
    5866all-local :
    59         @+${TEST_PY} --debug=${debug}  --install=${installed} --archive-errors=${archiveerrors} ${concurrent} ${timeouts} ${quick_test}
     67        @+${TEST_PY} --debug=${debug} --install=${installed} --archive-errors=${archiveerrors} ${concurrent} ${timeouts} ${quick_test}
    6068
    6169all-tests :
    62         @+${TEST_PY} --debug=${debug}  --install=${installed} --archive-errors=${archiveerrors} ${concurrent} ${timeouts} --all # '@' => do not echo command (SILENT), '+' => allows recursive make from within python program
     70        @+${TEST_PY} --debug=${debug} --install=${installed} --archive-errors=${archiveerrors} ${concurrent} ${timeouts} --all # '@' => do not echo command (SILENT), '+' => allows recursive make from within python program
    6371
    6472clean-local :
    … …  
    8795
    8896# Use for all tests, make sure the path are correct and all flags are added
    89 CFACOMPILETEST=$(PRETTY_PATH) $(CFACOMPILE) $(shell realpath --relative-to=${srcdir} ${<}) $($(shell echo "${@}_FLAGS" | sed 's/-\|\//_/g'))
    90 
    91 # Use for tests that either generate an executable, print directyl to stdout or the make command is expected to fail
    92 CFATEST_STDOUT=$(CFACOMPILETEST) -o $(abspath ${@})
    93 
    94 # Use for tests where the make command is expecte to succeed but the expected.txt should be compared to stderr
    95 CFATEST_STDERR=$(CFACOMPILETEST) 2> $(abspath ${@})
     97CFACOMPILETEST=$(PRETTY_PATH) $(CFACOMPILE) $(shell realpath --relative-to=${srcdir} ${<}) $($(shell echo "${@}_FLAGSCFA" | sed 's/-\|\//_/g'))
    9698
    9799#----------------------------------------------------------------------------------------------------------------
    98100
    99101# implicit rule so not all test require a rule
    100 % : %.cfa $(CFACC)
    101         $(CFATEST_STDOUT)
     102# split into two steps to support compiling remotely using distcc
     103# don't use distcc to do the linking because distcc doesn't do linking
     104% : %.cfa $(CFACCBIN)
     105        $(CFACOMPILETEST) -c -o $(abspath ${@}).o
     106        $(CFACCLOCAL) $($(shell echo "${@}_FLAGSLD" | sed 's/-\|\//_/g')) $(abspath ${@}).o -o $(abspath ${@})
    102107
     108# implicit rule for c++ test
     109# convient for testing the testsuite itself but not actuall used
    103110% : %.cpp
    104111        $(PRETTY_PATH) $(CXXCOMPILE) $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    105112
    106113#------------------------------------------------------------------------------
    107 # TARGET WITH STANDARD RULE BUT CUSTOM FLAGS
     114# TARGETS WITH CUSTOM FLAGS
    108115#------------------------------------------------------------------------------
    109 # Expected failures
    110 declarationSpecifier_FLAGS= -CFA -XCFA -p
    111 gccExtensions_FLAGS= -CFA -XCFA -p
    112 extension_FLAGS= -CFA -XCFA -p
    113 attributes_FLAGS= -CFA -XCFA -p
    114 functions_FLAGS= -CFA -XCFA -p
    115 KRfunctions_FLAGS= -CFA -XCFA -p
    116 gmp_FLAGS= -lgmp
     116# custom libs
     117gmp_FLAGSLD= -lgmp
    117118
    118119#------------------------------------------------------------------------------
    119 # Expected failures
    120 completeTypeError_FLAGS= -DERR1
     120# Generated code
     121GENERATED_CODE = declarationSpecifier gccExtensions extension attributes functions KRfunctions
     122$(GENERATED_CODE): % : %.cfa $(CFACCBIN)
     123        $(CFACOMPILETEST) -CFA -XCFA -p -c -fsyntax-only -o $(abspath ${@})
     124
     125# Use for tests where the make command is expected to succeed but the expected.txt should be compared to stderr
     126EXPECT_STDERR = builtins/sync warnings/self-assignment
     127$(EXPECT_STDERR): % : %.cfa $(CFACCBIN)
     128        $(CFACOMPILETEST) -c -fsyntax-only 2> $(abspath ${@})
    121129
    122130#------------------------------------------------------------------------------
    123131# CUSTOM TARGET
    124132#------------------------------------------------------------------------------
    125 typedefRedef-ERR1: typedefRedef.cfa $(CFACC)
    126         $(CFATEST_STDOUT) -DERR1
     133# expected failures
     134# use custom target since they require a custom define and custom dependencies
     135alloc-ERROR : alloc.cfa $(CFACCBIN)
     136        $(CFACOMPILETEST) -DERR1 -c -fsyntax-only -o $(abspath ${@})
    127137
    128 alloc-ERROR: alloc.cfa $(CFACC)
    129         $(CFATEST_STDOUT) -DERR1
     138typedefRedef-ERR1 : typedefRedef.cfa $(CFACCBIN)
     139        $(CFACOMPILETEST) -DERR1 -c -fsyntax-only -o $(abspath ${@})
    130140
    131 nested-types-ERR1: nested-types.cfa $(CFACC)
    132         $(CFATEST_STDOUT) -DERR1
     141nested-types-ERR1 : nested-types.cfa $(CFACCBIN)
     142        $(CFACOMPILETEST) -DERR1 -c -fsyntax-only -o $(abspath ${@})
    133143
    134 nested-types-ERR2: nested-types.cfa $(CFACC)
    135         $(CFATEST_STDOUT) -DERR2
     144nested-types-ERR2 : nested-types.cfa $(CFACCBIN)
     145        $(CFACOMPILETEST) -DERR2 -c -fsyntax-only -o $(abspath ${@})
    136146
    137 raii/dtor-early-exit-ERR1: raii/dtor-early-exit.cfa $(CFACC)
    138         $(CFATEST_STDOUT) -DERR1
     147raii/memberCtors-ERR1 : raii/memberCtors.cfa $(CFACCBIN)
     148        $(CFACOMPILETEST) -DERR1 -c -fsyntax-only -o $(abspath ${@})
    139149
    140 raii/dtor-early-exit-ERR2: raii/dtor-early-exit.cfa $(CFACC)
    141         $(CFATEST_STDOUT) -DERR2
     150raii/ctor-autogen-ERR1 : raii/ctor-autogen.cfa $(CFACCBIN)
     151        $(CFACOMPILETEST) -DERR1 -c -fsyntax-only -o $(abspath ${@})
    142152
    143 raii/memberCtors-ERR1: raii/memberCtors.cfa $(CFACC)
    144         $(CFATEST_STDOUT) -DERR1
     153raii/dtor-early-exit-ERR1 : raii/dtor-early-exit.cfa $(CFACCBIN)
     154        $(CFACOMPILETEST) -DERR1 -c -fsyntax-only -o $(abspath ${@})
    145155
    146 raii/ctor-autogen-ERR1: raii/ctor-autogen.cfa $(CFACC)
    147         $(CFATEST_STDOUT) -DERR1
     156raii/dtor-early-exit-ERR2 : raii/dtor-early-exit.cfa $(CFACCBIN)
     157        $(CFACOMPILETEST) -DERR2 -c -fsyntax-only -o $(abspath ${@})
    148158
    149 #builtins
    150 builtins/sync: builtins/sync.cfa $(CFACC)
    151         $(CFATEST_STDERR) -fsyntax-only
    152 
    153 # Warnings
    154 warnings/self-assignment: warnings/self-assignment.cfa $(CFACC)
    155         $(CFATEST_STDERR) -fsyntax-only
     159#------------------------------------------------------------------------------
     160# Other targets

  • tests/Makefile.in

    r85142648 r970141d  
    212212AWK = @AWK@
    213213BUILD_IN_TREE_FLAGS = @BUILD_IN_TREE_FLAGS@
    214 CC = @CFACC@
     214
     215# adjust CC to current flags
     216CC = $(if $(DISTCC_CFA_PATH),distcc $(DISTCC_CFA_PATH) -dist-tree -in-tree,@CFACC@ ${DEBUG_FLAGS} ${INSTALL_FLAGS} ${ARCH_FLAGS})
    215217CCAS = @CCAS@
    216218CCASDEPMODE = @CCASDEPMODE@
    217219CCASFLAGS = @CCASFLAGS@
    218220CCDEPMODE = @CCDEPMODE@
    219 CFACC = @CFACC@
     221CFACC = $(CC)
    220222CFACPP = @CFACPP@
    221223CFA_BACKEND_CC = @CFA_BACKEND_CC@
    … …  
    248250FGREP = @FGREP@
    249251GREP = @GREP@
     252HAS_DISTCC = @HAS_DISTCC@
    250253HOST_FLAGS = @HOST_FLAGS@
    251254INSTALL = @INSTALL@
    … …  
    386389
    387390# applies to both programs
    388 AM_CFLAGS = $(if $(test), 2> $(test), ) -g -Wall -Wno-unused-function \
    389         -quiet @CFA_FLAGS@ -DIN_DIR="${abs_srcdir}/.in/" \
    390         ${DEBUG_FLAGS} ${INSTALL_FLAGS} ${ARCH_FLAGS}
     391# since automake doesn't have support for CFA we have to
     392AM_CFLAGS = $(if $(test), 2> $(test), ) \
     393        -g \
     394        -Wall \
     395        -Wno-unused-function \
     396        -quiet @CFA_FLAGS@ \
     397        -DIN_DIR="${abs_srcdir}/.in/"
     398
     399
     400# get local binary for depedencies
     401CFACCBIN = @CFACC@
     402
     403# adjusted CC but without the actual distcc call
     404CFACCLOCAL = $(if $(DISTCC_CFA_PATH),$(DISTCC_CFA_PATH) -dist-tree -in-tree,@CFACC@ ${DEBUG_FLAGS} ${INSTALL_FLAGS} ${ARCH_FLAGS})
    391405PRETTY_PATH = mkdir -p $(dir $(abspath ${@})) && cd ${srcdir} &&
    392406avl_test_SOURCES = avltree/avl_test.cfa avltree/avl0.cfa avltree/avl1.cfa avltree/avl2.cfa avltree/avl3.cfa avltree/avl4.cfa avltree/avl-private.cfa
    … …  
    397411
    398412# Use for all tests, make sure the path are correct and all flags are added
    399 CFACOMPILETEST = $(PRETTY_PATH) $(CFACOMPILE) $(shell realpath --relative-to=${srcdir} ${<}) $($(shell echo "${@}_FLAGS" | sed 's/-\|\//_/g'))
    400 
    401 # Use for tests that either generate an executable, print directyl to stdout or the make command is expected to fail
    402 CFATEST_STDOUT = $(CFACOMPILETEST) -o $(abspath ${@})
    403 
    404 # Use for tests where the make command is expecte to succeed but the expected.txt should be compared to stderr
    405 CFATEST_STDERR = $(CFACOMPILETEST) 2> $(abspath ${@})
     413CFACOMPILETEST = $(PRETTY_PATH) $(CFACOMPILE) $(shell realpath --relative-to=${srcdir} ${<}) $($(shell echo "${@}_FLAGSCFA" | sed 's/-\|\//_/g'))
    406414
    407415#------------------------------------------------------------------------------
    408 # TARGET WITH STANDARD RULE BUT CUSTOM FLAGS
     416# TARGETS WITH CUSTOM FLAGS
    409417#------------------------------------------------------------------------------
    410 # Expected failures
    411 declarationSpecifier_FLAGS = -CFA -XCFA -p
    412 gccExtensions_FLAGS = -CFA -XCFA -p
    413 extension_FLAGS = -CFA -XCFA -p
    414 attributes_FLAGS = -CFA -XCFA -p
    415 functions_FLAGS = -CFA -XCFA -p
    416 KRfunctions_FLAGS = -CFA -XCFA -p
    417 gmp_FLAGS = -lgmp
     418# custom libs
     419gmp_FLAGSLD = -lgmp
    418420
    419421#------------------------------------------------------------------------------
    420 # Expected failures
    421 completeTypeError_FLAGS = -DERR1
     422# Generated code
     423GENERATED_CODE = declarationSpecifier gccExtensions extension attributes functions KRfunctions
     424
     425# Use for tests where the make command is expected to succeed but the expected.txt should be compared to stderr
     426EXPECT_STDERR = builtins/sync warnings/self-assignment
    422427all: all-am
    423428
    … …  
    771776#----------------------------------------------------------------------------------------------------------------
    772777all-local :
    773         @+${TEST_PY} --debug=${debug}  --install=${installed} --archive-errors=${archiveerrors} ${concurrent} ${timeouts} ${quick_test}
     778        @+${TEST_PY} --debug=${debug} --install=${installed} --archive-errors=${archiveerrors} ${concurrent} ${timeouts} ${quick_test}
    774779
    775780all-tests :
    776         @+${TEST_PY} --debug=${debug}  --install=${installed} --archive-errors=${archiveerrors} ${concurrent} ${timeouts} --all # '@' => do not echo command (SILENT), '+' => allows recursive make from within python program
     781        @+${TEST_PY} --debug=${debug} --install=${installed} --archive-errors=${archiveerrors} ${concurrent} ${timeouts} --all # '@' => do not echo command (SILENT), '+' => allows recursive make from within python program
    777782
    778783clean-local :
    … …  
    801806
    802807# implicit rule so not all test require a rule
    803 % : %.cfa $(CFACC)
    804         $(CFATEST_STDOUT)
    805 
     808# split into two steps to support compiling remotely using distcc
     809# don't use distcc to do the linking because distcc doesn't do linking
     810% : %.cfa $(CFACCBIN)
     811        $(CFACOMPILETEST) -c -o $(abspath ${@}).o
     812        $(CFACCLOCAL) $($(shell echo "${@}_FLAGSLD" | sed 's/-\|\//_/g')) $(abspath ${@}).o -o $(abspath ${@})
     813
     814# implicit rule for c++ test
     815# convient for testing the testsuite itself but not actuall used
    806816% : %.cpp
    807817        $(PRETTY_PATH) $(CXXCOMPILE) $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     818$(GENERATED_CODE): % : %.cfa $(CFACCBIN)
     819        $(CFACOMPILETEST) -CFA -XCFA -p -c -fsyntax-only -o $(abspath ${@})
     820$(EXPECT_STDERR): % : %.cfa $(CFACCBIN)
     821        $(CFACOMPILETEST) -c -fsyntax-only 2> $(abspath ${@})
    808822
    809823#------------------------------------------------------------------------------
    810824# CUSTOM TARGET
    811825#------------------------------------------------------------------------------
    812 typedefRedef-ERR1: typedefRedef.cfa $(CFACC)
    813         $(CFATEST_STDOUT) -DERR1
    814 
    815 alloc-ERROR: alloc.cfa $(CFACC)
    816         $(CFATEST_STDOUT) -DERR1
    817 
    818 nested-types-ERR1: nested-types.cfa $(CFACC)
    819         $(CFATEST_STDOUT) -DERR1
    820 
    821 nested-types-ERR2: nested-types.cfa $(CFACC)
    822         $(CFATEST_STDOUT) -DERR2
    823 
    824 raii/dtor-early-exit-ERR1: raii/dtor-early-exit.cfa $(CFACC)
    825         $(CFATEST_STDOUT) -DERR1
    826 
    827 raii/dtor-early-exit-ERR2: raii/dtor-early-exit.cfa $(CFACC)
    828         $(CFATEST_STDOUT) -DERR2
    829 
    830 raii/memberCtors-ERR1: raii/memberCtors.cfa $(CFACC)
    831         $(CFATEST_STDOUT) -DERR1
    832 
    833 raii/ctor-autogen-ERR1: raii/ctor-autogen.cfa $(CFACC)
    834         $(CFATEST_STDOUT) -DERR1
    835 
    836 #builtins
    837 builtins/sync: builtins/sync.cfa $(CFACC)
    838         $(CFATEST_STDERR) -fsyntax-only
    839 
    840 # Warnings
    841 warnings/self-assignment: warnings/self-assignment.cfa $(CFACC)
    842         $(CFATEST_STDERR) -fsyntax-only
     826# expected failures
     827# use custom target since they require a custom define and custom dependencies
     828alloc-ERROR : alloc.cfa $(CFACCBIN)
     829        $(CFACOMPILETEST) -DERR1 -c -fsyntax-only -o $(abspath ${@})
     830
     831typedefRedef-ERR1 : typedefRedef.cfa $(CFACCBIN)
     832        $(CFACOMPILETEST) -DERR1 -c -fsyntax-only -o $(abspath ${@})
     833
     834nested-types-ERR1 : nested-types.cfa $(CFACCBIN)
     835        $(CFACOMPILETEST) -DERR1 -c -fsyntax-only -o $(abspath ${@})
     836
     837nested-types-ERR2 : nested-types.cfa $(CFACCBIN)
     838        $(CFACOMPILETEST) -DERR2 -c -fsyntax-only -o $(abspath ${@})
     839
     840raii/memberCtors-ERR1 : raii/memberCtors.cfa $(CFACCBIN)
     841        $(CFACOMPILETEST) -DERR1 -c -fsyntax-only -o $(abspath ${@})
     842
     843raii/ctor-autogen-ERR1 : raii/ctor-autogen.cfa $(CFACCBIN)
     844        $(CFACOMPILETEST) -DERR1 -c -fsyntax-only -o $(abspath ${@})
     845
     846raii/dtor-early-exit-ERR1 : raii/dtor-early-exit.cfa $(CFACCBIN)
     847        $(CFACOMPILETEST) -DERR1 -c -fsyntax-only -o $(abspath ${@})
     848
     849raii/dtor-early-exit-ERR2 : raii/dtor-early-exit.cfa $(CFACCBIN)
     850        $(CFACOMPILETEST) -DERR2 -c -fsyntax-only -o $(abspath ${@})
     851
     852#------------------------------------------------------------------------------
     853# Other targets
    843854
    844855# Tell versions [3.59,3.63) of GNU make to not export all variables.

  • tests/config.py.in

    r85142648 r970141d  
    88BUILDDIR = "@abs_builddir@"
    99HOSTARCH = "@host_cpu@"
     10DISTRIBUTE = @HAS_DISTCC@

  • tests/pybin/settings.py

    r85142648 r970141d  
    1414        SRCDIR = os.path.abspath(config.SRCDIR)
    1515        BUILDDIR = os.path.abspath(config.BUILDDIR)
     16        distribute = config.DISTRIBUTE
    1617        os.chdir(testpath)
    1718
    … …  
    8889                self.string = "debug" if value else "no debug"
    8990                self.flags  = """DEBUG_FLAGS=%s""" % ("-debug -O0" if value else "-nodebug -O2")
     91                self.path   = "debug" if value else "nodebug"
    9092
    9193class Install:
    9294        def __init__(self, value):
     95                if value:
     96                        distribute = False
     97
    9398                self.string = "installed" if value else "in-tree"
    9499                self.flags  = """INSTALL_FLAGS=%s""" % ("" if value else "-in-tree")
    … …  
    109114def init( options ):
    110115        global arch
     116        global archive
     117        global debug
     118        global distcc
    111119        global dry_run
    112120        global generating
     121        global install
    113122        global make
    114         global debug
    115         global install
     123        global output_width
    116124        global timeout
    117         global output_width
    118         global archive
    119125
    120         dry_run      = options.dry_run
     126        arch         = Architecture(options.arch)
     127        archive      = os.path.abspath(os.path.join(original_path, options.archive_errors)) if options.archive_errors else None
     128        debug        = Debug(options.debug)
     129        dry_run      = options.dry_run # must be called before tools.config_hash()
     130        distcc       = "DISTCC_CFA_PATH=~/.cfadistcc/%s/cfa" % tools.config_hash()
    121131        generating   = options.regenerate_expected
     132        install      = Install(options.install)
    122133        make         = ['make']
    123         debug        = Debug(options.debug)
    124         install      = Install(options.install)
    125         arch         = Architecture(options.arch)
     134        output_width = 24
    126135        timeout      = Timeouts(options.timeout, options.global_timeout)
    127         output_width = 24
    128         archive      = os.path.abspath(os.path.join(original_path, options.archive_errors)) if options.archive_errors else None
    129136
     137        # if we distribute, distcc errors will fail tests, use log file for distcc
     138        # don't use "'DISTCC_LOG' not in os.environ" because it can be set to ''
     139        if distribute and not os.environ.get('DISTCC_LOG'):
     140                os.putenv('DISTCC_LOG', os.path.join(BUILDDIR, 'distcc_error.log'))
    130141
    131142def update_make_cmd(force, jobs):
    … …  
    136147def validate():
    137148        errf = os.path.join(BUILDDIR, ".validate.err")
    138         make_ret, out = tools.make( ".validate", error_file = errf, output=subprocess.DEVNULL, error=subprocess.DEVNULL )
     149        make_ret, out = tools.make( ".validate", error_file = errf, output_file=subprocess.DEVNULL, error=subprocess.DEVNULL )
    139150        if make_ret != 0:
    140151                with open (errf, "r") as myfile:

  • tests/pybin/tools.py

    r85142648 r970141d  
    2323
    2424# helper functions to run terminal commands
    25 def sh(*cmd, timeout = False, output = None, input = None, error = subprocess.STDOUT):
     25def sh(*cmd, timeout = False, output_file = None, input_file = None, input_text = None, error = subprocess.STDOUT, ignore_dry_run = False):
    2626        cmd = list(cmd)
    2727
     28        if input_file and input_text:
     29                return 401, "Cannot use both text and file inputs"
     30
    2831        # if this is a dry_run, only print the commands that would be ran
    29         if settings.dry_run :
     32        if settings.dry_run and not ignore_dry_run:
    3033                cmd = "{} cmd: {}".format(os.getcwd(), ' '.join(cmd))
    31                 if output and not isinstance(output, int):
     34                if output_file and not isinstance(output_file, int):
    3235                        cmd += " > "
    33                         cmd += output
     36                        cmd += output_file
    3437
    3538                if error and not isinstance(error, int):
    … …  
    3740                        cmd += error
    3841
    39                 if input and not isinstance(input, int) and os.path.isfile(input):
     42                if input_file and not isinstance(input_file, int) and os.path.isfile(input_file):
    4043                        cmd += " < "
    41                         cmd += input
     44                        cmd += input_file
    4245
    4346                print(cmd)
    … …  
    4649        with contextlib.ExitStack() as onexit:
    4750                # add input redirection if needed
    48                 input = openfd(input, 'r', onexit, True)
     51                input_file = openfd(input_file, 'r', onexit, True)
    4952
    5053                # add output redirection if needed
    51                 output = openfd(output, 'w', onexit, False)
     54                output_file = openfd(output_file, 'w', onexit, False)
    5255
    5356                # add error redirection if needed
    … …  
    5861                        proc = subprocess.run(
    5962                                cmd,
    60                                 stdin =input,
    61                                 stdout=output,
    62                                 stderr=error,
    63                                 timeout=settings.timeout.single if timeout else None
     63                                **({'input' : bytes(input_text, encoding='utf-8')} if input_text else {'stdin' : input_file}),
     64                                stdout  = output_file,
     65                                stderr  = error,
     66                                timeout = settings.timeout.single if timeout else None
    6467                        )
     68
    6569                        return proc.returncode, proc.stdout.decode("utf-8") if proc.stdout else None
    6670                except subprocess.TimeoutExpired:
    … …  
    7579                return False
    7680
    77         code, out = sh("file %s" % fname, output=subprocess.PIPE)
     81        code, out = sh("file %s" % fname, output_file=subprocess.PIPE)
    7882        if code != 0:
    7983                return False
    … …  
    107111        if isinstance(files, str ): files = [ files ]
    108112        for file in files:
    109                 sh( 'rm', '-f', file, output=subprocess.DEVNULL, error=subprocess.DEVNULL )
     113                sh( 'rm', '-f', file, output_file=subprocess.DEVNULL, error=subprocess.DEVNULL )
    110114
    111115# Create 1 or more directory
    … …  
    115119                p = os.path.normpath( file )
    116120                d = os.path.dirname ( p )
    117                 sh( 'mkdir', '-p', d, output=subprocess.DEVNULL, error=subprocess.DEVNULL )
     121                sh( 'mkdir', '-p', d, output_file=subprocess.DEVNULL, error=subprocess.DEVNULL )
    118122
    119123
    … …  
    138142                lhs,
    139143                rhs,
    140                 output=subprocess.PIPE
     144                output_file=subprocess.PIPE
    141145        )
    142146
    143147# call make
    144 def make(target, *, flags = '', output = None, error = None, error_file = None, silent = False):
     148def make(target, *, flags = '', output_file = None, error = None, error_file = None, silent = False):
    145149        test_param = """test="%s" """ % (error_file) if error_file else None
    146150        cmd = [
    … …  
    151155                settings.debug.flags,
    152156                settings.install.flags,
     157                settings.distcc if settings.distribute else None,
    153158                flags,
    154159                target
    155160        ]
    156161        cmd = [s for s in cmd if s]
    157         return sh(*cmd, output=output, error=error)
     162        return sh(*cmd, output_file=output_file, error=error)
    158163
    159164def which(program):
    … …  
    201206# cat one file into the other
    202207def cat(source, dest):
    203         ret, _ = sh("cat", source, output=dest)
     208        ret, _ = sh("cat", source, output_file=dest)
    204209        return ret
    205210
    … …  
    256261                        os.write(int(make_jobs_fds.group(3)), tokens)
    257262                else :
    258                         options.jobs = multiprocessing.cpu_count()
     263                        if settings.distribute:
     264                                ret, jstr = sh("distcc", "-j", output_file=subprocess.PIPE, ignore_dry_run=True)
     265                                if ret == 0:
     266                                        options.jobs = int(jstr.strip())
     267                                else :
     268                                        options.jobs = multiprocessing.cpu_count()
     269                        else:
     270                                options.jobs = multiprocessing.cpu_count()
    259271        else :
    260272                force = True
    … …  
    274286################################################################################
    275287
     288# get hash for given configuration
     289def config_hash():
     290        path = os.path.normpath(os.path.join(
     291                settings.SRCDIR,
     292        ))
     293
     294        distcc_hash = os.path.join(settings.SRCDIR, '../tools/build/distcc_hash')
     295        config = "%s-%s" % (settings.arch.target, settings.debug.path)
     296        _, out = sh(distcc_hash, config, output_file=subprocess.PIPE, ignore_dry_run=True)
     297        return out.strip()
     298
     299# get pretty string for time of day
    276300def pretty_now():
    277301        ts = time.time()
    … …  
    308332                return 1, "ERR No core dump"
    309333
    310         return sh('gdb', '-n', path, core, '-batch', '-x', cmd, output=subprocess.PIPE)
     334        return sh('gdb', '-n', path, core, '-batch', '-x', cmd, output_file=subprocess.PIPE)
    311335
    312336def core_archive(dst, name, exe):

  • tests/test.py

    r85142648 r970141d  
    143143        # build, skipping to next test on error
    144144        with Timed() as comp_dur:
    145                 make_ret, _ = make( test.target(), output=subprocess.DEVNULL, error=out_file, error_file = err_file )
     145                make_ret, _ = make( test.target(), output_file=subprocess.DEVNULL, error=out_file, error_file = err_file )
    146146
    147147        run_dur = None
    … …  
    153153                                if settings.dry_run or is_exe(exe_file):
    154154                                        # run test
    155                                         retcode, _ = sh(exe_file, output=out_file, input=in_file, timeout=True)
     155                                        retcode, _ = sh(exe_file, output_file=out_file, input_file=in_file, timeout=True)
    156156                                else :
    157157                                        # simply cat the result into the output
    … …  
    219219def run_tests(tests, jobs) :
    220220        # clean the sandbox from previous commands
    221         make('clean', output=subprocess.DEVNULL, error=subprocess.DEVNULL)
     221        make('clean', output_file=subprocess.DEVNULL, error=subprocess.DEVNULL)
    222222
    223223        # create the executor for our jobs and handle the signal properly
    … …  
    260260
    261261        # clean the workspace
    262         make('clean', output=subprocess.DEVNULL, error=subprocess.DEVNULL)
     262        make('clean', output_file=subprocess.DEVNULL, error=subprocess.DEVNULL)
    263263
    264264        return 1 if failed else 0

  • tools/Makefile.in

    r85142648 r970141d  
    238238FGREP = @FGREP@
    239239GREP = @GREP@
     240HAS_DISTCC = @HAS_DISTCC@
    240241HOST_FLAGS = @HOST_FLAGS@
    241242INSTALL = @INSTALL@

  • tools/prettyprinter/Makefile.in

    r85142648 r970141d  
    267267FGREP = @FGREP@
    268268GREP = @GREP@
     269HAS_DISTCC = @HAS_DISTCC@
    269270HOST_FLAGS = @HOST_FLAGS@
    270271INSTALL = @INSTALL@
Note: See TracChangeset for help on using the changeset viewer.