Changeset 3eb55f98


Ignore:
Timestamp:
Apr 29, 2021, 4:26:37 PM (3 months ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
arm-eh, jacob/cs343-translation, master
Children:
34b2796, 63a4b92
Parents:
c993b15 (diff), 2d8a770 (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 branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Files:
13 edited

Legend:

Unmodified
Added
Removed
  • doc/LaTeXmacros/common.tex

    rc993b15 r3eb55f98  
    1111%% Created On       : Sat Apr  9 10:06:17 2016
    1212%% Last Modified By : Peter A. Buhr
    13 %% Last Modified On : Sun Feb 14 15:52:46 2021
    14 %% Update Count     : 524
     13%% Last Modified On : Tue Apr 27 12:03:17 2021
     14%% Update Count     : 539
    1515%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    1616
     
    102102\renewcommand\subsubsection{\@startsection{subsubsection}{3}{\z@}{-2.5ex \@plus -1ex \@minus -.2ex}{1.0ex \@plus .2ex}{\normalfont\normalsize\bfseries}}
    103103\renewcommand\paragraph{\@startsection{paragraph}{4}{\z@}{-2.0ex \@plus -1ex \@minus -.2ex}{-1em}{\normalfont\normalsize\bfseries}}
     104\renewcommand\subparagraph{\@startsection{subparagraph}{4}{\z@}{-1.5ex \@plus -1ex \@minus -.2ex}{-1em}{\normalfont\normalsize\bfseries\itshape}}
    104105
    105106% index macros
     
    284285showlines=true,                                                 % show blank lines at end of code
    285286aboveskip=4pt,                                                  % spacing above/below code block
    286 belowskip=0pt,
     287belowskip=2pt,
    287288numberstyle=\footnotesize\sf,                   % numbering style
    288289% replace/adjust listing characters that look bad in sanserif
     
    297298\lstset{
    298299language=CFA,
    299 moredelim=**[is][\color{red}]{@}{@},    % red highlighting @...@
    300 %moredelim=**[is][\color{red}]{®}{®},   % red highlighting ®...® (registered trademark symbol) emacs: C-q M-.
     300%moredelim=**[is][\color{red}]{@}{@},   % red highlighting @...@
     301moredelim=**[is][\color{red}]{®}{®},    % red highlighting ®...® (registered trademark symbol) emacs: C-q M-.
    301302%moredelim=**[is][\color{blue}]{ß}{ß},  % blue highlighting ß...ß (sharp s symbol) emacs: C-q M-_
    302303%moredelim=**[is][\color{OliveGreen}]{¢}{¢}, % green highlighting ¢...¢ (cent symbol) emacs: C-q M-"
  • doc/theses/andrew_beach_MMath/Makefile

    rc993b15 r3eb55f98  
    3434        ${LATEX} ${BASE}
    3535        ${BIBTEX} ${BUILD}/${BASE}
    36         ${LATEX} ${BASE}
    3736        ${GLOSSARY} ${BUILD}/${BASE}
    3837        ${LATEX} ${BASE}
  • doc/theses/andrew_beach_MMath/cfalab.sty

    rc993b15 r3eb55f98  
    1010
    1111% Other packages required.
     12%
     13% Access to new basic LaTeX tools and other low level commands.
    1214\RequirePackage{etoolbox}
     15% Code formatting tools and environments.
    1316\RequirePackage{listings}
     17% Automatically adds spaces.
    1418\RequirePackage{xspace}
     19% Improved reference tools.
     20\RequirePackage[nospace]{varioref}
    1521
    1622% Symbols: All symbols are zero argument robust commands with special rules
     
    2026
    2127% \newsymbolcmd{<command>}{<replacement text>}
    22 %     Defines <command> to be a symbol that has the given <replacement text>.
     28% Defines <command> to be a symbol that has the given <replacement text>.
    2329\newrobustcmd*\newsymbolcmd[2]{\newrobustcmd{#1}{\cfalab@symbol{#2}}}
    2430\def\cfalab@symbol#1{\@ifnextchar*{#1\cfalab@eatstar}{#1\xspace}}
     
    2834\newsymbolcmd\CFA{\textsf{C}\raisebox{\depth}{\rotatebox{180}{\textsf{A}}}}
    2935% C++ with kerning. (No standard number support.)
    30 \newsymbolcmd\CPP{\textrm{C}\kern-.1em\hbox{+\kern-.25em+}}
     36\newsymbolcmd\Cpp{\textrm{C}\kern-.1em\hbox{+\kern-.25em+}}
    3137
    32 % This is executed very early in the \begin{document} code.
     38% This is executed very early in the \begin{document} code, before the
     39% document's contents but after packages are loaded.
    3340\AtEndPreamble{
    3441  \@ifpackageloaded{hyperref}{
     
    3643    \pdfstringdefDisableCommands{
    3744      \def\CFA{CFA}
    38       \def\CPP{C++}
     45      \def\Cpp{C++}
     46      \def\lstinline{}
    3947    }
    4048  }{}
    4149}
     50
     51% \colour{<colour>}{<text>}
     52% Just \color but using the LaTeX style instead of TeX style command.
     53\newcommand*\colour[2]{{\color{#1}#2}}
     54
     55% \code*{<code>}
     56% Use the listings package to format a snipit of <code>.
     57\newrobustcmd*\codeCFA[1]{\lstinline[language=CFA]{#1}}
     58\newrobustcmd*\codeC[1]{\lstinline[language=C]{#1}}
     59\newrobustcmd*\codeCpp[1]{\lstinline[language=C++]{#1}}
     60\newrobustcmd*\codePy[1]{\lstinline[language=Python]{#1}}
     61
     62% Use the listings package to format a block of CFA code.
     63% Extra listings options can be passed in as an optional argument.
     64\lstnewenvironment{cfa}[1][]{\lstset{language=CFA}\lstset{#1}}{}
     65
     66% \settextunderscore{(new|old)}
     67% Redefines the underscore either as a new repersentation or the old one.
     68% Not that some other packages (ex. hyperref) can override this. Set it up
     69% after loading them.
     70\let\cfalab@textunderscore@old=\textunderscore
     71\newcommand\cfalab@textunderscore@new{%
     72    \leavevmode\makebox[1.2ex][c]{\rule{1ex}{0.075ex}}}
     73\newcommand\settextunderscore[1]{%
     74    \renewcommand\textunderscore{\csuse{cfalab@textunderscore@#1}}}
    4275
    4376% The CFA listings language. Based off of ANCI C and including GCC extensions.
     
    6194\lstset{defaultdialect={[UW]CFA}}
    6295
    63 % The cfalab style defines some common settings useful in different languages.
    64 \lstdefinestyle{cfalab}{%
    65     columns=fullflexible,
    66     basicstyle=\linespread{0.9}\tt,
    67     stringstyle=\tt,
     96% Create an internal paragraph indent amount. This is used internally to
     97% mimic the standard indent even when it has been overriden in the document.
     98\newlength\cfalab@parindent
     99\deflength\cfalab@parindent{\parindent}
     100
     101% The cfacommon style has many useful defaults for CFA and other types of
     102% code. Use the listings option "style=cfacommon" to load them.
     103\lstdefinestyle{cfacommon}{
     104  columns=fullflexible,
     105  basicstyle=\linespread{0.9}\sf,
     106  stringstyle=\tt,
     107  tabsize=5,
     108  % Indent code to paragraph indentation.
     109  xleftmargin=\cfalab@parindent,
     110  % Allow ASCII characters in the range 128-255.
     111  extendedchars=true,
     112  % This allows you to use "math mode" to insert LaTeX into the code.
     113  % Use \( and \) if you need to insert math mode inside that code.
     114  escapechar=\$,
     115  % Disable LaTeX math escape in CFA code $...$
     116  mathescape=false,
     117  keepspaces=true,
     118  % Do not show spaces with cup.
     119  showstringspaces=false,
     120  % Show blank lines at end of code.
     121  showlines=true,
     122  % Spacing above/below code block.
     123  aboveskip=4pt,belowskip=0pt,
     124  numberstyle=\footnotesize\sf,
     125  % Replace/adjust listing characters that look bad in sanserif.
     126  literate={-}{\makebox[1ex][c]{\raisebox{0.4ex}{\rule{0.75ex}{0.1ex}}}}1
     127    {^}{\raisebox{0.6ex}{$\scriptscriptstyle\land\,$}}1
     128    {~}{\raisebox{0.3ex}{$\scriptstyle\sim\,$}}1 {`}{\ttfamily\upshape\hspace*{-0.1ex}`}1
     129    {<-}{$\leftarrow$}2 {=>}{$\Rightarrow$}2
     130    {->}{\makebox[1ex][c]{\raisebox{0.4ex}{\rule{0.8ex}{0.075ex}}}\kern-0.2ex\textgreater}2,
    68131}
    69132
    70 % \code*[<escape character>]{<code>}
    71 %     Use the listings package to format a snipit of <code>.
    72 %     The <escape character> must be a character that does not appear in
    73 %     <code> and defaults to a backtick.
    74 \newcommand*\codeC[2][\`]{\lstinline[language=C]#1#2#1}
    75 \newcommand*\codeCFA[2][\`]{\lstinline[language=CFA]#1#2#1}
     133% common.tex Compatablity ===================================================
     134% Below this line is for compatability with the old common.tex file.
    76135
    77 % \settextunderscore{(new|old)}
    78 %     Redefines the underscore either as a new repersentation or the old one.
    79 %     Not that some other packages (ex. hyperref) can override this. Set it
    80 %     up after loading them.
    81 \let\cfalab@textunderscore@old=\textunderscore
    82 \newcommand\cfalab@textunderscore@new{%
    83     \leavevmode\makebox[1.2ex][c]{\rule{1ex}{0.075ex}}}
    84 \newcommand\settextunderscore[1]{%
    85     \renewcommand\textunderscore{\csuse{cfalab@textunderscore@#1}}}
     136% Backwards compatable way to activate the cfacommon style.
     137\newcommand{\CFAStyle}{\lstset{style=cfacommon}}
     138
     139% A couple of abbreviations are provided. Just ones someone liked.
     140%
     141% Abbreviation formatting commands (renew to customize):
     142\newcommand{\abbrevFont}{\textit}
     143%
     144% Abbreviations that, if not followed by a comma or colon, add a comma.
     145\newrobustcmd*\cfalab@abbrev@comma{%
     146  \@ifnextchar{,}{}{\@ifnextchar{:}{}{,\xspace}}}
     147\providerobustcmd*\eg{\abbrevFont{e}.\abbrevFont{g}.\cfalab@abbrev@comma}
     148\providerobustcmd*\ie{\abbrevFont{i}.\abbrevFont{e}.\cfalab@abbrev@comma}
     149%
     150% Abbreviations that, if not followed by a period, add a period.
     151\newrobustcmd*\cfalab@abbrev@period{\@ifnextchar{.}{}{.\xspace}}
     152\providerobustcmd*\etc{\abbrevFont{etc}\cfalab@abbrev@period}
     153\providerobustcmd*\etal{\abbrevFont{et}~\abbrevFont{al}\cfalab@abbrev@period}
     154\providerobustcmd*\viz{\abbrevFont{viz}\cfalab@abbrev@period}
    86155
    87156\endinput
  • doc/theses/andrew_beach_MMath/existing.tex

    rc993b15 r3eb55f98  
    1616to be defined~\cite{Moss18}.
    1717\begin{cfa}
    18 char i; int i; double i;                        $\C[3.75in]{// variable overload}$
    19 int f(); double f();                            $\C{// return overload}$
    20 void g( int ); void g( double );        $\C{// parameter overload}\CRT$
     18char i; int i; double i;
     19int f(); double f();
     20void g( int ); void g( double );
    2121\end{cfa}
    2222This feature requires name mangling so the assembly symbols are unique for
     
    2626mangling is:
    2727\begin{cfa}
    28 // name mangling
     28// name mangling on by default
    2929int i; // _X1ii_1
    30 @extern "C"@ {  // no name mangling
     30extern "C" {  // disables name mangling
    3131        int j; // j
    32         @extern "Cforall"@ {  // name mangling
     32        extern "Cforall" {  // enables name mangling
    3333                int k; // _X1ki_1
    3434        }
    35         // no name mangling
    36 }
    37 // name mangling
     35        // revert to no name mangling
     36}
     37// revert to name mangling
    3838\end{cfa}
    3939Both forms of @extern@ affect all the declarations within their nested lexical
     
    5050\begin{cfa}
    5151int i, j;
    52 int @&@ ri = i, @&&@ rri = ri;
     52int & ri = i, && rri = ri;
    5353rri = 3;  // auto-dereference assign to i
    54 @&@ri = @&@j; // rebindable
     54&ri = &j; // rebindable
    5555ri = 5;   // assign to j
    5656\end{cfa}
     
    6464
    6565In general, operator names in \CFA are constructed by bracketing an operator
    66 token with @?@, which indicates the position of the arguments. For example, infixed
    67 multiplication is @?*?@ while prefix dereference is @*?@. This syntax make it
    68 easy to tell the difference between prefix operations (such as @++?@) and
    69 post-fix operations (@?++@).
     66token with @?@, which indicates the position of the arguments. For example,
     67infixed multiplication is @?*?@ while prefix dereference is @*?@.
     68This syntax make it easy to tell the difference between prefix operations
     69(such as @++?@) and post-fix operations (@?++@).
    7070
    7171The special name for a constructor is @?{}@, which comes from the
    72 initialization syntax in C. The special name for a destructor is @^{}@, where
    73 the @^@ has no special meaning.
     72initialization syntax in C. That initialation syntax is also the operator
     73form. \CFA will generate a constructor call each time a variable is declared,
     74passing the initialization arguments to the constructort.
     75\begin{cfa}
     76struct Example { ... };
     77void ?{}(Example & this) { ... }
     78{
     79        Example a;
     80        Example b = {};
     81}
     82void ?{}(Example & this, char first, int num) { ... }
     83{
     84        Example c = {'a', 2};
     85}
     86\end{cfa}
     87Both @a@ and @b@ will be initalized with the first constructor (there is no
     88general way to skip initialation) while @c@ will be initalized with the
     89second.
     90
    7491% I don't like the \^{} symbol but $^\wedge$ isn't better.
    75 \begin{cfa}
    76 struct T { ... };
    77 void ?@{}@(@T &@ this, ...) { ... }  // constructor
    78 void ?@^{}@(@T &@ this, ...) { ... } // destructor
     92Similarly destructors use the special name @^?{}@ (the @^@ has no special
     93meaning). They can be called explicatly as well but normally they are
     94implicitly called on a variable when it goes out of scope.
     95\begin{cfa}
     96void ^?{}(Example & this) { ... }
    7997{
    80         T s = @{@ ... @}@;  // same constructor/initialization braces
    81 } // destructor call automatically generated
    82 \end{cfa}
    83 The first parameter is a reference parameter to the type for the
    84 constructor/destructor. Destructors may have multiple parameters.  The compiler
    85 implicitly matches an overloaded constructor @void ^?{}(T &, ...);@ to an
    86 object declaration with associated initialization, and generates a construction
    87 call after the object is allocated. When an object goes out of scope, the
    88 matching overloaded destructor @void ^?{}(T &);@ is called.  Without explicit
    89 definition, \CFA creates a default and copy constructor, destructor and
    90 assignment (like \Cpp). It is possible to define constructors/destructors for
    91 basic and existing types (unlike \Cpp).
     98    Example d;
     99} // <- implicit destructor call
     100\end{cfa}
     101No operator name is restricted in what function signatures they may be bound
     102to although most of the forms cannot be called in operator form. Some
     103``near-misses" will generate warnings.
     104
     105Whenever a type is defined, \CFA will create a default zero-argument
     106constructor, a copy constructor, a series of argument-per-field constructors
     107and a destructor. All user constructors are defined after this.
     108Because operators are never part of the type definition they may be added
     109at any time, including on built-in types.
    92110
    93111\section{Polymorphism}
     
    105123works on any type @T@:
    106124\begin{cfa}
    107 @forall( T )@ @T@ identity( @T@ val ) { return val; }
    108 int forty_two = identity( 42 ); // T bound to int, forty_two == 42
    109 \end{cfa}
     125forall( T ) T identity( T val ) { return val; }
     126int forty_two = identity( 42 );
     127char capital_a = identity( 'A' );
     128\end{cfa}
     129Each use of a polymorphic declaration will resolve its polymorphic parameters
     130(in this case, just @T@) to concrete types (@int@ in the first use and @char@
     131in the second).
    110132
    111133To allow a polymorphic function to be separately compiled, the type @T@ must be
     
    115137types used in a function, \eg:
    116138\begin{cfa}
    117 forall( T @| { void do_once(T); }@) // assertion
     139forall( T | { void do_once(T); })
    118140void do_twice(T value) {
    119141        do_once(value);
    120142        do_once(value);
    121143}
    122 void do_once(@int@ i) { ... }  // provide assertion
    123 @int@ i;
    124 do_twice(i); // implicitly pass assertion do_once to do_twice
    125 \end{cfa}
    126 Any object with a type fulfilling the assertion may be passed as an argument to
    127 a @do_twice@ call.
     144\end{cfa}
    128145
    129146A polymorphic function can be used in the same way as a normal function.  The
     
    132149all the variables replaced with the concrete types from the arguments) is
    133150defined at a call site.
     151\begin{cfa}
     152void do_once(int i) { ... }
     153int i;
     154do_twice(i);
     155\end{cfa}
     156Any object with a type fulfilling the assertion may be passed as an argument to
     157a @do_twice@ call.
    134158
    135159Note, a function named @do_once@ is not required in the scope of @do_twice@ to
     
    138162call.
    139163\begin{cfa}
    140 void do_once(double y) { ... } // global
     164void do_once(double y) { ... }
    141165int quadruple(int x) {
    142         void do_once(int y) { y = y * 2; } // local
    143         do_twice(x); // using local "do_once"
     166        void do_once(int y) { y = y * 2; }
     167        do_twice(x);
    144168        return x;
    145169}
     
    150174function. The matched assertion function is then passed as a function pointer
    151175to @do_twice@ and called within it.
     176The global definition of @do_once@ is ignored.
    152177
    153178To avoid typing long lists of assertions, constraints can be collect into
     
    161186and the @forall@ list in the previous example is replaced with the trait.
    162187\begin{cfa}
    163 forall(dtype T | @done_once(T)@)
     188forall(dtype T | done_once(T))
    164189\end{cfa}
    165190In general, a trait can contain an arbitrary number of assertions, both
     
    172197declarations instead of parameters, returns, and local variable declarations.
    173198\begin{cfa}
    174 forall(dtype @T@)
     199forall(dtype T)
    175200struct node {
    176         node(@T@) * next;  // generic linked node
    177         @T@ * data;
    178 }
    179 node(@int@) inode;
    180 \end{cfa}
    181 The generic type @node(T)@ is an example of a polymorphic-type usage.  Like \Cpp
    182 template usage, a polymorphic-type usage must specify a type parameter.
     201        node(T) * next;  // generic linked node
     202        T * data;
     203}
     204node(int) inode;
     205\end{cfa}
     206The generic type @node(T)@ is an example of a polymorphic type usage.  Like \Cpp
     207template usage, a polymorphic type usage must specify a type parameter.
    183208
    184209There are many other polymorphism features in \CFA but these are the ones used
     
    219244Each coroutine has a @main@ function, which takes a reference to a coroutine
    220245object and returns @void@.
    221 \begin{cfa}[numbers=left]
    222 void main(@CountUp & this@) { // argument matches trait is_coroutine
    223         unsigned int up = 0;  // retained between calls
    224         while (true) {
    225                 next = up; // make "up" available outside function
    226                 @suspend;@$\label{suspend}$
    227                 up += 1;
     246\begin{cfa}
     247void main(CountUp & this) {
     248    for (unsigned int next = 0 ; true ; ++next) {
     249                next = up;
     250                suspend;$\label{suspend}$
    228251        }
    229252}
     
    254277@mutex@.
    255278\begin{cfa}
    256 void example(MonitorA & @mutex@ argA, MonitorB & @mutex@ argB);
     279void example(MonitorA & mutex argA, MonitorB & mutex argB);
    257280\end{cfa}
    258281When the function is called, it implicitly acquires the monitor lock for all of
  • doc/theses/andrew_beach_MMath/features.tex

    rc993b15 r3eb55f98  
    2020\subparagraph{Raise}
    2121The raise is the starting point for exception handling. It marks the beginning
    22 of exception handling by \newterm{raising} an excepion, which passes it to
     22of exception handling by raising an excepion, which passes it to
    2323the EHM.
    2424
     
    101101between different sub-hierarchies.
    102102This design is used in \CFA even though it is not a object-orientated
    103 language using different tools to create the hierarchy.
     103language; so different tools are used to create the hierarchy.
    104104
    105105% Could I cite the rational for the Python IO exception rework?
     
    123123\section{Virtuals}
    124124Virtual types and casts are not part of \CFA's EHM nor are they required for
    125 any EHM. But \CFA uses a hierarchial system of exceptions and this feature
    126 is leveraged to create that.
    127 
    128 % Maybe talk about why the virtual system is so minimal.
    129 % Created for but not a part of the exception system.
     125any EHM.
     126However the \CFA uses a hierarchy built with the virtual system as the basis
     127for exceptions and exception matching.
     128
     129The virtual system would have ideally been part of \CFA before the work
     130on exception handling began, but unfortunately it was not.
     131Because of this only the features and framework needed for the EHM were
     132designed and implemented. Other features were considered to ensure that
     133the structure could accomidate other desirable features but they were not
     134implemented.
     135The rest of this section will only discuss the finalized portion of the
     136virtual system.
    130137
    131138The virtual system supports multiple ``trees" of types. Each tree is
     
    175182While much of the virtual infrastructure is created, it is currently only used
    176183internally for exception handling. The only user-level feature is the virtual
    177 cast, which is the same as the \Cpp \lstinline[language=C++]|dynamic_cast|.
     184cast, which is the same as the \Cpp \codeCpp{dynamic_cast}.
    178185\label{p:VirtualCast}
    179186\begin{cfa}
     
    197204\begin{cfa}
    198205trait is_exception(exceptT &, virtualT &) {
    199         virtualT const & get_exception_vtable(exceptT *);
     206        // Numerous imaginary assertions.
    200207};
    201208\end{cfa}
    202209The trait is defined over two types, the exception type and the virtual table
    203 type. This should be one-to-one: each exception type has only one virtual
    204 table type and vice versa. The only assertion in the trait is
    205 @get_exception_vtable@, which takes a pointer of the exception type and
    206 returns a reference to the virtual table type instance.
    207 
    208 % TODO: This section, and all references to get_exception_vtable, are
    209 % out-of-data. Perhaps wait until the update is finished before rewriting it.
    210 The function @get_exception_vtable@ is actually a constant function.
    211 Regardless of the value passed in (including the null pointer) it should
    212 return a reference to the virtual table instance for that type.
    213 The reason it is a function instead of a constant is that it make type
    214 annotations easier to write as you can use the exception type instead of the
    215 virtual table type; which usually has a mangled name.
    216 % Also \CFA's trait system handles functions better than constants and doing
    217 % it this way reduce the amount of boiler plate we need.
     210type. Each exception type should have but a single virtual table type.
     211Now there are no actual assertions in this trait because the trait system
     212actually can't express them (adding such assertions would be part of
     213completing the virtual system). The imaginary assertions would probably come
     214from a trait defined by the virtual system, and state that the exception type
     215is a virtual type, is a decendent of @exception_t@ (the base exception type)
     216and note its virtual table type.
    218217
    219218% I did have a note about how it is the programmer's responsibility to make
     
    235234Both traits ensure a pair of types are an exception type and its virtual table
    236235and defines one of the two default handlers. The default handlers are used
    237 as fallbacks and are discussed in detail in \VRef{s:ExceptionHandling}.
     236as fallbacks and are discussed in detail in \vref{s:ExceptionHandling}.
    238237
    239238However, all three of these traits can be tricky to use directly.
     
    351350for particular exception type.
    352351The global default termination handler performs a cancellation
    353 \see{\VRef{s:Cancellation}} on the current stack with the copied exception.
     352(see \vref{s:Cancellation}) on the current stack with the copied exception.
    354353
    355354\subsection{Resumption}
     
    426425
    427426\subsubsection{Resumption Marking}
     427\label{s:ResumptionMarking}
    428428A key difference between resumption and termination is that resumption does
    429429not unwind the stack. A side effect that is that when a handler is matched
     
    472472The symmetry between resumption termination is why this pattern was picked.
    473473Other patterns, such as marking just the handlers that caught, also work but
    474 lack the symmetry means there are less rules to remember.
     474lack the symmetry means there are more rules to remember.
    475475
    476476\section{Conditional Catch}
     
    557557\end{cfa}
    558558If there are further handlers after this handler only the first version will
    559 check them. If multiple handlers on a single try block could handle the same
    560 exception the translations get more complex but they are equivilantly
     559check them. If multiple handlers on a single try block that could handle the
     560same exception the translations get more complex but they are equivilantly
    561561powerful.
    562562
     
    633633and the current stack is
    634634unwound. After that it depends one which stack is being cancelled.
    635 \begin{description}
    636 \item[Main Stack:]
     635
     636\paragraph{Main Stack}
    637637The main stack is the one used by the program main at the start of execution,
    638638and is the only stack in a sequential program.
     
    645645to, so it would have be explicitly managed.
    646646
    647 \item[Thread Stack:]
     647\paragraph{Thread Stack}
    648648A thread stack is created for a \CFA @thread@ object or object that satisfies
    649649the @is_thread@ trait.
     
    671671Also you can always add an explicit join if that is the desired behaviour.
    672672
    673 \item[Coroutine Stack:]
     673\paragraph{Coroutine Stack}
    674674A coroutine stack is created for a @coroutine@ object or object that
    675675satisfies the @is_coroutine@ trait.
     
    685685(in terms of coroutine state) called resume on this coroutine, so the message
    686686is passed to the latter.
    687 \end{description}
  • doc/theses/andrew_beach_MMath/future.tex

    rc993b15 r3eb55f98  
    110110\section{Zero-Cost Try}
    111111\CFA does not have zero-cost try-statements because the compiler generates C
    112 code rather than assembler code \see{\VPageref{p:zero-cost}}. When the compiler
     112code rather than assembler code (see \vpageref{p:zero-cost}). When the compiler
    113113does create its own assembly (or LLVM byte-code), then zero-cost try-statements
    114114are possible. The downside of zero-cost try-statements is the LSDA complexity,
  • doc/theses/andrew_beach_MMath/implement.tex

    rc993b15 r3eb55f98  
    99% Virtual table rules. Virtual tables, the pointer to them and the cast.
    1010While the \CFA virtual system currently has only one public feature, virtual
    11 cast \see{\VPageref{p:VirtualCast}}, substantial structure is required to
    12 support it, and provide features for exception handling and the standard
    13 library.
     11cast (see the virtual cast feature \vpageref{p:VirtualCast}),
     12substantial structure is required to support it,
     13and provide features for exception handling and the standard library.
    1414
    1515\subsection{Virtual Type}
     
    215215\subsection{libunwind Usage}
    216216Libunwind, accessed through @unwind.h@ on most platforms, is a C library that
    217 provides \CC-style stack-unwinding. Its operation is divided into two phases:
     217provides \Cpp-style stack-unwinding. Its operation is divided into two phases:
    218218search and cleanup. The dynamic target search -- phase 1 -- is used to scan the
    219219stack and decide where unwinding should stop (but no unwinding occurs). The
     
    291291@_UA_FORCE_UNWIND@ specifies a forced unwind call. Forced unwind only performs
    292292the cleanup phase and uses a different means to decide when to stop
    293 \see{\VRef{s:ForcedUnwind}}.
     293(see \vref{s:ForcedUnwind}).
    294294\end{enumerate}
    295295
     
    400400
    401401Termination exceptions use libunwind heavily because it matches the intended
    402 use from \CC exceptions closely. The main complication for \CFA is that the
     402use from \Cpp exceptions closely. The main complication for \CFA is that the
    403403compiler generates C code, making it very difficult to generate the assembly to
    404404form the LSDA for try blocks or destructors.
     
    509509
    510510% Recursive Resumption Stuff:
    511 Search skipping \see{\VPageref{p:searchskip}}, which ignores parts of the stack
     511Search skipping (see \vpageref{s:ResumptionMarking}), which ignores parts of
     512the stack
    512513already examined, is accomplished by updating the front of the list as the
    513514search continues. Before the handler at a node is called the head of the list
     
    554555Cancellation also uses libunwind to do its stack traversal and unwinding,
    555556however it uses a different primary function @_Unwind_ForcedUnwind@. Details
    556 of its interface can be found in the \VRef{s:ForcedUnwind}.
     557of its interface can be found in the \vref{s:ForcedUnwind}.
    557558
    558559The first step of cancellation is to find the cancelled stack and its type:
  • doc/theses/andrew_beach_MMath/uw-ethesis.tex

    rc993b15 r3eb55f98  
    6666% Tip: Photographs should be cropped and compressed so as not to be too large.
    6767
    68 % To create a PDF output that is optimized for double-sided printing:
    69 % 1) comment-out the \documentclass statement in the preamble below, and
    70 %    un-comment the second \documentclass line.
    71 % 2) change the value assigned below to the boolean variable "PrintVersion"
    72 %    from "false" to "true".
    73 
    7468% ======================================================================
    7569%   D O C U M E N T   P R E A M B L E
     
    8781}
    8882
    89 % Some LaTeX commands I define for my own nomenclature.
    90 % If you have to, it's easier to make changes to nomenclature once here than
    91 % in a million places throughout your thesis!
    92 \newcommand{\package}[1]{\textbf{#1}} % package names in bold text
    93 \newcommand{\cmmd}[1]{\textbackslash\texttt{#1}} % command name in tt font
    94 \newcommand{\href}[1]{#1} % does nothing, but defines the command so the
    95 % print-optimized version will ignore \href tags (redefined by hyperref pkg).
    96 % Anything defined here may be redefined by packages added below...
     83% Does nothing, ignores \href tags (redefined by hyperref package).
     84\newcommand{\href}[1]{#1}
    9785
    9886% For a nomenclature (optional; available from ctan.org)
     
    10795% Adds todos (Must be included after comment.)
    10896\usepackage{todonotes}
     97% cfa macros used in the document
     98\usepackage{cfalab}
    10999
    110100% Hyperlinks make it very easy to navigate an electronic document.
     
    208198\makeglossaries
    209199
    210 % cfa macros used in the document
    211 %\usepackage{cfalab}
    212 % I'm going to bring back eventually.
    213 \makeatletter
    214 % Combines all \CC* commands:
    215 \newrobustcmd*\Cpp[1][\xspace]{\cfalab@Cpp#1}
    216 \newcommand\cfalab@Cpp{C\kern-.1em\hbox{+\kern-.25em+}}
    217 % Optional arguments do not work with pdf string. (Some fix-up required.)
    218 \pdfstringdefDisableCommands{\def\Cpp{C++}}
    219 
    220 % Wrappers for inline code snippits.
    221 \newrobustcmd*\codeCFA[1]{\lstinline[language=CFA]{#1}}
    222 \newrobustcmd*\codeC[1]{\lstinline[language=C]{#1}}
    223 \newrobustcmd*\codeCpp[1]{\lstinline[language=C++]{#1}}
    224 \newrobustcmd*\codePy[1]{\lstinline[language=Python]{#1}}
    225 
    226 % Colour text, formatted in LaTeX style instead of TeX style.
    227 \newcommand*\colour[2]{{\color{#1}#2}}
    228 \makeatother
    229 
    230 \input{common}
    231 % CFA code-style for all languages
    232 \CFAStyle
    233 % CFA default lnaguage
    234 \lstset{language=CFA,basicstyle=\linespread{0.9}\tt}
     200% listings package configuation:
     201\lstMakeShortInline@
     202\lstset{language=CFA,style=cfacommon,basicstyle=\linespread{0.9}\tt}
     203\lstset{moredelim=**[is][\protect\color{red}]{@}{@}}
    235204% Annotations from Peter:
    236205\newcommand{\PAB}[1]{{\color{blue}PAB: #1}}
  • doc/user/user.tex

    rc993b15 r3eb55f98  
    1111%% Created On       : Wed Apr  6 14:53:29 2016
    1212%% Last Modified By : Peter A. Buhr
    13 %% Last Modified On : Sun Apr 25 19:03:03 2021
    14 %% Update Count     : 4951
     13%% Last Modified On : Wed Apr 28 21:48:59 2021
     14%% Update Count     : 5051
    1515%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    1616
     
    33123312
    33133313\section{Tuples}
     3314\label{tuples}
    33143315
    33153316In C and \CFA, lists of elements appear in several contexts, such as the parameter list for a routine call.
     
    34203421
    34213422\subsection{Tuple Coercions}
     3423\label{tuple coercions}\label{coercions!tuple}
    34223424
    34233425There are four coercions that can be performed on tuples and tuple variables: closing, opening, flattening and structuring.
     
    34643466
    34653467\subsection{Mass Assignment}
     3468\label{mass assignment}\label{assignment!mass}
    34663469
    34673470\CFA permits assignment to several variables at once using mass assignment~\cite{CLU}.
     
    35043507
    35053508\subsection{Multiple Assignment}
     3509\label{multiple assignment}\label{assignment!multiple}
    35063510
    35073511\CFA also supports the assignment of several values at once, known as multiple assignment~\cite{CLU,Galletly96}.
     
    35453549
    35463550\subsection{Cascade Assignment}
     3551\index{cascade assignment}\index{assignment!cascade}
    35473552
    35483553As in C, \CFA mass and multiple assignments can be cascaded, producing cascade assignment.
     
    35643569\section{Stream I/O Library}
    35653570\label{s:StreamIOLibrary}
    3566 \index{input/output stream library}
    3567 \index{stream library}
     3571\index{input}\index{output}
     3572\index{stream library}\index{library!stream}
    35683573
    35693574The 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.
    35703575Stream I/O can be implicitly or explicitly formatted.
    3571 Implicit formatting means \CFA selects the output or input format for values that match with the type of a variable.
     3576Implicit formatting means \CFA selects the output or input format for values that matches the variable's type.
    35723577Explicit formatting means additional information is specified to augment how an output or input of value is interpreted.
    3573 \CFA formatting is a cross between C ©printf© and \CC ©cout© manipulators, and Python implicit spacing and newline.
     3578\CFA formatting incorporates ideas from C ©printf©, \CC ©stream© manipulators, and Python implicit spacing and newline.
    35743579Specifically:
    35753580\begin{itemize}
     
    35843589Hence, it is common programming practice to toggle manipulators on and then back to the default to prevent downstream side-effects.
    35853590Without this programming style, errors occur when moving prints, as manipulator effects incorrectly flow into the new location.
    3586 (To guarantee no side-effects, manipulator values must be saved and restored across function calls.)
    3587 \item
    3588 \CFA has more sophisticated implicit spacing between values than Python, plus implicit newline at the end of a print.
     3591Furthermore, to guarantee no side-effects, manipulator values must be saved and restored across function calls.
     3592\item
     3593\CFA has more sophisticated implicit value spacing than Python, plus implicit newline at the end of a print.
    35893594\end{itemize}
     3595
     3596The standard polymorphic I/Os stream are ©stdin©/©sin© (input), ©stdout©/©sout© and ©stderr©/©serr© (output) (like C++ ©cin©/©cout©/©cerr©).
     3597Polymorphic streams ©exit© and ©abort© provide implicit program termination without and with generating a stack trace and core file.
     3598Stream ©exit© implicitly returns ©EXIT_FAILURE© to the shell.
     3599\begin{cfa}
     3600®exit®   | "x (" | x | ") negative value."; // terminate and return EXIT_FAILURE to shell
     3601®abort® | "x (" | x | ") negative value."; // terminate and generate stack trace and core file
     3602\end{cfa}
     3603Note, \CFA stream variables ©stdin©, ©stdout©, ©stderr©, ©exit©, and ©abort© overload C variables ©stdin©, ©stdout©, ©stderr©, and functions ©exit© and ©abort©, respectively.
    35903604The \CFA header file for the I/O library is \Indexc{fstream.hfa}.
     3605
     3606
     3607\subsection{Basic I/O}
    35913608
    35923609For implicit formatted output, the common case is printing a series of variables separated by whitespace.
     
    36013618\begin{cfa}
    36023619
    3603 cout << x ®<< " "® << y ®<< " "® << z << endl;
     3620cout  <<  x  ®<< " "®  <<  y  ®<< " "®  <<  z << endl;
    36043621\end{cfa}
    36053622&
     
    36533670\end{tabular}
    36543671\end{cquote}
    3655 Input and output use a uniform operator, ©|©, rather than separate operators, as in ©>>© and ©<<© for \CC.
     3672Input and output use a uniform operator, ©|©, rather than \CC's ©>>© and ©<<© input/output operators.
    36563673There 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.
    36573674
     
    36983715\end{cquote}
    36993716
     3717\VRef[Figure]{f:CFACommand-LineProcessing} shows idiomatic \CFA command-line processing and copying an input file to an output file.
     3718Note, a stream variable may be copied because it is a reference to an underlying stream data-structures.
     3719All 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.
     3720
     3721\begin{figure}
     3722\begin{cfa}
     3723#include ®<fstream.hfa>®
     3724
     3725int main( int argc, char * argv[] ) {
     3726        ®ifstream® in  = stdin;                                 $\C{// copy default files}$
     3727        ®ofstream® out = stdout;
     3728
     3729        try {
     3730                choose ( argc ) {
     3731                  case 2, 3:
     3732                        ®open®( in, argv[1] );                  $\C{// open input file first as output creates file}$
     3733                        if ( argc == 3 ) ®open®( out, argv[2] ); $\C{// do not create output unless input opens}$
     3734                  case 1: ;                                                     $\C{// use default files}$
     3735                  default:
     3736                        ®exit® | "Usage" | argv[0] | "[ input-file (default stdin) "
     3737                                   "[ output-file (default stdout) ] ]";
     3738                } // choose
     3739        } catch( ®Open_Failure® * ex; ex->istream == &in ) {
     3740                ®exit® | "Unable to open input file" | argv[1];
     3741        } catch( ®Open_Failure® * ex; ex->ostream == &out ) {
     3742                ®close®( in );                                          $\C{// optional}$
     3743                ®exit® | "Unable to open output file" | argv[2];
     3744        } // try
     3745
     3746        out | nlOff;                                                    $\C{// turn off auto newline}$
     3747        in | nlOn;                                                              $\C{// turn on reading newline}$
     3748        char ch;
     3749        for () {                                                                $\C{// read/write characters}$
     3750                in | ch;
     3751          if ( eof( in ) ) break;                               $\C{// eof ?}$
     3752                out | ch;
     3753        } // for
     3754} // main
     3755\end{cfa}
     3756\caption{\CFA Command-Line Processing}
     3757\label{f:CFACommand-LineProcessing}
     3758\end{figure}
     3759
     3760\VRef[Figure]{f:StreamFunctions} shows the stream operations.
     3761\begin{itemize}[topsep=4pt,itemsep=2pt,parsep=0pt]
     3762\item
     3763\Indexc{fail} tests the stream error-indicator, returning nonzero if it is set.
     3764\item
     3765\Indexc{clear} resets the stream error-indicator.
     3766\item
     3767\Indexc{flush} (©ofstream© only) causes any unwritten data for a stream to be written to the file.
     3768\item
     3769\Indexc{eof} (©ifstream© only) tests the end-of-file indicator for the stream pointed to by stream.
     3770Returns true if the end-of-file indicator is set, otherwise false.
     3771\item
     3772\Indexc{open} binds the file with ©name© to a stream accessed with ©mode© (see ©fopen©).
     3773\item
     3774\Indexc{close} flushes the stream and closes the file.
     3775\item
     3776\Indexc{write} (©ofstream© only) write ©size© bytes to the stream.
     3777The bytes are written lazily to file when internal buffers fill.
     3778Eager buffer writes are done with ©flush©
     3779\item
     3780\Indexc{read} (©ifstream© only) read ©size© bytes to the stream.
     3781\item
     3782\Indexc{ungetc} (©ifstream© only) pushes the character back to the input stream.
     3783Pushed-back characters returned by subsequent reads in the reverse order of pushing.
     3784\end{itemize}
     3785The constructor functions:
     3786\begin{itemize}[topsep=4pt,itemsep=2pt,parsep=0pt]
     3787\item
     3788create an unbound stream, which is subsequently bound to a file with ©open©.
     3789\item
     3790create a bound stream to the associated file with given ©mode©.
     3791\end{itemize}
     3792The destructor closes the stream.
     3793
     3794\begin{figure}
     3795\begin{cfa}
     3796// *********************************** ofstream ***********************************
     3797
     3798bool fail( ofstream & );$\indexc{fail}\index{ofstream@©ofstream©!©fail©}$
     3799void clear( ofstream & );$\indexc{clear}\index{ofstream@©ofstream©!©clear©}$
     3800int flush( ofstream & );$\indexc{flush}\index{ofstream@©ofstream©!©flush©}$
     3801void open( ofstream &, const char name[], const char mode[] = "w" );$\indexc{open}\index{ofstream@©ofstream©!©open©}$
     3802void close( ofstream & );$\indexc{close}\index{ofstream@©ofstream©!©close©}$
     3803ofstream & write( ofstream &, const char data[], size_t size );$\indexc{write}\index{ofstream@©ofstream©!©write©}$
     3804
     3805void ?{}( ofstream & );$\index{ofstream@©ofstream©!©?{}©}$
     3806void ?{}( ofstream &, const char name[], const char mode[] = "w" );
     3807void ^?{}( ofstream & );$\index{ofstream@©ofstream©!©^?{}©}$
     3808
     3809// *********************************** ifstream ***********************************
     3810
     3811bool fail( ifstream & is );$\indexc{fail}\index{ifstream@©ifstream©!©fail©}$
     3812void clear( ifstream & );$\indexc{clear}\index{ifstream@©ifstream©!©clear©}$
     3813bool eof( ifstream & is );$\indexc{eof}\index{ifstream@©ifstream©!©eof©}$
     3814void open( ifstream & is, const char name[], const char mode[] = "r" );$\indexc{open}\index{ifstream@©ifstream©!©open©}$
     3815void close( ifstream & is );$\indexc{close}\index{ifstream@©ifstream©!©close©}$
     3816ifstream & read( ifstream & is, char data[], size_t size );$\indexc{read}\index{ifstream@©ifstream©!©read©}$
     3817ifstream & ungetc( ifstream & is, char c );$\indexc{unget}\index{ifstream@©ifstream©!©unget©}$
     3818
     3819void ?{}( ifstream & is );$\index{ifstream@©ifstream©!©?{}©}$
     3820void ?{}( ifstream & is, const char name[], const char mode[] = "r" );
     3821void ^?{}( ifstream & is );$\index{ifstream@©ifstream©!©^?{}©}$
     3822\end{cfa}
     3823\caption{Stream Functions}
     3824\label{f:StreamFunctions}
     3825\end{figure}
    37003826
    37013827
     
    40304156sout | wd( 4, "ab" ) | wd( 3, "ab" ) | wd( 2, "ab" );
    40314157\end{cfa}
    4032 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
     4158\begin{cfa}[showspaces=true,aboveskip=0pt]
    40334159®  ®34 ® ®34 34
    40344160®  ®4.000000 ® ®4.000000 4.000000
     
    43784504\end{cfa}
    43794505
    4380 \Textbf{WARNING:} ©printf©\index{printf@©printf©}, ©scanf©\index{scanf@©scanf©} and their derivatives are unsafe when used with user-level threading, as in \CFA.
    4381 These stream routines use kernel-thread locking (©futex©\index{futex@©futex©}), which block kernel threads, to prevent interleaving of I/O.
    4382 However, the following simple example illustrates how a deadlock can occur (other complex scenarios are possible).
    4383 Assume a single kernel thread and two user-level threads calling ©printf©.
    4384 One user-level thread acquires the I/O lock and is time-sliced while performing ©printf©.
    4385 The other user-level thread then starts execution, calls ©printf©, and blocks the only kernel thread because it cannot acquire the I/O lock.
    4386 It does not help if the kernel lock is multiple acquisition, \ie, the lock owner can acquire it multiple times, because it then results in two user threads in the ©printf© critical section, corrupting the stream.
     4506
     4507\section{String Stream}
     4508
     4509All the stream formatting capabilities are available to format text to/from a C string rather than to a stream file.
     4510\VRef[Figure]{f:StringStreamProcessing} shows writing (output) and reading (input) from a C string.
     4511\begin{figure}
     4512\begin{cfa}
     4513#include <fstream.hfa>
     4514#include <strstream.hfa>
     4515
     4516int main() {
     4517        enum { size = 256 };
     4518        char buf[size]; $\C{// output buffer}$
     4519        ®ostrstream osstr = { buf, size };® $\C{// bind output buffer/size}$
     4520        int i = 3, j = 5, k = 7;
     4521        double x = 12345678.9, y = 98765.4321e-11;
     4522
     4523        osstr | i | hex(j) | wd(10, k) | sci(x) | unit(eng(y)); $\C{// same lines of output}$
     4524        write( osstr );
     4525        printf( "%s", buf );
     4526        sout | i | hex(j) | wd(10, k) | sci(x) | unit(eng(y));
     4527
     4528        char buf2[] = "12 14 15 3.5 7e4"; $\C{// input buffer}$
     4529        ®istrstream isstr = { buf2 };®
     4530        isstr | i | j | k | x | y;
     4531        sout | i | j | k | x | y;
     4532}
     4533\end{cfa}
     4534\caption{String Stream Processing}
     4535\label{f:StringStreamProcessing}
     4536\end{figure}
     4537
     4538\VRef[Figure]{f:StringStreamFunctions} shows the string stream operations.
     4539\begin{itemize}[topsep=4pt,itemsep=2pt,parsep=0pt]
     4540\item
     4541\Indexc{write} (©ostrstream© only) writes all the buffered characters to the specified stream (©stdout© default).
     4542\end{itemize}
     4543The constructor functions:
     4544\begin{itemize}[topsep=4pt,itemsep=2pt,parsep=0pt]
     4545\item
     4546create a bound stream to a write buffer (©ostrstream©) of ©size© or a read buffer (©istrstream©) containing a C string terminated with ©'\0'©.
     4547\end{itemize}
     4548
     4549\begin{figure}
     4550\begin{cfa}
     4551// *********************************** ostrstream ***********************************
     4552
     4553ostrstream & write( ostrstream & os, FILE * stream = stdout );
     4554
     4555void ?{}( ostrstream &, char buf[], size_t size );
     4556
     4557// *********************************** istrstream ***********************************
     4558
     4559void ?{}( istrstream & is, char buf[] );
     4560\end{cfa}
     4561\caption{String Stream Functions}
     4562\label{f:StringStreamFunctions}
     4563\end{figure}
    43874564
    43884565
     
    81118288\begin{cquote}
    81128289\begin{tabular}{@{}l@{\hspace{\parindentlnth}}|@{\hspace{\parindentlnth}}l@{}}
    8113 \multicolumn{1}{@{}c|@{\hspace{\parindentlnth}}}{\textbf{\CFA}} & \multicolumn{1}{@{\hspace{\parindentlnth}}c}{\textbf{C}@{}}   \\
     8290\multicolumn{1}{@{}c|@{\hspace{\parindentlnth}}}{\textbf{\CFA}} & \multicolumn{1}{@{\hspace{\parindentlnth}}c@{}}{\textbf{C}}   \\
    81148291\hline
    81158292\begin{cfa}
    8116 #include <gmp>$\indexc{gmp}$
     8293#include <gmp.hfa>$\indexc{gmp}$
    81178294int main( void ) {
    81188295        sout | "Factorial Numbers";
  • libcfa/src/fstream.cfa

    rc993b15 r3eb55f98  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Apr 27 22:08:57 2021
    13 // Update Count     : 442
     12// Last Modified On : Wed Apr 28 20:37:53 2021
     13// Update Count     : 445
    1414//
    1515
     
    114114} // fail
    115115
     116void clear( ofstream & os ) {
     117        clearerr( (FILE *)(os.file$) );
     118} // clear
     119
    116120int flush( ofstream & os ) {
    117121        return fflush( (FILE *)(os.file$) );
     
    207211} // nl
    208212
     213
    209214// *********************************** ifstream ***********************************
    210215
     
    240245} // fail
    241246
     247void clear( ifstream & is ) {
     248        clearerr( (FILE *)(is.file$) );
     249} // clear
     250
    242251void ends( ifstream & is ) {
    243252        if ( is.acquired$ ) { is.acquired$ = false; release( is ); }
    244253} // ends
    245254
    246 int eof( ifstream & is ) {
     255bool eof( ifstream & is ) {
    247256        return feof( (FILE *)(is.file$) );
    248257} // eof
     
    273282} // close
    274283
    275 ifstream & read( ifstream & is, char * data, size_t size ) {
     284ifstream & read( ifstream & is, char data[], size_t size ) {
    276285        if ( fail( is ) ) {
    277286                abort | IO_MSG "attempt read I/O on failed stream";
  • libcfa/src/fstream.hfa

    rc993b15 r3eb55f98  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Apr 27 22:00:30 2021
    13 // Update Count     : 226
     12// Last Modified On : Wed Apr 28 20:37:57 2021
     13// Update Count     : 230
    1414//
    1515
     
    7070
    7171bool fail( ofstream & );
     72void clear( ofstream & );
    7273int flush( ofstream & );
    7374void open( ofstream &, const char name[], const char mode[] ); // FIX ME: use default = "w"
     
    119120
    120121bool fail( ifstream & is );
    121 int eof( ifstream & is );
     122void clear( ifstream & );
     123bool eof( ifstream & is );
    122124void open( ifstream & is, const char name[], const char mode[] ); // FIX ME: use default = "r"
    123125void open( ifstream & is, const char name[] );
    124126void close( ifstream & is );
    125 ifstream & read( ifstream & is, char * data, size_t size );
     127ifstream & read( ifstream & is, char data[], size_t size );
    126128ifstream & ungetc( ifstream & is, char c );
    127129
  • libcfa/src/iostream.hfa

    rc993b15 r3eb55f98  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Apr 27 17:59:21 2021
    13 // Update Count     : 398
     12// Last Modified On : Wed Apr 28 20:37:56 2021
     13// Update Count     : 401
    1414//
    1515
     
    5252       
    5353trait ostream( ostype & | basic_ostream( ostype ) ) {
     54        bool fail( ostype & );                                                          // operation failed?
     55        void clear( ostype & );
    5456        int flush( ostype & );
    55         bool fail( ostype & );                                                          // operation failed?
    5657        void open( ostype &, const char name[], const char mode[] );
    5758        void close( ostype & );
     
    302303        int fmt( istype &, const char format[], ... ) __attribute__(( format(scanf, 2, 3) ));
    303304        istype & ungetc( istype &, char );
    304         int eof( istype & );
     305        bool eof( istype & );
    305306}; // basic_istream
    306307
    307308trait istream( istype & | basic_istream( istype ) ) {
    308309        bool fail( istype & );
     310        void clear( istype & );
    309311        void open( istype & is, const char name[] );
    310312        void close( istype & is );
    311         istype & read( istype &, char *, size_t );
     313        istype & read( istype &, char [], size_t );
    312314        void acquire( istype & );                                                       // concurrent access
    313315}; // istream
  • tests/strstream.cfa

    rc993b15 r3eb55f98  
     1//
     2// Cforall Version 1.0.0 Copyright (C) 2021 University of Waterloo
     3//
     4// strstream.cfa --
     5//
     6// Author           : Peter A. Buhr
     7// Created On       : Wed Apr 28 21:47:35 2021
     8// Last Modified By : Peter A. Buhr
     9// Last Modified On : Wed Apr 28 21:50:02 2021
     10// Update Count     : 3
     11//
     12
    113#include <fstream.hfa>
    214#include <strstream.hfa>
    315
    416int main() {
    5     enum { size = 256 };
    6     char buf[size];
    7     ostrstream osstr = { buf, size };
    8     int i = 3, j = 5, k = 7;
    9     double x = 12345678.9, y = 98765.4321e-11;
     17        enum { size = 256 };
     18        char buf[size];                                                                         // output buffer
     19        ostrstream osstr = { buf, size };                                       // bind output buffer/size
     20        int i = 3, j = 5, k = 7;
     21        double x = 12345678.9, y = 98765.4321e-11;
    1022
    11     osstr | i | hex(j) | wd(10, k) | sci(x) | unit(eng(y));
    12     write( osstr );
    13     printf( "%s", buf );
    14     sout | i | hex(j) | wd(10, k) | sci(x) | unit(eng(y));
     23        osstr | i | hex(j) | wd(10, k) | sci(x) | unit(eng(y)); // same lines of output
     24        write( osstr );
     25        printf( "%s", buf );
     26        sout | i | hex(j) | wd(10, k) | sci(x) | unit(eng(y));
    1527
    16     // char buf2[] = "12 14 15 3.5 7e4";
    17     // istrstream isstr = { buf2 };
    18     // isstr | i | j | k | x | y;
    19     // sout | i | j | k | x | y;
     28        // char buf2[] = "12 14 15 3.5 7e4";                                    // input buffer
     29        // istrstream isstr = { buf2 };
     30        // isstr | i | j | k | x | y;
     31        // sout | i | j | k | x | y;
    2032}
     33
     34// Local Variables: //
     35// tab-width: 4 //
     36// compile-command: "cfa strstream.cfa" //
     37// End: //
Note: See TracChangeset for help on using the changeset viewer.