Changes in / [32490deb:c75b30a]


Ignore:
Files:
22 edited

Legend:

Unmodified
Added
Removed

  • doc/LaTeXmacros/common.sty

    r32490deb rc75b30a  
    1111%% Created On       : Sat Apr  9 10:06:17 2016
    1212%% Last Modified By : Peter A. Buhr
    13 %% Last Modified On : Sun Jan 21 13:17:48 2024
    14 %% Update Count     : 633
     13%% Last Modified On : Sun Jan 14 12:28:26 2024
     14%% Update Count     : 631
    1515%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    1616
    … …  
    270270\newlength{\gcolumnposn}                                % temporary hack because lstlisting does not handle tabs correctly
    271271\newlength{\columnposn}
    272 \setlength{\gcolumnposn}{3in}
     272\setlength{\gcolumnposn}{2.75in}
    273273\setlength{\columnposn}{\gcolumnposn}
    274274\newcommand{\setgcolumn}[1]{\global\gcolumnposn=#1\global\columnposn=\gcolumnposn}

  • doc/LaTeXmacros/common.tex

    r32490deb rc75b30a  
    1111%% Created On       : Sat Apr  9 10:06:17 2016
    1212%% Last Modified By : Peter A. Buhr
    13 %% Last Modified On : Wed Jan 24 08:43:57 2024
    14 %% Update Count     : 593
     13%% Last Modified On : Sun Jan 14 17:59:02 2024
     14%% Update Count     : 592
    1515%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    1616
    … …  
    273273\newlength{\gcolumnposn}                                % temporary hack because lstlisting does not handle tabs correctly
    274274\newlength{\columnposn}
    275 \setlength{\gcolumnposn}{3in}
     275\setlength{\gcolumnposn}{2.75in}
    276276\setlength{\columnposn}{\gcolumnposn}
    277277\newcommand{\setgcolumn}[1]{\global\gcolumnposn=#1\global\columnposn=\gcolumnposn}

  • doc/bibliography/pl.bib

    r32490deb rc75b30a  
    219219    title       = {Actor Benchmarks},
    220220    author      = {Peter A. Buhr and Colby A. Parsons},
    221     howpublished= {\url{https://github.com/pabuhr/ActorExperiments}},
     221    howpublished= {\href{https://github.com/pabuhr/ActorExperiments}{https://\-github.com/\-pabuhr/\-ActorExperiments}},
    222222    year        = 2022,
    223223}
    … …  
    296296    contributer = {pabuhr@plg},
    297297    author      = {Ada16},
    298     title       = {Ada Reference Manual ISO/IEC 8652:2012(E) with COR.1:2016},
     298    title       = {Ada Reference Manual  ISO/IEC 8652:2012(E) with COR.1:2016},
    299299    edition     = {3rd with Technical Corrigendum 1 for Ada 2012},
    300300    organization= {AXE Consultants},
    … …  
    416416    address     = {Waterloo, Ontario, Canada, N2L 3G1},
    417417    optnote     = {\textsf{http://uwspace.uwaterloo.ca/\-bitstream/10012/\-5751\-/1/Krischer\_Roy.pdf}},
    418     note        = {\url{http://uwspace.uwaterloo.ca/bitstream/10012/5751/1/Krischer_Roy.pdf}},
     418    note        = {\href{http://uwspace.uwaterloo.ca/bitstream/10012/5751/1/Krischer_Roy.pdf}{http://uwspace.uwaterloo.ca/\-bitstream/10012/\-5751\-/1/Krischer\_Roy.pdf}},
    419419}
    420420
    … …  
    430430    number      = 5,
    431431    pages       = {1005-1042},
    432     optnote     = {\url{https://onlinelibrary.wiley.com/doi/10.1002/spe.2925}},
     432    optnote     = {\href{https://onlinelibrary.wiley.com/doi/10.1002/spe.2925}{https://\-onlinelibrary.wiley.com/\-doi/\-10.1002/\-spe.2925}},
    433433}
    434434
    … …  
    761761    pages       = {145-160},
    762762    publisher   = {{USENIX} Association},
    763     note        = {\url{https://www.usenix.org/conference/osdi18/presentation/qin}},
     763    note        = {\href{https://www.usenix.org/conference/osdi18/presentation/qin}{https://\-www.usenix.org/\-conference/\-osdi18/\-presentation/\-qin}},
    764764}
    765765
    … …  
    839839    title       = {Async Await},
    840840    author      = {{WikipediA}},
    841     howpublished= {\url{https://en.wikipedia.org/wiki/Async/await}},
     841    howpublished= {\href{https://en.wikipedia.org/wiki/Async/await}{https://\-en.wikipedia.org/\-wiki/\-Async/\-await}},
    842842    year        = 2022,
    843843}
    … …  
    928928    institution = {Carnegie Mellon University},
    929929    address     = {California Institute of Technology, Pasadena, CA, USA},
    930     note        = {\url{http://www.cs.cmu.edu/~acw/15740/paper.pdf}},
     930    note        = {\href{http://www.cs.cmu.edu/~acw/15740/paper.pdf}{http://\-www.cs.cmu.edu/\-$\sim$acw/\-15740/\-paper.pdf}, Accessed May 2014},
    931931    year        = 2009,
    932932}
    … …  
    10341034    title       = {Boost Coroutine Library},
    10351035    year        = 2015,
    1036     howpublished= {\url{http://www.boost.org/doc/libs/1_61_0/libs/coroutine/doc/html/index.html}},
     1036    howpublished= {\href{http://www.boost.org/doc/libs/1_61_0/libs/coroutine/doc/html/index.html}
     1037                  {http://www.boost.org/\-doc/\-libs/1\_61\_0/\-libs/\-coroutine/\-doc/\-html/\-index.html}},
    10371038}
    10381039
    … …  
    10431044    title       = {Boost Thread Library},
    10441045    year        = 2015,
    1045     howpublished= {\url{https://www.boost.org/doc/libs/1_61_0/doc/html/thread.html}},
     1046    howpublished= {\href{https://www.boost.org/doc/libs/1_61_0/doc/html/thread.html}
     1047                  {https://\-www.boost.org/\-doc/\-libs/\-1\_61\_0/\-doc/\-html/\-thread.html}},
    10461048}
    10471049
    … …  
    10541056    month       = oct,
    10551057    type        = {Diplomarbeit},
    1056     note        = {\url{https://plg.uwaterloo.ca/~usystem/theses/KrischerThesis.pdf}},
     1058    note        = {\href{https://plg.uwaterloo.ca/~usystem/theses/KrischerThesis.pdf}{https://\-plg.uwaterloo.ca/\-$\sim$usystem/\-theses/\-KrischerThesis.pdf}},
    10571059}
    10581060
    … …  
    11461148    address     = {Geneva, Switzerland},
    11471149    year        = 1999,
    1148     note        = {\url{https://webstore.ansi.org/Standards/INCITS/INCITSISOIEC98991999R2005}},
     1150    note        = {\href{https://webstore.ansi.org/Standards/INCITS/INCITSISOIEC98991999R2005}{https://webstore.ansi.org/\-Standards/\-INCITS/\-INCITSISOIEC98991999R2005}},
    11491151}
    11501152
    … …  
    11581160    address     = {Geneva, Switzerland},
    11591161    year        = 2012,
    1160     note        = {\url{https://www.iso.org/standard/57853.html}},
     1162    note        = {\href{https://www.iso.org/standard/57853.html}{https://\-www.iso.org/\-standard/\-57853.html}},
    11611163}
    11621164
    … …  
    11691171    address     = {Geneva, Switzerland},
    11701172    year        = 2015,
    1171     note        = {\url{https://www.iso.org/standard/64031.html}},
     1173    note        = {\href{https://www.iso.org/standard/64031.html}{https://\-www.iso.org/\-standard/\-64031.html}},
    11721174}
    11731175
    … …  
    11961198    month       = aug,
    11971199    year        = {2020},
    1198     note        = {\url{https://cforall.uwaterloo.ca/doc/Fangren_Yu_Report_S20.pdf}},
     1200    note        = {\href{https://cforall.uwaterloo.ca/doc/Fangren_Yu_Report_S20.pdf}{https://\-cforall.uwaterloo.ca/\-doc/\-Fangren\_Yu\_Report\_S20.pdf}},
    11991201}
    12001202
    … …  
    12101212    year        = 2018,
    12111213    pages       = {2111-2146},
    1212     optnote     = {\url{http://dx.doi.org/10.1002/spe.2624}},
     1214    optnote     = {\href{http://dx.doi.org/10.1002/spe.2624}{http://\-dx.doi.org/\-10.1002/\-spe.2624}},
    12131215}
    12141216
    … …  
    12171219    key         = {Cforall Benchmarks},
    12181220    author      = {{\textsf{C}{$\mathbf{\forall}$} Benchmarks}},
    1219     howpublished= {\url{https://github.com/cforall/ConcurrentBenchmarks_SPE20}},
     1221    howpublished= {\href{https://github.com/cforall/ConcurrentBenchmarks_SPE20}{https://\-github.com/\-cforall/\-ConcurrentBenchmarks\_SPE20}},
    12201222}
    12211223
    … …  
    12241226    key         = {Cforall},
    12251227    author      = {{\textsf{C}{$\mathbf{\forall}$} Features}},
    1226     howpublished= {\url{https://plg.uwaterloo.ca/~cforall/features}},
     1228    howpublished= {\href{https://plg.uwaterloo.ca/~cforall/features}{https://\-plg.uwaterloo.ca/\-$\sim$cforall/\-features}},
    12271229}
    12281230
    … …  
    12431245    title       = {\textsf{C}$\mathbf{\forall}$ Stack Evaluation Programs},
    12441246    year        = 2018,
    1245     howpublished= {\url{https://cforall.uwaterloo.ca/CFAStackEvaluation.zip}},
     1247    howpublished= {\href{https://cforall.uwaterloo.ca/CFAStackEvaluation.zip}{https://cforall.uwaterloo.ca/\-CFAStackEvaluation.zip}},
    12461248}
    12471249
    … …  
    12541256    year        = 2004,
    12551257    address     = {Waterloo, Ontario, Canada, N2L 3G1},
    1256     note        = {\url{http://plg.uwaterloo.ca/theses/EstevesThesis.pdf}},
     1258    note        = {\href{http://plg.uwaterloo.ca/theses/EstevesThesis.pdf}{http://\-plg.uwaterloo.ca/\-theses/\-EstevesThesis.pdf}},
    12571259}
    12581260
    … …  
    12641266    year        = 2019,
    12651267    optaddress  = {Waterloo, Ontario, Canada, N2L 3G1},
    1266     note        = {\url{https://uwspace.uwaterloo.ca/handle/10012/14584}},
     1268    note        = {\href{https://uwspace.uwaterloo.ca/handle/10012/14584}{https://\-uwspace.uwaterloo.ca/\-handle/\-10012/\-14584}},
    12671269}
    12681270
    … …  
    14211423    month       = oct,
    14221424    year        = 2001,
    1423     note        = {\url{http://plg.uwaterloo.ca/~cforall/cfa.ps}},
     1425    note        = {\href{http://plg.uwaterloo.ca/~cforall/cfa.ps}{http://\-plg.uwaterloo.ca/\-$\sim$cforall/\-cfa.ps}},
    14241426}
    14251427
    … …  
    14591461    contributer = {a3moss@uwaterloo.ca},
    14601462    title       = {Clang: a {C} language family frontend for {LLVM}},
    1461     howpublished= {\url{https://clang.llvm.org/}}
     1463    howpublished= {\href{https://clang.llvm.org/}{https://\-clang.llvm.org/}}
    14621464}
    14631465
    … …  
    15251527    address     = {Geneva, Switzerland},
    15261528    year        = 2014,
    1527     note        = {\url{https://www.iso.org/standard/51416.html}},
     1529    note        = {\href{https://www.iso.org/standard/51416.html}{https://\-www.iso.org/\-standard/\-51416.html}},
    15281530}
    15291531
    … …  
    16661668    publisher   = {Prentice-Hall},
    16671669    address     = {Upper Saddle River, NJ, USA},
    1668     note        = {\url{http://www.usingcsp.com/cspbook.pdf}},
     1670    note        = {\href{http://www.usingcsp.com/cspbook.pdf}{http://\-www.usingcsp.com/\-cspbook.pdf}},
    16691671}
    16701672
    … …  
    17311733    month       = sep,
    17321734    address     = {Waterloo, Ontario, Canada, N2L 3G1},
    1733     note        = {\url{http://plg.uwaterloo.ca/theses/MokThesis.pdf}},
     1735    note        = {\href{http://plg.uwaterloo.ca/theses/MokThesis.pdf}{http://\-plg.uwaterloo.ca/\-theses/\-MokThesis.pdf}},
    17341736}
    17351737
    … …  
    18061808    author      = {Peter A. Buhr and David Dice and Wim H. Hesselink},
    18071809    title       = {concurrent-locking},
    1808     howpublished= {\url{https://github.com/pabuhr/concurrent-locking}},
     1810    howpublished= {\href{https://github.com/pabuhr/concurrent-locking}{https://\-github.com/\-pabuhr/\-concurrent-locking}},
    18091811}
    18101812
    … …  
    19561958    year        = 2015,
    19571959    optaddress  = {Waterloo, Ontario, Canada, N2L 3G1},
    1958     note        = {\url{https://uwspace.uwaterloo.ca/handle/10012/10013}},
     1960    note        = {\href{https://uwspace.uwaterloo.ca/handle/10012/10013}{https://\-uwspace.uwaterloo.ca/\-handle/\-10012/\-10013}},
    19591961}
    19601962
    … …  
    20962098    month       = oct,
    20972099    year        = 2010,
    2098     howpublished= {\url{https://www.airs.com/blog/archives/428}},
     2100    howpublished= {\href{https://www.airs.com/blog/archives/428}
     2101                  {https://www.airs.com/\-blog/\-archives/\-428}},
    20992102}
    21002103
    … …  
    21072110    year        = 1992,
    21082111    address     = {Waterloo, Ontario, Canada, N2L 3G1},
    2109     note        = {\url{http://plg.uwaterloo.ca/theses/DitchfieldThesis.pdf}}
     2112    note        = {\href{http://plg.uwaterloo.ca/theses/DitchfieldThesis.pdf}{http://\-plg.uwaterloo.ca/\-theses/\-DitchfieldThesis.pdf}}
    21102113}
    21112114
    … …  
    21772180    author      = {Glen Ditchfield},
    21782181    title       = {Conversions for \textsf{C}$\mathbf{\forall}$},
    2179     note        = {\url{http://plg.uwaterloo.ca/~cforall/Conversions/index.html}},
     2182    note        = {\href{http://plg.uwaterloo.ca/~cforall/Conversions/index.html}{http://\-plg.uwaterloo.ca/\-$\sim$cforall/\-Conversions/\-index.html}},
    21802183    month       = {Nov},
    21812184    year        = {2002},
    … …  
    22142217    year        = 2019,
    22152218    month       = feb,
    2216     howpublished= {\url{http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p0912r5.html}},
     2219    howpublished= {\href{http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p0912r5.html}
     2220                  {http://\-www.open-std.org/\-jtc1/\-sc22/\-wg21/\-docs/\-papers/\-2019/p0912r5.html}},
    22172221}
    22182222
    … …  
    22252229    month       = jun,
    22262230    year        = 2022,
    2227     note        = {\url{https://en.cppreference.com/w/cpp/language/coroutines}},
     2231    note        = {\href{https://en.cppreference.com/w/cpp/language/coroutines}{https://\-en.cppreference.com/\-w/\-cpp/\-language/\-coroutines}},
    22282232}
    22292233
    … …  
    22792283    title       = {CS343},
    22802284    year        = 2018,
    2281     howpublished= {\url{https://www.student.cs.uwaterloo.ca/~cs343}},
     2285    howpublished= {\href{https://www.student.cs.uwaterloo.ca/~cs343}{https://\-www.student.cs.uwaterloo.ca/\-$\sim$cs343}},
    22822286}
    22832287
    … …  
    23052309    address     = {Vienna Virginia, U.S.A.},
    23062310    year        = 2016,
    2307     note        = {\url{http://dlang.org/spec/spec.html}},
     2311    note        = {\href{http://dlang.org/spec/spec.html}{http://\-dlang.org/\-spec/\-spec.html}},
    23082312}
    23092313
    … …  
    27822786    author      = {Martin Odersky},
    27832787    title       = {Dotty},
    2784     howpublished= {\url{https://github.com/lampepfl/dotty}},
     2788    howpublished= {\href{https://github.com/lampepfl/dotty}{https://\-github.com/\-lampepfl/\-dotty}},
    27852789    note        = {Acessed: 2019-02-22}
    27862790}
    … …  
    27932797    month       = nov,
    27942798    year        = 1983,
    2795     note        = {\url{http://www.lysator.liu.se/c/duffs-device.html}}
     2799    note        = {\href{http://www.lysator.liu.se/c/duffs-device.html}{http://\-www.lysator.liu.se/\-c/\-duffs-device.html}}
    27962800}
    27972801
    … …  
    30293033    month       = aug,
    30303034    note        = {WikipediA},
    3031     howpublished= {\url{http://www.akkadia.org/drepper/tls.pdf}},
     3035    howpublished= {\href{http://www.akkadia.org/drepper/tls.pdf}
     3036                  {http://\-www.akkadia.org/\-drepper/\-tls.pdf}},
    30323037}
    30333038
    … …  
    30403045    month       = may,
    30413046    note        = {Electronic Engineering Times},
    3042     howpublished= {\url{https://www.eetimes.com/author.asp?sectionid=36&doc_id=1287712}},
     3047    howpublished= {\href{https://www.eetimes.com/author.asp?sectionid=36&doc_id=1287712}
     3048                  {https://\-www.eetimes.com/\-author.asp?sectionid=\-36&doc_id=1287712}},
    30433049}
    30443050
    … …  
    31533159    month       = sep,
    31543160    year        = 2016,
    3155     note        = {\url{http://erlang.org/doc/pdf/otp-system-documentation.pdf}},
     3161    note        = {\href{http://erlang.org/doc/pdf/otp-system-documentation.pdf}{http://\-erlang.org/\-doc/\-pdf/\-otp-system-documentation.pdf}},
    31563162}
    31573163
    … …  
    34763482    title       = {Extensions to the {C} Language Family},
    34773483    year        = 2014,
    3478     howpublished= {\url{https://gcc.gnu.org/onlinedocs/gcc-4.7.2/gcc/C-Extensions.html}},
     3484    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}},
    34793485}
    34803486
    … …  
    35593565    month       = feb,
    35603566    publisher   = {John Wiley \& Sons},
    3561     note        = {\url{https://doi.org/10.1002/cpe.4183}}
     3567    note        = {\href{https://doi.org/10.1002/cpe.4183}{https://\-doi.org/\-10.1002/\-cpe.4183}}
    35623568}
    35633569
    … …  
    35813587    title       = {Fibers},
    35823588    organization= {Microsoft, Windows Development Center},
    3583     address     = {\url{https://docs.microsoft.com/en-us/windows/desktop/ProcThread/fibers}},
     3589    address     = {\href{https://docs.microsoft.com/en-us/windows/desktop/ProcThread/fibers}{https://\-docs.microsoft.com/\-en-us/\-windows/\-desktop/\-ProcThread/\-fibers}},
    35843590    year        = 2018,
    35853591}
    … …  
    36033609    month       = jan,
    36043610    address     = {Waterloo, Ontario, Canada, N2L 3G1},
    3605     note        = {\url{http://uwspace.uwaterloo.ca/bitstream/10012/3501/1/Thesis.pdf}},
     3611    note        = {\href{http://uwspace.uwaterloo.ca/bitstream/10012/3501/1/Thesis.pdf}{http://\-uwspace.uwaterloo.ca/\-bitstream/\-10012/\-3501/\-1/\-Thesis.pdf}},
    36063612}
    36073613
    … …  
    36383644    title       = {Facebook Open-source Library},
    36393645    organization= {Facebook},
    3640     address     = {\url{https://github.com/facebook/folly}},
     3646    address     = {\href{https://github.com/facebook/folly}{https://\-github.com/\-facebook/\-folly}},
    36413647    year        = 2018,
    36423648}
    … …  
    36793685    address     = {Geneva, Switzerland},
    36803686    year        = 2010,
    3681     note        = {\url{https://www.iso.org/standard/50459.html}},
     3687    note        = {\href{https://www.iso.org/standard/50459.html}{https://\-www.iso.org/\-standard/\-50459.html}},
    36823688}
    36833689
    … …  
    36913697    address     = {Geneva, Switzerland},
    36923698    year        = 2018,
    3693     note        = {\url{https://www.iso.org/standard/72320.html}},
     3699    note        = {\href{https://www.iso.org/standard/72320.html}{https://\-www.iso.org/\-standard/\-72320.html}},
    36943700}
    36953701
    … …  
    39223928    address     = {GNU},
    39233929    year        = 2016,
    3924     note        = {\url{https://gmplib.org}},
     3930    note        = {\href{https://gmplib.org}{https://\-gmplib.org}},
    39253931}
    39263932
    … …  
    39333939    organization= {Google},
    39343940    year        = 2009,
    3935     note        = {\url{http://golang.org/ref/spec}},
     3941    note        = {\href{http://golang.org/ref/spec}{http://\-golang.org/\-ref/\-spec}},
    39363942}
    39373943
    … …  
    40374043    edition     = {{S}imon {M}arlow},
    40384044    year        = 2010,
    4039     note        = {\url{https://haskell.org/definition/haskell2010.pdf}},
     4045    note        = {\href{https://haskell.org/definition/haskell2010.pdf}{https://\-haskell.org/\-definition/\-haskell2010.pdf}},
    40404046}
    40414047
    … …  
    41124118    number      = 12,
    41134119    pages       = {2463-2500},
    4114     note        = {\url{https://onlinelibrary.wiley.com/doi/10.1002/spe.3262}},
     4120    note        = {\url{https://onlinelibrary.wiley.com/doi/10.1002/spe.3262},
    41154121}
    41164122
    … …  
    41214127    year        = 2019,
    41224128    optaddress  = {Waterloo, Ontario, Canada, N2L 3G1},
    4123     note        = {\url{https://uwspace.uwaterloo.ca/handle/10012/14706}},
     4129    note        = {\href{https://uwspace.uwaterloo.ca/handle/10012/14706}{https://\-uwspace.uwaterloo.ca/\-handle/\-10012/\-14706}},
    41244130}
    41254131
    … …  
    41804186    month       = sep,
    41814187    publisher   = {John Wiley \& Sons},
    4182     note        = {\url{https://doi.org/10.1002/cpe.4475}},
     4188    note        = {\href{https://doi.org/10.1002/cpe.4475}{https://\-doi.org/\-10.1002/\-cpe.4475}},
    41834189}
    41844190
    … …  
    43144320    year        = 2003,
    43154321    optaddress  = {Waterloo, Ontario, Canada, N2L 3G1},
    4316     note        = {\url{http://plg.uwaterloo.ca/theses/BilsonThesis.pdf}},
     4322    note        = {\href{http://plg.uwaterloo.ca/theses/BilsonThesis.pdf}{http://\-plg.uwaterloo.ca/\-theses/\-BilsonThesis.pdf}},
    43174323}
    43184324
    … …  
    47274733    title       = {JDK 1.1 for Solaris Developer's Guide},
    47284734    publisher   = {Oracle},
    4729     address     = {\url{https://docs.oracle.com/cd/E19455-01/806-3461/6jck06gqk/index.html#ch2mt-41}},
     4735    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}},
    47304736    year        = 2010,
    47314737}
    … …  
    47384744    organization= {Oracle},
    47394745    year        = 2014,
    4740     note        = {\url{http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/package-summary.html}},
     4746    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}},
    47414747}
    47424748
    … …  
    48674873    title       = {Labels as Values},
    48684874    year        = {since gcc-3},
    4869     howpublished= {\url{https://gcc.gnu.org/onlinedocs/gcc/Labels-as-Values.html}},
     4875    howpublished= {\href{https://gcc.gnu.org/onlinedocs/gcc/Labels-as-Values.html}
     4876                  {https:\-//gcc.gnu.org/\-onlinedocs/\-gcc/\-Labels-as-Values.html}},
    48704877}
    48714878
    … …  
    49244931    title       = {libdill Thread Library},
    49254932    year        = 2019,
    4926     howpublished= {\url{http://libdill.org/libdill-2.14.tar.gz}},
     4933    howpublished= {\href{http://libdill.org/libdill-2.14.tar.gz}
     4934                  {http://\-libdill.org/\-libdill-2.14.tar.gz}},
    49274935}
    49284936
    … …  
    49314939    author      = {Martin Karsten},
    49324940    title       = {{libfibre:~User-Level Threading Runtime}},
    4933     howpublished= {\url{https://git.uwaterloo.ca/mkarsten/libfibre}},
     4941    howpublished= {\href{https://git.uwaterloo.ca/mkarsten/libfibre}{https://\-git.uwaterloo.ca/\-mkarsten/\-libfibre}},
    49344942    note        = {[Online; accessed 2020-04-15]},
    49354943}
    … …  
    49544962    title       = {{G}o-style concurrency in {C}, Version 1.18},
    49554963    organization= {libmill},
    4956     address     = {\url{http://libmill.org/documentation.html}},
     4964    address     = {\href{http://libmill.org/documentation.html}{http://\-libmill.org/\-documentation.html}},
    49574965    month       = jan,
    49584966    year        = 2017,
    … …  
    50305038    month       = jan,
    50315039    year        = 2017,
    5032     howpublished= {\url{http://smallcultfollowing.com/babysteps/blog/2017/01/26/lowering-rust-traits-to-logic/}},
     5040    howpublished= {\href{http://smallcultfollowing.com/babysteps/blog/2017/01/26/lowering-rust-traits-to-logic/}
     5041                  {http://smallcultfollowing.com/\-babysteps/\-blog/\-2017/\-01/\-26/\-lowering-rust-traits-to-logic/}},
    50335042    optnote     = {Accessed: 2019-01},
    50345043}
    … …  
    50545063    title       = {Lua 5.4 Reference Manual},
    50555064    organization= {Pontifical Catholic University},
    5056     address     = {\url{https://www.lua.org/manual/5.4}},
     5065    address     = {\href{https://www.lua.org/manual/5.4}{https://\-www.lua.org/\-manual/\-5.4}},
    50575066    year        = 2020,
    50585067}
    … …  
    50755084    title       = {Making arbitrarily-large binaries from fixed-size {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} code},
    50765085    year        = 2016,
    5077     howpublished= {\url{http://blog.reverberate.org/2016/01/making-arbitrarily-large-binaries-from.html}},
     5086    howpublished= {\href{http://blog.reverberate.org/2016/01/making-arbitrarily-large-binaries-from.html}
     5087                  {http://blog.reverberate.org/\-2016/\-01/\-making-arbitrarily-large-binaries-from.html}},
    50785088    optnote     = {Accessed: 2016-09},
    50795089}
    … …  
    51085118    title       = {Marcel Thread Library},
    51095119    year        = 2011,
    5110     howpublished= {\url{https://gforge.inria.fr/frs/download.php/file/28643/marcel-2.99.3.tar.gz}},
     5120    howpublished= {\href{https://gforge.inria.fr/frs/download.php/file/28643/marcel-2.99.3.tar.gz}
     5121                  {https://\-gforge.inria.fr/\-frs/\-download.php/\-file/\-28643/\-marcel-2.99.3.tar.gz}},
    51115122}
    51125123
    … …  
    52535264    month       = sep,
    52545265    year        = 1994,
    5255     note        = {\url{https://plg.uwaterloo.ca/~usystem/pub/uSystem/uSystem.pdf}},
     5266    note        = {\href{https://plg.uwaterloo.ca/~usystem/pub/uSystem/uSystem.pdf}{https://\-plg.uwaterloo.ca/\-$\sim$usystem/\-pub/\-uSystem/\-uSystem.pdf}},
    52565267}
    52575268
    … …  
    54525463    month       = jun,
    54535464    year        = 2015,
    5454     note        = {\url{http://www.mpi-forum.org/docs/mpi-3.1/mpi31-report.pdf}},
     5465    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}},
    54555466}
    54565467
    … …  
    56025613    year        = 1980,
    56035614    pages       = {833-842},
    5604     note        = {\url{http://groups.csail.mit.edu/tds/papers/Lynch/allertonconf.pdf}},
     5615    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]},
    56055616    optnote     = {\textsf{http://\-groups.csail.mit.edu/\-tds/\-papers/\-Lynch/\-allertonconf.pdf}},
    56065617}
    … …  
    56285639    institution = {Red Hat},
    56295640    year        = 2003,
    5630     note        = {\url{http://www.cs.utexas.edu/~witchel/372/lectures/POSIX_Linux_Threading.pdf}},
     5641    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}},
    56315642}
    56325643
    … …  
    56385649    organization= {{gcc} 9.3 Manual},
    56395650    year        = 2019,
    5640     note        = {\url{https://gcc.gnu.org/onlinedocs/gcc-9.3.0/gcc/Nested-Functions.html}},
     5651    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}},
    56415652}
    56425653
    … …  
    57075718    year        = 1990,
    57085719    pages       = {41-51},
    5709     note        = {\url{http://doc.cat-v.org/bell_labs/new_c_compilers/new_c_compiler.pdf}},
     5720    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}},
    57105721}
    57115722
    … …  
    57705781    key         = {nginx},
    57715782    author      = {{NGINX}},
    5772     howpublished= {\url{https://www.nginx.com}},
     5783    howpublished= {\href{https://www.nginx.com}{https://\-www.nginx.com}},
    57735784}
    57745785
    … …  
    58995910    publisher   = {Apple Inc.},
    59005911    year        = 2014,
    5901     howpublished= {\url{https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/ProgrammingWithObjectiveC}},
     5912    howpublished= {\href{https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/ProgrammingWithObjectiveC}{https://\-developer.apple.com/\-library/archive/\-documentation/\-Cocoa/\-Conceptual/\-ProgrammingWithObjectiveC}},
    59025913}
    59035914
    … …  
    59085919    title       = {{X}code 7 Release Notes},
    59095920    year        = 2015,
    5910     howpublished= {\url{https://developer.apple.com/library/content/documentation/Xcode/Conceptual/RN-Xcode-Archive/Chapters/xc7_release_notes.html}},
     5921    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}},
    59115922}
    59125923
    … …  
    60416052    month       = nov,
    60426053    year        = 2015,
    6043     note        = {\url{https://www.openmp.org/wp-content/uploads/openmp-4.5.pdf}},
     6054    note        = {\href{https://www.openmp.org/wp-content/uploads/openmp-4.5.pdf}{https://\-www.openmp.org/\-wp-content/\-uploads/\-openmp-4.5.pdf}},
    60446055}
    60456056
    … …  
    60496060    title       = {OpenTelemetry},
    60506061    author      = {{Asynkron AB}},
    6051     howpublished= {\url{https://proto.actor/docs/tracing}},
     6062    howpublished= {\href{https://proto.actor/docs/tracing}{https://\-proto.actor/\-docs/\-tracing}},
    60526063    year        = 2022,
    60536064}
    … …  
    64506461    key         = {perf},
    64516462    author      = {perf},
    6452     howpublished= {\url{https://perf.wiki.kernel.org/index.php/Tutorial}},
     6463    howpublished= {\href{https://perf.wiki.kernel.org/index.php/Tutorial}{https://\-perf.wiki.kernel.org/\-index.php/\-Tutorial}},
    64536464}
    64546465
    … …  
    64596470    month       = may,
    64606471    year        = 2012,
    6461     howpublished= {\url{http://cs.brown.edu/research/pubs/theses/masters/2012/verch.pdf}},
     6472    howpublished= {\href{http://cs.brown.edu/research/pubs/theses/masters/2012/verch.pdf}{http://cs.brown.edu/\-research/\-pubs/\-theses/\-masters/\-2012/\-verch.pdf}},
    64626473}
    64636474
    … …  
    68586869    address     = {Geneva, Switzerland},
    68596870    year        = 1998,
    6860     note        = {\url{https://www.iso.org/standard/25845.html}},
     6871    note        = {\href{https://www.iso.org/standard/25845.html}{https://\-www.iso.org/\-standard/\-25845.html}},
    68616872}
    68626873
    … …  
    68706881    address     = {Geneva, Switzerland},
    68716882    year        = 2014,
    6872     note        = {\url{https://www.iso.org/standard/64029.html}},
     6883    note        = {\href{https://www.iso.org/standard/64029.html}{https://\-www.iso.org/\-standard/\-64029.html}},
    68736884}
    68746885
    … …  
    68826893    address     = {Geneva, Switzerland},
    68836894    year        = 2017,
    6884     note        = {\url{https://www.iso.org/standard/68564.html}},
     6895    note        = {\href{https://www.iso.org/standard/68564.html}{https://\-www.iso.org/\-standard/\-68564.html}},
    68856896}
    68866897
    … …  
    71627173    author      = {IEEE and {The Open Group}},
    71637174    year        = 2018,
    7164     howpublished= {\url{http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/pthread.h.html}},
     7175    howpublished= {\href{http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/pthread.h.html}
     7176                  {http://\-pubs.opengroup.org/\-onlinepubs/\-9699919799/\-basedefs/\-pthread.h.html}},
    71657177}
    71667178
    … …  
    71717183    title       = {Python Language Reference, Release 3.7.2},
    71727184    organization= {Python Software Foundation},
    7173     address     = {\url{https://docs.python.org/3/reference/index.html}},
     7185    address     = {\href{https://docs.python.org/3/reference/index.html}{https://\-docs.python.org/\-3/\-reference/\-index.html}},
    71747186    year        = 2018,
    71757187}
    … …  
    72267238    title       = {Quasar Documentation, Release 0.8.0},
    72277239    organization= {Parallel Universe},
    7228     address     = {\url{http://docs.paralleluniverse.co/quasar}},
     7240    address     = {\href{http://docs.paralleluniverse.co/quasar}{http://\-docs.paralleluniverse.co/\-quasar}},
    72297241    year        = 2018,
    72307242}
    … …  
    73667378    month       = apr,
    73677379    type        = {Diplomarbeit},
    7368     note        = {\url{https://plg.uwaterloo.ca/~usystem/theses/SchusterThesis.pdf}},
     7380    note        = {\href{https://plg.uwaterloo.ca/~usystem/theses/SchusterThesis.pdf}{https://\-plg.uwaterloo.ca/\-$\sim$usystem/\-theses/\-SchusterThesis.pdf}},
    73697381}
    73707382
    … …  
    74017413    year        = 2017,
    74027414    optaddress  = {Waterloo, Ontario, Canada, N2L 3G1},
    7403     note        = {\url{https://uwspace.uwaterloo.ca/handle/10012/11830}},
     7415    note        = {\href{https://uwspace.uwaterloo.ca/handle/10012/11830}{https://\-uwspace.uwaterloo.ca/\-handle/\-10012/\-11830}},
    74047416}
    74057417
    … …  
    74797491    month       = apr,
    74807492    year        = 2022,
    7481     howpublished= {\url{https://github.com/mjansson/rpmalloc}},
     7493    howpublished= {\href{https://github.com/mjansson/rpmalloc}{https://\-github.com/\-mjansson/\-rpmalloc}},
    74827494}
    74837495
    … …  
    74897501    optaddress  = {Rust Project Developers},
    74907502    year        = 2015,
    7491     note        = {\url{https://doc.rust-lang.org/reference.html}},
     7503    note        = {\href{https://doc.rust-lang.org/reference.html}{https://\-doc.rust-lang\-.org/\-reference.html}},
    74927504}
    74937505
    … …  
    74987510    title       = {Ruby Documentation, Release 2.6.0},
    74997511    organization= {Python Software Foundation},
    7500     address     = {\url{https://www.ruby-lang.org/en/documentation}},
     7512    address     = {\href{https://www.ruby-lang.org/en/documentation}{https://\-www.ruby-lang.org/\-en/\-documentation}},
    75017513    year        = 2018,
    75027514}
    … …  
    75267538    address     = {\'{E}cole Polytechnique F\'{e}d\'{e}rale de Lausanne},
    75277539    year        = 2016,
    7528     note        = {\url{http://www.scala-lang.org/files/archive/spec/2.11}},
     7540    note        = {\href{http://www.scala-lang.org/files/archive/spec/2.11}{http://\-www.scala-lang.org/\-files/\-archive/\-spec/\-2.11}},
    75297541}
    75307542
    … …  
    76877699    month       = sep,
    76887700    year        = 1995,
    7689     note        = {\url{http://www.hpl.hp.com/techreports/Compaq-DEC/WRL-95-7.pdf}},
     7701    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}.},
    76907702}
    76917703
    … …  
    77617773    month       = may,
    77627774    year        = 2001,
    7763     note        = {\url{http://www.python.org/peps/pep-0255.html}},
     7775    note        = {\href{http://www.python.org/peps/pep-0255.html}{http://\-www.python.org/\-peps/\-pep-0255.html}},
    77647776}
    77657777
    … …  
    80648076    organization= {IEEE and The Open Group},
    80658077    year        = 2017,
    8066     note        = {\url{https://pubs.opengroup.org/onlinepubs/9699919799}},
     8078    note        = {\href{https://pubs.opengroup.org/onlinepubs/9699919799}{https://\-pubs.opengroup.org/\-onlinepubs/\-9699919799}},
    80678079}
    80688080
    … …  
    81318143    pages       = {1-6},
    81328144    numpages    = {6},
    8133     howpublished= {\url{http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0144r0.pdf}},
     8145    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}},
    81348146}
    81358147
    … …  
    84418453    key         = {TIOBE Index},
    84428454    author      = {{TIOBE Index}},
    8443     howpublished= {\url{http://www.tiobe.com/tiobe_index}},
     8455    howpublished= {\href{http://www.tiobe.com/tiobe_index}{http://\-www.tiobe.com/\-tiobe\_index}},
    84448456}
    84458457
    … …  
    84498461    title       = {Thread (computing)},
    84508462    author      = {{Threading Model}},
    8451     howpublished= {\url{https://en.wikipedia.org/wiki/Thread_(computing)}},
     8463    howpublished= {\href{https://en.wikipedia.org/wiki/Thread_(computing)}{https://\-en.wikipedia.org/\-wiki/\-Thread\_\-(computing)}},
    84528464}
    84538465
    … …  
    84578469    title       = {{T}okio Asynchronous Runtime for {R}ust},
    84588470    author      = {Tokio},
    8459     howpublished= {\url{https://tokio.rs}},
     8471    howpublished= {\href{https://tokio.rs}{https://\-tokio.rs}},
    84608472}
    84618473
    … …  
    85978609    key         = {Trace Compass},
    85988610    author      = {{T}race {C}ompass},
    8599     howpublished= {\url{https://projects.eclipse.org/proposals/trace-compass}},
     8611    howpublished= {\href{https://projects.eclipse.org/proposals/trace-compass}{https://\-projects.eclipse.org/\-proposals/\-trace-compass}},
    86008612}
    86018613
    … …  
    86568668    title       = {Typed Actors},
    86578669    author      = {{Lightbend}},
    8658     howpublished= {\url{https://doc.akka.io/docs/akka/2.5/typed-actors.html}},
     8670    howpublished= {\href{https://doc.akka.io/docs/akka/2.5/typed-actors.html}{https://\-doc.akka.io/\-docs/\-akka/\-2.5/\-typed-actors.html}},
    86598671    year        = 2022,
    86608672}
    … …  
    89268938    year        = 2020,
    89278939    note        = {WikipediA},
    8928     howpublished= {\url{https://en.wikipedia.org/wiki/Visitor\_pattern}},
     8940    howpublished= {\href{https://en.wikipedia.org/wiki/Visitor\_pattern}
     8941                  {https://\-en.wikipedia.org/\-wiki/\-Visitor\_pattern}},
    89298942}
    89308943
    … …  
    90289041    month       = jun,
    90299042    year        = 1985,
    9030     note        = {\url{http://www.hpl.hp.com/techreports/tandem/TR-85.7.pdf}},
     9043    note        = {\href{http://www.hpl.hp.com/techreports/tandem/TR-85.7.pdf}{http://www.hpl.hp.com/\-techreports/\-tandem/\-TR-85.7.pdf}},
    90319044}
    90329045

  • doc/papers/llheap/Paper.tex

    r32490deb rc75b30a  
    7777\lstset{
    7878columns=fullflexible,
    79 basicstyle=\linespread{0.9}\sf,                 % reduce line spacing and use sanserif font
    80 stringstyle=\small\tt,                                  % use typewriter font
    81 tabsize=5,                                                              % N space tabbing
    82 xleftmargin=\parindentlnth,                             % indent code to paragraph indentation
    83 escapechar=\$,                                                  % LaTeX escape in CFA code
    84 %mathescape=true,                                               % LaTeX math escape in CFA code $...$
    85 keepspaces=true,                                                %
    86 showstringspaces=false,                                 % do not show spaces with cup
    87 showlines=true,                                                 % show blank lines at end of code
    88 aboveskip=4pt,                                                  % spacing above/below code block
    89 belowskip=2pt,
    90 numberstyle=\footnotesize\sf,                   % numbering style
    91 moredelim=**[is][\color{red}]{@}{@},
     79basicstyle=\linespread{0.9}\sf,                                                 % reduce line spacing and use sanserif font
     80stringstyle=\tt,                                                                                % use typewriter font
     81tabsize=5,                                                                                              % N space tabbing
     82xleftmargin=\parindentlnth,                                                             % indent code to paragraph indentation
     83%mathescape=true,                                                                               % LaTeX math escape in CFA code $...$
     84escapechar=\$,                                                                                  % LaTeX escape in CFA code
     85keepspaces=true,                                                                                %
     86showstringspaces=false,                                                                 % do not show spaces with cup
     87showlines=true,                                                                                 % show blank lines at end of code
     88aboveskip=4pt,                                                                                  % spacing above/below code block
     89belowskip=3pt,
     90moredelim=**[is][\color{red}]{`}{`},
    9291}% lstset
    9392
    … …  
    10831082
    10841083The 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.
    1085 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.
     1084(Large allocations requiring initialization, \eg zero fill, and/or copying are not covered by the low-latency objective.)
    10861085A direct consequence of this objective is very simple or no storage coalescing;
    10871086hence, llheap's design is willing to use more storage to lower latency.
    10881087This objective is apropos because systems research and industrial applications are striving for low latency and computers have huge amounts of RAM memory.
    1089 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}).
     1088Finally, llheap's performance should be comparable with the current best allocators (see performance comparison in Section~\ref{c:Performance}).
    10901089
    10911090% The objective of llheap's new design was to fulfill following requirements:
    … …  
    12061205% \label{s:AllocationFastpath}
    12071206
    1208 llheap's design was reviewed and changed multiple times during its development, with the final choices are discussed here.
     1207llheap's design was reviewed and changed multiple times during its development.  Only the final design choices are
     1208discussed in this paper.
    12091209(See~\cite{Zulfiqar22} for a discussion of alternate choices and reasons for rejecting them.)
    12101210All designs were analyzed for the allocation/free \newterm{fastpath}, \ie when an allocation can immediately return free storage or returned storage is not coalesced.
    1211 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.
     1211The 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.
    12121212(See Figure~\ref{f:THSharedHeaps} but with a heap bucket per KT and no bucket or local-pool lock.)
    12131213Hence, immediately after a KT starts, its heap is created and just before a KT terminates, its heap is (logically) deleted.
    … …  
    14261426
    14271427
    1428 Algorithm~\ref{alg:heapObjectFreeOwn} shows the deallocation (free) outline for an object at address $A$ with ownership.
     1428Algorithm~\ref{alg:heapObjectFreeOwn} shows the de-allocation (free) outline for an object at address $A$ with ownership.
    14291429First, the address is divided into small (@sbrk@) or large (@mmap@).
    14301430For large allocations, the storage is unmapped back to the OS.
    … …  
    14331433If the bucket is not local to the thread, the allocation is pushed onto the owning thread's associated away stack.
    14341434
    1435 Algorithm~\ref{alg:heapObjectFreeNoOwn} shows the deallocation (free) outline for an object at address $A$ without ownership.
     1435Algorithm~\ref{alg:heapObjectFreeNoOwn} shows the de-allocation (free) outline for an object at address $A$ without ownership.
    14361436The algorithm is the same as for ownership except if the bucket is not local to the thread.
    14371437Then the corresponding bucket of the owner thread is computed for the deallocating thread, and the allocation is pushed onto the deallocating thread's bucket.
    … …  
    17921792The C dynamic-memory API is extended with the following routines:
    17931793
    1794 \medskip\noindent
    1795 \lstinline{void * aalloc( size_t dim, size_t elemSize )}
    1796 extends @calloc@ for allocating a dynamic array of objects with total size @dim@ $\times$ @elemSize@ but \emph{without} zero-filling the memory.
    1797 @aalloc@ is significantly faster than @calloc@, which is the only alternative given by the standard memory-allocation routines for array allocation.
     1794\paragraph{\lstinline{void * aalloc( size_t dim, size_t elemSize )}}
     1795extends @calloc@ for allocating a dynamic array of objects without calculating the total size of array explicitly but \emph{without} zero-filling the memory.
     1796@aalloc@ is significantly faster than @calloc@, which is the only alternative given by the standard memory-allocation routines.
     1797
     1798\noindent\textbf{Usage}
     1799@aalloc@ takes two parameters.
     1800\begin{itemize}[topsep=3pt,itemsep=2pt,parsep=0pt]
     1801\item
     1802@dim@: number of array objects
     1803\item
     1804@elemSize@: size of array object
     1805\end{itemize}
    17981806It returns the address of the dynamic array or @NULL@ if either @dim@ or @elemSize@ are zero.
    17991807
    1800 \medskip\noindent
    1801 \lstinline{void * resize( void * oaddr, size_t size )}
    1802 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.
     1808\paragraph{\lstinline{void * resize( void * oaddr, size_t size )}}
     1809extends @realloc@ for resizing an existing allocation \emph{without} copying previous data into the new allocation or preserving sticky properties.
    18031810@resize@ is significantly faster than @realloc@, which is the only alternative.
     1811
     1812\noindent\textbf{Usage}
     1813@resize@ takes two parameters.
     1814\begin{itemize}[topsep=3pt,itemsep=2pt,parsep=0pt]
     1815\item
     1816@oaddr@: address to be resized
     1817\item
     1818@size@: new allocation size (smaller or larger than previous)
     1819\end{itemize}
    18041820It returns the address of the old or new storage with the specified new size or @NULL@ if @size@ is zero.
    18051821
    1806 \medskip\noindent
    1807 \lstinline{void * amemalign( size_t alignment, size_t dim, size_t elemSize )}
    1808 extends @aalloc@ and @memalign@ for allocating a dynamic array of objects with the starting address on the @alignment@ boundary.
     1822\paragraph{\lstinline{void * amemalign( size_t alignment, size_t dim, size_t elemSize )}}
     1823extends @aalloc@ and @memalign@ for allocating an aligned dynamic array of objects.
    18091824Sets sticky alignment property.
     1825
     1826\noindent\textbf{Usage}
     1827@amemalign@ takes three parameters.
     1828\begin{itemize}[topsep=3pt,itemsep=2pt,parsep=0pt]
     1829\item
     1830@alignment@: alignment requirement
     1831\item
     1832@dim@: number of array objects
     1833\item
     1834@elemSize@: size of array object
     1835\end{itemize}
    18101836It returns the address of the aligned dynamic-array or @NULL@ if either @dim@ or @elemSize@ are zero.
    18111837
    1812 \medskip\noindent
    1813 \lstinline{void * cmemalign( size_t alignment, size_t dim, size_t elemSize )}
     1838\paragraph{\lstinline{void * cmemalign( size_t alignment, size_t dim, size_t elemSize )}}
    18141839extends @amemalign@ with zero fill and has the same usage as @amemalign@.
    18151840Sets sticky zero-fill and alignment property.
    18161841It returns the address of the aligned, zero-filled dynamic-array or @NULL@ if either @dim@ or @elemSize@ are zero.
    18171842
    1818 \medskip\noindent
    1819 \lstinline{size_t malloc_alignment( void * addr )}
    1820 returns the object alignment, where objects not allocated with alignment return the minimal allocation alignment.
    1821 For use in aligning similar allocations.
    1822 
    1823 \medskip\noindent
    1824 \lstinline{bool malloc_zero_fill( void * addr )}
    1825 returns true if the objects zero-fill sticky property is set and false otherwise.
    1826 For use in zero filling similar allocations.
    1827 
    1828 \medskip\noindent
    1829 \lstinline{size_t malloc_size( void * addr )}
    1830 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@).
    1831 For use in similar allocations.
    1832 
    1833 \medskip\noindent
    1834 \lstinline{int malloc_stats_fd( int fd )}
    1835 changes the file descriptor where @malloc_stats@ writes statistics (default @stdout@) and returns the previous file descriptor.
    1836 
    1837 \medskip\noindent
    1838 \lstinline{size_t malloc_expansion()}
     1843\paragraph{\lstinline{size_t malloc_alignment( void * addr )}}
     1844returns the alignment of the dynamic object for use in aligning similar allocations.
     1845
     1846\noindent\textbf{Usage}
     1847@malloc_alignment@ takes one parameter.
     1848\begin{itemize}[topsep=3pt,itemsep=2pt,parsep=0pt]
     1849\item
     1850@addr@: address of an allocated object.
     1851\end{itemize}
     1852It returns the alignment of the given object, where objects not allocated with alignment return the minimal allocation alignment.
     1853
     1854\paragraph{\lstinline{bool malloc_zero_fill( void * addr )}}
     1855returns true if the object has the zero-fill sticky property for use in zero filling similar allocations.
     1856
     1857\noindent\textbf{Usage}
     1858@malloc_zero_fill@ takes one parameters.
     1859
     1860\begin{itemize}[topsep=3pt,itemsep=2pt,parsep=0pt]
     1861\item
     1862@addr@: address of an allocated object.
     1863\end{itemize}
     1864It returns true if the zero-fill sticky property is set and false otherwise.
     1865
     1866\paragraph{\lstinline{size_t malloc_size( void * addr )}}
     1867returns the request size of the dynamic object (updated when an object is resized) for use in similar allocations.
     1868See also @malloc_usable_size@.
     1869
     1870\noindent\textbf{Usage}
     1871@malloc_size@ takes one parameters.
     1872\begin{itemize}[topsep=3pt,itemsep=2pt,parsep=0pt]
     1873\item
     1874@addr@: address of an allocated object.
     1875\end{itemize}
     1876It returns the request size or zero if @addr@ is @NULL@.
     1877
     1878\paragraph{\lstinline{int malloc_stats_fd( int fd )}}
     1879changes the file descriptor where @malloc_stats@ writes statistics (default @stdout@).
     1880
     1881\noindent\textbf{Usage}
     1882@malloc_stats_fd@ takes one parameters.
     1883\begin{itemize}[topsep=3pt,itemsep=2pt,parsep=0pt]
     1884\item
     1885@fd@: file descriptor.
     1886\end{itemize}
     1887It returns the previous file descriptor.
     1888
     1889\paragraph{\lstinline{size_t malloc_expansion()}}
    18391890\label{p:malloc_expansion}
    18401891set the amount (bytes) to extend the heap when there is insufficient free storage to service an allocation request.
    18411892It 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.
    18421893
    1843 \medskip\noindent
    1844 \lstinline{size_t malloc_mmap_start()}
     1894\paragraph{\lstinline{size_t malloc_mmap_start()}}
    18451895set the crossover between allocations occurring in the @sbrk@ area or separately mapped.
    18461896It returns the crossover point used throughout a program, \ie called once at heap initialization.
    18471897
    1848 \medskip\noindent
    1849 \lstinline{size_t malloc_unfreed()}
     1898\paragraph{\lstinline{size_t malloc_unfreed()}}
    18501899\label{p:malloc_unfreed}
    18511900amount subtracted to adjust for unfreed program storage (debug only).
    1852 It returns the new subtraction amount and called by @malloc_stats@ (discussed in Section~\ref{}).
     1901It returns the new subtraction amount and called by @malloc_stats@.
    18531902
    18541903
    … …  
    18571906The following extensions take advantage of overload polymorphism in the \CC type-system.
    18581907
    1859 \medskip\noindent
    1860 \lstinline{void * resize( void * oaddr, size_t nalign, size_t size )}
    1861 extends @resize@ with an alignment requirement, @nalign@.
     1908\paragraph{\lstinline{void * resize( void * oaddr, size_t nalign, size_t size )}}
     1909extends @resize@ with an alignment re\-quirement.
     1910
     1911\noindent\textbf{Usage}
     1912takes three parameters.
     1913\begin{itemize}[topsep=3pt,itemsep=2pt,parsep=0pt]
     1914\item
     1915@oaddr@: address to be resized
     1916\item
     1917@nalign@: alignment requirement
     1918\item
     1919@size@: new allocation size (smaller or larger than previous)
     1920\end{itemize}
    18621921It returns the address of the old or new storage with the specified new size and alignment, or @NULL@ if @size@ is zero.
    18631922
    1864 \medskip\noindent
    1865 \lstinline{void * realloc( void * oaddr, size_t nalign, size_t size )}
    1866 extends @realloc@ with an alignment requirement, @nalign@.
    1867 It returns the address of the old or new storage with the specified new size and alignment, or @NULL@ if @size@ is zero.
     1923\paragraph{\lstinline{void * realloc( void * oaddr, size_t nalign, size_t size )}}
     1924extends @realloc@ with an alignment re\-quirement and has the same usage as aligned @resize@.
    18681925
    18691926
    … …  
    19221979object size: like the \CFA's C-interface, programmers do not have to specify object size or cast allocation results.
    19231980\end{itemize}
    1924 Note, postfix function call is an alternative call syntax, using backtick @`@, so the argument appears before the function name, \eg
     1981Note, postfix function call is an alternative call syntax, using backtick @`@, where the argument appears before the function name, \eg
    19251982\begin{cfa}
    19261983duration ?@`@h( int h );                // ? denote the position of the function operand
    … …  
    19301987\end{cfa}
    19311988
    1932 The following extensions take advantage of overload polymorphism in the \CC type-system.
    1933 
    1934 \medskip\noindent
    1935 \lstinline{T * alloc( ... )} or \lstinline{T * alloc( size_t dim, ... )}
     1989\paragraph{\lstinline{T * alloc( ... )} or \lstinline{T * alloc( size_t dim, ... )}}
    19361990is overloaded with a variable number of specific allocation operations, or an integer dimension parameter followed by a variable number of specific allocation operations.
    19371991These allocation operations can be passed as named arguments when calling the \lstinline{alloc} routine.
    … …  
    19421996
    19431997The allocation property functions are:
    1944 
    1945 \medskip\noindent
    1946 \lstinline{T_align ?`align( size_t alignment )}
     1998\subparagraph{\lstinline{T_align ?`align( size_t alignment )}}
    19471999to align the allocation.
    1948 The alignment parameter must be $\ge$ the default alignment (@libAlign()@ in \CFA) and a power of two.
    1949 The following example returns a dynamic object and object array aligned on a 4096-byte boundary.
     2000The alignment parameter must be $\ge$ the default alignment (@libAlign()@ in \CFA) and a power of two, \eg:
    19502001\begin{cfa}
    19512002int * i0 = alloc( @4096`align@ );  sout | i0 | nl;
    … …  
    195520060x555555574000 0x555555574000 0x555555574004 0x555555574008
    19562007\end{cfa}
    1957 
    1958 \medskip\noindent
    1959 \lstinline{S_fill(T) ?`fill ( /* various types */ )}
     2008returns a dynamic object and object array aligned on a 4096-byte boundary.
     2009
     2010\subparagraph{\lstinline{S_fill(T) ?`fill ( /* various types */ )}}
    19602011to initialize storage.
    19612012There are three ways to fill storage:
    1962 \begin{enumerate}[itemsep=0pt,parsep=0pt]
     2013\begin{enumerate}
    19632014\item
    19642015A char fills each byte of each object.
    … …  
    19692020\end{enumerate}
    19702021For example:
    1971 \begin{cfa}[numbers=left,xleftmargin=2.5\parindentlnth]
     2022\begin{cfa}[numbers=left]
    19722023int * i0 = alloc( @0n`fill@ );  sout | *i0 | nl;  // disambiguate 0
    19732024int * i1 = alloc( @5`fill@ );  sout | *i1 | nl;
    … …  
    19782029int * i6 = alloc( 5, @[i3, 3]`fill@ );  for ( i; 5 ) sout | i6[i]; sout | nl;
    19792030\end{cfa}
    1980 \begin{lstlisting}[numbers=left,xleftmargin=2.5\parindentlnth]
     2031\begin{lstlisting}[numbers=left]
    198120320
    198220335
    … …  
    19902041Examples 4 to 7 fill an array of objects with values, another array, or part of an array.
    19912042
    1992 \medskip\noindent
    1993 \lstinline{S_resize(T) ?`resize( void * oaddr )}
     2043\subparagraph{\lstinline{S_resize(T) ?`resize( void * oaddr )}}
    19942044used to resize, realign, and fill, where the old object data is not copied to the new object.
    19952045The old object type may be different from the new object type, since the values are not used.
    19962046For example:
    1997 \begin{cfa}[numbers=left,xleftmargin=2.5\parindentlnth]
     2047\begin{cfa}[numbers=left]
    19982048int * i = alloc( @5`fill@ );  sout | i | *i;
    19992049i = alloc( @i`resize@, @256`align@, @7`fill@ );  sout | i | *i;
    20002050double * d = alloc( @i`resize@, @4096`align@, @13.5`fill@ );  sout | d | *d;
    20012051\end{cfa}
    2002 \begin{lstlisting}[numbers=left,xleftmargin=2.5\parindentlnth]
     2052\begin{lstlisting}[numbers=left]
    200320530x55555556d5c0 5
    200420540x555555570000 7
    … …  
    20072057Examples 2 to 3 change the alignment, fill, and size for the initial storage of @i@.
    20082058
    2009 \begin{cfa}[numbers=left,xleftmargin=2.5\parindentlnth]
     2059\begin{cfa}[numbers=left]
    20102060int * ia = alloc( 5, @5`fill@ );  for ( i; 5 ) sout | ia[i]; sout | nl;
    20112061ia = alloc( 10, @ia`resize@, @7`fill@ ); for ( i; 10 ) sout | ia[i]; sout | nl;
    … …  
    20132063ia = alloc( 3, @ia`resize@, @4096`align@, @2`fill@ );  sout | ia; for ( i; 3 ) sout | &ia[i] | ia[i]; sout | nl;
    20142064\end{cfa}
    2015 \begin{lstlisting}[numbers=left,xleftmargin=2.5\parindentlnth]
     2065\begin{lstlisting}[numbers=left]
    201620665 5 5 5 5
    201720677 7 7 7 7 7 7 7 7 7
    … …  
    20212071Examples 2 to 4 change the array size, alignment and fill for the initial storage of @ia@.
    20222072
    2023 \medskip\noindent
    2024 \lstinline{S_realloc(T) ?`realloc( T * a ))}
     2073\subparagraph{\lstinline{S_realloc(T) ?`realloc( T * a ))}}
    20252074used to resize, realign, and fill, where the old object data is copied to the new object.
    20262075The old object type must be the same as the new object type, since the value is used.
    20272076Note, for @fill@, only the extra space after copying the data from the old object is filled with the given parameter.
    20282077For example:
    2029 \begin{cfa}[numbers=left,xleftmargin=2.5\parindentlnth]
     2078\begin{cfa}[numbers=left]
    20302079int * i = alloc( @5`fill@ );  sout | i | *i;
    20312080i = alloc( @i`realloc@, @256`align@ );  sout | i | *i;
    20322081i = alloc( @i`realloc@, @4096`align@, @13`fill@ );  sout | i | *i;
    20332082\end{cfa}
    2034 \begin{lstlisting}[numbers=left,xleftmargin=2.5\parindentlnth]
     2083\begin{lstlisting}[numbers=left]
    203520840x55555556d5c0 5
    203620850x555555570000 5
    … …  
    20402089The @13`fill@ in example 3 does nothing because no extra space is added.
    20412090
    2042 \begin{cfa}[numbers=left,xleftmargin=2.5\parindentlnth]
     2091\begin{cfa}[numbers=left]
    20432092int * ia = alloc( 5, @5`fill@ );  for ( i; 5 ) sout | ia[i]; sout | nl;
    20442093ia = alloc( 10, @ia`realloc@, @7`fill@ ); for ( i; 10 ) sout | ia[i]; sout | nl;
    … …  
    20462095ia = alloc( 3, @ia`realloc@, @4096`align@, @2`fill@ );  sout | ia; for ( i; 3 ) sout | &ia[i] | ia[i]; sout | nl;
    20472096\end{cfa}
    2048 \begin{lstlisting}[numbers=left,xleftmargin=2.5\parindentlnth]
     2097\begin{lstlisting}[numbers=left]
    204920985 5 5 5 5
    205020995 5 5 5 5 7 7 7 7 7

  • doc/proposals/enum.tex

    r32490deb rc75b30a  
    77\usepackage{graphics}
    88\usepackage{xspace}
    9 \usepackage{relsize}                                                                    % must be after change to small or selects old size
    10 \usepackage{calc}                                                                               % latex arithmetic
    119
    1210\makeatletter
    … …  
    2422\newcommand{\@newterm}[2][\@empty]{\lowercase{\def\temp{#2}}{\newtermFontInline{#2}}\ifx#1\@empty\index{\temp}\else\index{#1@{\protect#2}}\fi}
    2523\newcommand{\@snewterm}[2][\@empty]{{\newtermFontInline{#2}}\ifx#1\@empty\index{#2}\else\index{#1@{\protect#2}}\fi}
    26 
    27 \newcommand{\LstBasicStyle}[1]{{\lst@basicstyle{#1}}}
    28 \newcommand{\LstKeywordStyle}[1]{{\lst@basicstyle{\lst@keywordstyle{#1}}}}
    29 \newcommand{\LstCommentStyle}[1]{{\lst@basicstyle{\lst@commentstyle{#1}}}}
    30 \newcommand{\LstStringStyle}[1]{{\lst@basicstyle{\lst@stringstyle{#1}}}}
    31 \newcommand{\LstNumberStyle}[1]{{\lst@basicstyle{\lst@numberstyle{#1}}}}
    32 
    33 \newlength{\gcolumnposn}                                % temporary hack because lstlisting does not handle tabs correctly
    34 \newlength{\columnposn}
    35 \setlength{\gcolumnposn}{3in}
    36 \setlength{\columnposn}{\gcolumnposn}
    37 \newcommand{\setgcolumn}[1]{\global\gcolumnposn=#1\global\columnposn=\gcolumnposn}
    38 \newcommand{\C}[2][\@empty]{\ifx#1\@empty\else\global\setlength{\columnposn}{#1}\global\columnposn=\columnposn\fi\hfill\makebox[\textwidth-\columnposn][l]{\LstCommentStyle{#2}}}
    39 \newcommand{\CD}[2][\@empty]{\ifx#1\@empty\else\global\setlength{\columnposn}{#1}\global\columnposn=\columnposn\fi\hfill\makebox[\textwidth-\columnposn][l]{\LstBasicStyle{#2}}}
    40 \newcommand{\CRT}{\global\columnposn=\gcolumnposn}
    4124\makeatother
    4225
    … …  
    6548\newcommand{\CCIcon}{\textrm{C}\kern-.1em\hbox{+\kern-.25em+}} % C++ icon
    6649\newcommand{\CC}[1][]{\protect\CCIcon{#1}\xspace}               % C++ symbolic name
    67 \newcommand{\Csharp}{C\raisebox{-0.7ex}{\relsize{2}$^\sharp$}\xspace} % C# symbolic name
    6850\newcommand{\PAB}[1]{{\color{red}PAB: #1}}
    6951
    … …  
    7456
    7557\lstdefinestyle{CStyle}{
    76 %    backgroundcolor=\color{backgroundColour},
     58%    backgroundcolor=\color{backgroundColour},   
    7759%    commentstyle=\color{mGreen},
    7860%    keywordstyle=\color{magenta},
    … …  
    8264    basicstyle=\small\linespread{0.9}\sf,       % reduce line spacing and use sanserif font
    8365%   basicstyle=\footnotesize,
    84     breakatwhitespace=false,
    85 %    breaklines=true,
    86     captionpos=b,
    87     keepspaces=true,
     66    breakatwhitespace=false,         
     67%    breaklines=true,                 
     68    captionpos=b,                   
     69    keepspaces=true,                 
    8870        escapechar=\$,                                                  % LaTeX escape in CFA code
    89 %    numbers=left,
    90 %    numbersep=5pt,
     71%    numbers=left,                   
     72%    numbersep=5pt,                 
    9173%    numberstyle=\tiny\color{mGray},
    92 %    showspaces=false,
     74%    showspaces=false,               
    9375    showstringspaces=false,
    94 %    showtabs=false,
     76%    showtabs=false,                 
    9577        showlines=true,                                                 % show blank lines at end of code
    9678    tabsize=5,
    … …  
    11193
    11294\begin{abstract}
    113 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@.
    114 C restrict an enumeration type to the integral type @signed int@, which \CC support , meaning enumeration names bind to integer constants.
    115 \CFA extends C enumerations to allow all basic and custom types for the enumeration type, like other modern programming languages.
    116 Furthermore, \CFA adds other useful features for enumerations to support better software-engineering practices and simplify program development.
     95An enumeration is a type that defines a list of named constant values in C (and other languages).
     96C and \CC use an integral type as the underlying representation of an enumeration.
     97\CFA extends C enumerations to allow all basic and custom types for the inner representation.
    11798\end{abstract}
    11899
    119 \section{Background}
    120 
    121 Naming values is a common practice in mathematics and engineering, e.g., $\pi$, $\tau$ (2$\pi$), $\phi$ (golden ratio), MHz (1E6), etc.
    122 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).
    123 Many programming languages capture this important capability through a mechanism called an \newterm{enumeration}.
    124 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.
    125 Note, all enumeration names must be unique but different names can represent the same value (eight note, quaver), which are synonyms.
    126 
    127 Specifically, an enumerated type is a type whose values are restricted to a fixed set of named constants.
    128 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.
    129 However, the values for basic types are not named, other than the programming-language supplied constants.
    130 
    131 
    132100\section{C-Style Enum}
    133101
    134 The C-Style enumeration has the following syntax and semantics.
     102\CFA supports the C-Style enumeration using the same syntax and semantics.
    135103\begin{lstlisting}[label=lst:weekday]
    136 enum Weekday { Monday, Tuesday, Wednesday, Thursday@ = 10@, Friday, Saturday, Sunday };
    137                 $\(\uparrow\)$                                                                        $\(\uparrow\)$
    138     ${\rm \newterm{enumeration name}}$                                          ${\rm \newterm{enumerator names}}
    139 \end{lstlisting}
    140 Here, the enumeration type @Weekday@ defines the ordered \newterm{enumerator}s @Monday@, @Tuesday@, @Wednesday@, @Thursday@, @Friday@, @Saturday@ and @Sunday@.
     104enum Weekday { Monday, Tuesday, Wednesday, Thursday=10, Friday, Saturday, Sunday };
     105                $\(\uparrow\)$                                                                      $\(\uparrow\)$
     106    ${\rm \newterm{enumeration name}}$                                        ${\rm \newterm{enumerator names}}
     107\end{lstlisting}
     108The example defines an enumeration type @Weekday@ with ordered enumerators @Monday@, @Tuesday@, @Wednesday@, @Thursday@, @Friday@, @Saturday@ and @Sunday@.
    141109The successor of @Tuesday@ is @Monday@ and the predecessor of @Tuesday@ is @Wednesday@.
    142 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.
    143 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.
     110A 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.
     111For 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.
    144112
    145113There are 3 attributes for an enumeration: \newterm{position}, \newterm{label}, and \newterm{value}:
    … …  
    150118\it position            & 0                     & 1                     & 2                             & 3                             & 4                     & 5                     & 6                     \\
    151119\it label                       & Monday        & Tuesday       & Wednesday             & Thursday              & Friday        & Saturday      & Sunday        \\
    152 \it value                       & 0                     & 1                     & 2                             & {\color{red}10}& 11           & 12            & 13
     120\it value                       & 0                     & 1                     & 2                             & 10                    & 11            & 12            & 13
    153121\end{tabular}
    154122\end{cquote}
    155123
    156124The enumerators of an enumeration are unscoped, i.e., enumerators declared inside of an @enum@ are visible in the enclosing scope of the @enum@ type.
    157 Furthermore, there is an implicit bidirectional conversion between an enumeration and integral types.
    158125\begin{lstlisting}[label=lst:enum_scope]
    159126{
    160         enum Weekday { ... };                           $\C{// enumerators implicitly projected into local scope}$
     127        enum Weekday { ... };   // enumerators implicitly projected into local scope
    161128        Weekday weekday = Monday;
    162         weekday = Friday;                                       $\C{// weekday == 11}$
    163         int i = Sunday                                          $\C{// i == 13}$
    164         weekday = 10000;                                        $\C{// undefined behaviour}$
     129        weekday = Friday;
     130        int i = Sunday  // i == 13
    165131}
    166 int j = Wednesday;                                              $\C{// ERROR! Wednesday is not declared in this scope}$
     132int j = Wednesday; // ERROR! Wednesday is not declared in this scope
    167133\end{lstlisting}
    168134
    169135\section{\CFA-Style Enum}
    170136
    171 \CFA supports C-Style enumeration using the same syntax and semantics for backwards compatibility.
    172 \CFA also extends C-Style enumeration by adding a number of new features that bring enumerations inline with other modern programming languages.
    173 
    174 \subsection{Enumerator Typing}
    175 
    176 \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.
     137A \CFA enumeration is parameterized by a type specifying each enumerator's type.
     138\CFA allows any object type for the enumerators, and values assigned to enumerators must be from the declared type.
    177139\begin{lstlisting}[label=lst:color]
    178 enum( @char@ ) Currency { Dollar = '$\textdollar$', Euro = '$\texteuro$', Pound = '$\textsterling$'  };
    179 enum( @double@ ) Planet { Venus = 4.87, Earth = 5.97, Mars = 0.642  }; // mass
    180 enum( @char *@ ) Colour { Red = "red", Green = "green", Blue = "blue"  };
    181 enum( @Currency@ ) Europe { Euro = '$\texteuro$', Pound = '$\textsterling$' }; // intersection
    182 \end{lstlisting}
    183 The types of the enumerators are @char@, @double@, and @char *@ and each enumerator is initialized with corresponding type values.
    184 % Only types with a defined ordering can be automatically initialized (see Section~\ref{s:AutoInitializable}).
     140enum Colour( @char *@ ) { Red = "R", Green = "G", Blue = "B"  };
     141\end{lstlisting}
     142The type of @Colour@ is @char *@ and each enumerator is initialized with a C string.
     143Only types with a defined ordering can be automatically initialized (see Section~\ref{s:AutoInitializable}).
    185144
    186145% An instance of \CFA-enum (denoted as @<enum_instance>@) is a label for the defined enum name.
    … …  
    192151A \CFA-enum can be scoped, meaning the enumerator constants are not projected into the enclosing scope.
    193152\begin{lstlisting}
    194 enum Weekday @!@ { /* as above */ };
    195 enum Colour( char * ) @!@ { /* as above */ };
     153enum Colour( char * ) @!@ { ... };
    196154\end{lstlisting}
    197155where the @'!'@ implies the enumerators are \emph{not} projected.
    … …  
    200158% $$<qualified\_expression> := <enum\_type>.<enumerator>$$
    201159\begin{lstlisting}
    202 Weekday weekday = @Weekday.Monday@;             $\C{// qualification}$
    203 Colour colour = @Colour.@Red;
     160Colour colour = @Colour.@Red;   // qualification
    204161colour = @Colour.@Blue;
    205162\end{lstlisting}
    206163
    207 \subsection{Enumeration Pseudo-functions}
    208 
    209 Pseudo-functions are function-like operators that do not result in any run-time computations, i.e., like @sizeof@.
    210 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..
    211 
    212 \subsubsection{Enumerator Attributes}
    213 The attributes of an enumerator are accessed by pseudo-functions @position@, @value@, and @label@.
     164\section{Enumeration Pseudo-functions}
     165Pseudo-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.
     166
     167\subsection{Enumerator Attributes}
     168The attributes of an enumerator are accessed by pseudo-functions @position@, @value@, and @label@.
    214169\begin{lstlisting}
    215 int green_pos = @position@( Colour.Green );     $\C{// 1}$
    216 char * green_value = @value@( Colour.Green ); $\C{// "G"}$
    217 char * green_label = @label@( Colour.Green ); $\C{// "Green"}$
    218 \end{lstlisting}
    219 
    220 Enumeration Greek may have more or less enumerators than Letter, but the enumerator values must be from Letter.
    221 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.
    222 
    223 \subsubsection{\lstinline{enumerate()}}
    224 
     170int green_pos = @position@( Colour.Green );     // 1
     171char * green_value = @value@( Colour.Green ); / "G"
     172char * green_label = @label@( Colour.Green ); // "Green"
     173\end{lstlisting}
     174
     175\subsection{enumerate()}
    225176\begin{lstlisting}[label=lst:c_switch]
    226177enum(int) C_ENUM { First, Second, Third = First, Fourth };
    227 int v( C_ENUM e ) {
    228         switch( e ) {
    229                 case First: return 0; break;
    230                 case Second: return 1; break;
    231                 // case Third: return 2; break;
    232                 // case Fourth: return 3; break;
    233         };
    234 };
    235 \end{lstlisting}
    236 In the @C_ENUM@ example, @Third@ is an alias of @First@ and @Fourth@ is an alias of @Second@.
    237 Programmers cannot make case branches for @Third@ and @Fourth@ because the switch statement matches cases by the enumerator's value.
    238 Case @First@ and @Third@, or @Second@ and @Fourth@, has duplicate case values.
    239 
    240 @enumerate()@ is a pseudo-function that makes the switch statement match by an enumerator instead.
     178int v(C_ENUM e) {
     179    switch( e ) {
     180        case First: return 0; break;
     181        case Second: return 1; break;
     182        // case Thrid: return 2; break;
     183        // case Fourth: return 3; break;
     184    };
     185};
     186\end{lstlisting}
     187In 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.
     188
     189@enumerate()@ is a pseudo-function that makes the switch statement match by an enumerator instead.
    241190\begin{lstlisting}[label=lst:c_switch_enumerate]
    242191enum(double) C_ENUM { First, Second, Third = First, Fourth };
    243 C_ENUM variable_a = First, variable_b = Second, variable_c = Third, variable_d = Fourth;
    244 int v(C_ENUM e) {
    245         switch( enumeratate( e ) ) {
    246                 case First: return e; break;
    247                 case Second: return value( e ); break;
    248                 case Third: return label( e ); break;
    249                 case Fourth: return position( e ); break;
    250         };
     192C_ENUM variable_a = First, variable_b = Second, variable_c = Thrid, variable_d = Fourth;
     193int v(C_ENUM e) { 
     194    switch( enumeratate( e ) ) {
     195        case First: return e; break;
     196        case Second: return value( e ); break;
     197        case Thrid: return label( e ); break;
     198        case Fourth: return position( e ); break;
     199    };
    251200};
    252201p(variable_a); // 0
    … …  
    256205\end{lstlisting}
    257206
    258 
    259207\section{Enumeration Storage}
    260 
    261208
    262209\subsection{Enumeration Variable}
    … …  
    281228>>> label( Colour, 1) -> char *
    282229\end{lstlisting}
    283 @T@ represents the type declared in the \CFA enumeration defined and @char *@ in the example.
     230@T@ represents the type declared in the \CFA enumeration defined and @char *@ in the example. 
    284231These generated functions are $Companion Functions$, they take an $companion$ object and the position as parameters.
    285232
    286 
    287233\subsection{Enumeration Data}
    288 
    289234\begin{lstlisting}[label=lst:enumeration_backing_data]
    290235enum(T) E { ... };
    291236// backing data
    292 T * E_values;
    293 char ** E_labels;
    294 \end{lstlisting}
    295 Storing values and labels as arrays can sometimes help support enumeration features.
    296 However, the data structures are the overhead for the programs. We want to reduce the memory usage for enumeration support by:
     237T* E_values;
     238char** E_labels;
     239\end{lstlisting}
     240Storing 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:
    297241\begin{itemize}
    298         \item Only generates the data array if necessary
    299         \item The compilation units share the data structures.
    300         No extra overhead if the data structures are requested multiple times.
     242    \item Only generates the data array if necessary
     243    \item The compilation units share the data structures. No extra overhead if the data structures are requested multiple times.
    301244\end{itemize}
    302245
    303246
     247\
    304248\section{Unification}
    305249
    306250\subsection{Enumeration as Value}
    307251\label{section:enumeration_as_value}
    308 An \CFA enumeration with base type T can be used seamlessly as T, without explicitly calling the pseudo-function value.
     252An \CFA enumeration with base type T can be used seamlessly as T, without explicitly calling the pseudo-function value. 
    309253\begin{lstlisting}[label=lst:implicit_conversion]
    310254char * green_value = Colour.Green; // "G"
    311 // Is equivalent to
     255// Is equivalent to 
    312256// char * green_value = value( Color.Green ); "G"
    313257\end{lstlisting}
    314258
    315 
    316259\subsection{Unification Distance}
    317 
    318260\begin{lstlisting}[label=lst:unification_distance_example]
    319261T_2 Foo(T1);
    … …  
    323265@path(A, B)@ is a compiler concept that returns one of the following:
    324266\begin{itemize}
    325         \item Zero or 0, if and only if $A == B$.
    326         \item Safe, if B can be used as A without losing its precision, or B is a subtype of A.
    327         \item Unsafe, if B loses its precision when used as A, or A is a subtype of B.
    328         \item Infinite, if B cannot be used as A. A is not a subtype of B and B is not a subtype of A.
     267    \item Zero or 0, if and only if $A == B$.
     268    \item Safe, if B can be used as A without losing its precision, or B is a subtype of A.
     269    \item Unsafe, if B loses its precision when used as A, or A is a subtype of B.
     270    \item Infinite, if B cannot be used as A. A is not a subtype of B and B is not a subtype of A.
    329271\end{itemize}
    330272
    … …  
    336278The arithmetic of distance is the following:
    337279\begin{itemize}
    338         \item $Zero + v= v$, for some value v.
    339         \item $Safe * k <  Unsafe$, for finite k.
    340         \item $Unsafe * k < Infinite$, for finite k.
    341         \item $Infinite + v = Infinite$, for some value v.
     280    \item $Zero + v= v$, for some value v.
     281    \item $Safe * k <  Unsafe$, for finite k.
     282    \item $Unsafe * k < Infinite$, for finite k.
     283    \item $Infinite + v = Infinite$, for some value v.
    342284\end{itemize}
    343285
    … …  
    346288
    347289\subsection{Variable Overloading and Parameter Unification}
    348 
    349290\CFA allows variable names to be overloaded. It is possible to overload a variable that has type T and an enumeration with type T.
    350291\begin{lstlisting}[label=lst:variable_overload]
    … …  
    363304Similarly, functions can be overloaded with different signatures. \CFA picks the correct function entity based on the distance between parameter types and the arguments.
    364305\begin{lstlisting}[label=lst:function_overload]
    365 Colour green = Colour.Green;
     306Colour green = Colour.Green; 
    366307void foo(Colour c) { sout | "It is an enum"; } // First foo
    367308void foo(char * s) { sout | "It is a string"; } // Second foo
    … …  
    385326% The @EnumInstType@ is convertible to other types.
    386327% A \CFA enumeration expression is implicitly \emph{overloaded} with its three different attributes: value, position, and label.
    387 % The \CFA compilers need to resolve an @EnumInstType@ as one of its attributes based on the current context.
     328% The \CFA compilers need to resolve an @EnumInstType@ as one of its attributes based on the current context. 
    388329
    389330% \begin{lstlisting}[caption={Null Context}, label=lst:null_context]
    … …  
    438379% }
    439380% \end{lstlisting}
    440 % % The conversion can work backward: in restrictive cases, attributes of can be implicitly converted back to the EnumInstType.
     381% % The conversion can work backward: in restrictive cases, attributes of can be implicitly converted back to the EnumInstType. 
    441382% Backward conversion:
    442383% \begin{lstlisting}[caption={Unification Functions}, label=lst:unification_func_call]
    … …  
    448389% \begin{lstlisting}[caption={Unification Functions}, label=lst:unification_func_call]
    449390% {
    450 %       Unification( EnumInstType<Colour>, int ) >>> label
     391%    Unification( EnumInstType<Colour>, int ) >>> label
    451392% }
    452393% \end{lstlisting}
    453394% @int@ can be unified with the label of Colour.
    454 % @5@ is a constant expression $\Rightarrow$ Compiler knows the value during the compilation $\Rightarrow$ turns it into
     395% @5@ is a constant expression $\Rightarrow$ Compiler knows the value during the compilation $\Rightarrow$ turns it into 
    455396% \begin{lstlisting}
    456397% {
    457 %       enum Colour colour = Colour.Green;
     398%    enum Colour colour = Colour.Green;
    458399% }
    459400% \end{lstlisting}
    … …  
    470411% {
    471412%       enum T (int) { ... } // Declaration
    472 %       enum T t = 1;
     413%       enum T t = 1; 
    473414% }
    474415% \end{lstlisting}
    … …  
    482423% return the FIRST enumeration constant that has the value 1, by searching through the values array
    483424% \end{enumerate}
    484 % 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
     425% 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 
    485426
    486427% \subsection{Casting}
    … …  
    490431% (int) Foo.A;
    491432% \end{lstlisting}
    492 % The \CFA-compiler unifies @EnumInstType<int>@ 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<int>@ can be replaced by the compile with a constant expression 10, and optionally discard the cast expression.
     433% The \CFA-compiler unifies @EnumInstType<int>@ 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<int>@ can be replaced by the compile with a constant expression 10, and optionally discard the cast expression. 
    493434
    494435% \subsection{Value Conversion}
    … …  
    504445% int j = value( Foo, a )
    505446% \end{lstlisting}
    506 % Similarly, the generated code for the third line is
     447% Similarly, the generated code for the third line is 
    507448% \begin{lstlisting}
    508449% char * j = label( Foo, a )
    … …  
    514455
    515456\subsection{C Enumeration Rule}
    516 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$.
     457A 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$. 
    517458
    518459\subsection{Auto Initializable}
    … …  
    537478Odd ?++( Odd t1 ) { return Odd( t1.i + 2); };
    538479\end{lstlisting}
    539 When the type of an enumeration is @AutoInitializable@, implicit initialization is available.
     480When the type of an enumeration is @AutoInitializable@, implicit initialization is available. 
    540481\begin{lstlisting}[label=lst:sample_auto_Initializable_usage]
    541482enum AutoInitUsage(Odd) {
    … …  
    573514@alph@ is the iterating enumeration object, which returns the value of an @Alphabet@ in this context according to the precedence rule.
    574515
    575 \textbullet\ \CFA offers a shorthand for iterating all enumeration constants:
     516\textbullet\ \CFA offers a shorthand for iterating all enumeration constants: 
    576517\begin{lstlisting}[label=lst:range_functions]
    577518for ( Alphabet alph ) { sout | alph; }
    … …  
    626567>>> 10 11 12 13 14 15 16 17 18
    627568\end{lstlisting}
    628 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
     569The 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 
    629570\begin{lstlisting}[label=lst:range_function_stepping_converted]
    630571for ( typeof( value(Sequence.A) ) s=value( Sequence.A ); s <= Sequence.D; s+=1  ) { sout | alph; }
    … …  
    638579for ( char * alph; Alphabet )
    639580\end{lstlisting}
    640 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.
     581This 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.
    641582If the value can also be resolved as the @char *@, you might iterate the labels explicitly with the array iteration.
    642583\begin{lstlisting}[label=lst:range_functions_label_implicit]
    … …  
    650591% \begin{lstlisting}
    651592% enum T( int, char * ) {
    652 %        a=42, b="Hello World"
     593%    a=42, b="Hello World"
    653594% };
    654595% \end{lstlisting}
    655 % The enum T declares two different types: int and char *. The enumerators of T hold values of one of the declared types.
     596% The enum T declares two different types: int and char *. The enumerators of T hold values of one of the declared types. 
    656597
    657598\subsection{Enumeration Inheritance}
    … …  
    661602enum /* inferred */ Name2 { inline Name, Sue = "Sue", Tom = "Tom" };
    662603\end{lstlisting}
    663 \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.
     604\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. 
    664605\begin{lstlisting}[label=lst:EnumInline]
    665606Name Fred;
    … …  
    669610If enumeration A declares @inline B@ in its enumeration body, enumeration A is the "inlining enum" and enumeration B is the "inlined enum".
    670611
    671 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.
     612An 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. 
    672613\begin{lstlisting}[label=lst:EnumInline]
    673614enum /* inferred */ Name2 { inline Name, Sue = "Sue", Tom = "Tom" };
    … …  
    684625\begin{lstlisting}[label=lst:static_attr]
    685626enum( char * ) Colour {
    686         Red = "red", Blue = "blue", Green = "green"
    687 };
    688 \end{lstlisting}
    689 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.
     627    Red = "red", Blue = "blue", Green = "green" 
     628};
     629\end{lstlisting}
     630An 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. 
    690631
    691632\subsection{Runtime Attribute Expression and Weak Referenced Data}
    … …  
    697638An 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.
    698639
    699 \CFA stores the variables and labels in @const@ arrays to provide runtime lookup for enumeration information.
     640\CFA stores the variables and labels in const arrays to provide runtime lookup for enumeration information.
    700641
    701642\begin{lstlisting}[label=lst:attr_array]
    … …  
    710651\end{lstlisting}
    711652
    712 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.
     653To 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. 
    713654
    714655\subsection{Enum Prelude}
    … …  
    716657\begin{lstlisting}[label=lst:enum_func_dec]
    717658forall( T ) {
    718         unsigned position( unsigned );
    719         T value( unsigned );
    720         char * label( unsigned );
     659    unsigned position( unsigned );
     660    T value( unsigned );
     661    char * label( unsigned );
    721662}
    722663\end{lstlisting}
    … …  
    729670forall(T)
    730671class EnumDecl {
    731         T* values;
    732         char** label;
     672    T* values;
     673    char** label;
    733674};
    734675\end{lstlisting}
    … …  
    738679\begin{lstlisting}[label=lst:EnumInstType]
    739680class EnumInstType {
    740         EnumDecl enumDecl;
    741         int position;
     681    EnumDecl enumDecl;
     682    int position;
    742683};
    743684\end{lstlisting}
    … …  
    759700% struct Companion {
    760701%       const T * const values;
    761 %                const char * label;
     702%        const char * label;
    762703%       int length;
    763704% };
    … …  
    765706% \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@.
    766707
    767 % The companion object is singleton across the compilation (investigation).
     708% The companion object is singleton across the compilation (investigation). 
    768709
    769710% \CFA generates the definition of companion functions.
    … …  
    786727\begin{lstlisting}[label=lst:companion_trait]
    787728forall(T1) {
    788         trait Companion(otype T2<otype T1>) {
    789                 T1 value((otype T2<otype T1> const &);
    790                 int position(otype T2<otype T1> const &);
    791                 char * label(otype T2<otype T1> const &);
    792         }
     729    trait Companion(otype T2<otype T1>) {
     730        T1 value((otype T2<otype T1> const &);
     731        int position(otype T2<otype T1> const &);
     732        char * label(otype T2<otype T1> const &);
     733    }
    793734}
    794735\end{lstlisting}
    … …  
    802743\begin{lstlisting}
    803744enum(int) Weekday {
    804         Monday=10, Tuesday, ...
     745    Monday=10, Tuesday, ...
    805746};
    806747
    … …  
    817758\subsection{User Define Enumeration Functions}
    818759
    819 Companion objects make extending features for \CFA enumeration easy.
     760Companion objects make extending features for \CFA enumeration easy. 
    820761\begin{lstlisting}[label=lst:companion_user_definition]
    821 char * charastic_string( Companion o, int position ) {
    822         return sprintf( "Label: %s; Value: %s", label( o, position ), value( o, position) );
     762char * charastic_string( Companion o, int position ) { 
     763        return sprintf( "Label: %s; Value: %s", label( o, position ), value( o, position) ); 
    823764}
    824765printf( charactic_string ( Color, 1 ) );
    … …  
    835776Similarly, the user can work with the enumeration type itself: (see section ref...)
    836777\begin{lstlisting}[ label=lst:companion_user_definition]
    837 void print_enumerators ( Companion o ) {
     778void print_enumerators ( Companion o ) { 
    838779        for ( c : Companion o ) {
    839780                sout | label (c) | value( c ) ;
    840         }
     781        } 
    841782}
    842783print_enumerators( Colour );
    … …  
    854795It 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.
    855796If the declared type is not @AutoInitializable@, \CFA rejects the enumeration definition.
    856 Otherwise, it attempts to initialize enumerators with the enumeration initialization pattern. (a reference to a future initialization pattern section)
     797Otherwise, it attempts to initialize enumerators with the enumeration initialization pattern. (a reference to a future initialization pattern section) 
    857798
    858799\begin{lstlisting}[label=lst:init]
    … …  
    862803T ?+?( T & lhs, T & rhs ) { ... };
    863804
    864 enum (T) Sample {
    865         Zero: 0 /* zero_t */,
     805enum (T) Sample { 
     806        Zero: 0 /* zero_t */, 
    866807        One: Zero + 1 /* ?+?( Zero, one_t ) */ , ...
    867808};
    … …  
    885826\subsection{Qualified Expression}
    886827
    887 \CFA uses qualified expression to address the scoping of \CFA-enumeration.
     828\CFA uses qualified expression to address the scoping of \CFA-enumeration. 
    888829\begin{lstlisting}[label=lst:qualified_expression]
    889830aggregation_name.field;
    … …  
    896837
    897838\subsection{\lstinline{with} Clause/Statement}
    898 
    899839Instead of qualifying an enumeration expression every time, the @with@ can be used to expose enumerators to the current scope, making them directly accessible.
    900840\begin{lstlisting}[label=lst:declaration]
    … …  
    902842enum Animal( int ) { Cat=10, Dog=20 };
    903843with ( Color, Animal ) {
    904         char * red_string = Red; // value( Color.Red )
    905         int cat = Cat; // value( Animal.Cat )
     844    char * red_string = Red; // value( Color.Red )
     845    int cat = Cat; // value( Animal.Cat )
    906846}
    907847\end{lstlisting}
    … …  
    911851enum RGB( int ) { Red=0, Green=1, Blue=2 };
    912852with ( Color, RGB ) {
    913         // int red = Red;
     853    // int red = Red;
    914854}
    915855\end{lstlisting}
    … …  
    925865The declaration \CFA-enumeration variable has the same syntax as the C-enumeration. Internally, such a variable will be represented as an EnumInstType.
    926866
    927 \section{Related Work}
    928 
    929 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.
    930 There are a large set of overlapping features for all the languages, but each language has its own unique restrictions and extensions.
    931 
    932 \subsection{Pascal}
    933 
    934 \subsection{Ada}
    935 
    936 \subsection{\Csharp}
    937 
    938 \subsection{\CC}
    939 
    940 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;
    941 hence, the values in a \CC enumeration can only be its enumerators.
    942 
    943 \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@.
    944 \CC{20} supports unscoped access with a \lstinline[language=c++]{using enum} declaration.
    945 
    946 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.
    947 The underlying integral type can be explicitly specified:
    948 \begin{lstlisting}[language=c++,{moredelim=**[is][\color{red}]{@}{@}}]
    949 enum class RGB : @long@ { Red, Green, Blue };
    950 enum class rgb : @char@ { Red = 'r', Green = 'g', Blue = 'b' };
    951 enum class srgb : @signed char@ { Red = -1, Green = 0, Blue = 1 };
    952 \end{lstlisting}
    953 
    954 \subsection{Go}
    955 
    956 \subsection{Java}
    957 
    958 \subsection{Modula-3}
    959 
    960 \subsection{Rust}
    961 
    962 \subsection{Swift}
    963 
    964 \subsection{Python}
    965 
    966 \subsection{Algebraic Data Type}
    967867
    968868\end{document}

  • doc/uC++toCFA/Makefile

    r32490deb rc75b30a  
    88BibTeX = BIBINPUTS=../bibliography: && export BIBINPUTS && bibtex
    99
    10 MAKEFLAGS = --no-print-directory # --silent
     10MAKEFLAGS = --no-print-directory --silent #
    1111VPATH = ${Build} ${Figures}
    1212

  • doc/uC++toCFA/uC++toCFA.tex

    r32490deb rc75b30a  
    1111%% Created On       : Wed Apr  6 14:53:29 2016
    1212%% Last Modified By : Peter A. Buhr
    13 %% Last Modified On : Thu Jan 11 14:46:14 2024
    14 %% Update Count     : 5942
     13%% Last Modified On : Sun Oct 15 23:09:58 2023
     14%% Update Count     : 5926
    1515%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    1616
    … …  
    428428\begin{uC++}
    429429struct S {
    430         int i = 0;  // cheat, implicit default constructor
     430        int i = 0;
    431431        int setter( int j ) { int t = i; i = j; return t; }
    432432        int getter() { return i; }
    … …  
    434434
    435435S s;
    436 @s.@setter( 3 );  // object-oriented calls
     436@s.@setter( 3 );  // object-oriented call
    437437int k = @s.@getter();
    438438\end{uC++}
    … …  
    442442        int i;
    443443};
    444 void ?{}( S & s ) { s.i = 0; } // explicit default constructor
     444void ?{}( S & s ) { s.i = 0; }
    445445int setter( @S & s,@ int j ) @with(s)@ { int t = i; i = j; return t; }
    446446int getter( @S & s@ ) @with(s)@ { return i; }
    447447S s;
    448 setter( @s,@ 3 );  // normal routine calls
     448setter( @s,@ 3 );  // normal routine call
    449449int k = getter( @s@ );
    450450\end{cfa}
    … …  
    458458\begin{tabular}{l|l}
    459459\begin{uC++}
    460 
    461460struct S {
    462461        int i;
    463         S( int i ) { S::i = i; cout << "ctor " << S::i << endl; }
    464         ~S() { S::i = i; cout << "dtor " << S::i << endl; }
    465 };
     462        S( int i ) { S::i = i; cout << S::i << endl; }
     463};
     464@uNoCtor<S>@ s[10];
    466465int main() {
    467         enum { N = 5 };
    468         @uNoCtor<S>@ s[N];   // no constructor calls
    469         for ( int i = 0; i < N; i += 1 ) @s[i].ctor( i )@;
    470         for ( int i = 0; i < N; i += 1 ) cout << s[i]@->@i << endl;
    471 }
    472 \end{uC++}
    473 &
    474 \begin{cfa}
    475 #include @<raii.hfa>@          // uninit
     466        for ( int i = 0; i < 10; i += 1 ) {
     467                s[i].ctor( i );
     468        }
     469        for ( int i = 0; i < 10; i += 1 ) {
     470                cout << s[i]@->@i << endl;
     471        }
     472}
     473\end{uC++}
     474&
     475\begin{cfa}
    476476struct S {
    477477        int i;
    478478};
    479 void ?{}( S & s, int i ) { s.i = i; sout | "ctor" | s.i; }
    480 void ^?{}( S & s ) { sout | "dtor" | s.i; }
     479void ?{}( S & s, int i ) { s.i = i; sout | s.i; }
     480S s[10] @$\color{red}@$= {}@;
    481481int main() {
    482         enum { N = 5 };
    483         @uninit(S)@ s[N];   // no constructor calls
    484         for ( i; N ) @s[i]{ i }@;
    485         for ( i; N ) sout | s[i]@.@i;
     482        for ( i; 10 ) {
     483                ?{}( s[i], i );  // call constructor
     484        }
     485        for ( i; 10 ) {
     486                sout | s[i]@.@i; // dot not arrow
     487        }
    486488}
    487489\end{cfa}

  • doc/user/user.tex

    r32490deb rc75b30a  
    1111%% Created On       : Wed Apr  6 14:53:29 2016
    1212%% Last Modified By : Peter A. Buhr
    13 %% Last Modified On : Tue Jan 30 09:02:41 2024
    14 %% Update Count     : 6046
     13%% Last Modified On : Sun Jan 14 17:27:41 2024
     14%% Update Count     : 5764
    1515%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    1616
    … …  
    4646%\input{common}                                                                                 % common CFA document macros
    4747\usepackage[dvips,plainpages=false,pdfpagelabels,pdfpagemode=UseNone,colorlinks=true,pagebackref=true,linkcolor=blue,citecolor=blue,urlcolor=blue,pagebackref=true,breaklinks=true]{hyperref}
    48 \urlstyle{sf}
    4948\usepackage{breakurl}
    5049
    … …  
    164163
    165164\Index*[C++]{\CC{}}~\cite{c++:v1} had a similar goal 30 years ago, allowing object-oriented programming to be incrementally added to C.
    166 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.
     165However, \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.
    167166In contrast, \CFA has 30 years of hindsight and a clean starting point.
    168167
    … …  
    201200\end{center}
    202201While \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}.
    203 In general, \CFA programs are 10\% to 30\% shorter than their equivalent C/\CC counterparts.
    204202
    205203
    … …  
    220218Even with all its problems, C continues to be popular because it allows writing software at virtually any level in a computer system without restriction.
    221219For system programming, where direct access to hardware, storage management, and real-time issues are a requirement, C is the only language of choice.
    222 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.
     220The 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.
    223221The top 4 rankings over the past 35 years are:
    224222\begin{center}
    … …  
    240238however, it largely extended the C language, and did not address many of C's existing problems.\footnote{%
    241239Two 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.}
    242 \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.
     240\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.
    243241\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.
    244242These 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.
    … …  
    265263% extending the C type system with parametric polymorphism and overloading, as opposed to the \Index*[C++]{\CC{}} approach of object-oriented extensions.
    266264\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}.
    267 However, at that time, there was little interest in extending C, so work did not continue.
     265However, at that time, there was little interesting in extending C, so work did not continue.
    268266As 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.
    269267
    … …  
    274272\CFA is designed to integrate directly with existing C programs and libraries.
    275273The 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.
    276 This feature allows \CFA programmers to take advantage of the existing panoply of C libraries to access thousands of software features.
     274This feature allows \CFA programmers to take advantage of the existing panoply of C libraries to access thousands of external software features.
    277275Language developers often state that adequate \Index{library support} takes more work than designing and implementing the language itself.
    278276Fortunately, \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.
    … …  
    322320However, it is necessary to differentiate between C and \CFA code because of name \Index{overload}ing, as for \CC.
    323321For 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©.
    324 Whereas, \CFA wraps these routines into one overloaded name ©abs©:
    325 \begin{cfa}
    326 unsigned char ®abs®( signed char );                             §\C[3.5in]{// no C equivalent}§
    327 extern "C" { int ®abs®( int ); }                                §\C{// C abs}§
    328 unsigned long int ®abs®( long int );                    §\C{// C labs}§
    329 unsigned long long int ®abs®( long long int );  §\C{// C llabs}§
    330 float ®abs®( float );                                                   §\C{// C fabsf}§
    331 double ®abs®( double );                                                 §\C{// C fabs}§
    332 long double ®abs®( long double );                               §\C{// C fabsl}§
    333 float _Complex ®abs®( float _Complex );                 §\C{// C cabsf}§
    334 double _Complex ®abs®( double _Complex );               §\C{// C cabs}§
    335 long double _Complex ®abs®( long double _Complex ); §\C{// C cabsl}\CRT§
     322Whereas, \CFA wraps each of these routines into one overloaded name ©abs©:
     323\begin{cfa}
     324char ®abs®( char );
     325extern "C" { int ®abs®( int ); } §\C{// use default C routine for int}§
     326long int ®abs®( long int );
     327long long int ®abs®( long long int );
     328float ®abs®( float );
     329double ®abs®( double );
     330long double ®abs®( long double );
     331float _Complex ®abs®( float _Complex );
     332double _Complex ®abs®( double _Complex );
     333long double _Complex ®abs®( long double _Complex );
    336334\end{cfa}
    337335The 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).
    … …  
    341339
    342340This example illustrates a core idea in \CFA: \emph{the \Index{power of a name}}.
    343 The name ``©abs©'' evokes the notion of absolute value and many mathematical types provide the notion of absolute value.
    344 Hence, knowing the name ©abs© is sufficient to apply it to any applicable type.
     341The name ``©abs©'' evokes the notion of absolute value, and many mathematical types provide the notion of absolute value.
     342Hence, knowing the name ©abs© is sufficient to apply it to any type where it is applicable.
    345343The time savings and safety of using one name uniformly versus $N$ unique names cannot be underestimated.
    346344
    347345
    348346\section{\CFA Compilation}
    349 
    350 \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.
    351 Hence, \CFA is like the C preprocessor modifying a program and sending it on to another step for further transformation.
    352 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.
    353347
    354348The command ©cfa© is used to compile a \CFA program and is based on the \Index{GNU} \Indexc{gcc} command, \eg:
    … …  
    450444which conditionally includes the correct header file, if the program is compiled using \Indexc{gcc} or \Indexc{cfa}.
    451445
    452 The \CFA \Index{transpiler} has multiple internal steps.
    453 The following flags control how the \CFA transpiler works, the stages run, and printing within a stage.
     446The \CFA translator has multiple steps.
     447The following flags control how the translator works, the stages run, and printing within a stage.
    454448The majority of these flags are used by \CFA developers, but some are occasionally useful to programmers.
    455 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:
     449Each 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:
    456450\begin{lstlisting}[language=sh]
    457451cfa §test§.cfa -CFA -XCFA -p # print translated code without printing the standard prelude
    … …  
    464458\begin{description}[topsep=5pt,itemsep=0pt,parsep=0pt]
    465459\item
    466 \Indexc{-c}\index{transpiler option!-c@{©-c©}}, \Indexc{--colors}\index{transpiler option!--colors@{©--colors©}} \, diagnostic color: ©never©, ©always©, \lstinline[deletekeywords=auto]{auto}
    467 \item
    468 \Indexc{-g}\index{transpiler option!-g@{©-g©}}, \Indexc{--gdb}\index{transpiler option!--gdb@{©--gdb©}} \, wait for gdb to attach
    469 \item
    470 \Indexc{-h}\index{transpiler option!-h@{©-h©}}, \Indexc{--help}\index{transpiler option!--help@{©--help©}} \, print transpiler help message
    471 \item
    472 \Indexc{-i}\index{transpiler option!-i@{©-i©}}, \Indexc{--invariant}\index{transpiler option!--invariant@{©--invariant©}} \, invariant checking during AST passes
    473 \item
    474 \Indexc{-l}\index{transpiler option!-l@{©-l©}}, \Indexc{--libcfa}\index{transpiler option!--libcfa@{©--libcfa©}} \, generate ©libcfa.c©
    475 \item
    476 \Indexc{-L}\index{transpiler option!-L@{©-L©}}, \Indexc{--linemarks}\index{transpiler option!--linemarks@{©--linemarks©}} \, generate line marks
    477 \item
    478 \Indexc{-m}\index{transpiler option!-m@{©-m©}}, \Indexc{--no-main}\index{transpiler option!--no-main@{©--no-main©}} \, do not replace main
    479 \item
    480 \Indexc{-N}\index{transpiler option!-N@{©-N©}}, \Indexc{--no-linemarks}\index{transpiler option!--no-linemarks@{©--no-linemarks©}} \, do not generate line marks
    481 \item
    482 \Indexc{-n}\index{transpiler option!-n@{©-n©}}, \Indexc{--no-prelude}\index{transpiler option!--no-prelude@{©--no-prelude©}} \, do not read prelude
    483 \item
    484 \Indexc{-p}\index{transpiler option!-p@{©-p©}}, \Indexc{--prototypes}\index{transpiler option!--prototypes@{©--prototypes©}} \, do not generate prelude prototypes $\Rightarrow$ prelude not printed
    485 \item
    486 \Indexc{-d}\index{transpiler option!-d@{©-d©}}, \Indexc{--deterministic-out}\index{transpiler option!--deterministic-out@{©--deterministic-out©}} \, only print deterministic output
    487 \item
    488 \Indexc{-P}\index{transpiler option!-P@{©-P©}}, \Indexc{--print}\index{transpiler option!--print@{©--print©}} \, one of:
     460\Indexc{-c}\index{translator option!-c@{©-c©}}, \Indexc{--colors}\index{translator option!--colors@{©--colors©}} \, diagnostic color: ©never©, ©always©, \lstinline[deletekeywords=auto]{auto}
     461\item
     462\Indexc{-g}\index{translator option!-g@{©-g©}}, \Indexc{--gdb}\index{translator option!--gdb@{©--gdb©}} \, wait for gdb to attach
     463\item
     464\Indexc{-h}\index{translator option!-h@{©-h©}}, \Indexc{--help}\index{translator option!--help@{©--help©}} \, print translator help message
     465\item
     466\Indexc{-i}\index{translator option!-i@{©-i©}}, \Indexc{--invariant}\index{translator option!--invariant@{©--invariant©}} \, invariant checking during AST passes
     467\item
     468\Indexc{-l}\index{translator option!-l@{©-l©}}, \Indexc{--libcfa}\index{translator option!--libcfa@{©--libcfa©}} \, generate ©libcfa.c©
     469\item
     470\Indexc{-L}\index{translator option!-L@{©-L©}}, \Indexc{--linemarks}\index{translator option!--linemarks@{©--linemarks©}} \, generate line marks
     471\item
     472\Indexc{-m}\index{translator option!-m@{©-m©}}, \Indexc{--no-main}\index{translator option!--no-main@{©--no-main©}} \, do not replace main
     473\item
     474\Indexc{-N}\index{translator option!-N@{©-N©}}, \Indexc{--no-linemarks}\index{translator option!--no-linemarks@{©--no-linemarks©}} \, do not generate line marks
     475\item
     476\Indexc{-n}\index{translator option!-n@{©-n©}}, \Indexc{--no-prelude}\index{translator option!--no-prelude@{©--no-prelude©}} \, do not read prelude
     477\item
     478\Indexc{-p}\index{translator option!-p@{©-p©}}, \Indexc{--prototypes}\index{translator option!--prototypes@{©--prototypes©}} \, do not generate prelude prototypes $\Rightarrow$ prelude not printed
     479\item
     480\Indexc{-d}\index{translator option!-d@{©-d©}}, \Indexc{--deterministic-out}\index{translator option!--deterministic-out@{©--deterministic-out©}} \, only print deterministic output
     481\item
     482\Indexc{-P}\index{translator option!-P@{©-P©}}, \Indexc{--print}\index{translator option!--print@{©--print©}} \, one of:
    489483\begin{description}[topsep=0pt,itemsep=0pt,parsep=0pt]
    490484\item
    491 \Indexc{ascodegen}\index{transpiler option!-P@{©-P©}!©ascodegen©}\index{transpiler option!--print@{©-print©}!©ascodegen©} \, print AST as codegen rather than AST
    492 \item
    493 \Indexc{asterr}\index{transpiler option!-P@{©-P©}!©asterr©}\index{transpiler option!--print@{©-print©}!©asterr©} \, print AST on error
    494 \item
    495 \Indexc{declstats}\index{transpiler option!-P@{©-P©}!©declstats©}\index{transpiler option!--print@{©-print©}!©declstats©} \, print code property statistics
    496 \item
    497 \Indexc{parse}\index{transpiler option!-P@{©-P©}!©parse©}\index{transpiler option!--print@{©-print©}!©parse©} \, print yacc (parsing) debug information
    498 \item
    499 \Indexc{pretty}\index{transpiler option!-P@{©-P©}!©pretty©}\index{transpiler option!--print@{©-print©}!©pretty©} \, prettyprint for ©ascodegen© flag
    500 \item
    501 \Indexc{rproto}\index{transpiler option!-P@{©-P©}!©rproto©}\index{transpiler option!--print@{©-print©}!©rproto©} \, resolver-proto instance
    502 \item
    503 \Indexc{rsteps}\index{transpiler option!-P@{©-P©}!©rsteps©}\index{transpiler option!--print@{©-print©}!©rsteps©} \, print resolver steps
    504 \item
    505 \Indexc{ast}\index{transpiler option!-P@{©-P©}!©ast©}\index{transpiler option!--print@{©-print©}!©ast©} \, print AST after parsing
    506 \item
    507 \Indexc{excpdecl}\index{transpiler option!-P@{©-P©}!©excpdecl©}\index{transpiler option!--print@{©-print©}!©excpdecl©} \, print AST after translating exception decls
    508 \item
    509 \Indexc{symevt}\index{transpiler option!-P@{©-P©}!©symevt©}\index{transpiler option!--print@{©-print©}!©symevt©} \, print AST after symbol table events
    510 \item
    511 \Indexc{expralt}\index{transpiler option!-P@{©-P©}!©expralt©}\index{transpiler option!--print@{©-print©}!©expralt©} \, print AST after expressions alternatives
    512 \item
    513 \Indexc{valdecl}\index{transpiler option!-P@{©-P©}!©valdecl©}\index{transpiler option!--print@{©-print©}!©valdecl©} \, print AST after declaration validation pass
    514 \item
    515 \Indexc{bresolver}\index{transpiler option!-P@{©-P©}!©bresolver©}\index{transpiler option!--print@{©-print©}!©bresolver©} \, print AST before resolver step
    516 \item
    517 \Indexc{expranly}\index{transpiler option!-P@{©-P©}!©expranly©}\index{transpiler option!--print@{©-print©}!©expranly©} \, print AST after expression analysis
    518 \item
    519 \Indexc{ctordtor}\index{transpiler option!-P@{©-P©}!©ctordtor©}\index{transpiler option!--print@{©-print©}!©ctordtor©} \, print AST after ctor/dtor are replaced
    520 \item
    521 \Indexc{tuple}\index{transpiler option!-P@{©-P©}!©tuple©}\index{transpiler option!--print@{©-print©}!©tuple©} \, print AST after tuple expansion
    522 \item
    523 \Indexc{instgen}\index{transpiler option!-P@{©-P©}!©instgen©}\index{transpiler option!--print@{©-print©}!©instgen©} \, print AST after instantiate generics
    524 \item
    525 \Indexc{bbox}\index{transpiler option!-P@{©-P©}!©bbox©}\index{transpiler option!--print@{©-print©}!©bbox©} \, print AST before box pass
    526 \item
    527 \Indexc{bcodegen}\index{transpiler option!-P@{©-P©}!©bcodegen©}\index{transpiler option!--print@{©-print©}!©bcodegen©} \, print AST before code generation
     485\Indexc{ascodegen}\index{translator option!-P@{©-P©}!©ascodegen©}\index{translator option!--print@{©-print©}!©ascodegen©} \, print AST as codegen rather than AST
     486\item
     487\Indexc{asterr}\index{translator option!-P@{©-P©}!©asterr©}\index{translator option!--print@{©-print©}!©asterr©} \, print AST on error
     488\item
     489\Indexc{declstats}\index{translator option!-P@{©-P©}!©declstats©}\index{translator option!--print@{©-print©}!©declstats©} \, print code property statistics
     490\item
     491\Indexc{parse}\index{translator option!-P@{©-P©}!©parse©}\index{translator option!--print@{©-print©}!©parse©} \, print yacc (parsing) debug information
     492\item
     493\Indexc{pretty}\index{translator option!-P@{©-P©}!©pretty©}\index{translator option!--print@{©-print©}!©pretty©} \, prettyprint for ©ascodegen© flag
     494\item
     495\Indexc{rproto}\index{translator option!-P@{©-P©}!©rproto©}\index{translator option!--print@{©-print©}!©rproto©} \, resolver-proto instance
     496\item
     497\Indexc{rsteps}\index{translator option!-P@{©-P©}!©rsteps©}\index{translator option!--print@{©-print©}!©rsteps©} \, print resolver steps
     498\item
     499\Indexc{ast}\index{translator option!-P@{©-P©}!©ast©}\index{translator option!--print@{©-print©}!©ast©} \, print AST after parsing
     500\item
     501\Indexc{excpdecl}\index{translator option!-P@{©-P©}!©excpdecl©}\index{translator option!--print@{©-print©}!©excpdecl©} \, print AST after translating exception decls
     502\item
     503\Indexc{symevt}\index{translator option!-P@{©-P©}!©symevt©}\index{translator option!--print@{©-print©}!©symevt©} \, print AST after symbol table events
     504\item
     505\Indexc{expralt}\index{translator option!-P@{©-P©}!©expralt©}\index{translator option!--print@{©-print©}!©expralt©} \, print AST after expressions alternatives
     506\item
     507\Indexc{valdecl}\index{translator option!-P@{©-P©}!©valdecl©}\index{translator option!--print@{©-print©}!©valdecl©} \, print AST after declaration validation pass
     508\item
     509\Indexc{bresolver}\index{translator option!-P@{©-P©}!©bresolver©}\index{translator option!--print@{©-print©}!©bresolver©} \, print AST before resolver step
     510\item
     511\Indexc{expranly}\index{translator option!-P@{©-P©}!©expranly©}\index{translator option!--print@{©-print©}!©expranly©} \, print AST after expression analysis
     512\item
     513\Indexc{ctordtor}\index{translator option!-P@{©-P©}!©ctordtor©}\index{translator option!--print@{©-print©}!©ctordtor©} \, print AST after ctor/dtor are replaced
     514\item
     515\Indexc{tuple}\index{translator option!-P@{©-P©}!©tuple©}\index{translator option!--print@{©-print©}!©tuple©} \, print AST after tuple expansion
     516\item
     517\Indexc{instgen}\index{translator option!-P@{©-P©}!©instgen©}\index{translator option!--print@{©-print©}!©instgen©} \, print AST after instantiate generics
     518\item
     519\Indexc{bbox}\index{translator option!-P@{©-P©}!©bbox©}\index{translator option!--print@{©-print©}!©bbox©} \, print AST before box pass
     520\item
     521\Indexc{bcodegen}\index{translator option!-P@{©-P©}!©bcodegen©}\index{translator option!--print@{©-print©}!©bcodegen©} \, print AST before code generation
    528522\end{description}
    529523\item
    530524\Indexc{--prelude-dir} <directory> \, prelude directory for debug/nodebug
    531525\item
    532 \Indexc{-S}\index{transpiler option!-S@{©-S©}!©counters,heap,time,all,none©}, \Indexc{--statistics}\index{transpiler option!--statistics@{©--statistics©}!©counters,heap,time,all,none©} <option-list> \, enable profiling information: ©counters©, ©heap©, ©time©, ©all©, ©none©
    533 \item
    534 \Indexc{-t}\index{transpiler option!-t@{©-t©}}, \Indexc{--tree}\index{transpiler option!--tree@{©--tree©}} build in tree
     526\Indexc{-S}\index{translator option!-S@{©-S©}!©counters,heap,time,all,none©}, \Indexc{--statistics}\index{translator option!--statistics@{©--statistics©}!©counters,heap,time,all,none©} <option-list> \, enable profiling information: ©counters©, ©heap©, ©time©, ©all©, ©none©
     527\item
     528\Indexc{-t}\index{translator option!-t@{©-t©}}, \Indexc{--tree}\index{translator option!--tree@{©--tree©}} build in tree
    535529\end{description}
    536530
    … …  
    546540\end{cfa}
    547541Existing 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.
    548 \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©.
    549 Several common C header-files with keyword clashes are fixed in the standard \CFA header-library, so there is largely a seamless programming-experience.
     542\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©.
     543Several common C header-files with keyword clashes are fixed in the standard \CFA header-library, so there is a seamless programming-experience.
    550544
    551545\begin{figure}
    … …  
    597591the type suffixes ©U©, ©L©, \etc may start with an underscore ©1_U©, ©1_ll© or ©1.0E10_f©.
    598592\end{enumerate}
    599 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).
     593It 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).
    600594This extension is backwards compatible, matches with the use of underscore in variable names, and appears in \Index*{Ada} and \Index*{Java} 8.
    601595\CC uses the single quote (©'©) as a separator, restricted within a sequence of digits, \eg ©0xaa©©'©©ff©, ©3.141©©'©©592E1©©'©©1©.
    602 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©).
    603596
    604597
    605598\section{Exponentiation Operator}
    606599
    607 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.
     600C, \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.
    608601\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$.
    609602The 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©.
    610603
    611604There are exponentiation operators for integral and floating types, including the builtin \Index{complex} types.
    612 Integral exponentiation\index{exponentiation!unsigned integral} is performed with repeated multiplication ($O(\log y)$ or shifting if the exponent is 2).
     605Integral exponentiation\index{exponentiation!unsigned integral} is performed with repeated multiplication ($O(\log y)$ multiplies or shifting if the exponent is 2).
    613606Overflow for a large exponent or negative exponent returns zero.
    614607Floating exponentiation\index{exponentiation!floating} is performed using \Index{logarithm}s\index{exponentiation!logarithm}, so the exponent cannot be negative.
    … …  
    627620T ?®\®?( T ep, unsigned long int y );
    628621\end{cfa}
    629 A user type ©T© must define one (©1©), and multiplication (©*©) \see{\VRef{s:Operator}}.
     622A user type ©T© must define multiplication, one (©1©), and ©*©.
    630623
    631624
    … …  
    638631\subsection{\texorpdfstring{\LstKeywordStyle{if} / \LstKeywordStyle{while} Statement}{if / while Statement}}
    639632
    640 The \Indexc{if} and \Indexc{while} expressions are extended with declarations, similar to the \Indexc{for} declaration expression.\footnote{
     633The \Indexc{if}/\Indexc{while} expression allows declarations, similar to \Indexc{for} declaration expression.\footnote{
    641634Declarations in the \Indexc{do}-©while© condition are not useful because they appear after the loop body.}
    642635\begin{cfa}
    … …  
    660653\label{s:caseClause}
    661654
    662 C restricts the \Indexc{case} clause in a \Indexc{switch} statement to a single value.
     655C restricts a \Indexc{case} clause in \Indexc{switch} statement to a single value.
    663656For multiple ©case© clauses prefixing a statement within the ©switch© statement, it is necessary to have multiple ©case© clauses rather than multiple values.
    664657Requiring a ©case© clause for each value is not in the spirit of brevity normally associated with C.
    … …  
    695688\end{tabular}
    696689\end{cquote}
    697 In addition, subranges are allowed to specify a contiguous set of case values.
     690In addition, subranges are allowed to specify case values.
    698691\begin{cquote}
    699692\begin{tabular}{@{}l@{\hspace{3em}}l@{\hspace{2em}}l@{\hspace{2em}}l@{}}
    … …  
    808801\end{cfa}
    809802This situation is better handled by a list of case values \see{\VRef{s:caseClause}}.
    810 
    811 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.
    812 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.
     803While 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.
     804Hence, 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.
    813805
    814806\item
    … …  
    827819The technical problem results from the inability to ensure declaration and initialization of variables when blocks are not entered at the beginning.
    828820There are few arguments for this kind of control flow, and therefore, there is a strong impetus to eliminate it.
     821
    829822This C idiom is known as ``\Index*{Duff's device}''~\cite{Duff83}, from this example:
    830823\begin{cfa}
    … …  
    1003996with the current \Indexc{switch}/\Indexc{choose} statement.
    1004997
    1005 
    1006 \subsection{Loop Control}
    1007 
    1008 Looping a fixed number of times, possibly with a loop index, occurs frequently.
    1009 \CFA condenses simply looping to facilitate coding speed and safety~\see{examples in \VRef[Figure]{f:LoopControlExamples}}.
    1010 
    1011 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).
    1012 \begin{cfa}
    1013 while ( ®/* empty */®  )                                §\C{// while ( true )}§
    1014 for ( ®/* empty */®  )                                  §\C{// for ( ; true; )}§
    1015 do ... while ( ®/* empty */®  )                 §\C{// do ... while ( true )}§
    1016 \end{cfa}
    1017 
    1018998\begin{figure}
    1019999\begin{tabular}{@{}l@{\hspace{50pt}}|l@{}}
    … …  
    10231003while () { sout | "empty"; break; }
    10241004do { sout | "empty"; break; } while ();
    1025 for () { sout | "empty"; break; }                                                       §\C{sout | nl | nlOff;}§
     1005for () { sout | "empty"; break; }                                                       §\C[3in]{sout | nl | nlOff;}§
    10261006
    10271007for ( 0 ) { sout | "A"; } sout | "zero";                                        §\C{sout | nl;}§
    … …  
    10651045for ( i; 5 : j; @ -~ -5 ~ 2 : k; 1.5 ~ @ ) { sout | i | j | k; } §\C{sout | nl;}§
    10661046for ( i; 5 : j; @ -~ -5 ~ 2 : k; 1.5 ~ @ ) { sout | i | j | k; } §\C{sout | nl;}§
    1067 for ( i; 5 : k; 1.5 ~ @ : j; @ -~ -5 ~ 2 ) { sout | i | j | k; } §\C{sout | nl;}§
     1047for ( i; 5 : k; 1.5 ~ @ : j; @ -~ -5 ~ 2 ) { sout | i | j | k; } §\C{sout | nl;}\CRT§
    10681048\end{cfa}
    10691049&
    … …  
    11281108% for ( T i ; 3~9 ) => for ( T i = 3 ; i < 9; i += 1 ) // using 1
    11291109
    1130 The ©for© control is extended with 4 new loop-control operators, which are not overloadable:
     1110
     1111\subsection{Loop Control}
     1112
     1113Looping a fixed number of times, possibly with a loop index, occurs frequently.
     1114\CFA condenses simply looping to facilitate coding speed and safety~\see{examples in \VRef[Figure]{f:LoopControlExamples}}.
     1115
     1116The \Indexc{for}, \Indexc{while}, and \Indexc{do} loop-control allow an empty conditional, which implies a comparison value of ©1© (true).
     1117\begin{cfa}
     1118while ( ®/* empty */®  )                                §\C{// while ( true )}§
     1119for ( ®/* empty */®  )                                  §\C{// for ( ; true; )}§
     1120do ... while ( ®/* empty */®  )                 §\C{// do ... while ( true )}§
     1121\end{cfa}
     1122
     1123The ©for© control has 4 new loop-control operators that are not overloadable:
    11311124\begin{description}[itemsep=0pt,parsep=0pt]
    11321125\item
    … …  
    12021195Similarly, the high value cannot be elided is an anonymous loop index (©1 ~ @©), as there is no index to stop the loop.
    12031196\item
    1204 ©:© means add another index.
     1197©:© means low another index.
    12051198\begin{cfa}
    12061199for ( i; 5 ®:® j; 2 ~ 12 ~ 3 )                  §\C{// for ( typeof(i) i = 1, j = 2; i < 5 \&\& j < 12; i += 1, j += 3 )}§
    … …  
    12191212\subsection{\texorpdfstring{Labelled \LstKeywordStyle{continue} / \LstKeywordStyle{break} Statement}{Labelled continue / break Statement}}
    12201213
    1221 C \Indexc{continue} and \Indexc{break} statements are restricted to one level of nesting for a particular control structure.
     1214C \Indexc{continue} and \Indexc{break} statements, for altering control flow, are restricted to one level of nesting for a particular control structure.
    12221215This restriction forces programmers to use \Indexc{goto} to achieve the equivalent control-flow for more than one level of nesting.
    12231216To 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.
    … …  
    13091302Furthermore, 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.
    13101303With ©goto©, the label is at the end of the control structure, which fails to convey this important clue early enough to the reader.
    1311 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.
     1304Finally, using an explicit target for the transfer instead of an implicit target allows new constructs to be added or removed without affecting existing constructs.
    13121305Otherwise, the implicit targets of the current ©continue© and ©break©, \ie the closest enclosing loop or ©switch©, change as certain constructs are added or removed.
    13131306
    … …  
    13801373\begin{cfa}
    13811374Person p
    1382 ®p.®name ...;  ®p.®address ...;  ®p.®sex ...; §\C{// access containing fields}§
     1375®p.®name; ®p.®address; ®p.®sex;                 §\C{// access containing fields}§
    13831376\end{cfa}
    13841377which extends to multiple levels of qualification for nested aggregates and multiple aggregates.
    13851378\begin{cfa}
    13861379struct Ticket { ... } t;
    1387 ®p.name®.first ...;  ®p.address®.street ...; §\C{// access nested fields}§
    1388 ®t.®departure ...;  ®t.®cost ...;               §\C{// access multiple aggregate}§
     1380®p.name®.first; ®p.address®.street;             §\C{// access nested fields}§
     1381®t.®departure; ®t.®cost;                                §\C{// access multiple aggregate}§
    13891382\end{cfa}
    13901383Repeated aggregate qualification is tedious and makes code difficult to read.
    … …  
    15651558
    15661559
    1567 \subsection{Non-local Exception}
     1560\section{Non-local Exception}
    15681561
    15691562\begin{cfa}
    … …  
    23542347\subsection{Implicit String Conversions}
    23552348
    2356 The types ©char©, ©char *©, ©int©, ©double©, ©_Complex©, including different signness and sizes, implicitly convert to type ©string©.
    2357 \VRef[Figure]{f:ImplicitConversionsString} shows examples of implicit conversions between C strings, integral, floating-point and complex types to ©string©.
    2358 A conversions can be explicitly specified:
    2359 \begin{cfa}
    2360 s = string( "abc" );                            §\C{// converts char * to string}§
    2361 s = string( 5 );                                        §\C{// converts int to string}§
    2362 s = string( 5.5 );                                      §\C{// converts double to string}§
    2363 \end{cfa}
    2364 All conversions from ©string© to ©char *©, attempt to be safe:
    2365 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.
    2366 As well, a string is always null terminates, implying a minimum size of 1 character.
    2367 \begin{cquote}
    2368 \begin{tabular}{@{}l@{\hspace{1.75in}}|@{\hspace{15pt}}l@{}}
    2369 \begin{cfa}
    2370 string s = "abcde";
    2371 char cs[3];
    2372 strncpy( cs, s, sizeof(cs) );           §\C{sout | cs;}§
    2373 char * cp = s;                                          §\C{sout | cp;}§
    2374 delete( cp );
    2375 cp = s + ' ' + s;                                       §\C{sout | cp;}§
    2376 delete( cp );
    2377 \end{cfa}
    2378 &
    2379 \begin{cfa}
    2380 
    2381 
    2382 ab
    2383 abcde
    2384 
    2385 abcde abcde
    2386 
    2387 \end{cfa}
    2388 \end{tabular}
    2389 \end{cquote}
     2349The types ©char©, ©char *©, ©int©, ©double©, ©_Complex©, including signness and different sizes, implicitly convert to type ©string©.
     2350\VRef[Figure]{f:ImplicitStringConversions} shows examples of implicit conversion between C strings, integral, floating-point and complex types to ©string©
     2351The implicit conversions can be specified explicitly, as in:
     2352\begin{cfa}
     2353s = string( "abc" );            // converts char * to string
     2354s = string( 5 );                        // converts int to string
     2355s = string( 5.5 );                      // converts double to string
     2356\end{cfa}
     2357Conversions from ©string© to ©char *© are supported but with restrictions.
     2358Explicit 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:
     2359\begin{cfa}
     2360string x = "abc";
     2361char *p = x;                            // convert from string to char *
     2362...
     2363delete p;                                       // free storage created for p
     2364\end{cfa}
    23902365
    23912366\begin{figure}
    … …  
    23952370        string s;
    23962371        // conversion of char and char * to string
    2397         s = 'x';                                                §\C{sout | s;}§
    2398         s = "abc";                                              §\C{sout | s;}§
     2372        s = 'x';                                                §\CD{sout | s;}§
     2373        s = "abc";                                              §\CD{sout | s;}§
    23992374        char cs[5] = "abc";
    2400         s = cs;                                                 §\C{sout | s;}§
     2375        s = cs;                                                 §\CD{sout | s;}§
    24012376        // conversion of integral, floating-point, and complex to string
    2402         s = 45hh;                                               §\C{sout | s;}§
    2403         s = 45h;                                                §\C{sout | s;}§
    2404         s = -(ssize_t)MAX - 1;                  §\C{sout | s;}§
    2405         s = (size_t)MAX;                                §\C{sout | s;}§
    2406         s = 5.5;                                                §\C{sout | s;}§
    2407         s = 5.5L;                                               §\C{sout | s;}§
    2408         s = 5.5+3.4i;                                   §\C{sout | s;}§
    2409         s = 5.5L+3.4Li;                                 §\C{sout | s;}§
     2377        s = 45hh;                                               §\CD{sout | s;}§
     2378        s = 45h;                                                §\CD{sout | s;}§
     2379        s = -(ssize_t)MAX - 1;                  §\CD{sout | s;}§
     2380        s = (size_t)MAX;                                §\CD{sout | s;}§
     2381        s = 5.5;                                                §\CD{sout | s;}§
     2382        s = 5.5L;                                               §\CD{sout | s;}§
     2383        s = 5.5+3.4i;                                   §\CD{sout | s;}§
     2384        s = 5.5L+3.4Li;                                 §\CD{sout | s;}§
     2385        // safe conversion from string to char *
     2386        strncpy( cs, s, sizeof(cs) );   §\CD{sout | cs;}§
     2387        char * cp = s;                                  §\CD{sout | cp; // ownership}§
     2388        delete( cp );
     2389        cp = s + ' ' + s;                               §\CD{sout | cp; // ownership}§
     2390        delete( cp );
    24102391\end{cfa}
    24112392&
    … …  
    242724085.5+3.4i
    242824095.5+3.4i
     2410
     24115.5+
     24125.5+3.4i
     2413
     24145.5+3.4i 5.5+3.4i
     2415
    24292416\end{cfa}
    24302417\end{tabular}
    2431 \caption{Implicit Conversions to String}
    2432 \label{f:ImplicitConversionsString}
     2418\caption{Implicit String Conversions}
     2419\label{f:ImplicitStringConversions}
    24332420\end{figure}
    24342421
    24352422
    2436 \subsection{Size (length)}
    2437 
    2438 The ©size© operation returns the length of a string.
    2439 \begin{cfa}
    2440 i = size( "" );                                         §\C{// i is assigned 0}§
    2441 i = size( "abc" );                                      §\C{// i is assigned 3}§
    2442 i = size( peter );                                      §\C{// i is assigned 5}§
    2443 \end{cfa}
    2444 
    2445 
    24462423\subsection{Comparison Operators}
    24472424
    2448 The binary \Index{relational operator}s, ©<©, ©<=©, ©>©, ©>=©, and \Index{equality operator}s, ©==©, ©!=©, compare strings using lexicographical ordering, where longer strings are greater than shorter strings.
     2425The binary relational and equality operators ©<©, ©<=©, ©>©, ©>=©, ©==©, ©!=© compare ©string© using lexicographical ordering, where longer strings are greater than shorter strings.
    24492426
    24502427
    24512428\subsection{Concatenation}
    24522429
    2453 The binary operators \Indexc{+} and \Indexc{+=} concatenate two strings, creating the sum of the strings.
    2454 \begin{cfa}
    2455 s = peter + ' ' + digit;                        §\C{// s is assigned "PETER 0123456789"}§
    2456 s += peter;                                                     §\C{// s is assigned "PETER 0123456789PETER"}§
    2457 \end{cfa}
     2430The binary operator ©+© concatenates two strings.
     2431\begin{cfa}
     2432s = peter + digit;                                      §\C{// s is assigned "PETER0123456789"}§
     2433s += peter;                                                     §\C{// s is assigned "PETER0123456789PETER"}§
     2434\end{cfa}
     2435There is also an assignment form ©+=©.
    24582436
    24592437
    24602438\subsection{Repetition}
    24612439
    2462 The binary operators \Indexc{*} and \Indexc{*=} repeat a string $N$ times.
    2463 If $N = 0$, a zero length string, ©""© is returned.
    2464 \begin{cfa}
    2465 s = 'x' * 3;                            §\C{// s is assigned "PETER PETER PETER "}§
    2466 s = (peter + ' ') * 3;                          §\C{// s is assigned "PETER PETER PETER "}§
     2440The binary operator \Indexc{*} returns a string that is the string repeated ©n© times.
     2441If ©n = 0©, a zero length string, ©""© is returned.
     2442\begin{cfa}
     2443s = (peter + ' ') * 3;                          §\C{// s is assigned "PETER PETER PETER"}§
     2444\end{cfa}
     2445There is also an assignment form ©*=©.
     2446
     2447
     2448\subsection{Length}
     2449
     2450The ©length© operation
     2451\begin{cfa}
     2452int length()
     2453\end{cfa}
     2454returns the length of a string variable.
     2455\begin{cfa}
     2456i = peter.length();                     §\C{// i is assigned the value 5}§
    24672457\end{cfa}
    24682458
    24692459
    24702460\subsection{Substring}
    2471 The substring operation returns a subset of the string starting at a position in the string and traversing a length.
    2472 \begin{cfa}
    2473 s = peter( 2, 3 );                                      §\C{// s is assigned "ETE"}§
    2474 s = peter( 4, -3 );                                     §\C{// s is assigned "ETE", length is opposite direction}§
    2475 s = peter( 2, 8 );                                      §\C{// s is assigned "ETER", length is clipped to 4}§
    2476 s = peter( 0, -1 );                                     §\C{// s is assigned "", beyond string so clipped to null}§
    2477 s = peter(-1, -1 );                                     §\C{// s is assigned "R", start and length are negative}§
    2478 \end{cfa}
     2461The substring operation:
     2462\begin{cfa}
     2463string operator () (int start, int lnth);
     2464\end{cfa}
     2465performs a substring operation that returns the string starting at a specified position (©start©) in the current string, and having the specified length (©lnth©).
    24792466A negative starting position is a specification from the right end of the string.
    24802467A negative length means that characters are selected in the opposite (right to left) direction from the starting position.
    24812468If the substring request extends beyond the beginning or end of the string, it is clipped (shortened) to the bounds of the string.
    24822469If the substring request is completely outside of the original string, a null string located at the end of the original string is returned.
     2470\begin{cfa}
     2471s = peter( 2, 3 );                      §\C{// s is assigned "ETE"}§
     2472s = peter( 4, -3 );                     §\C{// s is assigned "ETE", length is opposite direction}§
     2473s = peter( 2, 8 );                      §\C{// s is assigned "ETER", length is clipped to 4}§
     2474s = peter( 0, -1 );                     §\C{// s is assigned "", beyond string so clipped to null}§
     2475s = peter(-1, -1 );                     §\C{// s is assigned "R", start and length are negative}§
     2476\end{cfa}
    24832477The substring operation can also appear on the left hand side of the assignment operator.
    24842478The substring is replaced by the value on the right hand side of the assignment.
    24852479The 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.
    2486 \begin{cfa}
    2487 digit( 3, 3 ) = "";                             §\C{// digit is assigned "0156789"}§
    2488 digit( 4, 3 ) = "xyz";                          §\C{// digit is assigned "015xyz9"}§
    2489 digit( 7, 0 ) = "***";                          §\C{// digit is assigned "015xyz***9"}§
    2490 digit(-4, 3 ) = "$$$";                          §\C{// digit is assigned "015xyz\$\$\$9"}§
     2480\begin{cfa}[mathescape=false]
     2481digit( 3, 3 ) = "";             §\C{// digit is assigned "0156789"}§
     2482digit( 4, 3 ) = "xyz";          §\C{// digit is assigned "015xyz9"}§
     2483digit( 7, 0 ) = "***";          §\C{// digit is assigned "015xyz***9"}§
     2484digit(-4, 3 ) = "$$$";          §\C{// digit is assigned "015xyz\$\$\$9"}§
    24912485\end{cfa}
    24922486A substring is treated as a pointer into the base (substringed) string rather than creating a copy of the subtext.
    … …  
    25072501// e is a substring result passed by value
    25082502void test(string &x, string &a, string &b, string &c, string &d, string e) {
    2509                                                                         §\C{//   x                                a               b               c               d               e}§
    2510         a( 1, 2 ) = "aaa";                              §\C{// aaaxxxxxxxxxxx   aaax    axx             xxxxx   xxxxx   xxxxx}§
    2511         b( 2, 12 ) = "bbb";                             §\C{// aaabbbxxxxxxxxx  aaab    abbb    bbxxx   xxxxx   xxxxx}§
    2512         c( 4, 5 ) = "ccc";                              §\C{// aaabbbxcccxxxxxx aaab    abbb    bbxccc  ccxxx   xxxxx}§
    2513         c = "yyy";                                              §\C{// aaabyyyxxxxxx    aaab    abyy    yyy             xxxxx   xxxxx}§
    2514         d( 1, 3 ) = "ddd";                              §\C{// aaabyyyxdddxx    aaab    abyy    yyy             dddxx   xxxxx}§
    2515         e( 1, 3 ) = "eee";                              §\C{// aaabyyyxdddxx    aaab    abyy    yyy             dddxx   eeexx}§
    2516         x = e;                                                  §\C{// eeexx                    eeex    exx             x                               eeexx}§
     2503                                                        §\C{//   x                                a               b               c               d               e}§
     2504        a( 1, 2 ) = "aaa";              §\C{// aaaxxxxxxxxxxx   aaax    axx             xxxxx   xxxxx   xxxxx}§
     2505        b( 2, 12 ) = "bbb";             §\C{// aaabbbxxxxxxxxx  aaab    abbb    bbxxx   xxxxx   xxxxx}§
     2506        c( 4, 5 ) = "ccc";              §\C{// aaabbbxcccxxxxxx aaab    abbb    bbxccc  ccxxx   xxxxx}§
     2507        c = "yyy";                              §\C{// aaabyyyxxxxxx    aaab    abyy    yyy             xxxxx   xxxxx}§
     2508        d( 1, 3 ) = "ddd";              §\C{// aaabyyyxdddxx    aaab    abyy    yyy             dddxx   xxxxx}§
     2509        e( 1, 3 ) = "eee";              §\C{// aaabyyyxdddxx    aaab    abyy    yyy             dddxx   eeexx}§
     2510        x = e;                                  §\C{// eeexx                    eeex    exx             x                               eeexx}§
    25172511}
    25182512\end{cfa}
    … …  
    25242518For example:
    25252519\begin{cfa}
    2526 s = peter( 2 );                                         §\C{// s is assigned "ETER"}§
    2527 peter( 2 ) = "IPER";                            §\C{// peter is assigned "PIPER"}§
     2520s = peter( 2 );                         §\C{// s is assigned "ETER"}§
     2521peter( 2 ) = "IPER";            §\C{// peter is assigned "PIPER"}§
    25282522\end{cfa}
    25292523It is also possible to substring using a string as the index for selecting the substring portion of the string.
    … …  
    25332527For example:
    25342528\begin{cfa}[mathescape=false]
    2535 digit( "xyz$$$" ) = "678";                      §\C{// digit is assigned "0156789"}§
    2536 digit( "234") = "***";                          §\C{// digit is assigned "0156789***"}§
    2537 \end{cfa}
     2529digit( "xyz$$$" ) = "678";      §\C{// digit is assigned "0156789"}§
     2530digit( "234") = "***";          §\C{// digit is assigned "0156789***"}§
     2531\end{cfa}
     2532%$
    25382533
    25392534
    … …  
    25752570A negative starting position is a specification from the right end of the string.
    25762571\begin{cfa}
    2577 i = peter.include( digitmask );         §\C{// i is assigned 1}§
    2578 i = peter.include( alphamask );         §\C{// i is assigned 6}§
     2572i = peter.include( digitmask ); §\C{// i is assigned 1}§
     2573i = peter.include( alphamask ); §\C{// i is assigned 6}§
    25792574\end{cfa}
    25802575
    … …  
    26272622\begin{cfa}
    26282623// remove leading blanks
    2629 s = string( "   ABC" ).trim( " " );     §\C{// s is assigned "ABC",}§
     2624s = string( "   ABC" ).trim( " " );                     §\C{// s is assigned "ABC",}§
    26302625// remove trailing blanks
    2631 s = string( "ABC   " ).trim( " ", last ); §\C{// s is assigned "ABC",}§
     2626s = string( "ABC   " ).trim( " ", last );       §\C{// s is assigned "ABC",}§
    26322627\end{cfa}
    26332628
    … …  
    26562651returns a string in which all occurrences of the ©from© string in the current string have been replaced by the ©to© string.
    26572652\begin{cfa}
    2658 s = peter.replace( "E", "XX" );         §\C{// s is assigned "PXXTXXR"}§
     2653s = peter.replace( "E", "XX" ); §\C{// s is assigned "PXXTXXR"}§
    26592654\end{cfa}
    26602655The replacement is done left-to-right.
    26612656When an instance of the ©from© string is found and changed to the ©to© string, it is NOT examined again for further replacement.
    26622657
    2663 \subsection{Returning N+1 on Failure}
     2658
     2659\section{Returning N+1 on Failure}
    26642660
    26652661Any of the string search routines can fail at some point during the search.
    … …  
    26912687
    26922688
    2693 \subsection{C Compatibility}
    2694 
    2695 To ease conversion from C to \CFA, there are companion ©string© routines for C strings.
    2696 \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.
    2697 Hence, it is possible to directly convert a block of C string operations into @string@ just by changing the
    2698 
    2699 \begin{table}
    2700 \begin{cquote}
    2701 \begin{tabular}{@{}l|l@{}}
    2702 \multicolumn{1}{c|}{©char []©}  & \multicolumn{1}{c}{©string©}  \\
    2703 \hline
    2704 ©strcpy©, ©strncpy©             & ©=©                                                                   \\
    2705 ©strcat©, ©strncat©             & ©+©                                                                   \\
    2706 ©strcmp©, ©strncmp©             & ©==©, ©!=©, ©<©, ©<=©, ©>©, ©>=©              \\
    2707 ©strlen©                                & ©size©                                                                \\
    2708 ©[]©                                    & ©[]©                                                                  \\
    2709 ©strstr©                                & ©find©                                                                \\
    2710 ©strcspn©                               & ©find_first_of©, ©find_last_of©               \\
    2711 ©strspc©                                & ©find_fist_not_of©, ©find_last_not_of©
    2712 \end{tabular}
    2713 \end{cquote}
    2714 \caption{Companion Routines for \CFA \lstinline{string} to C Strings}
    2715 \label{t:CompanionStringRoutines}
    2716 \end{table}
    2717 
    2718 For example, this block of C code can be converted to \CFA by simply changing the type of variable ©s© from ©char []© to ©string©.
    2719 \begin{cfa}
    2720         char s[32];
    2721         //string s;
    2722         strcpy( s, "abc" );                             PRINT( %s, s );
    2723         strncpy( s, "abcdef", 3 );              PRINT( %s, s );
    2724         strcat( s, "xyz" );                             PRINT( %s, s );
    2725         strncat( s, "uvwxyz", 3 );              PRINT( %s, s );
    2726         PRINT( %zd, strlen( s ) );
    2727         PRINT( %c, s[3] );
    2728         PRINT( %s, strstr( s, "yzu" ) ) ;
    2729         PRINT( %s, strstr( s, 'y' ) ) ;
    2730 \end{cfa}
    2731 However, the conversion fails with I/O because ©printf© cannot print a ©string© using format code ©%s© because \CFA strings are not null terminated.
    2732 
    2733 
    27342689\subsection{Input/Output Operators}
    27352690
    … …  
    27522707Hence, enums may be overloaded with variable, enum, and function names.
    27532708\begin{cfa}
    2754 int Foo;                                                        §\C{// type/variable separate namespaces}§
     2709int Foo;                        §\C{// type/variable separate namespaces}§
    27552710enum Foo { Bar };
    2756 enum Goo { Bar };                                       §\C{// overload Foo.Bar}§
    2757 double Bar;                                                     §\C{// overload Foo.Bar, Goo.Bar}§
     2711enum Goo { Bar };       §\C[1.75in]{// overload Foo.Bar}§
     2712double Bar;                     §\C{// overload Foo.Bar, Goo.Bar}\CRT§
    27582713\end{cfa}
    27592714An anonymous enumeration injects enums with specific values into a scope.
    … …  
    28282783The following examples illustrate the difference between the enumeration type and the type of its enums.
    28292784\begin{cfa}
    2830 Math m = PI;                                            §\C{// allowed}§
    2831 double d = PI;                                          §\C{// allowed, conversion to base type}§
    2832 m = E;                                                          §\C{// allowed}§
    2833 m = Alph;                                                       §\C{// {\color{red}disallowed}}§
    2834 m = 3.141597;                                           §\C{// {\color{red}disallowed}}§
    2835 d = m;                                                          §\C{// allowed}§
    2836 d = Alph;                                                       §\C{// {\color{red}disallowed}}§
    2837 Letter l = A;                                           §\C{// allowed}§
    2838 Greek g = Alph;                                         §\C{// allowed}§
    2839 l = Alph;                                                       §\C{// allowed, conversion to base type}§
    2840 g = A;                                                          §\C{// {\color{red}disallowed}}§
     2785Math m = PI;    §\C[1.5in]{// allowed}§
     2786double d = PI;  §\C{// allowed, conversion to base type}§
     2787m = E;                  §\C{// allowed}§
     2788m = Alph;               §\C{// {\color{red}disallowed}}§
     2789m = 3.141597;   §\C{// {\color{red}disallowed}}§
     2790d = m;                  §\C{// allowed}§
     2791d = Alph;               §\C{// {\color{red}disallowed}}§
     2792Letter l = A;   §\C{// allowed}§
     2793Greek g = Alph; §\C{// allowed}§
     2794l = Alph;               §\C{// allowed, conversion to base type}§
     2795g = A;                  §\C{// {\color{red}disallowed}}\CRT§
    28412796\end{cfa}
    28422797
    … …  
    34073362For example, consider C's \Indexc{div} function, which returns the quotient and remainder for a division of an integer value.
    34083363\begin{cfa}
    3409 typedef struct { int quot, rem; } div_t; §\C{// from include stdlib.h}§
     3364typedef struct { int quot, rem; } div_t;        §\C[7cm]{// from include stdlib.h}§
    34103365div_t div( int num, int den );
    3411 div_t qr = div( 13, 5 );                                §\C{// return quotient/remainder aggregate}§
     3366div_t qr = div( 13, 5 ); §\C{// return quotient/remainder aggregate}§
    34123367printf( "%d %d\n", qr.quot, qr.rem ); §\C{// print quotient/remainder}§
    34133368\end{cfa}
    … …  
    34203375For example, consider C's \Indexc{modf} function, which returns the integral and fractional part of a floating value.
    34213376\begin{cfa}
    3422 double modf( double x, double * i );    §\C{// from include math.h}§
     3377double modf( double x, double * i ); §\C{// from include math.h}§
    34233378double intp, frac = modf( 13.5, &intp ); §\C{// return integral and fractional components}§
    34243379printf( "%g %g\n", intp, frac ); §\C{// print integral/fractional components}§
    … …  
    34493404When 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.
    34503405\begin{cfa}
    3451 void g( int, int );                                             §\C{// 1}§
    3452 void g( double, double );                               §\C{// 2}§
    3453 g( div( 13, 5 ) );                                              §\C{// select 1}§
    3454 g( modf( 13.5 ) );                                              §\C{// select 2}§
     3406void g( int, int ); §\C{// 1}§
     3407void g( double, double ); §\C{// 2}§
     3408g( div( 13, 5 ) ); §\C{// select 1}§
     3409g( modf( 13.5 ) ); §\C{// select 2}§
    34553410\end{cfa}
    34563411In this case, there are two overloaded ©g© routines.
    … …  
    34613416The previous examples can be rewritten passing the multiple returned-values directly to the ©printf© function call.
    34623417\begin{cfa}
    3463 [ int, int ] div( int x, int y );               §\C{// from include stdlib}§
     3418[ int, int ] div( int x, int y ); §\C{// from include stdlib}§
    34643419printf( "%d %d\n", div( 13, 5 ) ); §\C{// print quotient/remainder}§
    34653420
    3466 [ double, double ] modf( double x );    §\C{// from include math}§
     3421[ double, double ] modf( double x ); §\C{// from include math}§
    34673422printf( "%g %g\n", modf( 13.5 ) ); §\C{// print integral/fractional components}§
    34683423\end{cfa}
    … …  
    34753430\begin{cfa}
    34763431int quot, rem;
    3477 [ quot, rem ] = div( 13, 5 );                   §\C{// assign multiple variables}§
    3478 printf( "%d %d\n", quot, rem );                 §\C{// print quotient/remainder}§
     3432[ quot, rem ] = div( 13, 5 ); §\C{// assign multiple variables}§
     3433printf( "%d %d\n", quot, rem ); §\C{// print quotient/remainder}\CRT§
    34793434\end{cfa}
    34803435Here, the multiple return-values are matched in much the same way as passing multiple return-values to multiple parameters in a call.
    … …  
    38933848The general syntax of a lexical list is:
    38943849\begin{cfa}
    3895 [ §\emph{exprlist}§ ]
    3896 \end{cfa}
    3897 where \LstBasicStyle{\emph{exprlist}} is a list of one or more expressions separated by commas.
     3850[ $\emph{exprlist}$ ]
     3851\end{cfa}
     3852where ©$\emph{exprlist}$© is a list of one or more expressions separated by commas.
    38983853The brackets, ©[]©, allow differentiating between lexical lists and expressions containing the C comma operator.
    38993854The following are examples of lexical lists:
    … …  
    39013856[ x, y, z ]
    39023857[ 2 ]
    3903 [ v + w, x * y, 3.14159, f() ]
     3858[ v+w, x*y, 3.14159, f() ]
    39043859\end{cfa}
    39053860Tuples 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.
    … …  
    39133868The general syntax of a tuple type is:
    39143869\begin{cfa}
    3915 [ §\emph{typelist}§ ]
    3916 \end{cfa}
    3917 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.
     3870[ $\emph{typelist}$ ]
     3871\end{cfa}
     3872where ©$\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.
    39183873Examples of tuple types include:
    39193874\begin{cfa}
    39203875[ unsigned int, char ]
    39213876[ double, double, double ]
    3922 [ * int, int * ]                                                §\C{// mix of CFA and ANSI}§
     3877[ * int, int * ] §\C{// mix of CFA and ANSI}§
    39233878[ * [ 5 ] int, * * char, * [ [ int, int ] ] (int, int) ]
    39243879\end{cfa}
    … …  
    39273882Examples of declarations using tuple types are:
    39283883\begin{cfa}
    3929 [ int, int ] x;                                                 §\C{// 2 element tuple, each element of type int}§
    3930 * [ char, char ] y;                                             §\C{// pointer to a 2 element tuple}§
     3884[ int, int ] x; §\C{// 2 element tuple, each element of type int}§
     3885* [ char, char ] y; §\C{// pointer to a 2 element tuple}§
    39313886[ [ int, int ] ] z ([ int, int ]);
    39323887\end{cfa}
    … …  
    39453900[ int, int ] w1;
    39463901[ int, int, int ] w2;
    3947 [ void ] f (int, int, int);                             §\C{// three input parameters of type int}§
    3948 [ void ] g ([ int, int, int ]);                 §\C{// 3 element tuple as input}§
     3902[ void ] f (int, int, int); §\C{// three input parameters of type int}§
     3903[ void ] g ([ int, int, int ]); §\C{3 element tuple as input}§
    39493904f( [ 1, 2, 3 ] );
    39503905f( w1, 3 );
    … …  
    40273982[ int, int, int, int ] w = [ 1, 2, 3, 4 ];
    40283983int x = 5;
    4029 [ x, w ] = [ w, x ];                                    §\C{// all four tuple coercions}§
     3984[ x, w ] = [ w, x ]; §\C{// all four tuple coercions}§
    40303985\end{cfa}
    40313986Starting on the right-hand tuple in the last assignment statement, w is opened, producing a tuple of four values;
    … …  
    40454000Mass assignment has the following form:
    40464001\begin{cfa}
    4047 [ §\emph{lvalue}§, ... , §\emph{lvalue}§ ] = §\emph{expr}§;
     4002[ $\emph{lvalue}$, ... , $\emph{lvalue}$ ] = $\emph{expr}$;
    40484003\end{cfa}
    40494004\index{lvalue}
    4050 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.
    4051 \LstBasicStyle{\emph{expr}} is any standard arithmetic expression.
     4005The 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.
     4006©$\emph{expr}$© is any standard arithmetic expression.
    40524007Clearly, the types of the entities being assigned must be type compatible with the value of the expression.
    40534008
    … …  
    40864041Multiple assignment has the following form:
    40874042\begin{cfa}
    4088 [ §\emph{lvalue}§, ... , §\emph{lvalue}§ ] = [ §\emph{expr}§, ... , §\emph{expr}§ ];
     4043[ $\emph{lvalue}$, ... , $\emph{lvalue}$ ] = [ $\emph{expr}$, ... , $\emph{expr}$ ];
    40894044\end{cfa}
    40904045\index{lvalue}
    … …  
    41174072both these examples produce indeterminate results:
    41184073\begin{cfa}
    4119 f( x++, x++ );                                                  §\C{// C routine call with side effects in arguments}§
    4120 [ v1, v2 ] = [ x++, x++ ];                              §\C{// side effects in right-hand side of multiple assignment}§
     4074f( x++, x++ ); §\C{// C routine call with side effects in arguments}§
     4075[ v1, v2 ] = [ x++, x++ ]; §\C{// side effects in right-hand side of multiple assignment}§
    41214076\end{cfa}
    41224077
    … …  
    41284083Cascade assignment has the following form:
    41294084\begin{cfa}
    4130 §\emph{tuple}§ = §\emph{tuple}§ = ... = §\emph{tuple}§;
     4085$\emph{tuple}$ = $\emph{tuple}$ = ... = $\emph{tuple}$;
    41314086\end{cfa}
    41324087and it has the same parallel semantics as for mass and multiple assignment.
    … …  
    41484103The 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.
    41494104Stream I/O can be implicitly or explicitly formatted.
    4150 Implicit formatting means \CFA selects an I/O format for values that matches a variable's type.
    4151 Explicit formatting means additional I/O information is specified to control how a value is interpreted.
    4152 
     4105Implicit formatting means \CFA selects the output or input format for values that matches the variable's type.
     4106Explicit formatting means additional information is specified to augment how an output or input of value is interpreted.
    41534107\CFA formatting incorporates ideas from C ©printf©, \CC ©stream© manipulators, and Python implicit spacing and newline.
    41544108Specifically:
    … …  
    41584112\CFA/\CC format manipulators are named, making them easier to read and remember.
    41594113\item
    4160 ©printf©/Python separate format codes from associated variables, making it difficult to match codes with variables.
     4114©printf©/Python separates format codes from associated variables, making it difficult to match codes with variables.
    41614115\CFA/\CC co-locate codes with associated variables, where \CFA has the tighter binding.
    41624116\item
    4163 Format manipulators in ©printf©/Python/\CFA have local effect, whereas \CC have global effect, except ©setw©.
    4164 Hence, it is common \CC programming practice to toggle manipulators on and then back to the default to prevent downstream side-effects.
     4117Format manipulators in \CFA have local effect, whereas \CC have global effect, except ©setw©.
     4118Hence, it is common programming practice to toggle manipulators on and then back to the default to prevent downstream side-effects.
    41654119Without this programming style, errors occur when moving prints, as manipulator effects incorrectly flow into the new location.
    41664120Furthermore, to guarantee no side-effects, manipulator values must be saved and restored across function calls.
    4167 \CC programers never do any of this.
    41684121\item
    41694122\CFA has more sophisticated implicit value spacing than Python, plus implicit newline at the end of a print.
    41704123\end{itemize}
    41714124
     4125The standard polymorphic I/Os stream are ©stdin©/©sin© (input), ©stdout©/©sout© and ©stderr©/©serr© (output) (like C++ ©cin©/©cout©/©cerr©).
     4126Polymorphic streams ©exit© and ©abort© provide implicit program termination without and with generating a stack trace and core file.
     4127Stream ©exit© implicitly returns ©EXIT_FAILURE© to the shell.
     4128\begin{cfa}
     4129®exit®   | "x (" | x | ") negative value.";   // terminate and return EXIT_FAILURE to shell
     4130®abort® | "x (" | x | ") negative value.";   // terminate and generate stack trace and core file
     4131\end{cfa}
     4132Note, \CFA stream variables ©stdin©, ©stdout©, ©stderr©, ©exit©, and ©abort© overload C variables ©stdin©, ©stdout©, ©stderr©, and functions ©exit© and ©abort©, respectively.
     4133The \CFA header file for the I/O library is \Indexc{fstream.hfa}.
     4134
    41724135
    41734136\subsection{Basic I/O}
    4174 
    4175 The standard polymorphic I/O streams are ©stdin©/©sin© (input), ©stdout©/©sout©, and ©stderr©/©serr© (output) (like C++ ©cin©/©cout©/©cerr©).
    4176 The standard I/O operator is the bit-wise (or) operator, ©'|'©, which is used to cascade multiple I/O operations.
    4177 The \CFA header file for the I/O library is \Indexc{fstream.hfa}.
    41784137
    41794138For implicit formatted output, the common case is printing a series of variables separated by whitespace.
    … …  
    421841771®, ®2®, ®3 4®, ®5®, ®6
    42194178\end{cfa}
    4220 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.
    4221 (Operators ©||© and ©&&© are not overloadable in \CFA.)
     4179Finally, \CFA uses the logical-or operator for I/O as it is the lowest-priority \emph{overloadable} operator, other than assignment.
    42224180Therefore, fewer output expressions require parenthesis.
    42234181\begin{cquote}
    … …  
    42424200\end{cquote}
    42434201There 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.
    4244 Input and output use a uniform operator, ©|©, rather than \CC's ©<<© and ©>>© input/output operators to prevent this common error in \CC:
     4202Input and output use a uniform operator, ©|©, rather than \CC's ©<<© and ©>>© input/output operators, which prevents this common error in \CC:
    42454203\begin{C++}
    42464204cin << i; // why is this generating a lot of error messages?
    42474205\end{C++}
    4248 
    4249 Streams ©exit© and ©abort© provide output with immediate program termination without and with generating a stack trace and core file.
    4250 Stream ©exit© implicitly returns ©EXIT_FAILURE© to the shell.
    4251 \begin{cfa}
    4252 ®exit®   | "x (" | x | ") negative value.";     §\C{// print, terminate, and return EXIT\_FAILURE to shell}§
    4253 ®abort® | "x (" | x | ") negative value.";      §\C{// print, terminate, and generate stack trace and core file}§
    4254 \end{cfa}
    4255 Note, \CFA stream variables ©stdin©, ©stdout©, ©stderr©, ©exit©, and ©abort© overload C variables ©stdin©, ©stdout©, ©stderr©, and functions ©exit© and ©abort©, respectively.
    42564206
    42574207For 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.
    … …  
    42964246\end{tabular}
    42974247\end{cquote}
    4298 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.
    4299 For ©bool© type, the constants are ©true© and ©false©.
    4300 For integral types, any number of digits, optionally preceded by a sign (©+© or ©-©), where a
    4301 \begin{itemize}
    4302 \item
    4303 ©1©-©9© prefix introduces a decimal value (©0©-©9©),
    4304 \item
    4305 ©0© prefix introduces an octal value (©0©-©7©), and
    4306 \item
    4307 ©0x© or ©0X© prefix introduces a hexadecimal value (©0©-©f©) with lower or upper case letters.
    4308 \end{itemize}
    4309 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.
    4310 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©.
    4311 In all cases, all whitespace characters are skipped until an appropriate value is found.
    4312 \Textbf{If an appropriate value is not found, the exception ©missing_data© is raised.}
    4313 
    4314 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..
    4315 In both cases, the string is null terminated ©'\0'©.
    4316 For the quoted string, the start and end quote characters can be any character and do not have to match \see{\ref{XXX}}.
    4317 
    4318 \VRef[Figure]{f:IOStreamFunctions} shows the I/O stream operations for interacting with files other than ©cin©, ©cout©, and ©cerr©.
    4319 \begin{itemize}[topsep=4pt,itemsep=2pt,parsep=0pt]
    4320 \item
    4321 \Indexc{fail} tests the stream error-indicator, returning nonzero if it is set.
    4322 \item
    4323 \Indexc{clear} resets the stream error-indicator.
    4324 \item
    4325 \Indexc{flush} (©ofstream© only) causes any unwritten data for a stream to be written to the file.
    4326 \item
    4327 \Indexc{eof} (©ifstream© only) tests the end-of-file indicator for the stream pointed to by stream.
    4328 Returns true if the end-of-file indicator is set, otherwise false.
    4329 \item
    4330 \Indexc{open} binds the file with ©name© to a stream accessed with ©mode© (see ©fopen©).
    4331 \item
    4332 \Indexc{close} flushes the stream and closes the file.
    4333 \item
    4334 \Indexc{write} (©ofstream© only) writes ©size© bytes to the stream.
    4335 The bytes are written lazily when an internal buffer fills.
    4336 Eager buffer writes are done with ©flush©
    4337 \item
    4338 \Indexc{read} (©ifstream© only) reads ©size© bytes from the stream.
    4339 \item
    4340 \Indexc{ungetc} (©ifstream© only) pushes the character back to the input stream.
    4341 Pushed-back characters returned by subsequent reads in the reverse order of pushing.
    4342 \end{itemize}
    4343 The constructor functions:
    4344 \begin{itemize}[topsep=4pt,itemsep=2pt,parsep=0pt]
    4345 \item
    4346 create an unbound stream, which is subsequently bound to a file with ©open©.
    4347 \item
    4348 create a bound stream to the associated file with given ©mode©.
    4349 \end{itemize}
    4350 The destructor closes the stream.
    4351 
    4352 \begin{figure}
    4353 \begin{cfa}
    4354 // *********************************** ofstream ***********************************
    4355 bool fail( ofstream & );§\indexc{fail}\index{ofstream@©ofstream©!©fail©}§
    4356 void clear( ofstream & );§\indexc{clear}\index{ofstream@©ofstream©!©clear©}§
    4357 int flush( ofstream & );§\indexc{flush}\index{ofstream@©ofstream©!©flush©}§
    4358 void open( ofstream &, const char name[], const char mode[] = "w" );§\indexc{open}\index{ofstream@©ofstream©!©open©}§
    4359 void close( ofstream & );§\indexc{close}\index{ofstream@©ofstream©!©close©}§
    4360 ofstream & write( ofstream &, const char data[], size_t size );§\indexc{write}\index{ofstream@©ofstream©!©write©}§
    4361 void ?{}( ofstream & );§\index{ofstream@©ofstream©!©?{}©}§
    4362 void ?{}( ofstream &, const char name[], const char mode[] = "w" );
    4363 void ^?{}( ofstream & );§\index{ofstream@©ofstream©!©^?{}©}§
    4364 
    4365 // *********************************** ifstream ***********************************
    4366 bool fail( ifstream & is );§\indexc{fail}\index{ifstream@©ifstream©!©fail©}§
    4367 void clear( ifstream & );§\indexc{clear}\index{ifstream@©ifstream©!©clear©}§
    4368 bool eof( ifstream & is );§\indexc{eof}\index{ifstream@©ifstream©!©eof©}§
    4369 void open( ifstream & is, const char name[], const char mode[] = "r" );§\indexc{open}\index{ifstream@©ifstream©!©open©}§
    4370 void close( ifstream & is );§\indexc{close}\index{ifstream@©ifstream©!©close©}§
    4371 ifstream & read( ifstream & is, char data[], size_t size );§\indexc{read}\index{ifstream@©ifstream©!©read©}§
    4372 ifstream & ungetc( ifstream & is, char c );§\indexc{unget}\index{ifstream@©ifstream©!©unget©}§
    4373 void ?{}( ifstream & is );§\index{ifstream@©ifstream©!©?{}©}§
    4374 void ?{}( ifstream & is, const char name[], const char mode[] = "r" );
    4375 void ^?{}( ifstream & is );§\index{ifstream@©ifstream©!©^?{}©}§
    4376 \end{cfa}
    4377 \caption{I/O Stream Functions}
    4378 \label{f:IOStreamFunctions}
    4379 \end{figure}
    4380 
    4381 \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.
     4248
     4249\VRef[Figure]{f:CFACommand-LineProcessing} shows idiomatic \CFA command-line processing and copying an input file to an output file.
    43824250Note, a stream variable may be copied because it is a reference to an underlying stream data-structures.
    4383 \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.
     4251All 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.
    43844252
    43854253\begin{figure}
    … …  
    43934261        try {
    43944262                choose ( argc ) {
    4395                   case 3, 2:
     4263                  case 2, 3:
    43964264                        ®open®( in, argv[1] );                  §\C{// open input file first as output creates file}§
    43974265                        if ( argc == 3 ) ®open®( out, argv[2] ); §\C{// do not create output unless input opens}§
    … …  
    44224290\end{figure}
    44234291
     4292\VRef[Figure]{f:StreamFunctions} shows the stream operations.
     4293\begin{itemize}[topsep=4pt,itemsep=2pt,parsep=0pt]
     4294\item
     4295\Indexc{fail} tests the stream error-indicator, returning nonzero if it is set.
     4296\item
     4297\Indexc{clear} resets the stream error-indicator.
     4298\item
     4299\Indexc{flush} (©ofstream© only) causes any unwritten data for a stream to be written to the file.
     4300\item
     4301\Indexc{eof} (©ifstream© only) tests the end-of-file indicator for the stream pointed to by stream.
     4302Returns true if the end-of-file indicator is set, otherwise false.
     4303\item
     4304\Indexc{open} binds the file with ©name© to a stream accessed with ©mode© (see ©fopen©).
     4305\item
     4306\Indexc{close} flushes the stream and closes the file.
     4307\item
     4308\Indexc{write} (©ofstream© only) writes ©size© bytes to the stream.
     4309The bytes are written lazily when an internal buffer fills.
     4310Eager buffer writes are done with ©flush©
     4311\item
     4312\Indexc{read} (©ifstream© only) reads ©size© bytes from the stream.
     4313\item
     4314\Indexc{ungetc} (©ifstream© only) pushes the character back to the input stream.
     4315Pushed-back characters returned by subsequent reads in the reverse order of pushing.
     4316\end{itemize}
     4317The constructor functions:
     4318\begin{itemize}[topsep=4pt,itemsep=2pt,parsep=0pt]
     4319\item
     4320create an unbound stream, which is subsequently bound to a file with ©open©.
     4321\item
     4322create a bound stream to the associated file with given ©mode©.
     4323\end{itemize}
     4324The destructor closes the stream.
     4325
     4326\begin{figure}
     4327\begin{cfa}
     4328// *********************************** ofstream ***********************************
     4329
     4330bool fail( ofstream & );§\indexc{fail}\index{ofstream@©ofstream©!©fail©}§
     4331void clear( ofstream & );§\indexc{clear}\index{ofstream@©ofstream©!©clear©}§
     4332int flush( ofstream & );§\indexc{flush}\index{ofstream@©ofstream©!©flush©}§
     4333void open( ofstream &, const char name[], const char mode[] = "w" );§\indexc{open}\index{ofstream@©ofstream©!©open©}§
     4334void close( ofstream & );§\indexc{close}\index{ofstream@©ofstream©!©close©}§
     4335ofstream & write( ofstream &, const char data[], size_t size );§\indexc{write}\index{ofstream@©ofstream©!©write©}§
     4336
     4337void ?{}( ofstream & );§\index{ofstream@©ofstream©!©?{}©}§
     4338void ?{}( ofstream &, const char name[], const char mode[] = "w" );
     4339void ^?{}( ofstream & );§\index{ofstream@©ofstream©!©^?{}©}§
     4340
     4341// *********************************** ifstream ***********************************
     4342
     4343bool fail( ifstream & is );§\indexc{fail}\index{ifstream@©ifstream©!©fail©}§
     4344void clear( ifstream & );§\indexc{clear}\index{ifstream@©ifstream©!©clear©}§
     4345bool eof( ifstream & is );§\indexc{eof}\index{ifstream@©ifstream©!©eof©}§
     4346void open( ifstream & is, const char name[], const char mode[] = "r" );§\indexc{open}\index{ifstream@©ifstream©!©open©}§
     4347void close( ifstream & is );§\indexc{close}\index{ifstream@©ifstream©!©close©}§
     4348ifstream & read( ifstream & is, char data[], size_t size );§\indexc{read}\index{ifstream@©ifstream©!©read©}§
     4349ifstream & ungetc( ifstream & is, char c );§\indexc{unget}\index{ifstream@©ifstream©!©unget©}§
     4350
     4351void ?{}( ifstream & is );§\index{ifstream@©ifstream©!©?{}©}§
     4352void ?{}( ifstream & is, const char name[], const char mode[] = "r" );
     4353void ^?{}( ifstream & is );§\index{ifstream@©ifstream©!©^?{}©}§
     4354\end{cfa}
     4355\caption{Stream Functions}
     4356\label{f:StreamFunctions}
     4357\end{figure}
     4358
    44244359
    44254360\subsection{Implicit Separator}
    44264361
    44274362The \Index{implicit separator}\index{I/O!separator} character (space/blank) is a separator not a terminator for output.
    4428 The rules for implicitly adding a separator are:
     4363The rules for implicitly adding the separator are:
    44294364\begin{enumerate}
    44304365\item
    … …  
    44554390\begin{cfa}
    44564391sout | 1 | ", x" | 2 | ". x" | 3 | "; x" | 4 | "! x" | 5 | "? x" | 6 | "% x"
    4457            | 7 | "§\LstStringStyle{\textcent}§ x" | 8 | "§\LstStringStyle{\guillemotright}§ x" | 9 | ") x" | 10 | "] x" | 11 | "} x";
     4392           | 7 | "$\LstStringStyle{\textcent}$ x" | 8 | "$\LstStringStyle{\guillemotright}$ x" | 9 | ") x" | 10 | "] x" | 11 | "} x";
    44584393\end{cfa}
    44594394\begin{cfa}[showspaces=true]
    4460 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
     43951®,® 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
    44614396\end{cfa}
    44624397
    44634398\item
    44644399A 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.
    4465 \begin{cfa}
    4466 sout | "x (" | 1 | "x [" | 2 | "x {" | 3 | "x =" | 4 | "x §\LstStringStyle{\textdollar}§" | 5 | "x §\LstStringStyle{\textsterling}§" | 6 | "x §\LstStringStyle{\textyen}§"
    4467            | 7 | "x §\LstStringStyle{\textexclamdown}§" | 8 | "x §\LstStringStyle{\textquestiondown}§" | 9 | "x §\LstStringStyle{\guillemotleft}§" | 10;
    4468 \end{cfa}
     4400%$
     4401\begin{cfa}
     4402sout | "x (" | 1 | "x [" | 2 | "x {" | 3 | "x =" | 4 | "x $\LstStringStyle{\textdollar}$" | 5 | "x $\LstStringStyle{\textsterling}$" | 6 | "x $\LstStringStyle{\textyen}$"
     4403           | 7 | "x $\LstStringStyle{\textexclamdown}$" | 8 | "x $\LstStringStyle{\textquestiondown}$" | 9 | "x $\LstStringStyle{\guillemotleft}$" | 10;
     4404\end{cfa}
     4405%$
    44694406\begin{cfa}[showspaces=true]
    4470 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
    4471 \end{cfa}
     4407x ®(®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
     4408\end{cfa}
     4409%$
    44724410
    44734411\item
    … …  
    44774415\end{cfa}
    44784416\begin{cfa}[showspaces=true,showtabs=true]
    4479 x®`®1®`®x§\R{\texttt{'}}§2§\R{\texttt{'}}§x§\R{\texttt{"}}§3§\R{\texttt{"}}§x®:®4®:®x® ®5® ®x®  ®6®     ®x
     4417x®`®1®`®x$\R{\texttt{'}}$2$\R{\texttt{'}}$x$\R{\texttt{"}}$3$\R{\texttt{"}}$x®:®4®:®x® ®5® ®x®  ®6®     ®x
    44804418\end{cfa}
    44814419
    … …  
    44834421If a space is desired before or after one of the special string start/end characters, explicitly insert a space.
    44844422\begin{cfa}
    4485 sout | "x (§\R{\texttt{\textvisiblespace}}§" | 1 | "§\R{\texttt{\textvisiblespace}}§) x" | 2 | "§\R{\texttt{\textvisiblespace}}§, x" | 3 | "§\R{\texttt{\textvisiblespace}}§:x:§\R{\texttt{\textvisiblespace}}§" | 4;
     4423sout | "x ($\R{\texttt{\textvisiblespace}}$" | 1 | "$\R{\texttt{\textvisiblespace}}$) x" | 2 | "$\R{\texttt{\textvisiblespace}}$, x" | 3 | "$\R{\texttt{\textvisiblespace}}$:x:$\R{\texttt{\textvisiblespace}}$" | 4;
    44864424\end{cfa}
    44874425\begin{cfa}[showspaces=true,showtabs=true]
    … …  
    45004438The separator string can be at most 16 characters including the ©'\0'© string terminator (15 printable characters).
    45014439\begin{cfa}[belowskip=0pt]
    4502 sepSet( sout, ", §\LstStringStyle{\textdollar}§" ); §\C{// set separator from " " to ", \$"}§
     4440sepSet( sout, ", $\LstStringStyle{\textdollar}$" ); §\C{// set separator from " " to ", \$"}§
    45034441sout | 1 | 2 | 3 | " \"" | ®sepVal® | "\"";
    45044442\end{cfa}
    45054443\begin{cfa}[showspaces=true,aboveskip=0pt]
    4506 1®, §\color{red}\LstStringStyle{\textdollar}§®2®, §\color{red}\LstStringStyle{\textdollar}§®3 ®", §\color{red}\LstStringStyle{\textdollar}§"®
     44441®, $\color{red}\LstStringStyle{\textdollar}$®2®, $\color{red}\LstStringStyle{\textdollar}$®3 ®", $\color{red}\LstStringStyle{\textdollar}$"®
    45074445\end{cfa}
    45084446\begin{cfa}[belowskip=0pt]
    … …  
    46194557For example, in:
    46204558\begin{cfa}
    4621 int i, j;
    46224559sin | i | ®nl® | j;
    462345601 ®2®
    … …  
    46254562\end{cfa}
    46264563variable ©i© is assigned 1, the 2 is skipped, and variable ©j© is assigned 3.
    4627 For example, in:
    4628 \begin{cquote}
    4629 \begin{tabular}{@{}l@{\hspace{3em}}l@{}}
    4630 \begin{cfa}
    4631 char ch
    4632 
    4633 sin | ch; // read X
    4634 
    4635 X
    4636 \end{cfa}
    4637 &
    4638 \begin{cfa}
    4639 
    4640 sin | ®nlOn®; // enable reading newlines
    4641 sin | ch; // read newline
    4642 
    4643 
    4644 \end{cfa}
    4645 \end{tabular}
    4646 \end{cquote}
    4647 the left example skips the newline and reads ©'X'© into ©ch©, while the right example reads the newline into ©ch©.
    46484564
    46494565For output:
    … …  
    46734589
    46744590
    4675 \subsection{Output Manipulators}
     4591\subsection{Output Value Manipulators}
    46764592
    46774593The following \Index{manipulator}s control formatting (printing) of the argument output values.
    … …  
    47274643\item
    47284644\Indexc{unit}( engineering-notation )\index{manipulator!unit@©unit©} print engineering exponent as a letter between the range $10^{-24}$ and $10^{24}$:
    4729 \begin{cquote}
    47304645©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}$.
    4731 \end{cquote}
    47324646For exponent $10^{0}$, no decimal point or letter is printed.
    47334647\begin{cfa}[belowskip=0pt]
    … …  
    49294843// End: //
    49304844\end{comment}
    4931 
    4932 
    4933 \subsection{Input Manipulators}
    4934 
    4935 The following \Index{manipulator}s control scanning of input values (reading), and only affect the format of the argument.
    4936 
    4937 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.
    4938 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) ©'§'©.
     4845%$
     4846
     4847
     4848\subsection{Input Value Manipulators}
     4849
     4850The 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.
     4851For ©bool© type, the constants are ©true© and ©false©.
     4852For integral types, any number of digits, optionally preceded by a sign (©+© or ©-©), where a
     4853\begin{itemize}
     4854\item
     4855©1©-©9© prefix introduces a decimal value (©0©-©9©),
     4856\item
     4857©0© prefix introduces an octal value (©0©-©7©), and
     4858\item
     4859©0x© or ©0X© prefix introduces a hexadecimal value (©0©-©f©) with lower or upper case letters.
     4860\end{itemize}
     4861For 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.
     4862Floating-point values can also be written in hexadecimal format preceded by ©0x© or ©0X© with hexadecimal digits and exponent denoted by ©p© or ©P©.
     4863
     4864For 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.
     4865Instead, the next sequence of non-whitespace characters are read, and the input sequence is terminated with delimiter ©'\0'©.
     4866The string variable \emph{must} be large enough to contain the input sequence.
     4867To 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:
     4868\begin{cfa}
     4869char line[64];
     4870sin | wdi( ®sizeof(line)®, line ); // must specify size
     4871\end{cfa}
     4872
     4873A scanset is a simple regular expression, where the matching set contains any Latin-1 character (8-bits) or character ranges using minus.
     4874For 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) ©'§'©.
    49394875The following string is matched by this scanset:
    49404876\begin{cfa}
    4941 !&%$  abAA () ZZZ  ??  xx§\S\S\S§
     4877!&%$  abAA () ZZZ  ??  xx§§§§
    49424878\end{cfa}
    49434879To match a minus, put it as the first character, ©"-0-9"©.
    49444880Other complex forms of regular-expression matching are not supported.
    49454881
    4946 A string variable \emph{must} be large enough to contain the input sequence.
    4947 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:
    4948 \begin{cfa}
    4949 char line[64];
    4950 sin | wdi( ®sizeof(line)®, line ); // must specify size
    4951 \end{cfa}
    4952 
    4953 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.
    4954 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.
    4955 All reads in \CFA check if values do not fit into the argument variable's type and raise the exception
    4956 All types are
    4957 
     4882The following \Index{manipulator}s control scanning of input values (reading), and only affect the format of the argument.
    49584883\begin{enumerate}
    49594884\item
    4960 \Indexc{skip}( scanset )\index{manipulator!skip@©skip©}, ©skip©( $N$ )
    4961 The first form uses a scanset to skip matching characters.
    4962 The second form skips the next $N$ characters, including newline.
     4885\Indexc{skip}( pattern )\index{manipulator!skip@©skip©}, ©skip©( length )
     4886The 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.
     4887The length is composed of the next $N$ characters, including the newline character.
    49634888If the match successes, the input characters are discarded, and input continues with the next character.
    49644889If the match fails, the input characters are left unread.
    49654890\begin{cfa}[belowskip=0pt]
    4966 char sk[§\,§] = "abc";
     4891char sk[$\,$] = "abc";
    49674892sin | "abc " | skip( sk ) | skip( 5 ); // match input sequence
    49684893\end{cfa}
    … …  
    49744899
    49754900\item
    4976 \Indexc{wdi}( maximum, variable )\index{manipulator!wdi@©wdi©}
    4977 For all types except ©char *©, whitespace is skipped until an appropriate value is found for the specified variable type.
    4978 maximum is the maximum number of characters read for the current operation.
     4901\Indexc{wdi}( maximum, reference-value )\index{manipulator!wdi@©wdi©}
     4902For all types except ©char©, maximum is the maximum number of characters read for the current operation.
    49794903\begin{cfa}[belowskip=0pt]
    4980 char ch;   char ca[3];   int i;   double d;   
    4981 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
     4904char s[10];   int i;   double d;   
     4905sin | wdi( 4, s ) | wdi( 3, i ) | wdi( 8, d );  // c == "abcd", i == 123, d == 3.456E+2
    49824906\end{cfa}
    49834907\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
    49844908®abcd1233.456E+2®
    49854909\end{cfa}
    4986 Here, ©ca[0]© is type ©char©, so the width reads 3 characters \Textbf{without} a null terminator.
    4987 
    49884910Note, input ©wdi© cannot be overloaded with output ©wd© because both have the same parameters but return different types.
    49894911Currently, \CFA cannot distinguish between these two manipulators in the middle of an ©sout©/©sin© expression based on return type.
    4990 
    4991 \item
    4992 \Indexc{wdi}( maximum size, ©char s[]© )\index{manipulator!wdi@©wdi©}
    4993 For type ©char *©, maximum is the maximum number of characters read for the current operation.
    4994 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
    4995 \begin{cfa}[belowskip=0pt]
    4996 char cstr[10];
    4997 sin | wdi( sizeof(cstr), cstr );
    4998 \end{cfa}
    4999 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
    5000 ®abcd1233.456E+2®
    5001 \end{cfa}
    5002 
    5003 \item
    5004 \Indexc{wdi}( maximum size, maximum read, ©char s[]© )\index{manipulator!wdi@©wdi©}
    5005 For type ©char *©, maximum is the maximum number of characters read for the current operation.
    5006 \begin{cfa}[belowskip=0pt]
    5007 char ch;   char ca[3];   int i;   double d;   
    5008 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
    5009 \end{cfa}
    5010 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
    5011 ®abcd1233.456E+2®
    5012 \end{cfa}
    50134912
    50144913\item
    … …  
    50474946\end{cfa}
    50484947
    5049 \Indexc{quoted}( char delimit, wdi-input-string )\index{manipulator!quoted@©quoted©}
    5050 Is an ©excl© with scanset ©"delimit"©, which consumes all characters up to the delimit character.
    5051 If the delimit character is omitted, it defaults to ©'\n'© (newline).
    5052 
    50534948\item
    50544949\Indexc{getline}( char delimit, wdi-input-string )\index{manipulator!getline@©getline©}
    5055 Is an ©excl© with scanset ©"delimit"©, which consumes all characters up to the delimit character.
     4950Is an @excl@ with scanset ©"delimit"©, which consumes all characters up to the delimit character.
    50564951If the delimit character is omitted, it defaults to ©'\n'© (newline).
    50574952\end{enumerate}
    … …  
    50634958For example, if two threads execute the following:
    50644959\begin{cfa}
    5065 §\emph{thread\(_1\)}§ : sout | "abc " | "def ";
    5066 §\emph{thread\(_2\)}§ : sout | "uvw " | "xyz ";
     4960$\emph{thread\(_1\)}$ : sout | "abc " | "def ";
     4961$\emph{thread\(_2\)}$ : sout | "uvw " | "xyz ";
    50674962\end{cfa}
    50684963possible outputs are:
    … …  
    51044999The 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:
    51055000\begin{cfa}
    5106 §\emph{thread\(_1\)}§ : ®mutex( sout )® sout | "abc " | "def ";
    5107 §\emph{thread\(_2\)}§ : ®mutex( sout )® sout | "uvw " | "xyz ";
     5001$\emph{thread\(_1\)}$ : ®mutex( sout )® sout | "abc " | "def ";
     5002$\emph{thread\(_2\)}$ : ®mutex( sout )® sout | "uvw " | "xyz ";
    51085003\end{cfa}
    51095004Now, the order of the thread execution is still non-deterministic, but the output is constrained to two possible lines in either order.
    … …  
    51665061Cultures use different syntax, called a \newterm{locale}, for printing numbers so they are easier to read, \eg:
    51675062\begin{cfa}
    5168 12®,®345®.®123          §\C[1.25in]{// comma separator, period decimal-point}§
     506312®,®345®.®123          $\C[1.25in]{// comma separator, period decimal-point}$
    5169506412®.®345®,®123          §\C{// period separator, comma decimal-point}§
    5170 12§\Sp§345®,®123®.®     §\C{// space separator, comma decimal-point, period terminator}\CRT§
     506512$\Sp$345®,®123®.®     §\C{// space separator, comma decimal-point, period terminator}\CRT§
    51715066\end{cfa}
    51725067A locale is selected with function ©setlocale©, and the corresponding locale package \emph{must} be installed on the underlying system;
    … …  
    52145109Ukraine uk_UA.utf8
    5215511012 123 1 234 12 345 123 456 1 234 567
    5216 12®.® 123®,®1®.® 1§\Sp§234®,®12®.® 12§\Sp§ 345®,®123®.® 123§\Sp§ 456®,®1234®.® 1§\Sp§ 234§\Sp§567®,®12345®.®
     511112®.® 123®,®1®.® 1$\Sp$234®,®12®.® 12$\Sp$ 345®,®123®.® 123$\Sp$ 456®,®1234®.® 1$\Sp$ 234$\Sp$567®,®12345®.®
    52175112
    52185113Default locale off C
    … …  
    55665461
    55675462\subsection{Operator}
    5568 \label{s:Operator}
    55695463
    55705464\CFA also allows operators to be overloaded, to simplify the use of user-defined types.
    … …  
    74387332
    74397333\Index*[C++]{\CC{}} is a general-purpose programming language.
    7440 It is an imperative, object-oriented and generic programming language, while also providing facilities for low-level memory manipulation.
    7441 The primary focus of \CC was adding object-oriented programming to C, and this is the primary difference between \CC and \CFA.
     7334It has imperative, object-oriented and generic programming features, while also providing facilities for low-level memory manipulation. (Wikipedia)
     7335
     7336The primary focus of \CC seems to be adding object-oriented programming to C, and this is the primary difference between \CC and Do.
    74427337\CC uses classes to encapsulate data and the functions that operate on that data, and to hide the internal representation of the data.
    74437338\CFA uses modules instead to perform these same tasks.
    … …  
    74577352\subsection{Go}
    74587353
    7459 \Index*{Go}, also commonly referred to as golang, is a programming language developed at Google in 2007~\cite{Go}.
     7354\Index*{Go}, also commonly referred to as golang, is a programming language developed at Google in 2007 [.].
    74607355It is a statically typed language with syntax loosely derived from that of C, adding garbage collection, type
    74617356safety, some structural typing capabilities, additional built-in types such as variable-length arrays and key-value maps, and a large standard library. (Wikipedia)
    … …  
    75117406In \CFA, there are ambiguous cases with dereference and operator identifiers, \eg ©int *?*?()©, where the string ©*?*?© can be interpreted as:
    75127407\begin{cfa}
    7513 *?§\Sp§*?                                                               §\C{// dereference operator, dereference operator}§
    7514 *§\Sp§?*?                                                               §\C{// dereference, multiplication operator}§
     7408*?$\Sp$*? §\C{// dereference operator, dereference operator}§
     7409*$\Sp$?*? §\C{// dereference, multiplication operator}§
    75157410\end{cfa}
    75167411By default, the first interpretation is selected, which does not yield a meaningful parse.
    … …  
    75217416The ambiguity occurs when the deference operator has no parameters:
    75227417\begin{cfa}
    7523 *?()§\R{\textvisiblespace...}§ ;
    7524 *?()§\R{\textvisiblespace...}§(...) ;
     7418*?()$\R{\textvisiblespace...}$ ;
     7419*?()$\R{\textvisiblespace...}$(...) ;
    75257420\end{cfa}
    75267421requiring arbitrary whitespace look-ahead for the routine-call parameter-list to disambiguate.
    … …  
    75307425The remaining cases are with the increment/decrement operators and conditional expression, \eg:
    75317426\begin{cfa}
    7532 i++?§\R{\textvisiblespace...}§(...);
    7533 i?++§\R{\textvisiblespace...}§(...);
     7427i++?$\R{\textvisiblespace...}$(...);
     7428i?++$\R{\textvisiblespace...}$(...);
    75347429\end{cfa}
    75357430requiring arbitrary whitespace look-ahead for the operator parameter-list, even though that interpretation is an incorrect expression (juxtaposed identifiers).
    75367431Therefore, it is necessary to disambiguate these cases with a space:
    75377432\begin{cfa}
    7538 i++§\Sp§? i : 0;
    7539 i?§\Sp§++i : 0;
     7433i++$\Sp$? i : 0;
     7434i?$\Sp$++i : 0;
    75407435\end{cfa}
    75417436
    … …  
    75647459\eg:
    75657460\begin{cfa}
    7566 x;                                                              §\C{// int x}§
    7567 *y;                                                             §\C{// int * y}§
    7568 f( p1, p2 );                                    §\C{// int f( int p1, int p2 );}§
    7569 g( p1, p2 ) int p1, p2;                 §\C{// int g( int p1, int p2 );}§
     7461x; §\C{// int x}§
     7462*y; §\C{// int *y}§
     7463f( p1, p2 ); §\C{// int f( int p1, int p2 );}§
     7464g( p1, p2 ) int p1, p2; §\C{// int g( int p1, int p2 );}§
    75707465\end{cfa}
    75717466\CFA continues to support K\&R routine definitions:
    75727467\begin{cfa}
    7573 f( a, b, c )                                    §\C{// default int return}§
    7574         int a, b; char c;                       §\C{// K\&R parameter declarations}§
     7468f( a, b, c ) §\C{// default int return}§
     7469        int a, b; char c §\C{// K\&R parameter declarations}§
    75757470{
    75767471        ...
    … …  
    75917486int rtn( int i );
    75927487int rtn( char c );
    7593 rtn( 'x' );                                             §\C{// programmer expects 2nd rtn to be called}§
     7488rtn( 'x' ); §\C{// programmer expects 2nd rtn to be called}§
    75947489\end{cfa}
    75957490\item[Rationale:] it is more intuitive for the call to ©rtn© to match the second version of definition of ©rtn© rather than the first.
    … …  
    76137508\item[Change:] make string literals ©const©:
    76147509\begin{cfa}
    7615 char * p = "abc";                               §\C{// valid in C, deprecated in \CFA}§
    7616 char * q = expr ? "abc" : "de"; §\C{// valid in C, invalid in \CFA}§
     7510char * p = "abc"; §\C{// valid in C, deprecated in \CFA}§
     7511char * q = expr ? "abc" : "de"; §\C{// valid in C, invalid in \CFA}§
    76177512\end{cfa}
    76187513The type of a string literal is changed from ©[] char© to ©const [] char©.
    … …  
    76217516\begin{cfa}
    76227517char * p = "abc";
    7623 p[0] = 'w';                                             §\C{// segment fault or change constant literal}§
     7518p[0] = 'w'; §\C{// segment fault or change constant literal}§
    76247519\end{cfa}
    76257520The same problem occurs when passing a string literal to a routine that changes its argument.
    … …  
    76337528\item[Change:] remove \newterm{tentative definitions}, which only occurs at file scope:
    76347529\begin{cfa}
    7635 int i;                                                  §\C{// forward definition}§
    7636 int *j = ®&i®;                                  §\C{// forward reference, valid in C, invalid in \CFA}§
    7637 int i = 0;                                              §\C{// definition}§
     7530int i; §\C{// forward definition}§
     7531int *j = ®&i®; §\C{// forward reference, valid in C, invalid in \CFA}§
     7532int i = 0; §\C{// definition}§
    76387533\end{cfa}
    76397534is valid in C, and invalid in \CFA because duplicate overloaded object definitions at the same scope level are disallowed.
    … …  
    76417536\begin{cfa}
    76427537struct X { int i; struct X *next; };
    7643 static struct X a;                              §\C{// forward definition}§
    7644 static struct X b = { 0, ®&a® }; §\C{// forward reference, valid in C, invalid in \CFA}§
    7645 static struct X a = { 1, &b };  §\C{// definition}§
     7538static struct X a; §\C{// forward definition}§
     7539static struct X b = { 0, ®&a® };§\C{// forward reference, valid in C, invalid in \CFA}§
     7540static struct X a = { 1, &b }; §\C{// definition}§
    76467541\end{cfa}
    76477542\item[Rationale:] avoids having different initialization rules for builtin types and user-defined types.
    … …  
    76577552enum ®Colour® { R, G, B, Y, C, M };
    76587553struct Person {
    7659         enum ®Colour® { R, G, B };      §\C{// nested type}§
    7660         struct Face {                           §\C{// nested type}§
    7661                 ®Colour® Eyes, Hair;    §\C{// type defined outside (1 level)}§
     7554        enum ®Colour® { R, G, B };      $\C[7cm]{// nested type}$
     7555        struct Face { §\C{// nested type}§
     7556                ®Colour® Eyes, Hair; §\C{// type defined outside (1 level)}§
    76627557        };
    7663         ®.Colour® shirt;                        §\C{// type defined outside (top level)}§
    7664         ®Colour® pants;                         §\C{// type defined same level}§
    7665         Face looks[10];                         §\C{// type defined same level}§
     7558        ®.Colour® shirt; §\C{// type defined outside (top level)}§
     7559        ®Colour® pants; §\C{// type defined same level}§
     7560        Face looks[10]; §\C{// type defined same level}§
    76667561};
    7667 ®Colour® c = R;                                 §\C{// type/enum defined same level}§
    7668 Person®.Colour® pc = Person®.®R;        §\C{// type/enum defined inside}§
    7669 Person®.®Face pretty;                   §\C{// type defined inside}§
     7562®Colour® c = R; §\C{// type/enum defined same level}§
     7563Person®.Colour® pc = Person®.®R;§\C{// type/enum defined inside}§
     7564Person®.®Face pretty; §\C{// type defined inside}\CRT§
    76707565\end{cfa}
    76717566In 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.
    … …  
    77447639\CFA introduces the following new \Index{keyword}s, which cannot be used as identifiers.
    77457640
    7746 \begin{cquote}
    7747 \Indexc{basetypeof}, \Indexc{choose}, \Indexc{coroutine}, \Indexc{disable},
    7748 \Indexc{enable}, \Indexc{exception}, \Indexc{fallthrough}, \Indexc{fallthru},
    7749 \Indexc{finally}, \Indexc{fixup}, \Indexc{forall},\Indexc{generator},
    7750 \Indexc{int128}, \Indexc{monitor}, \Indexc{mutex}, \Indexc{one_t},
    7751 \Indexc{report}, \Indexc{suspend}, \Indexc{throw}, \Indexc{throwResume},
    7752 \Indexc{trait}, \Indexc{try}, \Indexc{virtual}, \Indexc{waitfor},
    7753 \Indexc{when}, \Indexc{with}, \Indexc{zero_t}
    7754 \end{cquote}
    7755 \CFA introduces the following new \Index{quasi-keyword}s, which can be used as identifiers.
    7756 \begin{cquote}
    7757 \Indexc{catch}, \Indexc{catchResume}, \Indexc{finally}, \Indexc{fixup}, \Indexc{or}, \Indexc{timeout}
    7758 \end{cquote}
    7759 
    7760 \begin{comment}
    77617641\begin{cquote}
    77627642\begin{tabular}{@{}lllllll@{}}
    … …  
    78277707\end{tabular}
    78287708\end{cquote}
    7829 \end{comment}
    7830 
    78317709
    78327710\section{Standard Headers}
    78337711\label{s:StandardHeaders}
    78347712
    7835 \Celeven prescribes the following standard header-files~\cite[\S~7.1.2]{C11}:
    7836 \begin{cquote}
    7837 \Indexc{assert.h}, \Indexc{complex.h}, \Indexc{ctype.h}, \Indexc{errno.h}, \Indexc{fenv.h},
    7838 \Indexc[deletekeywords=float]{float.h}, \Indexc{inttypes.h}, \Indexc{iso646.h}, \Indexc{limits.h},
    7839 \Indexc{locale.h}, \Indexc{math.h}, \Indexc{setjmp.h}, \Indexc{signal.h}, \Indexc{stdalign.h},
    7840 \Indexc{stdarg.h}, \Indexc{stdatomic.h}, \Indexc{stdbool.h}, \Indexc{stddef.h}, \Indexc{stdint.h},
    7841 \Indexc{stdio.h}, \Indexc{stdlib.h}, \Indexc{stdnoreturn.h}, \Indexc{string.h}, \Indexc{tgmath.h},
    7842 \Indexc{threads.h}, \Indexc{time.h}, \Indexc{uchar.h}, \Indexc{wchar.h}, \Indexc{wctype.h}
    7843 \end{cquote}
    7844 and \CFA adds to this list:
    7845 \begin{cquote}
    7846 \Indexc{gmp.h}, \Indexc{malloc.h}, \Indexc{unistd.h}
    7847 \end{cquote}
    7848 \begin{comment}
     7713\Celeven prescribes the following standard header-files~\cite[\S~7.1.2]{C11} and \CFA adds to this list:
    78497714\begin{cquote}
    78507715\begin{tabular}{@{}llllll|l@{}}
    … …  
    79087773\end{tabular}
    79097774\end{cquote}
    7910 \end{comment}
    79117775For the prescribed head-files, \CFA uses header interposition to wraps these includes in an ©extern "C"©;
    79127776hence, names in these include files are not mangled\index{mangling!name} \see{\VRef{s:Interoperability}}.
    … …  
    79737837Type-safe allocation is provided for all C allocation routines and new \CFA allocation routines, \eg in
    79747838\begin{cfa}
    7975 int * ip = (int *)malloc( sizeof(int) ); §\C{// C}§
    7976 int * ip = malloc();                                    §\C{// \CFA type-safe version of C malloc}§
    7977 int * ip = alloc();                                             §\C{// \CFA type-safe uniform alloc}§
     7839int * ip = (int *)malloc( sizeof(int) );                §\C{// C}§
     7840int * ip = malloc();                                                    §\C{// \CFA type-safe version of C malloc}§
     7841int * ip = alloc();                                                             §\C{// \CFA type-safe uniform alloc}§
    79787842\end{cfa}
    79797843the latter two allocations determine the allocation size from the type of ©p© (©int©) and cast the pointer to the allocated storage to ©int *©.
    … …  
    79827846\begin{cfa}
    79837847struct S { int i; } __attribute__(( aligned( 128 ) )); // cache-line alignment
    7984 S * sp = malloc();                                              §\C{// honour type alignment}§
     7848S * sp = malloc();                                                              §\C{// honour type alignment}§
    79857849\end{cfa}
    79867850the storage allocation is implicitly aligned to 128 rather than the default 16.
    … …  
    79977861\CFA memory management extends allocation to support constructors for initialization of allocated storage, \eg in
    79987862\begin{cfa}
    7999 struct S { int i; };                                    §\C{// cache-line alignment}§
     7863struct S { int i; };                                                    §\C{// cache-line alignment}§
    80007864void ?{}( S & s, int i ) { s.i = i; }
    80017865// assume ?|? operator for printing an S
    80027866
    8003 S & sp = *®new®( 3 );                                   §\C{// call constructor after allocation}§
     7867S & sp = *®new®( 3 );                                                   §\C{// call constructor after allocation}§
    80047868sout | sp.i;
    80057869®delete®( &sp );
    80067870
    8007 S * spa = ®anew®( 10, 5 );                              §\C{// allocate array and initialize each array element}§
     7871S * spa = ®anew®( 10, 5 );                                              §\C{// allocate array and initialize each array element}§
    80087872for ( i; 10 ) sout | spa[i] | nonl;
    80097873sout | nl;
    … …  
    80177881extern "C" {
    80187882        // C unsafe allocation
    8019         void * malloc( size_t size );§\indexc{malloc}§
    8020         void * calloc( size_t dim, size_t size );§\indexc{calloc}§
    8021         void * realloc( void * ptr, size_t size );§\indexc{realloc}§
    8022         void * memalign( size_t align, size_t size );§\indexc{memalign}§
    8023         void * aligned_alloc( size_t align, size_t size );§\indexc{aligned_alloc}§
    8024         int posix_memalign( void ** ptr, size_t align, size_t size );§\indexc{posix_memalign}§
    8025         void * cmemalign( size_t alignment, size_t noOfElems, size_t elemSize );§\indexc{cmemalign}§ // CFA
     7883        void * malloc( size_t size );$\indexc{malloc}$
     7884        void * calloc( size_t dim, size_t size );$\indexc{calloc}$
     7885        void * realloc( void * ptr, size_t size );$\indexc{realloc}$
     7886        void * memalign( size_t align, size_t size );$\indexc{memalign}$
     7887        void * aligned_alloc( size_t align, size_t size );$\indexc{aligned_alloc}$
     7888        int posix_memalign( void ** ptr, size_t align, size_t size );$\indexc{posix_memalign}$
     7889        void * cmemalign( size_t alignment, size_t noOfElems, size_t elemSize );$\indexc{cmemalign}$ // CFA
    80267890
    80277891        // C unsafe initialization/copy
    8028         void * memset( void * dest, int c, size_t size );§\indexc{memset}§
    8029         void * memcpy( void * dest, const void * src, size_t size );§\indexc{memcpy}§
     7892        void * memset( void * dest, int c, size_t size );$\indexc{memset}$
     7893        void * memcpy( void * dest, const void * src, size_t size );$\indexc{memcpy}$
    80307894}
    80317895
    … …  
    80337897
    80347898forall( dtype T | sized(T) ) {
    8035         // §\CFA§ safe equivalents, i.e., implicit size specification
     7899        // $\CFA$ safe equivalents, i.e., implicit size specification
    80367900        T * malloc( void );
    80377901        T * calloc( size_t dim );
    … …  
    80427906        int posix_memalign( T ** ptr, size_t align );
    80437907
    8044         // §\CFA§ safe general allocation, fill, resize, alignment, array
    8045         T * alloc( void );§\indexc{alloc}§                                      §\C[3.5in]{// variable, T size}§
     7908        // $\CFA$ safe general allocation, fill, resize, alignment, array
     7909        T * alloc( void );$\indexc{alloc}$                                      $\C[3.5in]{// variable, T size}$
    80467910        T * alloc( size_t dim );                                                        §\C{// array[dim], T size elements}§
    80477911        T * alloc( T ptr[], size_t dim );                                       §\C{// realloc array[dim], T size elements}§
    80487912
    8049         T * alloc_set( char fill );§\indexc{alloc_set}§         §\C{// variable, T size, fill bytes with value}§
     7913        T * alloc_set( char fill );$\indexc{alloc_set}$         §\C{// variable, T size, fill bytes with value}§
    80507914        T * alloc_set( T fill );                                                        §\C{// variable, T size, fill with value}§
    80517915        T * alloc_set( size_t dim, char fill );                         §\C{// array[dim], T size elements, fill bytes with value}§
    … …  
    80667930        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}§
    80677931
    8068         // §\CFA§ safe initialization/copy, i.e., implicit size specification
    8069         T * memset( T * dest, char fill );§\indexc{memset}§
    8070         T * memcpy( T * dest, const T * src );§\indexc{memcpy}§
    8071 
    8072         // §\CFA§ safe initialization/copy, i.e., implicit size specification, array types
     7932        // $\CFA$ safe initialization/copy, i.e., implicit size specification
     7933        T * memset( T * dest, char fill );$\indexc{memset}$
     7934        T * memcpy( T * dest, const T * src );$\indexc{memcpy}$
     7935
     7936        // $\CFA$ safe initialization/copy, i.e., implicit size specification, array types
    80737937        T * amemset( T dest[], char fill, size_t dim );
    80747938        T * amemcpy( T dest[], const T src[], size_t dim );
    80757939}
    80767940
    8077 // §\CFA§ allocation/deallocation and constructor/destructor, non-array types
    8078 forall( dtype T | sized(T), ttype Params | { void ?{}( T &, Params ); } ) T * new( Params p );§\indexc{new}§
    8079 forall( dtype T | sized(T) | { void ^?{}( T & ); } ) void delete( T * ptr );§\indexc{delete}§
     7941// $\CFA$ allocation/deallocation and constructor/destructor, non-array types
     7942forall( dtype T | sized(T), ttype Params | { void ?{}( T &, Params ); } ) T * new( Params p );$\indexc{new}$
     7943forall( dtype T | sized(T) | { void ^?{}( T & ); } ) void delete( T * ptr );$\indexc{delete}$
    80807944forall( dtype T, ttype Params | sized(T) | { void ^?{}( T & ); void delete( Params ); } )
    80817945  void delete( T * ptr, Params rest );
    80827946
    8083 // §\CFA§ allocation/deallocation and constructor/destructor, array types
    8084 forall( dtype T | sized(T), ttype Params | { void ?{}( T &, Params ); } ) T * anew( size_t dim, Params p );§\indexc{anew}§
    8085 forall( dtype T | sized(T) | { void ^?{}( T & ); } ) void adelete( size_t dim, T arr[] );§\indexc{adelete}§
     7947// $\CFA$ allocation/deallocation and constructor/destructor, array types
     7948forall( dtype T | sized(T), ttype Params | { void ?{}( T &, Params ); } ) T * anew( size_t dim, Params p );$\indexc{anew}$
     7949forall( dtype T | sized(T) | { void ^?{}( T & ); } ) void adelete( size_t dim, T arr[] );$\indexc{adelete}$
    80867950forall( dtype T | sized(T) | { void ^?{}( T & ); }, ttype Params | { void adelete( Params ); } )
    80877951  void adelete( size_t dim, T arr[], Params rest );
    … …  
    80937957\leavevmode
    80947958\begin{cfa}[aboveskip=0pt,belowskip=0pt]
    8095 int ato( const char * ptr );§\indexc{ato}§
     7959int ato( const char * ptr );$\indexc{ato}$
    80967960unsigned int ato( const char * ptr );
    80977961long int ato( const char * ptr );
    … …  
    81267990\begin{cfa}[aboveskip=0pt,belowskip=0pt]
    81277991forall( T | { int ?<?( T, T ); } ) §\C{// location}§
    8128 T * bsearch( T key, const T * arr, size_t dim );§\indexc{bsearch}§
     7992T * bsearch( T key, const T * arr, size_t dim );$\indexc{bsearch}$
    81297993
    81307994forall( T | { int ?<?( T, T ); } ) §\C{// position}§
    … …  
    81327996
    81337997forall( T | { int ?<?( T, T ); } )
    8134 void qsort( const T * arr, size_t dim );§\indexc{qsort}§
     7998void qsort( const T * arr, size_t dim );$\indexc{qsort}$
    81357999
    81368000forall( E | { int ?<?( E, E ); } ) {
    8137         E * bsearch( E key, const E * vals, size_t dim );§\indexc{bsearch}§ §\C{// location}§
     8001        E * bsearch( E key, const E * vals, size_t dim );$\indexc{bsearch}$ §\C{// location}§
    81388002        size_t bsearch( E key, const E * vals, size_t dim );§\C{// position}§
    8139         E * bsearchl( E key, const E * vals, size_t dim );§\indexc{bsearchl}§
     8003        E * bsearchl( E key, const E * vals, size_t dim );$\indexc{bsearchl}$
    81408004        size_t bsearchl( E key, const E * vals, size_t dim );
    8141         E * bsearchu( E key, const E * vals, size_t dim );§\indexc{bsearchu}§
     8005        E * bsearchu( E key, const E * vals, size_t dim );$\indexc{bsearchu}$
    81428006        size_t bsearchu( E key, const E * vals, size_t dim );
    81438007}
    … …  
    81538017
    81548018forall( E | { int ?<?( E, E ); } ) {
    8155         void qsort( E * vals, size_t dim );§\indexc{qsort}§
     8019        void qsort( E * vals, size_t dim );$\indexc{qsort}$
    81568020}
    81578021\end{cfa}
    … …  
    81628026\leavevmode
    81638027\begin{cfa}[aboveskip=0pt,belowskip=0pt]
    8164 unsigned char abs( signed char );§\indexc{abs}§
     8028unsigned char abs( signed char );$\indexc{abs}$
    81658029int abs( int );
    81668030unsigned long int abs( long int );
    … …  
    81778041
    81788042
    8179 \subsection{C Random Numbers}
     8043\subsection{Random Numbers}
    81808044
    81818045\leavevmode
    81828046\begin{cfa}[aboveskip=0pt,belowskip=0pt]
    8183 void srandom( unsigned int seed );§\indexc{srandom}§
    8184 char random( void );§\indexc{random}§
     8047void srandom( unsigned int seed );$\indexc{srandom}$
     8048char random( void );$\indexc{random}$
    81858049char random( char u ); §\C{// [0,u)}§
    81868050char random( char l, char u ); §\C{// [l,u]}§
    … …  
    82098073\leavevmode
    82108074\begin{cfa}[aboveskip=0pt,belowskip=0pt]
    8211 forall( T | { int ?<?( T, T ); } ) T min( T t1, T t2 );§\indexc{min}§
    8212 forall( T | { int ?>?( T, T ); } ) T max( T t1, T t2 );§\indexc{max}§
    8213 forall( T | { T min( T, T ); T max( T, T ); } ) T clamp( T value, T min_val, T max_val );§\indexc{clamp}§
    8214 forall( T ) void swap( T * t1, T * t2 );§\indexc{swap}§
     8075forall( T | { int ?<?( T, T ); } ) T min( T t1, T t2 );$\indexc{min}$
     8076forall( T | { int ?>?( T, T ); } ) T max( T t1, T t2 );$\indexc{max}$
     8077forall( T | { T min( T, T ); T max( T, T ); } ) T clamp( T value, T min_val, T max_val );$\indexc{clamp}$
     8078forall( T ) void swap( T * t1, T * t2 );$\indexc{swap}$
    82158079\end{cfa}
    82168080
    … …  
    82268090\leavevmode
    82278091\begin{cfa}[aboveskip=0pt,belowskip=0pt]
    8228 float ?%?( float, float );§\indexc{fmod}§
     8092float ?%?( float, float );$\indexc{fmod}$
    82298093float fmod( float, float );
    82308094double ?%?( double, double );
    … …  
    82338097long double fmod( long double, long double );
    82348098
    8235 float remainder( float, float );§\indexc{remainder}§
     8099float remainder( float, float );$\indexc{remainder}$
    82368100double remainder( double, double );
    82378101long double remainder( long double, long double );
    82388102
    8239 float remquo( float, float, int * );§\indexc{remquo}§
     8103float remquo( float, float, int * );$\indexc{remquo}$
    82408104double remquo( double, double, int * );
    82418105long double remquo( long double, long double, int * );
    … …  
    82488112[ int, long double ] div( long double, long double );
    82498113
    8250 float fma( float, float, float );§\indexc{fma}§
     8114float fma( float, float, float );$\indexc{fma}$
    82518115double fma( double, double, double );
    82528116long double fma( long double, long double, long double );
    82538117
    8254 float fdim( float, float );§\indexc{fdim}§
     8118float fdim( float, float );$\indexc{fdim}$
    82558119double fdim( double, double );
    82568120long double fdim( long double, long double );
    82578121
    8258 float nan( const char * );§\indexc{nan}§
     8122float nan( const char * );$\indexc{nan}$
    82598123double nan( const char * );
    82608124long double nan( const char * );
    … …  
    82668130\leavevmode
    82678131\begin{cfa}[aboveskip=0pt,belowskip=0pt]
    8268 float exp( float );§\indexc{exp}§
     8132float exp( float );$\indexc{exp}$
    82698133double exp( double );
    82708134long double exp( long double );
    … …  
    82738137long double _Complex exp( long double _Complex );
    82748138
    8275 float exp2( float );§\indexc{exp2}§
     8139float exp2( float );$\indexc{exp2}$
    82768140double exp2( double );
    82778141long double exp2( long double );
    … …  
    82808144// long double _Complex exp2( long double _Complex );
    82818145
    8282 float expm1( float );§\indexc{expm1}§
     8146float expm1( float );$\indexc{expm1}$
    82838147double expm1( double );
    82848148long double expm1( long double );
    82858149
    8286 float pow( float, float );§\indexc{pow}§
     8150float pow( float, float );$\indexc{pow}$
    82878151double pow( double, double );
    82888152long double pow( long double, long double );
    … …  
    82978161\leavevmode
    82988162\begin{cfa}[aboveskip=0pt,belowskip=0pt]
    8299 float log( float );§\indexc{log}§
     8163float log( float );$\indexc{log}$
    83008164double log( double );
    83018165long double log( long double );
    … …  
    83048168long double _Complex log( long double _Complex );
    83058169
    8306 int log2( unsigned int );§\indexc{log2}§
     8170int log2( unsigned int );$\indexc{log2}$
    83078171long int log2( unsigned long int );
    83088172long long int log2( unsigned long long int )
    … …  
    83148178// long double _Complex log2( long double _Complex );
    83158179
    8316 float log10( float );§\indexc{log10}§
     8180float log10( float );$\indexc{log10}$
    83178181double log10( double );
    83188182long double log10( long double );
    … …  
    83218185// long double _Complex log10( long double _Complex );
    83228186
    8323 float log1p( float );§\indexc{log1p}§
     8187float log1p( float );$\indexc{log1p}$
    83248188double log1p( double );
    83258189long double log1p( long double );
    83268190
    8327 int ilogb( float );§\indexc{ilogb}§
     8191int ilogb( float );$\indexc{ilogb}$
    83288192int ilogb( double );
    83298193int ilogb( long double );
    83308194
    8331 float logb( float );§\indexc{logb}§
     8195float logb( float );$\indexc{logb}$
    83328196double logb( double );
    83338197long double logb( long double );
    83348198
    8335 float sqrt( float );§\indexc{sqrt}§
     8199float sqrt( float );$\indexc{sqrt}$
    83368200double sqrt( double );
    83378201long double sqrt( long double );
    … …  
    83408204long double _Complex sqrt( long double _Complex );
    83418205
    8342 float cbrt( float );§\indexc{cbrt}§
     8206float cbrt( float );$\indexc{cbrt}$
    83438207double cbrt( double );
    83448208long double cbrt( long double );
    83458209
    8346 float hypot( float, float );§\indexc{hypot}§
     8210float hypot( float, float );$\indexc{hypot}$
    83478211double hypot( double, double );
    83488212long double hypot( long double, long double );
    … …  
    83548218\leavevmode
    83558219\begin{cfa}[aboveskip=0pt,belowskip=0pt]
    8356 float sin( float );§\indexc{sin}§
     8220float sin( float );$\indexc{sin}$
    83578221double sin( double );
    83588222long double sin( long double );
    … …  
    83618225long double _Complex sin( long double _Complex );
    83628226
    8363 float cos( float );§\indexc{cos}§
     8227float cos( float );$\indexc{cos}$
    83648228double cos( double );
    83658229long double cos( long double );
    … …  
    83688232long double _Complex cos( long double _Complex );
    83698233
    8370 float tan( float );§\indexc{tan}§
     8234float tan( float );$\indexc{tan}$
    83718235double tan( double );
    83728236long double tan( long double );
    … …  
    83758239long double _Complex tan( long double _Complex );
    83768240
    8377 float asin( float );§\indexc{asin}§
     8241float asin( float );$\indexc{asin}$
    83788242double asin( double );
    83798243long double asin( long double );
    … …  
    83828246long double _Complex asin( long double _Complex );
    83838247
    8384 float acos( float );§\indexc{acos}§
     8248float acos( float );$\indexc{acos}$
    83858249double acos( double );
    83868250long double acos( long double );
    … …  
    83898253long double _Complex acos( long double _Complex );
    83908254
    8391 float atan( float );§\indexc{atan}§
     8255float atan( float );$\indexc{atan}$
    83928256double atan( double );
    83938257long double atan( long double );
    … …  
    83968260long double _Complex atan( long double _Complex );
    83978261
    8398 float atan2( float, float );§\indexc{atan2}§
     8262float atan2( float, float );$\indexc{atan2}$
    83998263double atan2( double, double );
    84008264long double atan2( long double, long double );
    84018265
    84028266float atan( float, float ); §\C{// alternative name for atan2}§
    8403 double atan( double, double );§\indexc{atan}§
     8267double atan( double, double );$\indexc{atan}$
    84048268long double atan( long double, long double );
    84058269\end{cfa}
    … …  
    84108274\leavevmode
    84118275\begin{cfa}[aboveskip=0pt,belowskip=0pt]
    8412 float sinh( float );§\indexc{sinh}§
     8276float sinh( float );$\indexc{sinh}$
    84138277double sinh( double );
    84148278long double sinh( long double );
    … …  
    84178281long double _Complex sinh( long double _Complex );
    84188282
    8419 float cosh( float );§\indexc{cosh}§
     8283float cosh( float );$\indexc{cosh}$
    84208284double cosh( double );
    84218285long double cosh( long double );
    … …  
    84248288long double _Complex cosh( long double _Complex );
    84258289
    8426 float tanh( float );§\indexc{tanh}§
     8290float tanh( float );$\indexc{tanh}$
    84278291double tanh( double );
    84288292long double tanh( long double );
    … …  
    84318295long double _Complex tanh( long double _Complex );
    84328296
    8433 float asinh( float );§\indexc{asinh}§
     8297float asinh( float );$\indexc{asinh}$
    84348298double asinh( double );
    84358299long double asinh( long double );
    … …  
    84388302long double _Complex asinh( long double _Complex );
    84398303
    8440 float acosh( float );§\indexc{acosh}§
     8304float acosh( float );$\indexc{acosh}$
    84418305double acosh( double );
    84428306long double acosh( long double );
    … …  
    84458309long double _Complex acosh( long double _Complex );
    84468310
    8447 float atanh( float );§\indexc{atanh}§
     8311float atanh( float );$\indexc{atanh}$
    84488312double atanh( double );
    84498313long double atanh( long double );
    … …  
    84588322\leavevmode
    84598323\begin{cfa}[aboveskip=0pt,belowskip=0pt]
    8460 float erf( float );§\indexc{erf}§
     8324float erf( float );$\indexc{erf}$
    84618325double erf( double );
    84628326long double erf( long double );
    … …  
    84658329long double _Complex erf( long double _Complex );
    84668330
    8467 float erfc( float );§\indexc{erfc}§
     8331float erfc( float );$\indexc{erfc}$
    84688332double erfc( double );
    84698333long double erfc( long double );
    … …  
    84728336long double _Complex erfc( long double _Complex );
    84738337
    8474 float lgamma( float );§\indexc{lgamma}§
     8338float lgamma( float );$\indexc{lgamma}$
    84758339double lgamma( double );
    84768340long double lgamma( long double );
    … …  
    84798343long double lgamma( long double, int * );
    84808344
    8481 float tgamma( float );§\indexc{tgamma}§
     8345float tgamma( float );$\indexc{tgamma}$
    84828346double tgamma( double );
    84838347long double tgamma( long double );
    … …  
    85258389unsigned long long int ceiling( unsigned long long int n, unsigned long long int align );
    85268390
    8527 float floor( float );§\indexc{floor}§
     8391float floor( float );$\indexc{floor}$
    85288392double floor( double );
    85298393long double floor( long double );
    85308394
    8531 float ceil( float );§\indexc{ceil}§
     8395float ceil( float );$\indexc{ceil}$
    85328396double ceil( double );
    85338397long double ceil( long double );
    85348398
    8535 float trunc( float );§\indexc{trunc}§
     8399float trunc( float );$\indexc{trunc}$
    85368400double trunc( double );
    85378401long double trunc( long double );
    85388402
    8539 float rint( float );§\indexc{rint}§
     8403float rint( float );$\indexc{rint}$
    85408404long double rint( long double );
    85418405long int rint( float );
    … …  
    85468410long long int rint( long double );
    85478411
    8548 long int lrint( float );§\indexc{lrint}§
     8412long int lrint( float );$\indexc{lrint}$
    85498413long int lrint( double );
    85508414long int lrint( long double );
    … …  
    85538417long long int llrint( long double );
    85548418
    8555 float nearbyint( float );§\indexc{nearbyint}§
     8419float nearbyint( float );$\indexc{nearbyint}$
    85568420double nearbyint( double );
    85578421long double nearbyint( long double );
    85588422
    8559 float round( float );§\indexc{round}§
     8423float round( float );$\indexc{round}$
    85608424long double round( long double );
    85618425long int round( float );
    … …  
    85668430long long int round( long double );
    85678431
    8568 long int lround( float );§\indexc{lround}§
     8432long int lround( float );$\indexc{lround}$
    85698433long int lround( double );
    85708434long int lround( long double );
    … …  
    85798443\leavevmode
    85808444\begin{cfa}[aboveskip=0pt,belowskip=0pt]
    8581 float copysign( float, float );§\indexc{copysign}§
     8445float copysign( float, float );$\indexc{copysign}$
    85828446double copysign( double, double );
    85838447long double copysign( long double, long double );
    85848448
    8585 float frexp( float, int * );§\indexc{frexp}§
     8449float frexp( float, int * );$\indexc{frexp}$
    85868450double frexp( double, int * );
    85878451long double frexp( long double, int * );
    85888452
    8589 float ldexp( float, int );§\indexc{ldexp}§
     8453float ldexp( float, int );$\indexc{ldexp}$
    85908454double ldexp( double, int );
    85918455long double ldexp( long double, int );
    85928456
    8593 [ float, float ] modf( float );§\indexc{modf}§
     8457[ float, float ] modf( float );$\indexc{modf}$
    85948458float modf( float, float * );
    85958459[ double, double ] modf( double );
    … …  
    85988462long double modf( long double, long double * );
    85998463
    8600 float nextafter( float, float );§\indexc{nextafter}§
     8464float nextafter( float, float );$\indexc{nextafter}$
    86018465double nextafter( double, double );
    86028466long double nextafter( long double, long double );
    86038467
    8604 float nexttoward( float, long double );§\indexc{nexttoward}§
     8468float nexttoward( float, long double );$\indexc{nexttoward}$
    86058469double nexttoward( double, long double );
    86068470long double nexttoward( long double, long double );
    86078471
    8608 float scalbn( float, int );§\indexc{scalbn}§
     8472float scalbn( float, int );$\indexc{scalbn}$
    86098473double scalbn( double, int );
    86108474long double scalbn( long double, int );
    86118475
    8612 float scalbln( float, long int );§\indexc{scalbln}§
     8476float scalbln( float, long int );$\indexc{scalbln}$
    86138477double scalbln( double, long int );
    86148478long double scalbln( long double, long int );
    … …  
    88708734All \newterm{pseudo random-number generators} (\newterm{PRNG}) involve some technique to scramble bits of a value, \eg multiplicative recurrence:
    88718735\begin{cfa}
    8872 rand = 33967 * (rand + 1063); // scramble bits
     8736rand = 36973 * (rand & 65535) + (rand >> 16); // scramble bits
    88738737\end{cfa}
    88748738Multiplication of large values adds new least-significant bits and drops most-significant bits.
    … …  
    88778741bits 63--32 (most)      & bits 31--0 (least)    \\
    88788742\hline
    8879 ©0x0©                           & ©0x3e8e36©                    \\
    8880 ©0x5f©                          & ©0x718c25e1©                  \\
    8881 ©0xad3e©                        & ©0x7b5f1dbe©                  \\
    8882 ©0xbc3b©                        & ©0xac69ff19©                  \\
    8883 ©0x1070f©                       & ©0x2d258dc6©
     87430x0                                     & 0x3e8e36                              \\
     87440x5f                            & 0x718c25e1                    \\
     87450xad3e                          & 0x7b5f1dbe                    \\
     87460xbc3b                          & 0xac69ff19                    \\
     87470x1070f                         & 0x2d258dc6                    \\
    88848748\end{tabular}
    88858749\end{quote}
    … …  
    88878751The 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).
    88888752Hence, if a program uses the same seed, the same sequence of pseudo-random values is generated from the PRNG.
    8889 Often the seed is set to another random value like a program's process identifier (\Indexc{getpid}) or time when the program is run;
     8753Often 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;
    88908754hence, one random value bootstraps another.
    88918755Finally, 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.
    88928756
    8893 \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.
    8894 To use the PRNG interface \Textbf{requires including \Indexc{stdlib.hfa}}.
     8757\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.
    88958758\begin{itemize}
    88968759\item
    8897 The ©PRNG© types for sequential programs, including coroutining, are:
    8898 \begin{cfa}
    8899 struct PRNG32 {};                                               §\C{// opaque type, no copy or assignment}§
    8900 void ?{}( PRNG32 & prng, uint32_t seed ); §\C{// fixed seed}§
    8901 void ?{}( PRNG32 & prng );                              §\C{// random seed}§
    8902 void set_seed( PRNG32 & prng, uint32_t seed ); §\C{// set seed}§
    8903 uint32_t get_seed( PRNG32 & prng );             §\C{// get seed}§
    8904 uint32_t prng( PRNG32 & prng );                 §\C{// [0,UINT\_MAX]}§
    8905 uint32_t prng( PRNG32 & prng, uint32_t u ); §\C{// [0,u)}§
    8906 uint32_t prng( PRNG32 & prng, uint32_t l, uint32_t u ); §\C{// [l,u]}§
    8907 uint32_t calls( PRNG32 & prng );                §\C{// number of calls}§
    8908 void copy( PRNG32 & dst, PRNG32 & src ); §\C{// checkpoint PRNG state}§
    8909 \end{cfa}
    8910 \begin{cfa}
    8911 struct PRNG64 {};                                               §\C{// opaque type, no copy or assignment}§
    8912 void ?{}( PRNG64 & prng, uint64_t seed ); §\C{// fixed seed}§
    8913 void ?{}( PRNG64 & prng );                              §\C{// random seed}§
    8914 void set_seed( PRNG64 & prng, uint64_t seed ); §\C{// set seed}§
    8915 uint64_t get_seed( PRNG64 & prng );             §\C{// get seed}§
    8916 uint64_t prng( PRNG64 & prng );                 §\C{// [0,UINT\_MAX]}§
    8917 uint64_t prng( PRNG64 & prng, uint64_t u ); §\C{// [0,u)}§
    8918 uint64_t prng( PRNG64 & prng, uint64_t l, uint64_t u ); §\C{// [l,u]}§
    8919 uint64_t calls( PRNG64 & prng );                §\C{// number of calls}§
    8920 void copy( PRNG64 & dst, PRNG64 & src ); §\C{// checkpoint PRNG state}§
    8921 \end{cfa}
    8922 The type ©PRNG© is aliased to ©PRNG64© on 64-bit architectures and ©PRNG32© on 32-bit architectures.
     8760The ©PRNG© type is for sequential programs, like coroutining:
     8761\begin{cfa}
     8762struct PRNG { ... }; $\C[3.75in]{// opaque type}$
     8763void ?{}( PRNG & prng ); §\C{// random seed}§
     8764void ?{}( PRNG & prng, uint32_t seed ); §\C{// fixed seed}§
     8765void set_seed( PRNG & prng, uint32_t seed ); §\C{// set seed}§
     8766uint32_t get_seed( PRNG & prng ); §\C{// get seed}§
     8767uint32_t prng( PRNG & prng ); §\C{// [0,UINT\_MAX]}§
     8768uint32_t prng( PRNG & prng, uint32_t u ); §\C{// [0,u)}§
     8769uint32_t prng( PRNG & prng, uint32_t l, uint32_t u ); §\C{// [l,u]}§
     8770uint32_t calls( PRNG & prng ); §\C{// number of calls}\CRT§
     8771\end{cfa}
    89238772A ©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.
    89248773In this scenario, it is useful to have multiple ©PRNG© objects, \eg one per player or object.
    8925 However, sequential execution is still repeatable given the same starting seeds for all ©PRNG©s.
     8774However, sequential execution is still repeatable given the same starting seeds for all ©PRNG©s. 
    89268775\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.
    8927 Note, to prevent accidental PRNG copying, the copy constructor and assignment are hidden.
    8928 To copy a PRNG for checkpointing, use the explicit ©copy© member.
    89298776
    89308777\begin{figure}
    89318778\begin{cfa}
    8932 PRNG sprng1, sprng2;                                    §\C{// select appropriate 32/64-bit PRNG}§
    8933 ®set_seed( sprng1, 1009 )®;   ®set_seed( sprng2, 1009 )®;
     8779PRNG prng1, prng2;
     8780®set_seed( prng1, 1009 )®;   ®set_seed( prng2, 1009 )®;
    89348781for ( 10 ) {
    89358782        // Do not cascade prng calls because side-effect functions called in arbitrary order.
    8936         sout | nlOff | ®prng( sprng1 )®;  sout | ®prng( sprng1, 5 )®;  sout | ®prng( sprng1, 0, 5 )® | '\t';
    8937         sout | ®prng( sprng2 )®;  sout | ®prng( sprng2, 5 )®;  sout | ®prng( sprng2, 0, 5 )® | nlOn;
     8783        sout | nlOff | ®prng( prng1 )®;  sout | ®prng( prng1, 5 )®;  sout | ®prng( prng1, 0, 5 )® | '\t';
     8784        sout | ®prng( prng2 )®;  sout | ®prng( prng2, 5 )®;  sout | ®prng( prng2, 0, 5 )® | nlOn;
    89388785}
    89398786\end{cfa}
    … …  
    89748821The PRNG global and companion thread functions are for concurrent programming, such as randomizing execution in short-running programs, \eg ©yield( prng() % 5 )©.
    89758822\begin{cfa}
    8976 void set_seed( size_t seed );                   §\C{// set global seed}§
    8977 size_t get_seed();                                              §\C{// get global seed}§
    8978 // SLOWER, global routines
    8979 size_t prng( void );                                    §\C{// [0,UINT\_MAX]}§
    8980 size_t prng( size_t u );                                §\C{// [0,u)}§
    8981 size_t prng( size_t l, size_t u );              §\C{// [l,u]}§
    8982 // FASTER, thread members
    8983 size_t prng( §thread\LstStringStyle{\textdollar}§ & th );       §\C{// [0,UINT\_MAX]}§
    8984 size_t prng( §thread\LstStringStyle{\textdollar}§ & th, size_t u );     §\C{// [0,u)}§
    8985 size_t prng( §thread\LstStringStyle{\textdollar}§ & th, size_t l, size_t u );   §\C{// [l,u]}§
     8823void set_seed( uint32_t seed ); $\C[3.75in]{// set global seed}$
     8824uint32_t get_seed(); §\C{// get global seed}§
     8825// SLOWER
     8826uint32_t prng(); §\C{// [0,UINT\_MAX]}§
     8827uint32_t prng( uint32_t u ); §\C{// [0,u)}§
     8828uint32_t prng( uint32_t l, uint32_t u ); §\C{// [l,u]}§
     8829// FASTER
     8830uint32_t prng( $thread\LstStringStyle{\textdollar}$ & th );     §\C{// [0,UINT\_MAX]}§
     8831uint32_t prng( $thread\LstStringStyle{\textdollar}$ & th, uint32_t u ); §\C{// [0,u)}§
     8832uint32_t prng( $thread\LstStringStyle{\textdollar}$ & th, uint32_t l, uint32_t u );     §\C{// [l,u]}\CRT§
    89868833\end{cfa}
    89878834The only difference between the two sets of ©prng© routines is performance.
    … …  
    89948841Hence, these threads generate different sequences of random numbers.
    89958842If each thread needs its own seed, use a sequential ©PRNG© in each thread.
    8996 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.
     8843The 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.
    89978844If 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.
    89988845\VRef[Figure]{f:ConcurrentPRNG} shows an example using the slower/faster concurrent PRNG in the program main and a thread.
    … …  
    90098856int main() {
    90108857        set_seed( 1009 );
    9011         §\R{thread\LstStringStyle{\textdollar}}§ ®& th = *active_thread()®;  // program-main thread-address
     8858        $\R{thread\LstStringStyle{\textdollar}}$ ®& th = *active_thread()®;  // program-main thread-address
    90128859        for ( i; 10 ) {
    90138860                sout | nlOff | ®prng()®; sout | ®prng( 5 )®; sout | ®prng( 0, 5 )® | '\t';  // SLOWER
    … …  
    92329079\hline
    92339080\begin{cfa}
    9234 #include <gmp.h>§\indexc{gmp.h}§
     9081#include <gmp.h>$\indexc{gmp.h}$
    92359082int main( void ) {
    92369083        ®gmp_printf®( "Factorial Numbers\n" );
    … …  
    92469093&
    92479094\begin{cfa}
    9248 #include <gmp.hfa>§\indexc{gmp}§
     9095#include <gmp.hfa>$\indexc{gmp}$
    92499096int main( void ) {
    92509097        sout | "Factorial Numbers";
    … …  
    93189165\begin{cfa}[belowskip=0pt]
    93199166// implementation
    9320 struct Rational {§\indexc{Rational}§
     9167struct Rational {$\indexc{Rational}$
    93219168        long int numerator, denominator; §\C{// invariant: denominator > 0}§
    93229169}; // Rational

  • libcfa/src/collections/string_res.cfa

    r32490deb rc75b30a  
    1010// Created On       : Fri Sep 03 11:00:00 2021
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Jan 22 23:12:42 2024
    13 // Update Count     : 43
     12// Last Modified On : Tue Jan 16 22:19:27 2024
     13// Update Count     : 35
    1414//
    1515
    … …  
    263263        bool cont = false;
    264264
    265         _Istream_Cwidth cf = { cstr, (_Istream_str_base)f };
     265        _Istream_Cstr cf = { cstr, (_Istream_str_base)f };
    266266        if ( ! cf.flags.rwd ) cf.wd = wd;
    267267

  • libcfa/src/fstream.cfa

    r32490deb rc75b30a  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Jan 28 09:56:08 2024
    13 // Update Count     : 554
     12// Last Modified On : Wed Nov 15 10:51:14 2023
     13// Update Count     : 552
    1414//
    1515
    … …  
    209209void ?{}( ifstream & is, void * file ) with( is ) {
    210210        file$ = file;
    211         nlOnOff$ = false;                                                                       // => skip newlines when reading single characters
     211        nlOnOff$ = false;
    212212} // ?{}
    213213

  • libcfa/src/iostream.cfa

    r32490deb rc75b30a  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Jan 28 11:58:54 2024
    13 // Update Count     : 1917
     12// Last Modified On : Wed Jan  3 10:53:13 2024
     13// Update Count     : 1898
    1414//
    1515
    … …  
    944944        istype & nl( istype & is ) {
    945945                fmt( is, "%*[^\n]" );                                                   // ignore characters to newline
    946                 if ( ! eof( is ) ) fmt( is, "%*c" );                    // read newline
     946                if ( ! eof( is ) && getANL$( is ) ) fmt( is, "%*c" ); // read newline
    947947                return is;
    948948        } // nl
    … …  
    984984        }
    985985
    986         istype & ?|?( istype & is, _Istream_Cquoted f ) with( f.cstr ) {
     986        istype & ?|?( istype & is, _Istream_Cquoted f ) with( f ) {
     987                char fmtstr[32];                                                                // storage scanset and format codes
     988                fmtstr[0] = '%';
     989
     990                int pos = 1;
    987991                int args;
    988           fini: {
     992                bool check = true;
     993
     994                if ( cstr.flags.ignore ) { check = false; fmtstr[1] = '*'; pos += 1; }
     995                int rwd = cstr.wd;
     996                if ( cstr.wd != -1 ) {                                          // => just ignore versus ignore with width
     997                        // wd is buffer bytes available (for input chars + null terminator)
     998                        // rwd is count of input chars
     999                        // no maximum width necessary because text ignored => width is read width
     1000                        if ( cstr.flags.rwd ) check = false;
     1001                        else rwd = cstr.wd - 1;
     1002                        pos += sprintf( &fmtstr[pos], "%d", rwd );
     1003                } // if
     1004
     1005                int len = 0;                                                                    // may not be set in fmt
     1006                char enddelim;
     1007                if ( ! cstr.flags.inex ) {                                              // => quoted getline
    9891008                        args = fmt( is, "%*[ \f\n\r\t\v]" );            // remove leading whitespace
    990                         if ( eof( is ) ) break fini;
    991                         char rfmt[4] = { delimiters[0], '%', 'n', '\0' };
    992                         int len = 0;                                                            // may not be set in fmt
     1009                        if ( eof( is ) ) goto Eof;
     1010                        char rfmt[4] = { cstr.delimiters[0], '%', 'n', '\0' };
    9931011                        args = fmt( is, rfmt, &len );                           // remove leading quote
    994                         if ( len == 0 || eof( is ) ) break fini;
    995 
    996                         // Change the remainder of the read into a getline by reseting the closing delimiter.
    997                         if ( delimiters[1] != '\0' ) {
    998                                 delimiters[0] = delimiters[1];
    999                                 delimiters[1] = '\0';
     1012                        if ( len == 0 || eof( is ) ) goto Eof;
     1013                } // if
     1014                enddelim = cstr.delimiters[1] == '\0' ? cstr.delimiters[0] : cstr.delimiters[1];
     1015                sprintf( &fmtstr[pos], "[^%c]%%n", enddelim );
     1016                if ( cstr.flags.ignore ) args = fmt( is, fmtstr, &len ); // no string argument for '*'
     1017                else args = fmt( is, fmtstr, cstr.s, &len );
     1018                if ( check && len == rwd && ! eof( is ) ) {             // might not fit
     1019                        char peek;
     1020                        fmt( is, "%c", &peek );                                         // check for delimiter
     1021                        if ( ! eof( is ) ) {
     1022                                if ( peek != enddelim ) {
     1023                                        ungetc( is, peek );
     1024                                        throwResume ExceptionInst( cstring_length );
     1025                                } // if
    10001026                        } // if
    1001                         flags.delimiter = true;
    1002                         return is | *(_Istream_Cstr *)&f;
    1003                 } // fini
    1004                 // read failed => no pattern match => set string to null
    1005                 if ( ! flags.ignore && s != 0p && args == 0 ) s[0] = '\0';
     1027                } else fmt( is, "%*c" );                                                // remove delimiter
     1028          Eof: ;
     1029                if ( rwd > 0 && args == 0 ) cstr.s[0] = '\0';   // read failed => no pattern match => set string to null
    10061030                if ( args == 1 && eof( is ) ) {                                 // data but scan ended at EOF
    10071031                        clear( is );                                                            // => reset EOF => detect again on next read
    … …  
    10101034        }
    10111035
    1012         istype & ?|?( istype & is, _Istream_Cstr f ) with( f.cstr ) {
     1036        istype & ?|?( istype & is, _Istream_Cstr f ) with( f ) {
    10131037                const char * scanset;
    10141038                size_t nscanset = 0;
    10151039                if ( flags.delimiter ) scanset = delimiters;    // getline ?
    1016                 else scanset = f.cstr.scanset;
     1040                else scanset = f.scanset;
    10171041                if ( scanset ) nscanset = strlen( scanset );
    10181042
    10191043                char fmtstr[nscanset + 32];                                             // storage for scanset and format codes
    10201044                fmtstr[0] = '%';
     1045
    10211046                int pos = 1;
    10221047                int args;
    10231048                bool check = true;
    10241049
    1025                 if ( flags.ignore ) { check = false; fmtstr[1] = '*'; pos += 1; }
    1026                 int rwd = wd;
    1027                 if ( wd != -1 ) {                                                               // => just ignore versus ignore with width
     1050                if ( f.flags.ignore ) { check = false; fmtstr[1] = '*'; pos += 1; }
     1051                int rwd = f.wd;
     1052                if ( f.wd != -1 ) {                                                             // => just ignore versus ignore with width
    10281053                        // wd is buffer bytes available (for input chars + null terminator)
    10291054                        // rwd is count of input chars
    10301055                        // no maximum width necessary because text ignored => width is read width
    1031                         if ( flags.rwd ) check = false;
    1032                         else rwd = wd - 1;
    1033                         assert( rwd > 0 );
     1056                        if ( f.flags.rwd ) check = false;
     1057                        else rwd = f.wd - 1;
    10341058                        pos += sprintf( &fmtstr[pos], "%d", rwd );
    10351059                } // if
    10361060
    10371061                if ( ! scanset ) {                                                              // %s, %*s, %ws, %*ws
    1038                         // fprintf( stderr, "cstr %s\n", s );
     1062                        // fprintf( stderr, "cstr %s\n", f.s );
    10391063                        strcpy( &fmtstr[pos], "s%n" );
    10401064                        int len = 0;                                                            // may not be set in fmt
    1041                         if ( flags.ignore ) args = fmt( is, fmtstr, &len ); // no string argument for '*'
    1042                         else args = fmt( is, fmtstr, s, &len );
    1043                         // fprintf( stderr, "cstr %s %d %d %d %s\n", fmtstr, args, len, wd, s );
     1065                        if ( f.flags.ignore ) args = fmt( is, fmtstr, &len ); // no string argument for '*'
     1066                        else args = fmt( is, fmtstr, f.s, &len );
     1067                        // fprintf( stderr, "cstr %s %d %d %d %s\n", fmtstr, args, len, f.wd, f.s );
    10441068                        if ( check && len >= rwd && ! eof( is ) ) {     // might not fit
    10451069                                char peek;
    … …  
    10521076                        } // if
    10531077                        // FIX ME: CFA strings need to be modified to NOT change the argument for this case, then this can be removed.
    1054                         if ( ! flags.ignore && args == 0 ) s[0]= '\0'; // read failed => no pattern match => set string to null
     1078                        if ( rwd > 0 && args == 0 ) f.s[0]= '\0';       // read failed => no pattern match => set string to null
    10551079                } else {
    1056                         if ( flags.delimiter ) {                                        // getline
     1080                        if ( f.flags.delimiter ) {                                      // getline
    10571081                                int len = 0;                                                    // may not be set in fmt
    1058                                 if ( delimiters[2] != '\0' ) {                  // read single character ?
    1059                                         sprintf( &fmtstr[pos], "c%%n" );
    1060                                 } else {
    1061                                         sprintf( &fmtstr[pos], "[^%c]%%n", delimiters[0] );
    1062                                 } // if
    1063                                 if ( flags.ignore ) args = fmt( is, fmtstr, &len ); // no string argument for '*'
    1064                                 else args = fmt( is, fmtstr, s, &len );
     1082                                sprintf( &fmtstr[pos], "[^%c]%%n", f.delimiters[0] );
     1083                                if ( f.flags.ignore ) args = fmt( is, fmtstr, &len ); // no string argument for '*'
     1084                                else args = fmt( is, fmtstr, f.s, &len );
    10651085                                if ( check && len == rwd && ! eof( is ) ) {     // might not fit
    1066                                         char peek;
    1067                                         fmt( is, "%c", &peek );                         // check for delimiter
     1086                                        fmtstr[0] = f.delimiters[0]; fmtstr[1] = '%'; fmtstr[2] = 'n'; fmtstr[3] = '\0';
     1087                                        fmt( is, fmtstr, &len );                        // remove delimiter
    10681088                                        if ( ! eof( is ) ) {
    1069                                                 if ( peek != delimiters[0] ) {
    1070                                                         ungetc( is, peek );
     1089//                                              if ( peek != f.delimiter[0] ) {
     1090                                                if ( len != 1 ) {
     1091//                                                      ungetc( is, peek );
    10711092                                                        throwResume ExceptionInst( cstring_length );
    10721093                                                } // if
    … …  
    10761097                                // incl %[xxx],  %*[xxx],  %w[xxx],  %*w[xxx]
    10771098                                // excl %[^xxx], %*[^xxx], %w[^xxx], %*w[^xxx]
    1078                                 sprintf( &fmtstr[pos], "[%s%s]%%n", flags.inex ? "^" : "", scanset );
    1079                                 // fprintf( stderr, "incl/excl %s %d\n", fmtstr, wd );
     1099                                sprintf( &fmtstr[pos], "[%s%s]%%n", f.flags.inex ? "^" : "", scanset );
     1100                                // fprintf( stderr, "incl/excl %s %d\n", fmtstr, f.wd );
    10801101                                int len = 0;                                                    // may not be set in fmt
    1081                                 if ( flags.ignore ) args = fmt( is, fmtstr, &len ); // no string argument for '*'
    1082                                 else args = fmt( is, fmtstr, s, &len );
    1083                                 // fprintf( stderr, "incl/excl %s \"%s\" %d %d %d %d %d %c\n", fmtstr, s, args, wd, len, eof( is ), check, s[wd] );
     1102                                if ( f.flags.ignore ) args = fmt( is, fmtstr, &len ); // no string argument for '*'
     1103                                else args = fmt( is, fmtstr, f.s, &len );
     1104                                // 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] );
    10841105                                if ( check && len == rwd && ! eof( is ) ) {     // might not fit
    10851106                                        // fprintf( stderr, "overflow\n" );
    … …  
    10891110                                        if ( ! eof( is ) ) {
    10901111                                                ungetc( is, peek );
    1091                                                 if ( flags.inex ^ strchr( scanset, peek ) != 0p ) throwResume ExceptionInst( cstring_length );
     1112                                                if ( f.flags.inex ^ strchr( f.scanset, peek ) != 0p ) throwResume ExceptionInst( cstring_length );
    10921113                                        } // if
    10931114                                } // if
    10941115                        } // if
    1095                         if ( ! flags.ignore && args == 0 ) s[0]= '\0'; // read failed => no pattern match => set string to null
     1116                        if ( rwd > 0 && args == 0 ) f.s[0]= '\0';       // read failed => no pattern match => set string to null
    10961117                } // if
    10971118                if ( args == 1 && eof( is ) ) {                                 // data but scan ended at EOF
    … …  
    10991120                        clear( is );                                                            // => reset EOF => detect again on next read
    11001121                } // if
     1122                return is;
     1123        } // ?|?
     1124
     1125        istype & ?|?( istype & is, _Istream_Char f ) {
     1126                fmt( is, "%*c" );                                                               // argument variable unused
    11011127                return is;
    11021128        } // ?|?
    … …  
    11191145} // distribution
    11201146
    1121 INPUT_FMT_IMPL( char, "c" )
    11221147INPUT_FMT_IMPL( signed char, "hhi" )
    11231148INPUT_FMT_IMPL( unsigned char, "hhi" )

  • libcfa/src/iostream.hfa

    r32490deb rc75b30a  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Jan 28 11:56:29 2024
    13 // Update Count     : 733
     12// Last Modified On : Wed Jan  3 10:53:18 2024
     13// Update Count     : 610
    1414//
    1515
    … …  
    196196// *********************************** integral ***********************************
    197197
     198// See 6.7.9. 19) The initialization shall occur in initializer list order, each initializer provided for a particular
     199// subobject overriding any previously listed initializer for the same subobject; ***all subobjects that are not
     200// initialized explicitly shall be initialized implicitly the same as objects that have static storage duration.***
     201
    198202#define INTEGRAL_FMT_DECL( T, CODE ) \
    199203static inline { \
    200         _Ostream_Manip(T) bin( T val ) { return (_Ostream_Manip(T))@{ .val : val, .wd : 1, .pc : 0, .base : 'b', { .all : 0 } }; } \
    201         _Ostream_Manip(T) oct( T val ) { return (_Ostream_Manip(T))@{ .val : val, .wd : 1, .pc : 0, .base : 'o', { .all : 0 } }; } \
    202         _Ostream_Manip(T) hex( T val ) { return (_Ostream_Manip(T))@{ .val : val, .wd : 1, .pc : 0, .base : 'x', { .all : 0 } }; } \
    203         _Ostream_Manip(T) wd( unsigned int wd, T val ) { return (_Ostream_Manip(T))@{ .val : val, .wd : wd, .pc : 0, .base : CODE, { .all : 0 } }; } \
    204         _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 } }; } \
    205         _Ostream_Manip(T) & wd( unsigned int wd, _Ostream_Manip(T) & fmt ) { fmt.wd = wd; return fmt; } \
    206         _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; } \
     204        _Ostream_Manip(T) bin( T val ) { return (_Ostream_Manip(T))@{ val, 1, 0, 'b', { .all : 0 } }; } \
     205        _Ostream_Manip(T) oct( T val ) { return (_Ostream_Manip(T))@{ val, 1, 0, 'o', { .all : 0 } }; } \
     206        _Ostream_Manip(T) hex( T val ) { return (_Ostream_Manip(T))@{ val, 1, 0, 'x', { .all : 0 } }; } \
     207        _Ostream_Manip(T) wd( unsigned int w, T val ) { return (_Ostream_Manip(T))@{ val, w, 0, CODE, { .all : 0 } }; } \
     208        _Ostream_Manip(T) wd( unsigned int w, unsigned int pc, T val ) { return (_Ostream_Manip(T))@{ val, w, pc, CODE, { .flags.pc : true } }; } \
     209        _Ostream_Manip(T) & wd( unsigned int w, _Ostream_Manip(T) & fmt ) { fmt.wd = w; return fmt; } \
     210        _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; } \
    207211        _Ostream_Manip(T) & left( _Ostream_Manip(T) & fmt ) { fmt.flags.left = true; return fmt; } \
    208212        _Ostream_Manip(T) & upcase( _Ostream_Manip(T) & fmt ) { if ( fmt.base == 'x' || fmt.base == 'b' ) fmt.base -= 32; /* upper case */ return fmt; } \
    209213        _Ostream_Manip(T) & nobase( _Ostream_Manip(T) & fmt ) { fmt.flags.nobsdp = true; return fmt; } \
    210214        _Ostream_Manip(T) & pad0( _Ostream_Manip(T) & fmt ) { fmt.flags.pad0 = true; return fmt; } \
    211         _Ostream_Manip(T) sign( T val ) { return (_Ostream_Manip(T))@{ .val : val, .wd : 1, .pc : 0, .base : CODE, { .flags.sign : true } }; } \
     215        _Ostream_Manip(T) sign( T val ) { return (_Ostream_Manip(T))@{ val, 1, 0, CODE, { .flags.sign : true } }; } \
    212216        _Ostream_Manip(T) & sign( _Ostream_Manip(T) & fmt ) { fmt.flags.sign = true; return fmt; } \
    213217} /* distribution */ \
    … …  
    237241#define FLOATING_POINT_FMT_DECL( T ) \
    238242static inline { \
    239         _Ostream_Manip(T) hex( T val ) { return (_Ostream_Manip(T))@{ .val : val, .wd : 1, .pc : 0, .base : 'a', { .all : 0 } }; } \
    240         _Ostream_Manip(T) sci( T val ) { return (_Ostream_Manip(T))@{ .val : val, .wd : 1, .pc : 0, .base : 'e', { .all : 0 } }; } \
    241         _Ostream_Manip(T) eng( T val ) { return (_Ostream_Manip(T))@{ .val : val, 1, -1, .base : 'g', { .flags.eng : true } }; } \
    242         _Ostream_Manip(T) wd( unsigned int wd, T val ) { return (_Ostream_Manip(T))@{ .val : val, .wd : wd, .pc : 0, .base : 'g', { .all : 0 } }; } \
    243         _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 } }; } \
    244         _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 } }; } \
    245         _Ostream_Manip(T) & wd( unsigned int wd, _Ostream_Manip(T) & fmt ) { if ( fmt.flags.eng ) fmt.base = 'f'; fmt.wd = wd; return fmt; } \
    246         _Ostream_Manip(T) & wd( unsigned int wd, unsigned int pc, _Ostream_Manip(T) & fmt ) { \
    247                 if ( fmt.flags.eng ) fmt.base = 'f'; fmt.wd = wd; fmt.pc = pc; fmt.flags.pc = true; return fmt; } \
    248         _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; } \
     243        _Ostream_Manip(T) hex( T val ) { return (_Ostream_Manip(T))@{ val, 1, 0, 'a', { .all : 0 } }; } \
     244        _Ostream_Manip(T) sci( T val ) { return (_Ostream_Manip(T))@{ val, 1, 0, 'e', { .all : 0 } }; } \
     245        _Ostream_Manip(T) eng( T val ) { return (_Ostream_Manip(T))@{ val, 1, -1, 'g', { .flags.eng : true } }; } \
     246        _Ostream_Manip(T) wd( unsigned int w, T val ) { return (_Ostream_Manip(T))@{ val, w, 0, 'g', { .all : 0 } }; } \
     247        _Ostream_Manip(T) wd( unsigned int w, unsigned int pc, T val ) { return (_Ostream_Manip(T))@{ val, w, pc, 'f', { .flags.pc : true } }; } \
     248        _Ostream_Manip(T) ws( unsigned int w, unsigned int pc, T val ) { return (_Ostream_Manip(T))@{ val, w, pc, 'g', { .flags.pc : true } }; } \
     249        _Ostream_Manip(T) & wd( unsigned int w, _Ostream_Manip(T) & fmt ) { if ( fmt.flags.eng ) fmt.base = 'f'; fmt.wd = w; return fmt; } \
     250        _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; } \
     251        _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; } \
    249252        _Ostream_Manip(T) & left( _Ostream_Manip(T) & fmt ) { fmt.flags.left = true; return fmt; } \
    250         _Ostream_Manip(T) upcase( T val ) { return (_Ostream_Manip(T))@{ .val : val, .wd : 1, .pc : 0, .base : 'G', { .all : 0 } }; } \
     253        _Ostream_Manip(T) upcase( T val ) { return (_Ostream_Manip(T))@{ val, 1, 0, 'G', { .all : 0 } }; } \
    251254        _Ostream_Manip(T) & upcase( _Ostream_Manip(T) & fmt ) { fmt.base -= 32; /* upper case */ return fmt; } \
    252255        _Ostream_Manip(T) & pad0( _Ostream_Manip(T) & fmt ) { fmt.flags.pad0 = true; return fmt; } \
    253         _Ostream_Manip(T) sign( T val ) { return (_Ostream_Manip(T))@{ .val : val, .wd : 1, .pc : 0, .base : 'g', { .flags.sign : true } }; } \
     256        _Ostream_Manip(T) sign( T val ) { return (_Ostream_Manip(T))@{ val, 1, 0, 'g', { .flags.sign : true } }; } \
    254257        _Ostream_Manip(T) & sign( _Ostream_Manip(T) & fmt ) { fmt.flags.sign = true; return fmt; } \
    255         _Ostream_Manip(T) nodp( T val ) { return (_Ostream_Manip(T))@{ .val : val, .wd : 1, .pc : 0, .base : 'g', { .flags.nobsdp : true } }; } \
     258        _Ostream_Manip(T) nodp( T val ) { return (_Ostream_Manip(T))@{ val, 1, 0, 'g', { .flags.nobsdp : true } }; } \
    256259        _Ostream_Manip(T) & nodp( _Ostream_Manip(T) & fmt ) { fmt.flags.nobsdp = true; return fmt; } \
    257         _Ostream_Manip(T) unit( T val ) { return (_Ostream_Manip(T))@{ .val : val, .wd : 1, .pc : 0, .base : 'g', { .flags.nobsdp : true } }; } \
     260        _Ostream_Manip(T) unit( T val ) { return (_Ostream_Manip(T))@{ val, 1, 0, 'g', { .flags.nobsdp : true } }; } \
    258261        _Ostream_Manip(T) & unit( _Ostream_Manip(T) & fmt ) { fmt.flags.nobsdp = true; return fmt; } \
    259262} /* distribution */ \
    … …  
    269272
    270273static inline {
    271         _Ostream_Manip(char) bin( char c ) { return (_Ostream_Manip(char))@{ .val : c, .wd : 1, .pc : 0, .base : 'b', { .all : 0 } }; }
    272         _Ostream_Manip(char) oct( char c ) { return (_Ostream_Manip(char))@{ .val : c, .wd : 1, .pc : 0, .base : 'o', { .all : 0 } }; }
    273         _Ostream_Manip(char) hex( char c ) { return (_Ostream_Manip(char))@{ .val : c, .wd : 1, .pc : 0, .base : 'x', { .all : 0 } }; }
    274         _Ostream_Manip(char) wd( unsigned int wd, char c ) { return (_Ostream_Manip(char))@{ c, wd, 0, .base : 'c', { .all : 0 } }; }
    275         _Ostream_Manip(char) & wd( unsigned int wd, _Ostream_Manip(char) & fmt ) { fmt.wd = wd; return fmt; }
     274        _Ostream_Manip(char) bin( char c ) { return (_Ostream_Manip(char))@{ c, 1, 0, 'b', { .all : 0 } }; }
     275        _Ostream_Manip(char) oct( char c ) { return (_Ostream_Manip(char))@{ c, 1, 0, 'o', { .all : 0 } }; }
     276        _Ostream_Manip(char) hex( char c ) { return (_Ostream_Manip(char))@{ c, 1, 0, 'x', { .all : 0 } }; }
     277        _Ostream_Manip(char) wd( unsigned int w, char c ) { return (_Ostream_Manip(char))@{ c, w, 0, 'c', { .all : 0 } }; }
     278        _Ostream_Manip(char) & wd( unsigned int w, _Ostream_Manip(char) & fmt ) { fmt.wd = w; return fmt; }
    276279        _Ostream_Manip(char) & left( _Ostream_Manip(char) & fmt ) { fmt.flags.left = true; return fmt; }
    277280        _Ostream_Manip(char) & upcase( _Ostream_Manip(char) & fmt ) { if ( fmt.base == 'x' || fmt.base == 'b' ) fmt.base -= 32; /* upper case */ return fmt; }
    … …  
    286289
    287290static inline {
    288         _Ostream_Manip(const char *) bin( const char s[] ) { return (_Ostream_Manip(const char *))@{ .val : s, .wd : 1, .pc : 0, .base : 'b', { .all : 0 } }; }
    289         _Ostream_Manip(const char *) oct( const char s[] ) { return (_Ostream_Manip(const char *))@{ .val : s, .wd : 1, .pc : 0, .base : 'o', { .all : 0 } }; }
    290         _Ostream_Manip(const char *) hex( const char s[] ) { return (_Ostream_Manip(const char *))@{ .val : s, .wd : 1, .pc : 0, .base : 'x', { .all : 0 } }; }
    291         _Ostream_Manip(const char *) wd( unsigned int wd, const char s[] ) { return (_Ostream_Manip(const char *))@{ s, wd, 0, .base : 's', { .all : 0 } }; }
    292         _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 } }; }
    293         _Ostream_Manip(const char *) & wd( unsigned int wd, _Ostream_Manip(const char *) & fmt ) { fmt.wd = wd; return fmt; }
    294         _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; }
     291        _Ostream_Manip(const char *) bin( const char s[] ) { return (_Ostream_Manip(const char *))@{ s, 1, 0, 'b', { .all : 0 } }; }
     292        _Ostream_Manip(const char *) oct( const char s[] ) { return (_Ostream_Manip(const char *))@{ s, 1, 0, 'o', { .all : 0 } }; }
     293        _Ostream_Manip(const char *) hex( const char s[] ) { return (_Ostream_Manip(const char *))@{ s, 1, 0, 'x', { .all : 0 } }; }
     294        _Ostream_Manip(const char *) wd( unsigned int w, const char s[] ) { return (_Ostream_Manip(const char *))@{ s, w, 0, 's', { .all : 0 } }; }
     295        _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 } }; }
     296        _Ostream_Manip(const char *) & wd( unsigned int w, _Ostream_Manip(const char *) & fmt ) { fmt.wd = w; return fmt; }
     297        _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; }
    295298        _Ostream_Manip(const char *) & left( _Ostream_Manip(const char *) & fmt ) { fmt.flags.left = true; return fmt; }
    296299        _Ostream_Manip(const char *) & nobase( _Ostream_Manip(const char *) & fmt ) { fmt.flags.nobsdp = true; return fmt; }
    … …  
    382385
    383386static inline {
    384         _Istream_Cskip skip( const char scanset[] ) { return (_Istream_Cskip)@{ .scanset : scanset, .wd : 0 }; }
    385         _Istream_Cskip skip( unsigned int wd ) { return (_Istream_Cskip)@{ .scanset : 0p, .wd : wd }; }
     387        _Istream_Cskip skip( const char scanset[] ) { return (_Istream_Cskip)@{ scanset, 0 }; }
     388        _Istream_Cskip skip( unsigned int wd ) { return (_Istream_Cskip)@{ 0p, wd }; }
    386389} // distribution
    387390
    … …  
    397400                        unsigned char ignore:1;                                         // do not change input argument
    398401                        unsigned char inex:1;                                           // include/exclude characters in scanset
    399                         unsigned char delimiter:1;                                      // delimit character(s)
     402                        unsigned char delimiter:1;                                      // delimit character
    400403                        unsigned char rwd:1;                                            // read width
    401404                } flags;
    … …  
    403406}; // _Istream_str_base
    404407
    405 struct _Istream_Cwidth {
     408struct _Istream_Cstr {
    406409        char * s;
    407410        inline _Istream_str_base;
    408411}; // _Istream_Cstr
    409412
    410 // Restrict nesting of input manipulators to those combinations that make sense.
    411 
    412 struct _Istream_Cstr {
    413         _Istream_Cwidth cstr;
    414 }; // _Istream_Cstr
    415 
    416413struct _Istream_Cquoted {
    417         _Istream_Cwidth cstr;
     414        _Istream_Cstr cstr;
    418415}; // _Istream_Cquoted
    419416
    420417static inline {
    421         // 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);
    422         _Istream_Cwidth wdi( unsigned int wd, char s[] ) {
    423                 if ( wd <= 1 ) throw (cstring_length){ &cstring_length_vt }; // minimum 1 character and null terminator
    424                 return (_Istream_Cwidth)@{ .s : s, { {.scanset : 0p}, .wd : wd, {.all : 0} } };
     418        // width must include room for null terminator
     419        _Istream_Cstr wdi( unsigned int wd, char s[] ) { return (_Istream_Cstr)@{ s, { {0p}, wd, {.all : 0} } }; }
     420        _Istream_Cstr wdi( unsigned int wd, unsigned int rwd, char s[] ) {
     421                if ( wd <= rwd ) throw (cstring_length){ &cstring_length_vt };
     422                return (_Istream_Cstr)@{ s, { {0p}, rwd, {.flags.rwd : true} } };
    425423        }
    426         _Istream_Cwidth wdi( unsigned int wd, unsigned int rwd, char s[] ) {
    427                 if ( wd <= 1 || wd <= rwd ) throw (cstring_length){ &cstring_length_vt }; // minimum 1 character, null terminator, plus subset
    428                 return (_Istream_Cwidth)@{ .s : s, { {.scanset : 0p}, .wd : rwd, {.flags.rwd : true} } };
     424        _Istream_Cquoted & quoted( _Istream_Cstr & fmt, const char Ldelimiter = '"', const char Rdelimiter = '\0' ) {
     425                fmt.delimiters[0] = Ldelimiter;  fmt.delimiters[1] = Rdelimiter;  fmt.delimiters[2] = '\0';
     426                return (_Istream_Cquoted &)fmt;
    429427        }
    430         _Istream_Cquoted quoted( char & ch, const char Ldelimiter = '\'', const char Rdelimiter = '\0' ) {
    431                 return (_Istream_Cquoted)@{ { .s : &ch, { {.delimiters : { Ldelimiter, Rdelimiter, '\1' }}, .wd : 1, {.flags.rwd : true} } } };
     428        _Istream_Cstr & getline( _Istream_Cstr & fmt, const char delimiter = '\n' ) {
     429                fmt.delimiters[0] = delimiter; fmt.delimiters[1] = '\0'; fmt.flags.delimiter = true; fmt.flags.inex = true; return fmt;
    432430        }
    433         _Istream_Cquoted & quoted( _Istream_Cwidth & f, const char Ldelimiter = '"', const char Rdelimiter = '\0' ) {
    434                 f.delimiters[0] = Ldelimiter;  f.delimiters[1] = Rdelimiter;  f.delimiters[2] = '\0';
    435                 return (_Istream_Cquoted &)f;
    436         }
    437         _Istream_Cstr & getline( _Istream_Cwidth & f, const char delimiter = '\n' ) {
    438                 f.delimiters[0] = delimiter; f.delimiters[1] = '\0'; f.flags.delimiter = true; return (_Istream_Cstr &)f;
    439         }
    440         _Istream_Cstr & incl( const char scanset[], _Istream_Cwidth & f ) { f.scanset = scanset; f.flags.inex = false; return (_Istream_Cstr &)f; }
    441         _Istream_Cstr & excl( const char scanset[], _Istream_Cwidth & f ) { f.scanset = scanset; f.flags.inex = true; return (_Istream_Cstr &)f; }
    442         _Istream_Cstr ignore( const char s[] ) { return (_Istream_Cwidth)@{ .s : (char *)s, { {.scanset : 0p}, .wd : -1, {.flags.ignore : true} } }; }
    443         _Istream_Cstr & ignore( _Istream_Cwidth & f ) { f.flags.ignore = true; return (_Istream_Cstr &)f; }
    444         _Istream_Cquoted & ignore( _Istream_Cquoted & f ) { f.cstr.flags.ignore = true; return (_Istream_Cquoted &)f; }
    445         _Istream_Cstr & ignore( _Istream_Cstr & f ) { f.cstr.flags.ignore = true; return (_Istream_Cstr &)f; }
     431        _Istream_Cstr & incl( const char scanset[], _Istream_Cstr & fmt ) { fmt.scanset = scanset; fmt.flags.inex = false; return fmt; }
     432        _Istream_Cstr & excl( const char scanset[], _Istream_Cstr & fmt ) { fmt.scanset = scanset; fmt.flags.inex = true; return fmt; }
     433        _Istream_Cstr ignore( char s[] ) { return (_Istream_Cstr)@{ s, { {0p}, -1, {.flags.ignore : true} } }; }
     434        _Istream_Cstr & ignore( _Istream_Cstr & fmt ) { fmt.flags.ignore = true; return fmt; }
    446435} // distribution
    447436
    448437forall( istype & | basic_istream( istype ) ) {
     438        istype & ?|?( istype & is, _Istream_Cstr f );
    449439        istype & ?|?( istype & is, _Istream_Cskip f );
    450440        istype & ?|?( istype & is, _Istream_Cquoted f );
    451         istype & ?|?( istype & is, _Istream_Cstr f );
    452         static inline {
    453                 istype & ?|?( istype & is, _Istream_Cwidth f ) { return is | *(_Istream_Cstr *)&f; }
    454         } // distribution
    455 } // distribution
     441} // distribution
     442
     443struct _Istream_Char {
     444        bool ignore;                                                                            // do not change input argument
     445}; // _Istream_Char
     446
     447static inline {
     448        _Istream_Char ignore( const char ) { return (_Istream_Char)@{ true }; }
     449        _Istream_Char & ignore( _Istream_Char & fmt ) { fmt.ignore = true; return fmt; }
     450} // distribution
     451forall( istype & | basic_istream( istype ) ) {
     452        istype & ?|?( istype & is, _Istream_Char f );
     453}
    456454
    457455forall( T & | sized( T ) )
    … …  
    464462#define INPUT_FMT_DECL( T ) \
    465463static inline { \
    466         _Istream_Manip(T) wdi( unsigned int wd, T & val ) { return (_Istream_Manip(T))@{ .val : val, .wd : wd, .ignore : false }; } \
    467         _Istream_Manip(T) ignore( const T & val ) { return (_Istream_Manip(T))@{ .val : (T &)val, .wd : -1, .ignore : true }; } \
     464        _Istream_Manip(T) ignore( const T & val ) { return (_Istream_Manip(T))@{ (T &)val, -1, true }; } \
    468465        _Istream_Manip(T) & ignore( _Istream_Manip(T) & fmt ) { fmt.ignore = true; return fmt; } \
     466        _Istream_Manip(T) wdi( unsigned int wd, T & val ) { return (_Istream_Manip(T))@{ val, wd, false }; } \
     467        _Istream_Manip(T) & wdi( unsigned int wd, _Istream_Manip(T) & fmt ) { fmt.wd = wd; return fmt; } \
    469468} /* distribution */ \
    470469forall( istype & | basic_istream( istype ) ) { \
    … …  
    472471} // ?|?
    473472
    474 INPUT_FMT_DECL( char )
    475473INPUT_FMT_DECL( signed char )
    476474INPUT_FMT_DECL( unsigned char )

  • src/Common/utility.h

    r32490deb rc75b30a  
    111111};
    112112
     113// -----------------------------------------------------------------------------
     114// O(1) polymorphic integer ilog2, using clz, which returns the number of leading 0-bits, starting at the most
     115// significant bit (single instruction on x86)
     116
     117template<typename T>
     118inline
     119#if defined(__GNUC__) && __GNUC__ > 4
     120constexpr
     121#endif
     122T ilog2(const T & t) {
     123        if(std::is_integral<T>::value) {
     124                const constexpr int r = sizeof(t) * __CHAR_BIT__ - 1;
     125                if( sizeof(T) == sizeof(unsigned       int) ) return r - __builtin_clz  ( t );
     126                if( sizeof(T) == sizeof(unsigned      long) ) return r - __builtin_clzl ( t );
     127                if( sizeof(T) == sizeof(unsigned long long) ) return r - __builtin_clzll( t );
     128        }
     129        assert(false);
     130        return -1;
     131} // ilog2
     132
    113133// Local Variables: //
    114134// tab-width: 4 //

  • src/ResolvExpr/Resolver.cc

    r32490deb rc75b30a  
    5050
    5151namespace ResolvExpr {
     52        template< typename iterator_t >
     53        inline bool advance_to_mutex( iterator_t & it, const iterator_t & end ) {
     54                while( it != end && !(*it)->get_type()->get_mutex() ) {
     55                        it++;
     56                }
     57
     58                return it != end;
     59        }
     60
    5261        namespace {
    5362                /// Finds deleted expressions in an expression tree

  • tests/collections/.expect/string-istream-manip.txt

    r32490deb rc75b30a  
    686812 wwwwwwww
    696913 wwwwwwww
    70 14
     7014 cccc
    717115
    72721 yyyyyyyyyyyyyyyyyyyy
    … …  
    838312 wwwwwwww
    848413 wwwwwwww
    85 14
     8514 cccc
    868615

  • tests/collections/.in/string-istream-manip.txt

    r32490deb rc75b30a  
    3636abcxxx
    3737abcyyy
    38 aaaaaaaaxxxxxxxxaabbccbbdddwwwbbbbbbbbwwwwwwwwaaaaaaaawwwwwwwwaaaaaaaawwwwwwww
    39 uuuuu
     38aaaaaaaaxxxxxxxxaabbccbbdddwwwbbbbbbbbwwwwwwwwaaaaaaaawwwwwwww
     39uuuuuccccuuuuu
    4040abc
    4141cccccb
    … …  
    4343abcxxx
    4444abcyyy
    45 aaaaaaaaxxxxxxxxaabbccbbdddwwwbbbbbbbbwwwwwwwwaaaaaaaawwwwwwwwaaaaaaaawwwwwwww
    46 uuuuu
     45aaaaaaaaxxxxxxxxaabbccbbdddwwwbbbbbbbbwwwwwwwwaaaaaaaawwwwwwww
     46uuuuuccccuuuuu

  • tests/collections/string-istream-manip.cfa

    r32490deb rc75b30a  
    165165        sin | ignore( incl( "abc", wdi( 8, s ) ) );     sout | "12" | s;
    166166        sin | ignore( excl( "abc", wdi( 8, s ) ) );     sout | "13" | s;
    167                 sin | "\n";
    168167
    169168                s = "q";
    … …  
    192191        sin | ignore( incl( "abc", wdi( 8, s ) ) );     sout | "12" | s;
    193192        sin | ignore( excl( "abc", wdi( 8, s ) ) );     sout | "13" | s;
    194                 sin | "\n";
    195193
    196194                s = "q";

  • tests/io/.expect/manipulatorsInput.arm64.txt

    r32490deb rc75b30a  
    181812 wwwwwwww
    191913 wwwwwwww
    20 14 rc=0, q
     2014 rc=1, cccc
    212115 rc=0, q
    222216 get this line
    232317 @# this line 1)-{}
    24 18 @# this line 1)-{}
    25 19 abc
    26 20 abc 
    27 21  d d
     2418 abc
     2519 abc 
     2620  d d
    2827
    2928d
    30 22              ZC44%
    31 23              ZC44%
    32 24 x
    33 25 x
    34 26 x
    35 27 x
    36 28 x
     2921              ZC44%
    37301 yyyyyyyyyyyyyyyyyyyy
    38312 abcxxx
    39323 abcxxx
    40334 aaaaaaaa
    41 5 aaaaaaaa
     345
    42356 aabbccbb
    43367 dddwww
    44 8 dddwww
    45 9 dddwww
     378
     389
    463910 aaaaaaaa
    474011 wwwwwwww
    48 12 wwwwwwww
    49 13 wwwwwwww
    50 14
     4112
     4213
     4314 cccc
    514415
    524516 get this line
    534617 @# this line 1)-{}
    54 18 @# this line 1)-{}
    55 19 abc
    56 20 abc 
    57 21 d d
     4718 abc
     4819 abc 
     4920 d d
    5850
    5951d
    60 22              ZC44%
    61 23              ZC44%
    62 24 x
    63 25 x
    64 26 x
    65 27 x
    66 28 x
     5221              ZC44%
    6753a
    6854a
    69 xxx
    70 xxx
    7155-1
    725615

  • tests/io/.expect/manipulatorsInput.x64.txt

    r32490deb rc75b30a  
    181812 wwwwwwww
    191913 wwwwwwww
    20 14 rc=0, q
     2014 rc=1, cccc
    212115 rc=0, q
    222216 get this line
    232317 @# this line 1)-{}
    24 18 @# this line 1)-{}
    25 19 abc
    26 20 abc 
    27 21  d d
     2418 abc
     2519 abc 
     2620  d d
    2827
    2928d
    30 22              ZC44%
    31 23              ZC44%
    32 24 x
    33 25 x
    34 26 x
    35 27 x
    36 28 x
     2921              ZC44%
    37301 yyyyyyyyyyyyyyyyyyyy
    38312 abcxxx
    39323 abcxxx
    40334 aaaaaaaa
    41 5 aaaaaaaa
     345
    42356 aabbccbb
    43367 dddwww
    44 8 dddwww
    45 9 dddwww
     378
     389
    463910 aaaaaaaa
    474011 wwwwwwww
    48 12 wwwwwwww
    49 13 wwwwwwww
    50 14
     4112
     4213
     4314 cccc
    514415
    524516 get this line
    534617 @# this line 1)-{}
    54 18 @# this line 1)-{}
    55 19 abc
    56 20 abc 
    57 21 d d
     4718 abc
     4819 abc 
     4920 d d
    5850
    5951d
    60 22              ZC44%
    61 23              ZC44%
    62 24 x
    63 25 x
    64 26 x
    65 27 x
    66 28 x
     5221              ZC44%
    6753a
    6854a
    69 xxx
    70 xxx
    7155-1
    725615

  • tests/io/.expect/manipulatorsInput.x86.txt

    r32490deb rc75b30a  
    181812 wwwwwwww
    191913 wwwwwwww
    20 14 rc=0, q
     2014 rc=1, cccc
    212115 rc=0, q
    222216 get this line
    232317 @# this line 1)-{}
    24 18 @# this line 1)-{}
    25 19 abc
    26 20 abc 
    27 21  d d
     2418 abc
     2519 abc 
     2620  d d
    2827
    2928d
    30 22              ZC44%
    31 23              ZC44%
    32 24 x
    33 25 x
    34 26 x
    35 27 x
    36 28 x
     2921              ZC44%
    37301 yyyyyyyyyyyyyyyyyyyy
    38312 abcxxx
    39323 abcxxx
    40334 aaaaaaaa
    41 5 aaaaaaaa
     345
    42356 aabbccbb
    43367 dddwww
    44 8 dddwww
    45 9 dddwww
     378
     389
    463910 aaaaaaaa
    474011 wwwwwwww
    48 12 wwwwwwww
    49 13 wwwwwwww
    50 14
     4112
     4213
     4314 cccc
    514415
    524516 get this line
    534617 @# this line 1)-{}
    54 18 @# this line 1)-{}
    55 19 abc
    56 20 abc 
    57 21 d d
     4718 abc
     4819 abc 
     4920 d d
    5850
    5951d
    60 22              ZC44%
    61 23              ZC44%
    62 24 x
    63 25 x
    64 26 x
    65 27 x
    66 28 x
     5221              ZC44%
    6753a
    6854a
    69 xxx
    70 xxx
    7155-1
    725615

  • tests/io/.in/manipulatorsInput.txt

    r32490deb rc75b30a  
    88abcxxx
    99abcyyy
    10 aaaaaaaaxxxxxxxxaabbccbbdddwwwbbbbbbbbwwwwwwwwaaaaaaaawwwwwwwwaaaaaaaawwwwwwww
    11 uuuuu
     10aaaaaaaaxxxxxxxxaabbccbbdddwwwbbbbbbbbwwwwwwwwaaaaaaaawwwwwwww
     11uuuuuccccuuuuu
    1212get this line
    1313@# this line 1)-{}%
    14 @# this line 2)-{}%
    1514"abc"
    1615'abc  '
    … …  
    1918d }
    2019X               ZC44%Y
    21 X               ZC55%Y
    22 'x'
    23 "x"
    24 {x}
    25 XxY
    26 XyY
    2720abc
    2821cccccb
    … …  
    3023abcxxx
    3124abcyyy
    32 aaaaaaaaxxxxxxxxaabbccbbdddwwwbbbbbbbbwwwwwwwwaaaaaaaawwwwwwwwaaaaaaaawwwwwwww
    33 uuuuu
     25aaaaaaaaxxxxxxxxaabbccbbdddwwwbbbbbbbbwwwwwwwwaaaaaaaawwwwwwww
     26uuuuuccccuuuuu
    3427get this line
    3528@# this line 1)-{}%
    36 @# this line 2)-{}%
    3729"abc"
    3830'abc  '
    … …  
    4133d }
    4234X               ZC44%Y
    43 X               ZC55%Y
    44 'x'
    45 "x"
    46 {x}
    47 XxY
    48 XyY
    4935ab
    50 xxxyyy
    51360xff 017 15-15
    52370xff 017 15-15

  • tests/io/manipulatorsInput.cfa

    r32490deb rc75b30a  
    77// Created On       : Sat Jun  8 17:58:54 2019
    88// Last Modified By : Peter A. Buhr
    9 // Last Modified On : Sun Jan 28 11:59:55 2024
    10 // Update Count     : 133
     9// Last Modified On : Wed Jan  3 11:15:04 2024
     10// Update Count     : 103
    1111//
    1212
    … …  
    5555        }
    5656        {
    57                 char s[] = "yyyyyyyyyyyyyyyyyyyy";                                                                                                      // Input characters consumed:
     57                char s[] = "yyyyyyyyyyyyyyyyyyyy";
    5858                const char sk_fmt[] = "%*[abc]";
    59                 scanf( "abc " ); scanf( sk_fmt ); for ( 5 ) scanf( "%*c" ); printf( "1 %s\n", s );      // |abc |\ncccccb| \nxx\n|
    60                 scanf( "%s", s );                                                               printf( "2 %s\n", s );                          // |abcxxx|
    61                 scanf( "%*s" );                                                                 printf( "3 %s\n", s );                          // |\nabcyyy|
    62                 scanf( "%8s", s );                                                              printf( "4 %s\n", s );                          // |\naaaaaaaa|
    63                 scanf( "%*8s" );                                                                printf( "5 %s\n", s );                          // |xxxxxxxx|
    64 
    65                 scanf( "%[abc]", s );                                                   printf( "6 %s\n", s );                          // |aabbccbb|
    66                 scanf( "%[^abc]", s );                                                  printf( "7 %s\n", s );                          // |dddwww|
    67                 scanf( "%*[abc]" );                                                             printf( "8 %s\n", s );                          // |bbbbbbbb|
    68                 scanf( "%*[^abc]" );                                                    printf( "9 %s\n", s );                          // |wwwwwwww|
    69                 scanf( "%8[abc]", s );                                                  printf( "10 %s\n", s );                         // |aaaaaaaa|
    70                 scanf( "%8[^abc]", s );                                                 printf( "11 %s\n", s );                         // |wwwwwwww|
    71                 scanf( "%*8[abc]" );                                                    printf( "12 %s\n", s );                         // |aaaaaaaa|
    72                 scanf( "%*8[^abc]" );                                                   printf( "13 %s\n", s );                         // |wwwwwwww|
    73                 scanf( "\n" );                                                                  // must start next line                         // |\n|
     59                scanf( "abc " ); scanf( sk_fmt ); for ( 5 ) scanf( "%*c" ); printf( "1 %s\n", s );
     60                scanf( "%s", s );                                                               printf( "2 %s\n", s );
     61                scanf( "%*s" );                                                                 printf( "3 %s\n", s );
     62                scanf( "%8s", s );                                                              printf( "4 %s\n", s );
     63                scanf( "%*8s" );                                                                printf( "5 %s\n", s );
     64
     65                scanf( "%[abc]", s );                                                   printf( "6 %s\n", s );
     66                scanf( "%[^abc]", s );                                                  printf( "7 %s\n", s );
     67                scanf( "%*[abc]" );                                                             printf( "8 %s\n", s );
     68                scanf( "%*[^abc]" );                                                    printf( "9 %s\n", s );
     69                scanf( "%8[abc]", s );                                                  printf( "10 %s\n", s );
     70                scanf( "%8[^abc]", s );                                                 printf( "11 %s\n", s );
     71                scanf( "%*8[abc]" );                                                    printf( "12 %s\n", s );
     72                scanf( "%*8[^abc]" );                                                   printf( "13 %s\n", s );
    7473
    7574                int rc;
    7675                s[0] = 'q'; s[1] = '\0'; rc = 99;
    77                 rc = scanf( "%[abc]", s );                                              printf( "14 rc=%d, %s\n", rc, s );      // ||
     76                rc = scanf( "%[abc]", s );                                              printf( "14 rc=%d, %s\n", rc, s );
    7877                s[0] = 'q'; s[1] = '\0'; rc = 99;
    79                 rc = scanf( "%[^u]", s );                                               printf( "15 rc=%d, %s\n", rc, s );      // ||
    80                 scanf( "%*[u]\n" );                                                                                                                                     // |uuuuu\n|
    81                 scanf( "%[^\n]\n", s );                                                 printf( "16 %s\n", s );                         // |get this line\n|
    82                 scanf( "%[^%%]%%\n", s );                                               printf( "17 %s\n", s );                         // |@# this line 1)-{}%\n|
    83                 scanf( "%*[^%%]%%\n", s );                                              printf( "18 %s\n", s );                         // |@# this line 1)-{}%\n|
    84 
    85                 scanf( "%*[ \f\n\r\t\v]" );                                             // ignore whitespace                            // ||
    86                 scanf( "\"%[^\"]\"", s );                                               printf( "19 %s\n", s );                         // |"abc"|
    87                 scanf( "%*[ \f\n\r\t\v]" );                                             // ignore whitespace                            // |\n|
    88                 scanf( "'%[^']'", s );                                                  printf( "20 %s\n", s );                         // |'abc  '|
    89                 scanf( "%*[ \f\n\r\t\v]" );                                             // ignore whitespace                            // |\n|
    90                 scanf( "{%[^}]}", s );                                                  printf( "21 %s\n", s );                         // |{ d d\n\nd }|
    91                 scanf( "%*[ \f\n\r\t\v]" );                                             // ignore whitespace                            // |\n|
    92                 scanf( "X%[^Y]Y", s );                                                  printf( "22 %s\n", s );                         // |X           ZC44%Y|
    93                 scanf( "%*[ \f\n\r\t\v]" );                                             // ignore whitespace                            // |\n|
    94                 scanf( "X%*[^Y]Y", s );                                                 printf( "23 %s\n", s );                         // |X           ZC44%Y|
    95                 scanf( "\n" );                                                                  // must start next line                         // |\n|
    96 
    97                 char ch;
    98                 scanf( "%*[ \f\n\r\t\v]" );                                             // ignore whitespace                            // |\n|
    99                 scanf( "'%c'", &ch );                                                   printf( "24 %c\n", ch );                        // |x|
    100                 scanf( "%*[ \f\n\r\t\v]" );                                             // ignore whitespace                            // |\n|
    101                 scanf( "\"%c\"", &ch );                                                 printf( "25 %c\n", ch );                        // |x|
    102                 scanf( "%*[ \f\n\r\t\v]" );                                             // ignore whitespace                            // |\n|
    103                 scanf( "{%c}", &ch );                                                   printf( "26 %c\n", ch );                        // |x|
    104                 scanf( "%*[ \f\n\r\t\v]" );                                             // ignore whitespace                            // |\n|
    105                 scanf( "X%cY", &ch );                                                   printf( "27 %c\n", ch );                        // |x|
    106                 scanf( "%*[ \f\n\r\t\v]" );                                             // ignore whitespace                            // |\n|
    107                 scanf( "X%*cY", &ch );                                                  printf( "28 %c\n", ch );                        // |x|
    108                 scanf( "\n" );                                                                  // must start next line                         // |\n|
     78                rc = scanf( "%[^u]", s );                                               printf( "15 rc=%d, %s\n", rc, s );
     79                scanf( "%*[u]\n" );
     80                scanf( "%[^\n]\n", s );                                                 printf( "16 %s\n", s );
     81                scanf( "%[^%%]%%\n", s );                                               printf( "17 %s\n", s );
     82
     83                scanf( "%*[ \f\n\r\t\v]" );                                             // ignore whitespace
     84                scanf( "\"%[^\"]\"", s );                                               printf( "18 %s\n", s );
     85                scanf( "%*[ \f\n\r\t\v]" );                                             // ignore whitespace
     86                scanf( "'%[^']'", s );                                                  printf( "19 %s\n", s );
     87                scanf( "%*[ \f\n\r\t\v]" );                                             // ignore whitespace
     88                scanf( "{%[^}]}", s );                                                  printf( "20 %s\n", s );
     89                scanf( "%*[ \f\n\r\t\v]" );                                             // ignore whitespace
     90                scanf( "X%[^Y]Y", s );                                                  printf( "21 %s\n", s );
     91                scanf( "\n" );                                                                  // must start next line
    10992        }
    11093        {
    … …  
    125108                sin | ignore( incl( "abc", wdi( sizeof(s), 8, s ) ) ); sout | "12" | s;
    126109                sin | ignore( excl( "abc", wdi( sizeof(s), 8, s ) ) ); sout | "13" | s;
    127                 sin | nl;
    128110
    129111                s[0] = 'q'; s[1] = '\0';
    … …  
    134116                sin | getline( wdi( sizeof(s), s ) );                   sout | "16" | s;
    135117                sin | getline( wdi( sizeof(s), s ), '%' ) | "\n"; sout | "17" | s;
    136                 sin | ignore( getline( wdi( sizeof(s), s ), '%' ) ) | "\n"; sout | "18" | s;
    137 
    138                 sin | quoted( wdi( sizeof(s), s ) );                    sout | "19" | s;
    139                 sin | quoted( wdi( sizeof(s), s ), '\'' );              sout | "20" | s;
    140                 sin | quoted( wdi( sizeof(s), s ), '{', '}' );  sout | "21" | s;
    141                 sin | quoted( wdi( sizeof(s), s ), 'X', 'Y' );  sout | "22" | s;
    142                 sin | ignore( quoted( wdi( sizeof(s), s ), 'X', 'Y' ) ); sout | "23" | s;
    143 
    144                 char ch;
    145                 sin | quoted( ch );                                                             sout | "24 " | ch;
    146                 sin | quoted( ch, '\"' );                                               sout | "25 " | ch;
    147                 sin | quoted( ch, '{', '}' );                                   sout | "26 " | ch;
    148                 sin | quoted( ch, 'X', 'Y' );                                   sout | "27 " | ch;
    149                 sin | ignore( quoted( ch, 'X', 'Y' ) );                 sout | "28 " | ch;
    150                 sin | nl;
    151         }
    152         // Keep harmonized with collections/string-istream-manip
     118
     119                sin | quoted( wdi( sizeof(s), s ) );                    sout | "18" | s;
     120                sin | quoted( wdi( sizeof(s), s ), '\'' );              sout | "19" | s;
     121                sin | quoted( wdi( sizeof(s), s ), '{', '}' );  sout | "20" | s;
     122                sin | quoted( wdi( sizeof(s), s ), 'X', 'Y' );  sout | "21" | s;
     123        }
     124    // Keep harmonized with collections/string-istream-manip
    153125        {
    154126                char c;
    155127                sin | c;                                                                                sout | c;
    156128                sin | ignore( c );                                                              sout | c;
    157                 sin | nl;
    158 
    159                 char ca[3] = { 'a', 'b', 'c' };
    160                 sin | wdi( sizeof(ca), ca[0] );                                 sout | ca[0] | ca[1] | ca[2];
    161                 sin | ignore( wdi( sizeof(ca), ca[0] ) );               sout | ca[0] | ca[1] | ca[2];
    162                 sin | nl;
    163129
    164130                signed char sc;
Note: See TracChangeset for help on using the changeset viewer.