Index: doc/LaTeXmacros/common.sty =================================================================== --- doc/LaTeXmacros/common.sty (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ doc/LaTeXmacros/common.sty (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -11,6 +11,6 @@ %% Created On : Sat Apr 9 10:06:17 2016 %% Last Modified By : Peter A. Buhr -%% Last Modified On : Sat Apr 2 17:35:23 2022 -%% Update Count : 570 +%% Last Modified On : Fri Feb 10 12:09:30 2023 +%% Update Count : 581 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% @@ -30,5 +30,5 @@ \setlist[itemize,1]{label=\textbullet}% local %\renewcommand{\labelitemi}{{\raisebox{0.25ex}{\footnotesize$\bullet$}}} -\setlist[enumerate]{listparindent=\parindent}% global +\setlist[enumerate]{topsep=0.5ex,parsep=0.25ex,itemsep=0.25ex,listparindent=\parindent}% global \setlist[enumerate,2]{leftmargin=\parindent,labelsep=*,align=parleft,label=\alph*.}% local \setlist[description]{topsep=0.5ex,itemsep=0pt,listparindent=\parindent,leftmargin=\parindent,labelsep=1.5ex} @@ -49,9 +49,10 @@ \newcommand{\CCseventeen}{\protect\CCIcon{17}\xspace} % C++17 symbolic name \newcommand{\CCtwenty}{\protect\CCIcon{20}\xspace} % C++20 symbolic name -\newcommand{\Csharp}{C\raisebox{-0.7ex}{\Large$^\sharp$}\xspace} % C# symbolic name +\newcommand{\Csharp}{C\raisebox{-0.7ex}{\relsize{2}$^\sharp$}\xspace} % C# symbolic name %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -\usepackage{pslatex} % reduce size of san serif font +\usepackage[scaled=0.85]{helvet} % descent Helvetica font and scale to times size +\usepackage[T1]{fontenc} \usepackage{relsize} % must be after change to small or selects old size \usepackage{rotating} @@ -195,4 +196,7 @@ \newcommand{\viz}{\VIZ\CheckPeriod} +\newcommand{\VS}{\abbrevFont{vs}} +\newcommand{\vs}{\VS\CheckPeriod} + \newenvironment{cquote}{% \list{}{\lstset{resetmargins=true,aboveskip=0pt,belowskip=0pt}\topsep=4pt\parsep=0pt\leftmargin=\parindentlnth\rightmargin\leftmargin}% @@ -244,5 +248,7 @@ \renewcommand{\reftextpagerange}[2]{\unskip, pp.~\pageref{#1}--\pageref{#2}} \newcommand{\VRef}[2][Section]{\ifx#1\@empty\else{#1}\nobreakspace\fi\vref{#2}} +\newcommand{\VRefrange}[3][Sections]{\ifx#1\@empty\else{#1}\nobreakspace\fi\vrefrange{#2}{#3}} \newcommand{\VPageref}[2][page]{\ifx#1\@empty\else{#1}\nobreakspace\fi\pageref{#2}} +\newcommand{\VPagerefrange}[3][pages]{\ifx#1\@empty\else{#1}\nobreakspace\fi\pageref{#2}{#3}} \let\Oldthebibliography\thebibliography Index: doc/LaTeXmacros/common.tex =================================================================== --- doc/LaTeXmacros/common.tex (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ doc/LaTeXmacros/common.tex (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -11,6 +11,6 @@ %% Created On : Sat Apr 9 10:06:17 2016 %% Last Modified By : Peter A. Buhr -%% Last Modified On : Tue Apr 26 16:02:48 2022 -%% Update Count : 558 +%% Last Modified On : Fri Feb 10 11:48:00 2023 +%% Update Count : 564 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% @@ -49,9 +49,10 @@ \newcommand{\CCseventeen}{\protect\CCIcon{17}\xspace} % C++17 symbolic name \newcommand{\CCtwenty}{\protect\CCIcon{20}\xspace} % C++20 symbolic name -\newcommand{\Csharp}{C\raisebox{-0.7ex}{\Large$^\sharp$}\xspace} % C# symbolic name +\newcommand{\Csharp}{C\raisebox{-0.7ex}{\relsize{2}$^\sharp$}\xspace} % C# symbolic name %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -\usepackage{pslatex} % reduce size of san serif font +\usepackage[scaled=0.85]{helvet} % descent Helvetica font and scale to times size +\usepackage[T1]{fontenc} \usepackage{relsize} % must be after change to small or selects old size \usepackage{rotating} @@ -196,4 +197,6 @@ \newcommand{\viz}{\VIZ\CheckPeriod} +\newcommand{\VS}{\abbrevFont{vs}} +\newcommand{\vs}{\VS\CheckPeriod} \makeatother Index: doc/bibliography/pl.bib =================================================================== --- doc/bibliography/pl.bib (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ doc/bibliography/pl.bib (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -147,5 +147,5 @@ author = {Zhang, Yizhou and Salvaneschi, Guido and Beightol, Quinn and Liskov, Barbara and Myers, Andrew C.}, title = {Accepting Blame for Safe Tunneled Exceptions}, - booktitle = {Proceedings of the 37th ACM SIGPLAN Conference on Programming Language Design and Implementation}, + organization= {Proceedings of the 37th ACM SIGPLAN Conference on Programming Language Design and Implementation}, series = {PLDI'16}, year = {2016}, @@ -196,4 +196,14 @@ }, comment = {Mentions Thoth in reference to delegation} +} + +@misc{ActorBenchmarks, + keywords = {Actors, microbenchmarks, uC++. CAF, AkkaC, AkkaT, ProtoActor}, + contributer = {pabuhr@plg}, + key = {ActorBenchmarks}, + title = {Actor Benchmarks}, + author = {Peter A. Buhr and Colby A. Parsons}, + howpublished= {\href{https://github.com/pabuhr/ActorExperiments}{https://\-github.com/\-pabuhr/\-ActorExperiments}}, + year = 2022, } @@ -245,4 +255,38 @@ } +@manual{Ada95, + keywords = {Ada}, + contributer = {pabuhr@plg}, + title = {{A}da Reference Manual}, + edition = {International Standard {ISO}/{IEC} {8652:1995(E)} with {COR.1:2000}}, + organization= {Intermetrics, Inc.}, + month = dec, + year = 1995, + note = {Language and Standards Libraries} +} + +@manual{Ada12, + keywords = {ISO/IEC Ada}, + contributer = {pabuhr@plg}, + author = {Ada12}, + title = {Programming languages -- {Ada} ISO/IEC 8652:2012}, + edition = {3rd}, + organization= {International Standard Organization}, + address = {Geneva, Switzerland}, + year = 2012, + note = {\href{https://www.iso.org/standard/61507.html}{https://\-www.iso.org/\-standard/\-61507.html}}, +} + +@manual{Ada95:annotated, + keywords = {Ada}, + contributer = {pabuhr@plg}, + title = {Annotated {A}da Reference Manual}, + edition = {International Standard {ISO}/{IEC} {8652:1995(E)} with {COR.1:2000}}, + organization= {Intermetrics, Inc.}, + month = dec, + year = 1995, + note = {Language and Standards Libraries} +} + @article{dim:ada, keywords = {Dimensional Analysis, Ada}, @@ -256,4 +300,19 @@ number = 2, pages = {189-203}, +} + +@article{Agrawal08, + keywords = {Adaptive scheduling, adversary, instantaneous parallelism, job scheduling, multiprocessing, multiprogramming, parallel computation, parallelism feedback, processor allocation, randomized algorithm, space sharing, span, thread scheduling, trim analysis, two-level scheduling, work, work-stealing}, + author = {Agrawal, Kunal and Leiserson, Charles E. and He, Yuxiong and Hsu, Wen Jing}, + title = {Adaptive Work-stealing with Parallelism Feedback}, + journal = {ACM Trans. Comput. Syst.}, + issue_date = {September 2008}, + volume = {26}, + number = {3}, + month = sep, + year = {2008}, + pages = {7:1-7:32}, + publisher = {ACM}, + address = {New York, NY, USA}, } @@ -377,4 +436,13 @@ year = 2016, note = {\href{http://doc.akka.io/docs/akka/2.4/AkkaScala.pdf}{http://\-doc.akka.io/\-docs/\-akka/\-2.4/\-AkkaScala.pdf}}, +} + +@misc{AkkaFuture, + contributer = {pabuhr@plg}, + key = {AkkaFuture}, + title = {Akka Futures}, + author = {{Lightbend}}, + howpublished= {\href{https://doc.akka.io/docs/akka/2.5/futures.html}{https://\-doc.akka.io/\-docs/\-akka/\-2.5/\-futures.html}}, + year = 2022, } @@ -548,4 +616,30 @@ } +@inproceedings{Mitzenmacher98, + author = {Mitzenmacher, Michael}, + title = {Analyses of Load Stealing Models Based on Differential Equations}, + organization= {Proceedings of the Tenth Annual ACM Symposium on Parallel Algorithms and Architectures}, + series = {SPAA '98}, + year = {1998}, + isbn = {0-89791-989-0}, + location = {Puerto Vallarta, Mexico}, + pages = {212-221}, + publisher = {ACM}, + address = {New York, NY, USA}, +} + +@inproceedings{Squillante91, + author = {Squillante, Mark S. and Nelson, Randolph D.}, + title = {Analysis of Task Migration in Shared-memory Multiprocessor Scheduling}, + organization= {Proceedings of the 1991 ACM SIGMETRICS Conference on Measurement and Modeling of Computer Systems}, + series = {SIGMETRICS '91}, + year = {1991}, + isbn = {0-89791-392-2}, + location = {San Diego, California, USA}, + pages = {143-155}, + publisher = {ACM}, + address = {New York, NY, USA}, +} + @article{Sinha00, author = {Saurabh Sinha and Mary Jean Harrold}, @@ -562,5 +656,5 @@ author = {Martin P. Robillard and Gail C. Murphy}, title = {Analyzing Exception Flow in {J}ava Programs}, - booktitle = {ESEC/FSE-7: Proceedings of the 7th European Software Engineering Conference held jointly + organization= {ESEC/FSE-7: Proceedings of the 7th European Software Engineering Conference held jointly with the 7th ACM SIGSOFT International Symposium on Foundations of Software Engineering}, year = 1999, @@ -604,5 +698,5 @@ author = {Henry Qin and Qian Li and Jacqueline Speiser and Peter Kraft and John Ousterhout}, title = {Arachne: Core-Aware Thread Management}, - booktitle = {13th {USENIX} Symp. on Oper. Sys. Design and Impl. ({OSDI} 18)}, + organization= {13th {USENIX} Symp. on Oper. Sys. Design and Impl. ({OSDI} 18)}, year = {2018}, address = {Carlsbad, CA}, @@ -661,5 +755,5 @@ author = {Jaewoong Chung and Luke Yen and Stephan Diestelhorst and Martin Pohlack and Michael Hohmuth and David Christie and Dan Grossman}, title = {ASF: AMD64 Extension for Lock-Free Data Structures and Transactional Memory}, - booktitle = {Proceedings of the 2010 43rd Annual IEEE/ACM International Symposium on Microarchitecture}, + organization= {Proceedings of the 2010 43rd Annual IEEE/ACM International Symposium on Microarchitecture}, series = {MICRO '43}, year = 2010, @@ -682,4 +776,13 @@ } +@misc{AsyncAwait, + contributer = {pabuhr@plg}, + key = {AsyncAwait}, + title = {Async Await}, + author = {{WikipediA}}, + howpublished= {\href{https://en.wikipedia.org/wiki/Async/await}{https://\-en.wikipedia.org/\-wiki/\-Async/\-await}}, + year = 2022, +} + @inproceedings{Krischer08, keywords = {exception handling, asynchronous, blocked tasks}, @@ -687,5 +790,5 @@ author = {Roy Krischer and Peter A. Buhr}, title = {Asynchronous Exception Propagation in Blocked Tasks}, - booktitle = {4th International Workshop on Exception Handling (WEH.08)}, + organization= {4th International Workshop on Exception Handling (WEH.08)}, optorganization= {16th International Symposium on the Foundations of Software Engineering (FSE 16)}, address = {Atlanta, U.S.A}, @@ -759,4 +862,13 @@ publisher = {ACM}, address = {New York, NY, USA}, +} + +@techreport{Neill09, + author = {Daniel Neill and Adam Wierman}, + title = {On the Benefits of Work Stealing in Shared-Memory Multiprocessors}, + institution = {Carnegie Mellon University}, + address = {California Institute of Technology, Pasadena, CA, USA}, + note = {\href{http://www.cs.cmu.edu/~acw/15740/paper.pdf}{http://\-www.cs.cmu.edu/\-$\sim$acw/\-15740/\-paper.pdf}, Accessed May 2014}, + year = 2009, } @@ -914,4 +1026,17 @@ year = 2006, pages = {1-21} +} + +@inproceedings{Ding12, + keywords = {fairness, multicore, time sharing, work stealing}, + author = {Ding, Xiaoning and Wang, Kaibo and Gibbons, Phillip B. and Zhang, Xiaodong}, + title = {BWS: Balanced Work Stealing for Time-sharing Multicores}, + organization= {Proceedings of the 7th ACM European Conference on Computer Systems}, + series = {EuroSys '12}, + year = {2012}, + location = {Bern, Switzerland}, + pages = {365-378}, + publisher = {ACM}, + address = {New York, NY, USA}, } @@ -2003,5 +2128,5 @@ author = {Adya, Atul and Howell, Jon and Theimer, Marvin and Bolosky, William J. and Douceur, John R.}, title = {Cooperative Task Management Without Manual Stack Management}, - booktitle = {Proc. of the General Track USENIX Tech. Conf.}, + organization= {Proc. of the General Track USENIX Tech. Conf.}, series = {ATEC '02}, year = {2002}, @@ -2111,4 +2236,15 @@ year = 2016, note = {\href{http://dlang.org/spec/spec.html}{http://\-dlang.org/\-spec/\-spec.html}}, +} + +@article{Acar02, + author = {Acar, Umut A. and Blelloch, Guy E. and Blumofe, Robert D.}, + title = {The Data Locality of Work Stealing}, + journal = {Theory of Computing Systems}, + volume = {35}, + number = {3}, + year = {2002}, + publisher = {Springer-Verlag}, + pages = {321-347}, } @@ -2370,6 +2506,6 @@ editor = {R. E. A. Mason}, organization= {IFIP}, - publisher = {North-Holland}, - summary = { + publisher = {North-Holland}, + summary = { Packages group related declarations or subprograms, and encapsulate data types. Separate interfaces and bodies promotes information @@ -2598,4 +2734,19 @@ address = {Waterview Corporate Center, 20 Waterview Boulevard, Parsippany, NJ 07054}, year = {1993} +} + +@inproceedings{Chen14, + keywords = {Core allocation, Multi-programmed, Work-stealing}, + author = {Chen, Quan and Zheng, Long and Guo, Minyi}, + title = {DWS: Demand-aware Work-Stealing in Multi-programmed Multi-core Architectures}, + organization= {Proceedings of Programming Models and Applications on Multicores and Manycores}, + series = {PMAM'14}, + year = {2007}, + location = {Orlando, FL, USA}, + pages = {131:131-131:139}, + articleno = {131}, + numpages = {9}, + publisher = {ACM}, + address = {New York, NY, USA}, } @@ -2631,4 +2782,26 @@ year = 2003, pages = {29-35}, +} + +@inproceedings{Hamidzadeh96, + keywords = {processor scheduling, resource allocation, shared memory systems, average memory referencing delay}, + author = {Hamidzadeh, B. and Lilja, D.J.}, + booktitle = {Distributed Computing Systems, 1996., Proceedings of the 16th International Conference on}, + title = {Dynamic scheduling strategies for shared-memory multiprocessors}, + year = {1996}, + month = {May}, + pages = {208-215}, +} + +@article{Hendler06, + keywords = {Concurrent programming; Load balancing; Work stealing; Lock-free; Data structures}, + author = {Hendler, Danny and Lev, Yossi and Moir, Mark and Shavit, Nir}, + title = {A dynamic-sized nonblocking work stealing deque}, + journal = {Distributed Computing}, + volume = {18}, + number = {3}, + year = {2006}, + publisher = {Springer-Verlag}, + pages = {189-207}, } @@ -2734,4 +2907,17 @@ } +@inproceedings{Blelloch04, + keywords = {chip multiprocessors, multithreaded architectures, scheduling algorithms, shared cache}, + author = {Blelloch, Guy E. and Gibbons, Phillip B.}, + title = {Effectively Sharing a Cache Among Threads}, + organization= {Proceedings of the Sixteenth Annual ACM Symposium on Parallelism in Algorithms and Architectures}, + series = {SPAA '04}, + year = {2004}, + location = {Barcelona, Spain}, + pages = {235-244}, + publisher = {ACM}, + address = {New York, NY, USA}, +} + @techreport{Habermann80, keywords = {Ada, threads}, @@ -2808,7 +2994,9 @@ title = {Encapsulation and Inheritance in Object-Oriented Programming Languages}, journal = sigplan, - volume = {21}, number = {11}, + volume = {21}, + number = {11}, pages = {38-45}, - month = nov, year = 1986, + month = nov, + year = 1986, comment = { Client, child interfaces should be distinct. Child interface @@ -2866,4 +3054,17 @@ } +@inproceedings{Ribic14, + keywords = {dvfs, energy efficiency, language runtimes, thread management, work stealing}, + author = {Ribic, Haris and Liu, Yu David}, + title = {Energy-efficient Work-stealing Language Runtimes}, + organization= {Proceedings of the 19th International Conference on Architectural Support for Programming Languages and Operating Systems}, + series = {ASPLOS '14}, + year = {2014}, + location = {Salt Lake City, Utah, USA}, + pages = {513-528}, + publisher = {ACM}, + address = {New York, NY, USA}, +} + @manual{EPT, keywords = {concurrency, light-weight threads}, @@ -2903,4 +3104,14 @@ publisher = {North Oxford Academic}, year = 1985 +} + +@article{Torrellas95, + author = {J. Torrellas and A. Tucker and A. Gupta}, + title = {Evaluating the Performance of Cache-Affinity Scheduling in Shared-Memory Multiprocessors}, + journal = {Journal of Parallel and Distributed Computing}, + volume = {24}, + number = {2}, + pages = {139-151}, + year = {1995}, } @@ -3614,4 +3825,5 @@ author = {Robert Griesemer and Rob Pike and Ken Thompson}, title = {{Go} Programming Language}, + address = {Mountain View, CA, USA}, organization= {Google}, year = 2009, @@ -3725,4 +3937,5 @@ @article{Michael04a, keywords = {Lock-free, synchronization, concurrent programming, memory management, multiprogramming, dynamic data structures}, + contributer = {pabuhr@plg}, author = {Maged M. Michael}, title = {Hazard Pointers: Safe Memory Reclamation for Lock-Free Objects}, @@ -3735,4 +3948,18 @@ publisher = {IEEE Press}, address = {Piscataway, NJ, USA}, +} + +@inproceedings{Johansson02, + keywords = {concurrent languages, erlang, garbage collection, message passing, runtime systems}, + contributer = {pabuhr@plg}, + author = {Erik Johansson and Konstantinos Sagonas and Jesper Wilhelmsson}, + title = {Heap Architectures for Concurrent Languages Using Message Passing}, + year = {2002}, + isbn = {1581135394}, + publisher = {ACM}, + address = {New York, NY, USA}, + organization= {Proceedings of the 3rd International Symposium on Memory Management}, + pages = {88-99}, + location = {Berlin, Germany}, } @@ -3917,4 +4144,16 @@ year = {1994}, pages = {64-69}, +} + +@inproceedings{Halstead84, + author = {Halstead,Jr., Robert H.}, + title = {Implementation of Multilisp: Lisp on a Multiprocessor}, + organization= {Proceedings of the 1984 ACM Symposium on LISP and Functional Programming}, + series = {LFP '84}, + year = {1984}, + location = {Austin, Texas, USA}, + pages = {9-17}, + publisher = {ACM}, + address = {New York, NY, USA}, } @@ -4695,7 +4934,8 @@ contributer = {pabuhr@plg}, author = {Lua}, - title = {Lua 5.3 Reference Manual}, - address = {\href{https://www.lua.org/manual/5.3}{https://\-www.lua.org/\-manual/\-5.3}}, - year = 2018, + title = {Lua 5.4 Reference Manual}, + organization= {Pontifical Catholic University}, + address = {\href{https://www.lua.org/manual/5.4}{https://\-www.lua.org/\-manual/\-5.4}}, + year = 2020, } @@ -5277,5 +5517,6 @@ Programming Language}, year = 1980, - month = dec, pages = {139-145}, + month = dec, + pages = {139-145}, note = {SIGPLAN Notices, v. 15, n. 11}, abstract = { @@ -5398,4 +5639,16 @@ year = 2005, pages = {146-196}, + publisher = {ACM}, + address = {New York, NY, USA}, +} + +@inproceedings{Hendler02, + author = {Hendler, Danny and Shavit, Nir}, + title = {Non-blocking Steal-half Work Queues}, + organization= {Proceedings of the Twenty-first Annual Symposium on Principles of Distributed Computing}, + series = {PODC '02}, + year = {2002}, + location = {Monterey, California}, + pages = {280-289}, publisher = {ACM}, address = {New York, NY, USA}, @@ -5646,4 +5899,13 @@ } +@misc{OpenTelemetry, + contributer = {pabuhr@plg}, + key = {OpenTelemetry}, + title = {OpenTelemetry}, + author = {{Asynkron AB}}, + howpublished= {\href{https://proto.actor/docs/tracing}{https://\-proto.actor/\-docs/\-tracing}}, + year = 2022, +} + @inproceedings{Krebbers14, keywords = {c formalization}, @@ -5883,4 +6145,15 @@ } +@article{Nigro21, + keywords = {Actors, Asynchronous messages, Reflective control on message passing, Lock-free parallel computing, Java, Scalable multi-agent systems, Parallel matrix multiplication, Iterated Prisoner's Dilemma}, + contributer = {pabuhr@plg}, + author = {Libero Nigro}, + title = {Parallel Theatre: An actor framework in {Java} for high performance computing}, + journal = {Simulation Modelling Practice and Theory}, + volume = {106}, + number = {102189}, + year = {2021}, +} + @incollection{Stroustrup96, keywords = {concurrency, C++}, @@ -5917,5 +6190,8 @@ journal = ieeese, year = 1984, - month = sep, volume = "SE-10", number = 5, pages = {528-543}, + month = sep, + volume = "SE-10", + number = 5, + pages = {528-543}, abstract = { Parameterized programming is a powerful technique for the reliable @@ -5949,5 +6225,6 @@ booktitle = {USENIX {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Conference}, organization= {USENIX Association}, - year = 1988, pages = {1-18} + year = 1988, + pages = {1-18} } @@ -6037,4 +6314,29 @@ } +@incollection{Kazempour08, + keywords = {multicore processors; cache affinity; performance evaluation; scheduling}, + author = {Kazempour, Vahid and Fedorova, Alexandra and Alagheband, Pouya}, + title = {Performance Implications of Cache Affinity on Multicore Processors}, + organization= {Euro-Par 2008 -- Parallel Processing}, + series = {Lecture Notes in Computer Science}, + editor = {Luque, Emilio and Margalef, Tomas and Benitez, Domingo}, + year = {2008}, + volume = {5168}, + pages = {151-161}, + publisher = {Springer Berlin Heidelberg}, +} + +@article{Anderson89, + keywords = {data structures, multiprocessing systems, operating systems (computers), performance evaluation, critical resource waiting}, + author = {Anderson, T.E. and Lazowska, E.D. and Levy, H.M.}, + journal = {Computers, IEEE Transactions on}, + title = {The Performance Implications of Thread Management Alternatives for Shared-Memory Multiprocessors}, + year = {1989}, + month = {Dec}, + volume = {38}, + number = {12}, + pages = {1631-1644}, +} + @article{Anderson90, keywords = {spin locks, back off, performance}, @@ -6048,4 +6350,18 @@ number = 1, pages = {6-16}, +} + +@article{Blumofe98, + author = {Blumofe, Robert D. and Papadopoulos, Dionisios}, + title = {The Performance of Work Stealing in Multiprogrammed Environments (Extended Abstract)}, + journal = {SIGMETRICS Perform. Eval. Rev.}, + volume = {26}, + number = {1}, + month = jun, + year = {1998}, + issn = {0163-5999}, + pages = {266-267}, + publisher = {ACM}, + address = {New York, NY, USA}, } @@ -6760,36 +7076,15 @@ } -@manual{Ada95, - keywords = {Ada}, - contributer = {pabuhr@plg}, - title = {{A}da Reference Manual}, - edition = {International Standard {ISO}/{IEC} {8652:1995(E)} with {COR.1:2000}}, - organization= {Intermetrics, Inc.}, - month = dec, - year = 1995, - note = {Language and Standards Libraries} -} - -@manual{Ada12, - keywords = {ISO/IEC Ada}, - contributer = {pabuhr@plg}, - author = {Ada12}, - title = {Programming languages -- {Ada} ISO/IEC 8652:2012}, - edition = {3rd}, - organization= {International Standard Organization}, - address = {Geneva, Switzerland}, - year = 2012, - note = {\href{https://www.iso.org/standard/61507.html}{https://\-www.iso.org/\-standard/\-61507.html}}, -} - -@manual{Ada95:annotated, - keywords = {Ada}, - contributer = {pabuhr@plg}, - title = {Annotated {A}da Reference Manual}, - edition = {International Standard {ISO}/{IEC} {8652:1995(E)} with {COR.1:2000}}, - organization = {Intermetrics, Inc.}, - month = dec, - year = 1995, - note = {Language and Standards Libraries} +@inproceedings{Bacon03, + keywords = {utilization, real-time scheduling, read barrier, defragmentation}, + contributer = {pabuhr@plg}, + author = {David F. Bacon and Perry Cheng and V. T. Rajan}, + title = {A Real-Time Garbage Collector with Low Overhead and Consistent Utilization}, + year = {2003}, + organization= {Proceedings of the 30th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages}, + publisher = {ACM}, + address = {New York, NY, USA}, + pages = {285-298}, + location = {New Orleans, Louisiana, USA}, } @@ -6927,5 +7222,8 @@ journal = sigplan, year = 1991, - month = oct, volume = 26, number = 10, pages = {29-43}, + month = oct, + volume = 26, + number = 10, + pages = {29-43}, abstract = { {\tt lcc} is a new retargetable compiler for ANSI C. Versions for @@ -7017,5 +7315,5 @@ publisher = {ACM}, address = {New York, NY, USA}, - booktitle = {Proceedings of the 4th International Workshop on Programming Based on Actors Agents \& Decentralized Control}, + organization= {Proceedings of the 4th International Workshop on Programming Based on Actors Agents \& Decentralized Control}, pages = {67-80}, numpages = {14}, @@ -7049,4 +7347,17 @@ } +@article{Nickolls08, + author = {Nickolls, John and Buck, Ian and Garland, Michael and Skadron, Kevin}, + title = {Scalable Parallel Programming with CUDA}, + journal = {Queue}, + volume = {6}, + number = {2}, + month = mar, + year = 2008, + pages = {40-53}, + publisher = {ACM}, + address = {New York, NY, USA}, +} + @article{Anderson92, keywords = {light-weight tasks}, @@ -7060,4 +7371,45 @@ year = 1992, pages = {53-79}, +} + +@article{Blumofe99, + keywords = {critical-path length, multiprocessor, multithreading, randomized algorithm, thread scheduling, work stealing}, + author = {Blumofe, Robert D. and Leiserson, Charles E.}, + title = {Scheduling Multithreaded Computations by Work Stealing}, + journal = {Journal of the ACM}, + volume = {46}, + number = {5}, + month = sep, + year = {1999}, + pages = {720-748}, + publisher = {ACM}, + address = {New York, NY, USA}, +} + +@inproceedings{Acar13, + keywords = {dynamic load balancing, nested parallelism, work stealing}, + author = {Acar, Umut A. and Chargueraud, Arthur and Rainey, Mike}, + title = {Scheduling Parallel Programs by Work Stealing with Private Deques}, + organization= {Proceedings of the 18th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming}, + series = {PPoPP '13}, + year = {2013}, + location = {Shenzhen, China}, + pages = {219-228}, + publisher = {ACM}, + address = {New York, NY, USA}, +} + +@inproceedings{Chen07, + keywords = {chip multiprocessors, constructive cache sharing, parallel depth first, scheduling algorithms, thread granularity, work stealing, working set profiling}, + author = {Chen, Shimin and Gibbons, Phillip B. and Kozuch, Michael and Liaskovitis, Vasileios and Ailamaki, Anastassia and Blelloch, Guy E. and Falsafi, Babak and Fix, Limor and Hardavellas, Nikos and Mowry, Todd C. and Wilkerson, Chris}, + title = {Scheduling Threads for Constructive Cache Sharing on CMPs}, + organization= {Proceedings of the Nineteenth Annual ACM Symposium on Parallel Algorithms and Architectures}, + series = {SPAA '07}, + year = {2007}, + location = {San Diego, California, USA}, + pages = {105-115}, + numpages = {11}, + publisher = {ACM}, + address = {New York, NY, USA}, } @@ -7150,17 +7502,4 @@ publisher = {Morgan \& Claypool}, year = 2013, -} - -@article{Nickolls08, - author = {Nickolls, John and Buck, Ian and Garland, Michael and Skadron, Kevin}, - title = {Scalable Parallel Programming with CUDA}, - journal = {Queue}, - volume = {6}, - number = {2}, - month = mar, - year = 2008, - pages = {40-53}, - publisher = {ACM}, - address = {New York, NY, USA}, } @@ -7833,4 +8172,15 @@ } +@article{Arora01, + author = {Arora, N. S. and Blumofe, R. D. and Plaxton, C. G.}, + title = {Thread Scheduling for Multiprogrammed Multiprocessors}, + journal = {Theory of Computing Systems}, + year = {2001}, + volume = {34}, + number = {2}, + pages = {115-144}, + publisher = {Springer-Verlag}, +} + @article{Boehm05, keywords = {concurrency, C++}, @@ -8060,4 +8410,13 @@ } +@misc{AkkaBecome, + contributer = {pabuhr@plg}, + key = {AkkaBecome}, + title = {Typed Actors}, + author = {{Lightbend}}, + howpublished= {\href{https://doc.akka.io/docs/akka/2.5/typed-actors.html}{https://\-doc.akka.io/\-docs/\-akka/\-2.5/\-typed-actors.html}}, + year = 2022, +} + @article{concatenation, keywords = {record concatenation, isa}, @@ -8137,7 +8496,9 @@ author = {Carl Hewitt and Peter Bishop and Richard Steiger}, title = {A Universal Modular {ACTOR} Formalism for Artificial Intelligence}, - booktitle = {Proceedings of the 3rd International Joint Conference on Artificial Intelligence}, + organization= {Proceedings of the 3rd International Joint Conference on Artificial Intelligence}, address = {Standford, California, U.S.A.}, pages = {235-245}, + location = {Stanford, USA}, + series = {IJCAI'73}, month = aug, year = 1973, @@ -8171,5 +8532,5 @@ @article{Karsten20, author = {Karsten, Martin and Barghi, Saman}, - title = {{User-level Threading: Have Your Cake and Eat It Too}}, + title = {User-level Threading: Have Your Cake and Eat It Too}, year = {2020}, issue_date = {March 2020}, @@ -8196,4 +8557,16 @@ } +@article{Squillante93, + keywords = {buffer storage, performance evaluation, queueing theory, scheduling, shared memory systems, processor-cache affinity}, + author = {Squillante, M.S. and Lazowska, E.D.}, + title = {Using Processor-Cache Affinity Information in Shared-Memory Multiprocessor Scheduling}, + journal = {Parallel and Distributed Systems, IEEE Transactions on}, + year = {1993}, + month = {Feb}, + volume = {4}, + number = {2}, + pages = {131-143}, +} + @article{delegation, keywords = {delegation, inheritance, actors}, @@ -8345,4 +8718,31 @@ year = 2003, pages = {19-24}, +} + +@inproceedings{Saman18, + keywords = {actors, scheduling, NUMA, locality}, + contributer = {pabuhr@plg}, + author = {Saman Barghi and Martin Karsten}, + organization= {2018 IEEE International Parallel and Distributed Processing Symposium (IPDPS)}, + title = {Work-Stealing, Locality-Aware Actor Scheduling}, + year = {2018}, + address = {Vancouver, BC, Canada}, + pages = {484-494}, +} + +@article{Wimmer13, + keywords = {priorities, scheduler hints, strategies, work-stealing}, + author = {Wimmer, Martin and Cederman, Daniel and Tr\"{a}ff, Jesper Larsson and Tsigas, Philippas}, + title = {Work-stealing with Configurable Scheduling Strategies}, + journal = {SIGPLAN Not.}, + issue_date = {August 2013}, + volume = {48}, + number = {8}, + month = feb, + year = {2013}, + issn = {0362-1340}, + pages = {315-316}, + publisher = {ACM}, + address = {New York, NY, USA}, } Index: driver/cfa.cc =================================================================== --- driver/cfa.cc (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ driver/cfa.cc (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -10,6 +10,6 @@ // Created On : Tue Aug 20 13:44:49 2002 // Last Modified By : Peter A. Buhr -// Last Modified On : Wed Jul 14 21:55:12 2021 -// Update Count : 467 +// Last Modified On : Tue Feb 14 22:46:38 2023 +// Update Count : 470 // @@ -444,4 +444,5 @@ args[nargs++] = "-fexceptions"; // add exception flags (unconditionally) + args[nargs++] = "-D_GNU_SOURCE"; // force gnu libraries // add flags based on the type of compile Index: libcfa/src/bitmanip.hfa =================================================================== --- libcfa/src/bitmanip.hfa (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ libcfa/src/bitmanip.hfa (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -11,9 +11,11 @@ // Created On : Sat Mar 14 18:12:27 2020 // Last Modified By : Peter A. Buhr -// Last Modified On : Sat Oct 8 08:28:15 2022 -// Update Count : 142 +// Last Modified On : Mon Jan 9 09:02:43 2023 +// Update Count : 144 // #pragma once + +#include "bits/debug.hfa" // verify // Reference: Bit Twiddling Hacks: http://graphics.stanford.edu/%7Eseander/bithacks.html#CountBitsSetNaive Index: libcfa/src/concurrency/clib/cfathread.cfa =================================================================== --- libcfa/src/concurrency/clib/cfathread.cfa (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ libcfa/src/concurrency/clib/cfathread.cfa (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -16,4 +16,8 @@ // #define EPOLL_FOR_SOCKETS +#include // first include because of anonymous types __SOCKADDR_ARG, __CONST_SOCKADDR_ARG +#include +#include + #include "fstream.hfa" #include "locks.hfa" @@ -26,13 +30,7 @@ #include "cfathread.h" -extern "C" { - #include - #include -} - extern void ?{}(processor &, const char[], cluster &, thread$ *); extern "C" { - extern void __cfactx_invoke_thread(void (*main)(void *), void * this); - extern int accept4(int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags); + extern void __cfactx_invoke_thread(void (*main)(void *), void * this); } @@ -472,11 +470,9 @@ } +#include + #include extern "C" { - #include - #include - #include - //-------------------- // IO operations @@ -488,5 +484,5 @@ , protocol); } - int cfathread_bind(int socket, const struct sockaddr *address, socklen_t address_len) { + int cfathread_bind(int socket, __CONST_SOCKADDR_ARG address, socklen_t address_len) { return bind(socket, address, address_len); } @@ -496,5 +492,5 @@ } - int cfathread_accept(int socket, struct sockaddr *restrict address, socklen_t *restrict address_len) { + int cfathread_accept(int socket, __SOCKADDR_ARG address, socklen_t *restrict address_len) { #if defined(EPOLL_FOR_SOCKETS) int ret; @@ -513,5 +509,5 @@ } - int cfathread_connect(int socket, const struct sockaddr *address, socklen_t address_len) { + int cfathread_connect(int socket, __CONST_SOCKADDR_ARG address, socklen_t address_len) { #if defined(EPOLL_FOR_SOCKETS) int ret; Index: libcfa/src/concurrency/clib/cfathread.h =================================================================== --- libcfa/src/concurrency/clib/cfathread.h (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ libcfa/src/concurrency/clib/cfathread.h (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -9,17 +9,16 @@ // Author : Thierry Delisle // Created On : Tue Sep 22 15:31:20 2020 -// Last Modified By : -// Last Modified On : -// Update Count : +// Last Modified By : Peter A. Buhr +// Last Modified On : Thu Feb 16 12:00:32 2023 +// Update Count : 5 // #if defined(__cforall) || defined(__cplusplus) +#include // first include because of anonymous types __SOCKADDR_ARG, __CONST_SOCKADDR_ARG +#include +#include + extern "C" { #endif - #include - #include - #include - - //-------------------- // Basic types @@ -73,5 +72,5 @@ } cfathread_mutexattr_t; typedef struct cfathread_mutex * cfathread_mutex_t; - int cfathread_mutex_init(cfathread_mutex_t *restrict mut, const cfathread_mutexattr_t *restrict attr) __attribute__((nonnull (1))); + int cfathread_mutex_init(cfathread_mutex_t * restrict mut, const cfathread_mutexattr_t * restrict attr) __attribute__((nonnull (1))); int cfathread_mutex_destroy(cfathread_mutex_t *mut) __attribute__((nonnull (1))); int cfathread_mutex_lock(cfathread_mutex_t *mut) __attribute__((nonnull (1))); @@ -91,11 +90,9 @@ //-------------------- // IO operations - struct sockaddr; - struct msghdr; int cfathread_socket(int domain, int type, int protocol); - int cfathread_bind(int socket, const struct sockaddr *address, socklen_t address_len); + int cfathread_bind(int socket, __CONST_SOCKADDR_ARG address, socklen_t address_len); int cfathread_listen(int socket, int backlog); - int cfathread_accept(int socket, struct sockaddr *restrict address, socklen_t *restrict address_len); - int cfathread_connect(int socket, const struct sockaddr *address, socklen_t address_len); + int cfathread_accept(int socket, __SOCKADDR_ARG address, socklen_t * restrict address_len); + int cfathread_connect(int socket, __CONST_SOCKADDR_ARG address, socklen_t address_len); int cfathread_dup(int fildes); int cfathread_close(int fildes); Index: libcfa/src/concurrency/coroutine.cfa =================================================================== --- libcfa/src/concurrency/coroutine.cfa (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ libcfa/src/concurrency/coroutine.cfa (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -10,10 +10,9 @@ // Created On : Mon Nov 28 12:27:26 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Tue Dec 15 12:06:04 2020 -// Update Count : 23 +// Last Modified On : Thu Feb 16 15:34:46 2023 +// Update Count : 24 // #define __cforall_thread__ -#define _GNU_SOURCE #include "coroutine.hfa" Index: libcfa/src/concurrency/io.cfa =================================================================== --- libcfa/src/concurrency/io.cfa (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ libcfa/src/concurrency/io.cfa (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -15,5 +15,4 @@ #define __cforall_thread__ -#define _GNU_SOURCE #if defined(__CFA_DEBUG__) Index: libcfa/src/concurrency/io/call.cfa.in =================================================================== --- libcfa/src/concurrency/io/call.cfa.in (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ libcfa/src/concurrency/io/call.cfa.in (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -31,4 +31,9 @@ Prelude = """#define __cforall_thread__ +#include // first include because of anonymous types __SOCKADDR_ARG, __CONST_SOCKADDR_ARG +#include +#include +#include + #include "bits/defs.hfa" #include "kernel.hfa" @@ -43,7 +48,5 @@ #include #include - #include #include - #include "kernel/fwd.hfa" @@ -82,15 +85,6 @@ // I/O Forwards //============================================================================================= -#include - -// Some forward declarations -#include -#include extern "C" { - #include - #include - #include - #if defined(CFA_HAVE_PREADV2) struct iovec; @@ -118,6 +112,4 @@ extern ssize_t send(int sockfd, const void *buf, size_t len, int flags); extern ssize_t recv(int sockfd, void *buf, size_t len, int flags); - extern int accept4(int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags); - extern int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen); extern int fallocate(int fd, int mode, off_t offset, off_t len); @@ -292,14 +284,14 @@ }), # CFA_HAVE_IORING_OP_ACCEPT - Call('ACCEPT', 'int accept4(int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags)', { - 'fd': 'sockfd', - 'addr': '(uintptr_t)addr', + Call('ACCEPT', 'int accept4(int sockfd, __SOCKADDR_ARG addr, socklen_t * restrict addrlen, int flags)', { + 'fd': 'sockfd', + 'addr': '(uintptr_t)&addr', 'addr2': '(uintptr_t)addrlen', 'accept_flags': 'flags' }), # CFA_HAVE_IORING_OP_CONNECT - Call('CONNECT', 'int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen)', { - 'fd': 'sockfd', - 'addr': '(uintptr_t)addr', + Call('CONNECT', 'int connect(int sockfd, __CONST_SOCKADDR_ARG addr, socklen_t addrlen)', { + 'fd': 'sockfd', + 'addr': '(uintptr_t)&addr', 'off': 'addrlen' }), Index: libcfa/src/concurrency/io/setup.cfa =================================================================== --- libcfa/src/concurrency/io/setup.cfa (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ libcfa/src/concurrency/io/setup.cfa (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -15,5 +15,4 @@ #define __cforall_thread__ -#define _GNU_SOURCE #if defined(__CFA_DEBUG__) Index: libcfa/src/concurrency/iofwd.hfa =================================================================== --- libcfa/src/concurrency/iofwd.hfa (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ libcfa/src/concurrency/iofwd.hfa (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -16,5 +16,7 @@ #pragma once +#include // first include because of anonymous types __SOCKADDR_ARG, __CONST_SOCKADDR_ARG #include + extern "C" { #include @@ -53,5 +55,4 @@ struct iovec; struct msghdr; -struct sockaddr; struct statx; struct epoll_event; @@ -100,6 +101,6 @@ extern ssize_t cfa_send(int sockfd, const void *buf, size_t len, int flags, __u64 submit_flags); extern ssize_t cfa_recv(int sockfd, void *buf, size_t len, int flags, __u64 submit_flags); -extern int cfa_accept4(int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags, __u64 submit_flags); -extern int cfa_connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen, __u64 submit_flags); +extern int cfa_accept4(int sockfd, __SOCKADDR_ARG addr, socklen_t * restrict addrlen, int flags, __u64 submit_flags); +extern int cfa_connect(int sockfd, __CONST_SOCKADDR_ARG addr, socklen_t addrlen, __u64 submit_flags); extern int cfa_fallocate(int fd, int mode, off_t offset, off_t len, __u64 submit_flags); extern int cfa_posix_fadvise(int fd, off_t offset, off_t len, int advice, __u64 submit_flags); @@ -133,6 +134,6 @@ extern void async_send(io_future_t & future, int sockfd, const void *buf, size_t len, int flags, __u64 submit_flags); extern void async_recv(io_future_t & future, int sockfd, void *buf, size_t len, int flags, __u64 submit_flags); -extern void async_accept4(io_future_t & future, int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags, __u64 submit_flags); -extern void async_connect(io_future_t & future, int sockfd, const struct sockaddr *addr, socklen_t addrlen, __u64 submit_flags); +extern void async_accept4(io_future_t & future, int sockfd, __SOCKADDR_ARG addr, socklen_t * restrict addrlen, int flags, __u64 submit_flags); +extern void async_connect(io_future_t & future, int sockfd, __CONST_SOCKADDR_ARG addr, socklen_t addrlen, __u64 submit_flags); extern void async_fallocate(io_future_t & future, int fd, int mode, off_t offset, off_t len, __u64 submit_flags); extern void async_posix_fadvise(io_future_t & future, int fd, off_t offset, off_t len, int advice, __u64 submit_flags); Index: libcfa/src/concurrency/kernel.cfa =================================================================== --- libcfa/src/concurrency/kernel.cfa (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ libcfa/src/concurrency/kernel.cfa (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -10,10 +10,9 @@ // Created On : Tue Jan 17 12:27:26 2017 // Last Modified By : Peter A. Buhr -// Last Modified On : Wed Nov 30 18:14:08 2022 -// Update Count : 76 +// Last Modified On : Mon Jan 9 08:42:05 2023 +// Update Count : 77 // #define __cforall_thread__ -#define _GNU_SOURCE // #define __CFA_DEBUG_PRINT_RUNTIME_CORE__ Index: libcfa/src/concurrency/kernel/cluster.cfa =================================================================== --- libcfa/src/concurrency/kernel/cluster.cfa (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ libcfa/src/concurrency/kernel/cluster.cfa (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -15,5 +15,4 @@ #define __cforall_thread__ -#define _GNU_SOURCE #include "bits/defs.hfa" Index: libcfa/src/concurrency/kernel/startup.cfa =================================================================== --- libcfa/src/concurrency/kernel/startup.cfa (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ libcfa/src/concurrency/kernel/startup.cfa (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -15,20 +15,17 @@ #define __cforall_thread__ -#define _GNU_SOURCE // #define __CFA_DEBUG_PRINT_RUNTIME_CORE__ // C Includes -#include // errno +#include // errno #include -#include // strerror -#include // sysconf - +#include // strerror +#include +#include // PTHREAD_STACK_MIN extern "C" { - #include // PTHREAD_STACK_MIN - #include // syscall - #include // eventfd - #include // mprotect - #include // getrlimit + #include // eventfd + #include // mprotect + #include // getrlimit } Index: libcfa/src/concurrency/locks.cfa =================================================================== --- libcfa/src/concurrency/locks.cfa (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ libcfa/src/concurrency/locks.cfa (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -16,5 +16,4 @@ #define __cforall_thread__ -#define _GNU_SOURCE #include "locks.hfa" Index: libcfa/src/concurrency/monitor.cfa =================================================================== --- libcfa/src/concurrency/monitor.cfa (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ libcfa/src/concurrency/monitor.cfa (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -10,10 +10,9 @@ // Created On : Thd Feb 23 12:27:26 2017 // Last Modified By : Peter A. Buhr -// Last Modified On : Wed Dec 4 07:55:14 2019 -// Update Count : 10 +// Last Modified On : Sun Feb 19 17:00:59 2023 +// Update Count : 12 // #define __cforall_thread__ -#define _GNU_SOURCE #include "monitor.hfa" Index: libcfa/src/concurrency/mutex.cfa =================================================================== --- libcfa/src/concurrency/mutex.cfa (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ libcfa/src/concurrency/mutex.cfa (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -12,10 +12,9 @@ // Created On : Fri May 25 01:37:11 2018 // Last Modified By : Peter A. Buhr -// Last Modified On : Wed Dec 4 09:16:39 2019 -// Update Count : 1 +// Last Modified On : Sun Feb 19 17:01:36 2023 +// Update Count : 3 // #define __cforall_thread__ -#define _GNU_SOURCE #include "mutex.hfa" Index: libcfa/src/concurrency/preemption.cfa =================================================================== --- libcfa/src/concurrency/preemption.cfa (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ libcfa/src/concurrency/preemption.cfa (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -10,10 +10,9 @@ // Created On : Mon Jun 5 14:20:42 2017 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Feb 17 11:18:57 2022 -// Update Count : 59 +// Last Modified On : Mon Jan 9 08:42:59 2023 +// Update Count : 60 // #define __cforall_thread__ -#define _GNU_SOURCE // #define __CFA_DEBUG_PRINT_PREEMPTION__ Index: libcfa/src/concurrency/pthread.cfa =================================================================== --- libcfa/src/concurrency/pthread.cfa (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ libcfa/src/concurrency/pthread.cfa (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -15,5 +15,4 @@ #define __cforall_thread__ -#define _GNU_SOURCE #include @@ -35,5 +34,5 @@ struct pthread_values{ inline Seqable; - void* value; + void * value; bool in_use; }; @@ -51,9 +50,9 @@ struct pthread_keys { bool in_use; - void (*destructor)( void * ); + void (* destructor)( void * ); Sequence(pthread_values) threads; }; -static void ?{}(pthread_keys& k){ +static void ?{}(pthread_keys& k) { k.threads{}; } @@ -62,6 +61,6 @@ static pthread_keys cfa_pthread_keys_storage[PTHREAD_KEYS_MAX] __attribute__((aligned (16))); -static void init_pthread_storage(){ - for (int i = 0; i < PTHREAD_KEYS_MAX; i++){ +static void init_pthread_storage() { + for ( int i = 0; i < PTHREAD_KEYS_MAX; i++ ) { cfa_pthread_keys_storage[i]{}; } @@ -96,16 +95,16 @@ /* condvar helper routines */ -static void init(pthread_cond_t* pcond){ +static void init(pthread_cond_t * pcond) { static_assert(sizeof(pthread_cond_t) >= sizeof(cfa2pthr_cond_var_t),"sizeof(pthread_t) < sizeof(cfa2pthr_cond_var_t)"); - cfa2pthr_cond_var_t* _cond = (cfa2pthr_cond_var_t*)pcond; + cfa2pthr_cond_var_t * _cond = (cfa2pthr_cond_var_t *)pcond; ?{}(*_cond); } -static cfa2pthr_cond_var_t* get(pthread_cond_t* pcond){ +static cfa2pthr_cond_var_t * get(pthread_cond_t * pcond) { static_assert(sizeof(pthread_cond_t) >= sizeof(cfa2pthr_cond_var_t),"sizeof(pthread_t) < sizeof(cfa2pthr_cond_var_t)"); - return (cfa2pthr_cond_var_t*)pcond; -} - -static void destroy(pthread_cond_t* cond){ + return (cfa2pthr_cond_var_t *)pcond; +} + +static void destroy(pthread_cond_t * cond) { static_assert(sizeof(pthread_cond_t) >= sizeof(cfa2pthr_cond_var_t),"sizeof(pthread_t) < sizeof(cfa2pthr_cond_var_t)"); ^?{}(*get(cond)); @@ -116,8 +115,8 @@ /* mutex helper routines */ -static void mutex_check(pthread_mutex_t* t){ +static void mutex_check(pthread_mutex_t * t) { // Use double check to improve performance. // Check is safe on x86; volatile prevents compiler reordering - volatile pthread_mutex_t *const mutex_ = t; + volatile pthread_mutex_t * const mutex_ = t; // SKULLDUGGERY: not a portable way to access the kind field, /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h @@ -136,16 +135,16 @@ -static void init(pthread_mutex_t* plock){ +static void init(pthread_mutex_t * plock) { static_assert(sizeof(pthread_mutex_t) >= sizeof(simple_owner_lock),"sizeof(pthread_mutex_t) < sizeof(simple_owner_lock)"); - simple_owner_lock* _lock = (simple_owner_lock*)plock; + simple_owner_lock * _lock = (simple_owner_lock *)plock; ?{}(*_lock); } -static simple_owner_lock* get(pthread_mutex_t* plock){ +static simple_owner_lock * get(pthread_mutex_t * plock) { static_assert(sizeof(pthread_mutex_t) >= sizeof(simple_owner_lock),"sizeof(pthread_mutex_t) < sizeof(simple_owner_lock)"); - return (simple_owner_lock*)plock; -} - -static void destroy(pthread_mutex_t* plock){ + return (simple_owner_lock *)plock; +} + +static void destroy(pthread_mutex_t * plock) { static_assert(sizeof(pthread_mutex_t) >= sizeof(simple_owner_lock),"sizeof(pthread_mutex_t) < sizeof(simple_owner_lock)"); ^?{}(*get(plock)); @@ -157,5 +156,5 @@ int detachstate; size_t stacksize; - void *stackaddr; + void * stackaddr; int policy; int inheritsched; @@ -163,9 +162,9 @@ } typedef cfaPthread_attr_t; -static const cfaPthread_attr_t default_attrs{ +static const cfaPthread_attr_t default_attrs { 0, 0, - (size_t)65000, - (void *)NULL, + 65_000, + NULL, 0, 0, @@ -173,7 +172,7 @@ }; -static cfaPthread_attr_t* get(const pthread_attr_t* attr){ - static_assert(sizeof(pthread_attr_t) >= sizeof(cfaPthread_attr_t),"sizeof(pthread_attr_t) < sizeof(cfaPthread_attr_t)"); - return (cfaPthread_attr_t*)attr; +static cfaPthread_attr_t * get(const pthread_attr_t * attr) { + static_assert(sizeof(pthread_attr_t) >= sizeof(cfaPthread_attr_t), "sizeof(pthread_attr_t) < sizeof(cfaPthread_attr_t)"); + return (cfaPthread_attr_t *)attr; } @@ -190,14 +189,14 @@ // pthreads return value - void *joinval; + void * joinval; // pthread attributes pthread_attr_t pthread_attr; - void *(*start_routine)(void *); - void *start_arg; + void *(* start_routine)(void *); + void * start_arg; // thread local data - pthread_values* pthreadData; + pthread_values * pthreadData; // flag used for tryjoin @@ -207,25 +206,25 @@ /* thread part routines */ // cfaPthread entry point -void main(cfaPthread& _thread) with(_thread){ - joinval = start_routine(start_arg); +void main(cfaPthread & _thread) with(_thread) { + joinval = start_routine(start_arg); isTerminated = true; } -static cfaPthread *lookup( pthread_t p ){ - static_assert(sizeof(pthread_t) >= sizeof(cfaPthread*),"sizeof(pthread_t) < sizeof(cfaPthread*)"); - return (cfaPthread*)p; -} - -static void pthread_deletespecific_( pthread_values* values ) { // see uMachContext::invokeTask - pthread_values* value; - pthread_keys* key; +static cfaPthread * lookup( pthread_t p ) { + static_assert(sizeof(pthread_t) >= sizeof(cfaPthread *),"sizeof(pthread_t) < sizeof(cfaPthread *)"); + return (cfaPthread *)p; +} + +static void pthread_deletespecific_( pthread_values * values ) { // see uMachContext::invokeTask + pthread_values * value; + pthread_keys * key; bool destcalled = true; - if (values != NULL){ + if (values != NULL) { for ( int attempts = 0; attempts < PTHREAD_DESTRUCTOR_ITERATIONS && destcalled ; attempts += 1 ) { destcalled = false; lock(key_lock); - for (int i = 0; i < PTHREAD_KEYS_MAX; i++){ + for ( int i = 0; i < PTHREAD_KEYS_MAX; i++ ) { // for each valid key - if ( values[i].in_use){ + if ( values[i].in_use) { value = &values[i]; key = &cfa_pthread_keys[i]; @@ -234,5 +233,5 @@ // if a key value has a non-NULL destructor pointer, and the thread has a non-NULL value associated with that key, // the value of the key is set to NULL, and then the function pointed to is called with the previously associated value as its sole argument. - if (value->value != NULL && key->destructor != NULL){ + if (value->value != NULL && key->destructor != NULL) { unlock(key_lock); key->destructor(value->value); // run destructor @@ -249,5 +248,5 @@ } -static void ^?{}(cfaPthread & mutex t){ +static void ^?{}(cfaPthread & mutex t) { // delete pthread local storage pthread_values * values = t.pthreadData; @@ -255,6 +254,6 @@ } -static void ?{}(cfaPthread &t, pthread_t* _thread, const pthread_attr_t * _attr,void *(*start_routine)(void *), void * arg) { - static_assert(sizeof(pthread_t) >= sizeof(cfaPthread*), "pthread_t too small to hold a pointer: sizeof(pthread_t) < sizeof(cfaPthread*)"); +static void ?{}(cfaPthread & t, pthread_t * _thread, const pthread_attr_t * _attr,void *(* start_routine)(void *), void * arg) { + static_assert(sizeof(pthread_t) >= sizeof(cfaPthread *), "pthread_t too small to hold a pointer: sizeof(pthread_t) < sizeof(cfaPthread *)"); // set up user thread stackSize @@ -278,40 +277,40 @@ //######################### Pthread Attrs ######################### - int pthread_attr_init(pthread_attr_t *attr) libcfa_public __THROW { - cfaPthread_attr_t* _attr = get(attr); + int pthread_attr_init(pthread_attr_t * attr) libcfa_public __THROW { + cfaPthread_attr_t * _attr = get(attr); ?{}(*_attr, default_attrs); return 0; } - int pthread_attr_destroy(pthread_attr_t *attr) libcfa_public __THROW { + int pthread_attr_destroy(pthread_attr_t * attr) libcfa_public __THROW { ^?{}(*get(attr)); return 0; } - int pthread_attr_setscope( pthread_attr_t *attr, int contentionscope ) libcfa_public __THROW { + int pthread_attr_setscope( pthread_attr_t * attr, int contentionscope ) libcfa_public __THROW { get( attr )->contentionscope = contentionscope; return 0; } // pthread_attr_setscope - int pthread_attr_getscope( const pthread_attr_t *attr, int *contentionscope ) libcfa_public __THROW { + int pthread_attr_getscope( const pthread_attr_t * attr, int * contentionscope ) libcfa_public __THROW { *contentionscope = get( attr )->contentionscope; return 0; } // pthread_attr_getscope - int pthread_attr_setdetachstate( pthread_attr_t *attr, int detachstate ) libcfa_public __THROW { + int pthread_attr_setdetachstate( pthread_attr_t * attr, int detachstate ) libcfa_public __THROW { get( attr )->detachstate = detachstate; return 0; } // pthread_attr_setdetachstate - int pthread_attr_getdetachstate( const pthread_attr_t *attr, int *detachstate ) libcfa_public __THROW { + int pthread_attr_getdetachstate( const pthread_attr_t * attr, int * detachstate ) libcfa_public __THROW { *detachstate = get( attr )->detachstate; return 0; } // pthread_attr_getdetachstate - int pthread_attr_setstacksize( pthread_attr_t *attr, size_t stacksize ) libcfa_public __THROW { + int pthread_attr_setstacksize( pthread_attr_t * attr, size_t stacksize ) libcfa_public __THROW { get( attr )->stacksize = stacksize; return 0; } // pthread_attr_setstacksize - int pthread_attr_getstacksize( const pthread_attr_t *attr, size_t *stacksize ) libcfa_public __THROW { + int pthread_attr_getstacksize( const pthread_attr_t * attr, size_t * stacksize ) libcfa_public __THROW { *stacksize = get( attr )->stacksize; return 0; @@ -326,15 +325,15 @@ } // pthread_attr_setguardsize - int pthread_attr_setstackaddr( pthread_attr_t *attr, void *stackaddr ) libcfa_public __THROW { + int pthread_attr_setstackaddr( pthread_attr_t * attr, void * stackaddr ) libcfa_public __THROW { get( attr )->stackaddr = stackaddr; return 0; } // pthread_attr_setstackaddr - int pthread_attr_getstackaddr( const pthread_attr_t *attr, void **stackaddr ) libcfa_public __THROW { + int pthread_attr_getstackaddr( const pthread_attr_t * attr, void ** stackaddr ) libcfa_public __THROW { *stackaddr = get( attr )->stackaddr; return 0; } // pthread_attr_getstackaddr - int pthread_attr_setstack( pthread_attr_t *attr, void *stackaddr, size_t stacksize ) libcfa_public __THROW { + int pthread_attr_setstack( pthread_attr_t * attr, void * stackaddr, size_t stacksize ) libcfa_public __THROW { get( attr )->stackaddr = stackaddr; get( attr )->stacksize = stacksize; @@ -342,5 +341,5 @@ } // pthread_attr_setstack - int pthread_attr_getstack( const pthread_attr_t *attr, void **stackaddr, size_t *stacksize ) libcfa_public __THROW { + int pthread_attr_getstack( const pthread_attr_t * attr, void ** stackaddr, size_t * stacksize ) libcfa_public __THROW { *stackaddr = get( attr )->stackaddr; *stacksize = get( attr )->stacksize; @@ -351,5 +350,5 @@ // already running thread threadID. It shall be called on unitialized attr // and destroyed with pthread_attr_destroy when no longer needed. - int pthread_getattr_np( pthread_t threadID, pthread_attr_t *attr ) libcfa_public __THROW { // GNU extension + int pthread_getattr_np( pthread_t threadID, pthread_attr_t * attr ) libcfa_public __THROW { // GNU extension check_nonnull(attr); @@ -363,12 +362,11 @@ //######################### Threads ######################### - int pthread_create(pthread_t * _thread, const pthread_attr_t * attr, void *(*start_routine)(void *), void * arg) libcfa_public __THROW { - cfaPthread *t = alloc(); + int pthread_create(pthread_t * _thread, const pthread_attr_t * attr, void *(* start_routine)(void *), void * arg) libcfa_public __THROW { + cfaPthread * t = alloc(); (*t){_thread, attr, start_routine, arg}; return 0; } - - int pthread_join(pthread_t _thread, void **value_ptr) libcfa_public __THROW { + int pthread_join(pthread_t _thread, void ** value_ptr) libcfa_public __THROW { // if thread is invalid if (_thread == NULL) return EINVAL; @@ -376,5 +374,5 @@ // get user thr pointer - cfaPthread* p = lookup(_thread); + cfaPthread * p = lookup(_thread); try { join(*p); @@ -389,10 +387,10 @@ } - int pthread_tryjoin_np(pthread_t _thread, void **value_ptr) libcfa_public __THROW { + int pthread_tryjoin_np(pthread_t _thread, void ** value_ptr) libcfa_public __THROW { // if thread is invalid if (_thread == NULL) return EINVAL; if (_thread == pthread_self()) return EDEADLK; - cfaPthread* p = lookup(_thread); + cfaPthread * p = lookup(_thread); // thread not finished ? @@ -412,5 +410,5 @@ void pthread_exit(void * status) libcfa_public __THROW { pthread_t pid = pthread_self(); - cfaPthread* _thread = (cfaPthread*)pid; + cfaPthread * _thread = (cfaPthread *)pid; _thread->joinval = status; // set return value _thread->isTerminated = 1; // set terminated flag @@ -426,5 +424,5 @@ //######################### Mutex ######################### - int pthread_mutex_init(pthread_mutex_t *_mutex, const pthread_mutexattr_t *attr) libcfa_public __THROW { + int pthread_mutex_init(pthread_mutex_t *_mutex, const pthread_mutexattr_t * attr) libcfa_public __THROW { check_nonnull(_mutex); init(_mutex); @@ -435,6 +433,6 @@ int pthread_mutex_destroy(pthread_mutex_t *_mutex) libcfa_public __THROW { check_nonnull(_mutex); - simple_owner_lock* _lock = get(_mutex); - if (_lock->owner != NULL){ + simple_owner_lock * _lock = get(_mutex); + if (_lock->owner != NULL) { return EBUSY; } @@ -446,5 +444,5 @@ check_nonnull(_mutex); mutex_check(_mutex); - simple_owner_lock* _lock = get(_mutex); + simple_owner_lock * _lock = get(_mutex); lock(*_lock); return 0; @@ -453,6 +451,6 @@ int pthread_mutex_unlock(pthread_mutex_t *_mutex) libcfa_public __THROW { check_nonnull(_mutex); - simple_owner_lock* _lock = get(_mutex); - if (_lock->owner != active_thread()){ + simple_owner_lock * _lock = get(_mutex); + if (_lock->owner != active_thread()) { return EPERM; } // current thread does not hold the mutex @@ -463,6 +461,6 @@ int pthread_mutex_trylock(pthread_mutex_t *_mutex) libcfa_public __THROW { check_nonnull(_mutex); - simple_owner_lock* _lock = get(_mutex); - if (_lock->owner != active_thread() && _lock->owner != NULL){ + simple_owner_lock * _lock = get(_mutex); + if (_lock->owner != active_thread() && _lock->owner != NULL) { return EBUSY; } // if mutex is owned @@ -474,5 +472,5 @@ /* conditional variable routines */ - int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr) libcfa_public __THROW { + int pthread_cond_init(pthread_cond_t * cond, const pthread_condattr_t * attr) libcfa_public __THROW { check_nonnull(cond); init(cond); @@ -480,5 +478,5 @@ } //pthread_cond_init - int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *_mutex) libcfa_public __THROW { + int pthread_cond_wait(pthread_cond_t * cond, pthread_mutex_t *_mutex) libcfa_public __THROW { check_nonnull(_mutex); check_nonnull(cond); @@ -494,15 +492,15 @@ } // pthread_cond_timedwait - int pthread_cond_signal(pthread_cond_t *cond) libcfa_public __THROW { + int pthread_cond_signal(pthread_cond_t * cond) libcfa_public __THROW { check_nonnull(cond); return notify_one(*get(cond)); } // pthread_cond_signal - int pthread_cond_broadcast(pthread_cond_t *cond) libcfa_public __THROW { + int pthread_cond_broadcast(pthread_cond_t * cond) libcfa_public __THROW { check_nonnull(cond); return notify_all(*get(cond)); } // pthread_cond_broadcast - int pthread_cond_destroy(pthread_cond_t *cond) libcfa_public __THROW { + int pthread_cond_destroy(pthread_cond_t * cond) libcfa_public __THROW { check_nonnull(cond); destroy(cond); @@ -514,5 +512,5 @@ //######################### Local storage ######################### - int pthread_once(pthread_once_t *once_control, void (*init_routine)(void)) libcfa_public __THROW { + int pthread_once(pthread_once_t * once_control, void (* init_routine)(void)) libcfa_public __THROW { static_assert(sizeof(pthread_once_t) >= sizeof(int),"sizeof(pthread_once_t) < sizeof(int)"); check_nonnull(once_control); @@ -527,5 +525,5 @@ } // pthread_once - int pthread_key_create( pthread_key_t *key, void (*destructor)( void * ) ) libcfa_public __THROW { + int pthread_key_create( pthread_key_t * key, void (* destructor)( void * ) ) libcfa_public __THROW { lock(key_lock); for ( int i = 0; i < PTHREAD_KEYS_MAX; i += 1 ) { @@ -562,13 +560,13 @@ } // pthread_key_delete - int pthread_setspecific( pthread_key_t key, const void *value ) libcfa_public __THROW { + int pthread_setspecific( pthread_key_t key, const void * value ) libcfa_public __THROW { // get current thread - cfaPthread* t = lookup(pthread_self()); + cfaPthread * t = lookup(pthread_self()); // if current thread's pthreadData is NULL; initialize it - pthread_values* values; - if (t->pthreadData == NULL){ + pthread_values * values; + if (t->pthreadData == NULL) { values = anew( PTHREAD_KEYS_MAX); t->pthreadData = values; - for (int i = 0;i < PTHREAD_KEYS_MAX; i++){ + for ( int i = 0;i < PTHREAD_KEYS_MAX; i++ ) { t->pthreadData[i].in_use = false; } // for @@ -593,9 +591,9 @@ } //pthread_setspecific - void* pthread_getspecific(pthread_key_t key) libcfa_public __THROW { + void * pthread_getspecific(pthread_key_t key) libcfa_public __THROW { if (key >= PTHREAD_KEYS_MAX || ! cfa_pthread_keys[key].in_use) return NULL; // get current thread - cfaPthread* t = lookup(pthread_self()); + cfaPthread * t = lookup(pthread_self()); if (t->pthreadData == NULL) return NULL; lock(key_lock); @@ -605,5 +603,5 @@ return NULL; } // if - void *value = entry.value; + void * value = entry.value; unlock(key_lock); @@ -875,19 +873,19 @@ //######################### Parallelism ######################### - int pthread_setaffinity_np( pthread_t /* __th */, size_t /* __cpusetsize */, __const cpu_set_t * /* __cpuset */ ) libcfa_public __THROW { - abort( "pthread_setaffinity_np" ); - } // pthread_setaffinity_np - - int pthread_getaffinity_np( pthread_t /* __th */, size_t /* __cpusetsize */, cpu_set_t * /* __cpuset */ ) libcfa_public __THROW { - abort( "pthread_getaffinity_np" ); - } // pthread_getaffinity_np - - int pthread_attr_setaffinity_np( pthread_attr_t * /* __attr */, size_t /* __cpusetsize */, __const cpu_set_t * /* __cpuset */ ) libcfa_public __THROW { - abort( "pthread_attr_setaffinity_np" ); - } // pthread_attr_setaffinity_np - - int pthread_attr_getaffinity_np( __const pthread_attr_t * /* __attr */, size_t /* __cpusetsize */, cpu_set_t * /* __cpuset */ ) libcfa_public __THROW { - abort( "pthread_attr_getaffinity_np" ); - } // pthread_attr_getaffinity_np + // int pthread_setaffinity_np( pthread_t /* __th */, size_t /* __cpusetsize */, __const cpu_set_t * /* __cpuset */ ) libcfa_public __THROW { + // abort( "pthread_setaffinity_np" ); + // } // pthread_setaffinity_np + + // int pthread_getaffinity_np( pthread_t /* __th */, size_t /* __cpusetsize */, cpu_set_t * /* __cpuset */ ) libcfa_public __THROW { + // abort( "pthread_getaffinity_np" ); + // } // pthread_getaffinity_np + + // int pthread_attr_setaffinity_np( pthread_attr_t * /* __attr */, size_t /* __cpusetsize */, __const cpu_set_t * /* __cpuset */ ) libcfa_public __THROW { + // abort( "pthread_attr_setaffinity_np" ); + // } // pthread_attr_setaffinity_np + + // int pthread_attr_getaffinity_np( __const pthread_attr_t * /* __attr */, size_t /* __cpusetsize */, cpu_set_t * /* __cpuset */ ) libcfa_public __THROW { + // abort( "pthread_attr_getaffinity_np" ); + // } // pthread_attr_getaffinity_np //######################### Cancellation ######################### @@ -906,10 +904,10 @@ } // pthread_cancel - int pthread_setcancelstate( int state, int *oldstate ) libcfa_public __THROW { + int pthread_setcancelstate( int state, int * oldstate ) libcfa_public __THROW { abort("pthread_setcancelstate not implemented"); return 0; } // pthread_setcancelstate - int pthread_setcanceltype( int type, int *oldtype ) libcfa_public __THROW { + int pthread_setcanceltype( int type, int * oldtype ) libcfa_public __THROW { abort("pthread_setcanceltype not implemented"); return 0; @@ -918,3 +916,2 @@ #pragma GCC diagnostic pop - Index: libcfa/src/concurrency/ready_queue.cfa =================================================================== --- libcfa/src/concurrency/ready_queue.cfa (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ libcfa/src/concurrency/ready_queue.cfa (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -15,5 +15,4 @@ #define __cforall_thread__ -#define _GNU_SOURCE // #define __CFA_DEBUG_PRINT_READY_QUEUE__ Index: libcfa/src/concurrency/thread.cfa =================================================================== --- libcfa/src/concurrency/thread.cfa (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ libcfa/src/concurrency/thread.cfa (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -10,10 +10,9 @@ // Created On : Tue Jan 17 12:27:26 2017 // Last Modified By : Peter A. Buhr -// Last Modified On : Sun Dec 11 20:56:54 2022 -// Update Count : 102 +// Last Modified On : Mon Jan 9 08:42:33 2023 +// Update Count : 103 // #define __cforall_thread__ -#define _GNU_SOURCE #include "thread.hfa" Index: libcfa/src/interpose.cfa =================================================================== --- libcfa/src/interpose.cfa (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ libcfa/src/interpose.cfa (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -10,6 +10,6 @@ // Created On : Wed Mar 29 16:10:31 2017 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Jan 5 22:23:57 2023 -// Update Count : 180 +// Last Modified On : Sun Feb 19 17:09:16 2023 +// Update Count : 183 // @@ -45,14 +45,5 @@ union { generic_fptr_t fptr; void * ptr; } originalFunc; - #if defined( _GNU_SOURCE ) - if ( version ) { - originalFunc.ptr = dlvsym( library, symbol, version ); - } else { - originalFunc.ptr = dlsym( library, symbol ); - } - #else - originalFunc.ptr = dlsym( library, symbol ); - #endif // _GNU_SOURCE - + originalFunc.ptr = dlsym( library, symbol ); error = dlerror(); if ( error ) abort( "interpose_symbol : internal error, %s\n", error ); @@ -62,31 +53,20 @@ static generic_fptr_t interpose_symbol( const char symbol[], const char version[] ) { - const char * error; - static void * library; static void * pthread_library; + if ( ! library ) { - #if defined( RTLD_NEXT ) - library = RTLD_NEXT; - #else - // missing RTLD_NEXT => must hard-code library name, assuming libstdc++ - library = dlopen( "libc.so.6", RTLD_LAZY ); - error = dlerror(); - if ( error ) { - abort( "interpose_symbol : failed to open libc, %s\n", error ); - } - #endif + library = dlopen( "libc.so.6", RTLD_LAZY ); + const char * error = dlerror(); + if ( error ) { + abort( "interpose_symbol : failed to open libc, %s\n", error ); + } // if } // if if ( ! pthread_library ) { - #if defined( RTLD_NEXT ) - pthread_library = RTLD_NEXT; - #else - // missing RTLD_NEXT => must hard-code library name, assuming libstdc++ - pthread_library = dlopen( "libpthread.so", RTLD_LAZY ); - error = dlerror(); - if ( error ) { - abort( "interpose_symbol : failed to open libpthread, %s\n", error ); - } - #endif + pthread_library = dlopen( "libpthread.so", RTLD_LAZY ); + const char * error = dlerror(); + if ( error ) { + abort( "interpose_symbol : failed to open libpthread, %s\n", error ); + } // if } // if Index: libcfa/src/interpose_thread.cfa =================================================================== --- libcfa/src/interpose_thread.cfa (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ libcfa/src/interpose_thread.cfa (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -39,18 +39,11 @@ const char version[] ) libcfa_public { - const char * error; - static void * library; if ( ! library ) { - #if defined( RTLD_NEXT ) - library = RTLD_NEXT; - #else - // missing RTLD_NEXT => must hard-code library name, assuming libstdc++ - library = dlopen( "libpthread.so", RTLD_LAZY ); - error = dlerror(); - if ( error ) { - abort( "interpose_symbol : failed to open libpthread, %s\n", error ); - } - #endif + library = dlopen( "libpthread.so", RTLD_LAZY ); + const char * error = dlerror(); + if ( error ) { + abort( "interpose_symbol : failed to open libpthread, %s\n", error ); + } } // if Index: libcfa/src/iostream.cfa =================================================================== --- libcfa/src/iostream.cfa (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ libcfa/src/iostream.cfa (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -10,6 +10,6 @@ // Created On : Wed May 27 17:56:53 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Sat Aug 27 15:04:15 2022 -// Update Count : 1358 +// Last Modified On : Mon Jan 9 09:27:58 2023 +// Update Count : 1361 // @@ -667,5 +667,5 @@ } /* if */ \ if ( ! f.flags.nobsdp || (exp10 < SUFFIXES_START) || (exp10 > SUFFIXES_END) ) { \ - len2 = snprintf( &buf[len], size - len, "e%d", exp10 ); \ + len2 = snprintf( &buf[len], size - len, "e%d", (int)exp10 /* ambiguity with function exp10 */ ); \ } else { \ len2 = snprintf( &buf[len], size - len, "%s", suffixes[(exp10 - SUFFIXES_START) / 3] ); \ Index: libcfa/src/limits.cfa =================================================================== --- libcfa/src/limits.cfa (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ libcfa/src/limits.cfa (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -10,9 +10,9 @@ // Created On : Wed Apr 6 18:06:52 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Jan 5 22:27:40 2023 -// Update Count : 84 +// Last Modified On : Sun Jan 8 18:53:17 2023 +// Update Count : 86 // -#define _GNU_SOURCE // access long double M_*l in math.h +// need _GNU_SOURCE to access long double M_*l in math.h #include #include Index: libcfa/src/stdlib.cfa =================================================================== --- libcfa/src/stdlib.cfa (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ libcfa/src/stdlib.cfa (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -10,6 +10,6 @@ // Created On : Thu Jan 28 17:10:29 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Fri Dec 9 15:11:30 2022 -// Update Count : 631 +// Last Modified On : Thu Feb 16 16:31:34 2023 +// Update Count : 633 // @@ -20,5 +20,4 @@ //--------------------------------------- -#define _XOPEN_SOURCE 600 // posix_memalign, *rand48 #include // memcpy, memset //#include // fabsf, fabs, fabsl Index: src/AST/Create.cpp =================================================================== --- src/AST/Create.cpp (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ src/AST/Create.cpp (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -20,4 +20,5 @@ #include "AST/Decl.hpp" #include "AST/Type.hpp" +#include "Common/Iterate.hpp" namespace ast { Index: src/AST/Decl.cpp =================================================================== --- src/AST/Decl.cpp (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ src/AST/Decl.cpp (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -20,5 +20,5 @@ #include -#include "Common/utility.h" +#include "Common/Eval.h" // for eval #include "Fwd.hpp" // for UniqueId Index: src/AST/Pass.impl.hpp =================================================================== --- src/AST/Pass.impl.hpp (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ src/AST/Pass.impl.hpp (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -22,4 +22,5 @@ #include "AST/TranslationUnit.hpp" #include "AST/TypeSubstitution.hpp" +#include "Common/Iterate.hpp" #define VISIT_START( node ) \ Index: src/AST/Pass.proto.hpp =================================================================== --- src/AST/Pass.proto.hpp (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ src/AST/Pass.proto.hpp (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -18,506 +18,501 @@ #include "Common/Stats/Heap.h" - namespace ast { -template -class Pass; - -class TranslationUnit; - -struct PureVisitor; - -template -node_t * deepCopy( const node_t * localRoot ); - -namespace __pass { - typedef std::function cleanup_func_t; - typedef std::function at_cleanup_t; - - - // boolean reference that may be null - // either refers to a boolean value or is null and returns true - class bool_ref { - public: - bool_ref() = default; - ~bool_ref() = default; - - operator bool() { return m_ref ? *m_ref : true; } - bool operator=( bool val ) { assert(m_ref); return *m_ref = val; } - - private: - - friend class visit_children_guard; - - bool * set( bool * val ) { - bool * prev = m_ref; - m_ref = val; - return prev; - } - - bool * m_ref = nullptr; + template class Pass; + class TranslationUnit; + struct PureVisitor; + template node_t * deepCopy( const node_t * ); +} + +namespace ast::__pass { + +typedef std::function cleanup_func_t; +typedef std::function at_cleanup_t; + +// boolean reference that may be null +// either refers to a boolean value or is null and returns true +class bool_ref { +public: + bool_ref() = default; + ~bool_ref() = default; + + operator bool() { return m_ref ? *m_ref : true; } + bool operator=( bool val ) { assert(m_ref); return *m_ref = val; } + +private: + + friend class visit_children_guard; + + bool * set( bool * val ) { + bool * prev = m_ref; + m_ref = val; + return prev; + } + + bool * m_ref = nullptr; +}; + +// Implementation of the guard value +// Created inside the visit scope +class guard_value { +public: + /// Push onto the cleanup + guard_value( at_cleanup_t * at_cleanup ) { + if( at_cleanup ) { + *at_cleanup = [this]( cleanup_func_t && func, void* val ) { + push( std::move( func ), val ); + }; + } + } + + ~guard_value() { + while( !cleanups.empty() ) { + auto& cleanup = cleanups.top(); + cleanup.func( cleanup.val ); + cleanups.pop(); + } + } + + void push( cleanup_func_t && func, void* val ) { + cleanups.emplace( std::move(func), val ); + } + +private: + struct cleanup_t { + cleanup_func_t func; + void * val; + + cleanup_t( cleanup_func_t&& func, void * val ) : func(func), val(val) {} }; - // Implementation of the guard value - // Created inside the visit scope - class guard_value { - public: - /// Push onto the cleanup - guard_value( at_cleanup_t * at_cleanup ) { - if( at_cleanup ) { - *at_cleanup = [this]( cleanup_func_t && func, void* val ) { - push( std::move( func ), val ); - }; - } - } - - ~guard_value() { - while( !cleanups.empty() ) { - auto& cleanup = cleanups.top(); - cleanup.func( cleanup.val ); - cleanups.pop(); - } - } - - void push( cleanup_func_t && func, void* val ) { - cleanups.emplace( std::move(func), val ); - } - - private: - struct cleanup_t { - cleanup_func_t func; - void * val; - - cleanup_t( cleanup_func_t&& func, void * val ) : func(func), val(val) {} - }; - - std::stack< cleanup_t, std::vector > cleanups; + std::stack< cleanup_t, std::vector > cleanups; +}; + +// Guard structure implementation for whether or not children should be visited +class visit_children_guard { +public: + + visit_children_guard( bool_ref * ref ) + : m_val ( true ) + , m_prev( ref ? ref->set( &m_val ) : nullptr ) + , m_ref ( ref ) + {} + + ~visit_children_guard() { + if( m_ref ) { + m_ref->set( m_prev ); + } + } + + operator bool() { return m_val; } + +private: + bool m_val; + bool * m_prev; + bool_ref * m_ref; +}; + +/// "Short hand" to check if this is a valid previsit function +/// Mostly used to make the static_assert look (and print) prettier +template +struct is_valid_previsit { + using ret_t = decltype( std::declval()->previsit( std::declval() ) ); + + static constexpr bool value = std::is_void< ret_t >::value || + std::is_base_of::type >::value; +}; + +/// The result is a single node. +template< typename node_t > +struct result1 { + bool differs = false; + const node_t * value = nullptr; + + template< typename object_t, typename super_t, typename field_t > + void apply( object_t *, field_t super_t::* field ); +}; + +/// The result is a container of statements. +template< template class container_t > +struct resultNstmt { + /// The delta/change on a single node. + struct delta { + ptr new_val; + ssize_t old_idx; + bool is_old; + + delta(const Stmt * s, ssize_t i, bool old) : + new_val(s), old_idx(i), is_old(old) {} }; - // Guard structure implementation for whether or not children should be visited - class visit_children_guard { - public: - - visit_children_guard( bool_ref * ref ) - : m_val ( true ) - , m_prev( ref ? ref->set( &m_val ) : nullptr ) - , m_ref ( ref ) - {} - - ~visit_children_guard() { - if( m_ref ) { - m_ref->set( m_prev ); - } - } - - operator bool() { return m_val; } - - private: - bool m_val; - bool * m_prev; - bool_ref * m_ref; - }; - - /// "Short hand" to check if this is a valid previsit function - /// Mostly used to make the static_assert look (and print) prettier + bool differs = false; + container_t< delta > values; + + template< typename object_t, typename super_t, typename field_t > + void apply( object_t *, field_t super_t::* field ); + + template< template class incontainer_t > + void take_all( incontainer_t> * stmts ); + + template< template class incontainer_t > + void take_all( incontainer_t> * decls ); +}; + +/// The result is a container of nodes. +template< template class container_t, typename node_t > +struct resultN { + bool differs = false; + container_t> values; + + template< typename object_t, typename super_t, typename field_t > + void apply( object_t *, field_t super_t::* field ); +}; + +/// Used by previsit implementation +/// We need to reassign the result to 'node', unless the function +/// returns void, then we just leave 'node' unchanged +template +struct __assign; + +template<> +struct __assign { template - struct is_valid_previsit { - using ret_t = decltype( std::declval()->previsit( std::declval() ) ); - - static constexpr bool value = std::is_void< ret_t >::value || - std::is_base_of::type >::value; - }; - - /// The result is a single node. - template< typename node_t > - struct result1 { - bool differs = false; - const node_t * value = nullptr; - - template< typename object_t, typename super_t, typename field_t > - void apply( object_t *, field_t super_t::* field ); - }; - - /// The result is a container of statements. - template< template class container_t > - struct resultNstmt { - /// The delta/change on a single node. - struct delta { - ptr new_val; - ssize_t old_idx; - bool is_old; - - delta(const Stmt * s, ssize_t i, bool old) : - new_val(s), old_idx(i), is_old(old) {} - }; - - bool differs = false; - container_t< delta > values; - - template< typename object_t, typename super_t, typename field_t > - void apply( object_t *, field_t super_t::* field ); - - template< template class incontainer_t > - void take_all( incontainer_t> * stmts ); - - template< template class incontainer_t > - void take_all( incontainer_t> * decls ); - }; - - /// The result is a container of nodes. - template< template class container_t, typename node_t > - struct resultN { - bool differs = false; - container_t> values; - - template< typename object_t, typename super_t, typename field_t > - void apply( object_t *, field_t super_t::* field ); - }; - - /// Used by previsit implementation - /// We need to reassign the result to 'node', unless the function - /// returns void, then we just leave 'node' unchanged - template - struct __assign; - - template<> - struct __assign { - template - static inline void result( core_t & core, const node_t * & node ) { - core.previsit( node ); - } - }; - - template<> - struct __assign { - template - static inline void result( core_t & core, const node_t * & node ) { - node = core.previsit( node ); - assertf(node, "Previsit must not return NULL"); - } - }; - - /// Used by postvisit implementation - /// We need to return the result unless the function - /// returns void, then we just return the original node - template - struct __return; - - template<> - struct __return { - template - static inline const node_t * result( core_t & core, const node_t * & node ) { - core.postvisit( node ); - return node; - } - }; - - template<> - struct __return { - template - static inline auto result( core_t & core, const node_t * & node ) { - return core.postvisit( node ); - } - }; - - //------------------------------------------------------------------------------------------------------------------------------------------------------------------------- - // Deep magic (a.k.a template meta programming) to make the templated visitor work - // Basically the goal is to make 2 previsit - // 1 - Use when a pass implements a valid previsit. This uses overloading which means the any overload of - // 'pass.previsit( node )' that compiles will be used for that node for that type - // This requires that this option only compile for passes that actually define an appropriate visit. - // SFINAE will make sure the compilation errors in this function don't halt the build. - // See http://en.cppreference.com/w/cpp/language/sfinae for details on SFINAE - // 2 - Since the first implementation might not be specilizable, the second implementation exists and does nothing. - // This is needed only to eliminate the need for passes to specify any kind of handlers. - // The second implementation only works because it has a lower priority. This is due to the bogus last parameter. - // The second implementation takes a long while the first takes an int. Since the caller always passes an literal 0 - // the first implementation takes priority in regards to overloading. - //------------------------------------------------------------------------------------------------------------------------------------------------------------------------- - // PreVisit : may mutate the pointer passed in if the node is mutated in the previsit call + static inline void result( core_t & core, const node_t * & node ) { + core.previsit( node ); + } +}; + +template<> +struct __assign { template - static inline auto previsit( core_t & core, const node_t * & node, int ) -> decltype( core.previsit( node ), void() ) { - static_assert( - is_valid_previsit::value, - "Previsit may not change the type of the node. It must return its paremeter or void." - ); - - __assign< - std::is_void< - decltype( core.previsit( node ) ) - >::value - >::result( core, node ); - } - + static inline void result( core_t & core, const node_t * & node ) { + node = core.previsit( node ); + assertf(node, "Previsit must not return NULL"); + } +}; + +/// Used by postvisit implementation +/// We need to return the result unless the function +/// returns void, then we just return the original node +template +struct __return; + +template<> +struct __return { template - static inline auto previsit( core_t &, const node_t *, long ) {} - - // PostVisit : never mutates the passed pointer but may return a different node + static inline const node_t * result( core_t & core, const node_t * & node ) { + core.postvisit( node ); + return node; + } +}; + +template<> +struct __return { template - static inline auto postvisit( core_t & core, const node_t * node, int ) -> - decltype( core.postvisit( node ), node->accept( *(Visitor*)nullptr ) ) - { - return __return< - std::is_void< - decltype( core.postvisit( node ) ) - >::value - >::result( core, node ); - } - - template - static inline const node_t * postvisit( core_t &, const node_t * node, long ) { return node; } - - //------------------------------------------------------------------------------------------------------------------------------------------------------------------------- - // Deep magic (a.k.a template meta programming) continued - // To make the templated visitor be more expressive, we allow 'accessories' : classes/structs the implementation can inherit - // from in order to get extra functionallity for example - // class ErrorChecker : WithShortCircuiting { ... }; - // Pass checker; - // this would define a pass that uses the templated visitor with the additionnal feature that it has short circuiting - // Note that in all cases the accessories are not required but guarantee the requirements of the feature is matched - //------------------------------------------------------------------------------------------------------------------------------------------------------------------------- - // For several accessories, the feature is enabled by detecting that a specific field is present - // Use a macro the encapsulate the logic of detecting a particular field - // The type is not strictly enforced but does match the accessory - #define FIELD_PTR( name, default_type ) \ - template< typename core_t > \ - static inline auto name( core_t & core, int ) -> decltype( &core.name ) { return &core.name; } \ + static inline auto result( core_t & core, const node_t * & node ) { + return core.postvisit( node ); + } +}; + +//------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +// Deep magic (a.k.a template meta programming) to make the templated visitor work +// Basically the goal is to make 2 previsit +// 1 - Use when a pass implements a valid previsit. This uses overloading which means the any overload of +// 'pass.previsit( node )' that compiles will be used for that node for that type +// This requires that this option only compile for passes that actually define an appropriate visit. +// SFINAE will make sure the compilation errors in this function don't halt the build. +// See http://en.cppreference.com/w/cpp/language/sfinae for details on SFINAE +// 2 - Since the first implementation might not be specilizable, the second implementation exists and does nothing. +// This is needed only to eliminate the need for passes to specify any kind of handlers. +// The second implementation only works because it has a lower priority. This is due to the bogus last parameter. +// The second implementation takes a long while the first takes an int. Since the caller always passes an literal 0 +// the first implementation takes priority in regards to overloading. +//------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +// PreVisit : may mutate the pointer passed in if the node is mutated in the previsit call +template +static inline auto previsit( core_t & core, const node_t * & node, int ) -> decltype( core.previsit( node ), void() ) { + static_assert( + is_valid_previsit::value, + "Previsit may not change the type of the node. It must return its paremeter or void." + ); + + __assign< + std::is_void< + decltype( core.previsit( node ) ) + >::value + >::result( core, node ); +} + +template +static inline auto previsit( core_t &, const node_t *, long ) {} + +// PostVisit : never mutates the passed pointer but may return a different node +template +static inline auto postvisit( core_t & core, const node_t * node, int ) -> + decltype( core.postvisit( node ), node->accept( *(Visitor*)nullptr ) ) +{ + return __return< + std::is_void< + decltype( core.postvisit( node ) ) + >::value + >::result( core, node ); +} + +template +static inline const node_t * postvisit( core_t &, const node_t * node, long ) { return node; } + +//------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +// Deep magic (a.k.a template meta programming) continued +// To make the templated visitor be more expressive, we allow 'accessories' : classes/structs the implementation can inherit +// from in order to get extra functionallity for example +// class ErrorChecker : WithShortCircuiting { ... }; +// Pass checker; +// this would define a pass that uses the templated visitor with the additionnal feature that it has short circuiting +// Note that in all cases the accessories are not required but guarantee the requirements of the feature is matched +//------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +// For several accessories, the feature is enabled by detecting that a specific field is present +// Use a macro the encapsulate the logic of detecting a particular field +// The type is not strictly enforced but does match the accessory +#define FIELD_PTR( name, default_type ) \ +template< typename core_t > \ +static inline auto name( core_t & core, int ) -> decltype( &core.name ) { return &core.name; } \ +\ +template< typename core_t > \ +static inline default_type * name( core_t &, long ) { return nullptr; } + +// List of fields and their expected types +FIELD_PTR( typeSubs, const ast::TypeSubstitution * ) +FIELD_PTR( stmtsToAddBefore, std::list< ast::ptr< ast::Stmt > > ) +FIELD_PTR( stmtsToAddAfter , std::list< ast::ptr< ast::Stmt > > ) +FIELD_PTR( declsToAddBefore, std::list< ast::ptr< ast::Decl > > ) +FIELD_PTR( declsToAddAfter , std::list< ast::ptr< ast::Decl > > ) +FIELD_PTR( visit_children, __pass::bool_ref ) +FIELD_PTR( at_cleanup, __pass::at_cleanup_t ) +FIELD_PTR( visitor, ast::Pass * const ) + +// Remove the macro to make sure we don't clash +#undef FIELD_PTR + +template< typename core_t > +static inline auto beginTrace(core_t &, int) -> decltype( core_t::traceId, void() ) { + // Stats::Heap::stacktrace_push(core_t::traceId); +} + +template< typename core_t > +static inline auto endTrace(core_t &, int) -> decltype( core_t::traceId, void() ) { + // Stats::Heap::stacktrace_pop(); +} + +template< typename core_t > +static void beginTrace(core_t &, long) {} + +template< typename core_t > +static void endTrace(core_t &, long) {} + +// Allows visitor to handle an error on top-level declarations, and possibly suppress the error. +// If on_error() returns false, the error will be ignored. By default, it returns true. + +template< typename core_t > +static bool on_error (core_t &, ptr &, long) { return true; } + +template< typename core_t > +static auto on_error (core_t & core, ptr & decl, int) -> decltype(core.on_error(decl)) { + return core.on_error(decl); +} + +template< typename core_t, typename node_t > +static auto make_location_guard( core_t & core, node_t * node, int ) + -> decltype( node->location, ValueGuardPtr( &core.location ) ) { + ValueGuardPtr guard( &core.location ); + core.location = &node->location; + return guard; +} + +template< typename core_t, typename node_t > +static auto make_location_guard( core_t &, node_t *, long ) -> int { + return 0; +} + +// Another feature of the templated visitor is that it calls beginScope()/endScope() for compound statement. +// All passes which have such functions are assumed desire this behaviour +// detect it using the same strategy +namespace scope { + template + static inline auto enter( core_t & core, int ) -> decltype( core.beginScope(), void() ) { + core.beginScope(); + } + + template + static inline void enter( core_t &, long ) {} + + template + static inline auto leave( core_t & core, int ) -> decltype( core.endScope(), void() ) { + core.endScope(); + } + + template + static inline void leave( core_t &, long ) {} +} // namespace scope + +// Certain passes desire an up to date symbol table automatically +// detect the presence of a member name `symtab` and call all the members appropriately +namespace symtab { + // Some simple scoping rules + template + static inline auto enter( core_t & core, int ) -> decltype( core.symtab, void() ) { + core.symtab.enterScope(); + } + + template + static inline auto enter( core_t &, long ) {} + + template + static inline auto leave( core_t & core, int ) -> decltype( core.symtab, void() ) { + core.symtab.leaveScope(); + } + + template + static inline auto leave( core_t &, long ) {} + + // The symbol table has 2 kind of functions mostly, 1 argument and 2 arguments + // Create macro to condense these common patterns + #define SYMTAB_FUNC1( func, type ) \ + template \ + static inline auto func( core_t & core, int, type arg ) -> decltype( core.symtab.func( arg ), void() ) {\ + core.symtab.func( arg ); \ + } \ \ - template< typename core_t > \ - static inline default_type * name( core_t &, long ) { return nullptr; } - - // List of fields and their expected types - FIELD_PTR( typeSubs, const ast::TypeSubstitution * ) - FIELD_PTR( stmtsToAddBefore, std::list< ast::ptr< ast::Stmt > > ) - FIELD_PTR( stmtsToAddAfter , std::list< ast::ptr< ast::Stmt > > ) - FIELD_PTR( declsToAddBefore, std::list< ast::ptr< ast::Decl > > ) - FIELD_PTR( declsToAddAfter , std::list< ast::ptr< ast::Decl > > ) - FIELD_PTR( visit_children, __pass::bool_ref ) - FIELD_PTR( at_cleanup, __pass::at_cleanup_t ) - FIELD_PTR( visitor, ast::Pass * const ) - - // Remove the macro to make sure we don't clash - #undef FIELD_PTR - - template< typename core_t > - static inline auto beginTrace(core_t &, int) -> decltype( core_t::traceId, void() ) { - // Stats::Heap::stacktrace_push(core_t::traceId); - } - - template< typename core_t > - static inline auto endTrace(core_t &, int) -> decltype( core_t::traceId, void() ) { - // Stats::Heap::stacktrace_pop(); - } - - template< typename core_t > - static void beginTrace(core_t &, long) {} - - template< typename core_t > - static void endTrace(core_t &, long) {} - - // Allows visitor to handle an error on top-level declarations, and possibly suppress the error. - // If onError() returns false, the error will be ignored. By default, it returns true. - - template< typename core_t > - static bool on_error (core_t &, ptr &, long) { return true; } - - template< typename core_t > - static auto on_error (core_t & core, ptr & decl, int) -> decltype(core.on_error(decl)) { - return core.on_error(decl); - } - - template< typename core_t, typename node_t > - static auto make_location_guard( core_t & core, node_t * node, int ) - -> decltype( node->location, ValueGuardPtr( &core.location ) ) { - ValueGuardPtr guard( &core.location ); - core.location = &node->location; - return guard; - } - - template< typename core_t, typename node_t > - static auto make_location_guard( core_t &, node_t *, long ) -> int { - return 0; - } - - // Another feature of the templated visitor is that it calls beginScope()/endScope() for compound statement. - // All passes which have such functions are assumed desire this behaviour - // detect it using the same strategy - namespace scope { - template - static inline auto enter( core_t & core, int ) -> decltype( core.beginScope(), void() ) { - core.beginScope(); - } - - template - static inline void enter( core_t &, long ) {} - - template - static inline auto leave( core_t & core, int ) -> decltype( core.endScope(), void() ) { - core.endScope(); - } - - template - static inline void leave( core_t &, long ) {} - } // namespace scope - - // Certain passes desire an up to date symbol table automatically - // detect the presence of a member name `symtab` and call all the members appropriately - namespace symtab { - // Some simple scoping rules - template - static inline auto enter( core_t & core, int ) -> decltype( core.symtab, void() ) { - core.symtab.enterScope(); - } - - template - static inline auto enter( core_t &, long ) {} - - template - static inline auto leave( core_t & core, int ) -> decltype( core.symtab, void() ) { - core.symtab.leaveScope(); - } - - template - static inline auto leave( core_t &, long ) {} - - // The symbol table has 2 kind of functions mostly, 1 argument and 2 arguments - // Create macro to condense these common patterns - #define SYMTAB_FUNC1( func, type ) \ - template \ - static inline auto func( core_t & core, int, type arg ) -> decltype( core.symtab.func( arg ), void() ) {\ - core.symtab.func( arg ); \ - } \ - \ - template \ - static inline void func( core_t &, long, type ) {} - - #define SYMTAB_FUNC2( func, type1, type2 ) \ - template \ - static inline auto func( core_t & core, int, type1 arg1, type2 arg2 ) -> decltype( core.symtab.func( arg1, arg2 ), void () ) {\ - core.symtab.func( arg1, arg2 ); \ - } \ - \ - template \ - static inline void func( core_t &, long, type1, type2 ) {} - - SYMTAB_FUNC1( addId , const DeclWithType * ); - SYMTAB_FUNC1( addType , const NamedTypeDecl * ); - SYMTAB_FUNC1( addStruct , const StructDecl * ); - SYMTAB_FUNC1( addEnum , const EnumDecl * ); - SYMTAB_FUNC1( addUnion , const UnionDecl * ); - SYMTAB_FUNC1( addTrait , const TraitDecl * ); - SYMTAB_FUNC2( addWith , const std::vector< ptr > &, const Decl * ); - - // A few extra functions have more complicated behaviour, they are hand written - template - static inline auto addStructFwd( core_t & core, int, const ast::StructDecl * decl ) -> decltype( core.symtab.addStruct( decl ), void() ) { - ast::StructDecl * fwd = new ast::StructDecl( decl->location, decl->name ); - for ( const auto & param : decl->params ) { - fwd->params.push_back( deepCopy( param.get() ) ); - } - core.symtab.addStruct( fwd ); - } - - template - static inline void addStructFwd( core_t &, long, const ast::StructDecl * ) {} - - template - static inline auto addUnionFwd( core_t & core, int, const ast::UnionDecl * decl ) -> decltype( core.symtab.addUnion( decl ), void() ) { - ast::UnionDecl * fwd = new ast::UnionDecl( decl->location, decl->name ); - for ( const auto & param : decl->params ) { - fwd->params.push_back( deepCopy( param.get() ) ); - } - core.symtab.addUnion( fwd ); - } - - template - static inline void addUnionFwd( core_t &, long, const ast::UnionDecl * ) {} - - template - static inline auto addStruct( core_t & core, int, const std::string & str ) -> decltype( core.symtab.addStruct( str ), void() ) { - if ( ! core.symtab.lookupStruct( str ) ) { - core.symtab.addStruct( str ); - } - } - - template - static inline void addStruct( core_t &, long, const std::string & ) {} - - template - static inline auto addUnion( core_t & core, int, const std::string & str ) -> decltype( core.symtab.addUnion( str ), void() ) { - if ( ! core.symtab.lookupUnion( str ) ) { - core.symtab.addUnion( str ); - } - } - - template - static inline void addUnion( core_t &, long, const std::string & ) {} - - #undef SYMTAB_FUNC1 - #undef SYMTAB_FUNC2 - } // namespace symtab - - // Some passes need to mutate TypeDecl and properly update their pointing TypeInstType. - // Detect the presence of a member name `subs` and call all members appropriately - namespace forall { - // Some simple scoping rules - template - static inline auto enter( core_t & core, int, const ast::FunctionType * type ) - -> decltype( core.subs, void() ) { - if ( ! type->forall.empty() ) core.subs.beginScope(); - } - - template - static inline auto enter( core_t &, long, const ast::FunctionType * ) {} - - template - static inline auto leave( core_t & core, int, const ast::FunctionType * type ) - -> decltype( core.subs, void() ) { - if ( ! type->forall.empty() ) { core.subs.endScope(); } - } - - template - static inline auto leave( core_t &, long, const ast::FunctionType * ) {} - - // Replaces a TypeInstType's base TypeDecl according to the table - template - static inline auto replace( core_t & core, int, const ast::TypeInstType *& inst ) - -> decltype( core.subs, void() ) { - inst = ast::mutate_field( - inst, &ast::TypeInstType::base, core.subs.replace( inst->base ) ); - } - - template - static inline auto replace( core_t &, long, const ast::TypeInstType *& ) {} - } // namespace forall - - // For passes that need access to the global context. Sreaches `translationUnit` - namespace translation_unit { - template - static inline auto get_cptr( core_t & core, int ) - -> decltype( &core.translationUnit ) { - return &core.translationUnit; - } - - template - static inline const TranslationUnit ** get_cptr( core_t &, long ) { - return nullptr; - } - } - - // For passes, usually utility passes, that have a result. - namespace result { - template - static inline auto get( core_t & core, char ) -> decltype( core.result() ) { - return core.result(); - } - - template - static inline auto get( core_t & core, int ) -> decltype( core.result ) { - return core.result; - } - - template - static inline void get( core_t &, long ) {} - } -} // namespace __pass -} // namespace ast + template \ + static inline void func( core_t &, long, type ) {} + + #define SYMTAB_FUNC2( func, type1, type2 ) \ + template \ + static inline auto func( core_t & core, int, type1 arg1, type2 arg2 ) -> decltype( core.symtab.func( arg1, arg2 ), void () ) {\ + core.symtab.func( arg1, arg2 ); \ + } \ + \ + template \ + static inline void func( core_t &, long, type1, type2 ) {} + + SYMTAB_FUNC1( addId , const DeclWithType * ); + SYMTAB_FUNC1( addType , const NamedTypeDecl * ); + SYMTAB_FUNC1( addStruct , const StructDecl * ); + SYMTAB_FUNC1( addEnum , const EnumDecl * ); + SYMTAB_FUNC1( addUnion , const UnionDecl * ); + SYMTAB_FUNC1( addTrait , const TraitDecl * ); + SYMTAB_FUNC2( addWith , const std::vector< ptr > &, const Decl * ); + + // A few extra functions have more complicated behaviour, they are hand written + template + static inline auto addStructFwd( core_t & core, int, const ast::StructDecl * decl ) -> decltype( core.symtab.addStruct( decl ), void() ) { + ast::StructDecl * fwd = new ast::StructDecl( decl->location, decl->name ); + for ( const auto & param : decl->params ) { + fwd->params.push_back( deepCopy( param.get() ) ); + } + core.symtab.addStruct( fwd ); + } + + template + static inline void addStructFwd( core_t &, long, const ast::StructDecl * ) {} + + template + static inline auto addUnionFwd( core_t & core, int, const ast::UnionDecl * decl ) -> decltype( core.symtab.addUnion( decl ), void() ) { + ast::UnionDecl * fwd = new ast::UnionDecl( decl->location, decl->name ); + for ( const auto & param : decl->params ) { + fwd->params.push_back( deepCopy( param.get() ) ); + } + core.symtab.addUnion( fwd ); + } + + template + static inline void addUnionFwd( core_t &, long, const ast::UnionDecl * ) {} + + template + static inline auto addStruct( core_t & core, int, const std::string & str ) -> decltype( core.symtab.addStruct( str ), void() ) { + if ( ! core.symtab.lookupStruct( str ) ) { + core.symtab.addStruct( str ); + } + } + + template + static inline void addStruct( core_t &, long, const std::string & ) {} + + template + static inline auto addUnion( core_t & core, int, const std::string & str ) -> decltype( core.symtab.addUnion( str ), void() ) { + if ( ! core.symtab.lookupUnion( str ) ) { + core.symtab.addUnion( str ); + } + } + + template + static inline void addUnion( core_t &, long, const std::string & ) {} + + #undef SYMTAB_FUNC1 + #undef SYMTAB_FUNC2 +} // namespace symtab + +// Some passes need to mutate TypeDecl and properly update their pointing TypeInstType. +// Detect the presence of a member name `subs` and call all members appropriately +namespace forall { + // Some simple scoping rules + template + static inline auto enter( core_t & core, int, const ast::FunctionType * type ) + -> decltype( core.subs, void() ) { + if ( ! type->forall.empty() ) core.subs.beginScope(); + } + + template + static inline auto enter( core_t &, long, const ast::FunctionType * ) {} + + template + static inline auto leave( core_t & core, int, const ast::FunctionType * type ) + -> decltype( core.subs, void() ) { + if ( ! type->forall.empty() ) { core.subs.endScope(); } + } + + template + static inline auto leave( core_t &, long, const ast::FunctionType * ) {} + + // Replaces a TypeInstType's base TypeDecl according to the table + template + static inline auto replace( core_t & core, int, const ast::TypeInstType *& inst ) + -> decltype( core.subs, void() ) { + inst = ast::mutate_field( + inst, &ast::TypeInstType::base, core.subs.replace( inst->base ) ); + } + + template + static inline auto replace( core_t &, long, const ast::TypeInstType *& ) {} +} // namespace forall + +// For passes that need access to the global context. Searches `translationUnit` +namespace translation_unit { + template + static inline auto get_cptr( core_t & core, int ) + -> decltype( &core.translationUnit ) { + return &core.translationUnit; + } + + template + static inline const TranslationUnit ** get_cptr( core_t &, long ) { + return nullptr; + } +} + +// For passes, usually utility passes, that have a result. +namespace result { + template + static inline auto get( core_t & core, char ) -> decltype( core.result() ) { + return core.result(); + } + + template + static inline auto get( core_t & core, int ) -> decltype( core.result ) { + return core.result; + } + + template + static inline void get( core_t &, long ) {} +} + +} // namespace ast::__pass Index: src/AST/porting.md =================================================================== --- src/AST/porting.md (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ src/AST/porting.md (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -213,5 +213,5 @@ * `get_statement()` exclusively used for code location, replaced with `CodeLocation` field -`CaseStmt` +`CaseStmt` => `CaseClause` * `_isDefault` has been removed * `isDefault` calculates value from `cond` @@ -227,8 +227,8 @@ * `block` -> `body` and `finallyBlock` -> `finally` -`ThrowStmt` `CatchStmt` +`ThrowStmt` and `CatchStmt` => `CatchClause` * moved `Kind` enums to shared `ast::ExceptionKind` enum -`FinallyStmt` +`FinallyStmt` => `FinallyClause` * `block` -> `body` @@ -280,4 +280,5 @@ * Template class, with specializations and using to implement some other types: * `StructInstType`, `UnionInstType` & `EnumInstType` + * `baseStruct`, `baseUnion` & `baseEnum` => `base` `TypeInstType` Index: c/Common/CompilerError.h =================================================================== --- src/Common/CompilerError.h (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ (revision ) @@ -1,36 +1,0 @@ -// -// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo -// -// The contents of this file are covered under the licence agreement in the -// file "LICENCE" distributed with Cforall. -// -// CompilerError.h -- -// -// Author : Richard C. Bilson -// Created On : Mon May 18 07:44:20 2015 -// Last Modified By : Peter A. Buhr -// Last Modified On : Fri Jul 21 22:18:07 2017 -// Update Count : 4 -// - -#pragma once - -#include - -class CompilerError : public std::exception { - public: - CompilerError(); - CompilerError( std::string what ) : what( what ) {} - ~CompilerError() throw () {} - - std::string get_what() const { return what; } - void set_what( std::string newValue ) { what = newValue; } - private: - std::string what; -}; - -// Local Variables: // -// tab-width: 4 // -// mode: c++ // -// compile-command: "make install" // -// End: // Index: src/Common/Eval.cc =================================================================== --- src/Common/Eval.cc (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ src/Common/Eval.cc (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -5,5 +5,5 @@ // file "LICENCE" distributed with Cforall. // -// utility.h -- +// Eval.cc -- Evaluate parts of the ast at compile time. // // Author : Richard C. Bilson @@ -13,4 +13,6 @@ // Update Count : 119 // + +#include "Eval.h" #include // for pair Index: src/Common/Eval.h =================================================================== --- src/Common/Eval.h (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) +++ src/Common/Eval.h (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -0,0 +1,34 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// Eval.h -- Evaluate parts of the ast at compile time. +// +// Author : Andrew Beach +// Created On : Fri Feb 17 11:41:00 2023 +// Last Modified By : Andrew Beach +// Last Modified On : Fri Feb 17 11:41:00 2023 +// Update Count : 0 +// + +#pragma once + +#include // for pair + +class Expression; +namespace ast { + class Expr; +} + +/// Evaluates expr as a long long int. +/// If second is false, expr could not be evaluated. +std::pair eval(const Expression * expr); +std::pair eval(const ast::Expr * expr); + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/Common/Iterate.hpp =================================================================== --- src/Common/Iterate.hpp (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) +++ src/Common/Iterate.hpp (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -0,0 +1,241 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// Iterate.hpp -- +// +// Author : Andrew Beach +// Created On : Fri Feb 17 13:32:00 2023 +// Last Modified By : Andrew Beach +// Last Modified On : Fri Feb 17 13:32:00 2023 +// Update Count : 0 +// + +#pragma once + +#include +#include +#include + +// it's nice to actually be able to increment iterators by an arbitrary amount +template< class InputIt, class Distance > +InputIt operator+( InputIt it, Distance n ) { + advance(it, n); + return it; +} + +// ----------------------------------------------------------------------------- +// Helper struct and function to support +// for ( val : reverseIterate( container ) ) {} +// syntax to have a for each that iterates backwards + +template< typename T > +struct reverse_iterate_t { + T& ref; + + reverse_iterate_t( T & ref ) : ref(ref) {} + + // this does NOT work on const T!!! + // typedef typename T::reverse_iterator iterator; + auto begin() { return ref.rbegin(); } + auto end() { return ref.rend(); } +}; + +template< typename T > +reverse_iterate_t< T > reverseIterate( T & ref ) { + return reverse_iterate_t< T >( ref ); +} + +// ----------------------------------------------------------------------------- +template< typename T > +struct enumerate_t { + template + struct value_t { + val_t & val; + size_t idx; + }; + + template< typename iter_t, typename val_t > + struct iterator_t { + iter_t it; + size_t idx; + + iterator_t( iter_t _it, size_t _idx ) : it(_it), idx(_idx) {} + + value_t operator*() const { return value_t{ *it, idx }; } + + bool operator==(const iterator_t & o) const { return o.it == it; } + bool operator!=(const iterator_t & o) const { return o.it != it; } + + iterator_t & operator++() { + it++; + idx++; + return *this; + } + + using difference_type = typename std::iterator_traits< iter_t >::difference_type; + using value_type = value_t; + using pointer = value_t *; + using reference = value_t &; + using iterator_category = std::forward_iterator_tag; + }; + + T & ref; + + using iterator = iterator_t< typename T::iterator, typename T::value_type >; + using const_iterator = iterator_t< typename T::const_iterator, const typename T::value_type >; + + iterator begin() { return iterator( ref.begin(), 0 ); } + iterator end() { return iterator( ref.end(), ref.size() ); } + + const_iterator begin() const { return const_iterator( ref.cbegin(), 0 ); } + const_iterator end() const { return const_iterator( ref.cend(), ref.size() ); } + + const_iterator cbegin() const { return const_iterator( ref.cbegin(), 0 ); } + const_iterator cend() const { return const_iterator( ref.cend(), ref.size() ); } +}; + +template< typename T > +enumerate_t enumerate( T & ref ) { + return enumerate_t< T >{ ref }; +} + +template< typename T > +const enumerate_t< const T > enumerate( const T & ref ) { + return enumerate_t< const T >{ ref }; +} + +// ----------------------------------------------------------------------------- +template< typename OutType, typename Range, typename Functor > +OutType map_range( const Range& range, Functor&& functor ) { + OutType out; + + std::transform( + begin( range ), + end( range ), + std::back_inserter( out ), + std::forward< Functor >( functor ) + ); + + return out; +} + +// ----------------------------------------------------------------------------- +// Helper struct and function to support: +// for ( auto val : group_iterate( container1, container2, ... ) ) { ... } +// This iteraters through multiple containers of the same size. + +template +class group_iterate_t { + using Iterables = std::tuple; + Iterables iterables; + + // Getting the iterator and value types this way preserves const. + template using Iter = decltype(std::get(iterables).begin()); + template using Data = decltype(*std::get(iterables).begin()); + template struct base_iterator; + + // This inner template puts the sequence of `0, 1, ... sizeof...(Args)-1` + // into a pack. These are the indexes into the tuples, so unpacking can + // go over each element of the tuple. + // The std::integer_sequence is just used to build that sequence. + // A library reference will probably explain it better than I can. + template + struct base_iterator> { + using value_type = std::tuple< Data... >; + std::tuple...> iterators; + + base_iterator( Iter... is ) : iterators( is... ) {} + base_iterator operator++() { + return base_iterator( ++std::get( iterators )... ); + } + bool operator!=( const base_iterator& other ) const { + return iterators != other.iterators; + } + value_type operator*() const { + return std::tie( *std::get( iterators )... ); + } + + static base_iterator make_begin( Iterables & data ) { + return base_iterator( std::get( data ).begin()... ); + } + static base_iterator make_end( Iterables & data ) { + return base_iterator( std::get( data ).end()... ); + } + }; + +public: + group_iterate_t( const Args &... args ) : iterables( args... ) {} + + using iterator = base_iterator())>; + + iterator begin() { return iterator::make_begin( iterables ); } + iterator end() { return iterator::make_end( iterables ); } +}; + +// Helpers for the bounds checks (the non-varatic part of group_iterate): +static inline void runGroupBoundsCheck(size_t size0, size_t size1) { + assertf( size0 == size1, + "group iteration requires containers of the same size: <%zd, %zd>.", + size0, size1 ); +} + +static inline void runGroupBoundsCheck(size_t size0, size_t size1, size_t size2) { + assertf( size0 == size1 && size1 == size2, + "group iteration requires containers of the same size: <%zd, %zd, %zd>.", + size0, size1, size2 ); +} + +/// Performs bounds check to ensure that all arguments are of the same length. +template< typename... Args > +group_iterate_t group_iterate( Args &&... args ) { + runGroupBoundsCheck( args.size()... ); + return group_iterate_t( std::forward( args )... ); +} + +/// Does not perform a bounds check - requires user to ensure that iteration terminates when appropriate. +template< typename... Args > +group_iterate_t unsafe_group_iterate( Args &&... args ) { + return group_iterate_t( std::forward( args )... ); +} + +// ----------------------------------------------------------------------------- +// Helper struct and function to support +// for ( val : lazy_map( container1, f ) ) {} +// syntax to have a for each that iterates a container, mapping each element by applying f +template< typename T, typename Func > +struct lambda_iterate_t { + const T & ref; + std::function f; + + struct iterator { + typedef decltype(begin(ref)) Iter; + Iter it; + std::function f; + iterator( Iter it, std::function f ) : it(it), f(f) {} + iterator & operator++() { + ++it; return *this; + } + bool operator!=( const iterator &other ) const { return it != other.it; } + auto operator*() const -> decltype(f(*it)) { return f(*it); } + }; + + lambda_iterate_t( const T & ref, std::function f ) : ref(ref), f(f) {} + + auto begin() const -> decltype(iterator(std::begin(ref), f)) { return iterator(std::begin(ref), f); } + auto end() const -> decltype(iterator(std::end(ref), f)) { return iterator(std::end(ref), f); } +}; + +template< typename... Args > +lambda_iterate_t lazy_map( const Args &... args ) { + return lambda_iterate_t( args...); +} + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: c/Common/UnimplementedError.h =================================================================== --- src/Common/UnimplementedError.h (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ (revision ) @@ -1,36 +1,0 @@ -// -// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo -// -// The contents of this file are covered under the licence agreement in the -// file "LICENCE" distributed with Cforall. -// -// UnimplementedError.h -- -// -// Author : Richard C. Bilson -// Created On : Mon May 18 07:44:20 2015 -// Last Modified By : Peter A. Buhr -// Last Modified On : Fri Jul 21 22:18:35 2017 -// Update Count : 2 -// - -#pragma once - -#include - -class UnimplementedError : public std::exception { - public: - UnimplementedError(); - UnimplementedError( std::string what ) : what( what ) {} - ~UnimplementedError() throw () {} - - std::string get_what() const { return what; } - void set_what( std::string newValue ) { what = newValue; } - private: - std::string what; -}; - -// Local Variables: // -// tab-width: 4 // -// mode: c++ // -// compile-command: "make install" // -// End: // Index: src/Common/module.mk =================================================================== --- src/Common/module.mk (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ src/Common/module.mk (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -20,5 +20,4 @@ Common/CodeLocationTools.hpp \ Common/CodeLocationTools.cpp \ - Common/CompilerError.h \ Common/Debug.h \ Common/DeclStats.hpp \ @@ -26,4 +25,5 @@ Common/ErrorObjects.h \ Common/Eval.cc \ + Common/Eval.h \ Common/Examine.cc \ Common/Examine.h \ @@ -31,4 +31,5 @@ Common/Indenter.h \ Common/Indenter.cc \ + Common/Iterate.hpp \ Common/PassVisitor.cc \ Common/PassVisitor.h \ @@ -52,5 +53,4 @@ Common/Stats/Time.cc \ Common/Stats/Time.h \ - Common/UnimplementedError.h \ Common/UniqueName.cc \ Common/UniqueName.h \ Index: src/Common/utility.h =================================================================== --- src/Common/utility.h (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ src/Common/utility.h (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -5,11 +5,11 @@ // file "LICENCE" distributed with Cforall. // -// utility.h -- +// utility.h -- General utilities used across the compiler. // // Author : Richard C. Bilson // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Andrew Beach -// Last Modified On : Mon Apr 25 14:26:00 2022 -// Update Count : 51 +// Last Modified On : Fri Feb 17 15:25:00 2023 +// Update Count : 53 // @@ -19,7 +19,5 @@ #include #include -#include #include -#include #include #include @@ -27,5 +25,4 @@ #include #include -#include #include #include // memcmp @@ -49,27 +46,4 @@ return 0; } // if -} - -template< typename T, typename U > -struct maybeBuild_t { - static T * doit( const U *orig ) { - if ( orig ) { - return orig->build(); - } else { - return 0; - } // if - } -}; - -template< typename T, typename U > -static inline T * maybeBuild( const U *orig ) { - return maybeBuild_t::doit(orig); -} - -template< typename T, typename U > -static inline T * maybeMoveBuild( const U *orig ) { - T* ret = maybeBuild(orig); - delete orig; - return ret; } @@ -189,24 +163,4 @@ #define toCString( ... ) toString( __VA_ARGS__ ).c_str() - -// replace element of list with all elements of another list -template< typename T > -void replace( std::list< T > &org, typename std::list< T >::iterator pos, std::list< T > &with ) { - typename std::list< T >::iterator next = pos; advance( next, 1 ); - - //if ( next != org.end() ) { - org.erase( pos ); - org.splice( next, with ); - //} - - return; -} - -// replace range of a list with a single element -template< typename T > -void replace( std::list< T > &org, typename std::list< T >::iterator begin, typename std::list< T >::iterator end, const T & with ) { - org.insert( begin, with ); - org.erase( begin, end ); -} template< typename... Args > @@ -236,37 +190,9 @@ } -template< typename... Args > -auto zip(Args&&... args) -> decltype(zipWith(std::forward(args)..., std::make_pair)) { - return zipWith(std::forward(args)..., std::make_pair); -} - -template< class InputIterator1, class InputIterator2, class OutputIterator, class BinFunction > -void zipWith( InputIterator1 b1, InputIterator1 e1, InputIterator2 b2, InputIterator2 e2, OutputIterator out, BinFunction func ) { - while ( b1 != e1 && b2 != e2 ) - *out++ = func(*b1++, *b2++); -} - -// it's nice to actually be able to increment iterators by an arbitrary amount -template< class InputIt, class Distance > -InputIt operator+( InputIt it, Distance n ) { - advance(it, n); - return it; -} - -template< typename T > -void warn_single( const T & arg ) { - std::cerr << arg << std::endl; -} - -template< typename T, typename... Params > -void warn_single(const T & arg, const Params & ... params ) { - std::cerr << arg; - warn_single( params... ); -} - template< typename... Params > void warn( const Params & ... params ) { std::cerr << "Warning: "; - warn_single( params... ); + toString_single( std::cerr, params... ); + std::cerr << std::endl; } @@ -274,30 +200,6 @@ static inline bool isPrefix( const std::string & str, const std::string & pref, unsigned int start = 0 ) { if ( pref.size() > str.size() ) return false; - return 0 == memcmp( str.c_str() + start, pref.c_str(), pref.size() ); - // return prefix == full.substr(0, prefix.size()); // for future, requires c++17 -} - -// ----------------------------------------------------------------------------- -// Ref Counted Singleton class -// Objects that inherit from this class will have at most one reference to it -// but if all references die, the object will be deleted. - -template< typename ThisType > -class RefCountSingleton { - public: - static std::shared_ptr get() { - if( global_instance.expired() ) { - std::shared_ptr new_instance = std::make_shared(); - global_instance = new_instance; - return std::move(new_instance); - } - return global_instance.lock(); - } - private: - static std::weak_ptr global_instance; -}; - -template< typename ThisType > -std::weak_ptr RefCountSingleton::global_instance; + return pref == str.substr(start, pref.size()); +} // ----------------------------------------------------------------------------- @@ -356,210 +258,4 @@ ~ValueGuardPtr() { if( ref ) { swap( *ref, old ); } } }; - -// ----------------------------------------------------------------------------- -// Helper struct and function to support -// for ( val : reverseIterate( container ) ) {} -// syntax to have a for each that iterates backwards - -template< typename T > -struct reverse_iterate_t { - T& ref; - - reverse_iterate_t( T & ref ) : ref(ref) {} - - // this does NOT work on const T!!! - // typedef typename T::reverse_iterator iterator; - auto begin() { return ref.rbegin(); } - auto end() { return ref.rend(); } -}; - -template< typename T > -reverse_iterate_t< T > reverseIterate( T & ref ) { - return reverse_iterate_t< T >( ref ); -} - -template< typename T > -struct enumerate_t { - template - struct value_t { - val_t & val; - size_t idx; - }; - - template< typename iter_t, typename val_t > - struct iterator_t { - iter_t it; - size_t idx; - - iterator_t( iter_t _it, size_t _idx ) : it(_it), idx(_idx) {} - - value_t operator*() const { return value_t{ *it, idx }; } - - bool operator==(const iterator_t & o) const { return o.it == it; } - bool operator!=(const iterator_t & o) const { return o.it != it; } - - iterator_t & operator++() { - it++; - idx++; - return *this; - } - - using difference_type = typename std::iterator_traits< iter_t >::difference_type; - using value_type = value_t; - using pointer = value_t *; - using reference = value_t &; - using iterator_category = std::forward_iterator_tag; - }; - - T & ref; - - using iterator = iterator_t< typename T::iterator, typename T::value_type >; - using const_iterator = iterator_t< typename T::const_iterator, const typename T::value_type >; - - iterator begin() { return iterator( ref.begin(), 0 ); } - iterator end() { return iterator( ref.end(), ref.size() ); } - - const_iterator begin() const { return const_iterator( ref.cbegin(), 0 ); } - const_iterator end() const { return const_iterator( ref.cend(), ref.size() ); } - - const_iterator cbegin() const { return const_iterator( ref.cbegin(), 0 ); } - const_iterator cend() const { return const_iterator( ref.cend(), ref.size() ); } -}; - -template< typename T > -enumerate_t enumerate( T & ref ) { - return enumerate_t< T >{ ref }; -} - -template< typename T > -const enumerate_t< const T > enumerate( const T & ref ) { - return enumerate_t< const T >{ ref }; -} - -template< typename OutType, typename Range, typename Functor > -OutType map_range( const Range& range, Functor&& functor ) { - OutType out; - - std::transform( - begin( range ), - end( range ), - std::back_inserter( out ), - std::forward< Functor >( functor ) - ); - - return out; -} - -// ----------------------------------------------------------------------------- -// Helper struct and function to support: -// for ( auto val : group_iterate( container1, container2, ... ) ) { ... } -// This iteraters through multiple containers of the same size. - -template -class group_iterate_t { - using Iterables = std::tuple; - Iterables iterables; - - // Getting the iterator and value types this way preserves const. - template using Iter = decltype(std::get(iterables).begin()); - template using Data = decltype(*std::get(iterables).begin()); - template struct base_iterator; - - // This inner template puts the sequence of `0, 1, ... sizeof...(Args)-1` - // into a pack. These are the indexes into the tuples, so unpacking can - // go over each element of the tuple. - // The std::integer_sequence is just used to build that sequence. - // A library reference will probably explain it better than I can. - template - struct base_iterator> { - using value_type = std::tuple< Data... >; - std::tuple...> iterators; - - base_iterator( Iter... is ) : iterators( is... ) {} - base_iterator operator++() { - return base_iterator( ++std::get( iterators )... ); - } - bool operator!=( const base_iterator& other ) const { - return iterators != other.iterators; - } - value_type operator*() const { - return std::tie( *std::get( iterators )... ); - } - - static base_iterator make_begin( Iterables & data ) { - return base_iterator( std::get( data ).begin()... ); - } - static base_iterator make_end( Iterables & data ) { - return base_iterator( std::get( data ).end()... ); - } - }; - -public: - group_iterate_t( const Args &... args ) : iterables( args... ) {} - - using iterator = base_iterator())>; - - iterator begin() { return iterator::make_begin( iterables ); } - iterator end() { return iterator::make_end( iterables ); } -}; - -// Helpers for the bounds checks (the non-varatic part of group_iterate): -static inline void runGroupBoundsCheck(size_t size0, size_t size1) { - assertf( size0 == size1, - "group iteration requires containers of the same size: <%zd, %zd>.", - size0, size1 ); -} - -static inline void runGroupBoundsCheck(size_t size0, size_t size1, size_t size2) { - assertf( size0 == size1 && size1 == size2, - "group iteration requires containers of the same size: <%zd, %zd, %zd>.", - size0, size1, size2 ); -} - -/// Performs bounds check to ensure that all arguments are of the same length. -template< typename... Args > -group_iterate_t group_iterate( Args &&... args ) { - runGroupBoundsCheck( args.size()... ); - return group_iterate_t( std::forward( args )... ); -} - -/// Does not perform a bounds check - requires user to ensure that iteration terminates when appropriate. -template< typename... Args > -group_iterate_t unsafe_group_iterate( Args &&... args ) { - return group_iterate_t( std::forward( args )... ); -} - -// ----------------------------------------------------------------------------- -// Helper struct and function to support -// for ( val : lazy_map( container1, f ) ) {} -// syntax to have a for each that iterates a container, mapping each element by applying f -template< typename T, typename Func > -struct lambda_iterate_t { - const T & ref; - std::function f; - - struct iterator { - typedef decltype(begin(ref)) Iter; - Iter it; - std::function f; - iterator( Iter it, std::function f ) : it(it), f(f) {} - iterator & operator++() { - ++it; return *this; - } - bool operator!=( const iterator &other ) const { return it != other.it; } - auto operator*() const -> decltype(f(*it)) { return f(*it); } - }; - - lambda_iterate_t( const T & ref, std::function f ) : ref(ref), f(f) {} - - auto begin() const -> decltype(iterator(std::begin(ref), f)) { return iterator(std::begin(ref), f); } - auto end() const -> decltype(iterator(std::end(ref), f)) { return iterator(std::end(ref), f); } -}; - -template< typename... Args > -lambda_iterate_t lazy_map( const Args &... args ) { - return lambda_iterate_t( args...); -} // ----------------------------------------------------------------------------- @@ -583,48 +279,4 @@ } // ilog2 -// ----------------------------------------------------------------------------- -/// evaluates expr as a long long int. If second is false, expr could not be evaluated -std::pair eval(const Expression * expr); - -namespace ast { - class Expr; -} - -std::pair eval(const ast::Expr * expr); - -// ----------------------------------------------------------------------------- -/// Reorders the input range in-place so that the minimal-value elements according to the -/// comparator are in front; -/// returns the iterator after the last minimal-value element. -template -Iter sort_mins( Iter begin, Iter end, Compare& lt ) { - if ( begin == end ) return end; - - Iter min_pos = begin; - for ( Iter i = begin + 1; i != end; ++i ) { - if ( lt( *i, *min_pos ) ) { - // new minimum cost; swap into first position - min_pos = begin; - std::iter_swap( min_pos, i ); - } else if ( ! lt( *min_pos, *i ) ) { - // duplicate minimum cost; swap into next minimum position - ++min_pos; - std::iter_swap( min_pos, i ); - } - } - return ++min_pos; -} - -template -inline Iter sort_mins( Iter begin, Iter end, Compare&& lt ) { - return sort_mins( begin, end, lt ); -} - -/// sort_mins defaulted to use std::less -template -inline Iter sort_mins( Iter begin, Iter end ) { - return sort_mins( begin, end, std::less::value_type>{} ); -} - // Local Variables: // // tab-width: 4 // Index: src/GenPoly/Box.cc =================================================================== --- src/GenPoly/Box.cc (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ src/GenPoly/Box.cc (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -80,4 +80,5 @@ CallAdapter(); + void premutate( Declaration * declaration ); void premutate( FunctionDecl * functionDecl ); void premutate( TypeDecl * typeDecl ); @@ -454,4 +455,9 @@ CallAdapter::CallAdapter() : tempNamer( "_temp" ) {} + + void CallAdapter::premutate( Declaration * ) { + // Prevent type declaration information from leaking out. + GuardScope( scopeTyVars ); + } void CallAdapter::premutate( FunctionDecl *functionDecl ) { Index: src/GenPoly/FindFunction.cc =================================================================== --- src/GenPoly/FindFunction.cc (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ src/GenPoly/FindFunction.cc (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -9,7 +9,7 @@ // Author : Richard C. Bilson // Created On : Mon May 18 07:44:20 2015 -// Last Modified By : Rob Schluntz -// Last Modified On : Fri Feb 05 12:22:20 2016 -// Update Count : 6 +// Last Modified By : Andrew Beach +// Last Modified On : Fri Oct 7 17:05:20 2022 +// Update Count : 7 // @@ -18,4 +18,6 @@ #include // for pair +#include "AST/Pass.hpp" // for Pass +#include "AST/Type.hpp" #include "Common/PassVisitor.h" // for PassVisitor #include "GenPoly/ErasableScopedMap.h" // for ErasableScopedMap<>::iterator @@ -89,4 +91,94 @@ handleForall( pointerType->get_forall() ); } + +namespace { + +struct FindFunctionCore : + public ast::WithGuards, + public ast::WithShortCircuiting, + public ast::WithVisitorRef { + FindFunctionCore( + std::vector> & functions, + const TypeVarMap & typeVars, FindFunctionPred predicate, + bool replaceMode ); + + void previsit( ast::FunctionType const * type ); + ast::Type const * postvisit( ast::FunctionType const * type ); + void previsit( ast::PointerType const * type ); +private: + void handleForall( const ast::FunctionType::ForallList & forall ); + + std::vector> &functions; + TypeVarMap typeVars; + FindFunctionPred predicate; + bool replaceMode; +}; + +FindFunctionCore::FindFunctionCore( + std::vector> & functions, + const TypeVarMap &typeVars, FindFunctionPred predicate, + bool replaceMode ) : + functions( functions ), typeVars( typeVars ), + predicate( predicate ), replaceMode( replaceMode ) {} + +void FindFunctionCore::handleForall( const ast::FunctionType::ForallList & forall ) { + for ( const ast::ptr & td : forall ) { + TypeVarMap::iterator var = typeVars.find( *td ); + if ( var != typeVars.end() ) { + typeVars.erase( var->first ); + } // if + } // for +} + +void FindFunctionCore::previsit( ast::FunctionType const * type ) { + visit_children = false; + GuardScope( typeVars ); + handleForall( type->forall ); + //ast::accept_all( type->returns, *visitor ); + // This might have to become ast::mutate_each with return. + ast::accept_each( type->returns, *visitor ); +} + +ast::Type const * FindFunctionCore::postvisit( ast::FunctionType const * type ) { + ast::Type const * ret = type; + if ( predicate( type, typeVars ) ) { + functions.push_back( type ); + if ( replaceMode ) { + // replace type parameters in function type with void* + ret = scrubTypeVars( ast::deepCopy( type ), typeVars ); + } // if + } // if + return ret; +} + +void FindFunctionCore::previsit( ast::PointerType const * /*type*/ ) { + GuardScope( typeVars ); + //handleForall( type->forall ); +} + +} // namespace + +void findFunction( const ast::Type * type, + std::vector> & functions, + const TypeVarMap & typeVars, FindFunctionPred predicate ) { + ast::Pass pass( functions, typeVars, predicate, false ); + type->accept( pass ); + //(void)type; + //(void)functions; + //(void)typeVars; + //(void)predicate; +} + +const ast::Type * findAndReplaceFunction( const ast::Type * type, + std::vector> & functions, + const TypeVarMap & typeVars, FindFunctionPred predicate ) { + ast::Pass pass( functions, typeVars, predicate, true ); + return type->accept( pass ); + //(void)functions; + //(void)typeVars; + //(void)predicate; + //return type; +} + } // namespace GenPoly Index: src/GenPoly/FindFunction.h =================================================================== --- src/GenPoly/FindFunction.h (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ src/GenPoly/FindFunction.h (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -9,7 +9,7 @@ // Author : Richard C. Bilson // Created On : Mon May 18 07:44:20 2015 -// Last Modified By : Peter A. Buhr -// Last Modified On : Sat Jul 22 09:23:36 2017 -// Update Count : 2 +// Last Modified By : Andrew Beach +// Last Modified On : Fri Oct 7 10:30:00 2022 +// Update Count : 3 // @@ -30,4 +30,17 @@ /// like `findFunction`, but also replaces the function type with void ()(void) void findAndReplaceFunction( Type *&type, std::list< FunctionType const * > &functions, const TyVarMap &tyVars, FindFunctionPredicate predicate ); + +typedef bool (*FindFunctionPred)( const ast::FunctionType *, const TypeVarMap & ); + +/// Recursively walks `type`, placing all functions that match `predicate` +/// under `typeVars` into `functions`. +void findFunction( const ast::Type * type, + std::vector> & functions, + const TypeVarMap & typeVars, FindFunctionPred predicate ); +/// Like findFunction, but also replaces the function type with `void ()(void)`. +const ast::Type * findAndReplaceFunction( const ast::Type * type, + std::vector> & functions, + const TypeVarMap & typeVars, FindFunctionPred predicate ); + } // namespace GenPoly Index: src/GenPoly/GenPoly.cc =================================================================== --- src/GenPoly/GenPoly.cc (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ src/GenPoly/GenPoly.cc (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -275,4 +275,12 @@ } +const ast::BaseInstType *isDynRet( const ast::FunctionType * func ) { + if ( func->returns.empty() ) return nullptr; + + TypeVarMap forallTypes = { ast::TypeData() }; + makeTypeVarMap( func, forallTypes ); + return isDynType( func->returns.front(), forallTypes ); +} + bool needsAdapter( FunctionType *adaptee, const TyVarMap &tyVars ) { // if ( ! adaptee->get_returnVals().empty() && isPolyType( adaptee->get_returnVals().front()->get_type(), tyVars ) ) { @@ -319,4 +327,15 @@ return 0; } + +const ast::Type * isPolyPtr( + const ast::Type * type, const TypeVarMap & typeVars, + const ast::TypeSubstitution * typeSubs ) { + type = replaceTypeInst( type, typeSubs ); + + if ( auto * ptr = dynamic_cast( type ) ) { + return isPolyType( ptr->base, typeVars, typeSubs ); + } + return nullptr; +} Type * hasPolyBase( Type *type, int *levels, const TypeSubstitution *env ) { @@ -796,6 +815,10 @@ } +void addToTypeVarMap( const ast::TypeDecl * decl, TypeVarMap & typeVars ) { + typeVars.insert( ast::TypeEnvKey( decl, 0, 0 ), ast::TypeData( decl ) ); +} + void addToTypeVarMap( const ast::TypeInstType * type, TypeVarMap & typeVars ) { - typeVars.insert( *type, ast::TypeData( type->base ) ); + typeVars.insert( ast::TypeEnvKey( *type ), ast::TypeData( type->base ) ); } @@ -822,4 +845,10 @@ } +void makeTypeVarMap( const ast::FunctionDecl * decl, TypeVarMap & typeVars ) { + for ( auto & typeDecl : decl->type_params ) { + addToTypeVarMap( typeDecl, typeVars ); + } +} + void printTyVarMap( std::ostream &os, const TyVarMap &tyVarMap ) { for ( TyVarMap::const_iterator i = tyVarMap.begin(); i != tyVarMap.end(); ++i ) { Index: src/GenPoly/GenPoly.h =================================================================== --- src/GenPoly/GenPoly.h (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ src/GenPoly/GenPoly.h (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -111,8 +111,10 @@ void addToTyVarMap( TypeDecl * tyVar, TyVarMap &tyVarMap ); void addToTypeVarMap( const ast::TypeDecl * type, TypeVarMap & typeVars ); + void addToTypeVarMap( const ast::TypeInstType * type, TypeVarMap & typeVars ); /// Adds the declarations in the forall list of type (and its pointed-to type if it's a pointer type) to `tyVarMap` void makeTyVarMap( Type *type, TyVarMap &tyVarMap ); void makeTypeVarMap( const ast::Type * type, TypeVarMap & typeVars ); + void makeTypeVarMap( const ast::FunctionDecl * decl, TypeVarMap & typeVars ); /// Prints type variable map Index: src/Parser/DeclarationNode.cc =================================================================== --- src/Parser/DeclarationNode.cc (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ src/Parser/DeclarationNode.cc (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -10,6 +10,6 @@ // Created On : Sat May 16 12:34:05 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon Aug 8 17:07:00 2022 -// Update Count : 1185 +// Last Modified On : Thu Feb 16 14:12:03 2023 +// Update Count : 1388 // @@ -61,8 +61,4 @@ variable.initializer = nullptr; -// attr.name = nullptr; - attr.expr = nullptr; - attr.type = nullptr; - assert.condition = nullptr; assert.message = nullptr; @@ -70,8 +66,4 @@ DeclarationNode::~DeclarationNode() { -// delete attr.name; - delete attr.expr; - delete attr.type; - // delete variable.name; delete variable.assertions; @@ -115,8 +107,4 @@ newnode->variable.initializer = maybeClone( variable.initializer ); -// newnode->attr.name = attr.name ? new string( *attr.name ) : nullptr; - newnode->attr.expr = maybeClone( attr.expr ); - newnode->attr.type = maybeClone( attr.type ); - newnode->assert.condition = maybeClone( assert.condition ); newnode->assert.message = maybeClone( assert.message ); @@ -154,7 +142,10 @@ } // if - for ( Attribute * attr: reverseIterate( attributes ) ) { - os << string( indent + 2, ' ' ) << "attr " << attr->name.c_str(); - } // for + if ( ! attributes.empty() ) { + os << string( indent + 2, ' ' ) << "with attributes " << endl; + for ( Attribute * attr: reverseIterate( attributes ) ) { + os << string( indent + 4, ' ' ) << attr->name.c_str() << endl; + } // for + } // if os << endl; @@ -244,5 +235,6 @@ newnode->type = new TypeData( TypeData::Aggregate ); newnode->type->aggregate.kind = kind; - newnode->type->aggregate.name = name == nullptr ? new string( DeclarationNode::anonymous.newName() ) : name; + newnode->type->aggregate.anon = name == nullptr; + newnode->type->aggregate.name = newnode->type->aggregate.anon ? new string( DeclarationNode::anonymous.newName() ) : name; newnode->type->aggregate.actuals = actuals; newnode->type->aggregate.fields = fields; @@ -250,5 +242,4 @@ newnode->type->aggregate.tagged = false; newnode->type->aggregate.parent = nullptr; - newnode->type->aggregate.anon = name == nullptr; return newnode; } // DeclarationNode::newAggregate @@ -257,8 +248,8 @@ DeclarationNode * newnode = new DeclarationNode; newnode->type = new TypeData( TypeData::Enum ); - newnode->type->enumeration.name = name == nullptr ? new string( DeclarationNode::anonymous.newName() ) : name; + newnode->type->enumeration.anon = name == nullptr; + newnode->type->enumeration.name = newnode->type->enumeration.anon ? new string( DeclarationNode::anonymous.newName() ) : name; newnode->type->enumeration.constants = constants; newnode->type->enumeration.body = body; - newnode->type->enumeration.anon = name == nullptr; newnode->type->enumeration.typed = typed; newnode->type->enumeration.hiding = hiding; @@ -989,13 +980,17 @@ for ( const DeclarationNode * cur = firstNode; cur; cur = dynamic_cast< DeclarationNode * >( cur->get_next() ) ) { try { - bool extracted = false; - bool anon = false; + bool extracted = false, anon = false; + AggregateDecl * unionDecl = nullptr; + if ( DeclarationNode * extr = cur->extractAggregate() ) { // handle the case where a structure declaration is contained within an object or type declaration + Declaration * decl = extr->build(); if ( decl ) { - // hoist the structure declaration + // Remember the declaration if it is a union aggregate ? + unionDecl = dynamic_cast( decl ); + decl->location = cur->location; - * out++ = decl; + *out++ = decl; // need to remember the cases where a declaration contains an anonymous aggregate definition @@ -1003,7 +998,8 @@ assert( extr->type ); if ( extr->type->kind == TypeData::Aggregate ) { + // typedef struct { int A } B is the only case? anon = extr->type->aggregate.anon; } else if ( extr->type->kind == TypeData::Enum ) { - // xxx - is it useful to have an implicit anonymous enum member? + // typedef enum { A } B is the only case? anon = extr->type->enumeration.anon; } @@ -1014,4 +1010,33 @@ Declaration * decl = cur->build(); if ( decl ) { + if ( TypedefDecl * typedefDecl = dynamic_cast( decl ) ) { + if ( unionDecl ) { // is the typedef alias a union aggregate ? + // This code handles a special issue with the attribute transparent_union. + // + // typedef union U { int i; } typedef_name __attribute__(( aligned(16) )) __attribute__(( transparent_union )) + // + // Here the attribute aligned goes with the typedef_name, so variables declared of this type are + // aligned. However, the attribute transparent_union must be moved from the typedef_name to + // alias union U. Currently, this is the only know attribute that must be moved from typedef to + // alias. + + // If typedef is an alias for a union, then its alias type was hoisted above and remembered. + if ( UnionInstType * unionInstType = dynamic_cast( typedefDecl->base ) ) { + // Remove all transparent_union attributes from typedef and move to alias union. + list::iterator attr; + for ( attr = unionInstType->attributes.begin(); attr != unionInstType->attributes.end(); ) { // forward order + if ( (*attr)->name == "transparent_union" || (*attr)->name == "__transparent_union__" ) { + list::iterator cur = attr; // remember current node + attr++; // advance iterator + unionDecl->attributes.emplace_back( *cur ); // move current + unionInstType->attributes.erase( cur ); // remove current + } else { + attr++; // advance iterator + } // if + } // for + } // if + } // if + } // if + // don't include anonymous declaration for named aggregates, but do include them for anonymous aggregates, e.g.: // struct S { @@ -1176,10 +1201,4 @@ assert( type ); - if ( attr.expr ) { - return new AttrType( buildQualifiers( type ), *name, attr.expr->build(), attributes ); - } else if ( attr.type ) { - return new AttrType( buildQualifiers( type ), *name, attr.type->buildType(), attributes ); - } // if - switch ( type->kind ) { case TypeData::Enum: Index: src/Parser/ExpressionNode.cc =================================================================== --- src/Parser/ExpressionNode.cc (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ src/Parser/ExpressionNode.cc (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -10,6 +10,6 @@ // Created On : Sat May 16 13:17:07 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Sat Aug 7 09:18:56 2021 -// Update Count : 1077 +// Last Modified On : Sat Feb 11 14:49:00 2023 +// Update Count : 1079 // @@ -173,8 +173,8 @@ if ( posn != string::npos ) { Unsigned = true; type = 2; ltype = 4; str.erase( posn, 1 ); goto FINI; } - posn = str.rfind( "hh" ); // char + posn = str.rfind( "hh" ); // signed char if ( posn != string::npos ) { type = 1; str.erase( posn, 2 ); goto FINI; } - posn = str.rfind( "HH" ); // char + posn = str.rfind( "HH" ); // signed char if ( posn != string::npos ) { type = 1; str.erase( posn, 2 ); goto FINI; } @@ -592,5 +592,5 @@ Expression * build_unary_ptr( OperKinds op, ExpressionNode * expr_node ) { list< Expression * > args; - args.push_back( maybeMoveBuild< Expression >(expr_node) ); // xxx -- this is exactly the same as the val case now, refactor this code. + args.push_back( maybeMoveBuild< Expression >(expr_node) ); // xxx -- this is exactly the same as the val case now, refactor this code. return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args ); } // build_unary_ptr Index: src/Parser/ParseNode.h =================================================================== --- src/Parser/ParseNode.h (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ src/Parser/ParseNode.h (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -10,6 +10,6 @@ // Created On : Sat May 16 13:28:16 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Wed Nov 2 21:27:07 2022 -// Update Count : 939 +// Last Modified On : Sun Feb 19 09:02:37 2023 +// Update Count : 940 // @@ -27,5 +27,6 @@ #include "Common/SemanticError.h" // for SemanticError #include "Common/UniqueName.h" // for UniqueName -#include "Common/utility.h" // for maybeClone, maybeBuild +#include "Common/utility.h" // for maybeClone +#include "Parser/parserutility.h" // for maybeBuild #include "SynTree/LinkageSpec.h" // for Spec #include "SynTree/Declaration.h" // for Aggregate @@ -324,11 +325,4 @@ Variable_t variable; - struct Attr_t { -// const std::string * name; - ExpressionNode * expr; - DeclarationNode * type; - }; - Attr_t attr; - struct StaticAssert_t { ExpressionNode * condition; @@ -342,5 +336,5 @@ bool inLine = false; - bool enumInLine = false; + bool enumInLine = false; Type::FuncSpecifiers funcSpecs; Type::StorageClasses storageClasses; Index: src/Parser/RunParser.cpp =================================================================== --- src/Parser/RunParser.cpp (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ src/Parser/RunParser.cpp (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -10,6 +10,6 @@ // Created On : Mon Dec 19 11:00:00 2022 // Last Modified By : Andrew Beach -// Last Modified On : Thr Dec 22 10:18:00 2022 -// Update Count : 1 +// Last Modified On : Thr Feb 16 10:08:00 2023 +// Update Count : 2 // @@ -24,9 +24,9 @@ // Variables global to the parsing code. -LinkageSpec::Spec linkage = LinkageSpec::Cforall; +ast::Linkage::Spec linkage = ast::Linkage::Cforall; TypedefTable typedefTable; DeclarationNode * parseTree = nullptr; -void parse( FILE * input, LinkageSpec::Spec linkage, bool alwaysExit ) { +void parse( FILE * input, ast::Linkage::Spec linkage, bool alwaysExit ) { extern int yyparse( void ); extern FILE * yyin; Index: src/Parser/RunParser.hpp =================================================================== --- src/Parser/RunParser.hpp (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ src/Parser/RunParser.hpp (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -10,6 +10,6 @@ // Created On : Mon Dec 19 10:42:00 2022 // Last Modified By : Andrew Beach -// Last Modified On : Thr Dec 22 10:23:00 2022 -// Update Count : 1 +// Last Modified On : Thr Feb 16 10:08:00 2023 +// Update Count : 2 // @@ -18,5 +18,5 @@ #include // for ostream -#include "SynTree/LinkageSpec.h" // for Spec +#include "AST/LinkageSpec.hpp" // for Spec namespace ast { class TranslationUnit; @@ -29,5 +29,5 @@ /// The input file is closed when complete. Exits instead of returning on /// error or if alwaysExit is true. -void parse( FILE * input, LinkageSpec::Spec linkage, bool alwaysExit = false ); +void parse( FILE * input, ast::Linkage::Spec linkage, bool alwaysExit = false ); /// Drain the internal accumulator of parsed code and build a translation Index: src/Parser/TypeData.cc =================================================================== --- src/Parser/TypeData.cc (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ src/Parser/TypeData.cc (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -10,6 +10,6 @@ // Created On : Sat May 16 15:12:51 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Tue May 10 22:36:52 2022 -// Update Count : 677 +// Last Modified On : Sun Feb 19 11:00:46 2023 +// Update Count : 679 // @@ -375,5 +375,5 @@ break; case Enum: - os << "enumeration "; + os << "enumeration " << *enumeration.name << endl;; if ( enumeration.constants ) { os << "with constants" << endl; Index: src/Parser/TypeData.h =================================================================== --- src/Parser/TypeData.h (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ src/Parser/TypeData.h (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -10,6 +10,6 @@ // Created On : Sat May 16 15:18:36 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Tue May 10 22:18:49 2022 -// Update Count : 203 +// Last Modified On : Sun Feb 19 09:09:39 2023 +// Update Count : 204 // @@ -37,5 +37,4 @@ bool body; bool anon; - bool tagged; const std::string * parent = nullptr; Index: src/Parser/parser.yy =================================================================== --- src/Parser/parser.yy (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ src/Parser/parser.yy (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -10,6 +10,6 @@ // Created On : Sat Sep 1 20:22:55 2001 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Feb 2 21:36:16 2023 -// Update Count : 5865 +// Last Modified On : Mon Feb 20 11:31:26 2023 +// Update Count : 5896 // @@ -55,5 +55,5 @@ #include "Common/utility.h" // for maybeMoveBuild, maybeBuild, CodeLo... -#include "SynTree/Attribute.h" // for Attribute +#include "SynTree/Attribute.h" // for Attribute // lex uses __null in a boolean context, it's fine. @@ -1951,5 +1951,5 @@ { typedefTable.addToEnclosingScope( *$4->name, TYPEDEFname, "6" ); - $$ = $4->addType( $3 )->addQualifiers( $1 )->addTypedef(); + $$ = $4->addQualifiers( $1 )->addType( $3 )->addTypedef(); } | type_specifier TYPEDEF declarator @@ -1961,5 +1961,5 @@ { typedefTable.addToEnclosingScope( *$4->name, TYPEDEFname, "8" ); - $$ = $4->addQualifiers( $1 )->addTypedef()->addType( $1 ); + $$ = $4->addQualifiers( $1 )->addType( $1 )->addTypedef(); } ; @@ -1983,4 +1983,10 @@ | typedef_expression // deprecated GCC, naming expression type | sue_declaration_specifier + { + assert( $1->type ); + if ( $1->type->qualifiers.val != 0 ) { + SemanticError( yylloc, "Useless type qualifier in empty declaration." ); $$ = nullptr; + } + } ; Index: src/Parser/parserutility.h =================================================================== --- src/Parser/parserutility.h (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ src/Parser/parserutility.h (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -5,11 +5,11 @@ // file "LICENCE" distributed with Cforall. // -// parserutility.h -- +// parserutility.h -- Collected utilities for the parser. // // Author : Rodolfo G. Esteves // Created On : Sat May 16 15:31:46 2015 -// Last Modified By : Peter A. Buhr -// Last Modified On : Sat Jul 22 09:32:58 2017 -// Update Count : 4 +// Last Modified By : Andrew Beach +// Last Modified On : Thr Feb 16 12:34:00 2023 +// Update Count : 5 // @@ -20,4 +20,27 @@ Expression *notZeroExpr( Expression *orig ); +template< typename T, typename U > +struct maybeBuild_t { + static T * doit( const U *orig ) { + if ( orig ) { + return orig->build(); + } else { + return 0; + } + } +}; + +template< typename T, typename U > +static inline T * maybeBuild( const U *orig ) { + return maybeBuild_t::doit(orig); +} + +template< typename T, typename U > +static inline T * maybeMoveBuild( const U *orig ) { + T* ret = maybeBuild(orig); + delete orig; + return ret; +} + // Local Variables: // // tab-width: 4 // Index: src/ResolvExpr/CurrentObject.cc =================================================================== --- src/ResolvExpr/CurrentObject.cc (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ src/ResolvExpr/CurrentObject.cc (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -26,6 +26,7 @@ #include "AST/Init.hpp" // for Designation #include "AST/Node.hpp" // for readonly -#include "AST/Print.hpp" // for readonly +#include "AST/Print.hpp" // for readonly #include "AST/Type.hpp" +#include "Common/Eval.h" // for eval #include "Common/Indenter.h" // for Indenter, operator<< #include "Common/SemanticError.h" // for SemanticError Index: src/ResolvExpr/ResolveAssertions.cc =================================================================== --- src/ResolvExpr/ResolveAssertions.cc (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ src/ResolvExpr/ResolveAssertions.cc (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -30,5 +30,4 @@ #include "Common/FilterCombos.h" // for filterCombos #include "Common/Indenter.h" // for Indenter -#include "Common/utility.h" // for sort_mins #include "GenPoly/GenPoly.h" // for getFunctionType #include "ResolvExpr/AlternativeFinder.h" // for computeConversionCost Index: src/ResolvExpr/Resolver.cc =================================================================== --- src/ResolvExpr/Resolver.cc (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ src/ResolvExpr/Resolver.cc (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -38,4 +38,5 @@ #include "AST/SymbolTable.hpp" #include "AST/Type.hpp" +#include "Common/Eval.h" // for eval #include "Common/PassVisitor.h" // for PassVisitor #include "Common/SemanticError.h" // for SemanticError Index: src/ResolvExpr/Resolver.h =================================================================== --- src/ResolvExpr/Resolver.h (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ src/ResolvExpr/Resolver.h (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -34,4 +34,5 @@ class Decl; class DeletedExpr; + class Expr; class Init; class StmtExpr; Index: src/SynTree/AggregateDecl.cc =================================================================== --- src/SynTree/AggregateDecl.cc (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ src/SynTree/AggregateDecl.cc (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -19,4 +19,5 @@ #include "Attribute.h" // for Attribute +#include "Common/Eval.h" // for eval #include "Common/utility.h" // for printAll, cloneAll, deleteAll #include "Declaration.h" // for AggregateDecl, TypeDecl, Declaration Index: src/SynTree/Type.h =================================================================== --- src/SynTree/Type.h (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ src/SynTree/Type.h (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -9,7 +9,7 @@ // Author : Richard C. Bilson // Created On : Mon May 18 07:44:20 2015 -// Last Modified By : Andrew Beach -// Last Modified On : Wed Jul 14 15:40:00 2021 -// Update Count : 171 +// Last Modified By : Peter A. Buhr +// Last Modified On : Sun Feb 19 22:37:10 2023 +// Update Count : 176 // @@ -23,5 +23,6 @@ #include "BaseSyntaxNode.h" // for BaseSyntaxNode -#include "Common/utility.h" // for operator+ +#include "Common/Iterate.hpp"// for operator+ +#include "Common/utility.h" // for toCString #include "Mutator.h" // for Mutator #include "SynTree.h" // for AST nodes @@ -124,8 +125,8 @@ bool operator!=( Qualifiers other ) const { return (val & Mask) != (other.val & Mask); } bool operator<=( Qualifiers other ) const { - return is_const <= other.is_const //Any non-const converts to const without cost - && is_volatile <= other.is_volatile //Any non-volatile converts to volatile without cost - && is_mutex >= other.is_mutex //Any mutex converts to non-mutex without cost - && is_atomic == other.is_atomic; //No conversion from atomic to non atomic is free + return is_const <= other.is_const // Any non-const converts to const without cost + && is_volatile <= other.is_volatile // Any non-volatile converts to volatile without cost + && is_mutex >= other.is_mutex // Any mutex converts to non-mutex without cost + && is_atomic == other.is_atomic; // No conversion from atomic to non atomic is free } bool operator<( Qualifiers other ) const { return *this != other && *this <= other; } @@ -189,8 +190,8 @@ virtual TypeSubstitution genericSubstitution() const; - virtual Type *clone() const = 0; + virtual Type * clone() const = 0; virtual void accept( Visitor & v ) = 0; virtual void accept( Visitor & v ) const = 0; - virtual Type *acceptMutator( Mutator & m ) = 0; + virtual Type * acceptMutator( Mutator & m ) = 0; virtual void print( std::ostream & os, Indenter indent = {} ) const; }; @@ -207,8 +208,8 @@ virtual bool isComplete() const override { return false; } - virtual VoidType *clone() const override { return new VoidType( *this ); } - virtual void accept( Visitor & v ) override { v.visit( this ); } - virtual void accept( Visitor & v ) const override { v.visit( this ); } - virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); } + virtual VoidType * clone() const override { return new VoidType( *this ); } + virtual void accept( Visitor & v ) override { v.visit( this ); } + virtual void accept( Visitor & v ) const override { v.visit( this ); } + virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); } virtual void print( std::ostream & os, Indenter indent = {} ) const override; }; @@ -259,5 +260,5 @@ // GENERATED END - static const char *typeNames[]; // string names for basic types, MUST MATCH with Kind + static const char * typeNames[]; // string names for basic types, MUST MATCH with Kind BasicType( const Type::Qualifiers & tq, Kind bt, const std::list< Attribute * > & attributes = std::list< Attribute * >() ); @@ -266,8 +267,8 @@ void set_kind( Kind newValue ) { kind = newValue; } - virtual BasicType *clone() const override { return new BasicType( *this ); } - virtual void accept( Visitor & v ) override { v.visit( this ); } - virtual void accept( Visitor & v ) const override { v.visit( this ); } - virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); } + virtual BasicType * clone() const override { return new BasicType( *this ); } + virtual void accept( Visitor & v ) override { v.visit( this ); } + virtual void accept( Visitor & v ) const override { v.visit( this ); } + virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); } virtual void print( std::ostream & os, Indenter indent = {} ) const override; bool isInteger() const; @@ -279,17 +280,17 @@ // In C99, pointer types can be qualified in many ways e.g., int f( int a[ static 3 ] ) - Expression *dimension; + Expression * dimension; bool isVarLen; bool isStatic; - PointerType( const Type::Qualifiers & tq, Type *base, const std::list< Attribute * > & attributes = std::list< Attribute * >() ); - PointerType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() ); + PointerType( const Type::Qualifiers & tq, Type * base, const std::list< Attribute * > & attributes = std::list< Attribute * >() ); + PointerType( const Type::Qualifiers & tq, Type * base, Expression * dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() ); PointerType( const PointerType& ); virtual ~PointerType(); - Type *get_base() { return base; } - void set_base( Type *newValue ) { base = newValue; } - Expression *get_dimension() { return dimension; } - void set_dimension( Expression *newValue ) { dimension = newValue; } + Type * get_base() { return base; } + void set_base( Type * newValue ) { base = newValue; } + Expression * get_dimension() { return dimension; } + void set_dimension( Expression * newValue ) { dimension = newValue; } bool get_isVarLen() { return isVarLen; } void set_isVarLen( bool newValue ) { isVarLen = newValue; } @@ -301,8 +302,8 @@ virtual bool isComplete() const override { return ! isVarLen; } - virtual PointerType *clone() const override { return new PointerType( *this ); } - virtual void accept( Visitor & v ) override { v.visit( this ); } - virtual void accept( Visitor & v ) const override { v.visit( this ); } - virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); } + virtual PointerType * clone() const override { return new PointerType( * this ); } + virtual void accept( Visitor & v ) override { v.visit( this ); } + virtual void accept( Visitor & v ) const override { v.visit( this ); } + virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); } virtual void print( std::ostream & os, Indenter indent = {} ) const override; }; @@ -310,17 +311,17 @@ class ArrayType : public Type { public: - Type *base; - Expression *dimension; + Type * base; + Expression * dimension; bool isVarLen; bool isStatic; - ArrayType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() ); + ArrayType( const Type::Qualifiers & tq, Type * base, Expression * dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() ); ArrayType( const ArrayType& ); virtual ~ArrayType(); - Type *get_base() { return base; } - void set_base( Type *newValue ) { base = newValue; } - Expression *get_dimension() { return dimension; } - void set_dimension( Expression *newValue ) { dimension = newValue; } + Type * get_base() { return base; } + void set_base( Type * newValue ) { base = newValue; } + Expression * get_dimension() { return dimension; } + void set_dimension( Expression * newValue ) { dimension = newValue; } bool get_isVarLen() { return isVarLen; } void set_isVarLen( bool newValue ) { isVarLen = newValue; } @@ -333,8 +334,8 @@ virtual bool isComplete() const override { return dimension || isVarLen; } - virtual ArrayType *clone() const override { return new ArrayType( *this ); } - virtual void accept( Visitor & v ) override { v.visit( this ); } - virtual void accept( Visitor & v ) const override { v.visit( this ); } - virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); } + virtual ArrayType * clone() const override { return new ArrayType( *this ); } + virtual void accept( Visitor & v ) override { v.visit( this ); } + virtual void accept( Visitor & v ) const override { v.visit( this ); } + virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); } virtual void print( std::ostream & os, Indenter indent = {} ) const override; }; @@ -348,8 +349,8 @@ virtual ~QualifiedType(); - virtual QualifiedType *clone() const override { return new QualifiedType( *this ); } - virtual void accept( Visitor & v ) override { v.visit( this ); } - virtual void accept( Visitor & v ) const override { v.visit( this ); } - virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); } + virtual QualifiedType * clone() const override { return new QualifiedType( *this ); } + virtual void accept( Visitor & v ) override { v.visit( this ); } + virtual void accept( Visitor & v ) const override { v.visit( this ); } + virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); } virtual void print( std::ostream & os, Indenter indent = {} ) const override; }; @@ -357,12 +358,12 @@ class ReferenceType : public Type { public: - Type *base; - - ReferenceType( const Type::Qualifiers & tq, Type *base, const std::list< Attribute * > & attributes = std::list< Attribute * >() ); + Type * base; + + ReferenceType( const Type::Qualifiers & tq, Type * base, const std::list< Attribute * > & attributes = std::list< Attribute * >() ); ReferenceType( const ReferenceType & ); virtual ~ReferenceType(); - Type *get_base() { return base; } - void set_base( Type *newValue ) { base = newValue; } + Type * get_base() { return base; } + void set_base( Type * newValue ) { base = newValue; } virtual int referenceDepth() const override; @@ -375,8 +376,8 @@ virtual TypeSubstitution genericSubstitution() const override; - virtual ReferenceType *clone() const override { return new ReferenceType( *this ); } - virtual void accept( Visitor & v ) override { v.visit( this ); } - virtual void accept( Visitor & v ) const override { v.visit( this ); } - virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); } + virtual ReferenceType * clone() const override { return new ReferenceType( *this ); } + virtual void accept( Visitor & v ) override { v.visit( this ); } + virtual void accept( Visitor & v ) const override { v.visit( this ); } + virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); } virtual void print( std::ostream & os, Indenter indent = {} ) const override; }; @@ -405,8 +406,8 @@ bool isUnprototyped() const { return isVarArgs && parameters.size() == 0; } - virtual FunctionType *clone() const override { return new FunctionType( *this ); } - virtual void accept( Visitor & v ) override { v.visit( this ); } - virtual void accept( Visitor & v ) const override { v.visit( this ); } - virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); } + virtual FunctionType * clone() const override { return new FunctionType( *this ); } + virtual void accept( Visitor & v ) override { v.visit( this ); } + virtual void accept( Visitor & v ) const override { v.visit( this ); } + virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); } virtual void print( std::ostream & os, Indenter indent = {} ) const override; }; @@ -414,5 +415,5 @@ class ReferenceToType : public Type { public: - std::list< Expression* > parameters; + std::list< Expression * > parameters; std::string name; bool hoistType; @@ -428,7 +429,7 @@ void set_hoistType( bool newValue ) { hoistType = newValue; } - virtual ReferenceToType *clone() const override = 0; + virtual ReferenceToType * clone() const override = 0; virtual void accept( Visitor & v ) override = 0; - virtual Type *acceptMutator( Mutator & m ) override = 0; + virtual Type * acceptMutator( Mutator & m ) override = 0; virtual void print( std::ostream & os, Indenter indent = {} ) const override; @@ -443,5 +444,5 @@ // this decl is not "owned" by the struct inst; it is merely a pointer to elsewhere in the tree, // where the structure used in this type is actually defined - StructDecl *baseStruct; + StructDecl * baseStruct; StructInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >() ) : Parent( tq, name, attributes ), baseStruct( 0 ) {} @@ -449,6 +450,6 @@ StructInstType( const StructInstType & other ) : Parent( other ), baseStruct( other.baseStruct ) {} - StructDecl *get_baseStruct() const { return baseStruct; } - void set_baseStruct( StructDecl *newValue ) { baseStruct = newValue; } + StructDecl * get_baseStruct() const { return baseStruct; } + void set_baseStruct( StructDecl * newValue ) { baseStruct = newValue; } /// Accesses generic parameters of base struct (NULL if none such) @@ -466,8 +467,8 @@ void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const override; - virtual StructInstType *clone() const override { return new StructInstType( *this ); } - virtual void accept( Visitor & v ) override { v.visit( this ); } - virtual void accept( Visitor & v ) const override { v.visit( this ); } - virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); } + virtual StructInstType * clone() const override { return new StructInstType( *this ); } + virtual void accept( Visitor & v ) override { v.visit( this ); } + virtual void accept( Visitor & v ) const override { v.visit( this ); } + virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); } virtual void print( std::ostream & os, Indenter indent = {} ) const override; @@ -481,5 +482,5 @@ // this decl is not "owned" by the union inst; it is merely a pointer to elsewhere in the tree, // where the union used in this type is actually defined - UnionDecl *baseUnion; + UnionDecl * baseUnion; UnionInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >() ) : Parent( tq, name, attributes ), baseUnion( 0 ) {} @@ -487,5 +488,5 @@ UnionInstType( const UnionInstType & other ) : Parent( other ), baseUnion( other.baseUnion ) {} - UnionDecl *get_baseUnion() const { return baseUnion; } + UnionDecl * get_baseUnion() const { return baseUnion; } void set_baseUnion( UnionDecl * newValue ) { baseUnion = newValue; } @@ -504,8 +505,8 @@ void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const override; - virtual UnionInstType *clone() const override { return new UnionInstType( *this ); } - virtual void accept( Visitor & v ) override { v.visit( this ); } - virtual void accept( Visitor & v ) const override { v.visit( this ); } - virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); } + virtual UnionInstType * clone() const override { return new UnionInstType( *this ); } + virtual void accept( Visitor & v ) override { v.visit( this ); } + virtual void accept( Visitor & v ) const override { v.visit( this ); } + virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); } virtual void print( std::ostream & os, Indenter indent = {} ) const override; @@ -519,5 +520,5 @@ // this decl is not "owned" by the enum inst; it is merely a pointer to elsewhere in the tree, // where the enum used in this type is actually defined - EnumDecl *baseEnum = nullptr; + EnumDecl * baseEnum = nullptr; EnumInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >() ) : Parent( tq, name, attributes ) {} @@ -525,6 +526,6 @@ EnumInstType( const EnumInstType & other ) : Parent( other ), baseEnum( other.baseEnum ) {} - EnumDecl *get_baseEnum() const { return baseEnum; } - void set_baseEnum( EnumDecl *newValue ) { baseEnum = newValue; } + EnumDecl * get_baseEnum() const { return baseEnum; } + void set_baseEnum( EnumDecl * newValue ) { baseEnum = newValue; } virtual bool isComplete() const override; @@ -532,8 +533,8 @@ virtual AggregateDecl * getAggr() const override; - virtual EnumInstType *clone() const override { return new EnumInstType( *this ); } - virtual void accept( Visitor & v ) override { v.visit( this ); } - virtual void accept( Visitor & v ) const override { v.visit( this ); } - virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); } + virtual EnumInstType * clone() const override { return new EnumInstType( *this ); } + virtual void accept( Visitor & v ) override { v.visit( this ); } + virtual void accept( Visitor & v ) const override { v.visit( this ); } + virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); } virtual void print( std::ostream & os, Indenter indent = {} ) const override; @@ -556,8 +557,8 @@ virtual bool isComplete() const override; - virtual TraitInstType *clone() const override { return new TraitInstType( *this ); } - virtual void accept( Visitor & v ) override { v.visit( this ); } - virtual void accept( Visitor & v ) const override { v.visit( this ); } - virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); } + virtual TraitInstType * clone() const override { return new TraitInstType( *this ); } + virtual void accept( Visitor & v ) override { v.visit( this ); } + virtual void accept( Visitor & v ) const override { v.visit( this ); } + virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); } private: virtual std::string typeString() const override; @@ -569,14 +570,14 @@ // this decl is not "owned" by the type inst; it is merely a pointer to elsewhere in the tree, // where the type used here is actually defined - TypeDecl *baseType; + TypeDecl * baseType; bool isFtype; - TypeInstType( const Type::Qualifiers & tq, const std::string & name, TypeDecl *baseType, const std::list< Attribute * > & attributes = std::list< Attribute * >() ); + TypeInstType( const Type::Qualifiers & tq, const std::string & name, TypeDecl * baseType, const std::list< Attribute * > & attributes = std::list< Attribute * >() ); TypeInstType( const Type::Qualifiers & tq, const std::string & name, bool isFtype, const std::list< Attribute * > & attributes = std::list< Attribute * >() ); TypeInstType( const TypeInstType & other ); ~TypeInstType(); - TypeDecl *get_baseType() const { return baseType; } - void set_baseType( TypeDecl *newValue ); + TypeDecl * get_baseType() const { return baseType; } + void set_baseType( TypeDecl * newValue ); bool get_isFtype() const { return isFtype; } void set_isFtype( bool newValue ) { isFtype = newValue; } @@ -584,8 +585,8 @@ virtual bool isComplete() const override; - virtual TypeInstType *clone() const override { return new TypeInstType( *this ); } - virtual void accept( Visitor & v ) override { v.visit( this ); } - virtual void accept( Visitor & v ) const override { v.visit( this ); } - virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); } + virtual TypeInstType * clone() const override { return new TypeInstType( *this ); } + virtual void accept( Visitor & v ) override { v.visit( this ); } + virtual void accept( Visitor & v ) const override { v.visit( this ); } + virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); } virtual void print( std::ostream & os, Indenter indent = {} ) const override; private: @@ -622,8 +623,8 @@ // virtual bool isComplete() const override { return true; } // xxx - not sure if this is right, might need to recursively check complete-ness - virtual TupleType *clone() const override { return new TupleType( *this ); } - virtual void accept( Visitor & v ) override { v.visit( this ); } - virtual void accept( Visitor & v ) const override { v.visit( this ); } - virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); } + virtual TupleType * clone() const override { return new TupleType( *this ); } + virtual void accept( Visitor & v ) override { v.visit( this ); } + virtual void accept( Visitor & v ) const override { v.visit( this ); } + virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); } virtual void print( std::ostream & os, Indenter indent = {} ) const override; }; @@ -631,22 +632,22 @@ class TypeofType : public Type { public: - Expression *expr; ///< expression to take the type of - bool is_basetypeof; ///< true iff is basetypeof type - - TypeofType( const Type::Qualifiers & tq, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() ); - TypeofType( const Type::Qualifiers & tq, Expression *expr, bool is_basetypeof, + Expression * expr; ///< expression to take the type of + bool is_basetypeof; ///< true iff is basetypeof type + + TypeofType( const Type::Qualifiers & tq, Expression * expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() ); + TypeofType( const Type::Qualifiers & tq, Expression * expr, bool is_basetypeof, const std::list< Attribute * > & attributes = std::list< Attribute * >() ); TypeofType( const TypeofType& ); virtual ~TypeofType(); - Expression *get_expr() const { return expr; } - void set_expr( Expression *newValue ) { expr = newValue; } + Expression * get_expr() const { return expr; } + void set_expr( Expression * newValue ) { expr = newValue; } virtual bool isComplete() const override { assert( false ); return false; } - virtual TypeofType *clone() const override { return new TypeofType( *this ); } - virtual void accept( Visitor & v ) override { v.visit( this ); } - virtual void accept( Visitor & v ) const override { v.visit( this ); } - virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); } + virtual TypeofType * clone() const override { return new TypeofType( *this ); } + virtual void accept( Visitor & v ) override { v.visit( this ); } + virtual void accept( Visitor & v ) const override { v.visit( this ); } + virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); } virtual void print( std::ostream & os, Indenter indent = {} ) const override; }; @@ -654,18 +655,18 @@ class VTableType : public Type { public: - Type *base; - - VTableType( const Type::Qualifiers & tq, Type *base, + Type * base; + + VTableType( const Type::Qualifiers & tq, Type * base, const std::list< Attribute * > & attributes = std::list< Attribute * >() ); VTableType( const VTableType & ); virtual ~VTableType(); - Type *get_base() { return base; } - void set_base( Type *newValue ) { base = newValue; } - - virtual VTableType *clone() const override { return new VTableType( *this ); } - virtual void accept( Visitor & v ) override { v.visit( this ); } - virtual void accept( Visitor & v ) const override { v.visit( this ); } - virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); } + Type * get_base() { return base; } + void set_base( Type * newValue ) { base = newValue; } + + virtual VTableType * clone() const override { return new VTableType( *this ); } + virtual void accept( Visitor & v ) override { v.visit( this ); } + virtual void accept( Visitor & v ) const override { v.visit( this ); } + virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); } virtual void print( std::ostream & os, Indenter indent = {} ) const override; }; @@ -674,10 +675,10 @@ public: std::string name; - Expression *expr; - Type *type; + Expression * expr; + Type * type; bool isType; - AttrType( const Type::Qualifiers & tq, const std::string & name, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() ); - AttrType( const Type::Qualifiers & tq, const std::string & name, Type *type, const std::list< Attribute * > & attributes = std::list< Attribute * >() ); + AttrType( const Type::Qualifiers & tq, const std::string & name, Expression * expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() ); + AttrType( const Type::Qualifiers & tq, const std::string & name, Type * type, const std::list< Attribute * > & attributes = std::list< Attribute * >() ); AttrType( const AttrType& ); virtual ~AttrType(); @@ -685,8 +686,8 @@ const std::string & get_name() const { return name; } void set_name( const std::string & newValue ) { name = newValue; } - Expression *get_expr() const { return expr; } - void set_expr( Expression *newValue ) { expr = newValue; } - Type *get_type() const { return type; } - void set_type( Type *newValue ) { type = newValue; } + Expression * get_expr() const { return expr; } + void set_expr( Expression * newValue ) { expr = newValue; } + Type * get_type() const { return type; } + void set_type( Type * newValue ) { type = newValue; } bool get_isType() const { return isType; } void set_isType( bool newValue ) { isType = newValue; } @@ -694,8 +695,8 @@ virtual bool isComplete() const override { assert( false ); } // xxx - not sure what to do here - virtual AttrType *clone() const override { return new AttrType( *this ); } - virtual void accept( Visitor & v ) override { v.visit( this ); } - virtual void accept( Visitor & v ) const override { v.visit( this ); } - virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); } + virtual AttrType * clone() const override { return new AttrType( *this ); } + virtual void accept( Visitor & v ) override { v.visit( this ); } + virtual void accept( Visitor & v ) const override { v.visit( this ); } + virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); } virtual void print( std::ostream & os, Indenter indent = {} ) const override; }; @@ -709,8 +710,8 @@ virtual bool isComplete() const override{ return true; } // xxx - is this right? - virtual VarArgsType *clone() const override { return new VarArgsType( *this ); } - virtual void accept( Visitor & v ) override { v.visit( this ); } - virtual void accept( Visitor & v ) const override { v.visit( this ); } - virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); } + virtual VarArgsType * clone() const override { return new VarArgsType( *this ); } + virtual void accept( Visitor & v ) override { v.visit( this ); } + virtual void accept( Visitor & v ) const override { v.visit( this ); } + virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); } virtual void print( std::ostream & os, Indenter indent = {} ) const override; }; @@ -722,8 +723,8 @@ ZeroType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() ); - virtual ZeroType *clone() const override { return new ZeroType( *this ); } - virtual void accept( Visitor & v ) override { v.visit( this ); } - virtual void accept( Visitor & v ) const override { v.visit( this ); } - virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); } + virtual ZeroType * clone() const override { return new ZeroType( *this ); } + virtual void accept( Visitor & v ) override { v.visit( this ); } + virtual void accept( Visitor & v ) const override { v.visit( this ); } + virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); } virtual void print( std::ostream & os, Indenter indent = {} ) const override; }; @@ -735,8 +736,8 @@ OneType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() ); - virtual OneType *clone() const override { return new OneType( *this ); } - virtual void accept( Visitor & v ) override { v.visit( this ); } - virtual void accept( Visitor & v ) const override { v.visit( this ); } - virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); } + virtual OneType * clone() const override { return new OneType( *this ); } + virtual void accept( Visitor & v ) override { v.visit( this ); } + virtual void accept( Visitor & v ) const override { v.visit( this ); } + virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); } virtual void print( std::ostream & os, Indenter indent = {} ) const override; }; @@ -746,8 +747,8 @@ GlobalScopeType(); - virtual GlobalScopeType *clone() const override { return new GlobalScopeType( *this ); } - virtual void accept( Visitor & v ) override { v.visit( this ); } - virtual void accept( Visitor & v ) const override { v.visit( this ); } - virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); } + virtual GlobalScopeType * clone() const override { return new GlobalScopeType( *this ); } + virtual void accept( Visitor & v ) override { v.visit( this ); } + virtual void accept( Visitor & v ) const override { v.visit( this ); } + virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); } virtual void print( std::ostream & os, Indenter indent = {} ) const override; }; Index: src/Validate/HandleAttributes.cc =================================================================== --- src/Validate/HandleAttributes.cc (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ src/Validate/HandleAttributes.cc (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -17,4 +17,5 @@ #include "CompilationState.h" +#include "Common/Eval.h" #include "Common/PassVisitor.h" #include "Common/SemanticError.h" Index: src/main.cc =================================================================== --- src/main.cc (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ src/main.cc (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -10,6 +10,6 @@ // Created On : Fri May 15 23:12:02 2015 // Last Modified By : Andrew Beach -// Last Modified On : Wed Oct 5 12:06:00 2022 -// Update Count : 679 +// Last Modified On : Thr Feb 16 10:08:00 2023 +// Update Count : 680 // @@ -40,9 +40,7 @@ #include "CodeTools/TrackLoc.h" // for fillLocations #include "Common/CodeLocationTools.hpp" // for forceFillCodeLocations -#include "Common/CompilerError.h" // for CompilerError #include "Common/DeclStats.hpp" // for printDeclStats #include "Common/ResolvProtoDump.hpp" // for dumpAsResolverProto #include "Common/Stats.h" // for Stats -#include "Common/UnimplementedError.h" // for UnimplementedError #include "Common/utility.h" // for deleteAll, filter, printAll #include "Concurrency/Actors.hpp" // for implementActors @@ -274,10 +272,10 @@ FILE * gcc_builtins = fopen( (PreludeDirector + "/gcc-builtins.cf").c_str(), "r" ); assertf( gcc_builtins, "cannot open gcc-builtins.cf\n" ); - parse( gcc_builtins, LinkageSpec::Compiler ); + parse( gcc_builtins, ast::Linkage::Compiler ); // read the extra prelude in, if not generating the cfa library FILE * extras = fopen( (PreludeDirector + "/extras.cf").c_str(), "r" ); assertf( extras, "cannot open extras.cf\n" ); - parse( extras, LinkageSpec::BuiltinC ); + parse( extras, ast::Linkage::BuiltinC ); if ( ! libcfap ) { @@ -285,14 +283,14 @@ FILE * prelude = fopen( (PreludeDirector + "/prelude.cfa").c_str(), "r" ); assertf( prelude, "cannot open prelude.cfa\n" ); - parse( prelude, LinkageSpec::Intrinsic ); + parse( prelude, ast::Linkage::Intrinsic ); // Read to cfa builtins, if not generating the cfa library FILE * builtins = fopen( (PreludeDirector + "/builtins.cf").c_str(), "r" ); assertf( builtins, "cannot open builtins.cf\n" ); - parse( builtins, LinkageSpec::BuiltinCFA ); - } // if - } // if - - parse( input, libcfap ? LinkageSpec::Intrinsic : LinkageSpec::Cforall, yydebug ); + parse( builtins, ast::Linkage::BuiltinCFA ); + } // if + } // if + + parse( input, libcfap ? ast::Linkage::Intrinsic : ast::Linkage::Cforall, yydebug ); transUnit = buildUnit(); @@ -342,6 +340,5 @@ PASS( "Generate Autogen Routines", Validate::autogenerateRoutines( transUnit ) ); - PASS( "Implement Actors", Concurrency::implementActors( transUnit ) ); - + PASS( "Implement Actors", Concurrency::implementActors( transUnit ) ); PASS( "Implement Mutex", Concurrency::implementMutex( transUnit ) ); PASS( "Implement Thread Start", Concurrency::implementThreadStarter( transUnit ) ); @@ -476,17 +473,4 @@ } // if e.print(); - if ( output != &cout ) { - delete output; - } // if - return EXIT_FAILURE; - } catch ( UnimplementedError & e ) { - cout << "Sorry, " << e.get_what() << " is not currently implemented" << endl; - if ( output != &cout ) { - delete output; - } // if - return EXIT_FAILURE; - } catch ( CompilerError & e ) { - cerr << "Compiler Error: " << e.get_what() << endl; - cerr << "(please report bugs to [REDACTED])" << endl; if ( output != &cout ) { delete output; Index: tests/include/includes.cfa =================================================================== --- tests/include/includes.cfa (revision 1180175fe87444afc7d78dd0e227aa5351b0b058) +++ tests/include/includes.cfa (revision 640b3dfd1727995c187f28aa3bdbaab51fc5e93b) @@ -10,6 +10,6 @@ // Created On : Wed May 27 17:56:53 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Sun May 22 08:27:20 2022 -// Update Count : 779 +// Last Modified On : Mon Feb 20 21:51:04 2023 +// Update Count : 780 // @@ -72,5 +72,5 @@ #include #include -#include +//#include // causes warning messages that break the build #include #include