Index: doc/LaTeXmacros/common.sty =================================================================== --- doc/LaTeXmacros/common.sty (revision c75b30ae4d3f97678f27275a033614f675b7fdaf) +++ doc/LaTeXmacros/common.sty (revision 32490deb2180d977e78b79e5c2342a8fa2357a53) @@ -11,6 +11,6 @@ %% Created On : Sat Apr 9 10:06:17 2016 %% Last Modified By : Peter A. Buhr -%% Last Modified On : Sun Jan 14 12:28:26 2024 -%% Update Count : 631 +%% Last Modified On : Sun Jan 21 13:17:48 2024 +%% Update Count : 633 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% @@ -270,5 +270,5 @@ \newlength{\gcolumnposn} % temporary hack because lstlisting does not handle tabs correctly \newlength{\columnposn} -\setlength{\gcolumnposn}{2.75in} +\setlength{\gcolumnposn}{3in} \setlength{\columnposn}{\gcolumnposn} \newcommand{\setgcolumn}[1]{\global\gcolumnposn=#1\global\columnposn=\gcolumnposn} Index: doc/LaTeXmacros/common.tex =================================================================== --- doc/LaTeXmacros/common.tex (revision c75b30ae4d3f97678f27275a033614f675b7fdaf) +++ doc/LaTeXmacros/common.tex (revision 32490deb2180d977e78b79e5c2342a8fa2357a53) @@ -11,6 +11,6 @@ %% Created On : Sat Apr 9 10:06:17 2016 %% Last Modified By : Peter A. Buhr -%% Last Modified On : Sun Jan 14 17:59:02 2024 -%% Update Count : 592 +%% Last Modified On : Wed Jan 24 08:43:57 2024 +%% Update Count : 593 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% @@ -273,5 +273,5 @@ \newlength{\gcolumnposn} % temporary hack because lstlisting does not handle tabs correctly \newlength{\columnposn} -\setlength{\gcolumnposn}{2.75in} +\setlength{\gcolumnposn}{3in} \setlength{\columnposn}{\gcolumnposn} \newcommand{\setgcolumn}[1]{\global\gcolumnposn=#1\global\columnposn=\gcolumnposn} Index: doc/bibliography/pl.bib =================================================================== --- doc/bibliography/pl.bib (revision c75b30ae4d3f97678f27275a033614f675b7fdaf) +++ doc/bibliography/pl.bib (revision 32490deb2180d977e78b79e5c2342a8fa2357a53) @@ -219,5 +219,5 @@ title = {Actor Benchmarks}, author = {Peter A. Buhr and Colby A. Parsons}, - howpublished= {\href{https://github.com/pabuhr/ActorExperiments}{https://\-github.com/\-pabuhr/\-ActorExperiments}}, + howpublished= {\url{https://github.com/pabuhr/ActorExperiments}}, year = 2022, } @@ -296,5 +296,5 @@ contributer = {pabuhr@plg}, author = {Ada16}, - title = {Ada Reference Manual ISO/IEC 8652:2012(E) with COR.1:2016}, + title = {Ada Reference Manual ISO/IEC 8652:2012(E) with COR.1:2016}, edition = {3rd with Technical Corrigendum 1 for Ada 2012}, organization= {AXE Consultants}, @@ -416,5 +416,5 @@ address = {Waterloo, Ontario, Canada, N2L 3G1}, optnote = {\textsf{http://uwspace.uwaterloo.ca/\-bitstream/10012/\-5751\-/1/Krischer\_Roy.pdf}}, - note = {\href{http://uwspace.uwaterloo.ca/bitstream/10012/5751/1/Krischer_Roy.pdf}{http://uwspace.uwaterloo.ca/\-bitstream/10012/\-5751\-/1/Krischer\_Roy.pdf}}, + note = {\url{http://uwspace.uwaterloo.ca/bitstream/10012/5751/1/Krischer_Roy.pdf}}, } @@ -430,5 +430,5 @@ number = 5, pages = {1005-1042}, - optnote = {\href{https://onlinelibrary.wiley.com/doi/10.1002/spe.2925}{https://\-onlinelibrary.wiley.com/\-doi/\-10.1002/\-spe.2925}}, + optnote = {\url{https://onlinelibrary.wiley.com/doi/10.1002/spe.2925}}, } @@ -761,5 +761,5 @@ pages = {145-160}, publisher = {{USENIX} Association}, - note = {\href{https://www.usenix.org/conference/osdi18/presentation/qin}{https://\-www.usenix.org/\-conference/\-osdi18/\-presentation/\-qin}}, + note = {\url{https://www.usenix.org/conference/osdi18/presentation/qin}}, } @@ -839,5 +839,5 @@ title = {Async Await}, author = {{WikipediA}}, - howpublished= {\href{https://en.wikipedia.org/wiki/Async/await}{https://\-en.wikipedia.org/\-wiki/\-Async/\-await}}, + howpublished= {\url{https://en.wikipedia.org/wiki/Async/await}}, year = 2022, } @@ -928,5 +928,5 @@ 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}, + note = {\url{http://www.cs.cmu.edu/~acw/15740/paper.pdf}}, year = 2009, } @@ -1034,6 +1034,5 @@ title = {Boost Coroutine Library}, year = 2015, - howpublished= {\href{http://www.boost.org/doc/libs/1_61_0/libs/coroutine/doc/html/index.html} - {http://www.boost.org/\-doc/\-libs/1\_61\_0/\-libs/\-coroutine/\-doc/\-html/\-index.html}}, + howpublished= {\url{http://www.boost.org/doc/libs/1_61_0/libs/coroutine/doc/html/index.html}}, } @@ -1044,6 +1043,5 @@ title = {Boost Thread Library}, year = 2015, - howpublished= {\href{https://www.boost.org/doc/libs/1_61_0/doc/html/thread.html} - {https://\-www.boost.org/\-doc/\-libs/\-1\_61\_0/\-doc/\-html/\-thread.html}}, + howpublished= {\url{https://www.boost.org/doc/libs/1_61_0/doc/html/thread.html}}, } @@ -1056,5 +1054,5 @@ month = oct, type = {Diplomarbeit}, - note = {\href{https://plg.uwaterloo.ca/~usystem/theses/KrischerThesis.pdf}{https://\-plg.uwaterloo.ca/\-$\sim$usystem/\-theses/\-KrischerThesis.pdf}}, + note = {\url{https://plg.uwaterloo.ca/~usystem/theses/KrischerThesis.pdf}}, } @@ -1148,5 +1146,5 @@ address = {Geneva, Switzerland}, year = 1999, - note = {\href{https://webstore.ansi.org/Standards/INCITS/INCITSISOIEC98991999R2005}{https://webstore.ansi.org/\-Standards/\-INCITS/\-INCITSISOIEC98991999R2005}}, + note = {\url{https://webstore.ansi.org/Standards/INCITS/INCITSISOIEC98991999R2005}}, } @@ -1160,5 +1158,5 @@ address = {Geneva, Switzerland}, year = 2012, - note = {\href{https://www.iso.org/standard/57853.html}{https://\-www.iso.org/\-standard/\-57853.html}}, + note = {\url{https://www.iso.org/standard/57853.html}}, } @@ -1171,5 +1169,5 @@ address = {Geneva, Switzerland}, year = 2015, - note = {\href{https://www.iso.org/standard/64031.html}{https://\-www.iso.org/\-standard/\-64031.html}}, + note = {\url{https://www.iso.org/standard/64031.html}}, } @@ -1198,5 +1196,5 @@ month = aug, year = {2020}, - note = {\href{https://cforall.uwaterloo.ca/doc/Fangren_Yu_Report_S20.pdf}{https://\-cforall.uwaterloo.ca/\-doc/\-Fangren\_Yu\_Report\_S20.pdf}}, + note = {\url{https://cforall.uwaterloo.ca/doc/Fangren_Yu_Report_S20.pdf}}, } @@ -1212,5 +1210,5 @@ year = 2018, pages = {2111-2146}, - optnote = {\href{http://dx.doi.org/10.1002/spe.2624}{http://\-dx.doi.org/\-10.1002/\-spe.2624}}, + optnote = {\url{http://dx.doi.org/10.1002/spe.2624}}, } @@ -1219,5 +1217,5 @@ key = {Cforall Benchmarks}, author = {{\textsf{C}{$\mathbf{\forall}$} Benchmarks}}, - howpublished= {\href{https://github.com/cforall/ConcurrentBenchmarks_SPE20}{https://\-github.com/\-cforall/\-ConcurrentBenchmarks\_SPE20}}, + howpublished= {\url{https://github.com/cforall/ConcurrentBenchmarks_SPE20}}, } @@ -1226,5 +1224,5 @@ key = {Cforall}, author = {{\textsf{C}{$\mathbf{\forall}$} Features}}, - howpublished= {\href{https://plg.uwaterloo.ca/~cforall/features}{https://\-plg.uwaterloo.ca/\-$\sim$cforall/\-features}}, + howpublished= {\url{https://plg.uwaterloo.ca/~cforall/features}}, } @@ -1245,5 +1243,5 @@ title = {\textsf{C}$\mathbf{\forall}$ Stack Evaluation Programs}, year = 2018, - howpublished= {\href{https://cforall.uwaterloo.ca/CFAStackEvaluation.zip}{https://cforall.uwaterloo.ca/\-CFAStackEvaluation.zip}}, + howpublished= {\url{https://cforall.uwaterloo.ca/CFAStackEvaluation.zip}}, } @@ -1256,5 +1254,5 @@ year = 2004, address = {Waterloo, Ontario, Canada, N2L 3G1}, - note = {\href{http://plg.uwaterloo.ca/theses/EstevesThesis.pdf}{http://\-plg.uwaterloo.ca/\-theses/\-EstevesThesis.pdf}}, + note = {\url{http://plg.uwaterloo.ca/theses/EstevesThesis.pdf}}, } @@ -1266,5 +1264,5 @@ year = 2019, optaddress = {Waterloo, Ontario, Canada, N2L 3G1}, - note = {\href{https://uwspace.uwaterloo.ca/handle/10012/14584}{https://\-uwspace.uwaterloo.ca/\-handle/\-10012/\-14584}}, + note = {\url{https://uwspace.uwaterloo.ca/handle/10012/14584}}, } @@ -1423,5 +1421,5 @@ month = oct, year = 2001, - note = {\href{http://plg.uwaterloo.ca/~cforall/cfa.ps}{http://\-plg.uwaterloo.ca/\-$\sim$cforall/\-cfa.ps}}, + note = {\url{http://plg.uwaterloo.ca/~cforall/cfa.ps}}, } @@ -1461,5 +1459,5 @@ contributer = {a3moss@uwaterloo.ca}, title = {Clang: a {C} language family frontend for {LLVM}}, - howpublished= {\href{https://clang.llvm.org/}{https://\-clang.llvm.org/}} + howpublished= {\url{https://clang.llvm.org/}} } @@ -1527,5 +1525,5 @@ address = {Geneva, Switzerland}, year = 2014, - note = {\href{https://www.iso.org/standard/51416.html}{https://\-www.iso.org/\-standard/\-51416.html}}, + note = {\url{https://www.iso.org/standard/51416.html}}, } @@ -1668,5 +1666,5 @@ publisher = {Prentice-Hall}, address = {Upper Saddle River, NJ, USA}, - note = {\href{http://www.usingcsp.com/cspbook.pdf}{http://\-www.usingcsp.com/\-cspbook.pdf}}, + note = {\url{http://www.usingcsp.com/cspbook.pdf}}, } @@ -1733,5 +1731,5 @@ month = sep, address = {Waterloo, Ontario, Canada, N2L 3G1}, - note = {\href{http://plg.uwaterloo.ca/theses/MokThesis.pdf}{http://\-plg.uwaterloo.ca/\-theses/\-MokThesis.pdf}}, + note = {\url{http://plg.uwaterloo.ca/theses/MokThesis.pdf}}, } @@ -1808,5 +1806,5 @@ author = {Peter A. Buhr and David Dice and Wim H. Hesselink}, title = {concurrent-locking}, - howpublished= {\href{https://github.com/pabuhr/concurrent-locking}{https://\-github.com/\-pabuhr/\-concurrent-locking}}, + howpublished= {\url{https://github.com/pabuhr/concurrent-locking}}, } @@ -1958,5 +1956,5 @@ year = 2015, optaddress = {Waterloo, Ontario, Canada, N2L 3G1}, - note = {\href{https://uwspace.uwaterloo.ca/handle/10012/10013}{https://\-uwspace.uwaterloo.ca/\-handle/\-10012/\-10013}}, + note = {\url{https://uwspace.uwaterloo.ca/handle/10012/10013}}, } @@ -2098,6 +2096,5 @@ month = oct, year = 2010, - howpublished= {\href{https://www.airs.com/blog/archives/428} - {https://www.airs.com/\-blog/\-archives/\-428}}, + howpublished= {\url{https://www.airs.com/blog/archives/428}}, } @@ -2110,5 +2107,5 @@ year = 1992, address = {Waterloo, Ontario, Canada, N2L 3G1}, - note = {\href{http://plg.uwaterloo.ca/theses/DitchfieldThesis.pdf}{http://\-plg.uwaterloo.ca/\-theses/\-DitchfieldThesis.pdf}} + note = {\url{http://plg.uwaterloo.ca/theses/DitchfieldThesis.pdf}} } @@ -2180,5 +2177,5 @@ author = {Glen Ditchfield}, title = {Conversions for \textsf{C}$\mathbf{\forall}$}, - note = {\href{http://plg.uwaterloo.ca/~cforall/Conversions/index.html}{http://\-plg.uwaterloo.ca/\-$\sim$cforall/\-Conversions/\-index.html}}, + note = {\url{http://plg.uwaterloo.ca/~cforall/Conversions/index.html}}, month = {Nov}, year = {2002}, @@ -2217,6 +2214,5 @@ year = 2019, month = feb, - howpublished= {\href{http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p0912r5.html} - {http://\-www.open-std.org/\-jtc1/\-sc22/\-wg21/\-docs/\-papers/\-2019/p0912r5.html}}, + howpublished= {\url{http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p0912r5.html}}, } @@ -2229,5 +2225,5 @@ month = jun, year = 2022, - note = {\href{https://en.cppreference.com/w/cpp/language/coroutines}{https://\-en.cppreference.com/\-w/\-cpp/\-language/\-coroutines}}, + note = {\url{https://en.cppreference.com/w/cpp/language/coroutines}}, } @@ -2283,5 +2279,5 @@ title = {CS343}, year = 2018, - howpublished= {\href{https://www.student.cs.uwaterloo.ca/~cs343}{https://\-www.student.cs.uwaterloo.ca/\-$\sim$cs343}}, + howpublished= {\url{https://www.student.cs.uwaterloo.ca/~cs343}}, } @@ -2309,5 +2305,5 @@ address = {Vienna Virginia, U.S.A.}, year = 2016, - note = {\href{http://dlang.org/spec/spec.html}{http://\-dlang.org/\-spec/\-spec.html}}, + note = {\url{http://dlang.org/spec/spec.html}}, } @@ -2786,5 +2782,5 @@ author = {Martin Odersky}, title = {Dotty}, - howpublished= {\href{https://github.com/lampepfl/dotty}{https://\-github.com/\-lampepfl/\-dotty}}, + howpublished= {\url{https://github.com/lampepfl/dotty}}, note = {Acessed: 2019-02-22} } @@ -2797,5 +2793,5 @@ month = nov, year = 1983, - note = {\href{http://www.lysator.liu.se/c/duffs-device.html}{http://\-www.lysator.liu.se/\-c/\-duffs-device.html}} + note = {\url{http://www.lysator.liu.se/c/duffs-device.html}} } @@ -3033,6 +3029,5 @@ month = aug, note = {WikipediA}, - howpublished= {\href{http://www.akkadia.org/drepper/tls.pdf} - {http://\-www.akkadia.org/\-drepper/\-tls.pdf}}, + howpublished= {\url{http://www.akkadia.org/drepper/tls.pdf}}, } @@ -3045,6 +3040,5 @@ month = may, note = {Electronic Engineering Times}, - howpublished= {\href{https://www.eetimes.com/author.asp?sectionid=36&doc_id=1287712} - {https://\-www.eetimes.com/\-author.asp?sectionid=\-36&doc_id=1287712}}, + howpublished= {\url{https://www.eetimes.com/author.asp?sectionid=36&doc_id=1287712}}, } @@ -3159,5 +3153,5 @@ month = sep, year = 2016, - note = {\href{http://erlang.org/doc/pdf/otp-system-documentation.pdf}{http://\-erlang.org/\-doc/\-pdf/\-otp-system-documentation.pdf}}, + note = {\url{http://erlang.org/doc/pdf/otp-system-documentation.pdf}}, } @@ -3482,5 +3476,5 @@ title = {Extensions to the {C} Language Family}, year = 2014, - howpublished= {\href{https://gcc.gnu.org/onlinedocs/gcc-4.7.2/gcc/C-Extensions.html}{https://\-gcc.gnu.org/\-onlinedocs/\-gcc-4.7.2/\-gcc/\-C\-Extensions.html}}, + howpublished= {\url{https://gcc.gnu.org/onlinedocs/gcc-4.7.2/gcc/C-Extensions.html}}, } @@ -3565,5 +3559,5 @@ month = feb, publisher = {John Wiley \& Sons}, - note = {\href{https://doi.org/10.1002/cpe.4183}{https://\-doi.org/\-10.1002/\-cpe.4183}} + note = {\url{https://doi.org/10.1002/cpe.4183}} } @@ -3587,5 +3581,5 @@ title = {Fibers}, organization= {Microsoft, Windows Development Center}, - address = {\href{https://docs.microsoft.com/en-us/windows/desktop/ProcThread/fibers}{https://\-docs.microsoft.com/\-en-us/\-windows/\-desktop/\-ProcThread/\-fibers}}, + address = {\url{https://docs.microsoft.com/en-us/windows/desktop/ProcThread/fibers}}, year = 2018, } @@ -3609,5 +3603,5 @@ month = jan, address = {Waterloo, Ontario, Canada, N2L 3G1}, - note = {\href{http://uwspace.uwaterloo.ca/bitstream/10012/3501/1/Thesis.pdf}{http://\-uwspace.uwaterloo.ca/\-bitstream/\-10012/\-3501/\-1/\-Thesis.pdf}}, + note = {\url{http://uwspace.uwaterloo.ca/bitstream/10012/3501/1/Thesis.pdf}}, } @@ -3644,5 +3638,5 @@ title = {Facebook Open-source Library}, organization= {Facebook}, - address = {\href{https://github.com/facebook/folly}{https://\-github.com/\-facebook/\-folly}}, + address = {\url{https://github.com/facebook/folly}}, year = 2018, } @@ -3685,5 +3679,5 @@ address = {Geneva, Switzerland}, year = 2010, - note = {\href{https://www.iso.org/standard/50459.html}{https://\-www.iso.org/\-standard/\-50459.html}}, + note = {\url{https://www.iso.org/standard/50459.html}}, } @@ -3697,5 +3691,5 @@ address = {Geneva, Switzerland}, year = 2018, - note = {\href{https://www.iso.org/standard/72320.html}{https://\-www.iso.org/\-standard/\-72320.html}}, + note = {\url{https://www.iso.org/standard/72320.html}}, } @@ -3928,5 +3922,5 @@ address = {GNU}, year = 2016, - note = {\href{https://gmplib.org}{https://\-gmplib.org}}, + note = {\url{https://gmplib.org}}, } @@ -3939,5 +3933,5 @@ organization= {Google}, year = 2009, - note = {\href{http://golang.org/ref/spec}{http://\-golang.org/\-ref/\-spec}}, + note = {\url{http://golang.org/ref/spec}}, } @@ -4043,5 +4037,5 @@ edition = {{S}imon {M}arlow}, year = 2010, - note = {\href{https://haskell.org/definition/haskell2010.pdf}{https://\-haskell.org/\-definition/\-haskell2010.pdf}}, + note = {\url{https://haskell.org/definition/haskell2010.pdf}}, } @@ -4118,5 +4112,5 @@ number = 12, pages = {2463-2500}, - note = {\url{https://onlinelibrary.wiley.com/doi/10.1002/spe.3262}, + note = {\url{https://onlinelibrary.wiley.com/doi/10.1002/spe.3262}}, } @@ -4127,5 +4121,5 @@ year = 2019, optaddress = {Waterloo, Ontario, Canada, N2L 3G1}, - note = {\href{https://uwspace.uwaterloo.ca/handle/10012/14706}{https://\-uwspace.uwaterloo.ca/\-handle/\-10012/\-14706}}, + note = {\url{https://uwspace.uwaterloo.ca/handle/10012/14706}}, } @@ -4186,5 +4180,5 @@ month = sep, publisher = {John Wiley \& Sons}, - note = {\href{https://doi.org/10.1002/cpe.4475}{https://\-doi.org/\-10.1002/\-cpe.4475}}, + note = {\url{https://doi.org/10.1002/cpe.4475}}, } @@ -4320,5 +4314,5 @@ year = 2003, optaddress = {Waterloo, Ontario, Canada, N2L 3G1}, - note = {\href{http://plg.uwaterloo.ca/theses/BilsonThesis.pdf}{http://\-plg.uwaterloo.ca/\-theses/\-BilsonThesis.pdf}}, + note = {\url{http://plg.uwaterloo.ca/theses/BilsonThesis.pdf}}, } @@ -4733,5 +4727,5 @@ title = {JDK 1.1 for Solaris Developer's Guide}, publisher = {Oracle}, - address = {\href{https://docs.oracle.com/cd/E19455-01/806-3461/6jck06gqk/index.html#ch2mt-41}{https://\-docs.oracle.com/\-cd/\-E19455-01/\-806-3461/\-6jck06gqk/\-index.html\#ch2mt-41}}, + address = {\url{https://docs.oracle.com/cd/E19455-01/806-3461/6jck06gqk/index.html#ch2mt-41}}, year = 2010, } @@ -4744,5 +4738,5 @@ organization= {Oracle}, year = 2014, - note = {\href{http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/package-summary.html}{http://docs.oracle.com/\-javase/7/\-docs/\-api/\-java/\-util/\-concurrent/\-package-summary.html}}, + note = {\url{http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/package-summary.html}}, } @@ -4873,6 +4867,5 @@ title = {Labels as Values}, year = {since gcc-3}, - howpublished= {\href{https://gcc.gnu.org/onlinedocs/gcc/Labels-as-Values.html} - {https:\-//gcc.gnu.org/\-onlinedocs/\-gcc/\-Labels-as-Values.html}}, + howpublished= {\url{https://gcc.gnu.org/onlinedocs/gcc/Labels-as-Values.html}}, } @@ -4931,6 +4924,5 @@ title = {libdill Thread Library}, year = 2019, - howpublished= {\href{http://libdill.org/libdill-2.14.tar.gz} - {http://\-libdill.org/\-libdill-2.14.tar.gz}}, + howpublished= {\url{http://libdill.org/libdill-2.14.tar.gz}}, } @@ -4939,5 +4931,5 @@ author = {Martin Karsten}, title = {{libfibre:~User-Level Threading Runtime}}, - howpublished= {\href{https://git.uwaterloo.ca/mkarsten/libfibre}{https://\-git.uwaterloo.ca/\-mkarsten/\-libfibre}}, + howpublished= {\url{https://git.uwaterloo.ca/mkarsten/libfibre}}, note = {[Online; accessed 2020-04-15]}, } @@ -4962,5 +4954,5 @@ title = {{G}o-style concurrency in {C}, Version 1.18}, organization= {libmill}, - address = {\href{http://libmill.org/documentation.html}{http://\-libmill.org/\-documentation.html}}, + address = {\url{http://libmill.org/documentation.html}}, month = jan, year = 2017, @@ -5038,6 +5030,5 @@ month = jan, year = 2017, - howpublished= {\href{http://smallcultfollowing.com/babysteps/blog/2017/01/26/lowering-rust-traits-to-logic/} - {http://smallcultfollowing.com/\-babysteps/\-blog/\-2017/\-01/\-26/\-lowering-rust-traits-to-logic/}}, + howpublished= {\url{http://smallcultfollowing.com/babysteps/blog/2017/01/26/lowering-rust-traits-to-logic/}}, optnote = {Accessed: 2019-01}, } @@ -5063,5 +5054,5 @@ 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}}, + address = {\url{https://www.lua.org/manual/5.4}}, year = 2020, } @@ -5084,6 +5075,5 @@ title = {Making arbitrarily-large binaries from fixed-size {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} code}, year = 2016, - howpublished= {\href{http://blog.reverberate.org/2016/01/making-arbitrarily-large-binaries-from.html} - {http://blog.reverberate.org/\-2016/\-01/\-making-arbitrarily-large-binaries-from.html}}, + howpublished= {\url{http://blog.reverberate.org/2016/01/making-arbitrarily-large-binaries-from.html}}, optnote = {Accessed: 2016-09}, } @@ -5118,6 +5108,5 @@ title = {Marcel Thread Library}, year = 2011, - howpublished= {\href{https://gforge.inria.fr/frs/download.php/file/28643/marcel-2.99.3.tar.gz} - {https://\-gforge.inria.fr/\-frs/\-download.php/\-file/\-28643/\-marcel-2.99.3.tar.gz}}, + howpublished= {\url{https://gforge.inria.fr/frs/download.php/file/28643/marcel-2.99.3.tar.gz}}, } @@ -5264,5 +5253,5 @@ month = sep, year = 1994, - note = {\href{https://plg.uwaterloo.ca/~usystem/pub/uSystem/uSystem.pdf}{https://\-plg.uwaterloo.ca/\-$\sim$usystem/\-pub/\-uSystem/\-uSystem.pdf}}, + note = {\url{https://plg.uwaterloo.ca/~usystem/pub/uSystem/uSystem.pdf}}, } @@ -5463,5 +5452,5 @@ month = jun, year = 2015, - note = {\href{http://www.mpi-forum.org/docs/mpi-3.1/mpi31-report.pdf}{http://www.mpi-forum.org/\-docs/\-mpi-3.1/\-mpi31-report.pdf}}, + note = {\url{http://www.mpi-forum.org/docs/mpi-3.1/mpi31-report.pdf}}, } @@ -5613,5 +5602,5 @@ year = 1980, pages = {833-842}, - note = {\href{http://groups.csail.mit.edu/tds/papers/Lynch/allertonconf.pdf}{http://\-groups.csail.mit.edu/\-tds/\-papers/\-Lynch/\-allertonconf.pdf} [Accessed on March 2014]}, + note = {\url{http://groups.csail.mit.edu/tds/papers/Lynch/allertonconf.pdf}}, optnote = {\textsf{http://\-groups.csail.mit.edu/\-tds/\-papers/\-Lynch/\-allertonconf.pdf}}, } @@ -5639,5 +5628,5 @@ institution = {Red Hat}, year = 2003, - note = {\href{http://www.cs.utexas.edu/~witchel/372/lectures/POSIX_Linux_Threading.pdf}{http://www.cs.utexas.edu/\-$\sim$witchel/\-372/\-lectures/\-POSIX\_Linux\_Threading.pdf}}, + note = {\url{http://www.cs.utexas.edu/~witchel/372/lectures/POSIX_Linux_Threading.pdf}}, } @@ -5649,5 +5638,5 @@ organization= {{gcc} 9.3 Manual}, year = 2019, - note = {\href{https://gcc.gnu.org/onlinedocs/gcc-9.3.0/gcc/Nested-Functions.html}{https://\-gcc.gnu.org/\-onlinedocs/\-gcc-9.3.0/\-gcc/\-Nested-Functions.html}}, + note = {\url{https://gcc.gnu.org/onlinedocs/gcc-9.3.0/gcc/Nested-Functions.html}}, } @@ -5718,5 +5707,5 @@ year = 1990, pages = {41-51}, - note = {\href{http://doc.cat-v.org/bell_labs/new_c_compilers/new_c_compiler.pdf}{http://\-doc.cat-v.org/\-bell\_labs/\-new\_c\_compilers/\-new\_c\_compiler.pdf}}, + note = {\url{http://doc.cat-v.org/bell_labs/new_c_compilers/new_c_compiler.pdf}}, } @@ -5781,5 +5770,5 @@ key = {nginx}, author = {{NGINX}}, - howpublished= {\href{https://www.nginx.com}{https://\-www.nginx.com}}, + howpublished= {\url{https://www.nginx.com}}, } @@ -5910,5 +5899,5 @@ publisher = {Apple Inc.}, year = 2014, - howpublished= {\href{https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/ProgrammingWithObjectiveC}{https://\-developer.apple.com/\-library/archive/\-documentation/\-Cocoa/\-Conceptual/\-ProgrammingWithObjectiveC}}, + howpublished= {\url{https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/ProgrammingWithObjectiveC}}, } @@ -5919,5 +5908,5 @@ title = {{X}code 7 Release Notes}, year = 2015, - howpublished= {\href{https://developer.apple.com/library/content/documentation/Xcode/Conceptual/RN-Xcode-Archive/Chapters/xc7_release_notes.html}{https://\-developer.apple.com/\-library/\-content/\-documentation/\-Xcode/\-Conceptual/\-RN-Xcode-Archive/\-Chapters/\-xc7\_release\_notes.html}}, + howpublished= {\url{https://developer.apple.com/library/content/documentation/Xcode/Conceptual/RN-Xcode-Archive/Chapters/xc7_release_notes.html}}, } @@ -6052,5 +6041,5 @@ month = nov, year = 2015, - note = {\href{https://www.openmp.org/wp-content/uploads/openmp-4.5.pdf}{https://\-www.openmp.org/\-wp-content/\-uploads/\-openmp-4.5.pdf}}, + note = {\url{https://www.openmp.org/wp-content/uploads/openmp-4.5.pdf}}, } @@ -6060,5 +6049,5 @@ title = {OpenTelemetry}, author = {{Asynkron AB}}, - howpublished= {\href{https://proto.actor/docs/tracing}{https://\-proto.actor/\-docs/\-tracing}}, + howpublished= {\url{https://proto.actor/docs/tracing}}, year = 2022, } @@ -6461,5 +6450,5 @@ key = {perf}, author = {perf}, - howpublished= {\href{https://perf.wiki.kernel.org/index.php/Tutorial}{https://\-perf.wiki.kernel.org/\-index.php/\-Tutorial}}, + howpublished= {\url{https://perf.wiki.kernel.org/index.php/Tutorial}}, } @@ -6470,5 +6459,5 @@ month = may, year = 2012, - howpublished= {\href{http://cs.brown.edu/research/pubs/theses/masters/2012/verch.pdf}{http://cs.brown.edu/\-research/\-pubs/\-theses/\-masters/\-2012/\-verch.pdf}}, + howpublished= {\url{http://cs.brown.edu/research/pubs/theses/masters/2012/verch.pdf}}, } @@ -6869,5 +6858,5 @@ address = {Geneva, Switzerland}, year = 1998, - note = {\href{https://www.iso.org/standard/25845.html}{https://\-www.iso.org/\-standard/\-25845.html}}, + note = {\url{https://www.iso.org/standard/25845.html}}, } @@ -6881,5 +6870,5 @@ address = {Geneva, Switzerland}, year = 2014, - note = {\href{https://www.iso.org/standard/64029.html}{https://\-www.iso.org/\-standard/\-64029.html}}, + note = {\url{https://www.iso.org/standard/64029.html}}, } @@ -6893,5 +6882,5 @@ address = {Geneva, Switzerland}, year = 2017, - note = {\href{https://www.iso.org/standard/68564.html}{https://\-www.iso.org/\-standard/\-68564.html}}, + note = {\url{https://www.iso.org/standard/68564.html}}, } @@ -7173,6 +7162,5 @@ author = {IEEE and {The Open Group}}, year = 2018, - howpublished= {\href{http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/pthread.h.html} - {http://\-pubs.opengroup.org/\-onlinepubs/\-9699919799/\-basedefs/\-pthread.h.html}}, + howpublished= {\url{http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/pthread.h.html}}, } @@ -7183,5 +7171,5 @@ title = {Python Language Reference, Release 3.7.2}, organization= {Python Software Foundation}, - address = {\href{https://docs.python.org/3/reference/index.html}{https://\-docs.python.org/\-3/\-reference/\-index.html}}, + address = {\url{https://docs.python.org/3/reference/index.html}}, year = 2018, } @@ -7238,5 +7226,5 @@ title = {Quasar Documentation, Release 0.8.0}, organization= {Parallel Universe}, - address = {\href{http://docs.paralleluniverse.co/quasar}{http://\-docs.paralleluniverse.co/\-quasar}}, + address = {\url{http://docs.paralleluniverse.co/quasar}}, year = 2018, } @@ -7378,5 +7366,5 @@ month = apr, type = {Diplomarbeit}, - note = {\href{https://plg.uwaterloo.ca/~usystem/theses/SchusterThesis.pdf}{https://\-plg.uwaterloo.ca/\-$\sim$usystem/\-theses/\-SchusterThesis.pdf}}, + note = {\url{https://plg.uwaterloo.ca/~usystem/theses/SchusterThesis.pdf}}, } @@ -7413,5 +7401,5 @@ year = 2017, optaddress = {Waterloo, Ontario, Canada, N2L 3G1}, - note = {\href{https://uwspace.uwaterloo.ca/handle/10012/11830}{https://\-uwspace.uwaterloo.ca/\-handle/\-10012/\-11830}}, + note = {\url{https://uwspace.uwaterloo.ca/handle/10012/11830}}, } @@ -7491,5 +7479,5 @@ month = apr, year = 2022, - howpublished= {\href{https://github.com/mjansson/rpmalloc}{https://\-github.com/\-mjansson/\-rpmalloc}}, + howpublished= {\url{https://github.com/mjansson/rpmalloc}}, } @@ -7501,5 +7489,5 @@ optaddress = {Rust Project Developers}, year = 2015, - note = {\href{https://doc.rust-lang.org/reference.html}{https://\-doc.rust-lang\-.org/\-reference.html}}, + note = {\url{https://doc.rust-lang.org/reference.html}}, } @@ -7510,5 +7498,5 @@ title = {Ruby Documentation, Release 2.6.0}, organization= {Python Software Foundation}, - address = {\href{https://www.ruby-lang.org/en/documentation}{https://\-www.ruby-lang.org/\-en/\-documentation}}, + address = {\url{https://www.ruby-lang.org/en/documentation}}, year = 2018, } @@ -7538,5 +7526,5 @@ address = {\'{E}cole Polytechnique F\'{e}d\'{e}rale de Lausanne}, year = 2016, - note = {\href{http://www.scala-lang.org/files/archive/spec/2.11}{http://\-www.scala-lang.org/\-files/\-archive/\-spec/\-2.11}}, + note = {\url{http://www.scala-lang.org/files/archive/spec/2.11}}, } @@ -7699,5 +7687,5 @@ month = sep, year = 1995, - note = {\href{http://www.hpl.hp.com/techreports/Compaq-DEC/WRL-95-7.pdf}{http://www.hpl.hp.com/\-techreports/\-Compaq-DEC/\-WRL-95-7.pdf}, Reprinted in \cite{Adve95reprint}.}, + note = {\url{http://www.hpl.hp.com/techreports/Compaq-DEC/WRL-95-7.pdf}}, } @@ -7773,5 +7761,5 @@ month = may, year = 2001, - note = {\href{http://www.python.org/peps/pep-0255.html}{http://\-www.python.org/\-peps/\-pep-0255.html}}, + note = {\url{http://www.python.org/peps/pep-0255.html}}, } @@ -8076,5 +8064,5 @@ organization= {IEEE and The Open Group}, year = 2017, - note = {\href{https://pubs.opengroup.org/onlinepubs/9699919799}{https://\-pubs.opengroup.org/\-onlinepubs/\-9699919799}}, + note = {\url{https://pubs.opengroup.org/onlinepubs/9699919799}}, } @@ -8143,5 +8131,5 @@ pages = {1-6}, numpages = {6}, - howpublished= {\href{http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0144r0.pdf}{http://\-www.open-std.org/\-jtc1/\-sc22/\-wg21/\-docs/\-papers/\-2015/\-p0144r0.pdf}}, + howpublished= {\url{http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0144r0.pdf}}, } @@ -8453,5 +8441,5 @@ key = {TIOBE Index}, author = {{TIOBE Index}}, - howpublished= {\href{http://www.tiobe.com/tiobe_index}{http://\-www.tiobe.com/\-tiobe\_index}}, + howpublished= {\url{http://www.tiobe.com/tiobe_index}}, } @@ -8461,5 +8449,5 @@ title = {Thread (computing)}, author = {{Threading Model}}, - howpublished= {\href{https://en.wikipedia.org/wiki/Thread_(computing)}{https://\-en.wikipedia.org/\-wiki/\-Thread\_\-(computing)}}, + howpublished= {\url{https://en.wikipedia.org/wiki/Thread_(computing)}}, } @@ -8469,5 +8457,5 @@ title = {{T}okio Asynchronous Runtime for {R}ust}, author = {Tokio}, - howpublished= {\href{https://tokio.rs}{https://\-tokio.rs}}, + howpublished= {\url{https://tokio.rs}}, } @@ -8609,5 +8597,5 @@ key = {Trace Compass}, author = {{T}race {C}ompass}, - howpublished= {\href{https://projects.eclipse.org/proposals/trace-compass}{https://\-projects.eclipse.org/\-proposals/\-trace-compass}}, + howpublished= {\url{https://projects.eclipse.org/proposals/trace-compass}}, } @@ -8668,5 +8656,5 @@ 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}}, + howpublished= {\url{https://doc.akka.io/docs/akka/2.5/typed-actors.html}}, year = 2022, } @@ -8938,6 +8926,5 @@ year = 2020, note = {WikipediA}, - howpublished= {\href{https://en.wikipedia.org/wiki/Visitor\_pattern} - {https://\-en.wikipedia.org/\-wiki/\-Visitor\_pattern}}, + howpublished= {\url{https://en.wikipedia.org/wiki/Visitor\_pattern}}, } @@ -9041,5 +9028,5 @@ month = jun, year = 1985, - note = {\href{http://www.hpl.hp.com/techreports/tandem/TR-85.7.pdf}{http://www.hpl.hp.com/\-techreports/\-tandem/\-TR-85.7.pdf}}, + note = {\url{http://www.hpl.hp.com/techreports/tandem/TR-85.7.pdf}}, } Index: doc/papers/llheap/Paper.tex =================================================================== --- doc/papers/llheap/Paper.tex (revision c75b30ae4d3f97678f27275a033614f675b7fdaf) +++ doc/papers/llheap/Paper.tex (revision 32490deb2180d977e78b79e5c2342a8fa2357a53) @@ -77,16 +77,17 @@ \lstset{ columns=fullflexible, -basicstyle=\linespread{0.9}\sf, % reduce line spacing and use sanserif font -stringstyle=\tt, % use typewriter font -tabsize=5, % N space tabbing -xleftmargin=\parindentlnth, % indent code to paragraph indentation -%mathescape=true, % LaTeX math escape in CFA code $...$ -escapechar=\$, % LaTeX escape in CFA code -keepspaces=true, % -showstringspaces=false, % do not show spaces with cup -showlines=true, % show blank lines at end of code -aboveskip=4pt, % spacing above/below code block -belowskip=3pt, -moredelim=**[is][\color{red}]{`}{`}, +basicstyle=\linespread{0.9}\sf, % reduce line spacing and use sanserif font +stringstyle=\small\tt, % use typewriter font +tabsize=5, % N space tabbing +xleftmargin=\parindentlnth, % indent code to paragraph indentation +escapechar=\$, % LaTeX escape in CFA code +%mathescape=true, % LaTeX math escape in CFA code $...$ +keepspaces=true, % +showstringspaces=false, % do not show spaces with cup +showlines=true, % show blank lines at end of code +aboveskip=4pt, % spacing above/below code block +belowskip=2pt, +numberstyle=\footnotesize\sf, % numbering style +moredelim=**[is][\color{red}]{@}{@}, }% lstset @@ -1082,9 +1083,9 @@ The primary design objective for llheap is low-latency across all allocator calls independent of application access-patterns and/or number of threads, \ie very seldom does the allocator have a delay during an allocator call. -(Large allocations requiring initialization, \eg zero fill, and/or copying are not covered by the low-latency objective.) +Excluded from the low-latency objective are (large) allocations requiring initialization, \eg zero fill, and/or data copying, which are outside the allocator's purview. A direct consequence of this objective is very simple or no storage coalescing; hence, llheap's design is willing to use more storage to lower latency. This objective is apropos because systems research and industrial applications are striving for low latency and computers have huge amounts of RAM memory. -Finally, llheap's performance should be comparable with the current best allocators (see performance comparison in Section~\ref{c:Performance}). +Finally, llheap's performance should be comparable with the current best allocators, both in space and time (see performance comparison in Section~\ref{c:Performance}). % The objective of llheap's new design was to fulfill following requirements: @@ -1205,9 +1206,8 @@ % \label{s:AllocationFastpath} -llheap's design was reviewed and changed multiple times during its development. Only the final design choices are -discussed in this paper. +llheap's design was reviewed and changed multiple times during its development, with the final choices are discussed here. (See~\cite{Zulfiqar22} for a discussion of alternate choices and reasons for rejecting them.) All designs were analyzed for the allocation/free \newterm{fastpath}, \ie when an allocation can immediately return free storage or returned storage is not coalesced. -The heap model choosen is 1:1, which is the T:H model with T = H, where there is one thread-local heap for each KT. +The heap model chosen is 1:1, which is the T:H model with T = H, where there is one thread-local heap for each KT. (See Figure~\ref{f:THSharedHeaps} but with a heap bucket per KT and no bucket or local-pool lock.) Hence, immediately after a KT starts, its heap is created and just before a KT terminates, its heap is (logically) deleted. @@ -1426,5 +1426,5 @@ -Algorithm~\ref{alg:heapObjectFreeOwn} shows the de-allocation (free) outline for an object at address $A$ with ownership. +Algorithm~\ref{alg:heapObjectFreeOwn} shows the deallocation (free) outline for an object at address $A$ with ownership. First, the address is divided into small (@sbrk@) or large (@mmap@). For large allocations, the storage is unmapped back to the OS. @@ -1433,5 +1433,5 @@ If the bucket is not local to the thread, the allocation is pushed onto the owning thread's associated away stack. -Algorithm~\ref{alg:heapObjectFreeNoOwn} shows the de-allocation (free) outline for an object at address $A$ without ownership. +Algorithm~\ref{alg:heapObjectFreeNoOwn} shows the deallocation (free) outline for an object at address $A$ without ownership. The algorithm is the same as for ownership except if the bucket is not local to the thread. Then the corresponding bucket of the owner thread is computed for the deallocating thread, and the allocation is pushed onto the deallocating thread's bucket. @@ -1792,112 +1792,63 @@ The C dynamic-memory API is extended with the following routines: -\paragraph{\lstinline{void * aalloc( size_t dim, size_t elemSize )}} -extends @calloc@ for allocating a dynamic array of objects without calculating the total size of array explicitly but \emph{without} zero-filling the memory. -@aalloc@ is significantly faster than @calloc@, which is the only alternative given by the standard memory-allocation routines. - -\noindent\textbf{Usage} -@aalloc@ takes two parameters. -\begin{itemize}[topsep=3pt,itemsep=2pt,parsep=0pt] -\item -@dim@: number of array objects -\item -@elemSize@: size of array object -\end{itemize} +\medskip\noindent +\lstinline{void * aalloc( size_t dim, size_t elemSize )} +extends @calloc@ for allocating a dynamic array of objects with total size @dim@ $\times$ @elemSize@ but \emph{without} zero-filling the memory. +@aalloc@ is significantly faster than @calloc@, which is the only alternative given by the standard memory-allocation routines for array allocation. It returns the address of the dynamic array or @NULL@ if either @dim@ or @elemSize@ are zero. -\paragraph{\lstinline{void * resize( void * oaddr, size_t size )}} -extends @realloc@ for resizing an existing allocation \emph{without} copying previous data into the new allocation or preserving sticky properties. +\medskip\noindent +\lstinline{void * resize( void * oaddr, size_t size )} +extends @realloc@ for resizing an existing allocation, @oaddr@, to the new @size@ (smaller or larger than previous) \emph{without} copying previous data into the new allocation or preserving sticky properties. @resize@ is significantly faster than @realloc@, which is the only alternative. - -\noindent\textbf{Usage} -@resize@ takes two parameters. -\begin{itemize}[topsep=3pt,itemsep=2pt,parsep=0pt] -\item -@oaddr@: address to be resized -\item -@size@: new allocation size (smaller or larger than previous) -\end{itemize} It returns the address of the old or new storage with the specified new size or @NULL@ if @size@ is zero. -\paragraph{\lstinline{void * amemalign( size_t alignment, size_t dim, size_t elemSize )}} -extends @aalloc@ and @memalign@ for allocating an aligned dynamic array of objects. +\medskip\noindent +\lstinline{void * amemalign( size_t alignment, size_t dim, size_t elemSize )} +extends @aalloc@ and @memalign@ for allocating a dynamic array of objects with the starting address on the @alignment@ boundary. Sets sticky alignment property. - -\noindent\textbf{Usage} -@amemalign@ takes three parameters. -\begin{itemize}[topsep=3pt,itemsep=2pt,parsep=0pt] -\item -@alignment@: alignment requirement -\item -@dim@: number of array objects -\item -@elemSize@: size of array object -\end{itemize} It returns the address of the aligned dynamic-array or @NULL@ if either @dim@ or @elemSize@ are zero. -\paragraph{\lstinline{void * cmemalign( size_t alignment, size_t dim, size_t elemSize )}} +\medskip\noindent +\lstinline{void * cmemalign( size_t alignment, size_t dim, size_t elemSize )} extends @amemalign@ with zero fill and has the same usage as @amemalign@. Sets sticky zero-fill and alignment property. It returns the address of the aligned, zero-filled dynamic-array or @NULL@ if either @dim@ or @elemSize@ are zero. -\paragraph{\lstinline{size_t malloc_alignment( void * addr )}} -returns the alignment of the dynamic object for use in aligning similar allocations. - -\noindent\textbf{Usage} -@malloc_alignment@ takes one parameter. -\begin{itemize}[topsep=3pt,itemsep=2pt,parsep=0pt] -\item -@addr@: address of an allocated object. -\end{itemize} -It returns the alignment of the given object, where objects not allocated with alignment return the minimal allocation alignment. - -\paragraph{\lstinline{bool malloc_zero_fill( void * addr )}} -returns true if the object has the zero-fill sticky property for use in zero filling similar allocations. - -\noindent\textbf{Usage} -@malloc_zero_fill@ takes one parameters. - -\begin{itemize}[topsep=3pt,itemsep=2pt,parsep=0pt] -\item -@addr@: address of an allocated object. -\end{itemize} -It returns true if the zero-fill sticky property is set and false otherwise. - -\paragraph{\lstinline{size_t malloc_size( void * addr )}} -returns the request size of the dynamic object (updated when an object is resized) for use in similar allocations. -See also @malloc_usable_size@. - -\noindent\textbf{Usage} -@malloc_size@ takes one parameters. -\begin{itemize}[topsep=3pt,itemsep=2pt,parsep=0pt] -\item -@addr@: address of an allocated object. -\end{itemize} -It returns the request size or zero if @addr@ is @NULL@. - -\paragraph{\lstinline{int malloc_stats_fd( int fd )}} -changes the file descriptor where @malloc_stats@ writes statistics (default @stdout@). - -\noindent\textbf{Usage} -@malloc_stats_fd@ takes one parameters. -\begin{itemize}[topsep=3pt,itemsep=2pt,parsep=0pt] -\item -@fd@: file descriptor. -\end{itemize} -It returns the previous file descriptor. - -\paragraph{\lstinline{size_t malloc_expansion()}} +\medskip\noindent +\lstinline{size_t malloc_alignment( void * addr )} +returns the object alignment, where objects not allocated with alignment return the minimal allocation alignment. +For use in aligning similar allocations. + +\medskip\noindent +\lstinline{bool malloc_zero_fill( void * addr )} +returns true if the objects zero-fill sticky property is set and false otherwise. +For use in zero filling similar allocations. + +\medskip\noindent +\lstinline{size_t malloc_size( void * addr )} +returns the object's request size, which is updated when an object is resized or zero if @addr@ is @NULL@ (see also @malloc_usable_size@). +For use in similar allocations. + +\medskip\noindent +\lstinline{int malloc_stats_fd( int fd )} +changes the file descriptor where @malloc_stats@ writes statistics (default @stdout@) and returns the previous file descriptor. + +\medskip\noindent +\lstinline{size_t malloc_expansion()} \label{p:malloc_expansion} set the amount (bytes) to extend the heap when there is insufficient free storage to service an allocation request. It returns the heap extension size used throughout a program when requesting more memory from the system using @sbrk@ system-call, \ie called once at heap initialization. -\paragraph{\lstinline{size_t malloc_mmap_start()}} +\medskip\noindent +\lstinline{size_t malloc_mmap_start()} set the crossover between allocations occurring in the @sbrk@ area or separately mapped. It returns the crossover point used throughout a program, \ie called once at heap initialization. -\paragraph{\lstinline{size_t malloc_unfreed()}} +\medskip\noindent +\lstinline{size_t malloc_unfreed()} \label{p:malloc_unfreed} amount subtracted to adjust for unfreed program storage (debug only). -It returns the new subtraction amount and called by @malloc_stats@. +It returns the new subtraction amount and called by @malloc_stats@ (discussed in Section~\ref{}). @@ -1906,21 +1857,13 @@ The following extensions take advantage of overload polymorphism in the \CC type-system. -\paragraph{\lstinline{void * resize( void * oaddr, size_t nalign, size_t size )}} -extends @resize@ with an alignment re\-quirement. - -\noindent\textbf{Usage} -takes three parameters. -\begin{itemize}[topsep=3pt,itemsep=2pt,parsep=0pt] -\item -@oaddr@: address to be resized -\item -@nalign@: alignment requirement -\item -@size@: new allocation size (smaller or larger than previous) -\end{itemize} +\medskip\noindent +\lstinline{void * resize( void * oaddr, size_t nalign, size_t size )} +extends @resize@ with an alignment requirement, @nalign@. It returns the address of the old or new storage with the specified new size and alignment, or @NULL@ if @size@ is zero. -\paragraph{\lstinline{void * realloc( void * oaddr, size_t nalign, size_t size )}} -extends @realloc@ with an alignment re\-quirement and has the same usage as aligned @resize@. +\medskip\noindent +\lstinline{void * realloc( void * oaddr, size_t nalign, size_t size )} +extends @realloc@ with an alignment requirement, @nalign@. +It returns the address of the old or new storage with the specified new size and alignment, or @NULL@ if @size@ is zero. @@ -1979,5 +1922,5 @@ object size: like the \CFA's C-interface, programmers do not have to specify object size or cast allocation results. \end{itemize} -Note, postfix function call is an alternative call syntax, using backtick @`@, where the argument appears before the function name, \eg +Note, postfix function call is an alternative call syntax, using backtick @`@, so the argument appears before the function name, \eg \begin{cfa} duration ?@`@h( int h ); // ? denote the position of the function operand @@ -1987,5 +1930,8 @@ \end{cfa} -\paragraph{\lstinline{T * alloc( ... )} or \lstinline{T * alloc( size_t dim, ... )}} +The following extensions take advantage of overload polymorphism in the \CC type-system. + +\medskip\noindent +\lstinline{T * alloc( ... )} or \lstinline{T * alloc( size_t dim, ... )} is overloaded with a variable number of specific allocation operations, or an integer dimension parameter followed by a variable number of specific allocation operations. These allocation operations can be passed as named arguments when calling the \lstinline{alloc} routine. @@ -1996,7 +1942,10 @@ The allocation property functions are: -\subparagraph{\lstinline{T_align ?`align( size_t alignment )}} + +\medskip\noindent +\lstinline{T_align ?`align( size_t alignment )} to align the allocation. -The alignment parameter must be $\ge$ the default alignment (@libAlign()@ in \CFA) and a power of two, \eg: +The alignment parameter must be $\ge$ the default alignment (@libAlign()@ in \CFA) and a power of two. +The following example returns a dynamic object and object array aligned on a 4096-byte boundary. \begin{cfa} int * i0 = alloc( @4096`align@ ); sout | i0 | nl; @@ -2006,10 +1955,10 @@ 0x555555574000 0x555555574000 0x555555574004 0x555555574008 \end{cfa} -returns a dynamic object and object array aligned on a 4096-byte boundary. - -\subparagraph{\lstinline{S_fill(T) ?`fill ( /* various types */ )}} + +\medskip\noindent +\lstinline{S_fill(T) ?`fill ( /* various types */ )} to initialize storage. There are three ways to fill storage: -\begin{enumerate} +\begin{enumerate}[itemsep=0pt,parsep=0pt] \item A char fills each byte of each object. @@ -2020,5 +1969,5 @@ \end{enumerate} For example: -\begin{cfa}[numbers=left] +\begin{cfa}[numbers=left,xleftmargin=2.5\parindentlnth] int * i0 = alloc( @0n`fill@ ); sout | *i0 | nl; // disambiguate 0 int * i1 = alloc( @5`fill@ ); sout | *i1 | nl; @@ -2029,5 +1978,5 @@ int * i6 = alloc( 5, @[i3, 3]`fill@ ); for ( i; 5 ) sout | i6[i]; sout | nl; \end{cfa} -\begin{lstlisting}[numbers=left] +\begin{lstlisting}[numbers=left,xleftmargin=2.5\parindentlnth] 0 5 @@ -2041,14 +1990,15 @@ Examples 4 to 7 fill an array of objects with values, another array, or part of an array. -\subparagraph{\lstinline{S_resize(T) ?`resize( void * oaddr )}} +\medskip\noindent +\lstinline{S_resize(T) ?`resize( void * oaddr )} used to resize, realign, and fill, where the old object data is not copied to the new object. The old object type may be different from the new object type, since the values are not used. For example: -\begin{cfa}[numbers=left] +\begin{cfa}[numbers=left,xleftmargin=2.5\parindentlnth] int * i = alloc( @5`fill@ ); sout | i | *i; i = alloc( @i`resize@, @256`align@, @7`fill@ ); sout | i | *i; double * d = alloc( @i`resize@, @4096`align@, @13.5`fill@ ); sout | d | *d; \end{cfa} -\begin{lstlisting}[numbers=left] +\begin{lstlisting}[numbers=left,xleftmargin=2.5\parindentlnth] 0x55555556d5c0 5 0x555555570000 7 @@ -2057,5 +2007,5 @@ Examples 2 to 3 change the alignment, fill, and size for the initial storage of @i@. -\begin{cfa}[numbers=left] +\begin{cfa}[numbers=left,xleftmargin=2.5\parindentlnth] int * ia = alloc( 5, @5`fill@ ); for ( i; 5 ) sout | ia[i]; sout | nl; ia = alloc( 10, @ia`resize@, @7`fill@ ); for ( i; 10 ) sout | ia[i]; sout | nl; @@ -2063,5 +2013,5 @@ ia = alloc( 3, @ia`resize@, @4096`align@, @2`fill@ ); sout | ia; for ( i; 3 ) sout | &ia[i] | ia[i]; sout | nl; \end{cfa} -\begin{lstlisting}[numbers=left] +\begin{lstlisting}[numbers=left,xleftmargin=2.5\parindentlnth] 5 5 5 5 5 7 7 7 7 7 7 7 7 7 7 @@ -2071,15 +2021,16 @@ Examples 2 to 4 change the array size, alignment and fill for the initial storage of @ia@. -\subparagraph{\lstinline{S_realloc(T) ?`realloc( T * a ))}} +\medskip\noindent +\lstinline{S_realloc(T) ?`realloc( T * a ))} used to resize, realign, and fill, where the old object data is copied to the new object. The old object type must be the same as the new object type, since the value is used. Note, for @fill@, only the extra space after copying the data from the old object is filled with the given parameter. For example: -\begin{cfa}[numbers=left] +\begin{cfa}[numbers=left,xleftmargin=2.5\parindentlnth] int * i = alloc( @5`fill@ ); sout | i | *i; i = alloc( @i`realloc@, @256`align@ ); sout | i | *i; i = alloc( @i`realloc@, @4096`align@, @13`fill@ ); sout | i | *i; \end{cfa} -\begin{lstlisting}[numbers=left] +\begin{lstlisting}[numbers=left,xleftmargin=2.5\parindentlnth] 0x55555556d5c0 5 0x555555570000 5 @@ -2089,5 +2040,5 @@ The @13`fill@ in example 3 does nothing because no extra space is added. -\begin{cfa}[numbers=left] +\begin{cfa}[numbers=left,xleftmargin=2.5\parindentlnth] int * ia = alloc( 5, @5`fill@ ); for ( i; 5 ) sout | ia[i]; sout | nl; ia = alloc( 10, @ia`realloc@, @7`fill@ ); for ( i; 10 ) sout | ia[i]; sout | nl; @@ -2095,5 +2046,5 @@ ia = alloc( 3, @ia`realloc@, @4096`align@, @2`fill@ ); sout | ia; for ( i; 3 ) sout | &ia[i] | ia[i]; sout | nl; \end{cfa} -\begin{lstlisting}[numbers=left] +\begin{lstlisting}[numbers=left,xleftmargin=2.5\parindentlnth] 5 5 5 5 5 5 5 5 5 5 7 7 7 7 7 Index: doc/proposals/enum.tex =================================================================== --- doc/proposals/enum.tex (revision c75b30ae4d3f97678f27275a033614f675b7fdaf) +++ doc/proposals/enum.tex (revision 32490deb2180d977e78b79e5c2342a8fa2357a53) @@ -7,4 +7,6 @@ \usepackage{graphics} \usepackage{xspace} +\usepackage{relsize} % must be after change to small or selects old size +\usepackage{calc} % latex arithmetic \makeatletter @@ -22,4 +24,19 @@ \newcommand{\@newterm}[2][\@empty]{\lowercase{\def\temp{#2}}{\newtermFontInline{#2}}\ifx#1\@empty\index{\temp}\else\index{#1@{\protect#2}}\fi} \newcommand{\@snewterm}[2][\@empty]{{\newtermFontInline{#2}}\ifx#1\@empty\index{#2}\else\index{#1@{\protect#2}}\fi} + +\newcommand{\LstBasicStyle}[1]{{\lst@basicstyle{#1}}} +\newcommand{\LstKeywordStyle}[1]{{\lst@basicstyle{\lst@keywordstyle{#1}}}} +\newcommand{\LstCommentStyle}[1]{{\lst@basicstyle{\lst@commentstyle{#1}}}} +\newcommand{\LstStringStyle}[1]{{\lst@basicstyle{\lst@stringstyle{#1}}}} +\newcommand{\LstNumberStyle}[1]{{\lst@basicstyle{\lst@numberstyle{#1}}}} + +\newlength{\gcolumnposn} % temporary hack because lstlisting does not handle tabs correctly +\newlength{\columnposn} +\setlength{\gcolumnposn}{3in} +\setlength{\columnposn}{\gcolumnposn} +\newcommand{\setgcolumn}[1]{\global\gcolumnposn=#1\global\columnposn=\gcolumnposn} +\newcommand{\C}[2][\@empty]{\ifx#1\@empty\else\global\setlength{\columnposn}{#1}\global\columnposn=\columnposn\fi\hfill\makebox[\textwidth-\columnposn][l]{\LstCommentStyle{#2}}} +\newcommand{\CD}[2][\@empty]{\ifx#1\@empty\else\global\setlength{\columnposn}{#1}\global\columnposn=\columnposn\fi\hfill\makebox[\textwidth-\columnposn][l]{\LstBasicStyle{#2}}} +\newcommand{\CRT}{\global\columnposn=\gcolumnposn} \makeatother @@ -48,4 +65,5 @@ \newcommand{\CCIcon}{\textrm{C}\kern-.1em\hbox{+\kern-.25em+}} % C++ icon \newcommand{\CC}[1][]{\protect\CCIcon{#1}\xspace} % C++ symbolic name +\newcommand{\Csharp}{C\raisebox{-0.7ex}{\relsize{2}$^\sharp$}\xspace} % C# symbolic name \newcommand{\PAB}[1]{{\color{red}PAB: #1}} @@ -56,5 +74,5 @@ \lstdefinestyle{CStyle}{ -% backgroundcolor=\color{backgroundColour}, +% backgroundcolor=\color{backgroundColour}, % commentstyle=\color{mGreen}, % keywordstyle=\color{magenta}, @@ -64,15 +82,15 @@ basicstyle=\small\linespread{0.9}\sf, % reduce line spacing and use sanserif font % basicstyle=\footnotesize, - breakatwhitespace=false, -% breaklines=true, - captionpos=b, - keepspaces=true, + breakatwhitespace=false, +% breaklines=true, + captionpos=b, + keepspaces=true, escapechar=\$, % LaTeX escape in CFA code -% numbers=left, -% numbersep=5pt, +% numbers=left, +% numbersep=5pt, % numberstyle=\tiny\color{mGray}, -% showspaces=false, +% showspaces=false, showstringspaces=false, -% showtabs=false, +% showtabs=false, showlines=true, % show blank lines at end of code tabsize=5, @@ -93,21 +111,35 @@ \begin{abstract} -An enumeration is a type that defines a list of named constant values in C (and other languages). -C and \CC use an integral type as the underlying representation of an enumeration. -\CFA extends C enumerations to allow all basic and custom types for the inner representation. +An enumeration is a type defining an ordered set of named constant values, where a name abstracts a value, e.g., @PI@ versus @3.145159@. +C restrict an enumeration type to the integral type @signed int@, which \CC support , meaning enumeration names bind to integer constants. +\CFA extends C enumerations to allow all basic and custom types for the enumeration type, like other modern programming languages. +Furthermore, \CFA adds other useful features for enumerations to support better software-engineering practices and simplify program development. \end{abstract} +\section{Background} + +Naming values is a common practice in mathematics and engineering, e.g., $\pi$, $\tau$ (2$\pi$), $\phi$ (golden ratio), MHz (1E6), etc. +Naming is also commonly used to represent many other numerical phenomenon, such as days of the week, months of a year, floors of a building (basement), time (noon, New Years). +Many programming languages capture this important capability through a mechanism called an \newterm{enumeration}. +An enumeration is similar to other programming-language types by providing a set of constrained values, but adds the ability to name \emph{all} the values in its set. +Note, all enumeration names must be unique but different names can represent the same value (eight note, quaver), which are synonyms. + +Specifically, an enumerated type is a type whose values are restricted to a fixed set of named constants. +Fundamentally, all types are restricted to a fixed set of values because of the underlying von Neumann architecture, and hence, to a corresponding set of constants, e.g., @3@, @3.5@, @3.5+2.1i@, @'c'@, @"abc"@, etc. +However, the values for basic types are not named, other than the programming-language supplied constants. + + \section{C-Style Enum} -\CFA supports the C-Style enumeration using the same syntax and semantics. +The C-Style enumeration has the following syntax and semantics. \begin{lstlisting}[label=lst:weekday] -enum Weekday { Monday, Tuesday, Wednesday, Thursday=10, Friday, Saturday, Sunday }; - $\(\uparrow\)$ $\(\uparrow\)$ - ${\rm \newterm{enumeration name}}$ ${\rm \newterm{enumerator names}} -\end{lstlisting} -The example defines an enumeration type @Weekday@ with ordered enumerators @Monday@, @Tuesday@, @Wednesday@, @Thursday@, @Friday@, @Saturday@ and @Sunday@. +enum Weekday { Monday, Tuesday, Wednesday, Thursday@ = 10@, Friday, Saturday, Sunday }; + $\(\uparrow\)$ $\(\uparrow\)$ + ${\rm \newterm{enumeration name}}$ ${\rm \newterm{enumerator names}} +\end{lstlisting} +Here, the enumeration type @Weekday@ defines the ordered \newterm{enumerator}s @Monday@, @Tuesday@, @Wednesday@, @Thursday@, @Friday@, @Saturday@ and @Sunday@. The successor of @Tuesday@ is @Monday@ and the predecessor of @Tuesday@ is @Wednesday@. -A C enumeration is an integral type, with consecutive enumerator values assigned by the compiler starting at zero or the next explicitly initialized value by the programmer. -For example, @Monday@ to @Wednesday@ have values 0--2 implicitly set by the compiler, @Thursday@ is explicitly set to @10@ by the programmer, and @Friday@ to @Sunday@ have values 11--13 implicitly set by the compiler. +A C enumeration is implemented by an integral type, with consecutive enumerator values assigned by the compiler starting at zero or the next explicitly initialized value. +For example, @Monday@ to @Wednesday@ have values 0--2 implicitly set by the compiler, @Thursday@ is explicitly set to @10@, and @Friday@ to @Sunday@ have values 11--13 implicitly set by the compiler. There are 3 attributes for an enumeration: \newterm{position}, \newterm{label}, and \newterm{value}: @@ -118,28 +150,37 @@ \it position & 0 & 1 & 2 & 3 & 4 & 5 & 6 \\ \it label & Monday & Tuesday & Wednesday & Thursday & Friday & Saturday & Sunday \\ -\it value & 0 & 1 & 2 & 10 & 11 & 12 & 13 +\it value & 0 & 1 & 2 & {\color{red}10}& 11 & 12 & 13 \end{tabular} \end{cquote} The enumerators of an enumeration are unscoped, i.e., enumerators declared inside of an @enum@ are visible in the enclosing scope of the @enum@ type. +Furthermore, there is an implicit bidirectional conversion between an enumeration and integral types. \begin{lstlisting}[label=lst:enum_scope] { - enum Weekday { ... }; // enumerators implicitly projected into local scope + enum Weekday { ... }; $\C{// enumerators implicitly projected into local scope}$ Weekday weekday = Monday; - weekday = Friday; - int i = Sunday // i == 13 + weekday = Friday; $\C{// weekday == 11}$ + int i = Sunday $\C{// i == 13}$ + weekday = 10000; $\C{// undefined behaviour}$ } -int j = Wednesday; // ERROR! Wednesday is not declared in this scope +int j = Wednesday; $\C{// ERROR! Wednesday is not declared in this scope}$ \end{lstlisting} \section{\CFA-Style Enum} -A \CFA enumeration is parameterized by a type specifying each enumerator's type. -\CFA allows any object type for the enumerators, and values assigned to enumerators must be from the declared type. +\CFA supports C-Style enumeration using the same syntax and semantics for backwards compatibility. +\CFA also extends C-Style enumeration by adding a number of new features that bring enumerations inline with other modern programming languages. + +\subsection{Enumerator Typing} + +\CFA extends the enumeration by parameterizing the enumeration with a type for the enumerators, allowing enumerators to be assigned any values from the declared type. \begin{lstlisting}[label=lst:color] -enum Colour( @char *@ ) { Red = "R", Green = "G", Blue = "B" }; -\end{lstlisting} -The type of @Colour@ is @char *@ and each enumerator is initialized with a C string. -Only types with a defined ordering can be automatically initialized (see Section~\ref{s:AutoInitializable}). +enum( @char@ ) Currency { Dollar = '$\textdollar$', Euro = '$\texteuro$', Pound = '$\textsterling$' }; +enum( @double@ ) Planet { Venus = 4.87, Earth = 5.97, Mars = 0.642 }; // mass +enum( @char *@ ) Colour { Red = "red", Green = "green", Blue = "blue" }; +enum( @Currency@ ) Europe { Euro = '$\texteuro$', Pound = '$\textsterling$' }; // intersection +\end{lstlisting} +The types of the enumerators are @char@, @double@, and @char *@ and each enumerator is initialized with corresponding type values. +% Only types with a defined ordering can be automatically initialized (see Section~\ref{s:AutoInitializable}). % An instance of \CFA-enum (denoted as @@) is a label for the defined enum name. @@ -151,5 +192,6 @@ A \CFA-enum can be scoped, meaning the enumerator constants are not projected into the enclosing scope. \begin{lstlisting} -enum Colour( char * ) @!@ { ... }; +enum Weekday @!@ { /* as above */ }; +enum Colour( char * ) @!@ { /* as above */ }; \end{lstlisting} where the @'!'@ implies the enumerators are \emph{not} projected. @@ -158,44 +200,53 @@ % $$ := .$$ \begin{lstlisting} -Colour colour = @Colour.@Red; // qualification +Weekday weekday = @Weekday.Monday@; $\C{// qualification}$ +Colour colour = @Colour.@Red; colour = @Colour.@Blue; \end{lstlisting} -\section{Enumeration Pseudo-functions} -Pseudo-functions are function-like operators that do not result in any run-time computations, i.e., like @sizeof@. Instead, the call to functions will be substituted into other expressions in compilation time. - -\subsection{Enumerator Attributes} -The attributes of an enumerator are accessed by pseudo-functions @position@, @value@, and @label@. +\subsection{Enumeration Pseudo-functions} + +Pseudo-functions are function-like operators that do not result in any run-time computations, i.e., like @sizeof@. +Often a call to a pseudo-function is substituted with information extracted from the symbol table at compilation time, like storage size or alignment associated with the underlying architecture.. + +\subsubsection{Enumerator Attributes} +The attributes of an enumerator are accessed by pseudo-functions @position@, @value@, and @label@. \begin{lstlisting} -int green_pos = @position@( Colour.Green ); // 1 -char * green_value = @value@( Colour.Green ); / "G" -char * green_label = @label@( Colour.Green ); // "Green" -\end{lstlisting} - -\subsection{enumerate()} +int green_pos = @position@( Colour.Green ); $\C{// 1}$ +char * green_value = @value@( Colour.Green ); $\C{// "G"}$ +char * green_label = @label@( Colour.Green ); $\C{// "Green"}$ +\end{lstlisting} + +Enumeration Greek may have more or less enumerators than Letter, but the enumerator values must be from Letter. +Therefore, Greek enumerators are a subset of type Letter and are type compatible with enumeration Letter, but Letter enumerators are not type compatible with enumeration Greek. + +\subsubsection{\lstinline{enumerate()}} + \begin{lstlisting}[label=lst:c_switch] enum(int) C_ENUM { First, Second, Third = First, Fourth }; -int v(C_ENUM e) { - switch( e ) { - case First: return 0; break; - case Second: return 1; break; - // case Thrid: return 2; break; - // case Fourth: return 3; break; - }; -}; -\end{lstlisting} -In the @C_ENUM@ example, @Third@ is an alias of @First@ and @Fourth@ is an alias of @Second@. Programmers cannot make case branches for @Third@ and @Fourth@ because the switch statement matches cases by the enumerator's value. Case First and Third, or Second and Fourth, has duplicate case values. - -@enumerate()@ is a pseudo-function that makes the switch statement match by an enumerator instead. +int v( C_ENUM e ) { + switch( e ) { + case First: return 0; break; + case Second: return 1; break; + // case Third: return 2; break; + // case Fourth: return 3; break; + }; +}; +\end{lstlisting} +In the @C_ENUM@ example, @Third@ is an alias of @First@ and @Fourth@ is an alias of @Second@. +Programmers cannot make case branches for @Third@ and @Fourth@ because the switch statement matches cases by the enumerator's value. +Case @First@ and @Third@, or @Second@ and @Fourth@, has duplicate case values. + +@enumerate()@ is a pseudo-function that makes the switch statement match by an enumerator instead. \begin{lstlisting}[label=lst:c_switch_enumerate] enum(double) C_ENUM { First, Second, Third = First, Fourth }; -C_ENUM variable_a = First, variable_b = Second, variable_c = Thrid, variable_d = Fourth; -int v(C_ENUM e) { - switch( enumeratate( e ) ) { - case First: return e; break; - case Second: return value( e ); break; - case Thrid: return label( e ); break; - case Fourth: return position( e ); break; - }; +C_ENUM variable_a = First, variable_b = Second, variable_c = Third, variable_d = Fourth; +int v(C_ENUM e) { + switch( enumeratate( e ) ) { + case First: return e; break; + case Second: return value( e ); break; + case Third: return label( e ); break; + case Fourth: return position( e ); break; + }; }; p(variable_a); // 0 @@ -205,5 +256,7 @@ \end{lstlisting} + \section{Enumeration Storage} + \subsection{Enumeration Variable} @@ -228,34 +281,39 @@ >>> label( Colour, 1) -> char * \end{lstlisting} -@T@ represents the type declared in the \CFA enumeration defined and @char *@ in the example. +@T@ represents the type declared in the \CFA enumeration defined and @char *@ in the example. These generated functions are $Companion Functions$, they take an $companion$ object and the position as parameters. + \subsection{Enumeration Data} + \begin{lstlisting}[label=lst:enumeration_backing_data] enum(T) E { ... }; // backing data -T* E_values; -char** E_labels; -\end{lstlisting} -Storing values and labels as arrays can sometimes help support enumeration features. However, the data structures are the overhead for the programs. We want to reduce the memory usage for enumeration support by: +T * E_values; +char ** E_labels; +\end{lstlisting} +Storing values and labels as arrays can sometimes help support enumeration features. +However, the data structures are the overhead for the programs. We want to reduce the memory usage for enumeration support by: \begin{itemize} - \item Only generates the data array if necessary - \item The compilation units share the data structures. No extra overhead if the data structures are requested multiple times. + \item Only generates the data array if necessary + \item The compilation units share the data structures. + No extra overhead if the data structures are requested multiple times. \end{itemize} -\ \section{Unification} \subsection{Enumeration as Value} \label{section:enumeration_as_value} -An \CFA enumeration with base type T can be used seamlessly as T, without explicitly calling the pseudo-function value. +An \CFA enumeration with base type T can be used seamlessly as T, without explicitly calling the pseudo-function value. \begin{lstlisting}[label=lst:implicit_conversion] char * green_value = Colour.Green; // "G" -// Is equivalent to +// Is equivalent to // char * green_value = value( Color.Green ); "G" \end{lstlisting} + \subsection{Unification Distance} + \begin{lstlisting}[label=lst:unification_distance_example] T_2 Foo(T1); @@ -265,8 +323,8 @@ @path(A, B)@ is a compiler concept that returns one of the following: \begin{itemize} - \item Zero or 0, if and only if $A == B$. - \item Safe, if B can be used as A without losing its precision, or B is a subtype of A. - \item Unsafe, if B loses its precision when used as A, or A is a subtype of B. - \item Infinite, if B cannot be used as A. A is not a subtype of B and B is not a subtype of A. + \item Zero or 0, if and only if $A == B$. + \item Safe, if B can be used as A without losing its precision, or B is a subtype of A. + \item Unsafe, if B loses its precision when used as A, or A is a subtype of B. + \item Infinite, if B cannot be used as A. A is not a subtype of B and B is not a subtype of A. \end{itemize} @@ -278,8 +336,8 @@ The arithmetic of distance is the following: \begin{itemize} - \item $Zero + v= v$, for some value v. - \item $Safe * k < Unsafe$, for finite k. - \item $Unsafe * k < Infinite$, for finite k. - \item $Infinite + v = Infinite$, for some value v. + \item $Zero + v= v$, for some value v. + \item $Safe * k < Unsafe$, for finite k. + \item $Unsafe * k < Infinite$, for finite k. + \item $Infinite + v = Infinite$, for some value v. \end{itemize} @@ -288,4 +346,5 @@ \subsection{Variable Overloading and Parameter Unification} + \CFA allows variable names to be overloaded. It is possible to overload a variable that has type T and an enumeration with type T. \begin{lstlisting}[label=lst:variable_overload] @@ -304,5 +363,5 @@ Similarly, functions can be overloaded with different signatures. \CFA picks the correct function entity based on the distance between parameter types and the arguments. \begin{lstlisting}[label=lst:function_overload] -Colour green = Colour.Green; +Colour green = Colour.Green; void foo(Colour c) { sout | "It is an enum"; } // First foo void foo(char * s) { sout | "It is a string"; } // Second foo @@ -326,5 +385,5 @@ % The @EnumInstType@ is convertible to other types. % A \CFA enumeration expression is implicitly \emph{overloaded} with its three different attributes: value, position, and label. -% The \CFA compilers need to resolve an @EnumInstType@ as one of its attributes based on the current context. +% The \CFA compilers need to resolve an @EnumInstType@ as one of its attributes based on the current context. % \begin{lstlisting}[caption={Null Context}, label=lst:null_context] @@ -379,5 +438,5 @@ % } % \end{lstlisting} -% % The conversion can work backward: in restrictive cases, attributes of can be implicitly converted back to the EnumInstType. +% % The conversion can work backward: in restrictive cases, attributes of can be implicitly converted back to the EnumInstType. % Backward conversion: % \begin{lstlisting}[caption={Unification Functions}, label=lst:unification_func_call] @@ -389,12 +448,12 @@ % \begin{lstlisting}[caption={Unification Functions}, label=lst:unification_func_call] % { -% Unification( EnumInstType, int ) >>> label +% Unification( EnumInstType, int ) >>> label % } % \end{lstlisting} % @int@ can be unified with the label of Colour. -% @5@ is a constant expression $\Rightarrow$ Compiler knows the value during the compilation $\Rightarrow$ turns it into +% @5@ is a constant expression $\Rightarrow$ Compiler knows the value during the compilation $\Rightarrow$ turns it into % \begin{lstlisting} % { -% enum Colour colour = Colour.Green; +% enum Colour colour = Colour.Green; % } % \end{lstlisting} @@ -411,5 +470,5 @@ % { % enum T (int) { ... } // Declaration -% enum T t = 1; +% enum T t = 1; % } % \end{lstlisting} @@ -423,5 +482,5 @@ % return the FIRST enumeration constant that has the value 1, by searching through the values array % \end{enumerate} -% The downside of the precedence rule: @EnumInstType@ $\Rightarrow$ @int ( value )@ $\Rightarrow$ @EnumInstType@ may return a different @EnumInstType@ because the value can be repeated and there is no way to know which one is expected $\Rightarrow$ want uniqueness +% The downside of the precedence rule: @EnumInstType@ $\Rightarrow$ @int ( value )@ $\Rightarrow$ @EnumInstType@ may return a different @EnumInstType@ because the value can be repeated and there is no way to know which one is expected $\Rightarrow$ want uniqueness % \subsection{Casting} @@ -431,5 +490,5 @@ % (int) Foo.A; % \end{lstlisting} -% The \CFA-compiler unifies @EnumInstType@ with int, with returns @value( Foo.A )@, which has statically known value 10. In other words, \CFA-compiler is aware of a cast expression, and it forms the context for EnumInstType resolution. The expression with type @EnumInstType@ can be replaced by the compile with a constant expression 10, and optionally discard the cast expression. +% The \CFA-compiler unifies @EnumInstType@ with int, with returns @value( Foo.A )@, which has statically known value 10. In other words, \CFA-compiler is aware of a cast expression, and it forms the context for EnumInstType resolution. The expression with type @EnumInstType@ can be replaced by the compile with a constant expression 10, and optionally discard the cast expression. % \subsection{Value Conversion} @@ -445,5 +504,5 @@ % int j = value( Foo, a ) % \end{lstlisting} -% Similarly, the generated code for the third line is +% Similarly, the generated code for the third line is % \begin{lstlisting} % char * j = label( Foo, a ) @@ -455,5 +514,5 @@ \subsection{C Enumeration Rule} -A C enumeration has an integral type. If not initialized, the first enumerator implicitly has the integral value 0, and other enumerators have a value equal to its $predecessor + 1$. +A C enumeration has an integral type. If not initialized, the first enumerator implicitly has the integral value 0, and other enumerators have a value equal to its $predecessor + 1$. \subsection{Auto Initializable} @@ -478,5 +537,5 @@ Odd ?++( Odd t1 ) { return Odd( t1.i + 2); }; \end{lstlisting} -When the type of an enumeration is @AutoInitializable@, implicit initialization is available. +When the type of an enumeration is @AutoInitializable@, implicit initialization is available. \begin{lstlisting}[label=lst:sample_auto_Initializable_usage] enum AutoInitUsage(Odd) { @@ -514,5 +573,5 @@ @alph@ is the iterating enumeration object, which returns the value of an @Alphabet@ in this context according to the precedence rule. -\textbullet\ \CFA offers a shorthand for iterating all enumeration constants: +\textbullet\ \CFA offers a shorthand for iterating all enumeration constants: \begin{lstlisting}[label=lst:range_functions] for ( Alphabet alph ) { sout | alph; } @@ -567,5 +626,5 @@ >>> 10 11 12 13 14 15 16 17 18 \end{lstlisting} -The first syntax is stepping to the next enumeration constant, which is the default stepping scheme if not explicitly specified. The second syntax, on the other hand, is to call @operator+=@ @one_type@ on the @value( s )@. Therefore, the second syntax is equivalent to +The first syntax is stepping to the next enumeration constant, which is the default stepping scheme if not explicitly specified. The second syntax, on the other hand, is to call @operator+=@ @one_type@ on the @value( s )@. Therefore, the second syntax is equivalent to \begin{lstlisting}[label=lst:range_function_stepping_converted] for ( typeof( value(Sequence.A) ) s=value( Sequence.A ); s <= Sequence.D; s+=1 ) { sout | alph; } @@ -579,5 +638,5 @@ for ( char * alph; Alphabet ) \end{lstlisting} -This for-loop implicitly iterates every label of the enumeration, because a label is the only valid resolution to the ch with type @char *@ in this case. +This for-loop implicitly iterates every label of the enumeration, because a label is the only valid resolution to @ch@ with type @char *@ in this case. If the value can also be resolved as the @char *@, you might iterate the labels explicitly with the array iteration. \begin{lstlisting}[label=lst:range_functions_label_implicit] @@ -591,8 +650,8 @@ % \begin{lstlisting} % enum T( int, char * ) { -% a=42, b="Hello World" +% a=42, b="Hello World" % }; % \end{lstlisting} -% The enum T declares two different types: int and char *. The enumerators of T hold values of one of the declared types. +% The enum T declares two different types: int and char *. The enumerators of T hold values of one of the declared types. \subsection{Enumeration Inheritance} @@ -602,5 +661,5 @@ enum /* inferred */ Name2 { inline Name, Sue = "Sue", Tom = "Tom" }; \end{lstlisting} -\lstinline{Inline} allows Enumeration Name2 to inherit enumerators from Name1 by containment, and a Name enumeration is a subtype of enumeration Name2. An enumeration instance of type Name can be used where an instance of Name2 is expected. +\lstinline{Inline} allows Enumeration Name2 to inherit enumerators from Name1 by containment, and a Name enumeration is a subtype of enumeration Name2. An enumeration instance of type Name can be used where an instance of Name2 is expected. \begin{lstlisting}[label=lst:EnumInline] Name Fred; @@ -610,5 +669,5 @@ If enumeration A declares @inline B@ in its enumeration body, enumeration A is the "inlining enum" and enumeration B is the "inlined enum". -An enumeration can inline at most one other enumeration. The inline declaration must be placed before the first enumerator of the inlining enum. The inlining enum has all the enumerators from the inlined enum, with the same labels, values, and position. +An enumeration can inline at most one other enumeration. The inline declaration must be placed before the first enumerator of the inlining enum. The inlining enum has all the enumerators from the inlined enum, with the same labels, values, and position. \begin{lstlisting}[label=lst:EnumInline] enum /* inferred */ Name2 { inline Name, Sue = "Sue", Tom = "Tom" }; @@ -625,8 +684,8 @@ \begin{lstlisting}[label=lst:static_attr] enum( char * ) Colour { - Red = "red", Blue = "blue", Green = "green" -}; -\end{lstlisting} -An enumerator expression returns its enumerator value as a constant expression with no runtime cost. For example, @Colour.Red@ is equivalent to the constant expression "red", and \CFA finishes the expression evaluation before generating the corresponding C code. Applying a pseudo-function to a constant enumerator expression results in a constant expression as well. @value( Colour.Red )@, @position( Colour. Red )@, and @label( Colour.Red )@ are equivalent to constant expression with char * value "red", int value 0, and char * value "Red", respectively. + Red = "red", Blue = "blue", Green = "green" +}; +\end{lstlisting} +An enumerator expression returns its enumerator value as a constant expression with no runtime cost. For example, @Colour.Red@ is equivalent to the constant expression "red", and \CFA finishes the expression evaluation before generating the corresponding C code. Applying a pseudo-function to a constant enumerator expression results in a constant expression as well. @value( Colour.Red )@, @position( Colour. Red )@, and @label( Colour.Red )@ are equivalent to constant expression with char * value "red", int value 0, and char * value "Red", respectively. \subsection{Runtime Attribute Expression and Weak Referenced Data} @@ -638,5 +697,5 @@ An enumeration variable c is equivalent to an integer variable with the value of @position( c )@ In Example~\ref{lst:dynamic_attr}, the value of enumeration variable c is unknown at compile time. In this case, the pseudo-function calls are reduced to expression that returns the enumerator values at runtime. -\CFA stores the variables and labels in const arrays to provide runtime lookup for enumeration information. +\CFA stores the variables and labels in @const@ arrays to provide runtime lookup for enumeration information. \begin{lstlisting}[label=lst:attr_array] @@ -651,5 +710,5 @@ \end{lstlisting} -To avoid unnecessary memory usage, the labels and values array are only generated as needed, and only generate once across all compilation units. By default, \CFA defers the declaration of the label and value arrays until an call to attribute function with a dynamic value. If an attribute function is never called on a dynamic value of an enumerator, the array will never be allocated. Once the arrays are created, all compilation units share a weak reference to the allocation array. +To avoid unnecessary memory usage, the labels and values array are only generated as needed, and only generate once across all compilation units. By default, \CFA defers the declaration of the label and value arrays until an call to attribute function with a dynamic value. If an attribute function is never called on a dynamic value of an enumerator, the array will never be allocated. Once the arrays are created, all compilation units share a weak reference to the allocation array. \subsection{Enum Prelude} @@ -657,7 +716,7 @@ \begin{lstlisting}[label=lst:enum_func_dec] forall( T ) { - unsigned position( unsigned ); - T value( unsigned ); - char * label( unsigned ); + unsigned position( unsigned ); + T value( unsigned ); + char * label( unsigned ); } \end{lstlisting} @@ -670,6 +729,6 @@ forall(T) class EnumDecl { - T* values; - char** label; + T* values; + char** label; }; \end{lstlisting} @@ -679,6 +738,6 @@ \begin{lstlisting}[label=lst:EnumInstType] class EnumInstType { - EnumDecl enumDecl; - int position; + EnumDecl enumDecl; + int position; }; \end{lstlisting} @@ -700,5 +759,5 @@ % struct Companion { % const T * const values; -% const char * label; +% const char * label; % int length; % }; @@ -706,5 +765,5 @@ % \CFA generates companion objects, an instance of structure that encloses @necessary@ data to represent an enumeration. The size of the companion is unknown at the compilation time, and it "grows" in size to compensate for the @usage@. -% The companion object is singleton across the compilation (investigation). +% The companion object is singleton across the compilation (investigation). % \CFA generates the definition of companion functions. @@ -727,9 +786,9 @@ \begin{lstlisting}[label=lst:companion_trait] forall(T1) { - trait Companion(otype T2) { - T1 value((otype T2 const &); - int position(otype T2 const &); - char * label(otype T2 const &); - } + trait Companion(otype T2) { + T1 value((otype T2 const &); + int position(otype T2 const &); + char * label(otype T2 const &); + } } \end{lstlisting} @@ -743,5 +802,5 @@ \begin{lstlisting} enum(int) Weekday { - Monday=10, Tuesday, ... + Monday=10, Tuesday, ... }; @@ -758,8 +817,8 @@ \subsection{User Define Enumeration Functions} -Companion objects make extending features for \CFA enumeration easy. +Companion objects make extending features for \CFA enumeration easy. \begin{lstlisting}[label=lst:companion_user_definition] -char * charastic_string( Companion o, int position ) { - return sprintf( "Label: %s; Value: %s", label( o, position ), value( o, position) ); +char * charastic_string( Companion o, int position ) { + return sprintf( "Label: %s; Value: %s", label( o, position ), value( o, position) ); } printf( charactic_string ( Color, 1 ) ); @@ -776,8 +835,8 @@ Similarly, the user can work with the enumeration type itself: (see section ref...) \begin{lstlisting}[ label=lst:companion_user_definition] -void print_enumerators ( Companion o ) { +void print_enumerators ( Companion o ) { for ( c : Companion o ) { sout | label (c) | value( c ) ; - } + } } print_enumerators( Colour ); @@ -795,5 +854,5 @@ It ensures that the name of an enumerator is unique within the enumeration body, and checks if all values of the enumerator have the declaration type. If the declared type is not @AutoInitializable@, \CFA rejects the enumeration definition. -Otherwise, it attempts to initialize enumerators with the enumeration initialization pattern. (a reference to a future initialization pattern section) +Otherwise, it attempts to initialize enumerators with the enumeration initialization pattern. (a reference to a future initialization pattern section) \begin{lstlisting}[label=lst:init] @@ -803,6 +862,6 @@ T ?+?( T & lhs, T & rhs ) { ... }; -enum (T) Sample { - Zero: 0 /* zero_t */, +enum (T) Sample { + Zero: 0 /* zero_t */, One: Zero + 1 /* ?+?( Zero, one_t ) */ , ... }; @@ -826,5 +885,5 @@ \subsection{Qualified Expression} -\CFA uses qualified expression to address the scoping of \CFA-enumeration. +\CFA uses qualified expression to address the scoping of \CFA-enumeration. \begin{lstlisting}[label=lst:qualified_expression] aggregation_name.field; @@ -837,4 +896,5 @@ \subsection{\lstinline{with} Clause/Statement} + Instead of qualifying an enumeration expression every time, the @with@ can be used to expose enumerators to the current scope, making them directly accessible. \begin{lstlisting}[label=lst:declaration] @@ -842,6 +902,6 @@ enum Animal( int ) { Cat=10, Dog=20 }; with ( Color, Animal ) { - char * red_string = Red; // value( Color.Red ) - int cat = Cat; // value( Animal.Cat ) + char * red_string = Red; // value( Color.Red ) + int cat = Cat; // value( Animal.Cat ) } \end{lstlisting} @@ -851,5 +911,5 @@ enum RGB( int ) { Red=0, Green=1, Blue=2 }; with ( Color, RGB ) { - // int red = Red; + // int red = Red; } \end{lstlisting} @@ -865,4 +925,44 @@ The declaration \CFA-enumeration variable has the same syntax as the C-enumeration. Internally, such a variable will be represented as an EnumInstType. +\section{Related Work} + +Enumerations exist in many popular programming languages, e.g., Pascal, Ada, \Csharp, \CC, Go, Java, Modula-3, Rust, Swift, Python, and Algebraic data type in functional programming. +There are a large set of overlapping features for all the languages, but each language has its own unique restrictions and extensions. + +\subsection{Pascal} + +\subsection{Ada} + +\subsection{\Csharp} + +\subsection{\CC} + +Because \CC is backwards compatible with C, it inherited C's enumerations, except there is no implicit conversion from an integral value to an enumeration; +hence, the values in a \CC enumeration can only be its enumerators. + +\CC{11} extended enumeration with a scoped enumeration, \lstinline[language=c++]{enum class} (or \lstinline[language=c++]{enum struct}), where the enumerators are local to the enumeration and are accessed using type qualification, e.g., @Weekday::Monday@. +\CC{20} supports unscoped access with a \lstinline[language=c++]{using enum} declaration. + +For both unscoped and scoped enumerations, the underlying type is an implementation-defined integral type that is large enough to hold all enumerated values; it does not have to be the smallest possible type. +The underlying integral type can be explicitly specified: +\begin{lstlisting}[language=c++,{moredelim=**[is][\color{red}]{@}{@}}] +enum class RGB : @long@ { Red, Green, Blue }; +enum class rgb : @char@ { Red = 'r', Green = 'g', Blue = 'b' }; +enum class srgb : @signed char@ { Red = -1, Green = 0, Blue = 1 }; +\end{lstlisting} + +\subsection{Go} + +\subsection{Java} + +\subsection{Modula-3} + +\subsection{Rust} + +\subsection{Swift} + +\subsection{Python} + +\subsection{Algebraic Data Type} \end{document} Index: doc/uC++toCFA/Makefile =================================================================== --- doc/uC++toCFA/Makefile (revision c75b30ae4d3f97678f27275a033614f675b7fdaf) +++ doc/uC++toCFA/Makefile (revision 32490deb2180d977e78b79e5c2342a8fa2357a53) @@ -8,5 +8,5 @@ BibTeX = BIBINPUTS=../bibliography: && export BIBINPUTS && bibtex -MAKEFLAGS = --no-print-directory --silent # +MAKEFLAGS = --no-print-directory # --silent VPATH = ${Build} ${Figures} Index: doc/uC++toCFA/uC++toCFA.tex =================================================================== --- doc/uC++toCFA/uC++toCFA.tex (revision c75b30ae4d3f97678f27275a033614f675b7fdaf) +++ doc/uC++toCFA/uC++toCFA.tex (revision 32490deb2180d977e78b79e5c2342a8fa2357a53) @@ -11,6 +11,6 @@ %% Created On : Wed Apr 6 14:53:29 2016 %% Last Modified By : Peter A. Buhr -%% Last Modified On : Sun Oct 15 23:09:58 2023 -%% Update Count : 5926 +%% Last Modified On : Thu Jan 11 14:46:14 2024 +%% Update Count : 5942 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% @@ -428,5 +428,5 @@ \begin{uC++} struct S { - int i = 0; + int i = 0; // cheat, implicit default constructor int setter( int j ) { int t = i; i = j; return t; } int getter() { return i; } @@ -434,5 +434,5 @@ S s; -@s.@setter( 3 ); // object-oriented call +@s.@setter( 3 ); // object-oriented calls int k = @s.@getter(); \end{uC++} @@ -442,9 +442,9 @@ int i; }; -void ?{}( S & s ) { s.i = 0; } +void ?{}( S & s ) { s.i = 0; } // explicit default constructor int setter( @S & s,@ int j ) @with(s)@ { int t = i; i = j; return t; } int getter( @S & s@ ) @with(s)@ { return i; } S s; -setter( @s,@ 3 ); // normal routine call +setter( @s,@ 3 ); // normal routine calls int k = getter( @s@ ); \end{cfa} @@ -458,32 +458,30 @@ \begin{tabular}{l|l} \begin{uC++} + struct S { int i; - S( int i ) { S::i = i; cout << S::i << endl; } -}; -@uNoCtor@ s[10]; + S( int i ) { S::i = i; cout << "ctor " << S::i << endl; } + ~S() { S::i = i; cout << "dtor " << S::i << endl; } +}; int main() { - for ( int i = 0; i < 10; i += 1 ) { - s[i].ctor( i ); - } - for ( int i = 0; i < 10; i += 1 ) { - cout << s[i]@->@i << endl; - } -} -\end{uC++} -& -\begin{cfa} + enum { N = 5 }; + @uNoCtor@ s[N]; // no constructor calls + for ( int i = 0; i < N; i += 1 ) @s[i].ctor( i )@; + for ( int i = 0; i < N; i += 1 ) cout << s[i]@->@i << endl; +} +\end{uC++} +& +\begin{cfa} +#include @@ // uninit struct S { int i; }; -void ?{}( S & s, int i ) { s.i = i; sout | s.i; } -S s[10] @$\color{red}@$= {}@; +void ?{}( S & s, int i ) { s.i = i; sout | "ctor" | s.i; } +void ^?{}( S & s ) { sout | "dtor" | s.i; } int main() { - for ( i; 10 ) { - ?{}( s[i], i ); // call constructor - } - for ( i; 10 ) { - sout | s[i]@.@i; // dot not arrow - } + enum { N = 5 }; + @uninit(S)@ s[N]; // no constructor calls + for ( i; N ) @s[i]{ i }@; + for ( i; N ) sout | s[i]@.@i; } \end{cfa} Index: doc/user/user.tex =================================================================== --- doc/user/user.tex (revision c75b30ae4d3f97678f27275a033614f675b7fdaf) +++ doc/user/user.tex (revision 32490deb2180d977e78b79e5c2342a8fa2357a53) @@ -11,6 +11,6 @@ %% Created On : Wed Apr 6 14:53:29 2016 %% Last Modified By : Peter A. Buhr -%% Last Modified On : Sun Jan 14 17:27:41 2024 -%% Update Count : 5764 +%% Last Modified On : Tue Jan 30 09:02:41 2024 +%% Update Count : 6046 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% @@ -46,4 +46,5 @@ %\input{common} % common CFA document macros \usepackage[dvips,plainpages=false,pdfpagelabels,pdfpagemode=UseNone,colorlinks=true,pagebackref=true,linkcolor=blue,citecolor=blue,urlcolor=blue,pagebackref=true,breaklinks=true]{hyperref} +\urlstyle{sf} \usepackage{breakurl} @@ -163,5 +164,5 @@ \Index*[C++]{\CC{}}~\cite{c++:v1} had a similar goal 30 years ago, allowing object-oriented programming to be incrementally added to C. -However, \CC currently has the disadvantages of a strong object-oriented bias, multiple legacy design-choices that are difficult to update, and active divergence of the language model from C, requiring significant effort and training to incrementally add \CC to a C-based project. +However, \CC currently has the disadvantages of a strong object-oriented bias, multiple legacy design-choices that are difficult to update, and active divergence of the language model from C, requiring significant effort and training to incrementally add \CC to a C code-base. In contrast, \CFA has 30 years of hindsight and a clean starting point. @@ -200,4 +201,5 @@ \end{center} While \CFA I/O \see{\VRef{s:StreamIOLibrary}} looks similar to \Index*[C++]{\CC{}}, there are important differences, such as automatic spacing between variables and an implicit newline at the end of the expression list, similar to \Index*{Python}~\cite{Python}. +In general, \CFA programs are 10\% to 30\% shorter than their equivalent C/\CC counterparts. @@ -218,5 +220,5 @@ Even with all its problems, C continues to be popular because it allows writing software at virtually any level in a computer system without restriction. For system programming, where direct access to hardware, storage management, and real-time issues are a requirement, C is the only language of choice. -The TIOBE index~\cite{TIOBE} for February 2021 ranks the top six most \emph{popular} programming languages as C 17.4\%, \Index*{Java} 12\%, Python 12\%, \Index*[C++]{\CC{}} 7.6\%, \Csharp 4\%, Visual Basic 3.8\% = 56.8\%, where the next 50 languages are less than 2\% each, with a long tail. +The TIOBE index~\cite{TIOBE} for February 2023 ranks the top six most \emph{popular} programming languages as C 17.4\%, \Index*{Java} 12\%, Python 12\%, \Index*[C++]{\CC{}} 7.6\%, \Csharp 4\%, Visual Basic 3.8\% = 56.8\%, where the next 50 languages are less than 2\% each, with a long tail. The top 4 rankings over the past 35 years are: \begin{center} @@ -238,5 +240,5 @@ however, it largely extended the C language, and did not address many of C's existing problems.\footnote{% Two important existing problems addressed were changing the type of character literals from ©int© to ©char© and enumerator from ©int© to the type of its enumerators.} -\Index*{Fortran}~\cite{Fortran08}, \Index*{Cobol}~\cite{Cobol14}, and \Index*{Ada}~\cite{Ada12} are examples of programming languages that took an evolutionary approach, where modern language-features (\eg objects, concurrency) are added and problems fixed within the framework of the existing language. +\Index*{Fortran}~\cite{Fortran08}, \Index*{Cobol}~\cite{Cobol14}, and \Index*{Ada}~\cite{Ada16} are examples of programming languages that took an evolutionary approach, where modern language-features (\eg objects, concurrency) are added and problems fixed within the framework of the existing language. \Index*{Java}~\cite{Java8}, \Index*{Go}~\cite{Go}, \Index*{Rust}~\cite{Rust} and \Index*{D}~\cite{D} are examples of the revolutionary approach for modernizing C/\CC, resulting in a new language rather than an extension of the descendent. These languages have different syntax and semantics from C, do not interoperate directly with C, and are not systems languages because of restrictive memory-management or garbage collection. @@ -263,5 +265,5 @@ % extending the C type system with parametric polymorphism and overloading, as opposed to the \Index*[C++]{\CC{}} approach of object-oriented extensions. \CFA{}\hspace{1pt}'s polymorphism was originally formalized by \Index*{Glen Ditchfield}\index{Ditchfield, Glen}~\cite{Ditchfield92}, and first implemented by \Index*{Richard Bilson}\index{Bilson, Richard}~\cite{Bilson03}. -However, at that time, there was little interesting in extending C, so work did not continue. +However, at that time, there was little interest in extending C, so work did not continue. As the saying goes, ``\Index*{What goes around, comes around.}'', and there is now renewed interest in the C programming language because of the legacy code-base, so the \CFA project was restarted in 2015. @@ -272,5 +274,5 @@ \CFA is designed to integrate directly with existing C programs and libraries. The most important feature of \Index{interoperability} is using the same \Index{calling convention}s, so there is no complex interface or overhead to call existing C routines. -This feature allows \CFA programmers to take advantage of the existing panoply of C libraries to access thousands of external software features. +This feature allows \CFA programmers to take advantage of the existing panoply of C libraries to access thousands of software features. Language developers often state that adequate \Index{library support} takes more work than designing and implementing the language itself. Fortunately, \CFA, like \Index*[C++]{\CC{}}, starts with immediate access to all exiting C libraries, and in many cases, can easily wrap library routines with simpler and safer interfaces, at zero or very low cost. @@ -320,16 +322,16 @@ However, it is necessary to differentiate between C and \CFA code because of name \Index{overload}ing, as for \CC. For example, the C math-library provides the following routines for computing the absolute value of the basic types: ©abs©, ©labs©, ©llabs©, ©fabs©, ©fabsf©, ©fabsl©, ©cabsf©, ©cabs©, and ©cabsl©. -Whereas, \CFA wraps each of these routines into one overloaded name ©abs©: -\begin{cfa} -char ®abs®( char ); -extern "C" { int ®abs®( int ); } §\C{// use default C routine for int}§ -long int ®abs®( long int ); -long long int ®abs®( long long int ); -float ®abs®( float ); -double ®abs®( double ); -long double ®abs®( long double ); -float _Complex ®abs®( float _Complex ); -double _Complex ®abs®( double _Complex ); -long double _Complex ®abs®( long double _Complex ); +Whereas, \CFA wraps these routines into one overloaded name ©abs©: +\begin{cfa} +unsigned char ®abs®( signed char ); §\C[3.5in]{// no C equivalent}§ +extern "C" { int ®abs®( int ); } §\C{// C abs}§ +unsigned long int ®abs®( long int ); §\C{// C labs}§ +unsigned long long int ®abs®( long long int ); §\C{// C llabs}§ +float ®abs®( float ); §\C{// C fabsf}§ +double ®abs®( double ); §\C{// C fabs}§ +long double ®abs®( long double ); §\C{// C fabsl}§ +float _Complex ®abs®( float _Complex ); §\C{// C cabsf}§ +double _Complex ®abs®( double _Complex ); §\C{// C cabs}§ +long double _Complex ®abs®( long double _Complex ); §\C{// C cabsl}\CRT§ \end{cfa} The problem is a \Index{name clash} between the C name ©abs© and the \CFA names ©abs©, resulting in two name linkages\index{C linkage}: ©extern "C"© and ©extern "Cforall"© (default). @@ -339,10 +341,14 @@ This example illustrates a core idea in \CFA: \emph{the \Index{power of a name}}. -The name ``©abs©'' evokes the notion of absolute value, and many mathematical types provide the notion of absolute value. -Hence, knowing the name ©abs© is sufficient to apply it to any type where it is applicable. +The name ``©abs©'' evokes the notion of absolute value and many mathematical types provide the notion of absolute value. +Hence, knowing the name ©abs© is sufficient to apply it to any applicable type. The time savings and safety of using one name uniformly versus $N$ unique names cannot be underestimated. \section{\CFA Compilation} + +\CFA is a \newterm{transpiler}, meaning it reads in a programming language (\CFA) as input and generates another programming language (C) as output, whereas a \newterm{compiler} reads in a programming language and generates assembler/machine code. +Hence, \CFA is like the C preprocessor modifying a program and sending it on to another step for further transformation. +The order of transformation is C preprocessor, \CFA, and finally GNU C compiler, which also has a number of transformation steps, such as assembler and linker. The command ©cfa© is used to compile a \CFA program and is based on the \Index{GNU} \Indexc{gcc} command, \eg: @@ -444,8 +450,8 @@ which conditionally includes the correct header file, if the program is compiled using \Indexc{gcc} or \Indexc{cfa}. -The \CFA translator has multiple steps. -The following flags control how the translator works, the stages run, and printing within a stage. +The \CFA \Index{transpiler} has multiple internal steps. +The following flags control how the \CFA transpiler works, the stages run, and printing within a stage. The majority of these flags are used by \CFA developers, but some are occasionally useful to programmers. -Each option must be escaped with \Indexc{-XCFA}\index{translator option!-XCFA@{©-XCFA©}} to direct it to the compiler step, similar to the ©-Xlinker© flag for the linker, \eg: +Each option must be escaped with \Indexc{-XCFA}\index{transpiler option!-XCFA@{©-XCFA©}} to direct it to the \CFA compilation step, similar to the ©-Xlinker© flag for the linker, \eg: \begin{lstlisting}[language=sh] cfa §test§.cfa -CFA -XCFA -p # print translated code without printing the standard prelude @@ -458,73 +464,73 @@ \begin{description}[topsep=5pt,itemsep=0pt,parsep=0pt] \item -\Indexc{-c}\index{translator option!-c@{©-c©}}, \Indexc{--colors}\index{translator option!--colors@{©--colors©}} \, diagnostic color: ©never©, ©always©, \lstinline[deletekeywords=auto]{auto} -\item -\Indexc{-g}\index{translator option!-g@{©-g©}}, \Indexc{--gdb}\index{translator option!--gdb@{©--gdb©}} \, wait for gdb to attach -\item -\Indexc{-h}\index{translator option!-h@{©-h©}}, \Indexc{--help}\index{translator option!--help@{©--help©}} \, print translator help message -\item -\Indexc{-i}\index{translator option!-i@{©-i©}}, \Indexc{--invariant}\index{translator option!--invariant@{©--invariant©}} \, invariant checking during AST passes -\item -\Indexc{-l}\index{translator option!-l@{©-l©}}, \Indexc{--libcfa}\index{translator option!--libcfa@{©--libcfa©}} \, generate ©libcfa.c© -\item -\Indexc{-L}\index{translator option!-L@{©-L©}}, \Indexc{--linemarks}\index{translator option!--linemarks@{©--linemarks©}} \, generate line marks -\item -\Indexc{-m}\index{translator option!-m@{©-m©}}, \Indexc{--no-main}\index{translator option!--no-main@{©--no-main©}} \, do not replace main -\item -\Indexc{-N}\index{translator option!-N@{©-N©}}, \Indexc{--no-linemarks}\index{translator option!--no-linemarks@{©--no-linemarks©}} \, do not generate line marks -\item -\Indexc{-n}\index{translator option!-n@{©-n©}}, \Indexc{--no-prelude}\index{translator option!--no-prelude@{©--no-prelude©}} \, do not read prelude -\item -\Indexc{-p}\index{translator option!-p@{©-p©}}, \Indexc{--prototypes}\index{translator option!--prototypes@{©--prototypes©}} \, do not generate prelude prototypes $\Rightarrow$ prelude not printed -\item -\Indexc{-d}\index{translator option!-d@{©-d©}}, \Indexc{--deterministic-out}\index{translator option!--deterministic-out@{©--deterministic-out©}} \, only print deterministic output -\item -\Indexc{-P}\index{translator option!-P@{©-P©}}, \Indexc{--print}\index{translator option!--print@{©--print©}} \, one of: +\Indexc{-c}\index{transpiler option!-c@{©-c©}}, \Indexc{--colors}\index{transpiler option!--colors@{©--colors©}} \, diagnostic color: ©never©, ©always©, \lstinline[deletekeywords=auto]{auto} +\item +\Indexc{-g}\index{transpiler option!-g@{©-g©}}, \Indexc{--gdb}\index{transpiler option!--gdb@{©--gdb©}} \, wait for gdb to attach +\item +\Indexc{-h}\index{transpiler option!-h@{©-h©}}, \Indexc{--help}\index{transpiler option!--help@{©--help©}} \, print transpiler help message +\item +\Indexc{-i}\index{transpiler option!-i@{©-i©}}, \Indexc{--invariant}\index{transpiler option!--invariant@{©--invariant©}} \, invariant checking during AST passes +\item +\Indexc{-l}\index{transpiler option!-l@{©-l©}}, \Indexc{--libcfa}\index{transpiler option!--libcfa@{©--libcfa©}} \, generate ©libcfa.c© +\item +\Indexc{-L}\index{transpiler option!-L@{©-L©}}, \Indexc{--linemarks}\index{transpiler option!--linemarks@{©--linemarks©}} \, generate line marks +\item +\Indexc{-m}\index{transpiler option!-m@{©-m©}}, \Indexc{--no-main}\index{transpiler option!--no-main@{©--no-main©}} \, do not replace main +\item +\Indexc{-N}\index{transpiler option!-N@{©-N©}}, \Indexc{--no-linemarks}\index{transpiler option!--no-linemarks@{©--no-linemarks©}} \, do not generate line marks +\item +\Indexc{-n}\index{transpiler option!-n@{©-n©}}, \Indexc{--no-prelude}\index{transpiler option!--no-prelude@{©--no-prelude©}} \, do not read prelude +\item +\Indexc{-p}\index{transpiler option!-p@{©-p©}}, \Indexc{--prototypes}\index{transpiler option!--prototypes@{©--prototypes©}} \, do not generate prelude prototypes $\Rightarrow$ prelude not printed +\item +\Indexc{-d}\index{transpiler option!-d@{©-d©}}, \Indexc{--deterministic-out}\index{transpiler option!--deterministic-out@{©--deterministic-out©}} \, only print deterministic output +\item +\Indexc{-P}\index{transpiler option!-P@{©-P©}}, \Indexc{--print}\index{transpiler option!--print@{©--print©}} \, one of: \begin{description}[topsep=0pt,itemsep=0pt,parsep=0pt] \item -\Indexc{ascodegen}\index{translator option!-P@{©-P©}!©ascodegen©}\index{translator option!--print@{©-print©}!©ascodegen©} \, print AST as codegen rather than AST -\item -\Indexc{asterr}\index{translator option!-P@{©-P©}!©asterr©}\index{translator option!--print@{©-print©}!©asterr©} \, print AST on error -\item -\Indexc{declstats}\index{translator option!-P@{©-P©}!©declstats©}\index{translator option!--print@{©-print©}!©declstats©} \, print code property statistics -\item -\Indexc{parse}\index{translator option!-P@{©-P©}!©parse©}\index{translator option!--print@{©-print©}!©parse©} \, print yacc (parsing) debug information -\item -\Indexc{pretty}\index{translator option!-P@{©-P©}!©pretty©}\index{translator option!--print@{©-print©}!©pretty©} \, prettyprint for ©ascodegen© flag -\item -\Indexc{rproto}\index{translator option!-P@{©-P©}!©rproto©}\index{translator option!--print@{©-print©}!©rproto©} \, resolver-proto instance -\item -\Indexc{rsteps}\index{translator option!-P@{©-P©}!©rsteps©}\index{translator option!--print@{©-print©}!©rsteps©} \, print resolver steps -\item -\Indexc{ast}\index{translator option!-P@{©-P©}!©ast©}\index{translator option!--print@{©-print©}!©ast©} \, print AST after parsing -\item -\Indexc{excpdecl}\index{translator option!-P@{©-P©}!©excpdecl©}\index{translator option!--print@{©-print©}!©excpdecl©} \, print AST after translating exception decls -\item -\Indexc{symevt}\index{translator option!-P@{©-P©}!©symevt©}\index{translator option!--print@{©-print©}!©symevt©} \, print AST after symbol table events -\item -\Indexc{expralt}\index{translator option!-P@{©-P©}!©expralt©}\index{translator option!--print@{©-print©}!©expralt©} \, print AST after expressions alternatives -\item -\Indexc{valdecl}\index{translator option!-P@{©-P©}!©valdecl©}\index{translator option!--print@{©-print©}!©valdecl©} \, print AST after declaration validation pass -\item -\Indexc{bresolver}\index{translator option!-P@{©-P©}!©bresolver©}\index{translator option!--print@{©-print©}!©bresolver©} \, print AST before resolver step -\item -\Indexc{expranly}\index{translator option!-P@{©-P©}!©expranly©}\index{translator option!--print@{©-print©}!©expranly©} \, print AST after expression analysis -\item -\Indexc{ctordtor}\index{translator option!-P@{©-P©}!©ctordtor©}\index{translator option!--print@{©-print©}!©ctordtor©} \, print AST after ctor/dtor are replaced -\item -\Indexc{tuple}\index{translator option!-P@{©-P©}!©tuple©}\index{translator option!--print@{©-print©}!©tuple©} \, print AST after tuple expansion -\item -\Indexc{instgen}\index{translator option!-P@{©-P©}!©instgen©}\index{translator option!--print@{©-print©}!©instgen©} \, print AST after instantiate generics -\item -\Indexc{bbox}\index{translator option!-P@{©-P©}!©bbox©}\index{translator option!--print@{©-print©}!©bbox©} \, print AST before box pass -\item -\Indexc{bcodegen}\index{translator option!-P@{©-P©}!©bcodegen©}\index{translator option!--print@{©-print©}!©bcodegen©} \, print AST before code generation +\Indexc{ascodegen}\index{transpiler option!-P@{©-P©}!©ascodegen©}\index{transpiler option!--print@{©-print©}!©ascodegen©} \, print AST as codegen rather than AST +\item +\Indexc{asterr}\index{transpiler option!-P@{©-P©}!©asterr©}\index{transpiler option!--print@{©-print©}!©asterr©} \, print AST on error +\item +\Indexc{declstats}\index{transpiler option!-P@{©-P©}!©declstats©}\index{transpiler option!--print@{©-print©}!©declstats©} \, print code property statistics +\item +\Indexc{parse}\index{transpiler option!-P@{©-P©}!©parse©}\index{transpiler option!--print@{©-print©}!©parse©} \, print yacc (parsing) debug information +\item +\Indexc{pretty}\index{transpiler option!-P@{©-P©}!©pretty©}\index{transpiler option!--print@{©-print©}!©pretty©} \, prettyprint for ©ascodegen© flag +\item +\Indexc{rproto}\index{transpiler option!-P@{©-P©}!©rproto©}\index{transpiler option!--print@{©-print©}!©rproto©} \, resolver-proto instance +\item +\Indexc{rsteps}\index{transpiler option!-P@{©-P©}!©rsteps©}\index{transpiler option!--print@{©-print©}!©rsteps©} \, print resolver steps +\item +\Indexc{ast}\index{transpiler option!-P@{©-P©}!©ast©}\index{transpiler option!--print@{©-print©}!©ast©} \, print AST after parsing +\item +\Indexc{excpdecl}\index{transpiler option!-P@{©-P©}!©excpdecl©}\index{transpiler option!--print@{©-print©}!©excpdecl©} \, print AST after translating exception decls +\item +\Indexc{symevt}\index{transpiler option!-P@{©-P©}!©symevt©}\index{transpiler option!--print@{©-print©}!©symevt©} \, print AST after symbol table events +\item +\Indexc{expralt}\index{transpiler option!-P@{©-P©}!©expralt©}\index{transpiler option!--print@{©-print©}!©expralt©} \, print AST after expressions alternatives +\item +\Indexc{valdecl}\index{transpiler option!-P@{©-P©}!©valdecl©}\index{transpiler option!--print@{©-print©}!©valdecl©} \, print AST after declaration validation pass +\item +\Indexc{bresolver}\index{transpiler option!-P@{©-P©}!©bresolver©}\index{transpiler option!--print@{©-print©}!©bresolver©} \, print AST before resolver step +\item +\Indexc{expranly}\index{transpiler option!-P@{©-P©}!©expranly©}\index{transpiler option!--print@{©-print©}!©expranly©} \, print AST after expression analysis +\item +\Indexc{ctordtor}\index{transpiler option!-P@{©-P©}!©ctordtor©}\index{transpiler option!--print@{©-print©}!©ctordtor©} \, print AST after ctor/dtor are replaced +\item +\Indexc{tuple}\index{transpiler option!-P@{©-P©}!©tuple©}\index{transpiler option!--print@{©-print©}!©tuple©} \, print AST after tuple expansion +\item +\Indexc{instgen}\index{transpiler option!-P@{©-P©}!©instgen©}\index{transpiler option!--print@{©-print©}!©instgen©} \, print AST after instantiate generics +\item +\Indexc{bbox}\index{transpiler option!-P@{©-P©}!©bbox©}\index{transpiler option!--print@{©-print©}!©bbox©} \, print AST before box pass +\item +\Indexc{bcodegen}\index{transpiler option!-P@{©-P©}!©bcodegen©}\index{transpiler option!--print@{©-print©}!©bcodegen©} \, print AST before code generation \end{description} \item \Indexc{--prelude-dir} \, prelude directory for debug/nodebug \item -\Indexc{-S}\index{translator option!-S@{©-S©}!©counters,heap,time,all,none©}, \Indexc{--statistics}\index{translator option!--statistics@{©--statistics©}!©counters,heap,time,all,none©} \, enable profiling information: ©counters©, ©heap©, ©time©, ©all©, ©none© -\item -\Indexc{-t}\index{translator option!-t@{©-t©}}, \Indexc{--tree}\index{translator option!--tree@{©--tree©}} build in tree +\Indexc{-S}\index{transpiler option!-S@{©-S©}!©counters,heap,time,all,none©}, \Indexc{--statistics}\index{transpiler option!--statistics@{©--statistics©}!©counters,heap,time,all,none©} \, enable profiling information: ©counters©, ©heap©, ©time©, ©all©, ©none© +\item +\Indexc{-t}\index{transpiler option!-t@{©-t©}}, \Indexc{--tree}\index{transpiler option!--tree@{©--tree©}} build in tree \end{description} @@ -540,6 +546,6 @@ \end{cfa} Existing C programs with keyword clashes can be converted by prefixing the keyword identifiers with double backquotes, and eventually the identifier name can be changed to a non-keyword name. -\VRef[Figure]{f:HeaderFileInterposition} shows how clashes in existing C header-files \see{\VRef{s:StandardHeaders}} can be handled using preprocessor \newterm{interposition}: ©#include_next© and ©-I filename©. -Several common C header-files with keyword clashes are fixed in the standard \CFA header-library, so there is a seamless programming-experience. +\VRef[Figure]{f:HeaderFileInterposition} shows how clashes in existing C header-files \see{\VRef{s:StandardHeaders}} can be handled using preprocessor \newterm{interposition}: ©#include_next© and command-line ©-I filename©. +Several common C header-files with keyword clashes are fixed in the standard \CFA header-library, so there is largely a seamless programming-experience. \begin{figure} @@ -591,17 +597,18 @@ the type suffixes ©U©, ©L©, \etc may start with an underscore ©1_U©, ©1_ll© or ©1.0E10_f©. \end{enumerate} -It is significantly easier to read and enter long constants when they are broken up into smaller groupings (many cultures use comma and/or period among digits for the same purpose). +It is significantly easier to read and enter long constants when they are broken up into smaller groupings (most cultures use comma and/or period among digits for the same purpose). This extension is backwards compatible, matches with the use of underscore in variable names, and appears in \Index*{Ada} and \Index*{Java} 8. \CC uses the single quote (©'©) as a separator, restricted within a sequence of digits, \eg ©0xaa©©'©©ff©, ©3.141©©'©©592E1©©'©©1©. +However, the drawback of the \CC approach is difficults parsing for IDEs between character and numeric constants, as quotes are no longer balanced (©'x'© and ©3.14©©'©©159©). \section{Exponentiation Operator} -C, \CC, and Java (and other programming languages) have no exponentiation operator\index{exponentiation!operator}\index{operator!exponentiation}, \ie $x^y$, and instead use a routine, like \Indexc{pow(x,y)}, to perform the exponentiation operation. +C, \CC, and Java (and other programming languages) have \emph{no} exponentiation operator\index{exponentiation!operator}\index{operator!exponentiation}, \ie $x^y$, and instead use a routine, like \Indexc{pow(x,y)}, to perform the exponentiation operation. \CFA extends the basic operators with the exponentiation operator ©?©\R{©\\©}©?©\index{?\\?@©?@\@?©} and ©?©\R{©\\©}©=?©\index{?\\=?@©@\@=?©}, as in, ©x ©\R{©\\©}© y© and ©x ©\R{©\\©}©= y©, which means $x^y$ and $x \leftarrow x^y$. The priority of the exponentiation operator is between the cast and multiplicative operators, so that ©w * (int)x \ (int)y * z© is parenthesized as ©(w * (((int)x) \ ((int)y))) * z©. There are exponentiation operators for integral and floating types, including the builtin \Index{complex} types. -Integral exponentiation\index{exponentiation!unsigned integral} is performed with repeated multiplication ($O(\log y)$ multiplies or shifting if the exponent is 2). +Integral exponentiation\index{exponentiation!unsigned integral} is performed with repeated multiplication ($O(\log y)$ or shifting if the exponent is 2). Overflow for a large exponent or negative exponent returns zero. Floating exponentiation\index{exponentiation!floating} is performed using \Index{logarithm}s\index{exponentiation!logarithm}, so the exponent cannot be negative. @@ -620,5 +627,5 @@ T ?®\®?( T ep, unsigned long int y ); \end{cfa} -A user type ©T© must define multiplication, one (©1©), and ©*©. +A user type ©T© must define one (©1©), and multiplication (©*©) \see{\VRef{s:Operator}}. @@ -631,5 +638,5 @@ \subsection{\texorpdfstring{\LstKeywordStyle{if} / \LstKeywordStyle{while} Statement}{if / while Statement}} -The \Indexc{if}/\Indexc{while} expression allows declarations, similar to \Indexc{for} declaration expression.\footnote{ +The \Indexc{if} and \Indexc{while} expressions are extended with declarations, similar to the \Indexc{for} declaration expression.\footnote{ Declarations in the \Indexc{do}-©while© condition are not useful because they appear after the loop body.} \begin{cfa} @@ -653,5 +660,5 @@ \label{s:caseClause} -C restricts a \Indexc{case} clause in \Indexc{switch} statement to a single value. +C restricts the \Indexc{case} clause in a \Indexc{switch} statement to a single value. For multiple ©case© clauses prefixing a statement within the ©switch© statement, it is necessary to have multiple ©case© clauses rather than multiple values. Requiring a ©case© clause for each value is not in the spirit of brevity normally associated with C. @@ -688,5 +695,5 @@ \end{tabular} \end{cquote} -In addition, subranges are allowed to specify case values. +In addition, subranges are allowed to specify a contiguous set of case values. \begin{cquote} \begin{tabular}{@{}l@{\hspace{3em}}l@{\hspace{2em}}l@{\hspace{2em}}l@{}} @@ -801,6 +808,7 @@ \end{cfa} This situation is better handled by a list of case values \see{\VRef{s:caseClause}}. -While fall-through itself is not a problem, the problem occurs when fall-through is the default, as this semantics is unintuitive to many programmers and is different from most programming languages with a ©switch© statement. -Hence, default fall-through semantics results in a many programming errors as programmers often \emph{forget} the ©break© statement at the end of a ©case© clause, resulting in inadvertent fall-through. + +While fall-through itself is not a problem, the problem occurs when fall-through is the default, as this semantics is unintuitive for many programmers and is different from most programming languages with a ©switch© statement. +Hence, default fall-through semantics results in programming errors as programmers often \emph{forget} the ©break© statement at the end of a ©case© clause, resulting in inadvertent fall-through. \item @@ -819,5 +827,4 @@ The technical problem results from the inability to ensure declaration and initialization of variables when blocks are not entered at the beginning. There are few arguments for this kind of control flow, and therefore, there is a strong impetus to eliminate it. - This C idiom is known as ``\Index*{Duff's device}''~\cite{Duff83}, from this example: \begin{cfa} @@ -996,4 +1003,17 @@ with the current \Indexc{switch}/\Indexc{choose} statement. + +\subsection{Loop Control} + +Looping a fixed number of times, possibly with a loop index, occurs frequently. +\CFA condenses simply looping to facilitate coding speed and safety~\see{examples in \VRef[Figure]{f:LoopControlExamples}}. + +The \Indexc{for}, \Indexc{while}, and \Indexc{do} loop-control are extended to allow an empty conditional, which implies a comparison value of ©1© (true). +\begin{cfa} +while ( ®/* empty */® ) §\C{// while ( true )}§ +for ( ®/* empty */® ) §\C{// for ( ; true; )}§ +do ... while ( ®/* empty */® ) §\C{// do ... while ( true )}§ +\end{cfa} + \begin{figure} \begin{tabular}{@{}l@{\hspace{50pt}}|l@{}} @@ -1003,5 +1023,5 @@ while () { sout | "empty"; break; } do { sout | "empty"; break; } while (); -for () { sout | "empty"; break; } §\C[3in]{sout | nl | nlOff;}§ +for () { sout | "empty"; break; } §\C{sout | nl | nlOff;}§ for ( 0 ) { sout | "A"; } sout | "zero"; §\C{sout | nl;}§ @@ -1045,5 +1065,5 @@ for ( i; 5 : j; @ -~ -5 ~ 2 : k; 1.5 ~ @ ) { sout | i | j | k; } §\C{sout | nl;}§ for ( i; 5 : j; @ -~ -5 ~ 2 : k; 1.5 ~ @ ) { sout | i | j | k; } §\C{sout | nl;}§ -for ( i; 5 : k; 1.5 ~ @ : j; @ -~ -5 ~ 2 ) { sout | i | j | k; } §\C{sout | nl;}\CRT§ +for ( i; 5 : k; 1.5 ~ @ : j; @ -~ -5 ~ 2 ) { sout | i | j | k; } §\C{sout | nl;}§ \end{cfa} & @@ -1108,18 +1128,5 @@ % for ( T i ; 3~9 ) => for ( T i = 3 ; i < 9; i += 1 ) // using 1 - -\subsection{Loop Control} - -Looping a fixed number of times, possibly with a loop index, occurs frequently. -\CFA condenses simply looping to facilitate coding speed and safety~\see{examples in \VRef[Figure]{f:LoopControlExamples}}. - -The \Indexc{for}, \Indexc{while}, and \Indexc{do} loop-control allow an empty conditional, which implies a comparison value of ©1© (true). -\begin{cfa} -while ( ®/* empty */® ) §\C{// while ( true )}§ -for ( ®/* empty */® ) §\C{// for ( ; true; )}§ -do ... while ( ®/* empty */® ) §\C{// do ... while ( true )}§ -\end{cfa} - -The ©for© control has 4 new loop-control operators that are not overloadable: +The ©for© control is extended with 4 new loop-control operators, which are not overloadable: \begin{description}[itemsep=0pt,parsep=0pt] \item @@ -1195,5 +1202,5 @@ Similarly, the high value cannot be elided is an anonymous loop index (©1 ~ @©), as there is no index to stop the loop. \item -©:© means low another index. +©:© means add another index. \begin{cfa} for ( i; 5 ®:® j; 2 ~ 12 ~ 3 ) §\C{// for ( typeof(i) i = 1, j = 2; i < 5 \&\& j < 12; i += 1, j += 3 )}§ @@ -1212,5 +1219,5 @@ \subsection{\texorpdfstring{Labelled \LstKeywordStyle{continue} / \LstKeywordStyle{break} Statement}{Labelled continue / break Statement}} -C \Indexc{continue} and \Indexc{break} statements, for altering control flow, are restricted to one level of nesting for a particular control structure. +C \Indexc{continue} and \Indexc{break} statements are restricted to one level of nesting for a particular control structure. This restriction forces programmers to use \Indexc{goto} to achieve the equivalent control-flow for more than one level of nesting. To prevent having to switch to the ©goto©, \CFA extends the \Indexc{continue}\index{continue@©continue©!labelled}\index{labelled!continue@©continue©} and \Indexc{break}\index{break@©break©!labelled}\index{labelled!break@©break©} with a target label to support static multi-level exit\index{multi-level exit}\index{static multi-level exit}~\cite{Buhr85}, as in Java. @@ -1302,5 +1309,5 @@ Furthermore, the location of the label at the \emph{beginning} of the target control structure informs the reader (\Index{eye candy}) that complex control-flow is occurring in the body of the control structure. With ©goto©, the label is at the end of the control structure, which fails to convey this important clue early enough to the reader. -Finally, using an explicit target for the transfer instead of an implicit target allows new constructs to be added or removed without affecting existing constructs. +Finally, using an explicit target for the transfer, instead of an implicit target, allows new constructs to be added or removed without affecting existing constructs. Otherwise, the implicit targets of the current ©continue© and ©break©, \ie the closest enclosing loop or ©switch©, change as certain constructs are added or removed. @@ -1373,11 +1380,11 @@ \begin{cfa} Person p -®p.®name; ®p.®address; ®p.®sex; §\C{// access containing fields}§ +®p.®name ...; ®p.®address ...; ®p.®sex ...; §\C{// access containing fields}§ \end{cfa} which extends to multiple levels of qualification for nested aggregates and multiple aggregates. \begin{cfa} struct Ticket { ... } t; -®p.name®.first; ®p.address®.street; §\C{// access nested fields}§ -®t.®departure; ®t.®cost; §\C{// access multiple aggregate}§ +®p.name®.first ...; ®p.address®.street ...; §\C{// access nested fields}§ +®t.®departure ...; ®t.®cost ...; §\C{// access multiple aggregate}§ \end{cfa} Repeated aggregate qualification is tedious and makes code difficult to read. @@ -1558,5 +1565,5 @@ -\section{Non-local Exception} +\subsection{Non-local Exception} \begin{cfa} @@ -2347,20 +2354,38 @@ \subsection{Implicit String Conversions} -The types ©char©, ©char *©, ©int©, ©double©, ©_Complex©, including signness and different sizes, implicitly convert to type ©string©. -\VRef[Figure]{f:ImplicitStringConversions} shows examples of implicit conversion between C strings, integral, floating-point and complex types to ©string© -The implicit conversions can be specified explicitly, as in: -\begin{cfa} -s = string( "abc" ); // converts char * to string -s = string( 5 ); // converts int to string -s = string( 5.5 ); // converts double to string -\end{cfa} -Conversions from ©string© to ©char *© are supported but with restrictions. -Explicit As well, when a string is converted to a ©char *©, the storage for the ©char *© is created by the conversion operation, which must be subsequently deleted: -\begin{cfa} -string x = "abc"; -char *p = x; // convert from string to char * -... -delete p; // free storage created for p -\end{cfa} +The types ©char©, ©char *©, ©int©, ©double©, ©_Complex©, including different signness and sizes, implicitly convert to type ©string©. +\VRef[Figure]{f:ImplicitConversionsString} shows examples of implicit conversions between C strings, integral, floating-point and complex types to ©string©. +A conversions can be explicitly specified: +\begin{cfa} +s = string( "abc" ); §\C{// converts char * to string}§ +s = string( 5 ); §\C{// converts int to string}§ +s = string( 5.5 ); §\C{// converts double to string}§ +\end{cfa} +All conversions from ©string© to ©char *©, attempt to be safe: +either by requiring the maximum length of the ©char *© storage (©strncpy©) or allocating the ©char *© storage for the string characters (ownership), meaning the programmer must free the storage. +As well, a string is always null terminates, implying a minimum size of 1 character. +\begin{cquote} +\begin{tabular}{@{}l@{\hspace{1.75in}}|@{\hspace{15pt}}l@{}} +\begin{cfa} +string s = "abcde"; +char cs[3]; +strncpy( cs, s, sizeof(cs) ); §\C{sout | cs;}§ +char * cp = s; §\C{sout | cp;}§ +delete( cp ); +cp = s + ' ' + s; §\C{sout | cp;}§ +delete( cp ); +\end{cfa} +& +\begin{cfa} + + +ab +abcde + +abcde abcde + +\end{cfa} +\end{tabular} +\end{cquote} \begin{figure} @@ -2370,23 +2395,17 @@ string s; // conversion of char and char * to string - s = 'x'; §\CD{sout | s;}§ - s = "abc"; §\CD{sout | s;}§ + s = 'x'; §\C{sout | s;}§ + s = "abc"; §\C{sout | s;}§ char cs[5] = "abc"; - s = cs; §\CD{sout | s;}§ + s = cs; §\C{sout | s;}§ // conversion of integral, floating-point, and complex to string - s = 45hh; §\CD{sout | s;}§ - s = 45h; §\CD{sout | s;}§ - s = -(ssize_t)MAX - 1; §\CD{sout | s;}§ - s = (size_t)MAX; §\CD{sout | s;}§ - s = 5.5; §\CD{sout | s;}§ - s = 5.5L; §\CD{sout | s;}§ - s = 5.5+3.4i; §\CD{sout | s;}§ - s = 5.5L+3.4Li; §\CD{sout | s;}§ - // safe conversion from string to char * - strncpy( cs, s, sizeof(cs) ); §\CD{sout | cs;}§ - char * cp = s; §\CD{sout | cp; // ownership}§ - delete( cp ); - cp = s + ' ' + s; §\CD{sout | cp; // ownership}§ - delete( cp ); + s = 45hh; §\C{sout | s;}§ + s = 45h; §\C{sout | s;}§ + s = -(ssize_t)MAX - 1; §\C{sout | s;}§ + s = (size_t)MAX; §\C{sout | s;}§ + s = 5.5; §\C{sout | s;}§ + s = 5.5L; §\C{sout | s;}§ + s = 5.5+3.4i; §\C{sout | s;}§ + s = 5.5L+3.4Li; §\C{sout | s;}§ \end{cfa} & @@ -2408,79 +2427,66 @@ 5.5+3.4i 5.5+3.4i - -5.5+ -5.5+3.4i - -5.5+3.4i 5.5+3.4i - \end{cfa} \end{tabular} -\caption{Implicit String Conversions} -\label{f:ImplicitStringConversions} +\caption{Implicit Conversions to String} +\label{f:ImplicitConversionsString} \end{figure} +\subsection{Size (length)} + +The ©size© operation returns the length of a string. +\begin{cfa} +i = size( "" ); §\C{// i is assigned 0}§ +i = size( "abc" ); §\C{// i is assigned 3}§ +i = size( peter ); §\C{// i is assigned 5}§ +\end{cfa} + + \subsection{Comparison Operators} -The binary relational and equality operators ©<©, ©<=©, ©>©, ©>=©, ©==©, ©!=© compare ©string© using lexicographical ordering, where longer strings are greater than shorter strings. +The binary \Index{relational operator}s, ©<©, ©<=©, ©>©, ©>=©, and \Index{equality operator}s, ©==©, ©!=©, compare strings using lexicographical ordering, where longer strings are greater than shorter strings. \subsection{Concatenation} -The binary operator ©+© concatenates two strings. -\begin{cfa} -s = peter + digit; §\C{// s is assigned "PETER0123456789"}§ -s += peter; §\C{// s is assigned "PETER0123456789PETER"}§ -\end{cfa} -There is also an assignment form ©+=©. +The binary operators \Indexc{+} and \Indexc{+=} concatenate two strings, creating the sum of the strings. +\begin{cfa} +s = peter + ' ' + digit; §\C{// s is assigned "PETER 0123456789"}§ +s += peter; §\C{// s is assigned "PETER 0123456789PETER"}§ +\end{cfa} \subsection{Repetition} -The binary operator \Indexc{*} returns a string that is the string repeated ©n© times. -If ©n = 0©, a zero length string, ©""© is returned. -\begin{cfa} -s = (peter + ' ') * 3; §\C{// s is assigned "PETER PETER PETER"}§ -\end{cfa} -There is also an assignment form ©*=©. - - -\subsection{Length} - -The ©length© operation -\begin{cfa} -int length() -\end{cfa} -returns the length of a string variable. -\begin{cfa} -i = peter.length(); §\C{// i is assigned the value 5}§ +The binary operators \Indexc{*} and \Indexc{*=} repeat a string $N$ times. +If $N = 0$, a zero length string, ©""© is returned. +\begin{cfa} +s = 'x' * 3; §\C{// s is assigned "PETER PETER PETER "}§ +s = (peter + ' ') * 3; §\C{// s is assigned "PETER PETER PETER "}§ \end{cfa} \subsection{Substring} -The substring operation: -\begin{cfa} -string operator () (int start, int lnth); -\end{cfa} -performs a substring operation that returns the string starting at a specified position (©start©) in the current string, and having the specified length (©lnth©). +The substring operation returns a subset of the string starting at a position in the string and traversing a length. +\begin{cfa} +s = peter( 2, 3 ); §\C{// s is assigned "ETE"}§ +s = peter( 4, -3 ); §\C{// s is assigned "ETE", length is opposite direction}§ +s = peter( 2, 8 ); §\C{// s is assigned "ETER", length is clipped to 4}§ +s = peter( 0, -1 ); §\C{// s is assigned "", beyond string so clipped to null}§ +s = peter(-1, -1 ); §\C{// s is assigned "R", start and length are negative}§ +\end{cfa} A negative starting position is a specification from the right end of the string. A negative length means that characters are selected in the opposite (right to left) direction from the starting position. If the substring request extends beyond the beginning or end of the string, it is clipped (shortened) to the bounds of the string. If the substring request is completely outside of the original string, a null string located at the end of the original string is returned. -\begin{cfa} -s = peter( 2, 3 ); §\C{// s is assigned "ETE"}§ -s = peter( 4, -3 ); §\C{// s is assigned "ETE", length is opposite direction}§ -s = peter( 2, 8 ); §\C{// s is assigned "ETER", length is clipped to 4}§ -s = peter( 0, -1 ); §\C{// s is assigned "", beyond string so clipped to null}§ -s = peter(-1, -1 ); §\C{// s is assigned "R", start and length are negative}§ -\end{cfa} The substring operation can also appear on the left hand side of the assignment operator. The substring is replaced by the value on the right hand side of the assignment. The length of the right-hand-side value may be shorter, the same length, or longer than the length of the substring that is selected on the left hand side of the assignment. -\begin{cfa}[mathescape=false] -digit( 3, 3 ) = ""; §\C{// digit is assigned "0156789"}§ -digit( 4, 3 ) = "xyz"; §\C{// digit is assigned "015xyz9"}§ -digit( 7, 0 ) = "***"; §\C{// digit is assigned "015xyz***9"}§ -digit(-4, 3 ) = "$$$"; §\C{// digit is assigned "015xyz\$\$\$9"}§ +\begin{cfa} +digit( 3, 3 ) = ""; §\C{// digit is assigned "0156789"}§ +digit( 4, 3 ) = "xyz"; §\C{// digit is assigned "015xyz9"}§ +digit( 7, 0 ) = "***"; §\C{// digit is assigned "015xyz***9"}§ +digit(-4, 3 ) = "$$$"; §\C{// digit is assigned "015xyz\$\$\$9"}§ \end{cfa} A substring is treated as a pointer into the base (substringed) string rather than creating a copy of the subtext. @@ -2501,12 +2507,12 @@ // e is a substring result passed by value void test(string &x, string &a, string &b, string &c, string &d, string e) { - §\C{// x a b c d e}§ - a( 1, 2 ) = "aaa"; §\C{// aaaxxxxxxxxxxx aaax axx xxxxx xxxxx xxxxx}§ - b( 2, 12 ) = "bbb"; §\C{// aaabbbxxxxxxxxx aaab abbb bbxxx xxxxx xxxxx}§ - c( 4, 5 ) = "ccc"; §\C{// aaabbbxcccxxxxxx aaab abbb bbxccc ccxxx xxxxx}§ - c = "yyy"; §\C{// aaabyyyxxxxxx aaab abyy yyy xxxxx xxxxx}§ - d( 1, 3 ) = "ddd"; §\C{// aaabyyyxdddxx aaab abyy yyy dddxx xxxxx}§ - e( 1, 3 ) = "eee"; §\C{// aaabyyyxdddxx aaab abyy yyy dddxx eeexx}§ - x = e; §\C{// eeexx eeex exx x eeexx}§ + §\C{// x a b c d e}§ + a( 1, 2 ) = "aaa"; §\C{// aaaxxxxxxxxxxx aaax axx xxxxx xxxxx xxxxx}§ + b( 2, 12 ) = "bbb"; §\C{// aaabbbxxxxxxxxx aaab abbb bbxxx xxxxx xxxxx}§ + c( 4, 5 ) = "ccc"; §\C{// aaabbbxcccxxxxxx aaab abbb bbxccc ccxxx xxxxx}§ + c = "yyy"; §\C{// aaabyyyxxxxxx aaab abyy yyy xxxxx xxxxx}§ + d( 1, 3 ) = "ddd"; §\C{// aaabyyyxdddxx aaab abyy yyy dddxx xxxxx}§ + e( 1, 3 ) = "eee"; §\C{// aaabyyyxdddxx aaab abyy yyy dddxx eeexx}§ + x = e; §\C{// eeexx eeex exx x eeexx}§ } \end{cfa} @@ -2518,6 +2524,6 @@ For example: \begin{cfa} -s = peter( 2 ); §\C{// s is assigned "ETER"}§ -peter( 2 ) = "IPER"; §\C{// peter is assigned "PIPER"}§ +s = peter( 2 ); §\C{// s is assigned "ETER"}§ +peter( 2 ) = "IPER"; §\C{// peter is assigned "PIPER"}§ \end{cfa} It is also possible to substring using a string as the index for selecting the substring portion of the string. @@ -2527,8 +2533,7 @@ For example: \begin{cfa}[mathescape=false] -digit( "xyz$$$" ) = "678"; §\C{// digit is assigned "0156789"}§ -digit( "234") = "***"; §\C{// digit is assigned "0156789***"}§ -\end{cfa} -%$ +digit( "xyz$$$" ) = "678"; §\C{// digit is assigned "0156789"}§ +digit( "234") = "***"; §\C{// digit is assigned "0156789***"}§ +\end{cfa} @@ -2570,6 +2575,6 @@ A negative starting position is a specification from the right end of the string. \begin{cfa} -i = peter.include( digitmask ); §\C{// i is assigned 1}§ -i = peter.include( alphamask ); §\C{// i is assigned 6}§ +i = peter.include( digitmask ); §\C{// i is assigned 1}§ +i = peter.include( alphamask ); §\C{// i is assigned 6}§ \end{cfa} @@ -2622,7 +2627,7 @@ \begin{cfa} // remove leading blanks -s = string( " ABC" ).trim( " " ); §\C{// s is assigned "ABC",}§ +s = string( " ABC" ).trim( " " ); §\C{// s is assigned "ABC",}§ // remove trailing blanks -s = string( "ABC " ).trim( " ", last ); §\C{// s is assigned "ABC",}§ +s = string( "ABC " ).trim( " ", last ); §\C{// s is assigned "ABC",}§ \end{cfa} @@ -2651,11 +2656,10 @@ returns a string in which all occurrences of the ©from© string in the current string have been replaced by the ©to© string. \begin{cfa} -s = peter.replace( "E", "XX" ); §\C{// s is assigned "PXXTXXR"}§ +s = peter.replace( "E", "XX" ); §\C{// s is assigned "PXXTXXR"}§ \end{cfa} The replacement is done left-to-right. When an instance of the ©from© string is found and changed to the ©to© string, it is NOT examined again for further replacement. - -\section{Returning N+1 on Failure} +\subsection{Returning N+1 on Failure} Any of the string search routines can fail at some point during the search. @@ -2687,4 +2691,45 @@ +\subsection{C Compatibility} + +To ease conversion from C to \CFA, there are companion ©string© routines for C strings. +\VRef[Table]{t:CompanionStringRoutines} shows the C routines on the left that also work with ©string© and the rough equivalent ©string© opeation of the right. +Hence, it is possible to directly convert a block of C string operations into @string@ just by changing the + +\begin{table} +\begin{cquote} +\begin{tabular}{@{}l|l@{}} +\multicolumn{1}{c|}{©char []©} & \multicolumn{1}{c}{©string©} \\ +\hline +©strcpy©, ©strncpy© & ©=© \\ +©strcat©, ©strncat© & ©+© \\ +©strcmp©, ©strncmp© & ©==©, ©!=©, ©<©, ©<=©, ©>©, ©>=© \\ +©strlen© & ©size© \\ +©[]© & ©[]© \\ +©strstr© & ©find© \\ +©strcspn© & ©find_first_of©, ©find_last_of© \\ +©strspc© & ©find_fist_not_of©, ©find_last_not_of© +\end{tabular} +\end{cquote} +\caption{Companion Routines for \CFA \lstinline{string} to C Strings} +\label{t:CompanionStringRoutines} +\end{table} + +For example, this block of C code can be converted to \CFA by simply changing the type of variable ©s© from ©char []© to ©string©. +\begin{cfa} + char s[32]; + //string s; + strcpy( s, "abc" ); PRINT( %s, s ); + strncpy( s, "abcdef", 3 ); PRINT( %s, s ); + strcat( s, "xyz" ); PRINT( %s, s ); + strncat( s, "uvwxyz", 3 ); PRINT( %s, s ); + PRINT( %zd, strlen( s ) ); + PRINT( %c, s[3] ); + PRINT( %s, strstr( s, "yzu" ) ) ; + PRINT( %s, strstr( s, 'y' ) ) ; +\end{cfa} +However, the conversion fails with I/O because ©printf© cannot print a ©string© using format code ©%s© because \CFA strings are not null terminated. + + \subsection{Input/Output Operators} @@ -2707,8 +2752,8 @@ Hence, enums may be overloaded with variable, enum, and function names. \begin{cfa} -int Foo; §\C{// type/variable separate namespaces}§ +int Foo; §\C{// type/variable separate namespaces}§ enum Foo { Bar }; -enum Goo { Bar }; §\C[1.75in]{// overload Foo.Bar}§ -double Bar; §\C{// overload Foo.Bar, Goo.Bar}\CRT§ +enum Goo { Bar }; §\C{// overload Foo.Bar}§ +double Bar; §\C{// overload Foo.Bar, Goo.Bar}§ \end{cfa} An anonymous enumeration injects enums with specific values into a scope. @@ -2783,15 +2828,15 @@ The following examples illustrate the difference between the enumeration type and the type of its enums. \begin{cfa} -Math m = PI; §\C[1.5in]{// allowed}§ -double d = PI; §\C{// allowed, conversion to base type}§ -m = E; §\C{// allowed}§ -m = Alph; §\C{// {\color{red}disallowed}}§ -m = 3.141597; §\C{// {\color{red}disallowed}}§ -d = m; §\C{// allowed}§ -d = Alph; §\C{// {\color{red}disallowed}}§ -Letter l = A; §\C{// allowed}§ -Greek g = Alph; §\C{// allowed}§ -l = Alph; §\C{// allowed, conversion to base type}§ -g = A; §\C{// {\color{red}disallowed}}\CRT§ +Math m = PI; §\C{// allowed}§ +double d = PI; §\C{// allowed, conversion to base type}§ +m = E; §\C{// allowed}§ +m = Alph; §\C{// {\color{red}disallowed}}§ +m = 3.141597; §\C{// {\color{red}disallowed}}§ +d = m; §\C{// allowed}§ +d = Alph; §\C{// {\color{red}disallowed}}§ +Letter l = A; §\C{// allowed}§ +Greek g = Alph; §\C{// allowed}§ +l = Alph; §\C{// allowed, conversion to base type}§ +g = A; §\C{// {\color{red}disallowed}}§ \end{cfa} @@ -3362,7 +3407,7 @@ For example, consider C's \Indexc{div} function, which returns the quotient and remainder for a division of an integer value. \begin{cfa} -typedef struct { int quot, rem; } div_t; §\C[7cm]{// from include stdlib.h}§ +typedef struct { int quot, rem; } div_t; §\C{// from include stdlib.h}§ div_t div( int num, int den ); -div_t qr = div( 13, 5 ); §\C{// return quotient/remainder aggregate}§ +div_t qr = div( 13, 5 ); §\C{// return quotient/remainder aggregate}§ printf( "%d %d\n", qr.quot, qr.rem ); §\C{// print quotient/remainder}§ \end{cfa} @@ -3375,5 +3420,5 @@ For example, consider C's \Indexc{modf} function, which returns the integral and fractional part of a floating value. \begin{cfa} -double modf( double x, double * i ); §\C{// from include math.h}§ +double modf( double x, double * i ); §\C{// from include math.h}§ double intp, frac = modf( 13.5, &intp ); §\C{// return integral and fractional components}§ printf( "%g %g\n", intp, frac ); §\C{// print integral/fractional components}§ @@ -3404,8 +3449,8 @@ When a function call is passed as an argument to another call, the best match of actual arguments to formal parameters is evaluated given all possible expression interpretations in the current scope. \begin{cfa} -void g( int, int ); §\C{// 1}§ -void g( double, double ); §\C{// 2}§ -g( div( 13, 5 ) ); §\C{// select 1}§ -g( modf( 13.5 ) ); §\C{// select 2}§ +void g( int, int ); §\C{// 1}§ +void g( double, double ); §\C{// 2}§ +g( div( 13, 5 ) ); §\C{// select 1}§ +g( modf( 13.5 ) ); §\C{// select 2}§ \end{cfa} In this case, there are two overloaded ©g© routines. @@ -3416,8 +3461,8 @@ The previous examples can be rewritten passing the multiple returned-values directly to the ©printf© function call. \begin{cfa} -[ int, int ] div( int x, int y ); §\C{// from include stdlib}§ +[ int, int ] div( int x, int y ); §\C{// from include stdlib}§ printf( "%d %d\n", div( 13, 5 ) ); §\C{// print quotient/remainder}§ -[ double, double ] modf( double x ); §\C{// from include math}§ +[ double, double ] modf( double x ); §\C{// from include math}§ printf( "%g %g\n", modf( 13.5 ) ); §\C{// print integral/fractional components}§ \end{cfa} @@ -3430,6 +3475,6 @@ \begin{cfa} int quot, rem; -[ quot, rem ] = div( 13, 5 ); §\C{// assign multiple variables}§ -printf( "%d %d\n", quot, rem ); §\C{// print quotient/remainder}\CRT§ +[ quot, rem ] = div( 13, 5 ); §\C{// assign multiple variables}§ +printf( "%d %d\n", quot, rem ); §\C{// print quotient/remainder}§ \end{cfa} Here, the multiple return-values are matched in much the same way as passing multiple return-values to multiple parameters in a call. @@ -3848,7 +3893,7 @@ The general syntax of a lexical list is: \begin{cfa} -[ $\emph{exprlist}$ ] -\end{cfa} -where ©$\emph{exprlist}$© is a list of one or more expressions separated by commas. +[ §\emph{exprlist}§ ] +\end{cfa} +where \LstBasicStyle{\emph{exprlist}} is a list of one or more expressions separated by commas. The brackets, ©[]©, allow differentiating between lexical lists and expressions containing the C comma operator. The following are examples of lexical lists: @@ -3856,5 +3901,5 @@ [ x, y, z ] [ 2 ] -[ v+w, x*y, 3.14159, f() ] +[ v + w, x * y, 3.14159, f() ] \end{cfa} Tuples are permitted to contain sub-tuples (\ie nesting), such as ©[ [ 14, 21 ], 9 ]©, which is a 2-element tuple whose first element is itself a tuple. @@ -3868,12 +3913,12 @@ The general syntax of a tuple type is: \begin{cfa} -[ $\emph{typelist}$ ] -\end{cfa} -where ©$\emph{typelist}$© is a list of one or more legal \CFA or C type specifications separated by commas, which may include other tuple type specifications. +[ §\emph{typelist}§ ] +\end{cfa} +where \LstBasicStyle{\emph{typelist}} is a list of one or more legal \CFA or C type specifications separated by commas, which may include other tuple type specifications. Examples of tuple types include: \begin{cfa} [ unsigned int, char ] [ double, double, double ] -[ * int, int * ] §\C{// mix of CFA and ANSI}§ +[ * int, int * ] §\C{// mix of CFA and ANSI}§ [ * [ 5 ] int, * * char, * [ [ int, int ] ] (int, int) ] \end{cfa} @@ -3882,6 +3927,6 @@ Examples of declarations using tuple types are: \begin{cfa} -[ int, int ] x; §\C{// 2 element tuple, each element of type int}§ -* [ char, char ] y; §\C{// pointer to a 2 element tuple}§ +[ int, int ] x; §\C{// 2 element tuple, each element of type int}§ +* [ char, char ] y; §\C{// pointer to a 2 element tuple}§ [ [ int, int ] ] z ([ int, int ]); \end{cfa} @@ -3900,6 +3945,6 @@ [ int, int ] w1; [ int, int, int ] w2; -[ void ] f (int, int, int); §\C{// three input parameters of type int}§ -[ void ] g ([ int, int, int ]); §\C{3 element tuple as input}§ +[ void ] f (int, int, int); §\C{// three input parameters of type int}§ +[ void ] g ([ int, int, int ]); §\C{// 3 element tuple as input}§ f( [ 1, 2, 3 ] ); f( w1, 3 ); @@ -3982,5 +4027,5 @@ [ int, int, int, int ] w = [ 1, 2, 3, 4 ]; int x = 5; -[ x, w ] = [ w, x ]; §\C{// all four tuple coercions}§ +[ x, w ] = [ w, x ]; §\C{// all four tuple coercions}§ \end{cfa} Starting on the right-hand tuple in the last assignment statement, w is opened, producing a tuple of four values; @@ -4000,9 +4045,9 @@ Mass assignment has the following form: \begin{cfa} -[ $\emph{lvalue}$, ... , $\emph{lvalue}$ ] = $\emph{expr}$; +[ §\emph{lvalue}§, ... , §\emph{lvalue}§ ] = §\emph{expr}§; \end{cfa} \index{lvalue} -The left-hand side is a tuple of \emph{lvalues}, which is a list of expressions each yielding an address, \ie any data object that can appear on the left-hand side of a conventional assignment statement. -©$\emph{expr}$© is any standard arithmetic expression. +The left-hand side is a tuple of \LstBasicStyle{\emph{lvalues}}, which is a list of expressions each yielding an address, \ie any data object that can appear on the left-hand side of a conventional assignment statement. +\LstBasicStyle{\emph{expr}} is any standard arithmetic expression. Clearly, the types of the entities being assigned must be type compatible with the value of the expression. @@ -4041,5 +4086,5 @@ Multiple assignment has the following form: \begin{cfa} -[ $\emph{lvalue}$, ... , $\emph{lvalue}$ ] = [ $\emph{expr}$, ... , $\emph{expr}$ ]; +[ §\emph{lvalue}§, ... , §\emph{lvalue}§ ] = [ §\emph{expr}§, ... , §\emph{expr}§ ]; \end{cfa} \index{lvalue} @@ -4072,6 +4117,6 @@ both these examples produce indeterminate results: \begin{cfa} -f( x++, x++ ); §\C{// C routine call with side effects in arguments}§ -[ v1, v2 ] = [ x++, x++ ]; §\C{// side effects in right-hand side of multiple assignment}§ +f( x++, x++ ); §\C{// C routine call with side effects in arguments}§ +[ v1, v2 ] = [ x++, x++ ]; §\C{// side effects in right-hand side of multiple assignment}§ \end{cfa} @@ -4083,5 +4128,5 @@ Cascade assignment has the following form: \begin{cfa} -$\emph{tuple}$ = $\emph{tuple}$ = ... = $\emph{tuple}$; +§\emph{tuple}§ = §\emph{tuple}§ = ... = §\emph{tuple}§; \end{cfa} and it has the same parallel semantics as for mass and multiple assignment. @@ -4103,6 +4148,7 @@ The goal of \CFA stream input/output (I/O) is to simplify the common cases\index{I/O!common case}, while fully supporting polymorphism and user defined types in a consistent way. Stream I/O can be implicitly or explicitly formatted. -Implicit formatting means \CFA selects the output or input format for values that matches the variable's type. -Explicit formatting means additional information is specified to augment how an output or input of value is interpreted. +Implicit formatting means \CFA selects an I/O format for values that matches a variable's type. +Explicit formatting means additional I/O information is specified to control how a value is interpreted. + \CFA formatting incorporates ideas from C ©printf©, \CC ©stream© manipulators, and Python implicit spacing and newline. Specifically: @@ -4112,27 +4158,22 @@ \CFA/\CC format manipulators are named, making them easier to read and remember. \item -©printf©/Python separates format codes from associated variables, making it difficult to match codes with variables. +©printf©/Python separate format codes from associated variables, making it difficult to match codes with variables. \CFA/\CC co-locate codes with associated variables, where \CFA has the tighter binding. \item -Format manipulators in \CFA have local effect, whereas \CC have global effect, except ©setw©. -Hence, it is common programming practice to toggle manipulators on and then back to the default to prevent downstream side-effects. +Format manipulators in ©printf©/Python/\CFA have local effect, whereas \CC have global effect, except ©setw©. +Hence, it is common \CC programming practice to toggle manipulators on and then back to the default to prevent downstream side-effects. Without this programming style, errors occur when moving prints, as manipulator effects incorrectly flow into the new location. Furthermore, to guarantee no side-effects, manipulator values must be saved and restored across function calls. +\CC programers never do any of this. \item \CFA has more sophisticated implicit value spacing than Python, plus implicit newline at the end of a print. \end{itemize} -The standard polymorphic I/Os stream are ©stdin©/©sin© (input), ©stdout©/©sout© and ©stderr©/©serr© (output) (like C++ ©cin©/©cout©/©cerr©). -Polymorphic streams ©exit© and ©abort© provide implicit program termination without and with generating a stack trace and core file. -Stream ©exit© implicitly returns ©EXIT_FAILURE© to the shell. -\begin{cfa} -®exit® | "x (" | x | ") negative value."; // terminate and return EXIT_FAILURE to shell -®abort® | "x (" | x | ") negative value."; // terminate and generate stack trace and core file -\end{cfa} -Note, \CFA stream variables ©stdin©, ©stdout©, ©stderr©, ©exit©, and ©abort© overload C variables ©stdin©, ©stdout©, ©stderr©, and functions ©exit© and ©abort©, respectively. + +\subsection{Basic I/O} + +The standard polymorphic I/O streams are ©stdin©/©sin© (input), ©stdout©/©sout©, and ©stderr©/©serr© (output) (like C++ ©cin©/©cout©/©cerr©). +The standard I/O operator is the bit-wise (or) operator, ©'|'©, which is used to cascade multiple I/O operations. The \CFA header file for the I/O library is \Indexc{fstream.hfa}. - - -\subsection{Basic I/O} For implicit formatted output, the common case is printing a series of variables separated by whitespace. @@ -4177,5 +4218,6 @@ 1®, ®2®, ®3 4®, ®5®, ®6 \end{cfa} -Finally, \CFA uses the logical-or operator for I/O as it is the lowest-priority \emph{overloadable} operator, other than assignment. +The bit-wise ©|© operator is used for I/O, rather \CC shift-operators, ©<<© and ©>>©, as it is the lowest-priority \emph{overloadable} operator, other than assignment. +(Operators ©||© and ©&&© are not overloadable in \CFA.) Therefore, fewer output expressions require parenthesis. \begin{cquote} @@ -4200,8 +4242,16 @@ \end{cquote} There is a weak similarity between the \CFA logical-or operator and the \Index{Shell pipe-operator} for moving data, where data flows in the correct direction for input but the opposite direction for output. -Input and output use a uniform operator, ©|©, rather than \CC's ©<<© and ©>>© input/output operators, which prevents this common error in \CC: +Input and output use a uniform operator, ©|©, rather than \CC's ©<<© and ©>>© input/output operators to prevent this common error in \CC: \begin{C++} cin << i; // why is this generating a lot of error messages? \end{C++} + +Streams ©exit© and ©abort© provide output with immediate program termination without and with generating a stack trace and core file. +Stream ©exit© implicitly returns ©EXIT_FAILURE© to the shell. +\begin{cfa} +®exit® | "x (" | x | ") negative value."; §\C{// print, terminate, and return EXIT\_FAILURE to shell}§ +®abort® | "x (" | x | ") negative value."; §\C{// print, terminate, and generate stack trace and core file}§ +\end{cfa} +Note, \CFA stream variables ©stdin©, ©stdout©, ©stderr©, ©exit©, and ©abort© overload C variables ©stdin©, ©stdout©, ©stderr©, and functions ©exit© and ©abort©, respectively. For implicit formatted input, the common case is reading a sequence of values separated by whitespace, where the type of an input constant must match with the type of the input variable. @@ -4246,8 +4296,90 @@ \end{tabular} \end{cquote} - -\VRef[Figure]{f:CFACommand-LineProcessing} shows idiomatic \CFA command-line processing and copying an input file to an output file. +The format of numeric input values in the same as C constants without a trailing type suffix, as the input value-type is denoted by the input variable. +For ©bool© type, the constants are ©true© and ©false©. +For integral types, any number of digits, optionally preceded by a sign (©+© or ©-©), where a +\begin{itemize} +\item +©1©-©9© prefix introduces a decimal value (©0©-©9©), +\item +©0© prefix introduces an octal value (©0©-©7©), and +\item +©0x© or ©0X© prefix introduces a hexadecimal value (©0©-©f©) with lower or upper case letters. +\end{itemize} +For floating-point types, any number of decimal digits, optionally preceded by a sign (©+© or ©-©), optionally containing a decimal point, and optionally followed by an exponent, ©e© or ©E©, with signed (optional) decimal digits. +Floating-point values can also be written in hexadecimal format preceded by ©0x© or ©0X© with hexadecimal digits and exponent denoted by ©p© or ©P©. +In all cases, all whitespace characters are skipped until an appropriate value is found. +\Textbf{If an appropriate value is not found, the exception ©missing_data© is raised.} + +For the C-string type, there are two input forms: any number of \Textbf{non-whitespace} characters or a quoted sequence containing any characters except the closing quote, \ie there is no escape character supported in the string.. +In both cases, the string is null terminated ©'\0'©. +For the quoted string, the start and end quote characters can be any character and do not have to match \see{\ref{XXX}}. + +\VRef[Figure]{f:IOStreamFunctions} shows the I/O stream operations for interacting with files other than ©cin©, ©cout©, and ©cerr©. +\begin{itemize}[topsep=4pt,itemsep=2pt,parsep=0pt] +\item +\Indexc{fail} tests the stream error-indicator, returning nonzero if it is set. +\item +\Indexc{clear} resets the stream error-indicator. +\item +\Indexc{flush} (©ofstream© only) causes any unwritten data for a stream to be written to the file. +\item +\Indexc{eof} (©ifstream© only) tests the end-of-file indicator for the stream pointed to by stream. +Returns true if the end-of-file indicator is set, otherwise false. +\item +\Indexc{open} binds the file with ©name© to a stream accessed with ©mode© (see ©fopen©). +\item +\Indexc{close} flushes the stream and closes the file. +\item +\Indexc{write} (©ofstream© only) writes ©size© bytes to the stream. +The bytes are written lazily when an internal buffer fills. +Eager buffer writes are done with ©flush© +\item +\Indexc{read} (©ifstream© only) reads ©size© bytes from the stream. +\item +\Indexc{ungetc} (©ifstream© only) pushes the character back to the input stream. +Pushed-back characters returned by subsequent reads in the reverse order of pushing. +\end{itemize} +The constructor functions: +\begin{itemize}[topsep=4pt,itemsep=2pt,parsep=0pt] +\item +create an unbound stream, which is subsequently bound to a file with ©open©. +\item +create a bound stream to the associated file with given ©mode©. +\end{itemize} +The destructor closes the stream. + +\begin{figure} +\begin{cfa} +// *********************************** ofstream *********************************** +bool fail( ofstream & );§\indexc{fail}\index{ofstream@©ofstream©!©fail©}§ +void clear( ofstream & );§\indexc{clear}\index{ofstream@©ofstream©!©clear©}§ +int flush( ofstream & );§\indexc{flush}\index{ofstream@©ofstream©!©flush©}§ +void open( ofstream &, const char name[], const char mode[] = "w" );§\indexc{open}\index{ofstream@©ofstream©!©open©}§ +void close( ofstream & );§\indexc{close}\index{ofstream@©ofstream©!©close©}§ +ofstream & write( ofstream &, const char data[], size_t size );§\indexc{write}\index{ofstream@©ofstream©!©write©}§ +void ?{}( ofstream & );§\index{ofstream@©ofstream©!©?{}©}§ +void ?{}( ofstream &, const char name[], const char mode[] = "w" ); +void ^?{}( ofstream & );§\index{ofstream@©ofstream©!©^?{}©}§ + +// *********************************** ifstream *********************************** +bool fail( ifstream & is );§\indexc{fail}\index{ifstream@©ifstream©!©fail©}§ +void clear( ifstream & );§\indexc{clear}\index{ifstream@©ifstream©!©clear©}§ +bool eof( ifstream & is );§\indexc{eof}\index{ifstream@©ifstream©!©eof©}§ +void open( ifstream & is, const char name[], const char mode[] = "r" );§\indexc{open}\index{ifstream@©ifstream©!©open©}§ +void close( ifstream & is );§\indexc{close}\index{ifstream@©ifstream©!©close©}§ +ifstream & read( ifstream & is, char data[], size_t size );§\indexc{read}\index{ifstream@©ifstream©!©read©}§ +ifstream & ungetc( ifstream & is, char c );§\indexc{unget}\index{ifstream@©ifstream©!©unget©}§ +void ?{}( ifstream & is );§\index{ifstream@©ifstream©!©?{}©}§ +void ?{}( ifstream & is, const char name[], const char mode[] = "r" ); +void ^?{}( ifstream & is );§\index{ifstream@©ifstream©!©^?{}©}§ +\end{cfa} +\caption{I/O Stream Functions} +\label{f:IOStreamFunctions} +\end{figure} + +\VRef[Figure]{f:CFACommand-LineProcessing} demonstrates the file operations by showing the idiomatic \CFA command-line processing and copying an input file to an output file. Note, a stream variable may be copied because it is a reference to an underlying stream data-structures. -All I/O errors are handles as exceptions, but end-of-file is not an exception as C programmers are use to explicitly checking for it. +\Textbf{All I/O errors are handled as exceptions}, but end-of-file is not an exception as C programmers are use to explicitly checking for it. \begin{figure} @@ -4261,5 +4393,5 @@ try { choose ( argc ) { - case 2, 3: + case 3, 2: ®open®( in, argv[1] ); §\C{// open input file first as output creates file}§ if ( argc == 3 ) ®open®( out, argv[2] ); §\C{// do not create output unless input opens}§ @@ -4290,76 +4422,9 @@ \end{figure} -\VRef[Figure]{f:StreamFunctions} shows the stream operations. -\begin{itemize}[topsep=4pt,itemsep=2pt,parsep=0pt] -\item -\Indexc{fail} tests the stream error-indicator, returning nonzero if it is set. -\item -\Indexc{clear} resets the stream error-indicator. -\item -\Indexc{flush} (©ofstream© only) causes any unwritten data for a stream to be written to the file. -\item -\Indexc{eof} (©ifstream© only) tests the end-of-file indicator for the stream pointed to by stream. -Returns true if the end-of-file indicator is set, otherwise false. -\item -\Indexc{open} binds the file with ©name© to a stream accessed with ©mode© (see ©fopen©). -\item -\Indexc{close} flushes the stream and closes the file. -\item -\Indexc{write} (©ofstream© only) writes ©size© bytes to the stream. -The bytes are written lazily when an internal buffer fills. -Eager buffer writes are done with ©flush© -\item -\Indexc{read} (©ifstream© only) reads ©size© bytes from the stream. -\item -\Indexc{ungetc} (©ifstream© only) pushes the character back to the input stream. -Pushed-back characters returned by subsequent reads in the reverse order of pushing. -\end{itemize} -The constructor functions: -\begin{itemize}[topsep=4pt,itemsep=2pt,parsep=0pt] -\item -create an unbound stream, which is subsequently bound to a file with ©open©. -\item -create a bound stream to the associated file with given ©mode©. -\end{itemize} -The destructor closes the stream. - -\begin{figure} -\begin{cfa} -// *********************************** ofstream *********************************** - -bool fail( ofstream & );§\indexc{fail}\index{ofstream@©ofstream©!©fail©}§ -void clear( ofstream & );§\indexc{clear}\index{ofstream@©ofstream©!©clear©}§ -int flush( ofstream & );§\indexc{flush}\index{ofstream@©ofstream©!©flush©}§ -void open( ofstream &, const char name[], const char mode[] = "w" );§\indexc{open}\index{ofstream@©ofstream©!©open©}§ -void close( ofstream & );§\indexc{close}\index{ofstream@©ofstream©!©close©}§ -ofstream & write( ofstream &, const char data[], size_t size );§\indexc{write}\index{ofstream@©ofstream©!©write©}§ - -void ?{}( ofstream & );§\index{ofstream@©ofstream©!©?{}©}§ -void ?{}( ofstream &, const char name[], const char mode[] = "w" ); -void ^?{}( ofstream & );§\index{ofstream@©ofstream©!©^?{}©}§ - -// *********************************** ifstream *********************************** - -bool fail( ifstream & is );§\indexc{fail}\index{ifstream@©ifstream©!©fail©}§ -void clear( ifstream & );§\indexc{clear}\index{ifstream@©ifstream©!©clear©}§ -bool eof( ifstream & is );§\indexc{eof}\index{ifstream@©ifstream©!©eof©}§ -void open( ifstream & is, const char name[], const char mode[] = "r" );§\indexc{open}\index{ifstream@©ifstream©!©open©}§ -void close( ifstream & is );§\indexc{close}\index{ifstream@©ifstream©!©close©}§ -ifstream & read( ifstream & is, char data[], size_t size );§\indexc{read}\index{ifstream@©ifstream©!©read©}§ -ifstream & ungetc( ifstream & is, char c );§\indexc{unget}\index{ifstream@©ifstream©!©unget©}§ - -void ?{}( ifstream & is );§\index{ifstream@©ifstream©!©?{}©}§ -void ?{}( ifstream & is, const char name[], const char mode[] = "r" ); -void ^?{}( ifstream & is );§\index{ifstream@©ifstream©!©^?{}©}§ -\end{cfa} -\caption{Stream Functions} -\label{f:StreamFunctions} -\end{figure} - \subsection{Implicit Separator} The \Index{implicit separator}\index{I/O!separator} character (space/blank) is a separator not a terminator for output. -The rules for implicitly adding the separator are: +The rules for implicitly adding a separator are: \begin{enumerate} \item @@ -4390,22 +4455,19 @@ \begin{cfa} sout | 1 | ", x" | 2 | ". x" | 3 | "; x" | 4 | "! x" | 5 | "? x" | 6 | "% x" - | 7 | "$\LstStringStyle{\textcent}$ x" | 8 | "$\LstStringStyle{\guillemotright}$ x" | 9 | ") x" | 10 | "] x" | 11 | "} x"; + | 7 | "§\LstStringStyle{\textcent}§ x" | 8 | "§\LstStringStyle{\guillemotright}§ x" | 9 | ") x" | 10 | "] x" | 11 | "} x"; \end{cfa} \begin{cfa}[showspaces=true] -1®,® x 2®.® x 3®;® x 4®!® x 5®?® x 6®%® x 7$\R{\LstStringStyle{\textcent}}$ x 8$\R{\LstStringStyle{\guillemotright}}$ x 9®)® x 10®]® x 11®}® x +Input1®,® x 2®.® x 3®;® x 4®!® x 5®?® x 6®%® x 7§\R{\LstStringStyle{\textcent}}§ x 8§\R{\LstStringStyle{\guillemotright}}§ x 9®)® x 10®]® x 11®}® x \end{cfa} \item A separator does not appear after a C string ending with the (extended) \Index*{ASCII}\index{ASCII!extended} characters: \LstStringStyle{([\{=\$\textsterling\textyen\textexclamdown\textquestiondown\guillemotleft}, where \LstStringStyle{\textexclamdown\textquestiondown} are inverted opening exclamation and question marks, and \LstStringStyle{\guillemotleft} is an opening citation mark. -%$ -\begin{cfa} -sout | "x (" | 1 | "x [" | 2 | "x {" | 3 | "x =" | 4 | "x $\LstStringStyle{\textdollar}$" | 5 | "x $\LstStringStyle{\textsterling}$" | 6 | "x $\LstStringStyle{\textyen}$" - | 7 | "x $\LstStringStyle{\textexclamdown}$" | 8 | "x $\LstStringStyle{\textquestiondown}$" | 9 | "x $\LstStringStyle{\guillemotleft}$" | 10; -\end{cfa} -%$ +\begin{cfa} +sout | "x (" | 1 | "x [" | 2 | "x {" | 3 | "x =" | 4 | "x §\LstStringStyle{\textdollar}§" | 5 | "x §\LstStringStyle{\textsterling}§" | 6 | "x §\LstStringStyle{\textyen}§" + | 7 | "x §\LstStringStyle{\textexclamdown}§" | 8 | "x §\LstStringStyle{\textquestiondown}§" | 9 | "x §\LstStringStyle{\guillemotleft}§" | 10; +\end{cfa} \begin{cfa}[showspaces=true] -x ®(®1 x ®[®2 x ®{®3 x ®=®4 x $\LstStringStyle{\textdollar}$5 x $\R{\LstStringStyle{\textsterling}}$6 x $\R{\LstStringStyle{\textyen}}$7 x $\R{\LstStringStyle{\textexclamdown}}$8 x $\R{\LstStringStyle{\textquestiondown}}$9 x $\R{\LstStringStyle{\guillemotleft}}$10 -\end{cfa} -%$ +x ®(®1 x ®[®2 x ®{®3 x ®=®4 x §\LstStringStyle{\textdollar}§5 x §\R{\LstStringStyle{\textsterling}}§6 x §\R{\LstStringStyle{\textyen}}§7 x §\R{\LstStringStyle{\textexclamdown}}§8 x §\R{\LstStringStyle{\textquestiondown}}§9 x §\R{\LstStringStyle{\guillemotleft}}§10 +\end{cfa} \item @@ -4415,5 +4477,5 @@ \end{cfa} \begin{cfa}[showspaces=true,showtabs=true] -x®`®1®`®x$\R{\texttt{'}}$2$\R{\texttt{'}}$x$\R{\texttt{"}}$3$\R{\texttt{"}}$x®:®4®:®x® ®5® ®x® ®6® ®x +x®`®1®`®x§\R{\texttt{'}}§2§\R{\texttt{'}}§x§\R{\texttt{"}}§3§\R{\texttt{"}}§x®:®4®:®x® ®5® ®x® ®6® ®x \end{cfa} @@ -4421,5 +4483,5 @@ If a space is desired before or after one of the special string start/end characters, explicitly insert a space. \begin{cfa} -sout | "x ($\R{\texttt{\textvisiblespace}}$" | 1 | "$\R{\texttt{\textvisiblespace}}$) x" | 2 | "$\R{\texttt{\textvisiblespace}}$, x" | 3 | "$\R{\texttt{\textvisiblespace}}$:x:$\R{\texttt{\textvisiblespace}}$" | 4; +sout | "x (§\R{\texttt{\textvisiblespace}}§" | 1 | "§\R{\texttt{\textvisiblespace}}§) x" | 2 | "§\R{\texttt{\textvisiblespace}}§, x" | 3 | "§\R{\texttt{\textvisiblespace}}§:x:§\R{\texttt{\textvisiblespace}}§" | 4; \end{cfa} \begin{cfa}[showspaces=true,showtabs=true] @@ -4438,9 +4500,9 @@ The separator string can be at most 16 characters including the ©'\0'© string terminator (15 printable characters). \begin{cfa}[belowskip=0pt] -sepSet( sout, ", $\LstStringStyle{\textdollar}$" ); §\C{// set separator from " " to ", \$"}§ +sepSet( sout, ", §\LstStringStyle{\textdollar}§" ); §\C{// set separator from " " to ", \$"}§ sout | 1 | 2 | 3 | " \"" | ®sepVal® | "\""; \end{cfa} \begin{cfa}[showspaces=true,aboveskip=0pt] -1®, $\color{red}\LstStringStyle{\textdollar}$®2®, $\color{red}\LstStringStyle{\textdollar}$®3 ®", $\color{red}\LstStringStyle{\textdollar}$"® +1®, §\color{red}\LstStringStyle{\textdollar}§®2®, §\color{red}\LstStringStyle{\textdollar}§®3 ®", §\color{red}\LstStringStyle{\textdollar}§"® \end{cfa} \begin{cfa}[belowskip=0pt] @@ -4557,4 +4619,5 @@ For example, in: \begin{cfa} +int i, j; sin | i | ®nl® | j; 1 ®2® @@ -4562,4 +4625,25 @@ \end{cfa} variable ©i© is assigned 1, the 2 is skipped, and variable ©j© is assigned 3. +For example, in: +\begin{cquote} +\begin{tabular}{@{}l@{\hspace{3em}}l@{}} +\begin{cfa} +char ch + +sin | ch; // read X + +X +\end{cfa} +& +\begin{cfa} + +sin | ®nlOn®; // enable reading newlines +sin | ch; // read newline + + +\end{cfa} +\end{tabular} +\end{cquote} +the left example skips the newline and reads ©'X'© into ©ch©, while the right example reads the newline into ©ch©. For output: @@ -4589,5 +4673,5 @@ -\subsection{Output Value Manipulators} +\subsection{Output Manipulators} The following \Index{manipulator}s control formatting (printing) of the argument output values. @@ -4643,5 +4727,7 @@ \item \Indexc{unit}( engineering-notation )\index{manipulator!unit@©unit©} print engineering exponent as a letter between the range $10^{-24}$ and $10^{24}$: +\begin{cquote} ©y© $\Rightarrow 10^{-24}$, ©z© $\Rightarrow 10^{-21}$, ©a© $\Rightarrow 10^{-18}$, ©f© $\Rightarrow 10^{-15}$, ©p© $\Rightarrow 10^{-12}$, ©n© $\Rightarrow 10^{-9}$, ©u© $\Rightarrow 10^{-6}$, ©m© $\Rightarrow 10^{-3}$, ©K© $\Rightarrow 10^{3}$, ©M© $\Rightarrow 10^{6}$, ©G© $\Rightarrow 10^{9}$, ©T© $\Rightarrow 10^{12}$, ©P© $\Rightarrow 10^{15}$, ©E© $\Rightarrow 10^{18}$, ©Z© $\Rightarrow 10^{21}$, ©Y© $\Rightarrow 10^{24}$. +\end{cquote} For exponent $10^{0}$, no decimal point or letter is printed. \begin{cfa}[belowskip=0pt] @@ -4843,26 +4929,20 @@ // End: // \end{comment} -%$ - - -\subsection{Input Value Manipulators} - -The format of numeric input values in the same as C constants without a trailing type suffix, as the input value-type is denoted by the input variable. -For ©bool© type, the constants are ©true© and ©false©. -For integral types, any number of digits, optionally preceded by a sign (©+© or ©-©), where a -\begin{itemize} -\item -©1©-©9© prefix introduces a decimal value (©0©-©9©), -\item -©0© prefix introduces an octal value (©0©-©7©), and -\item -©0x© or ©0X© prefix introduces a hexadecimal value (©0©-©f©) with lower or upper case letters. -\end{itemize} -For floating-point types, any number of decimal digits, optionally preceded by a sign (©+© or ©-©), optionally containing a decimal point, and optionally followed by an exponent, ©e© or ©E©, with signed (optional) decimal digits. -Floating-point values can also be written in hexadecimal format preceded by ©0x© or ©0X© with hexadecimal digits and exponent denoted by ©p© or ©P©. - -For the C-string type, the input values are \emph{not} the same as C-string constants, \ie double quotes bracketing arbitrary text with escape sequences. -Instead, the next sequence of non-whitespace characters are read, and the input sequence is terminated with delimiter ©'\0'©. -The string variable \emph{must} be large enough to contain the input sequence. + + +\subsection{Input Manipulators} + +The following \Index{manipulator}s control scanning of input values (reading), and only affect the format of the argument. + +Certain manipulators support a \newterm{scanset}, which is a simple regular expression, where the matching set contains any Latin-1 character (8-bits) or character ranges using minus. +For example, the scanset \lstinline{"a-zA-Z -/?§"} matches any number of characters between ©'a'© and ©'z'©, between ©'A'© and ©'Z'©, between space and ©'/'©, and characters ©'?'© and (Latin-1) ©'§'©. +The following string is matched by this scanset: +\begin{cfa} +!&%$ abAA () ZZZ ?? xx§\S\S\S§ +\end{cfa} +To match a minus, put it as the first character, ©"-0-9"©. +Other complex forms of regular-expression matching are not supported. + +A string variable \emph{must} be large enough to contain the input sequence. To force programmers to consider buffer overruns for C-string input, C-strings can only be read with a width field, which should specify a size less than or equal to the C-string size, \eg: \begin{cfa} @@ -4871,23 +4951,18 @@ \end{cfa} -A scanset is a simple regular expression, where the matching set contains any Latin-1 character (8-bits) or character ranges using minus. -For example, the scanset \lstinline{"a-zA-Z -/?§"} matches characters between ©'a'© and ©'z'©, between ©'A'© and ©'Z'©, between space and ©'/'©, and characters ©'?'© and (Latin-1) ©'§'©. -The following string is matched by this scanset: -\begin{cfa} -!&%$ abAA () ZZZ ?? xx§§§§ -\end{cfa} -To match a minus, put it as the first character, ©"-0-9"©. -Other complex forms of regular-expression matching are not supported. - -The following \Index{manipulator}s control scanning of input values (reading), and only affect the format of the argument. +Currently, there is no mechanism to detect if a value read exceeds the capwhen Most types are finite sized, \eg integral types only store value that fit into their corresponding storage, 8, 16, 32, 64, 128 bits. +Hence, an input value may be too large, and the result of the read is often considered undefined, which leads to difficlt to locate runtime errors. +All reads in \CFA check if values do not fit into the argument variable's type and raise the exception +All types are + \begin{enumerate} \item -\Indexc{skip}( pattern )\index{manipulator!skip@©skip©}, ©skip©( length ) -The pattern is composed of white-space and non-white-space characters, where \emph{any} white-space character matches 0 or more input white-space characters (hence, consecutive white-space characters in the pattern are combined), and each non-white-space character matches exactly with an input character. -The length is composed of the next $N$ characters, including the newline character. +\Indexc{skip}( scanset )\index{manipulator!skip@©skip©}, ©skip©( $N$ ) +The first form uses a scanset to skip matching characters. +The second form skips the next $N$ characters, including newline. If the match successes, the input characters are discarded, and input continues with the next character. If the match fails, the input characters are left unread. \begin{cfa}[belowskip=0pt] -char sk[$\,$] = "abc"; +char sk[§\,§] = "abc"; sin | "abc " | skip( sk ) | skip( 5 ); // match input sequence \end{cfa} @@ -4899,15 +4974,41 @@ \item -\Indexc{wdi}( maximum, reference-value )\index{manipulator!wdi@©wdi©} -For all types except ©char©, maximum is the maximum number of characters read for the current operation. +\Indexc{wdi}( maximum, variable )\index{manipulator!wdi@©wdi©} +For all types except ©char *©, whitespace is skipped until an appropriate value is found for the specified variable type. +maximum is the maximum number of characters read for the current operation. \begin{cfa}[belowskip=0pt] -char s[10]; int i; double d; -sin | wdi( 4, s ) | wdi( 3, i ) | wdi( 8, d ); // c == "abcd", i == 123, d == 3.456E+2 +char ch; char ca[3]; int i; double d; +sin | wdi( sizeof(ch), ch ) | wdi( sizeof(ca), ca[0] ) | wdi( 3, i ) | wdi( 8, d ); // c == 'a', ca == "bcd", i == 123, d == 345.6 \end{cfa} \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] ®abcd1233.456E+2® \end{cfa} +Here, ©ca[0]© is type ©char©, so the width reads 3 characters \Textbf{without} a null terminator. + Note, input ©wdi© cannot be overloaded with output ©wd© because both have the same parameters but return different types. Currently, \CFA cannot distinguish between these two manipulators in the middle of an ©sout©/©sin© expression based on return type. + +\item +\Indexc{wdi}( maximum size, ©char s[]© )\index{manipulator!wdi@©wdi©} +For type ©char *©, maximum is the maximum number of characters read for the current operation. +Any number of non-whitespace characters, stopping at the first whitespace character found. A terminating null character is automatically added at the end of the stored sequence +\begin{cfa}[belowskip=0pt] +char cstr[10]; +sin | wdi( sizeof(cstr), cstr ); +\end{cfa} +\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] +®abcd1233.456E+2® +\end{cfa} + +\item +\Indexc{wdi}( maximum size, maximum read, ©char s[]© )\index{manipulator!wdi@©wdi©} +For type ©char *©, maximum is the maximum number of characters read for the current operation. +\begin{cfa}[belowskip=0pt] +char ch; char ca[3]; int i; double d; +sin | wdi( sizeof(ch), ch ) | wdi( sizeof(ca), ca[0] ) | wdi( 3, i ) | wdi( 8, d ); // c == 'a', ca == "bcd", i == 123, d == 345.6 +\end{cfa} +\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] +®abcd1233.456E+2® +\end{cfa} \item @@ -4946,7 +5047,11 @@ \end{cfa} +\Indexc{quoted}( char delimit, wdi-input-string )\index{manipulator!quoted@©quoted©} +Is an ©excl© with scanset ©"delimit"©, which consumes all characters up to the delimit character. +If the delimit character is omitted, it defaults to ©'\n'© (newline). + \item \Indexc{getline}( char delimit, wdi-input-string )\index{manipulator!getline@©getline©} -Is an @excl@ with scanset ©"delimit"©, which consumes all characters up to the delimit character. +Is an ©excl© with scanset ©"delimit"©, which consumes all characters up to the delimit character. If the delimit character is omitted, it defaults to ©'\n'© (newline). \end{enumerate} @@ -4958,6 +5063,6 @@ For example, if two threads execute the following: \begin{cfa} -$\emph{thread\(_1\)}$ : sout | "abc " | "def "; -$\emph{thread\(_2\)}$ : sout | "uvw " | "xyz "; +§\emph{thread\(_1\)}§ : sout | "abc " | "def "; +§\emph{thread\(_2\)}§ : sout | "uvw " | "xyz "; \end{cfa} possible outputs are: @@ -4999,6 +5104,6 @@ The common usage is the short form of the mutex statement\index{ostream@©ostream©!mutex@©mutex©} to lock a stream during a single cascaded I/O expression, \eg: \begin{cfa} -$\emph{thread\(_1\)}$ : ®mutex( sout )® sout | "abc " | "def "; -$\emph{thread\(_2\)}$ : ®mutex( sout )® sout | "uvw " | "xyz "; +§\emph{thread\(_1\)}§ : ®mutex( sout )® sout | "abc " | "def "; +§\emph{thread\(_2\)}§ : ®mutex( sout )® sout | "uvw " | "xyz "; \end{cfa} Now, the order of the thread execution is still non-deterministic, but the output is constrained to two possible lines in either order. @@ -5061,7 +5166,7 @@ Cultures use different syntax, called a \newterm{locale}, for printing numbers so they are easier to read, \eg: \begin{cfa} -12®,®345®.®123 $\C[1.25in]{// comma separator, period decimal-point}$ +12®,®345®.®123 §\C[1.25in]{// comma separator, period decimal-point}§ 12®.®345®,®123 §\C{// period separator, comma decimal-point}§ -12$\Sp$345®,®123®.® §\C{// space separator, comma decimal-point, period terminator}\CRT§ +12§\Sp§345®,®123®.® §\C{// space separator, comma decimal-point, period terminator}\CRT§ \end{cfa} A locale is selected with function ©setlocale©, and the corresponding locale package \emph{must} be installed on the underlying system; @@ -5109,5 +5214,5 @@ Ukraine uk_UA.utf8 12 123 1 234 12 345 123 456 1 234 567 -12®.® 123®,®1®.® 1$\Sp$234®,®12®.® 12$\Sp$ 345®,®123®.® 123$\Sp$ 456®,®1234®.® 1$\Sp$ 234$\Sp$567®,®12345®.® +12®.® 123®,®1®.® 1§\Sp§234®,®12®.® 12§\Sp§ 345®,®123®.® 123§\Sp§ 456®,®1234®.® 1§\Sp§ 234§\Sp§567®,®12345®.® Default locale off C @@ -5461,4 +5566,5 @@ \subsection{Operator} +\label{s:Operator} \CFA also allows operators to be overloaded, to simplify the use of user-defined types. @@ -7332,7 +7438,6 @@ \Index*[C++]{\CC{}} is a general-purpose programming language. -It has imperative, object-oriented and generic programming features, while also providing facilities for low-level memory manipulation. (Wikipedia) - -The primary focus of \CC seems to be adding object-oriented programming to C, and this is the primary difference between \CC and Do. +It is an imperative, object-oriented and generic programming language, while also providing facilities for low-level memory manipulation. +The primary focus of \CC was adding object-oriented programming to C, and this is the primary difference between \CC and \CFA. \CC uses classes to encapsulate data and the functions that operate on that data, and to hide the internal representation of the data. \CFA uses modules instead to perform these same tasks. @@ -7352,5 +7457,5 @@ \subsection{Go} -\Index*{Go}, also commonly referred to as golang, is a programming language developed at Google in 2007 [.]. +\Index*{Go}, also commonly referred to as golang, is a programming language developed at Google in 2007~\cite{Go}. It is a statically typed language with syntax loosely derived from that of C, adding garbage collection, type safety, some structural typing capabilities, additional built-in types such as variable-length arrays and key-value maps, and a large standard library. (Wikipedia) @@ -7406,6 +7511,6 @@ In \CFA, there are ambiguous cases with dereference and operator identifiers, \eg ©int *?*?()©, where the string ©*?*?© can be interpreted as: \begin{cfa} -*?$\Sp$*? §\C{// dereference operator, dereference operator}§ -*$\Sp$?*? §\C{// dereference, multiplication operator}§ +*?§\Sp§*? §\C{// dereference operator, dereference operator}§ +*§\Sp§?*? §\C{// dereference, multiplication operator}§ \end{cfa} By default, the first interpretation is selected, which does not yield a meaningful parse. @@ -7416,6 +7521,6 @@ The ambiguity occurs when the deference operator has no parameters: \begin{cfa} -*?()$\R{\textvisiblespace...}$ ; -*?()$\R{\textvisiblespace...}$(...) ; +*?()§\R{\textvisiblespace...}§ ; +*?()§\R{\textvisiblespace...}§(...) ; \end{cfa} requiring arbitrary whitespace look-ahead for the routine-call parameter-list to disambiguate. @@ -7425,12 +7530,12 @@ The remaining cases are with the increment/decrement operators and conditional expression, \eg: \begin{cfa} -i++?$\R{\textvisiblespace...}$(...); -i?++$\R{\textvisiblespace...}$(...); +i++?§\R{\textvisiblespace...}§(...); +i?++§\R{\textvisiblespace...}§(...); \end{cfa} requiring arbitrary whitespace look-ahead for the operator parameter-list, even though that interpretation is an incorrect expression (juxtaposed identifiers). Therefore, it is necessary to disambiguate these cases with a space: \begin{cfa} -i++$\Sp$? i : 0; -i?$\Sp$++i : 0; +i++§\Sp§? i : 0; +i?§\Sp§++i : 0; \end{cfa} @@ -7459,13 +7564,13 @@ \eg: \begin{cfa} -x; §\C{// int x}§ -*y; §\C{// int *y}§ -f( p1, p2 ); §\C{// int f( int p1, int p2 );}§ -g( p1, p2 ) int p1, p2; §\C{// int g( int p1, int p2 );}§ +x; §\C{// int x}§ +*y; §\C{// int * y}§ +f( p1, p2 ); §\C{// int f( int p1, int p2 );}§ +g( p1, p2 ) int p1, p2; §\C{// int g( int p1, int p2 );}§ \end{cfa} \CFA continues to support K\&R routine definitions: \begin{cfa} -f( a, b, c ) §\C{// default int return}§ - int a, b; char c §\C{// K\&R parameter declarations}§ +f( a, b, c ) §\C{// default int return}§ + int a, b; char c; §\C{// K\&R parameter declarations}§ { ... @@ -7486,5 +7591,5 @@ int rtn( int i ); int rtn( char c ); -rtn( 'x' ); §\C{// programmer expects 2nd rtn to be called}§ +rtn( 'x' ); §\C{// programmer expects 2nd rtn to be called}§ \end{cfa} \item[Rationale:] it is more intuitive for the call to ©rtn© to match the second version of definition of ©rtn© rather than the first. @@ -7508,6 +7613,6 @@ \item[Change:] make string literals ©const©: \begin{cfa} -char * p = "abc"; §\C{// valid in C, deprecated in \CFA}§ -char * q = expr ? "abc" : "de"; §\C{// valid in C, invalid in \CFA}§ +char * p = "abc"; §\C{// valid in C, deprecated in \CFA}§ +char * q = expr ? "abc" : "de"; §\C{// valid in C, invalid in \CFA}§ \end{cfa} The type of a string literal is changed from ©[] char© to ©const [] char©. @@ -7516,5 +7621,5 @@ \begin{cfa} char * p = "abc"; -p[0] = 'w'; §\C{// segment fault or change constant literal}§ +p[0] = 'w'; §\C{// segment fault or change constant literal}§ \end{cfa} The same problem occurs when passing a string literal to a routine that changes its argument. @@ -7528,7 +7633,7 @@ \item[Change:] remove \newterm{tentative definitions}, which only occurs at file scope: \begin{cfa} -int i; §\C{// forward definition}§ -int *j = ®&i®; §\C{// forward reference, valid in C, invalid in \CFA}§ -int i = 0; §\C{// definition}§ +int i; §\C{// forward definition}§ +int *j = ®&i®; §\C{// forward reference, valid in C, invalid in \CFA}§ +int i = 0; §\C{// definition}§ \end{cfa} is valid in C, and invalid in \CFA because duplicate overloaded object definitions at the same scope level are disallowed. @@ -7536,7 +7641,7 @@ \begin{cfa} struct X { int i; struct X *next; }; -static struct X a; §\C{// forward definition}§ -static struct X b = { 0, ®&a® };§\C{// forward reference, valid in C, invalid in \CFA}§ -static struct X a = { 1, &b }; §\C{// definition}§ +static struct X a; §\C{// forward definition}§ +static struct X b = { 0, ®&a® }; §\C{// forward reference, valid in C, invalid in \CFA}§ +static struct X a = { 1, &b }; §\C{// definition}§ \end{cfa} \item[Rationale:] avoids having different initialization rules for builtin types and user-defined types. @@ -7552,15 +7657,15 @@ enum ®Colour® { R, G, B, Y, C, M }; struct Person { - enum ®Colour® { R, G, B }; $\C[7cm]{// nested type}$ - struct Face { §\C{// nested type}§ - ®Colour® Eyes, Hair; §\C{// type defined outside (1 level)}§ + enum ®Colour® { R, G, B }; §\C{// nested type}§ + struct Face { §\C{// nested type}§ + ®Colour® Eyes, Hair; §\C{// type defined outside (1 level)}§ }; - ®.Colour® shirt; §\C{// type defined outside (top level)}§ - ®Colour® pants; §\C{// type defined same level}§ - Face looks[10]; §\C{// type defined same level}§ + ®.Colour® shirt; §\C{// type defined outside (top level)}§ + ®Colour® pants; §\C{// type defined same level}§ + Face looks[10]; §\C{// type defined same level}§ }; -®Colour® c = R; §\C{// type/enum defined same level}§ -Person®.Colour® pc = Person®.®R;§\C{// type/enum defined inside}§ -Person®.®Face pretty; §\C{// type defined inside}\CRT§ +®Colour® c = R; §\C{// type/enum defined same level}§ +Person®.Colour® pc = Person®.®R; §\C{// type/enum defined inside}§ +Person®.®Face pretty; §\C{// type defined inside}§ \end{cfa} In C, the name of the nested types belongs to the same scope as the name of the outermost enclosing structure, \ie the nested types are hoisted to the scope of the outer-most type, which is not useful and confusing. @@ -7639,4 +7744,19 @@ \CFA introduces the following new \Index{keyword}s, which cannot be used as identifiers. +\begin{cquote} +\Indexc{basetypeof}, \Indexc{choose}, \Indexc{coroutine}, \Indexc{disable}, +\Indexc{enable}, \Indexc{exception}, \Indexc{fallthrough}, \Indexc{fallthru}, +\Indexc{finally}, \Indexc{fixup}, \Indexc{forall},\Indexc{generator}, +\Indexc{int128}, \Indexc{monitor}, \Indexc{mutex}, \Indexc{one_t}, +\Indexc{report}, \Indexc{suspend}, \Indexc{throw}, \Indexc{throwResume}, +\Indexc{trait}, \Indexc{try}, \Indexc{virtual}, \Indexc{waitfor}, +\Indexc{when}, \Indexc{with}, \Indexc{zero_t} +\end{cquote} +\CFA introduces the following new \Index{quasi-keyword}s, which can be used as identifiers. +\begin{cquote} +\Indexc{catch}, \Indexc{catchResume}, \Indexc{finally}, \Indexc{fixup}, \Indexc{or}, \Indexc{timeout} +\end{cquote} + +\begin{comment} \begin{cquote} \begin{tabular}{@{}lllllll@{}} @@ -7707,9 +7827,24 @@ \end{tabular} \end{cquote} +\end{comment} + \section{Standard Headers} \label{s:StandardHeaders} -\Celeven prescribes the following standard header-files~\cite[\S~7.1.2]{C11} and \CFA adds to this list: +\Celeven prescribes the following standard header-files~\cite[\S~7.1.2]{C11}: +\begin{cquote} +\Indexc{assert.h}, \Indexc{complex.h}, \Indexc{ctype.h}, \Indexc{errno.h}, \Indexc{fenv.h}, +\Indexc[deletekeywords=float]{float.h}, \Indexc{inttypes.h}, \Indexc{iso646.h}, \Indexc{limits.h}, +\Indexc{locale.h}, \Indexc{math.h}, \Indexc{setjmp.h}, \Indexc{signal.h}, \Indexc{stdalign.h}, +\Indexc{stdarg.h}, \Indexc{stdatomic.h}, \Indexc{stdbool.h}, \Indexc{stddef.h}, \Indexc{stdint.h}, +\Indexc{stdio.h}, \Indexc{stdlib.h}, \Indexc{stdnoreturn.h}, \Indexc{string.h}, \Indexc{tgmath.h}, +\Indexc{threads.h}, \Indexc{time.h}, \Indexc{uchar.h}, \Indexc{wchar.h}, \Indexc{wctype.h} +\end{cquote} +and \CFA adds to this list: +\begin{cquote} +\Indexc{gmp.h}, \Indexc{malloc.h}, \Indexc{unistd.h} +\end{cquote} +\begin{comment} \begin{cquote} \begin{tabular}{@{}llllll|l@{}} @@ -7773,4 +7908,5 @@ \end{tabular} \end{cquote} +\end{comment} For the prescribed head-files, \CFA uses header interposition to wraps these includes in an ©extern "C"©; hence, names in these include files are not mangled\index{mangling!name} \see{\VRef{s:Interoperability}}. @@ -7837,7 +7973,7 @@ Type-safe allocation is provided for all C allocation routines and new \CFA allocation routines, \eg in \begin{cfa} -int * ip = (int *)malloc( sizeof(int) ); §\C{// C}§ -int * ip = malloc(); §\C{// \CFA type-safe version of C malloc}§ -int * ip = alloc(); §\C{// \CFA type-safe uniform alloc}§ +int * ip = (int *)malloc( sizeof(int) ); §\C{// C}§ +int * ip = malloc(); §\C{// \CFA type-safe version of C malloc}§ +int * ip = alloc(); §\C{// \CFA type-safe uniform alloc}§ \end{cfa} the latter two allocations determine the allocation size from the type of ©p© (©int©) and cast the pointer to the allocated storage to ©int *©. @@ -7846,5 +7982,5 @@ \begin{cfa} struct S { int i; } __attribute__(( aligned( 128 ) )); // cache-line alignment -S * sp = malloc(); §\C{// honour type alignment}§ +S * sp = malloc(); §\C{// honour type alignment}§ \end{cfa} the storage allocation is implicitly aligned to 128 rather than the default 16. @@ -7861,13 +7997,13 @@ \CFA memory management extends allocation to support constructors for initialization of allocated storage, \eg in \begin{cfa} -struct S { int i; }; §\C{// cache-line alignment}§ +struct S { int i; }; §\C{// cache-line alignment}§ void ?{}( S & s, int i ) { s.i = i; } // assume ?|? operator for printing an S -S & sp = *®new®( 3 ); §\C{// call constructor after allocation}§ +S & sp = *®new®( 3 ); §\C{// call constructor after allocation}§ sout | sp.i; ®delete®( &sp ); -S * spa = ®anew®( 10, 5 ); §\C{// allocate array and initialize each array element}§ +S * spa = ®anew®( 10, 5 ); §\C{// allocate array and initialize each array element}§ for ( i; 10 ) sout | spa[i] | nonl; sout | nl; @@ -7881,15 +8017,15 @@ extern "C" { // C unsafe allocation - void * malloc( size_t size );$\indexc{malloc}$ - void * calloc( size_t dim, size_t size );$\indexc{calloc}$ - void * realloc( void * ptr, size_t size );$\indexc{realloc}$ - void * memalign( size_t align, size_t size );$\indexc{memalign}$ - void * aligned_alloc( size_t align, size_t size );$\indexc{aligned_alloc}$ - int posix_memalign( void ** ptr, size_t align, size_t size );$\indexc{posix_memalign}$ - void * cmemalign( size_t alignment, size_t noOfElems, size_t elemSize );$\indexc{cmemalign}$ // CFA + void * malloc( size_t size );§\indexc{malloc}§ + void * calloc( size_t dim, size_t size );§\indexc{calloc}§ + void * realloc( void * ptr, size_t size );§\indexc{realloc}§ + void * memalign( size_t align, size_t size );§\indexc{memalign}§ + void * aligned_alloc( size_t align, size_t size );§\indexc{aligned_alloc}§ + int posix_memalign( void ** ptr, size_t align, size_t size );§\indexc{posix_memalign}§ + void * cmemalign( size_t alignment, size_t noOfElems, size_t elemSize );§\indexc{cmemalign}§ // CFA // C unsafe initialization/copy - void * memset( void * dest, int c, size_t size );$\indexc{memset}$ - void * memcpy( void * dest, const void * src, size_t size );$\indexc{memcpy}$ + void * memset( void * dest, int c, size_t size );§\indexc{memset}§ + void * memcpy( void * dest, const void * src, size_t size );§\indexc{memcpy}§ } @@ -7897,5 +8033,5 @@ forall( dtype T | sized(T) ) { - // $\CFA$ safe equivalents, i.e., implicit size specification + // §\CFA§ safe equivalents, i.e., implicit size specification T * malloc( void ); T * calloc( size_t dim ); @@ -7906,10 +8042,10 @@ int posix_memalign( T ** ptr, size_t align ); - // $\CFA$ safe general allocation, fill, resize, alignment, array - T * alloc( void );$\indexc{alloc}$ $\C[3.5in]{// variable, T size}$ + // §\CFA§ safe general allocation, fill, resize, alignment, array + T * alloc( void );§\indexc{alloc}§ §\C[3.5in]{// variable, T size}§ T * alloc( size_t dim ); §\C{// array[dim], T size elements}§ T * alloc( T ptr[], size_t dim ); §\C{// realloc array[dim], T size elements}§ - T * alloc_set( char fill );$\indexc{alloc_set}$ §\C{// variable, T size, fill bytes with value}§ + T * alloc_set( char fill );§\indexc{alloc_set}§ §\C{// variable, T size, fill bytes with value}§ T * alloc_set( T fill ); §\C{// variable, T size, fill with value}§ T * alloc_set( size_t dim, char fill ); §\C{// array[dim], T size elements, fill bytes with value}§ @@ -7930,22 +8066,22 @@ T * alloc_align_set( T ptr[], size_t align, size_t dim, char fill ); §\C{// realloc new aligned array[dim], fill new bytes with value}§ - // $\CFA$ safe initialization/copy, i.e., implicit size specification - T * memset( T * dest, char fill );$\indexc{memset}$ - T * memcpy( T * dest, const T * src );$\indexc{memcpy}$ - - // $\CFA$ safe initialization/copy, i.e., implicit size specification, array types + // §\CFA§ safe initialization/copy, i.e., implicit size specification + T * memset( T * dest, char fill );§\indexc{memset}§ + T * memcpy( T * dest, const T * src );§\indexc{memcpy}§ + + // §\CFA§ safe initialization/copy, i.e., implicit size specification, array types T * amemset( T dest[], char fill, size_t dim ); T * amemcpy( T dest[], const T src[], size_t dim ); } -// $\CFA$ allocation/deallocation and constructor/destructor, non-array types -forall( dtype T | sized(T), ttype Params | { void ?{}( T &, Params ); } ) T * new( Params p );$\indexc{new}$ -forall( dtype T | sized(T) | { void ^?{}( T & ); } ) void delete( T * ptr );$\indexc{delete}$ +// §\CFA§ allocation/deallocation and constructor/destructor, non-array types +forall( dtype T | sized(T), ttype Params | { void ?{}( T &, Params ); } ) T * new( Params p );§\indexc{new}§ +forall( dtype T | sized(T) | { void ^?{}( T & ); } ) void delete( T * ptr );§\indexc{delete}§ forall( dtype T, ttype Params | sized(T) | { void ^?{}( T & ); void delete( Params ); } ) void delete( T * ptr, Params rest ); -// $\CFA$ allocation/deallocation and constructor/destructor, array types -forall( dtype T | sized(T), ttype Params | { void ?{}( T &, Params ); } ) T * anew( size_t dim, Params p );$\indexc{anew}$ -forall( dtype T | sized(T) | { void ^?{}( T & ); } ) void adelete( size_t dim, T arr[] );$\indexc{adelete}$ +// §\CFA§ allocation/deallocation and constructor/destructor, array types +forall( dtype T | sized(T), ttype Params | { void ?{}( T &, Params ); } ) T * anew( size_t dim, Params p );§\indexc{anew}§ +forall( dtype T | sized(T) | { void ^?{}( T & ); } ) void adelete( size_t dim, T arr[] );§\indexc{adelete}§ forall( dtype T | sized(T) | { void ^?{}( T & ); }, ttype Params | { void adelete( Params ); } ) void adelete( size_t dim, T arr[], Params rest ); @@ -7957,5 +8093,5 @@ \leavevmode \begin{cfa}[aboveskip=0pt,belowskip=0pt] -int ato( const char * ptr );$\indexc{ato}$ +int ato( const char * ptr );§\indexc{ato}§ unsigned int ato( const char * ptr ); long int ato( const char * ptr ); @@ -7990,5 +8126,5 @@ \begin{cfa}[aboveskip=0pt,belowskip=0pt] forall( T | { int ??( T, T ); } ) T max( T t1, T t2 );$\indexc{max}$ -forall( T | { T min( T, T ); T max( T, T ); } ) T clamp( T value, T min_val, T max_val );$\indexc{clamp}$ -forall( T ) void swap( T * t1, T * t2 );$\indexc{swap}$ +forall( T | { int ??( T, T ); } ) T max( T t1, T t2 );§\indexc{max}§ +forall( T | { T min( T, T ); T max( T, T ); } ) T clamp( T value, T min_val, T max_val );§\indexc{clamp}§ +forall( T ) void swap( T * t1, T * t2 );§\indexc{swap}§ \end{cfa} @@ -8090,5 +8226,5 @@ \leavevmode \begin{cfa}[aboveskip=0pt,belowskip=0pt] -float ?%?( float, float );$\indexc{fmod}$ +float ?%?( float, float );§\indexc{fmod}§ float fmod( float, float ); double ?%?( double, double ); @@ -8097,9 +8233,9 @@ long double fmod( long double, long double ); -float remainder( float, float );$\indexc{remainder}$ +float remainder( float, float );§\indexc{remainder}§ double remainder( double, double ); long double remainder( long double, long double ); -float remquo( float, float, int * );$\indexc{remquo}$ +float remquo( float, float, int * );§\indexc{remquo}§ double remquo( double, double, int * ); long double remquo( long double, long double, int * ); @@ -8112,13 +8248,13 @@ [ int, long double ] div( long double, long double ); -float fma( float, float, float );$\indexc{fma}$ +float fma( float, float, float );§\indexc{fma}§ double fma( double, double, double ); long double fma( long double, long double, long double ); -float fdim( float, float );$\indexc{fdim}$ +float fdim( float, float );§\indexc{fdim}§ double fdim( double, double ); long double fdim( long double, long double ); -float nan( const char * );$\indexc{nan}$ +float nan( const char * );§\indexc{nan}§ double nan( const char * ); long double nan( const char * ); @@ -8130,5 +8266,5 @@ \leavevmode \begin{cfa}[aboveskip=0pt,belowskip=0pt] -float exp( float );$\indexc{exp}$ +float exp( float );§\indexc{exp}§ double exp( double ); long double exp( long double ); @@ -8137,5 +8273,5 @@ long double _Complex exp( long double _Complex ); -float exp2( float );$\indexc{exp2}$ +float exp2( float );§\indexc{exp2}§ double exp2( double ); long double exp2( long double ); @@ -8144,9 +8280,9 @@ // long double _Complex exp2( long double _Complex ); -float expm1( float );$\indexc{expm1}$ +float expm1( float );§\indexc{expm1}§ double expm1( double ); long double expm1( long double ); -float pow( float, float );$\indexc{pow}$ +float pow( float, float );§\indexc{pow}§ double pow( double, double ); long double pow( long double, long double ); @@ -8161,5 +8297,5 @@ \leavevmode \begin{cfa}[aboveskip=0pt,belowskip=0pt] -float log( float );$\indexc{log}$ +float log( float );§\indexc{log}§ double log( double ); long double log( long double ); @@ -8168,5 +8304,5 @@ long double _Complex log( long double _Complex ); -int log2( unsigned int );$\indexc{log2}$ +int log2( unsigned int );§\indexc{log2}§ long int log2( unsigned long int ); long long int log2( unsigned long long int ) @@ -8178,5 +8314,5 @@ // long double _Complex log2( long double _Complex ); -float log10( float );$\indexc{log10}$ +float log10( float );§\indexc{log10}§ double log10( double ); long double log10( long double ); @@ -8185,17 +8321,17 @@ // long double _Complex log10( long double _Complex ); -float log1p( float );$\indexc{log1p}$ +float log1p( float );§\indexc{log1p}§ double log1p( double ); long double log1p( long double ); -int ilogb( float );$\indexc{ilogb}$ +int ilogb( float );§\indexc{ilogb}§ int ilogb( double ); int ilogb( long double ); -float logb( float );$\indexc{logb}$ +float logb( float );§\indexc{logb}§ double logb( double ); long double logb( long double ); -float sqrt( float );$\indexc{sqrt}$ +float sqrt( float );§\indexc{sqrt}§ double sqrt( double ); long double sqrt( long double ); @@ -8204,9 +8340,9 @@ long double _Complex sqrt( long double _Complex ); -float cbrt( float );$\indexc{cbrt}$ +float cbrt( float );§\indexc{cbrt}§ double cbrt( double ); long double cbrt( long double ); -float hypot( float, float );$\indexc{hypot}$ +float hypot( float, float );§\indexc{hypot}§ double hypot( double, double ); long double hypot( long double, long double ); @@ -8218,5 +8354,5 @@ \leavevmode \begin{cfa}[aboveskip=0pt,belowskip=0pt] -float sin( float );$\indexc{sin}$ +float sin( float );§\indexc{sin}§ double sin( double ); long double sin( long double ); @@ -8225,5 +8361,5 @@ long double _Complex sin( long double _Complex ); -float cos( float );$\indexc{cos}$ +float cos( float );§\indexc{cos}§ double cos( double ); long double cos( long double ); @@ -8232,5 +8368,5 @@ long double _Complex cos( long double _Complex ); -float tan( float );$\indexc{tan}$ +float tan( float );§\indexc{tan}§ double tan( double ); long double tan( long double ); @@ -8239,5 +8375,5 @@ long double _Complex tan( long double _Complex ); -float asin( float );$\indexc{asin}$ +float asin( float );§\indexc{asin}§ double asin( double ); long double asin( long double ); @@ -8246,5 +8382,5 @@ long double _Complex asin( long double _Complex ); -float acos( float );$\indexc{acos}$ +float acos( float );§\indexc{acos}§ double acos( double ); long double acos( long double ); @@ -8253,5 +8389,5 @@ long double _Complex acos( long double _Complex ); -float atan( float );$\indexc{atan}$ +float atan( float );§\indexc{atan}§ double atan( double ); long double atan( long double ); @@ -8260,10 +8396,10 @@ long double _Complex atan( long double _Complex ); -float atan2( float, float );$\indexc{atan2}$ +float atan2( float, float );§\indexc{atan2}§ double atan2( double, double ); long double atan2( long double, long double ); float atan( float, float ); §\C{// alternative name for atan2}§ -double atan( double, double );$\indexc{atan}$ +double atan( double, double );§\indexc{atan}§ long double atan( long double, long double ); \end{cfa} @@ -8274,5 +8410,5 @@ \leavevmode \begin{cfa}[aboveskip=0pt,belowskip=0pt] -float sinh( float );$\indexc{sinh}$ +float sinh( float );§\indexc{sinh}§ double sinh( double ); long double sinh( long double ); @@ -8281,5 +8417,5 @@ long double _Complex sinh( long double _Complex ); -float cosh( float );$\indexc{cosh}$ +float cosh( float );§\indexc{cosh}§ double cosh( double ); long double cosh( long double ); @@ -8288,5 +8424,5 @@ long double _Complex cosh( long double _Complex ); -float tanh( float );$\indexc{tanh}$ +float tanh( float );§\indexc{tanh}§ double tanh( double ); long double tanh( long double ); @@ -8295,5 +8431,5 @@ long double _Complex tanh( long double _Complex ); -float asinh( float );$\indexc{asinh}$ +float asinh( float );§\indexc{asinh}§ double asinh( double ); long double asinh( long double ); @@ -8302,5 +8438,5 @@ long double _Complex asinh( long double _Complex ); -float acosh( float );$\indexc{acosh}$ +float acosh( float );§\indexc{acosh}§ double acosh( double ); long double acosh( long double ); @@ -8309,5 +8445,5 @@ long double _Complex acosh( long double _Complex ); -float atanh( float );$\indexc{atanh}$ +float atanh( float );§\indexc{atanh}§ double atanh( double ); long double atanh( long double ); @@ -8322,5 +8458,5 @@ \leavevmode \begin{cfa}[aboveskip=0pt,belowskip=0pt] -float erf( float );$\indexc{erf}$ +float erf( float );§\indexc{erf}§ double erf( double ); long double erf( long double ); @@ -8329,5 +8465,5 @@ long double _Complex erf( long double _Complex ); -float erfc( float );$\indexc{erfc}$ +float erfc( float );§\indexc{erfc}§ double erfc( double ); long double erfc( long double ); @@ -8336,5 +8472,5 @@ long double _Complex erfc( long double _Complex ); -float lgamma( float );$\indexc{lgamma}$ +float lgamma( float );§\indexc{lgamma}§ double lgamma( double ); long double lgamma( long double ); @@ -8343,5 +8479,5 @@ long double lgamma( long double, int * ); -float tgamma( float );$\indexc{tgamma}$ +float tgamma( float );§\indexc{tgamma}§ double tgamma( double ); long double tgamma( long double ); @@ -8389,17 +8525,17 @@ unsigned long long int ceiling( unsigned long long int n, unsigned long long int align ); -float floor( float );$\indexc{floor}$ +float floor( float );§\indexc{floor}§ double floor( double ); long double floor( long double ); -float ceil( float );$\indexc{ceil}$ +float ceil( float );§\indexc{ceil}§ double ceil( double ); long double ceil( long double ); -float trunc( float );$\indexc{trunc}$ +float trunc( float );§\indexc{trunc}§ double trunc( double ); long double trunc( long double ); -float rint( float );$\indexc{rint}$ +float rint( float );§\indexc{rint}§ long double rint( long double ); long int rint( float ); @@ -8410,5 +8546,5 @@ long long int rint( long double ); -long int lrint( float );$\indexc{lrint}$ +long int lrint( float );§\indexc{lrint}§ long int lrint( double ); long int lrint( long double ); @@ -8417,9 +8553,9 @@ long long int llrint( long double ); -float nearbyint( float );$\indexc{nearbyint}$ +float nearbyint( float );§\indexc{nearbyint}§ double nearbyint( double ); long double nearbyint( long double ); -float round( float );$\indexc{round}$ +float round( float );§\indexc{round}§ long double round( long double ); long int round( float ); @@ -8430,5 +8566,5 @@ long long int round( long double ); -long int lround( float );$\indexc{lround}$ +long int lround( float );§\indexc{lround}§ long int lround( double ); long int lround( long double ); @@ -8443,17 +8579,17 @@ \leavevmode \begin{cfa}[aboveskip=0pt,belowskip=0pt] -float copysign( float, float );$\indexc{copysign}$ +float copysign( float, float );§\indexc{copysign}§ double copysign( double, double ); long double copysign( long double, long double ); -float frexp( float, int * );$\indexc{frexp}$ +float frexp( float, int * );§\indexc{frexp}§ double frexp( double, int * ); long double frexp( long double, int * ); -float ldexp( float, int );$\indexc{ldexp}$ +float ldexp( float, int );§\indexc{ldexp}§ double ldexp( double, int ); long double ldexp( long double, int ); -[ float, float ] modf( float );$\indexc{modf}$ +[ float, float ] modf( float );§\indexc{modf}§ float modf( float, float * ); [ double, double ] modf( double ); @@ -8462,17 +8598,17 @@ long double modf( long double, long double * ); -float nextafter( float, float );$\indexc{nextafter}$ +float nextafter( float, float );§\indexc{nextafter}§ double nextafter( double, double ); long double nextafter( long double, long double ); -float nexttoward( float, long double );$\indexc{nexttoward}$ +float nexttoward( float, long double );§\indexc{nexttoward}§ double nexttoward( double, long double ); long double nexttoward( long double, long double ); -float scalbn( float, int );$\indexc{scalbn}$ +float scalbn( float, int );§\indexc{scalbn}§ double scalbn( double, int ); long double scalbn( long double, int ); -float scalbln( float, long int );$\indexc{scalbln}$ +float scalbln( float, long int );§\indexc{scalbln}§ double scalbln( double, long int ); long double scalbln( long double, long int ); @@ -8734,5 +8870,5 @@ All \newterm{pseudo random-number generators} (\newterm{PRNG}) involve some technique to scramble bits of a value, \eg multiplicative recurrence: \begin{cfa} -rand = 36973 * (rand & 65535) + (rand >> 16); // scramble bits +rand = 33967 * (rand + 1063); // scramble bits \end{cfa} Multiplication of large values adds new least-significant bits and drops most-significant bits. @@ -8741,9 +8877,9 @@ bits 63--32 (most) & bits 31--0 (least) \\ \hline -0x0 & 0x3e8e36 \\ -0x5f & 0x718c25e1 \\ -0xad3e & 0x7b5f1dbe \\ -0xbc3b & 0xac69ff19 \\ -0x1070f & 0x2d258dc6 \\ +©0x0© & ©0x3e8e36© \\ +©0x5f© & ©0x718c25e1© \\ +©0xad3e© & ©0x7b5f1dbe© \\ +©0xbc3b© & ©0xac69ff19© \\ +©0x1070f© & ©0x2d258dc6© \end{tabular} \end{quote} @@ -8751,36 +8887,53 @@ The least-significant bits \emph{appear} random but the same bits are always generated given a fixed starting value, called the \newterm{seed} (value 0x3e8e36 above). Hence, if a program uses the same seed, the same sequence of pseudo-random values is generated from the PRNG. -Often the seed is set to another random value like a program's process identifier (©getpid©\index{getpid@©getpid©}) or time when the program is run; +Often the seed is set to another random value like a program's process identifier (\Indexc{getpid}) or time when the program is run; hence, one random value bootstraps another. Finally, a PRNG usually generates a range of large values, \eg ©[0, UINT_MAX]©, which are scaled using the modulus operator, \eg ©prng() % 5© produces random values in the range 0--4. -\CFA provides a sequential PRNG type only accessible by a single thread (not thread-safe) and a set of global and companion thread PRNG functions accessible by multiple threads without contention. +\CFA provides 32/64-bit sequential PRNG type only accessible by a single thread (not thread-safe) and a set of global routines and companion thread PRNG functions accessible by multiple threads without contention. +To use the PRNG interface \Textbf{requires including \Indexc{stdlib.hfa}}. \begin{itemize} \item -The ©PRNG© type is for sequential programs, like coroutining: -\begin{cfa} -struct PRNG { ... }; $\C[3.75in]{// opaque type}$ -void ?{}( PRNG & prng ); §\C{// random seed}§ -void ?{}( PRNG & prng, uint32_t seed ); §\C{// fixed seed}§ -void set_seed( PRNG & prng, uint32_t seed ); §\C{// set seed}§ -uint32_t get_seed( PRNG & prng ); §\C{// get seed}§ -uint32_t prng( PRNG & prng ); §\C{// [0,UINT\_MAX]}§ -uint32_t prng( PRNG & prng, uint32_t u ); §\C{// [0,u)}§ -uint32_t prng( PRNG & prng, uint32_t l, uint32_t u ); §\C{// [l,u]}§ -uint32_t calls( PRNG & prng ); §\C{// number of calls}\CRT§ -\end{cfa} +The ©PRNG© types for sequential programs, including coroutining, are: +\begin{cfa} +struct PRNG32 {}; §\C{// opaque type, no copy or assignment}§ +void ?{}( PRNG32 & prng, uint32_t seed ); §\C{// fixed seed}§ +void ?{}( PRNG32 & prng ); §\C{// random seed}§ +void set_seed( PRNG32 & prng, uint32_t seed ); §\C{// set seed}§ +uint32_t get_seed( PRNG32 & prng ); §\C{// get seed}§ +uint32_t prng( PRNG32 & prng ); §\C{// [0,UINT\_MAX]}§ +uint32_t prng( PRNG32 & prng, uint32_t u ); §\C{// [0,u)}§ +uint32_t prng( PRNG32 & prng, uint32_t l, uint32_t u ); §\C{// [l,u]}§ +uint32_t calls( PRNG32 & prng ); §\C{// number of calls}§ +void copy( PRNG32 & dst, PRNG32 & src ); §\C{// checkpoint PRNG state}§ +\end{cfa} +\begin{cfa} +struct PRNG64 {}; §\C{// opaque type, no copy or assignment}§ +void ?{}( PRNG64 & prng, uint64_t seed ); §\C{// fixed seed}§ +void ?{}( PRNG64 & prng ); §\C{// random seed}§ +void set_seed( PRNG64 & prng, uint64_t seed ); §\C{// set seed}§ +uint64_t get_seed( PRNG64 & prng ); §\C{// get seed}§ +uint64_t prng( PRNG64 & prng ); §\C{// [0,UINT\_MAX]}§ +uint64_t prng( PRNG64 & prng, uint64_t u ); §\C{// [0,u)}§ +uint64_t prng( PRNG64 & prng, uint64_t l, uint64_t u ); §\C{// [l,u]}§ +uint64_t calls( PRNG64 & prng ); §\C{// number of calls}§ +void copy( PRNG64 & dst, PRNG64 & src ); §\C{// checkpoint PRNG state}§ +\end{cfa} +The type ©PRNG© is aliased to ©PRNG64© on 64-bit architectures and ©PRNG32© on 32-bit architectures. A ©PRNG© object is used to randomize behaviour or values during execution, \eg in games, a character makes a random move or an object takes on a random value. In this scenario, it is useful to have multiple ©PRNG© objects, \eg one per player or object. -However, sequential execution is still repeatable given the same starting seeds for all ©PRNG©s. +However, sequential execution is still repeatable given the same starting seeds for all ©PRNG©s. \VRef[Figure]{f:SequentialPRNG} shows an example that creates two sequential ©PRNG©s, sets both to the same seed (1009), and illustrates the three forms for generating random values, where both ©PRNG©s generate the same sequence of values. +Note, to prevent accidental PRNG copying, the copy constructor and assignment are hidden. +To copy a PRNG for checkpointing, use the explicit ©copy© member. \begin{figure} \begin{cfa} -PRNG prng1, prng2; -®set_seed( prng1, 1009 )®; ®set_seed( prng2, 1009 )®; +PRNG sprng1, sprng2; §\C{// select appropriate 32/64-bit PRNG}§ +®set_seed( sprng1, 1009 )®; ®set_seed( sprng2, 1009 )®; for ( 10 ) { // Do not cascade prng calls because side-effect functions called in arbitrary order. - sout | nlOff | ®prng( prng1 )®; sout | ®prng( prng1, 5 )®; sout | ®prng( prng1, 0, 5 )® | '\t'; - sout | ®prng( prng2 )®; sout | ®prng( prng2, 5 )®; sout | ®prng( prng2, 0, 5 )® | nlOn; + sout | nlOff | ®prng( sprng1 )®; sout | ®prng( sprng1, 5 )®; sout | ®prng( sprng1, 0, 5 )® | '\t'; + sout | ®prng( sprng2 )®; sout | ®prng( sprng2, 5 )®; sout | ®prng( sprng2, 0, 5 )® | nlOn; } \end{cfa} @@ -8821,14 +8974,14 @@ The PRNG global and companion thread functions are for concurrent programming, such as randomizing execution in short-running programs, \eg ©yield( prng() % 5 )©. \begin{cfa} -void set_seed( uint32_t seed ); $\C[3.75in]{// set global seed}$ -uint32_t get_seed(); §\C{// get global seed}§ -// SLOWER -uint32_t prng(); §\C{// [0,UINT\_MAX]}§ -uint32_t prng( uint32_t u ); §\C{// [0,u)}§ -uint32_t prng( uint32_t l, uint32_t u ); §\C{// [l,u]}§ -// FASTER -uint32_t prng( $thread\LstStringStyle{\textdollar}$ & th ); §\C{// [0,UINT\_MAX]}§ -uint32_t prng( $thread\LstStringStyle{\textdollar}$ & th, uint32_t u ); §\C{// [0,u)}§ -uint32_t prng( $thread\LstStringStyle{\textdollar}$ & th, uint32_t l, uint32_t u ); §\C{// [l,u]}\CRT§ +void set_seed( size_t seed ); §\C{// set global seed}§ +size_t get_seed(); §\C{// get global seed}§ +// SLOWER, global routines +size_t prng( void ); §\C{// [0,UINT\_MAX]}§ +size_t prng( size_t u ); §\C{// [0,u)}§ +size_t prng( size_t l, size_t u ); §\C{// [l,u]}§ +// FASTER, thread members +size_t prng( §thread\LstStringStyle{\textdollar}§ & th ); §\C{// [0,UINT\_MAX]}§ +size_t prng( §thread\LstStringStyle{\textdollar}§ & th, size_t u ); §\C{// [0,u)}§ +size_t prng( §thread\LstStringStyle{\textdollar}§ & th, size_t l, size_t u ); §\C{// [l,u]}§ \end{cfa} The only difference between the two sets of ©prng© routines is performance. @@ -8841,5 +8994,5 @@ Hence, these threads generate different sequences of random numbers. If each thread needs its own seed, use a sequential ©PRNG© in each thread. -The slower ©prng© functions \emph{without} a thread argument call ©active_thread© internally to indirectly access the current thread's PRNG state, while the faster ©prng© functions \emph{with} a thread argument directly access the thread through the thread parameter. +The slower ©prng© global functions, \ie \emph{without} a thread argument, call ©active_thread© internally to indirectly access the current thread's PRNG state, while the faster ©prng© functions, \ie \emph{with} a thread argument, directly access the thread through the thread parameter. If a thread pointer is available, \eg in thread main, eliminating the call to ©active_thread© significantly reduces the cost of accessing the thread's PRNG state. \VRef[Figure]{f:ConcurrentPRNG} shows an example using the slower/faster concurrent PRNG in the program main and a thread. @@ -8856,5 +9009,5 @@ int main() { set_seed( 1009 ); - $\R{thread\LstStringStyle{\textdollar}}$ ®& th = *active_thread()®; // program-main thread-address + §\R{thread\LstStringStyle{\textdollar}}§ ®& th = *active_thread()®; // program-main thread-address for ( i; 10 ) { sout | nlOff | ®prng()®; sout | ®prng( 5 )®; sout | ®prng( 0, 5 )® | '\t'; // SLOWER @@ -9079,5 +9232,5 @@ \hline \begin{cfa} -#include $\indexc{gmp.h}$ +#include §\indexc{gmp.h}§ int main( void ) { ®gmp_printf®( "Factorial Numbers\n" ); @@ -9093,5 +9246,5 @@ & \begin{cfa} -#include $\indexc{gmp}$ +#include §\indexc{gmp}§ int main( void ) { sout | "Factorial Numbers"; @@ -9165,5 +9318,5 @@ \begin{cfa}[belowskip=0pt] // implementation -struct Rational {$\indexc{Rational}$ +struct Rational {§\indexc{Rational}§ long int numerator, denominator; §\C{// invariant: denominator > 0}§ }; // Rational Index: libcfa/src/collections/string_res.cfa =================================================================== --- libcfa/src/collections/string_res.cfa (revision c75b30ae4d3f97678f27275a033614f675b7fdaf) +++ libcfa/src/collections/string_res.cfa (revision 32490deb2180d977e78b79e5c2342a8fa2357a53) @@ -10,6 +10,6 @@ // Created On : Fri Sep 03 11:00:00 2021 // Last Modified By : Peter A. Buhr -// Last Modified On : Tue Jan 16 22:19:27 2024 -// Update Count : 35 +// Last Modified On : Mon Jan 22 23:12:42 2024 +// Update Count : 43 // @@ -263,5 +263,5 @@ bool cont = false; - _Istream_Cstr cf = { cstr, (_Istream_str_base)f }; + _Istream_Cwidth cf = { cstr, (_Istream_str_base)f }; if ( ! cf.flags.rwd ) cf.wd = wd; Index: libcfa/src/fstream.cfa =================================================================== --- libcfa/src/fstream.cfa (revision c75b30ae4d3f97678f27275a033614f675b7fdaf) +++ libcfa/src/fstream.cfa (revision 32490deb2180d977e78b79e5c2342a8fa2357a53) @@ -10,6 +10,6 @@ // Created On : Wed May 27 17:56:53 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Wed Nov 15 10:51:14 2023 -// Update Count : 552 +// Last Modified On : Sun Jan 28 09:56:08 2024 +// Update Count : 554 // @@ -209,5 +209,5 @@ void ?{}( ifstream & is, void * file ) with( is ) { file$ = file; - nlOnOff$ = false; + nlOnOff$ = false; // => skip newlines when reading single characters } // ?{} Index: libcfa/src/iostream.cfa =================================================================== --- libcfa/src/iostream.cfa (revision c75b30ae4d3f97678f27275a033614f675b7fdaf) +++ libcfa/src/iostream.cfa (revision 32490deb2180d977e78b79e5c2342a8fa2357a53) @@ -10,6 +10,6 @@ // Created On : Wed May 27 17:56:53 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Wed Jan 3 10:53:13 2024 -// Update Count : 1898 +// Last Modified On : Sun Jan 28 11:58:54 2024 +// Update Count : 1917 // @@ -944,5 +944,5 @@ istype & nl( istype & is ) { fmt( is, "%*[^\n]" ); // ignore characters to newline - if ( ! eof( is ) && getANL$( is ) ) fmt( is, "%*c" ); // read newline + if ( ! eof( is ) ) fmt( is, "%*c" ); // read newline return is; } // nl @@ -984,86 +984,62 @@ } - istype & ?|?( istype & is, _Istream_Cquoted f ) with( f ) { - char fmtstr[32]; // storage scanset and format codes + istype & ?|?( istype & is, _Istream_Cquoted f ) with( f.cstr ) { + int args; + fini: { + args = fmt( is, "%*[ \f\n\r\t\v]" ); // remove leading whitespace + if ( eof( is ) ) break fini; + char rfmt[4] = { delimiters[0], '%', 'n', '\0' }; + int len = 0; // may not be set in fmt + args = fmt( is, rfmt, &len ); // remove leading quote + if ( len == 0 || eof( is ) ) break fini; + + // Change the remainder of the read into a getline by reseting the closing delimiter. + if ( delimiters[1] != '\0' ) { + delimiters[0] = delimiters[1]; + delimiters[1] = '\0'; + } // if + flags.delimiter = true; + return is | *(_Istream_Cstr *)&f; + } // fini + // read failed => no pattern match => set string to null + if ( ! flags.ignore && s != 0p && args == 0 ) s[0] = '\0'; + if ( args == 1 && eof( is ) ) { // data but scan ended at EOF + clear( is ); // => reset EOF => detect again on next read + } // if + return is; + } + + istype & ?|?( istype & is, _Istream_Cstr f ) with( f.cstr ) { + const char * scanset; + size_t nscanset = 0; + if ( flags.delimiter ) scanset = delimiters; // getline ? + else scanset = f.cstr.scanset; + if ( scanset ) nscanset = strlen( scanset ); + + char fmtstr[nscanset + 32]; // storage for scanset and format codes fmtstr[0] = '%'; - int pos = 1; int args; bool check = true; - if ( cstr.flags.ignore ) { check = false; fmtstr[1] = '*'; pos += 1; } - int rwd = cstr.wd; - if ( cstr.wd != -1 ) { // => just ignore versus ignore with width + if ( flags.ignore ) { check = false; fmtstr[1] = '*'; pos += 1; } + int rwd = wd; + if ( wd != -1 ) { // => just ignore versus ignore with width // wd is buffer bytes available (for input chars + null terminator) // rwd is count of input chars // no maximum width necessary because text ignored => width is read width - if ( cstr.flags.rwd ) check = false; - else rwd = cstr.wd - 1; + if ( flags.rwd ) check = false; + else rwd = wd - 1; + assert( rwd > 0 ); pos += sprintf( &fmtstr[pos], "%d", rwd ); } // if - int len = 0; // may not be set in fmt - char enddelim; - if ( ! cstr.flags.inex ) { // => quoted getline - args = fmt( is, "%*[ \f\n\r\t\v]" ); // remove leading whitespace - if ( eof( is ) ) goto Eof; - char rfmt[4] = { cstr.delimiters[0], '%', 'n', '\0' }; - args = fmt( is, rfmt, &len ); // remove leading quote - if ( len == 0 || eof( is ) ) goto Eof; - } // if - enddelim = cstr.delimiters[1] == '\0' ? cstr.delimiters[0] : cstr.delimiters[1]; - sprintf( &fmtstr[pos], "[^%c]%%n", enddelim ); - if ( cstr.flags.ignore ) args = fmt( is, fmtstr, &len ); // no string argument for '*' - else args = fmt( is, fmtstr, cstr.s, &len ); - if ( check && len == rwd && ! eof( is ) ) { // might not fit - char peek; - fmt( is, "%c", &peek ); // check for delimiter - if ( ! eof( is ) ) { - if ( peek != enddelim ) { - ungetc( is, peek ); - throwResume ExceptionInst( cstring_length ); - } // if - } // if - } else fmt( is, "%*c" ); // remove delimiter - Eof: ; - if ( rwd > 0 && args == 0 ) cstr.s[0] = '\0'; // read failed => no pattern match => set string to null - if ( args == 1 && eof( is ) ) { // data but scan ended at EOF - clear( is ); // => reset EOF => detect again on next read - } // if - return is; - } - - istype & ?|?( istype & is, _Istream_Cstr f ) with( f ) { - const char * scanset; - size_t nscanset = 0; - if ( flags.delimiter ) scanset = delimiters; // getline ? - else scanset = f.scanset; - if ( scanset ) nscanset = strlen( scanset ); - - char fmtstr[nscanset + 32]; // storage for scanset and format codes - fmtstr[0] = '%'; - - int pos = 1; - int args; - bool check = true; - - if ( f.flags.ignore ) { check = false; fmtstr[1] = '*'; pos += 1; } - int rwd = f.wd; - if ( f.wd != -1 ) { // => just ignore versus ignore with width - // wd is buffer bytes available (for input chars + null terminator) - // rwd is count of input chars - // no maximum width necessary because text ignored => width is read width - if ( f.flags.rwd ) check = false; - else rwd = f.wd - 1; - pos += sprintf( &fmtstr[pos], "%d", rwd ); - } // if - if ( ! scanset ) { // %s, %*s, %ws, %*ws - // fprintf( stderr, "cstr %s\n", f.s ); + // fprintf( stderr, "cstr %s\n", s ); strcpy( &fmtstr[pos], "s%n" ); int len = 0; // may not be set in fmt - if ( f.flags.ignore ) args = fmt( is, fmtstr, &len ); // no string argument for '*' - else args = fmt( is, fmtstr, f.s, &len ); - // fprintf( stderr, "cstr %s %d %d %d %s\n", fmtstr, args, len, f.wd, f.s ); + if ( flags.ignore ) args = fmt( is, fmtstr, &len ); // no string argument for '*' + else args = fmt( is, fmtstr, s, &len ); + // fprintf( stderr, "cstr %s %d %d %d %s\n", fmtstr, args, len, wd, s ); if ( check && len >= rwd && ! eof( is ) ) { // might not fit char peek; @@ -1076,18 +1052,21 @@ } // if // FIX ME: CFA strings need to be modified to NOT change the argument for this case, then this can be removed. - if ( rwd > 0 && args == 0 ) f.s[0]= '\0'; // read failed => no pattern match => set string to null + if ( ! flags.ignore && args == 0 ) s[0]= '\0'; // read failed => no pattern match => set string to null } else { - if ( f.flags.delimiter ) { // getline + if ( flags.delimiter ) { // getline int len = 0; // may not be set in fmt - sprintf( &fmtstr[pos], "[^%c]%%n", f.delimiters[0] ); - if ( f.flags.ignore ) args = fmt( is, fmtstr, &len ); // no string argument for '*' - else args = fmt( is, fmtstr, f.s, &len ); + if ( delimiters[2] != '\0' ) { // read single character ? + sprintf( &fmtstr[pos], "c%%n" ); + } else { + sprintf( &fmtstr[pos], "[^%c]%%n", delimiters[0] ); + } // if + if ( flags.ignore ) args = fmt( is, fmtstr, &len ); // no string argument for '*' + else args = fmt( is, fmtstr, s, &len ); if ( check && len == rwd && ! eof( is ) ) { // might not fit - fmtstr[0] = f.delimiters[0]; fmtstr[1] = '%'; fmtstr[2] = 'n'; fmtstr[3] = '\0'; - fmt( is, fmtstr, &len ); // remove delimiter + char peek; + fmt( is, "%c", &peek ); // check for delimiter if ( ! eof( is ) ) { -// if ( peek != f.delimiter[0] ) { - if ( len != 1 ) { -// ungetc( is, peek ); + if ( peek != delimiters[0] ) { + ungetc( is, peek ); throwResume ExceptionInst( cstring_length ); } // if @@ -1097,10 +1076,10 @@ // incl %[xxx], %*[xxx], %w[xxx], %*w[xxx] // excl %[^xxx], %*[^xxx], %w[^xxx], %*w[^xxx] - sprintf( &fmtstr[pos], "[%s%s]%%n", f.flags.inex ? "^" : "", scanset ); - // fprintf( stderr, "incl/excl %s %d\n", fmtstr, f.wd ); + sprintf( &fmtstr[pos], "[%s%s]%%n", flags.inex ? "^" : "", scanset ); + // fprintf( stderr, "incl/excl %s %d\n", fmtstr, wd ); int len = 0; // may not be set in fmt - if ( f.flags.ignore ) args = fmt( is, fmtstr, &len ); // no string argument for '*' - else args = fmt( is, fmtstr, f.s, &len ); - // fprintf( stderr, "incl/excl %s \"%s\" %d %d %d %d %d %c\n", fmtstr, f.s, args, f.wd, len, eof( is ), check, f.s[f.wd] ); + if ( flags.ignore ) args = fmt( is, fmtstr, &len ); // no string argument for '*' + else args = fmt( is, fmtstr, s, &len ); + // fprintf( stderr, "incl/excl %s \"%s\" %d %d %d %d %d %c\n", fmtstr, s, args, wd, len, eof( is ), check, s[wd] ); if ( check && len == rwd && ! eof( is ) ) { // might not fit // fprintf( stderr, "overflow\n" ); @@ -1110,9 +1089,9 @@ if ( ! eof( is ) ) { ungetc( is, peek ); - if ( f.flags.inex ^ strchr( f.scanset, peek ) != 0p ) throwResume ExceptionInst( cstring_length ); + if ( flags.inex ^ strchr( scanset, peek ) != 0p ) throwResume ExceptionInst( cstring_length ); } // if } // if } // if - if ( rwd > 0 && args == 0 ) f.s[0]= '\0'; // read failed => no pattern match => set string to null + if ( ! flags.ignore && args == 0 ) s[0]= '\0'; // read failed => no pattern match => set string to null } // if if ( args == 1 && eof( is ) ) { // data but scan ended at EOF @@ -1120,9 +1099,4 @@ clear( is ); // => reset EOF => detect again on next read } // if - return is; - } // ?|? - - istype & ?|?( istype & is, _Istream_Char f ) { - fmt( is, "%*c" ); // argument variable unused return is; } // ?|? @@ -1145,4 +1119,5 @@ } // distribution +INPUT_FMT_IMPL( char, "c" ) INPUT_FMT_IMPL( signed char, "hhi" ) INPUT_FMT_IMPL( unsigned char, "hhi" ) Index: libcfa/src/iostream.hfa =================================================================== --- libcfa/src/iostream.hfa (revision c75b30ae4d3f97678f27275a033614f675b7fdaf) +++ libcfa/src/iostream.hfa (revision 32490deb2180d977e78b79e5c2342a8fa2357a53) @@ -10,6 +10,6 @@ // Created On : Wed May 27 17:56:53 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Wed Jan 3 10:53:18 2024 -// Update Count : 610 +// Last Modified On : Sun Jan 28 11:56:29 2024 +// Update Count : 733 // @@ -196,22 +196,18 @@ // *********************************** integral *********************************** -// See 6.7.9. 19) The initialization shall occur in initializer list order, each initializer provided for a particular -// subobject overriding any previously listed initializer for the same subobject; ***all subobjects that are not -// initialized explicitly shall be initialized implicitly the same as objects that have static storage duration.*** - #define INTEGRAL_FMT_DECL( T, CODE ) \ static inline { \ - _Ostream_Manip(T) bin( T val ) { return (_Ostream_Manip(T))@{ val, 1, 0, 'b', { .all : 0 } }; } \ - _Ostream_Manip(T) oct( T val ) { return (_Ostream_Manip(T))@{ val, 1, 0, 'o', { .all : 0 } }; } \ - _Ostream_Manip(T) hex( T val ) { return (_Ostream_Manip(T))@{ val, 1, 0, 'x', { .all : 0 } }; } \ - _Ostream_Manip(T) wd( unsigned int w, T val ) { return (_Ostream_Manip(T))@{ val, w, 0, CODE, { .all : 0 } }; } \ - _Ostream_Manip(T) wd( unsigned int w, unsigned int pc, T val ) { return (_Ostream_Manip(T))@{ val, w, pc, CODE, { .flags.pc : true } }; } \ - _Ostream_Manip(T) & wd( unsigned int w, _Ostream_Manip(T) & fmt ) { fmt.wd = w; return fmt; } \ - _Ostream_Manip(T) & wd( unsigned int w, unsigned int pc, _Ostream_Manip(T) & fmt ) { fmt.wd = w; fmt.pc = pc; fmt.flags.pc = true; return fmt; } \ + _Ostream_Manip(T) bin( T val ) { return (_Ostream_Manip(T))@{ .val : val, .wd : 1, .pc : 0, .base : 'b', { .all : 0 } }; } \ + _Ostream_Manip(T) oct( T val ) { return (_Ostream_Manip(T))@{ .val : val, .wd : 1, .pc : 0, .base : 'o', { .all : 0 } }; } \ + _Ostream_Manip(T) hex( T val ) { return (_Ostream_Manip(T))@{ .val : val, .wd : 1, .pc : 0, .base : 'x', { .all : 0 } }; } \ + _Ostream_Manip(T) wd( unsigned int wd, T val ) { return (_Ostream_Manip(T))@{ .val : val, .wd : wd, .pc : 0, .base : CODE, { .all : 0 } }; } \ + _Ostream_Manip(T) wd( unsigned int wd, unsigned int pc, T val ) { return (_Ostream_Manip(T))@{ .val : val, .wd : wd, .pc : pc, .base : CODE, { .flags.pc : true } }; } \ + _Ostream_Manip(T) & wd( unsigned int wd, _Ostream_Manip(T) & fmt ) { fmt.wd = wd; return fmt; } \ + _Ostream_Manip(T) & wd( unsigned int wd, unsigned int pc, _Ostream_Manip(T) & fmt ) { fmt.wd = wd; fmt.pc = pc; fmt.flags.pc = true; return fmt; } \ _Ostream_Manip(T) & left( _Ostream_Manip(T) & fmt ) { fmt.flags.left = true; return fmt; } \ _Ostream_Manip(T) & upcase( _Ostream_Manip(T) & fmt ) { if ( fmt.base == 'x' || fmt.base == 'b' ) fmt.base -= 32; /* upper case */ return fmt; } \ _Ostream_Manip(T) & nobase( _Ostream_Manip(T) & fmt ) { fmt.flags.nobsdp = true; return fmt; } \ _Ostream_Manip(T) & pad0( _Ostream_Manip(T) & fmt ) { fmt.flags.pad0 = true; return fmt; } \ - _Ostream_Manip(T) sign( T val ) { return (_Ostream_Manip(T))@{ val, 1, 0, CODE, { .flags.sign : true } }; } \ + _Ostream_Manip(T) sign( T val ) { return (_Ostream_Manip(T))@{ .val : val, .wd : 1, .pc : 0, .base : CODE, { .flags.sign : true } }; } \ _Ostream_Manip(T) & sign( _Ostream_Manip(T) & fmt ) { fmt.flags.sign = true; return fmt; } \ } /* distribution */ \ @@ -241,22 +237,23 @@ #define FLOATING_POINT_FMT_DECL( T ) \ static inline { \ - _Ostream_Manip(T) hex( T val ) { return (_Ostream_Manip(T))@{ val, 1, 0, 'a', { .all : 0 } }; } \ - _Ostream_Manip(T) sci( T val ) { return (_Ostream_Manip(T))@{ val, 1, 0, 'e', { .all : 0 } }; } \ - _Ostream_Manip(T) eng( T val ) { return (_Ostream_Manip(T))@{ val, 1, -1, 'g', { .flags.eng : true } }; } \ - _Ostream_Manip(T) wd( unsigned int w, T val ) { return (_Ostream_Manip(T))@{ val, w, 0, 'g', { .all : 0 } }; } \ - _Ostream_Manip(T) wd( unsigned int w, unsigned int pc, T val ) { return (_Ostream_Manip(T))@{ val, w, pc, 'f', { .flags.pc : true } }; } \ - _Ostream_Manip(T) ws( unsigned int w, unsigned int pc, T val ) { return (_Ostream_Manip(T))@{ val, w, pc, 'g', { .flags.pc : true } }; } \ - _Ostream_Manip(T) & wd( unsigned int w, _Ostream_Manip(T) & fmt ) { if ( fmt.flags.eng ) fmt.base = 'f'; fmt.wd = w; return fmt; } \ - _Ostream_Manip(T) & wd( unsigned int w, unsigned int pc, _Ostream_Manip(T) & fmt ) { if ( fmt.flags.eng ) fmt.base = 'f'; fmt.wd = w; fmt.pc = pc; fmt.flags.pc = true; return fmt; } \ - _Ostream_Manip(T) & ws( unsigned int w, unsigned int pc, _Ostream_Manip(T) & fmt ) { fmt.wd = w; fmt.pc = pc; fmt.flags.pc = true; return fmt; } \ + _Ostream_Manip(T) hex( T val ) { return (_Ostream_Manip(T))@{ .val : val, .wd : 1, .pc : 0, .base : 'a', { .all : 0 } }; } \ + _Ostream_Manip(T) sci( T val ) { return (_Ostream_Manip(T))@{ .val : val, .wd : 1, .pc : 0, .base : 'e', { .all : 0 } }; } \ + _Ostream_Manip(T) eng( T val ) { return (_Ostream_Manip(T))@{ .val : val, 1, -1, .base : 'g', { .flags.eng : true } }; } \ + _Ostream_Manip(T) wd( unsigned int wd, T val ) { return (_Ostream_Manip(T))@{ .val : val, .wd : wd, .pc : 0, .base : 'g', { .all : 0 } }; } \ + _Ostream_Manip(T) wd( unsigned int wd, unsigned int pc, T val ) { return (_Ostream_Manip(T))@{ .val : val, .wd : wd, .pc : pc, .base : 'f', { .flags.pc : true } }; } \ + _Ostream_Manip(T) ws( unsigned int wd, unsigned int pc, T val ) { return (_Ostream_Manip(T))@{ .val : val, .wd : wd, .pc : pc, .base : 'g', { .flags.pc : true } }; } \ + _Ostream_Manip(T) & wd( unsigned int wd, _Ostream_Manip(T) & fmt ) { if ( fmt.flags.eng ) fmt.base = 'f'; fmt.wd = wd; return fmt; } \ + _Ostream_Manip(T) & wd( unsigned int wd, unsigned int pc, _Ostream_Manip(T) & fmt ) { \ + if ( fmt.flags.eng ) fmt.base = 'f'; fmt.wd = wd; fmt.pc = pc; fmt.flags.pc = true; return fmt; } \ + _Ostream_Manip(T) & ws( unsigned int wd, unsigned int pc, _Ostream_Manip(T) & fmt ) { fmt.wd = wd; fmt.pc = pc; fmt.flags.pc = true; return fmt; } \ _Ostream_Manip(T) & left( _Ostream_Manip(T) & fmt ) { fmt.flags.left = true; return fmt; } \ - _Ostream_Manip(T) upcase( T val ) { return (_Ostream_Manip(T))@{ val, 1, 0, 'G', { .all : 0 } }; } \ + _Ostream_Manip(T) upcase( T val ) { return (_Ostream_Manip(T))@{ .val : val, .wd : 1, .pc : 0, .base : 'G', { .all : 0 } }; } \ _Ostream_Manip(T) & upcase( _Ostream_Manip(T) & fmt ) { fmt.base -= 32; /* upper case */ return fmt; } \ _Ostream_Manip(T) & pad0( _Ostream_Manip(T) & fmt ) { fmt.flags.pad0 = true; return fmt; } \ - _Ostream_Manip(T) sign( T val ) { return (_Ostream_Manip(T))@{ val, 1, 0, 'g', { .flags.sign : true } }; } \ + _Ostream_Manip(T) sign( T val ) { return (_Ostream_Manip(T))@{ .val : val, .wd : 1, .pc : 0, .base : 'g', { .flags.sign : true } }; } \ _Ostream_Manip(T) & sign( _Ostream_Manip(T) & fmt ) { fmt.flags.sign = true; return fmt; } \ - _Ostream_Manip(T) nodp( T val ) { return (_Ostream_Manip(T))@{ val, 1, 0, 'g', { .flags.nobsdp : true } }; } \ + _Ostream_Manip(T) nodp( T val ) { return (_Ostream_Manip(T))@{ .val : val, .wd : 1, .pc : 0, .base : 'g', { .flags.nobsdp : true } }; } \ _Ostream_Manip(T) & nodp( _Ostream_Manip(T) & fmt ) { fmt.flags.nobsdp = true; return fmt; } \ - _Ostream_Manip(T) unit( T val ) { return (_Ostream_Manip(T))@{ val, 1, 0, 'g', { .flags.nobsdp : true } }; } \ + _Ostream_Manip(T) unit( T val ) { return (_Ostream_Manip(T))@{ .val : val, .wd : 1, .pc : 0, .base : 'g', { .flags.nobsdp : true } }; } \ _Ostream_Manip(T) & unit( _Ostream_Manip(T) & fmt ) { fmt.flags.nobsdp = true; return fmt; } \ } /* distribution */ \ @@ -272,9 +269,9 @@ static inline { - _Ostream_Manip(char) bin( char c ) { return (_Ostream_Manip(char))@{ c, 1, 0, 'b', { .all : 0 } }; } - _Ostream_Manip(char) oct( char c ) { return (_Ostream_Manip(char))@{ c, 1, 0, 'o', { .all : 0 } }; } - _Ostream_Manip(char) hex( char c ) { return (_Ostream_Manip(char))@{ c, 1, 0, 'x', { .all : 0 } }; } - _Ostream_Manip(char) wd( unsigned int w, char c ) { return (_Ostream_Manip(char))@{ c, w, 0, 'c', { .all : 0 } }; } - _Ostream_Manip(char) & wd( unsigned int w, _Ostream_Manip(char) & fmt ) { fmt.wd = w; return fmt; } + _Ostream_Manip(char) bin( char c ) { return (_Ostream_Manip(char))@{ .val : c, .wd : 1, .pc : 0, .base : 'b', { .all : 0 } }; } + _Ostream_Manip(char) oct( char c ) { return (_Ostream_Manip(char))@{ .val : c, .wd : 1, .pc : 0, .base : 'o', { .all : 0 } }; } + _Ostream_Manip(char) hex( char c ) { return (_Ostream_Manip(char))@{ .val : c, .wd : 1, .pc : 0, .base : 'x', { .all : 0 } }; } + _Ostream_Manip(char) wd( unsigned int wd, char c ) { return (_Ostream_Manip(char))@{ c, wd, 0, .base : 'c', { .all : 0 } }; } + _Ostream_Manip(char) & wd( unsigned int wd, _Ostream_Manip(char) & fmt ) { fmt.wd = wd; return fmt; } _Ostream_Manip(char) & left( _Ostream_Manip(char) & fmt ) { fmt.flags.left = true; return fmt; } _Ostream_Manip(char) & upcase( _Ostream_Manip(char) & fmt ) { if ( fmt.base == 'x' || fmt.base == 'b' ) fmt.base -= 32; /* upper case */ return fmt; } @@ -289,11 +286,11 @@ static inline { - _Ostream_Manip(const char *) bin( const char s[] ) { return (_Ostream_Manip(const char *))@{ s, 1, 0, 'b', { .all : 0 } }; } - _Ostream_Manip(const char *) oct( const char s[] ) { return (_Ostream_Manip(const char *))@{ s, 1, 0, 'o', { .all : 0 } }; } - _Ostream_Manip(const char *) hex( const char s[] ) { return (_Ostream_Manip(const char *))@{ s, 1, 0, 'x', { .all : 0 } }; } - _Ostream_Manip(const char *) wd( unsigned int w, const char s[] ) { return (_Ostream_Manip(const char *))@{ s, w, 0, 's', { .all : 0 } }; } - _Ostream_Manip(const char *) wd( unsigned int w, unsigned int pc, const char s[] ) { return (_Ostream_Manip(const char *))@{ s, w, pc, 's', { .flags.pc : true } }; } - _Ostream_Manip(const char *) & wd( unsigned int w, _Ostream_Manip(const char *) & fmt ) { fmt.wd = w; return fmt; } - _Ostream_Manip(const char *) & wd( unsigned int w, unsigned int pc, _Ostream_Manip(const char *) & fmt ) { fmt.wd = w; fmt.pc = pc; fmt.flags.pc = true; return fmt; } + _Ostream_Manip(const char *) bin( const char s[] ) { return (_Ostream_Manip(const char *))@{ .val : s, .wd : 1, .pc : 0, .base : 'b', { .all : 0 } }; } + _Ostream_Manip(const char *) oct( const char s[] ) { return (_Ostream_Manip(const char *))@{ .val : s, .wd : 1, .pc : 0, .base : 'o', { .all : 0 } }; } + _Ostream_Manip(const char *) hex( const char s[] ) { return (_Ostream_Manip(const char *))@{ .val : s, .wd : 1, .pc : 0, .base : 'x', { .all : 0 } }; } + _Ostream_Manip(const char *) wd( unsigned int wd, const char s[] ) { return (_Ostream_Manip(const char *))@{ s, wd, 0, .base : 's', { .all : 0 } }; } + _Ostream_Manip(const char *) wd( unsigned int wd, unsigned int pc, const char s[] ) { return (_Ostream_Manip(const char *))@{ s, .wd : wd, .pc : pc, .base : 's', { .flags.pc : true } }; } + _Ostream_Manip(const char *) & wd( unsigned int wd, _Ostream_Manip(const char *) & fmt ) { fmt.wd = wd; return fmt; } + _Ostream_Manip(const char *) & wd( unsigned int wd, unsigned int pc, _Ostream_Manip(const char *) & fmt ) { fmt.wd = wd; fmt.pc = pc; fmt.flags.pc = true; return fmt; } _Ostream_Manip(const char *) & left( _Ostream_Manip(const char *) & fmt ) { fmt.flags.left = true; return fmt; } _Ostream_Manip(const char *) & nobase( _Ostream_Manip(const char *) & fmt ) { fmt.flags.nobsdp = true; return fmt; } @@ -385,6 +382,6 @@ static inline { - _Istream_Cskip skip( const char scanset[] ) { return (_Istream_Cskip)@{ scanset, 0 }; } - _Istream_Cskip skip( unsigned int wd ) { return (_Istream_Cskip)@{ 0p, wd }; } + _Istream_Cskip skip( const char scanset[] ) { return (_Istream_Cskip)@{ .scanset : scanset, .wd : 0 }; } + _Istream_Cskip skip( unsigned int wd ) { return (_Istream_Cskip)@{ .scanset : 0p, .wd : wd }; } } // distribution @@ -400,5 +397,5 @@ unsigned char ignore:1; // do not change input argument unsigned char inex:1; // include/exclude characters in scanset - unsigned char delimiter:1; // delimit character + unsigned char delimiter:1; // delimit character(s) unsigned char rwd:1; // read width } flags; @@ -406,50 +403,55 @@ }; // _Istream_str_base -struct _Istream_Cstr { +struct _Istream_Cwidth { char * s; inline _Istream_str_base; }; // _Istream_Cstr +// Restrict nesting of input manipulators to those combinations that make sense. + +struct _Istream_Cstr { + _Istream_Cwidth cstr; +}; // _Istream_Cstr + struct _Istream_Cquoted { - _Istream_Cstr cstr; + _Istream_Cwidth cstr; }; // _Istream_Cquoted static inline { - // width must include room for null terminator - _Istream_Cstr wdi( unsigned int wd, char s[] ) { return (_Istream_Cstr)@{ s, { {0p}, wd, {.all : 0} } }; } - _Istream_Cstr wdi( unsigned int wd, unsigned int rwd, char s[] ) { - if ( wd <= rwd ) throw (cstring_length){ &cstring_length_vt }; - return (_Istream_Cstr)@{ s, { {0p}, rwd, {.flags.rwd : true} } }; + // width must include room for null terminator, (gcc) scanf does not allow a 0 width => wd > 1 (1 char and null) and rd > 0 (1 char); + _Istream_Cwidth wdi( unsigned int wd, char s[] ) { + if ( wd <= 1 ) throw (cstring_length){ &cstring_length_vt }; // minimum 1 character and null terminator + return (_Istream_Cwidth)@{ .s : s, { {.scanset : 0p}, .wd : wd, {.all : 0} } }; } - _Istream_Cquoted & quoted( _Istream_Cstr & fmt, const char Ldelimiter = '"', const char Rdelimiter = '\0' ) { - fmt.delimiters[0] = Ldelimiter; fmt.delimiters[1] = Rdelimiter; fmt.delimiters[2] = '\0'; - return (_Istream_Cquoted &)fmt; + _Istream_Cwidth wdi( unsigned int wd, unsigned int rwd, char s[] ) { + if ( wd <= 1 || wd <= rwd ) throw (cstring_length){ &cstring_length_vt }; // minimum 1 character, null terminator, plus subset + return (_Istream_Cwidth)@{ .s : s, { {.scanset : 0p}, .wd : rwd, {.flags.rwd : true} } }; } - _Istream_Cstr & getline( _Istream_Cstr & fmt, const char delimiter = '\n' ) { - fmt.delimiters[0] = delimiter; fmt.delimiters[1] = '\0'; fmt.flags.delimiter = true; fmt.flags.inex = true; return fmt; + _Istream_Cquoted quoted( char & ch, const char Ldelimiter = '\'', const char Rdelimiter = '\0' ) { + return (_Istream_Cquoted)@{ { .s : &ch, { {.delimiters : { Ldelimiter, Rdelimiter, '\1' }}, .wd : 1, {.flags.rwd : true} } } }; } - _Istream_Cstr & incl( const char scanset[], _Istream_Cstr & fmt ) { fmt.scanset = scanset; fmt.flags.inex = false; return fmt; } - _Istream_Cstr & excl( const char scanset[], _Istream_Cstr & fmt ) { fmt.scanset = scanset; fmt.flags.inex = true; return fmt; } - _Istream_Cstr ignore( char s[] ) { return (_Istream_Cstr)@{ s, { {0p}, -1, {.flags.ignore : true} } }; } - _Istream_Cstr & ignore( _Istream_Cstr & fmt ) { fmt.flags.ignore = true; return fmt; } + _Istream_Cquoted & quoted( _Istream_Cwidth & f, const char Ldelimiter = '"', const char Rdelimiter = '\0' ) { + f.delimiters[0] = Ldelimiter; f.delimiters[1] = Rdelimiter; f.delimiters[2] = '\0'; + return (_Istream_Cquoted &)f; + } + _Istream_Cstr & getline( _Istream_Cwidth & f, const char delimiter = '\n' ) { + f.delimiters[0] = delimiter; f.delimiters[1] = '\0'; f.flags.delimiter = true; return (_Istream_Cstr &)f; + } + _Istream_Cstr & incl( const char scanset[], _Istream_Cwidth & f ) { f.scanset = scanset; f.flags.inex = false; return (_Istream_Cstr &)f; } + _Istream_Cstr & excl( const char scanset[], _Istream_Cwidth & f ) { f.scanset = scanset; f.flags.inex = true; return (_Istream_Cstr &)f; } + _Istream_Cstr ignore( const char s[] ) { return (_Istream_Cwidth)@{ .s : (char *)s, { {.scanset : 0p}, .wd : -1, {.flags.ignore : true} } }; } + _Istream_Cstr & ignore( _Istream_Cwidth & f ) { f.flags.ignore = true; return (_Istream_Cstr &)f; } + _Istream_Cquoted & ignore( _Istream_Cquoted & f ) { f.cstr.flags.ignore = true; return (_Istream_Cquoted &)f; } + _Istream_Cstr & ignore( _Istream_Cstr & f ) { f.cstr.flags.ignore = true; return (_Istream_Cstr &)f; } } // distribution forall( istype & | basic_istream( istype ) ) { - istype & ?|?( istype & is, _Istream_Cstr f ); istype & ?|?( istype & is, _Istream_Cskip f ); istype & ?|?( istype & is, _Istream_Cquoted f ); -} // distribution - -struct _Istream_Char { - bool ignore; // do not change input argument -}; // _Istream_Char - -static inline { - _Istream_Char ignore( const char ) { return (_Istream_Char)@{ true }; } - _Istream_Char & ignore( _Istream_Char & fmt ) { fmt.ignore = true; return fmt; } -} // distribution -forall( istype & | basic_istream( istype ) ) { - istype & ?|?( istype & is, _Istream_Char f ); -} + istype & ?|?( istype & is, _Istream_Cstr f ); + static inline { + istype & ?|?( istype & is, _Istream_Cwidth f ) { return is | *(_Istream_Cstr *)&f; } + } // distribution +} // distribution forall( T & | sized( T ) ) @@ -462,8 +464,7 @@ #define INPUT_FMT_DECL( T ) \ static inline { \ - _Istream_Manip(T) ignore( const T & val ) { return (_Istream_Manip(T))@{ (T &)val, -1, true }; } \ + _Istream_Manip(T) wdi( unsigned int wd, T & val ) { return (_Istream_Manip(T))@{ .val : val, .wd : wd, .ignore : false }; } \ + _Istream_Manip(T) ignore( const T & val ) { return (_Istream_Manip(T))@{ .val : (T &)val, .wd : -1, .ignore : true }; } \ _Istream_Manip(T) & ignore( _Istream_Manip(T) & fmt ) { fmt.ignore = true; return fmt; } \ - _Istream_Manip(T) wdi( unsigned int wd, T & val ) { return (_Istream_Manip(T))@{ val, wd, false }; } \ - _Istream_Manip(T) & wdi( unsigned int wd, _Istream_Manip(T) & fmt ) { fmt.wd = wd; return fmt; } \ } /* distribution */ \ forall( istype & | basic_istream( istype ) ) { \ @@ -471,4 +472,5 @@ } // ?|? +INPUT_FMT_DECL( char ) INPUT_FMT_DECL( signed char ) INPUT_FMT_DECL( unsigned char ) Index: src/Common/utility.h =================================================================== --- src/Common/utility.h (revision c75b30ae4d3f97678f27275a033614f675b7fdaf) +++ src/Common/utility.h (revision 32490deb2180d977e78b79e5c2342a8fa2357a53) @@ -111,24 +111,4 @@ }; -// ----------------------------------------------------------------------------- -// O(1) polymorphic integer ilog2, using clz, which returns the number of leading 0-bits, starting at the most -// significant bit (single instruction on x86) - -template -inline -#if defined(__GNUC__) && __GNUC__ > 4 -constexpr -#endif -T ilog2(const T & t) { - if(std::is_integral::value) { - const constexpr int r = sizeof(t) * __CHAR_BIT__ - 1; - if( sizeof(T) == sizeof(unsigned int) ) return r - __builtin_clz ( t ); - if( sizeof(T) == sizeof(unsigned long) ) return r - __builtin_clzl ( t ); - if( sizeof(T) == sizeof(unsigned long long) ) return r - __builtin_clzll( t ); - } - assert(false); - return -1; -} // ilog2 - // Local Variables: // // tab-width: 4 // Index: src/ResolvExpr/Resolver.cc =================================================================== --- src/ResolvExpr/Resolver.cc (revision c75b30ae4d3f97678f27275a033614f675b7fdaf) +++ src/ResolvExpr/Resolver.cc (revision 32490deb2180d977e78b79e5c2342a8fa2357a53) @@ -50,13 +50,4 @@ namespace ResolvExpr { - template< typename iterator_t > - inline bool advance_to_mutex( iterator_t & it, const iterator_t & end ) { - while( it != end && !(*it)->get_type()->get_mutex() ) { - it++; - } - - return it != end; - } - namespace { /// Finds deleted expressions in an expression tree Index: tests/collections/.expect/string-istream-manip.txt =================================================================== --- tests/collections/.expect/string-istream-manip.txt (revision c75b30ae4d3f97678f27275a033614f675b7fdaf) +++ tests/collections/.expect/string-istream-manip.txt (revision 32490deb2180d977e78b79e5c2342a8fa2357a53) @@ -68,5 +68,5 @@ 12 wwwwwwww 13 wwwwwwww -14 cccc +14 15 1 yyyyyyyyyyyyyyyyyyyy @@ -83,4 +83,4 @@ 12 wwwwwwww 13 wwwwwwww -14 cccc +14 15 Index: tests/collections/.in/string-istream-manip.txt =================================================================== --- tests/collections/.in/string-istream-manip.txt (revision c75b30ae4d3f97678f27275a033614f675b7fdaf) +++ tests/collections/.in/string-istream-manip.txt (revision 32490deb2180d977e78b79e5c2342a8fa2357a53) @@ -36,6 +36,6 @@ abcxxx abcyyy -aaaaaaaaxxxxxxxxaabbccbbdddwwwbbbbbbbbwwwwwwwwaaaaaaaawwwwwwww -uuuuuccccuuuuu +aaaaaaaaxxxxxxxxaabbccbbdddwwwbbbbbbbbwwwwwwwwaaaaaaaawwwwwwwwaaaaaaaawwwwwwww +uuuuu abc cccccb @@ -43,4 +43,4 @@ abcxxx abcyyy -aaaaaaaaxxxxxxxxaabbccbbdddwwwbbbbbbbbwwwwwwwwaaaaaaaawwwwwwww -uuuuuccccuuuuu +aaaaaaaaxxxxxxxxaabbccbbdddwwwbbbbbbbbwwwwwwwwaaaaaaaawwwwwwwwaaaaaaaawwwwwwww +uuuuu Index: tests/collections/string-istream-manip.cfa =================================================================== --- tests/collections/string-istream-manip.cfa (revision c75b30ae4d3f97678f27275a033614f675b7fdaf) +++ tests/collections/string-istream-manip.cfa (revision 32490deb2180d977e78b79e5c2342a8fa2357a53) @@ -165,4 +165,5 @@ sin | ignore( incl( "abc", wdi( 8, s ) ) ); sout | "12" | s; sin | ignore( excl( "abc", wdi( 8, s ) ) ); sout | "13" | s; + sin | "\n"; s = "q"; @@ -191,4 +192,5 @@ sin | ignore( incl( "abc", wdi( 8, s ) ) ); sout | "12" | s; sin | ignore( excl( "abc", wdi( 8, s ) ) ); sout | "13" | s; + sin | "\n"; s = "q"; Index: tests/io/.expect/manipulatorsInput.arm64.txt =================================================================== --- tests/io/.expect/manipulatorsInput.arm64.txt (revision c75b30ae4d3f97678f27275a033614f675b7fdaf) +++ tests/io/.expect/manipulatorsInput.arm64.txt (revision 32490deb2180d977e78b79e5c2342a8fa2357a53) @@ -18,39 +18,55 @@ 12 wwwwwwww 13 wwwwwwww -14 rc=1, cccc +14 rc=0, q 15 rc=0, q 16 get this line 17 @# this line 1)-{} -18 abc -19 abc -20 d d +18 @# this line 1)-{} +19 abc +20 abc +21 d d d -21 ZC44% +22 ZC44% +23 ZC44% +24 x +25 x +26 x +27 x +28 x 1 yyyyyyyyyyyyyyyyyyyy 2 abcxxx 3 abcxxx 4 aaaaaaaa -5 +5 aaaaaaaa 6 aabbccbb 7 dddwww -8 -9 +8 dddwww +9 dddwww 10 aaaaaaaa 11 wwwwwwww -12 -13 -14 cccc +12 wwwwwwww +13 wwwwwwww +14 15 16 get this line 17 @# this line 1)-{} -18 abc -19 abc -20 d d +18 @# this line 1)-{} +19 abc +20 abc +21 d d d -21 ZC44% +22 ZC44% +23 ZC44% +24 x +25 x +26 x +27 x +28 x a a +xxx +xxx -1 15 Index: tests/io/.expect/manipulatorsInput.x64.txt =================================================================== --- tests/io/.expect/manipulatorsInput.x64.txt (revision c75b30ae4d3f97678f27275a033614f675b7fdaf) +++ tests/io/.expect/manipulatorsInput.x64.txt (revision 32490deb2180d977e78b79e5c2342a8fa2357a53) @@ -18,39 +18,55 @@ 12 wwwwwwww 13 wwwwwwww -14 rc=1, cccc +14 rc=0, q 15 rc=0, q 16 get this line 17 @# this line 1)-{} -18 abc -19 abc -20 d d +18 @# this line 1)-{} +19 abc +20 abc +21 d d d -21 ZC44% +22 ZC44% +23 ZC44% +24 x +25 x +26 x +27 x +28 x 1 yyyyyyyyyyyyyyyyyyyy 2 abcxxx 3 abcxxx 4 aaaaaaaa -5 +5 aaaaaaaa 6 aabbccbb 7 dddwww -8 -9 +8 dddwww +9 dddwww 10 aaaaaaaa 11 wwwwwwww -12 -13 -14 cccc +12 wwwwwwww +13 wwwwwwww +14 15 16 get this line 17 @# this line 1)-{} -18 abc -19 abc -20 d d +18 @# this line 1)-{} +19 abc +20 abc +21 d d d -21 ZC44% +22 ZC44% +23 ZC44% +24 x +25 x +26 x +27 x +28 x a a +xxx +xxx -1 15 Index: tests/io/.expect/manipulatorsInput.x86.txt =================================================================== --- tests/io/.expect/manipulatorsInput.x86.txt (revision c75b30ae4d3f97678f27275a033614f675b7fdaf) +++ tests/io/.expect/manipulatorsInput.x86.txt (revision 32490deb2180d977e78b79e5c2342a8fa2357a53) @@ -18,39 +18,55 @@ 12 wwwwwwww 13 wwwwwwww -14 rc=1, cccc +14 rc=0, q 15 rc=0, q 16 get this line 17 @# this line 1)-{} -18 abc -19 abc -20 d d +18 @# this line 1)-{} +19 abc +20 abc +21 d d d -21 ZC44% +22 ZC44% +23 ZC44% +24 x +25 x +26 x +27 x +28 x 1 yyyyyyyyyyyyyyyyyyyy 2 abcxxx 3 abcxxx 4 aaaaaaaa -5 +5 aaaaaaaa 6 aabbccbb 7 dddwww -8 -9 +8 dddwww +9 dddwww 10 aaaaaaaa 11 wwwwwwww -12 -13 -14 cccc +12 wwwwwwww +13 wwwwwwww +14 15 16 get this line 17 @# this line 1)-{} -18 abc -19 abc -20 d d +18 @# this line 1)-{} +19 abc +20 abc +21 d d d -21 ZC44% +22 ZC44% +23 ZC44% +24 x +25 x +26 x +27 x +28 x a a +xxx +xxx -1 15 Index: tests/io/.in/manipulatorsInput.txt =================================================================== --- tests/io/.in/manipulatorsInput.txt (revision c75b30ae4d3f97678f27275a033614f675b7fdaf) +++ tests/io/.in/manipulatorsInput.txt (revision 32490deb2180d977e78b79e5c2342a8fa2357a53) @@ -8,8 +8,9 @@ abcxxx abcyyy -aaaaaaaaxxxxxxxxaabbccbbdddwwwbbbbbbbbwwwwwwwwaaaaaaaawwwwwwww -uuuuuccccuuuuu +aaaaaaaaxxxxxxxxaabbccbbdddwwwbbbbbbbbwwwwwwwwaaaaaaaawwwwwwwwaaaaaaaawwwwwwww +uuuuu get this line @# this line 1)-{}% +@# this line 2)-{}% "abc" 'abc ' @@ -18,4 +19,10 @@ d } X ZC44%Y +X ZC55%Y +'x' +"x" +{x} +XxY +XyY abc cccccb @@ -23,8 +30,9 @@ abcxxx abcyyy -aaaaaaaaxxxxxxxxaabbccbbdddwwwbbbbbbbbwwwwwwwwaaaaaaaawwwwwwww -uuuuuccccuuuuu +aaaaaaaaxxxxxxxxaabbccbbdddwwwbbbbbbbbwwwwwwwwaaaaaaaawwwwwwwwaaaaaaaawwwwwwww +uuuuu get this line @# this line 1)-{}% +@# this line 2)-{}% "abc" 'abc ' @@ -33,5 +41,12 @@ d } X ZC44%Y +X ZC55%Y +'x' +"x" +{x} +XxY +XyY ab +xxxyyy 0xff 017 15-15 0xff 017 15-15 Index: tests/io/manipulatorsInput.cfa =================================================================== --- tests/io/manipulatorsInput.cfa (revision c75b30ae4d3f97678f27275a033614f675b7fdaf) +++ tests/io/manipulatorsInput.cfa (revision 32490deb2180d977e78b79e5c2342a8fa2357a53) @@ -7,6 +7,6 @@ // Created On : Sat Jun 8 17:58:54 2019 // Last Modified By : Peter A. Buhr -// Last Modified On : Wed Jan 3 11:15:04 2024 -// Update Count : 103 +// Last Modified On : Sun Jan 28 11:59:55 2024 +// Update Count : 133 // @@ -55,39 +55,56 @@ } { - char s[] = "yyyyyyyyyyyyyyyyyyyy"; + char s[] = "yyyyyyyyyyyyyyyyyyyy"; // Input characters consumed: const char sk_fmt[] = "%*[abc]"; - scanf( "abc " ); scanf( sk_fmt ); for ( 5 ) scanf( "%*c" ); printf( "1 %s\n", s ); - scanf( "%s", s ); printf( "2 %s\n", s ); - scanf( "%*s" ); printf( "3 %s\n", s ); - scanf( "%8s", s ); printf( "4 %s\n", s ); - scanf( "%*8s" ); printf( "5 %s\n", s ); - - scanf( "%[abc]", s ); printf( "6 %s\n", s ); - scanf( "%[^abc]", s ); printf( "7 %s\n", s ); - scanf( "%*[abc]" ); printf( "8 %s\n", s ); - scanf( "%*[^abc]" ); printf( "9 %s\n", s ); - scanf( "%8[abc]", s ); printf( "10 %s\n", s ); - scanf( "%8[^abc]", s ); printf( "11 %s\n", s ); - scanf( "%*8[abc]" ); printf( "12 %s\n", s ); - scanf( "%*8[^abc]" ); printf( "13 %s\n", s ); + scanf( "abc " ); scanf( sk_fmt ); for ( 5 ) scanf( "%*c" ); printf( "1 %s\n", s ); // |abc |\ncccccb| \nxx\n| + scanf( "%s", s ); printf( "2 %s\n", s ); // |abcxxx| + scanf( "%*s" ); printf( "3 %s\n", s ); // |\nabcyyy| + scanf( "%8s", s ); printf( "4 %s\n", s ); // |\naaaaaaaa| + scanf( "%*8s" ); printf( "5 %s\n", s ); // |xxxxxxxx| + + scanf( "%[abc]", s ); printf( "6 %s\n", s ); // |aabbccbb| + scanf( "%[^abc]", s ); printf( "7 %s\n", s ); // |dddwww| + scanf( "%*[abc]" ); printf( "8 %s\n", s ); // |bbbbbbbb| + scanf( "%*[^abc]" ); printf( "9 %s\n", s ); // |wwwwwwww| + scanf( "%8[abc]", s ); printf( "10 %s\n", s ); // |aaaaaaaa| + scanf( "%8[^abc]", s ); printf( "11 %s\n", s ); // |wwwwwwww| + scanf( "%*8[abc]" ); printf( "12 %s\n", s ); // |aaaaaaaa| + scanf( "%*8[^abc]" ); printf( "13 %s\n", s ); // |wwwwwwww| + scanf( "\n" ); // must start next line // |\n| int rc; s[0] = 'q'; s[1] = '\0'; rc = 99; - rc = scanf( "%[abc]", s ); printf( "14 rc=%d, %s\n", rc, s ); + rc = scanf( "%[abc]", s ); printf( "14 rc=%d, %s\n", rc, s ); // || s[0] = 'q'; s[1] = '\0'; rc = 99; - rc = scanf( "%[^u]", s ); printf( "15 rc=%d, %s\n", rc, s ); - scanf( "%*[u]\n" ); - scanf( "%[^\n]\n", s ); printf( "16 %s\n", s ); - scanf( "%[^%%]%%\n", s ); printf( "17 %s\n", s ); - - scanf( "%*[ \f\n\r\t\v]" ); // ignore whitespace - scanf( "\"%[^\"]\"", s ); printf( "18 %s\n", s ); - scanf( "%*[ \f\n\r\t\v]" ); // ignore whitespace - scanf( "'%[^']'", s ); printf( "19 %s\n", s ); - scanf( "%*[ \f\n\r\t\v]" ); // ignore whitespace - scanf( "{%[^}]}", s ); printf( "20 %s\n", s ); - scanf( "%*[ \f\n\r\t\v]" ); // ignore whitespace - scanf( "X%[^Y]Y", s ); printf( "21 %s\n", s ); - scanf( "\n" ); // must start next line + rc = scanf( "%[^u]", s ); printf( "15 rc=%d, %s\n", rc, s ); // || + scanf( "%*[u]\n" ); // |uuuuu\n| + scanf( "%[^\n]\n", s ); printf( "16 %s\n", s ); // |get this line\n| + scanf( "%[^%%]%%\n", s ); printf( "17 %s\n", s ); // |@# this line 1)-{}%\n| + scanf( "%*[^%%]%%\n", s ); printf( "18 %s\n", s ); // |@# this line 1)-{}%\n| + + scanf( "%*[ \f\n\r\t\v]" ); // ignore whitespace // || + scanf( "\"%[^\"]\"", s ); printf( "19 %s\n", s ); // |"abc"| + scanf( "%*[ \f\n\r\t\v]" ); // ignore whitespace // |\n| + scanf( "'%[^']'", s ); printf( "20 %s\n", s ); // |'abc '| + scanf( "%*[ \f\n\r\t\v]" ); // ignore whitespace // |\n| + scanf( "{%[^}]}", s ); printf( "21 %s\n", s ); // |{ d d\n\nd }| + scanf( "%*[ \f\n\r\t\v]" ); // ignore whitespace // |\n| + scanf( "X%[^Y]Y", s ); printf( "22 %s\n", s ); // |X ZC44%Y| + scanf( "%*[ \f\n\r\t\v]" ); // ignore whitespace // |\n| + scanf( "X%*[^Y]Y", s ); printf( "23 %s\n", s ); // |X ZC44%Y| + scanf( "\n" ); // must start next line // |\n| + + char ch; + scanf( "%*[ \f\n\r\t\v]" ); // ignore whitespace // |\n| + scanf( "'%c'", &ch ); printf( "24 %c\n", ch ); // |x| + scanf( "%*[ \f\n\r\t\v]" ); // ignore whitespace // |\n| + scanf( "\"%c\"", &ch ); printf( "25 %c\n", ch ); // |x| + scanf( "%*[ \f\n\r\t\v]" ); // ignore whitespace // |\n| + scanf( "{%c}", &ch ); printf( "26 %c\n", ch ); // |x| + scanf( "%*[ \f\n\r\t\v]" ); // ignore whitespace // |\n| + scanf( "X%cY", &ch ); printf( "27 %c\n", ch ); // |x| + scanf( "%*[ \f\n\r\t\v]" ); // ignore whitespace // |\n| + scanf( "X%*cY", &ch ); printf( "28 %c\n", ch ); // |x| + scanf( "\n" ); // must start next line // |\n| } { @@ -108,4 +125,5 @@ sin | ignore( incl( "abc", wdi( sizeof(s), 8, s ) ) ); sout | "12" | s; sin | ignore( excl( "abc", wdi( sizeof(s), 8, s ) ) ); sout | "13" | s; + sin | nl; s[0] = 'q'; s[1] = '\0'; @@ -116,15 +134,31 @@ sin | getline( wdi( sizeof(s), s ) ); sout | "16" | s; sin | getline( wdi( sizeof(s), s ), '%' ) | "\n"; sout | "17" | s; - - sin | quoted( wdi( sizeof(s), s ) ); sout | "18" | s; - sin | quoted( wdi( sizeof(s), s ), '\'' ); sout | "19" | s; - sin | quoted( wdi( sizeof(s), s ), '{', '}' ); sout | "20" | s; - sin | quoted( wdi( sizeof(s), s ), 'X', 'Y' ); sout | "21" | s; - } - // Keep harmonized with collections/string-istream-manip + sin | ignore( getline( wdi( sizeof(s), s ), '%' ) ) | "\n"; sout | "18" | s; + + sin | quoted( wdi( sizeof(s), s ) ); sout | "19" | s; + sin | quoted( wdi( sizeof(s), s ), '\'' ); sout | "20" | s; + sin | quoted( wdi( sizeof(s), s ), '{', '}' ); sout | "21" | s; + sin | quoted( wdi( sizeof(s), s ), 'X', 'Y' ); sout | "22" | s; + sin | ignore( quoted( wdi( sizeof(s), s ), 'X', 'Y' ) ); sout | "23" | s; + + char ch; + sin | quoted( ch ); sout | "24 " | ch; + sin | quoted( ch, '\"' ); sout | "25 " | ch; + sin | quoted( ch, '{', '}' ); sout | "26 " | ch; + sin | quoted( ch, 'X', 'Y' ); sout | "27 " | ch; + sin | ignore( quoted( ch, 'X', 'Y' ) ); sout | "28 " | ch; + sin | nl; + } + // Keep harmonized with collections/string-istream-manip { char c; sin | c; sout | c; sin | ignore( c ); sout | c; + sin | nl; + + char ca[3] = { 'a', 'b', 'c' }; + sin | wdi( sizeof(ca), ca[0] ); sout | ca[0] | ca[1] | ca[2]; + sin | ignore( wdi( sizeof(ca), ca[0] ) ); sout | ca[0] | ca[1] | ca[2]; + sin | nl; signed char sc;