Changeset 5e0b6657 for doc


Ignore:
Timestamp:
Dec 8, 2025, 11:29:33 AM (2 months ago)
Author:
Michael Brooks <mlbrooks@…>
Branches:
master, stuck-waitfor-destruct
Children:
79ba50c
Parents:
8f448e0 (diff), 79ec8c3 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge remote-tracking branch 'refs/remotes/origin/master'

Location:
doc
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • doc/LaTeXmacros/common.sty

    r8f448e0 r5e0b6657  
    1111%% Created On       : Sat Apr  9 10:06:17 2016
    1212%% Last Modified By : Peter A. Buhr
    13 %% Last Modified On : Mon May  5 21:37:13 2025
    14 %% Update Count     : 666
     13%% Last Modified On : Sun Sep 21 22:17:15 2025
     14%% Update Count     : 667
    1515%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    1616
    … …  
    325325  {<-}{$\leftarrow$}2
    326326  {=>}{$\Rightarrow$}2
     327  {/*}{/{\raisebox{-2pt}{*}}}2
     328  {*/}{{\raisebox{-2pt}{*}}/}2
    327329%  {->}{\raisebox{-1pt}{\texttt{-}}\kern-0.1ex\textgreater}2,
    328330}% lstset

  • doc/LaTeXmacros/common.tex

    r8f448e0 r5e0b6657  
    1111%% Created On       : Sat Apr  9 10:06:17 2016
    1212%% Last Modified By : Peter A. Buhr
    13 %% Last Modified On : Mon May  5 21:34:53 2025
    14 %% Update Count     : 709
     13%% Last Modified On : Sun Sep 21 22:16:43 2025
     14%% Update Count     : 710
    1515%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    1616
    … …  
    329329  {<-}{$\leftarrow$}2
    330330  {=>}{$\Rightarrow$}2
     331  {/*}{/{\raisebox{-2pt}{*}}}2
     332  {*/}{{\raisebox{-2pt}{*}}/}2
    331333%  {->}{\raisebox{-1pt}{\texttt{-}}\kern-0.1ex\textgreater}2,
    332334}% lstset

  • doc/bibliography/pl.bib

    r8f448e0 r5e0b6657  
    362362    school      = {University of Waterloo},
    363363    year        = 1991,
    364     address     = {Waterloo, Ontario, Canada, N2L 3G1},
     364    address     = {Waterloo, Ontario, Canada},
    365365}
    366366
    … …  
    426426    year        = 2010,
    427427    month       = dec,
    428     address     = {Waterloo, Ontario, Canada, N2L 3G1},
     428    address     = {Waterloo, Ontario, Canada},
    429429    optnote     = {\textsf{http://uwspace.uwaterloo.ca/\-bitstream/10012/\-5751\-/1/Krischer\_Roy.pdf}},
    430430    note        = {\url{http://uwspace.uwaterloo.ca/bitstream/10012/5751/1/Krischer_Roy.pdf}},
    … …  
    929929
    930930% B
     931
     932@misc{ONCD,
     933    keywords    = {programming lnaguage safety},
     934    contributer = {pabuhr@plg},
     935    key         = {Final-ONCD-Technical-Report},
     936    title       = {Back to the Building Blocks: A Path Toward Secure and Measurable Software},
     937    author      = {},
     938    howpublished= {\url{https://bidenwhitehouse.archives.gov/wp-content/uploads/2024/02/Final-ONCD-Technical-Report.pdf}},
     939    year        = 2024,
     940}
    931941
    932942@article{Michael13,
    … …  
    11541164% C
    11551165
     1166@mastersthesis{HummelViirola25,
     1167    keywords    = {C, Rust, conversion},
     1168    contributer = {pabuhr@plg},
     1169    author      = {Johan Hummel and Ella Viirola},
     1170    title       = {From C 2 Rust: Evaluating the Feasibility of Translating C to a Memory-Safe Programming Language at Ericsson},
     1171    school      = {Lund University},
     1172    year        = 2025,
     1173    address     = {Lund, Sweden},
     1174}
     1175
    11561176@book{C,
    11571177    keywords    = {C},
    … …  
    12471267    title       = {\textsf{C}$\mathbf{\forall}$ Container Library},
    12481268    school      = {School of Computer Science, University of Waterloo},
    1249     address     = {Waterloo, Ontario, Canada, N2L 3G1},
     1269    address     = {Waterloo, Ontario, Canada},
    12501270    publisher   = {UWSpace},
    12511271    year        = {2025},
    1252     note        = {\url{https://hdl.handle.net/10012/XXXXX}},
     1272    note        = {\url{https://hdl.handle.net/10012/12345}},
    12531273}
    12541274
    … …  
    13241344    title       = {The \textsf{C}$\mathbf{\forall}$ Scheduler},
    13251345    school      = {School of Computer Science, University of Waterloo},
    1326     address     = {Waterloo, Ontario, Canada, N2L 3G1},
     1346    address     = {Waterloo, Ontario, Canada},
    13271347    publisher   = {UWSpace},
    13281348    year        = 2022,
    … …  
    13451365    school      = {School of Computer Science, University of Waterloo},
    13461366    year        = 2004,
    1347     address     = {Waterloo, Ontario, Canada, N2L 3G1},
     1367    address     = {Waterloo, Ontario, Canada},
    13481368    note        = {\url{http://plg.uwaterloo.ca/theses/EstevesThesis.pdf}},
    13491369}
    … …  
    13551375    school      = {School of Computer Science, University of Waterloo},
    13561376    year        = 2019,
    1357     address     = {Waterloo, Ontario, Canada, N2L 3G1},
     1377    address     = {Waterloo, Ontario, Canada},
    13581378    note        = {\url{https://hdl.handle.net/10012/14584}},
    13591379}
    … …  
    15101530    title       = {\textsf{C}$\mathbf{\forall}$ Users Guide, Version 0.1},
    15111531    institution = {Department of Computer Science, University of Waterloo},
    1512     address     = {Waterloo, Ontario, Canada, N2L 3G1},
     1532    address     = {Waterloo, Ontario, Canada},
    15131533    month       = oct,
    15141534    year        = 2001,
    … …  
    18331853    year        = 1997,
    18341854    month       = sep,
    1835     address     = {Waterloo, Ontario, Canada, N2L 3G1},
     1855    address     = {Waterloo, Ontario, Canada},
    18361856    note        = {\url{http://plg.uwaterloo.ca/theses/MokThesis.pdf}},
    18371857}
    … …  
    20582078    school      = {School of Computer Sc., University of Waterloo},
    20592079    year        = 2015,
    2060     address     = {Waterloo, Ontario, Canada, N2L 3G1},
     2080    address     = {Waterloo, Ontario, Canada},
    20612081    note        = {\url{https://hdl.handle.net/10012/10013}},
    20622082}
    … …  
    21042124    title       = {Concurrency in \textsf{C}$\mathbf{\forall}$},
    21052125    school      = {School of Computer Science, University of Waterloo},
    2106     address     = {Waterloo, Ontario, Canada, N2L 3G1},
     2126    address     = {Waterloo, Ontario, Canada},
    21072127    publisher   = {UWSpace},
    21082128    year        = 2018,
    … …  
    21162136    title       = {Concurrency in {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}}},
    21172137    institution = {Department of Computer Science, University of Waterloo},
    2118     address     = {Waterloo, Ontario, Canada, N2L 3G1},
     2138    address     = {Waterloo, Ontario, Canada},
    21192139    number      = {CS-90-18},
    21202140    month       = may,
    … …  
    22092229    school      = {Department of Computer Science, University of Waterloo},
    22102230    year        = 1992,
    2211     address     = {Waterloo, Ontario, Canada, N2L 3G1},
     2231    address     = {Waterloo, Ontario, Canada},
    22122232    note        = {\url{http://plg.uwaterloo.ca/theses/DitchfieldThesis.pdf}}
    22132233}
    … …  
    32893309    title       = {Enumerated Types in \textsf{C}$\mathbf{\forall}$},
    32903310    school      = {School of Computer Science, University of Waterloo},
    3291     address     = {Waterloo, Ontario, Canada, N2L 3G1},
     3311    address     = {Waterloo, Ontario, Canada},
    32923312    publisher   = {UWSpace},
    32933313    year        = {2024},
    … …  
    34963516    title       = {Exception Handling in \textsf{C}$\mathbf{\forall}$},
    34973517    school      = {School of Computer Science, University of Waterloo},
    3498     address     = {Waterloo, Ontario, Canada, N2L 3G1},
     3518    address     = {Waterloo, Ontario, Canada},
    34993519    publisher   = {UWSpace},
    35003520    year        = {2021},
    … …  
    37523772    year        = 2008,
    37533773    month       = jan,
    3754     address     = {Waterloo, Ontario, Canada, N2L 3G1},
     3774    address     = {Waterloo, Ontario, Canada},
    37553775    note        = {\url{http://uwspace.uwaterloo.ca/bitstream/10012/3501/1/Thesis.pdf}},
    37563776}
    … …  
    42094229    year        = 2009,
    42104230    month       = sep,
    4211     address     = {Waterloo, Ontario, Canada, N2L 3G1},
     4231    address     = {Waterloo, Ontario, Canada},
    42124232    note        = {\textsf{http://uwspace.uwaterloo.ca/bitstream/\-10012/\-4735/\-1/\-Chen-Jun.pdf}},
    42134233}
    … …  
    42304250    author      = {Haskell},
    42314251    title       = {Haskell 2010 Language Report},
    4232     edition     = {{S}imon {M}arlow},
     4252    optedition  = {{S}imon {M}arlow},
    42334253    year        = 2010,
    42344254    note        = {\url{https://haskell.org/definition/haskell2010.pdf}},
    … …  
    42914311    title       = {High Level Concurrency in \textsf{C}$\mathbf{\forall}$},
    42924312    school      = {School of Computer Science, University of Waterloo},
    4293     address     = {Waterloo, Ontario, Canada, N2L 3G1},
     4313    address     = {Waterloo, Ontario, Canada},
    42944314    publisher   = {UWSpace},
    42954315    year        = {2023},
    … …  
    43024322    author      = {Mubeen Zulfiqar},
    43034323    title       = {High-Performance Concurrent Memory Allocation},
    4304     school      = {School of Computer Science, University of Waterloo},
     4324    school      = {School of Comp. Sc., Univ. of Waterloo},
    43054325    year        = 2022,
    4306     address     = {Waterloo, Ontario, Canada, N2L 3G1},
     4326    address     = {Waterloo, Ontario, Canada},
    43074327    note        = {\url{https://hdl.handle.net/10012/18329}},
    43084328}
    … …  
    43234343    author      = {Srihari Radhakrishnan},
    43244344    title       = {High Performance Web Servers: A Study In Concurrent Programming Models},
    4325     school      = {School of Computer Sc., University of Waterloo},
     4345    school      = {School of Computer Science, University of Waterloo},
    43264346    year        = 2019,
    4327     address     = {Waterloo, Ontario, Canada, N2L 3G1},
     4347    address     = {Waterloo, Ontario, Canada},
    43284348    note        = {\url{https://hdl.handle.net/10012/14706}},
    43294349}
    … …  
    45294549    author      = {Richard C. Bilson},
    45304550    title       = {Implementing Overloading and Polymorphism in \textsf{C}$\mathbf{\forall}$},
    4531     school      = {School of Computer Science, University of Waterloo},
     4551    school      = {University of Waterloo},
    45324552    year        = 2003,
    4533     address     = {Waterloo, Ontario, Canada, N2L 3G1},
     4553    address     = {Waterloo, Ontario, Canada},
    45344554    note        = {\url{http://plg.uwaterloo.ca/theses/BilsonThesis.pdf}},
    45354555}
    … …  
    45724592    year        = 2018,
    45734593    month       = sep,
    4574     address     = {Waterloo, Ontario, Canada, N2L 3G1},
     4594    address     = {Waterloo, Ontario, Canada},
    45754595    note        = {\url{https://uwspace.uwaterloo.ca/handle/10012/13935}},
    45764596}
    … …  
    51095129    school      = {University of Waterloo},
    51105130    year        = 1990,
    5111     address     = {Waterloo, Ontario, Canada, N2L 3G1}
     5131    address     = {Waterloo, Ontario, Canada}
    51125132}
    51135133
    … …  
    55315551    title       = {$\mu${S}ystem Annotated Reference Manual, Version 4.4.3},
    55325552    institution = {Department of Computer Science, University of Waterloo},
    5533     address     = {Waterloo, Ontario, Canada, N2L 3G1},
     5553    address     = {Waterloo, Ontario, Canada},
    55345554    month       = sep,
    55355555    year        = 1994,
    … …  
    62736293    contributer = {pabuhr@plg},
    62746294    key         = {OCaml},
    6275     title       = {The {OC}aml system, release 5.1},
    6276     address     = {Rust Project Developers},
    6277     year        = 2023,
    6278     note        = {\url{https://v2.ocaml.org/manual/}},
     6295    author      = {Xavier Leroy, Damien Doligez, Alain Frisch, Jacques Garrigue, Didier Rémy and Jérôme Vouillon},
     6296    title       = {The {OC}aml system, release 5.4},
     6297    year        = 2025,
     6298    note        = {\url{https://v2.ocaml.org/manual}},
    62796299}
    62806300
    … …  
    77337753    school      = {School of Computer Science, University of Waterloo},
    77347754    year        = 2017,
    7735     address     = {Waterloo, Ontario, Canada, N2L 3G1},
     7755    address     = {Waterloo, Ontario, Canada},
    77367756    note        = {\url{https://hdl.handle.net/10012/11830}},
    77377757}
    … …  
    78197839    contributer = {pabuhr@plg},
    78207840    key         = {Rust},
    7821     title       = {{R}ust Programming Language},
    7822     address     = {Rust Project Developers},
     7841    title       = {The {R}ust Reference},
     7842    address     = {Rust Developers},
    78237843    year        = 2015,
    7824     note        = {\url{https://doc.rust-lang.org/reference.html}},
     7844    note        = {\url{https://doc.rust-lang.org/stable/reference}},
    78257845}
    78267846
    … …  
    78757895    month       = jun,
    78767896    pages       = {35-46},
     7897}
     7898
     7899@inproceedings{Kashyap17,
     7900    contributer = {pabuhr@plg},
     7901    author      = {Sanidhya Kashyap and Changwoo Min and Taesoo Kim},
     7902    title       = {Scalable {NUMA-aware} Blocking Synchronization Primitives},
     7903    booktitle   = {2017 USENIX Annual Tech. Conf.},
     7904    address     = {Santa Clara, CA},
     7905    pages       = {603-615},
     7906    publisher   = {USENIX Assoc.},
     7907    year        = 2017,
     7908    month       = jul,
    78777909}
    78787910
    … …  
    83218353    contributer = {pabuhr@plg},
    83228354    author      = {Michael D. Tiemann},
    8323     title       = {Solving the RPC problem in GNU {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}}},
     8355    title       = {Solving the {RPC} problem in {GNU} {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}}},
    83248356    booktitle   = {Proceedings of the USENIX {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Conference},
    83258357    organization= {USENIX Association},
    … …  
    83338365    keywords    = {Polymorphic C},
    83348366    contributor = {a3moss@uwaterloo.ca},
    8335     title       = {A sound polymorphic type system for a dialect of {C}},
     8367    title       = {A Sound Polymorphic Type System for a Dialect of {C}},
    83368368    author      = {Smith, Geoffrey and Volpano, Dennis},
    83378369    journal     = {Science of computer programming},
    … …  
    85438575    school      = {Department of Computer Science, University of Waterloo},
    85448576    year        = 1989,
    8545     address     = {Waterloo, Ontario, Canada, N2L 3G1},
     8577    address     = {Waterloo, Ontario, Canada},
    85468578}
    85478579
    … …  
    87848816    volume      = 40,
    87858817    number      = 6,
    8786     month       = jun,
     8818    optmonth    = jun,
    87878819    year        = 2005,
    87888820    pages       = {261-268},
    … …  
    89098941}
    89108942
     8943@misc{Tractor,
     8944    keywords    = {Rust, C conversion},
     8945    contributer = {pabuhr@plg},
     8946    key         = {Tractor},
     8947    title       = {TRACTOR: Translating All C to Rust},
     8948    author      = {Dan Wallach},
     8949    note        = {DARPA},
     8950    howpublished= {\url{https://www.darpa.mil/research/programs/translating-all-c-to-rust}},
     8951    year        = 2024,
     8952}
     8953
    89118954@misc{Miller19,
    89128955    keywords    = {memory management, errors, unsafe},
    89138956    contributer = {pabuhr@plg},
    8914     title       = {Trends, challenges, and strategic shifts in the software vulnerability mitigation landscape},
     8957    title       = {Trends, Challenges, and Strategic Shifts in the Software Vulnerability Mitigation Landscape},
    89158958    author      = {Matt Miller},
    89168959    month       = feb,
    … …  
    89268969    school      = {Department of Computer Science, University of Waterloo},
    89278970    year        = 1989,
    8928     address     = {Waterloo, Ontario, Canada, N2L 3G1},
     8971    address     = {Waterloo, Ontario, Canada},
    89298972}
    89308973
    … …  
    90879130    title       = {Type Resolution in \textsf{C}$\mathbf{\forall}$},
    90889131    school      = {School of Computer Science, University of Waterloo},
    9089     address     = {Waterloo, Ontario, Canada, N2L 3G1},
     9132    address     = {Waterloo, Ontario, Canada},
    90909133    publisher   = {UWSpace},
    90919134    year        = {2025},

  • doc/proposals/autogen.md

    r8f448e0 r5e0b6657  
    100100The main reason to manually remove functions is to enforce a behaviour based interface for a type, as opposed to a data based one. To enforce that new interface, this would have to interact with visibility.
    101101
     102### Automatic Remove Hides Everything
     103As soon as you declare a custom constructor, _all_ autogenerated constructors become inaccessible. Often, this behaviour is good, and it agrees with C++. But the desire dual to "manually remove" exists: "manually keep." Furthermore, there is a use case for invoking an automatically provided constructor as a helper, when implementing a custom constructor.
     104
     105        struct S {
     106            int i;
     107            int & j;
     108        };
     109        void ?{}( S & s, int & w ) {
     110            // Unique best alternative includes deleted identifier in:
     111            s{ 3, w };
     112            // intended meaning / workaround:
     113            // s.i = 3; &s.j = &w;
     114        }
     115
     116This use case should be considered also, along with visibility. A private helper constructor should be usable in the implementation of a public value-add constructor. The private helper being an autogen is one such arrangement.
     117
     118Users should have the option to adopt the idiom: All constructors funnel into the most private, all-member constructor.
     119
     120### Removed Functions Linger
     121Even if a function is made CFA-uncallable, it still shows in the emitted C code (`cfa -CFA`). An uncallable function shows identically to a callable function, with no indication of, "This declaration has been deleted," or, "Here is a redaction of X." This quirk reduces the utility of inspecting -CFA to answer, "What constructors would be available to me?" or, "What's the net effect of the constructor declarations and deletions that I've given?"
     122
    102123## Other Problems & Requested Features
    103124

  • doc/theses/fangren_yu_MMath/test.adb

    r8f448e0 r5e0b6657  
    66        Function Random return Float is begin return 3.5; end;
    77        Function Random return Unbounded_String is begin return To_Unbounded_String( "abc" ); end;
    8        
     8
    99        Procedure Print( V : Integer ) is begin Put_Line( Integer'Image(V) ); end;
    1010        Procedure Print( V : Float ) is begin Put_Line( Float'Image(V) ); end;
    1111        Procedure Print( V : Unbounded_String ) is begin Put_Line( Ada.Strings.Unbounded.To_String(V) ); end;
    12        
     12
    1313        Function Func( V : Integer ) return Integer is begin return V; end;
    1414        Function Func( V : Float ) return Float is begin return V; end;
    1515        Function Func( V : Unbounded_String ) return Unbounded_String is begin return V; end;
    1616        Function Func( V1 : Integer; V2 : Float ) return Float is begin return Float(V1) + V2; end;
    17        
    18         subtype Int      is Integer;
     17
     18        subtype Int              is Integer;
    1919        J : Int;
    2020        Function "-"( L, R : Int ) return Int is begin Put_Line( "X" ); return Integer(L) + (-Integer(R)); end; --  prevent infinite recusion
    21        
    22 --      duplicate body for "-" declared at line 20
    23 --      subtype SInt is Integer range -10 .. 10;
    24 --      Function "-"( L, R : SInt ) return SInt is begin Put_Line( "X" ); return Integer(L) + (-Integer(R)); end; --  prevent infinite recusion
    25        
     21
     22        --      duplicate body for "-" declared at line 20
     23        --      subtype SInt is Integer range -10 .. 10;
     24        --      Function "-"( L, R : SInt ) return SInt is begin Put_Line( "X" ); return Integer(L) + (-Integer(R)); end; --  prevent infinite recusion
     25
    2626        i : Integer;
    2727        f : Float;
    2828        s : Unbounded_String;
    29        
     29
    3030        Type Complex is
    31         record
    32             Re, Im : Float;
    33         end record;
     31                record
     32                Re, Im : Float;
     33                end record;
    3434        c : Complex := (Re => 1.0, Im => 1.0);
    35     Procedure Grind (X : Complex) is begin Put_Line( "Grind1" ); end;
    36     Procedure Grind (X : Unbounded_String) is begin Put_Line( "Grind2" ); end;
    37        
     35        Procedure Grind (X : Complex) is begin Put_Line( "Grind1" ); end;
     36        Procedure Grind (X : Unbounded_String) is begin Put_Line( "Grind2" ); end;
     37
    3838        generic
    39            type T is private;
    40            with function "+"( X, Y: T ) return T;
     39                type T is private;
     40                with function "+"( X, Y: T ) return T;
    4141        function twice( X : T ) return T;
    42        
     42
    4343        function twice( X: T ) return T is
    4444        begin
    45            Put_Line( "XXX" ); return X + X;   -- The formal operator "*".
     45                Put_Line( "XXX" ); return X + X;        -- The formal operator "*".
    4646        end twice;
    4747
    4848        function Int_Twice is new Twice( Integer, "+" => "+" );
    4949        function float_Twice is new Twice( float, "+" => "+" );
    50        
    51 --      generic units cannot be overloaded
    52 --      generic
    53 --        type T is private;
    54 --        with function "+"( X, Y: T ) return T;
    55 --      function twice( X : T; Y : T ) return T;
    56        
    57 --      function twice( X: T; Y : T ) return T is
    58 --      begin
    59 --        Put_Line( "XXX" ); return X + X;   -- The formal operator "*".
    60 --      end twice;
     50
     51        --      generic units cannot be overloaded
     52        --      generic
     53        --              type T is private;
     54        --              with function "+"( X, Y: T ) return T;
     55        --      function twice( X : T; Y : T ) return T;
     56
     57        --      function twice( X: T; Y : T ) return T is
     58        --      begin
     59        --              Put_Line( "XXX" ); return X + X;        -- The formal operator "*".
     60        --      end twice;
    6161begin
    62    I := 3;
    63    I := 7 - 3;
    64         Print( i );
    65    F := 3.8;
    66    I := 7 - 2;
    67         Print( i );
    68    J := 7 - 3;
    69         Print( j );
    70    
     62        I := 3;
     63        I := 7 - 3;
     64        Print( i );
     65        F := 3.8;
     66        I := 7 - 2;
     67        Print( i );
     68        J := 7 - 3;
     69        Print( j );
     70
    7171        i := Random;
    72         Print( i );
     72        Print( i );
    7373        f := Random;
    74         Print( f );
     74        Print( f );
    7575        s := Random;
    76         Print( s );
    77        
    78         Print( Func( V => 7 ) );
    79         Print( Func( 7.5 ) );
    80         Print( Func( To_Unbounded_String( "abc" ) ) );
    81         Print( Func( 3, 3.5 ) );
    82 --      Print( Func( 3, 3 ) );
    83        
     76        Print( s );
     77
     78        Print( Func( V => 7 ) );
     79        Print( Func( 7.5 ) );
     80        Print( Func( To_Unbounded_String( "abc" ) ) );
     81        Print( Func( 3, 3.5 ) );
     82        --              Print( Func( 3, 3 ) );
     83
    8484        Grind( X => (Re => 1.0, Im => 1.0) );
    8585        Grind( c );
    8686        Grind( To_Unbounded_String( "abc" ) );
    87        
     87
    8888        i := Int_Twice( 2 );
    8989        Put_Line( Integer'Image(i) );
    9090        f := float_Twice( 2.5 );
    91         Print( f );
     91        Print( f );
    9292end test;
    9393

  • doc/theses/mike_brooks_MMath/intro.tex

    r8f448e0 r5e0b6657  
    22
    33All modern programming languages provide three high-level containers (collections): array, linked-list, and string.
    4 Often array is part of the programming language, while linked-list is built from (recursive) pointer types, and string from a combination of array and linked-list.
     4Often array is part of the programming language, while linked-lists are built from (recursive) pointer types, and strings from a combination of array and linked-list.
    55For all three types, languages and/or their libraries supply varying degrees of high-level mechanisms for manipulating these objects at the bulk and component level, such as copying, slicing, extracting, and iterating among elements.
    66
    77Unfortunately, these three aspects of C cause a significant number of memory errors~\cite{Oorschot23}.
     8Estimates suggest 50\%~\cite{Mendio24} of total reported open-source vulnerabilities occurring in C result from errors using these facilities (memory errors).
    89For operating system and browser vendors, who heavily use systems languages, 60\%--70\% of reported software vulnerabilities involved memory errors~\cite{Kehrer23}.
    910For Microsoft, 70\% of vulnerabilities addressed via security updates between 2006--2018 are memory safety issues~\cite[slide 10]{Miller19}.
    1011In a study of software exploits in the U.S. National Vulnerability Database over 2013--2017, the top reported vulnerability is (memory) buffer errors, among 19 vulnerability categories~\cite{Cifuentes19}.
    11 Therefore, hardening these three C types goes a long way to make the majority of C programs safer.
     12Therefore, hardening these three C types goes a long way to make the majority of C programs safer and eliminating major hacker attack-vectors.
    1213
    1314This work looks at extending these three foundational container types in the programming language \CFA, which is a new dialect of the C programming language.
    … …  
    2627The array size can be static, dynamic but fixed after creation, or dynamic and variable after creation.
    2728For static and dynamic-fixed, an array can be stack allocated, while dynamic-variable requires the heap.
    28 Because array layout has contiguous components, subscripting is a computation (some form of pointer arithmetic).
     29Because array layout has contiguous components, subscripting is a computation, \ie some form of pointer arithmetic.
    2930
    3031C provides a simple array type as a language feature.
    31 However, it adopts the controversial language position of treating pointer and array as duals, leading to multiple problems.
     32However, it adopts the controversial position of treating pointer and array as duals, leading to multiple problems.
    3233
    3334
    … …  
    3637A linked-list provides a homogeneous container often with $O(log N)$ or $O(N)$ access to elements using successor and predecessor operations that normally involve pointer chasing.
    3738Subscripting by value (rather than position or location as for array) is sometimes available, \eg hash table.
    38 Linked types are normally dynamically sized by adding and removing nodes using link fields internal or external to the elements (nodes).
    39 If a programming language allows pointers to stack storage, linked-list nodes can be allocated on the stack and connected with stack addresses (pointers);
     39Linked types are dynamically sized by adding and removing nodes using link fields internal or external to the list elements (nodes).
     40If a programming language allows pointers to stack storage, linked-list nodes can be allocated on the stack and connected with stack addresses;
    4041otherwise, elements are heap allocated with internal or external link fields.
    4142
    … …  
    4748hash search table consisting of a key (string) with associated data (@<search.h>@)
    4849\end{itemize}
    49 Because these libraries are simple, awkward to use, and unsafe, C programmers commonly build bespoke linked data-structures.
     50Because these container libraries can be restrictive, awkward to use, and unsafe, C programmers often build bespoke linked data-structures, which further increases the potential for memory errors.
    5051
    5152
    … …  
    5455A string provides a dynamic array of homogeneous elements, where the elements are (often) some form of human-readable characters.
    5556What differentiates a string from other types in that many of its operations work on groups of elements for scanning and changing, \eg @index@ and @substr@.
    56 While subscripting individual elements is usually available, working at the individual character level is considered poor practise, \ie underutilizing the powerful string operations.
     57While subscripting individual elements is usually available, working at the character level is considered poor practise, \ie underutilizing the powerful string operations.
    5758Therefore, the cost of a string operation is usually less important than the power of the operation to accomplish complex text manipulation, \eg search, analysing, composing, and decomposing string text.
    5859The dynamic nature of a string means storage is normally heap allocated but often implicitly managed, even in unmanaged languages.
    59 In some cases, string management is separate from heap management, \ie strings roll their own heap.
     60In many cases, string management is separate from heap management, \ie strings roll their own heap.
    6061
    6162The C string type is just a character array and requires user storage-management to handle varying size.
    62 The character array uses the convention of marking its (variable) array length by placing the 0-valued control character at the end (null-terminated).
     63C adopts a terminating sentinel character, @'\0'@, to mark the end of a variable-length character-array versus a preceding length field.
     64Hence, the sentinel character is excluded from a string and determining the string length is an $O(N)$ operation.
    6365The C standard library includes a number of high-level operations for working with this representation.
    64 Most of these operations are awkward and error prone.
     66Most of these operations are awkward to use and error prone.
    6567
    6668
    … …  
    8082\begin{enumerate}[leftmargin=*]
    8183\item
    82 These three aspects of C are difficult to understand, teach, and get right because they are correspondingly low level.
     84The three primary container types in C are difficult to understand, teach, and get right because they are too low level.
    8385Providing higher-level, feature-rich versions of these containers in \CFA is a major component of the primary goal.
     86The result is a simplify programming experience, which increases productivity and maintainability.
    8487\item
    85 These three aspects of C cause the greatest safety issues because there are few or no safe guards when a programmer misunderstands or misuses these features~\cite{Elliott18, Blache19, Ruef19, Oorschot23}.
    86 Estimates suggest 50\%~\cite{Mendio24} of total reported open-source vulnerabilities occurring in C result from errors using these facilities (memory errors), providing the major hacker attack-vectors.
     88The new container types must be as correct and safe to use as those in other modern programming languages, which has been shown to a primary concern of industry, government, and military~\cite{ONCD}.
     89Prior approaches focus on out-of-bound array accesses using a model-based approach (ASCET) in embedded systems (\eg cars)~\cite{Blache19}, and general and null-terminated string arrays using a \CC template syntax (Checked C)~\cite{Elliott18,Ruef19}.
     90Both White House~\cite{WhiteHouse24} and DARPA~\cite{DARPA24} recently released a recommendation to \emph{move away} from C and \CC, because of cybersecurity threats exploiting vulnerabilities in these languages.
     91Fixing these vulnerabilities negates this need, allowing C and its ecosystem to continue into the future.
    8792\end{enumerate}
    88 Both White House~\cite{WhiteHouse24} and DARPA~\cite{DARPA24} recently released a recommendation to move away from C and \CC, because of cybersecurity threats exploiting vulnerabilities in these older languages.
    89 Hardening these three types goes a long way to make the majority of C programs safer.
    9093
    91 
    92 While multiple new languages purport to be systems languages replacing C, the reality is that rewriting massive C code-bases is impractical and a non-starter if the new runtime uses garage collection.
     94While new languages, \eg Go, Rust, Swift, purport to be systems languages replacing C, the reality is that rewriting massive C code-bases is impractical and a non-starter if the runtime uses garbage collection.
     95Even assuming automated conversion of C programs to other safe languages, who will maintain this massive new code-base?
    9396Furthermore, new languages must still interact with the underlying C operating system through fragile, type-unsafe, interlanguage-communication.
    94 Switching to \CC is equally impractical as its complex and interdependent type-system (\eg objects, overloading, inheritance, templates) means idiomatic \CC code is difficult to use from C, and C programmers must expend significant effort learning new \CC.
    95 Hence, rewriting and retraining costs for these languages can be prohibitive for companies with a large C software-base (Google, Apple, Microsoft, Amazon, AMD, Nvidia).
     97Switching to \CC is equally impractical as its complex and interdependent type-system (\eg objects, overloading, inheritance, templates) means idiomatic \CC code is difficult to use from C, and C programmers must expend significant effort learning new \CC features and idioms.
     98Finally, projects claiming to be modern C replacements (Cyclone~\cite{Grossman06}, Polymorphic C~\cite{Smith98}, GObject~\cite{GObject}) do not retain C backwards compatibility in syntax, programing model, or semantic compatibility;
     99these languages are equivalent to switching to a different programming language.
     100Hence, rewriting and retraining costs for other languages are prohibitive when companies have a large C software-base (Google, Apple, Microsoft, Amazon, AMD, Nvidia).
    96101
    97102
    … …  
    100105Like many established programming languages, C has a standards committee and multiple ANSI/\-ISO language manuals~\cite{C99,C11,C18,C23}.
    101106However, most programming languages are only partially explained by their standard's manual(s).
    102 When it comes to explaining how C works, the definitive source is the @gcc@ compiler, which is mimicked by other C compilers, such as Clang~\cite{clang}.
    103 Often other C compilers \emph{must} mimic @gcc@ because a large part of the C library (runtime) system (@glibc@ on Linux) contains @gcc@ features.
     107When it comes to explaining how C works, the definitive source is the @gcc@ compiler, which is mimicked by other C compilers, such as Clang~\cite{clang}, because a large part of the C library (runtime) system (@glibc@ on Linux) contains @gcc@ features.
    104108Some key aspects of C need to be explained and understood by quoting from the language reference manual.
    105109However, to illustrate actual program semantics, this thesis constructs multiple small programs whose behaviour exercises a particular point and then confirms the behaviour by running the program using multiple @gcc@ compilers.
    106110These example programs show
    107 \begin{itemize}
     111\begin{itemize}[itemsep=0pt]
    108112        \item if the compiler accepts or rejects certain syntax,
    109113        \item prints output to buttress a behavioural claim,
    … …  
    111115\end{itemize}
    112116These programs are tested across @gcc@ versions 8--14 and clang versions 10--14 running on ARM, AMD, and Intel architectures.
    113 Any discovered anomalies among compilers, versions, or architectures is discussed.
     117Any discovered anomalies among compilers, versions, or architectures are discussed.
    114118In general, it is never clear whether the \emph{truth} lies in the C standard or the compiler(s), which may be true for other programming languages.
    115119
    … …  
    118122
    119123Overall, this work has produced significant syntactic and semantic improvements to C's arrays, linked-lists and string types.
    120 As well, a strong plan for general iteration has been sketched out.
     124% As well, a strong plan for general iteration has been sketched out.
    121125The following are the detailed contributions, where performance and safety were always the motivating factors.
    122126
    123127\subsection{Array}
    124128
    125 This work's array improvements are:
     129The improvements to C arrays are:
    126130\begin{enumerate}[leftmargin=*]
    127131\item
    128 Introduce a small number of subtle changes to the typing rules for the C array, while still achieving significant backwards compatibility
     132Introduce a small number of subtle changes to the typing rules for the C array, while still achieving significant backwards compatibility.
    129133\item
    130134Create a new polymorphic mechanism in the \CFA @forall@ clause to specify array dimension values, similar to a fixed-typed parameter in a \CC \lstinline[language=C++]{template}.

  • doc/theses/mike_brooks_MMath/uw-ethesis-frontpgs.tex

    r8f448e0 r5e0b6657  
    129129\begin{center}\textbf{Abstract}\end{center}
    130130
     131\CFA strives to fix mistakes in C, chief among them, safety.
     132This thesis presents a significant step forward in \CFA's goal to remove unsafe pointer operations.
     133The thesis presents improvements to the \CFA language design, both syntax and semantics, to support advanced container features.
     134These features are implemented across the \CFA compiler, libraries, and runtime system.
     135The results maintain another \CFA goal of remaining 99\% backwards compatible with C.
     136This thesis leverages preexisting work within the compiler's type and runtime systems generated by prior students working on the \CFA project.
     137
    131138All modern programming languages provide three high-level containers (collections): array, linked-list, and string.
    132 Often array is part of the programming language, while linked-list is built from (recursive) pointer types, and string from a combination of array and linked-list.
     139Often array is part of the programming language, while linked-lists are built from (recursive) pointer types, and strings from a combination of array and linked-list.
    133140For all three types, languages and/or their libraries supply varying degrees of high-level mechanisms for manipulating these objects at the bulk and component level, such as copying, slicing, extracting, and iterating among elements.
    134 Unfortunately, these three aspects of C cause 60\%--70\% of the reported software vulnerabilities involved memory errors, and 70\%--80\% of hacker attack-vectors target these types.
     141Unfortunately, these three aspects of C cause 60\%--70\% of the reported software vulnerabilities involving memory errors, and 70\%--80\% of hacker attack-vectors target these types.
    135142Therefore, hardening these three C types goes a long way to make the majority of C programs safer.
    136143
    137 This work looks at extending these three foundational container types in the programming language \CFA, which is a new dialect of the C programming language.
    138 The thesis describes improvements made to the \CFA language design, both syntax and semantics, to support the container features, and the source code created within the \CFA compiler, libraries, and runtime system to implement these features.
    139 This work leverages preexisting work within the compiler's type and runtime systems generated by prior students working on the \CFA project.
    140 
    141 Overall, this work has produced significant syntactic and semantic improvements to C's container types.
    142 \begin{enumerate}[leftmargin=*]
    143 \item
    144 Introduce a small number of subtle changes to the typing rules for the C array, while still achieving significant backwards compatibility.
    145 \item
    146 Create a new polymorphic mechanism in the \CFA @forall@ clause to specify array dimension values, similar to a fixed-typed parameter in a \CC \lstinline[language=C++]{template}.
    147 The new array type, enabled by prior features, defines an array with guaranteed runtime bound checks (often optimizer-removable) and implicit (guaranteed accurate) inter-function length communication.
    148 \item
    149 Create a new polymorphic list type and its runtime library following the established design pattern of intrusive link-fields for performance reasons, especially in concurrent programs.
    150 \item
    151 Create a new string type and runtime library comparable to the \CC @string@ type, including analogous coexistence with raw-character pointers, enabling programs to work with strings by value, without incurring excessive copying.
    152 Substrings are supported, including the ability for overlapping ranges to share edits transparently.
    153 \end{enumerate}
    154 The thesis includes a performance evaluation that shows the new \CFA containers perform comparably with their C counterparts in many programming cases.
     144Specifically, an array utility is provided that tracks length internally, relieving the user of managing explicit length parameters and stopping buffer-overrun errors.
     145This feature requires augmenting the \CFA type system, making array length available at compile and runtime.
     146A linked-list utility is provided, which obviates many explicit recursive pointers by catering directly to system-programming uses (intrusive lists) for which a library solution is often dismissed.
     147Finally, a string utility is provided with implicit memory management of text in a specialized heap, relieving error-prone buffer management, including overrun, and providing a copy-on-write speed boost.
     148For all three utilities, performance is argued to be on-par with, and occasionally surpassing relevant comparators.
     149With the array, this case is made by showing complete erasure down to a naked C array, modulo runtime bound checks, which are removable more often than with Java-style length management.
     150With the linked list and string, empirical measures are compared with relevant libraries.
     151These utilities offer a system programmer workable alternatives to hand-rolling several common causes of system vulnerabilities, thereby improving \CFA's position as a safety-forward system-programming alternative.
    155152
    156153\cleardoublepage

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

    r8f448e0 r5e0b6657  
    1111%% Created On       : Wed Apr  6 14:53:29 2016
    1212%% Last Modified By : Peter A. Buhr
    13 %% Last Modified On : Mon Sep  8 18:10:30 2025
    14 %% Update Count     : 6534
     13%% Last Modified On : Mon Nov 17 11:14:48 2025
     14%% Update Count     : 6677
    1515%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    1616
    … …  
    345345
    346346\begin{cquote}
     347\setlength{\tabcolsep}{5pt}
    347348\begin{tabular}{@{}l|ll@{}}
    348349\begin{uC++}
    349350
    350351
    351 void main() {
     352void Coroutine::main() {
    352353        try {
    353354                _Enable {
    … …  
    357358          catch( E & ) { ... }
    358359}
     360void Coroutine::mem() { resume(); }
    359361\end{uC++}
    360362&
    … …  
    362364#define resumePoll( coroutine ) resume( coroutine ); poll()
    363365#define suspendPoll suspend; poll()
    364 void main() {
     366void main( Coroutine & cor ) {
    365367        try {
    366368                enable_ehm();
    … …  
    370372          catch( E & ) { ... }
    371373}
     374void mem( Coroutine & cor ) { resumePoll(); }
    372375\end{cfa}
    373376\end{tabular}
    … …  
    429432\end{tabular}
    430433\end{cquote}
     434
     435
     436\section{Time}
     437
     438\begin{cquote}
     439\setlength{\tabcolsep}{5pt}
     440\begin{tabular}{@{}l|l@{}}
     441\begin{uC++}
     442
     443uTime start = uClock::currTime();
     444...
     445cout << "duration " << uClock::currTime() - start
     446        << " sec." << endl;
     447\end{uC++}
     448&
     449\begin{cfa}
     450#include <clock.hfa>
     451Time start = timeHiRes(); // time with nanoseconds
     452...
     453sout | "duration " | timeHiRes() - start | " sec.";
     454
     455\end{cfa}
     456\end{tabular}
     457\end{cquote}
     458
     459
     460\section{Constructor / Destructor}
     461
     462A constructor/destructor must have its structure type as the first parameter and be a reference.
     463\begin{cquote}
     464\begin{tabular}{@{}l|l@{}}
     465\begin{uC++}
     466
     467struct S {
     468        int i, j;
     469        @S@() { i = j = 3; }
     470        @S@( int i, int j ) { S::i = i; S::j = j; }
     471        @S@( const S & s ) { *this = s; }
     472        @~S@() {}
     473};
     474S s0, s1 = { 1, 2 };
     475
     476S * s2 = new S{ 1, 2 };   delete s2;
     477s2 = new S{ 1, 2 };   delete s2;
     478S & s3 = *new S{ 1, 2 };   delete &s3;
     479s3 = *new S{ 1, 2 };   delete &s3;
     480\end{uC++}
     481&
     482\begin{cfa}
     483#include <stdlib.hfa> // new (malloc)
     484struct S { int i, j; };
     485
     486void @?{}@( @S & s@ ) { s.i = s.j = 3; } $\C[3in]{// default}$
     487void @?{}@( @S & s@, int i, int j ) { s.i = i; s.j = j; } $\C{// initializer}$
     488void @?{}@( @S & s@, const S rhs ) { ?{}( s, rhs.i, rhs.j ); } $\C{// copy}$
     489void @^?{}@( @S & s@ ) { s.i = 0; s.j = 0; } $\C{// destructor}\CRT$
     490
     491S s0, s1 = { 1, 2 };
     492// bug, cannot use 0/1 (zero_t/one_t) with "new"
     493S * s2 = new( 0@n@, 2 );   /* suffix n => (natural int) */  delete( s2 );
     494s2 = new( 1@n@, 2 );   delete( s2 );
     495S & s3 = *new( 2, 2 );   delete( &s3 );
     496&s3 = &*new( 3, 2 );   delete( &s3 );
     497\end{cfa}
     498\end{tabular}
     499\end{cquote}
     500
     501
     502\section{\texorpdfstring{Structures (object-oriented \protect\vs routine style)}{Structures (object-oriented vs. routine style)}}
     503
     504\CFA is NOT an object-oriented programming-language, so there is no receiver (\lstinline[language=c++]{this}) or nested structure routines.
     505The equivalent of a \emph{member} routine has an explicit structure parameter in any parameter position (often the first).
     506\begin{cquote}
     507\begin{tabular}{@{}l|l@{}}
     508\begin{uC++}
     509struct S {
     510        int i = 0;  // cheat, implicit default constructor
     511        int setter( int j ) { int t = i; i = j; return t; }
     512        int getter() { return i; }
     513};
     514S s;
     515@s.@setter( 3 );  // object calls
     516int k = @s.@getter();
     517\end{uC++}
     518&
     519\begin{cfa}
     520struct S {  int i;  };
     521void ?{}( S & s ) { s.i = 0; } // explicit default constructor
     522int setter( @S & s,@ int j ) @with( s )@ { int t = i; i = j; return t; }
     523int getter( @S & s@ ) @with( s )@ { return i; }
     524
     525S s;
     526setter( @s,@ 3 );  // normal calls
     527int k = getter( @s@ );
     528\end{cfa}
     529\end{tabular}
     530\end{cquote}
     531Aggregate qualification is reduced or eliminated by opening scopes using the @with@ clause.
     532\begin{cfa}
     533struct S { int i; int j; double m; };  // field i has same type in structures S and T
     534struct T { int i; int k; int m; };
     535void foo( S s, T t ) @with( s, t )@ {   // open structure scope s and t in parallel
     536        j + k;                          $\C[1.6in]{// unambiguous, s.j + t.k}$
     537        m = 5.0;                        $\C{// unambiguous, s.m = 5.0}$
     538        m = 1;                          $\C{// unambiguous, t.m = 1}$
     539        int a = m;                      $\C{// unambiguous, a = t.m}$
     540        double b = m;           $\C{// unambiguous, b = s.m}$
     541        int c = s.i + t.i;      $\C{// unambiguous with qualification}$
     542        (double)m;                      $\C{// unambiguous with cast s.m}\CRT$
     543}
     544\end{cfa}
     545\noindent
     546In subsequent code examples, the left example is \CC/\uC and the right example is \CFA.
    431547
    432548
    … …  
    474590
    475591
     592\enlargethispage{1000pt}
    476593\section{\texorpdfstring{\lstinline{uArray}}{uArray}}
    477594
    … …  
    525642\end{cquote}
    526643
    527 
    528 \section{\texorpdfstring{Structures (object-oriented \protect\vs routine style)}{Structures (object-oriented vs. routine style)}}
    529 
    530 \CFA is NOT an object-oriented programming-language, so there is no receiver (\lstinline[language=c++]{this}) or nested structure routines.
    531 The equivalent of a \emph{member} routine has an explicit structure parameter in any parameter position (often the first).
    532 \begin{cquote}
    533 \begin{tabular}{@{}l|l@{}}
     644\newpage
     645
     646
     647\section{Doubly-Linked Intrusive List}
     648
     649\begin{cquote}
     650\setlength{\tabcolsep}{10pt}
     651\begin{tabular}{@{}l|l@{}}
     652\begin{uC++}
     653#include <iostream>
     654using namespace std;
     655struct Node : @public uSeqable@ {
     656        int i;
     657        Node( int i ) : i( i ) {}
     658};
     659
     660
     661int main() {
     662        @uSequence<Node> dlist;@
     663        Node n1{ 1 }, n2{ 2 }, n3{ 3 };
     664        dlist.addTail( &n1 );
     665        dlist.addHead( &n2 );  // out of order
     666        dlist.insertAft( &n1, &n3 );  // insertBef
     667        for ( Node * it = dlist.head(); it; it = dlist.succ( it ) ) {
     668                cout << it->i << endl;
     669        }
     670        dlist.remove( &n3 );  // shorten list
     671        dlist.dropTail();  // dropHead
     672        Node * it;
     673        for ( uSeqIter<Node> seqit(dlist);  // uSeqIterRev
     674                          seqit >> it; ) {
     675                cout << it->i << endl;
     676        }
     677}
     678\end{uC++}
     679&
     680\begin{cfa}
     681#include <fstream.hfa>
     682#include <list.hfa>
     683struct Node {
     684        @inline dlink( Node );@
     685        int i;
     686};
     687@P9_EMBEDDED( Node, dlink( Node ) );@  // magic
     688void ?{}( Node & node, int i ) { node.i = i; }
     689int main() {
     690        @dlist( Node ) dlist;@
     691        Node n1{ 1 }, n2{ 2 }, n3{ 3 };
     692        insert_last( dlist, n1 );
     693        insert_first( dlist, n2 );  // out of order
     694        insert_after( n1, n3 );  // insert_before
     695        for ( Node & it = first( dlist ); &it; &it = &next( it ) ) {
     696                sout | it.i;
     697        }
     698        remove( n3 );  // shorten list
     699        remove_last( dlist );  // remove_first
     700
     701        FOREACH( dlist, it ) {  // FOREACH_REV
     702
     703                sout | it.i;
     704        }
     705}
     706\end{cfa}
     707\end{tabular}
     708\end{cquote}
     709
     710
     711\section{RAII Dynamic Allocation}
     712
     713\begin{cquote}
     714\begin{tabular}{@{}l|ll@{}}
    534715\begin{uC++}
    535716struct S {
    536         int i = 0;  // cheat, implicit default constructor
    537         int setter( int j ) { int t = i; i = j; return t; }
    538         int getter() { return i; }
    539 };
    540 S s;
    541 @s.@setter( 3 );  // object calls
    542 int k = @s.@getter();
    543 \end{uC++}
    544 &
    545 \begin{cfa}
    546 struct S {  int i;  };
    547 void ?{}( S & s ) { s.i = 0; } // explicit default constructor
    548 int setter( @S & s,@ int j ) @with( s )@ { int t = i; i = j; return t; }
    549 int getter( @S & s@ ) @with( s )@ { return i; }
    550 
    551 S s;
    552 setter( @s,@ 3 );  // normal calls
    553 int k = getter( @s@ );
    554 \end{cfa}
    555 \end{tabular}
    556 \end{cquote}
    557 Aggregate qualification is reduced or eliminated by opening scopes using the @with@ clause.
    558 \begin{cfa}
    559 struct S { int i; int j; double m; };  // field i has same type in structures S and T
    560 struct T { int i; int k; int m; };
    561 void foo( S s, T t ) @with( s, t )@ {   // open structure scope s and t in parallel
    562         j + k;                          $\C[1.6in]{// unambiguous, s.j + t.k}$
    563         m = 5.0;                        $\C{// unambiguous, s.m = 5.0}$
    564         m = 1;                          $\C{// unambiguous, t.m = 1}$
    565         int a = m;                      $\C{// unambiguous, a = t.m}$
    566         double b = m;           $\C{// unambiguous, b = s.m}$
    567         int c = s.i + t.i;      $\C{// unambiguous with qualification}$
    568         (double)m;                      $\C{// unambiguous with cast s.m}\CRT$
    569 }
    570 \end{cfa}
    571 \noindent
    572 In subsequent code examples, the left example is \CC/\uC and the right example is \CFA.
    573 
    574 
    575 \section{Constructor / Destructor}
    576 
    577 A constructor/destructor must have its structure type as the first parameter and be a reference.
    578 \begin{cquote}
    579 \begin{tabular}{@{}l|l@{}}
    580 \begin{uC++}
    581 
    582 struct S {
    583         int i, j;
    584         @S@() { i = j = 3; }
    585         @S@( int i, int j ) { S::i = i; S::j = j; }
    586         @S@( const S & s ) { *this = s; }
    587         @~S@() {}
    588 };
    589 S s0;
    590 S s1 = { 1, 2 };
    591 
    592 S * s2 = new S{ 1, 2 };
    593 delete s2;
    594 s2 = new S{ 1, 2 };
    595 delete s2;
    596 S & s3 = *new S{ 1, 2 };
    597 delete &s3;
    598 s3 = *new S{ 1, 2 };
    599 delete &s3;
    600 \end{uC++}
    601 &
    602 \begin{cfa}
    603 #include <stdlib.hfa> // new (malloc)
    604 struct S { int i, j; };
    605 
    606 void @?{}@( @S & s@ ) { s.i = s.j = 3; } $\C[3in]{// default}$
    607 void @?{}@( @S & s@, int i, int j ) { s.i = i; s.j = j; } $\C{// initializer}$
    608 void @?{}@( @S & s@, const S rhs ) { ?{}( s, rhs.i, rhs.j ); } $\C{// copy}$
    609 void @^?{}@( @S & s@ ) { s.i = 0; s.j = 0; } $\C{// destructor}\CRT$
    610 
    611 S s0;
    612 S s1 = { 1, 2 };
    613 // bug, cannot use 0/1 (zero_t/one_t) with "new"
    614 S * s2 = new( 0@n@, 2 ); // suffix n => (natural int)
    615 delete( s2 );
    616 s2 = new( 1@n@, 2 );
    617 delete( s2 );
    618 S & s3 = *new( 2, 2 );
    619 delete( &s3 );
    620 &s3 = &*new( 3, 2 );
    621 delete( &s3 );
     717        ...    S() { ... }    ~S() { ... }   // ctor / dtor
     718};
     719S * s = new S;             delete s;
     720S * sa = new S[10];     delete [] sa;
     721\end{uC++}
     722&
     723\begin{cfa}
     724#include <stdlib.hfa>
     725struct S { ... };
     726void ?{}( S & ) { ... }    void ^?{}( S & ) { ... }   // ctor / dtor
     727S * s = new();        delete( s );
     728S * sa = anew( 10 );    adelete( sa );
    622729\end{cfa}
    623730\end{tabular}
    … …  
    660767}
    661768\end{cfa}
    662 \\
    663 \multicolumn{2}{@{}l@{}}{\lstinline{C c;}}
    664769\end{tabular}
    665770\end{cquote}
    … …  
    708813
    709814\begin{cquote}
     815\setlength{\tabcolsep}{10pt}
    710816\begin{tabular}{@{}l|ll@{}}
    711817\begin{uC++}
    … …  
    738844}
    739845\end{cfa}
    740 \end{tabular}
    741 \begin{tabular}{@{}l|ll@{}}
     846\\
    742847\begin{uC++}
    743848_Actor Hello { ${\color{red}\LstCommentStyle{// : public uActor}}$
    … …  
    829934
    830935uOwnerLock m;
    831 uCondLock s;
     936uCondLock c;
    832937m.acquire();
    833 if ( ! s.empty() ) s.wait( m );
     938if ( ! c.empty() ) c.wait( m );
    834939else {
    835940        m.release();
    … …  
    841946#include <locks.hfa>
    842947owner_lock m;
    843 cond_lock( owner_lock ) s;  // generic type on mutex lock
     948cond_lock( owner_lock ) c;  // generic type on mutex lock
    844949lock( m );
    845 if ( ! empty( s ) ) wait( s, m );
     950if ( ! empty( c ) ) wait( c, m );
    846951else {
    847952        unlock( m );
    … …  
    852957\end{cquote}
    853958
     959\begin{cquote}
     960\begin{tabular}{@{}l|ll@{}}
     961\begin{uC++}
     962
     963uSemaphore m, c;
     964m.P();
     965if ( ! c.empty() ) c.P( m );
     966else {
     967        m.V();
     968}
     969\end{uC++}
     970&
     971\begin{cfa}
     972#include <locks.hfa>
     973semaphore m, c;
     974P( m );
     975if ( ! empty( c ) ) P( c, m );
     976else {
     977        V( m );
     978}
     979\end{cfa}
     980\end{tabular}
     981\end{cquote}
     982
     983
     984\enlargethispage{1000pt}
    854985
    855986\section{Barrier}
    … …  
    8881019#include <mutex_stmt.hfa>
    8891020struct Barrier {
    890         @barrier b;@                    // containment
     1021        @inline barrier;@
    8911022        int total;
    8921023
    8931024};
    894 void ?{}( Barrier & B, unsigned int group ) with(B) {
    895         @?{}( b, group );@              // initialize barrier
     1025void ?{}( Barrier & b, unsigned int group ) with( b ) {
     1026        @(b){ group };@         // initialize barrier
    8961027        total = 0;
    8971028}
    898 unsigned int block( Barrier & B, int subtotal ) with(B) {
    899         void @last@() { sout | total; } // called by Gth arriving thread
     1029unsigned int block( Barrier & b, int subtotal ) with( b ) {
     1030        void @last@(...) { sout | total; }      // called by Gth arriving thread
    9001031        @mutex( b )@ {  // use barrier's mutual exclusion
    9011032                total += subtotal;
    … …  
    9091040\end{cquote}
    9101041
     1042\newpage
    9111043
    9121044\enlargethispage{1000pt}
    … …  
    9161048Internal Scheduling
    9171049\begin{cquote}
     1050\setlength{\tabcolsep}{5pt}
    9181051\begin{tabular}{@{}l|ll@{}}
    9191052\begin{uC++}
    … …  
    9791112\end{cquote}
    9801113
    981 \newpage
     1114\bigskip
    9821115\noindent
    9831116External Scheduling
    9841117\begin{cquote}
     1118\setlength{\tabcolsep}{5pt}
    9851119\begin{tabular}{@{}l|ll@{}}
    9861120\begin{uC++}
    … …  
    10391173
    10401174
    1041 \input{uC++toCFA.ind}
     1175\newpage
     1176
     1177\section{Futures (reference counting)}
     1178
     1179
     1180{\lstset{tabsize=3}
     1181\setlength{\tabcolsep}{5pt}
     1182\begin{tabular}{@{}l|ll@{}}
     1183\begin{uC++}
     1184#include <uFuture.h>
     1185@Future_ISM@<int> fi;
     1186@Future_ISM@<double> fd;
     1187struct Msg { int i, j; }; @Future_ISM@<Msg> fm;
     1188struct Stop {}; @Future_ISM@<Stop> fs;
     1189struct Cont {}; @Future_ISM@<Cont> fc;
     1190
     1191_Task Worker {
     1192        void main() {
     1193
     1194                for ( ;; ) {
     1195                        _Select( fi ) { cout << fi() << endl; fi.reset(); }
     1196                        and _Select( fd ) { cout << fd() << endl; fd.reset(); }
     1197                        and _Select( fm ) {
     1198                                cout << fm().i << " " << fm().j << endl; fm.reset();
     1199                        } or _Select( fs ) { cout << "stop" << endl; break; }
     1200                        fc.delivery( (Cont){} );        // synchronize
     1201                }
     1202        }
     1203
     1204};
     1205int main() {
     1206        Worker worker;
     1207        for ( int i = 0; i < 10; i += 1 ) {
     1208                fi( i );   fd( i + 2.5 );   fm( (Msg){ i, 2 } ); // fulfil
     1209                fc(); fc.reset();                               // synchronize
     1210        }
     1211        fs( (Stop){} );
     1212} // wait for worker to terminate
     1213\end{uC++}
     1214&
     1215\begin{cfa}
     1216#include <future.hfa>
     1217@future_rc@(int) fi;
     1218@future_rc@(double) fd;
     1219struct Msg { int i, j; }; @future_rc@(Msg) fm;
     1220struct Stop {}; @future_rc@(Stop) fs;
     1221struct Cont {}; @future_rc@(Cont) fc;
     1222ExceptionDecl( Break );
     1223thread Worker {};
     1224void main( Worker & ) {
     1225        try {
     1226                for () {
     1227                        waituntil( fi ) { sout | fi(); reset( fi ); }
     1228                        and waituntil( fd ) { sout | fd(); reset( fd ); }
     1229                        and waituntil( fm ) { sout | fm().i | fm().j; reset( fm ); }
     1230                        or waituntil( fs ) { sout | "stop";
     1231                                throw ExceptionInst( Break );
     1232                        }
     1233                        fc( (Cont){} );         // synchronize
     1234                }
     1235        } catch( Break * ) {}
     1236}
     1237int main() {
     1238        Worker worker;
     1239        for ( i; 10 ) {
     1240                fi( i );   fd( i + 2.5 );   fm( (Msg){ i, 2 } ); // fulfil
     1241                fc(); reset( fc );              // synchronize
     1242        }
     1243        fs( (Stop){} );
     1244} // wait for worker to terminate
     1245\end{cfa}
     1246\end{tabular}
     1247}%
     1248
     1249%\input{uC++toCFA.ind}
    10421250
    10431251% \bibliographystyle{plain}
Note: See TracChangeset for help on using the changeset viewer.