Changes in / [c993b15:3eb55f98]
- Files:
-
- 13 edited
-
doc/LaTeXmacros/common.tex (modified) (4 diffs)
-
doc/theses/andrew_beach_MMath/Makefile (modified) (1 diff)
-
doc/theses/andrew_beach_MMath/cfalab.sty (modified) (5 diffs)
-
doc/theses/andrew_beach_MMath/existing.tex (modified) (13 diffs)
-
doc/theses/andrew_beach_MMath/features.tex (modified) (14 diffs)
-
doc/theses/andrew_beach_MMath/future.tex (modified) (1 diff)
-
doc/theses/andrew_beach_MMath/implement.tex (modified) (6 diffs)
-
doc/theses/andrew_beach_MMath/uw-ethesis.tex (modified) (4 diffs)
-
doc/user/user.tex (modified) (14 diffs)
-
libcfa/src/fstream.cfa (modified) (5 diffs)
-
libcfa/src/fstream.hfa (modified) (3 diffs)
-
libcfa/src/iostream.hfa (modified) (3 diffs)
-
tests/strstream.cfa (modified) (1 diff)
Legend:
- Unmodified
- Added
- Removed
-
doc/LaTeXmacros/common.tex
rc993b15 r3eb55f98 11 11 %% Created On : Sat Apr 9 10:06:17 2016 12 12 %% Last Modified By : Peter A. Buhr 13 %% Last Modified On : Sun Feb 14 15:52:46202114 %% Update Count : 5 2413 %% Last Modified On : Tue Apr 27 12:03:17 2021 14 %% Update Count : 539 15 15 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 16 16 … … 102 102 \renewcommand\subsubsection{\@startsection{subsubsection}{3}{\z@}{-2.5ex \@plus -1ex \@minus -.2ex}{1.0ex \@plus .2ex}{\normalfont\normalsize\bfseries}} 103 103 \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}} 104 105 105 106 % index macros … … 284 285 showlines=true, % show blank lines at end of code 285 286 aboveskip=4pt, % spacing above/below code block 286 belowskip= 0pt,287 belowskip=2pt, 287 288 numberstyle=\footnotesize\sf, % numbering style 288 289 % replace/adjust listing characters that look bad in sanserif … … 297 298 \lstset{ 298 299 language=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 @...@ 301 moredelim=**[is][\color{red}]{®}{®}, % red highlighting ®...® (registered trademark symbol) emacs: C-q M-. 301 302 %moredelim=**[is][\color{blue}]{ß}{ß}, % blue highlighting ß...ß (sharp s symbol) emacs: C-q M-_ 302 303 %moredelim=**[is][\color{OliveGreen}]{¢}{¢}, % green highlighting ¢...¢ (cent symbol) emacs: C-q M-" -
doc/theses/andrew_beach_MMath/Makefile
rc993b15 r3eb55f98 34 34 ${LATEX} ${BASE} 35 35 ${BIBTEX} ${BUILD}/${BASE} 36 ${LATEX} ${BASE}37 36 ${GLOSSARY} ${BUILD}/${BASE} 38 37 ${LATEX} ${BASE} -
doc/theses/andrew_beach_MMath/cfalab.sty
rc993b15 r3eb55f98 10 10 11 11 % Other packages required. 12 % 13 % Access to new basic LaTeX tools and other low level commands. 12 14 \RequirePackage{etoolbox} 15 % Code formatting tools and environments. 13 16 \RequirePackage{listings} 17 % Automatically adds spaces. 14 18 \RequirePackage{xspace} 19 % Improved reference tools. 20 \RequirePackage[nospace]{varioref} 15 21 16 22 % Symbols: All symbols are zero argument robust commands with special rules … … 20 26 21 27 % \newsymbolcmd{<command>}{<replacement text>} 22 % 28 % Defines <command> to be a symbol that has the given <replacement text>. 23 29 \newrobustcmd*\newsymbolcmd[2]{\newrobustcmd{#1}{\cfalab@symbol{#2}}} 24 30 \def\cfalab@symbol#1{\@ifnextchar*{#1\cfalab@eatstar}{#1\xspace}} … … 28 34 \newsymbolcmd\CFA{\textsf{C}\raisebox{\depth}{\rotatebox{180}{\textsf{A}}}} 29 35 % C++ with kerning. (No standard number support.) 30 \newsymbolcmd\C PP{\textrm{C}\kern-.1em\hbox{+\kern-.25em+}}36 \newsymbolcmd\Cpp{\textrm{C}\kern-.1em\hbox{+\kern-.25em+}} 31 37 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. 33 40 \AtEndPreamble{ 34 41 \@ifpackageloaded{hyperref}{ … … 36 43 \pdfstringdefDisableCommands{ 37 44 \def\CFA{CFA} 38 \def\CPP{C++} 45 \def\Cpp{C++} 46 \def\lstinline{} 39 47 } 40 48 }{} 41 49 } 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}}} 42 75 43 76 % The CFA listings language. Based off of ANCI C and including GCC extensions. … … 61 94 \lstset{defaultdialect={[UW]CFA}} 62 95 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, 68 131 } 69 132 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. 76 135 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} 86 155 87 156 \endinput -
doc/theses/andrew_beach_MMath/existing.tex
rc993b15 r3eb55f98 16 16 to be defined~\cite{Moss18}. 17 17 \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$18 char i; int i; double i; 19 int f(); double f(); 20 void g( int ); void g( double ); 21 21 \end{cfa} 22 22 This feature requires name mangling so the assembly symbols are unique for … … 26 26 mangling is: 27 27 \begin{cfa} 28 // name mangling 28 // name mangling on by default 29 29 int i; // _X1ii_1 30 @extern "C"@ { // noname mangling30 extern "C" { // disables name mangling 31 31 int j; // j 32 @extern "Cforall"@ { //name mangling32 extern "Cforall" { // enables name mangling 33 33 int k; // _X1ki_1 34 34 } 35 // no name mangling36 } 37 // name mangling35 // revert to no name mangling 36 } 37 // revert to name mangling 38 38 \end{cfa} 39 39 Both forms of @extern@ affect all the declarations within their nested lexical … … 50 50 \begin{cfa} 51 51 int i, j; 52 int @&@ ri = i, @&&@rri = ri;52 int & ri = i, && rri = ri; 53 53 rri = 3; // auto-dereference assign to i 54 @&@ri = @&@j; // rebindable54 &ri = &j; // rebindable 55 55 ri = 5; // assign to j 56 56 \end{cfa} … … 64 64 65 65 In general, operator names in \CFA are constructed by bracketing an operator 66 token with @?@, which indicates the position of the arguments. For example, infixed67 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 (@?++@).66 token with @?@, which indicates the position of the arguments. For example, 67 infixed multiplication is @?*?@ while prefix dereference is @*?@. 68 This syntax make it easy to tell the difference between prefix operations 69 (such as @++?@) and post-fix operations (@?++@). 70 70 71 71 The 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. 72 initialization syntax in C. That initialation syntax is also the operator 73 form. \CFA will generate a constructor call each time a variable is declared, 74 passing the initialization arguments to the constructort. 75 \begin{cfa} 76 struct Example { ... }; 77 void ?{}(Example & this) { ... } 78 { 79 Example a; 80 Example b = {}; 81 } 82 void ?{}(Example & this, char first, int num) { ... } 83 { 84 Example c = {'a', 2}; 85 } 86 \end{cfa} 87 Both @a@ and @b@ will be initalized with the first constructor (there is no 88 general way to skip initialation) while @c@ will be initalized with the 89 second. 90 74 91 % 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 92 Similarly destructors use the special name @^?{}@ (the @^@ has no special 93 meaning). They can be called explicatly as well but normally they are 94 implicitly called on a variable when it goes out of scope. 95 \begin{cfa} 96 void ^?{}(Example & this) { ... } 79 97 { 80 T s = @{@ ... @}@; // same constructor/initialization braces 81 } // destructor call automatically generated82 \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} 101 No operator name is restricted in what function signatures they may be bound 102 to although most of the forms cannot be called in operator form. Some 103 ``near-misses" will generate warnings. 104 105 Whenever a type is defined, \CFA will create a default zero-argument 106 constructor, a copy constructor, a series of argument-per-field constructors 107 and a destructor. All user constructors are defined after this. 108 Because operators are never part of the type definition they may be added 109 at any time, including on built-in types. 92 110 93 111 \section{Polymorphism} … … 105 123 works on any type @T@: 106 124 \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} 125 forall( T ) T identity( T val ) { return val; } 126 int forty_two = identity( 42 ); 127 char capital_a = identity( 'A' ); 128 \end{cfa} 129 Each 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@ 131 in the second). 110 132 111 133 To allow a polymorphic function to be separately compiled, the type @T@ must be … … 115 137 types used in a function, \eg: 116 138 \begin{cfa} 117 forall( T @| { void do_once(T); }@) // assertion139 forall( T | { void do_once(T); }) 118 140 void do_twice(T value) { 119 141 do_once(value); 120 142 do_once(value); 121 143 } 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} 128 145 129 146 A polymorphic function can be used in the same way as a normal function. The … … 132 149 all the variables replaced with the concrete types from the arguments) is 133 150 defined at a call site. 151 \begin{cfa} 152 void do_once(int i) { ... } 153 int i; 154 do_twice(i); 155 \end{cfa} 156 Any object with a type fulfilling the assertion may be passed as an argument to 157 a @do_twice@ call. 134 158 135 159 Note, a function named @do_once@ is not required in the scope of @do_twice@ to … … 138 162 call. 139 163 \begin{cfa} 140 void do_once(double y) { ... } // global164 void do_once(double y) { ... } 141 165 int quadruple(int x) { 142 void do_once(int y) { y = y * 2; } // local143 do_twice(x); // using local "do_once"166 void do_once(int y) { y = y * 2; } 167 do_twice(x); 144 168 return x; 145 169 } … … 150 174 function. The matched assertion function is then passed as a function pointer 151 175 to @do_twice@ and called within it. 176 The global definition of @do_once@ is ignored. 152 177 153 178 To avoid typing long lists of assertions, constraints can be collect into … … 161 186 and the @forall@ list in the previous example is replaced with the trait. 162 187 \begin{cfa} 163 forall(dtype T | @done_once(T)@)188 forall(dtype T | done_once(T)) 164 189 \end{cfa} 165 190 In general, a trait can contain an arbitrary number of assertions, both … … 172 197 declarations instead of parameters, returns, and local variable declarations. 173 198 \begin{cfa} 174 forall(dtype @T@)199 forall(dtype T) 175 200 struct node { 176 node( @T@) * next; // generic linked node177 @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 \Cpp182 template usage, a polymorphic -type usage must specify a type parameter.201 node(T) * next; // generic linked node 202 T * data; 203 } 204 node(int) inode; 205 \end{cfa} 206 The generic type @node(T)@ is an example of a polymorphic type usage. Like \Cpp 207 template usage, a polymorphic type usage must specify a type parameter. 183 208 184 209 There are many other polymorphism features in \CFA but these are the ones used … … 219 244 Each coroutine has a @main@ function, which takes a reference to a coroutine 220 245 object 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} 247 void main(CountUp & this) { 248 for (unsigned int next = 0 ; true ; ++next) { 249 next = up; 250 suspend;$\label{suspend}$ 228 251 } 229 252 } … … 254 277 @mutex@. 255 278 \begin{cfa} 256 void example(MonitorA & @mutex@ argA, MonitorB & @mutex@argB);279 void example(MonitorA & mutex argA, MonitorB & mutex argB); 257 280 \end{cfa} 258 281 When the function is called, it implicitly acquires the monitor lock for all of -
doc/theses/andrew_beach_MMath/features.tex
rc993b15 r3eb55f98 20 20 \subparagraph{Raise} 21 21 The raise is the starting point for exception handling. It marks the beginning 22 of exception handling by \newterm{raising}an excepion, which passes it to22 of exception handling by raising an excepion, which passes it to 23 23 the EHM. 24 24 … … 101 101 between different sub-hierarchies. 102 102 This design is used in \CFA even though it is not a object-orientated 103 language using different toolsto create the hierarchy.103 language; so different tools are used to create the hierarchy. 104 104 105 105 % Could I cite the rational for the Python IO exception rework? … … 123 123 \section{Virtuals} 124 124 Virtual 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. 125 any EHM. 126 However the \CFA uses a hierarchy built with the virtual system as the basis 127 for exceptions and exception matching. 128 129 The virtual system would have ideally been part of \CFA before the work 130 on exception handling began, but unfortunately it was not. 131 Because of this only the features and framework needed for the EHM were 132 designed and implemented. Other features were considered to ensure that 133 the structure could accomidate other desirable features but they were not 134 implemented. 135 The rest of this section will only discuss the finalized portion of the 136 virtual system. 130 137 131 138 The virtual system supports multiple ``trees" of types. Each tree is … … 175 182 While much of the virtual infrastructure is created, it is currently only used 176 183 internally 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|.184 cast, which is the same as the \Cpp \codeCpp{dynamic_cast}. 178 185 \label{p:VirtualCast} 179 186 \begin{cfa} … … 197 204 \begin{cfa} 198 205 trait is_exception(exceptT &, virtualT &) { 199 virtualT const & get_exception_vtable(exceptT *);206 // Numerous imaginary assertions. 200 207 }; 201 208 \end{cfa} 202 209 The 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. 210 type. Each exception type should have but a single virtual table type. 211 Now there are no actual assertions in this trait because the trait system 212 actually can't express them (adding such assertions would be part of 213 completing the virtual system). The imaginary assertions would probably come 214 from a trait defined by the virtual system, and state that the exception type 215 is a virtual type, is a decendent of @exception_t@ (the base exception type) 216 and note its virtual table type. 218 217 219 218 % I did have a note about how it is the programmer's responsibility to make … … 235 234 Both traits ensure a pair of types are an exception type and its virtual table 236 235 and defines one of the two default handlers. The default handlers are used 237 as fallbacks and are discussed in detail in \ VRef{s:ExceptionHandling}.236 as fallbacks and are discussed in detail in \vref{s:ExceptionHandling}. 238 237 239 238 However, all three of these traits can be tricky to use directly. … … 351 350 for particular exception type. 352 351 The 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. 354 353 355 354 \subsection{Resumption} … … 426 425 427 426 \subsubsection{Resumption Marking} 427 \label{s:ResumptionMarking} 428 428 A key difference between resumption and termination is that resumption does 429 429 not unwind the stack. A side effect that is that when a handler is matched … … 472 472 The symmetry between resumption termination is why this pattern was picked. 473 473 Other patterns, such as marking just the handlers that caught, also work but 474 lack the symmetry means there are lessrules to remember.474 lack the symmetry means there are more rules to remember. 475 475 476 476 \section{Conditional Catch} … … 557 557 \end{cfa} 558 558 If 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 same560 exception the translations get more complex but they are equivilantly559 check them. If multiple handlers on a single try block that could handle the 560 same exception the translations get more complex but they are equivilantly 561 561 powerful. 562 562 … … 633 633 and the current stack is 634 634 unwound. After that it depends one which stack is being cancelled. 635 \begin{description} 636 \ item[Main Stack:]635 636 \paragraph{Main Stack} 637 637 The main stack is the one used by the program main at the start of execution, 638 638 and is the only stack in a sequential program. … … 645 645 to, so it would have be explicitly managed. 646 646 647 \ item[Thread Stack:]647 \paragraph{Thread Stack} 648 648 A thread stack is created for a \CFA @thread@ object or object that satisfies 649 649 the @is_thread@ trait. … … 671 671 Also you can always add an explicit join if that is the desired behaviour. 672 672 673 \ item[Coroutine Stack:]673 \paragraph{Coroutine Stack} 674 674 A coroutine stack is created for a @coroutine@ object or object that 675 675 satisfies the @is_coroutine@ trait. … … 685 685 (in terms of coroutine state) called resume on this coroutine, so the message 686 686 is passed to the latter. 687 \end{description} -
doc/theses/andrew_beach_MMath/future.tex
rc993b15 r3eb55f98 110 110 \section{Zero-Cost Try} 111 111 \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 compiler112 code rather than assembler code (see \vpageref{p:zero-cost}). When the compiler 113 113 does create its own assembly (or LLVM byte-code), then zero-cost try-statements 114 114 are possible. The downside of zero-cost try-statements is the LSDA complexity, -
doc/theses/andrew_beach_MMath/implement.tex
rc993b15 r3eb55f98 9 9 % Virtual table rules. Virtual tables, the pointer to them and the cast. 10 10 While the \CFA virtual system currently has only one public feature, virtual 11 cast \see{\VPageref{p:VirtualCast}}, substantial structure is required to12 su pport it, and provide features for exception handling and the standard13 library.11 cast (see the virtual cast feature \vpageref{p:VirtualCast}), 12 substantial structure is required to support it, 13 and provide features for exception handling and the standard library. 14 14 15 15 \subsection{Virtual Type} … … 215 215 \subsection{libunwind Usage} 216 216 Libunwind, accessed through @unwind.h@ on most platforms, is a C library that 217 provides \C C-style stack-unwinding. Its operation is divided into two phases:217 provides \Cpp-style stack-unwinding. Its operation is divided into two phases: 218 218 search and cleanup. The dynamic target search -- phase 1 -- is used to scan the 219 219 stack and decide where unwinding should stop (but no unwinding occurs). The … … 291 291 @_UA_FORCE_UNWIND@ specifies a forced unwind call. Forced unwind only performs 292 292 the cleanup phase and uses a different means to decide when to stop 293 \see{\VRef{s:ForcedUnwind}}.293 (see \vref{s:ForcedUnwind}). 294 294 \end{enumerate} 295 295 … … 400 400 401 401 Termination exceptions use libunwind heavily because it matches the intended 402 use from \C Cexceptions closely. The main complication for \CFA is that the402 use from \Cpp exceptions closely. The main complication for \CFA is that the 403 403 compiler generates C code, making it very difficult to generate the assembly to 404 404 form the LSDA for try blocks or destructors. … … 509 509 510 510 % Recursive Resumption Stuff: 511 Search skipping \see{\VPageref{p:searchskip}}, which ignores parts of the stack 511 Search skipping (see \vpageref{s:ResumptionMarking}), which ignores parts of 512 the stack 512 513 already examined, is accomplished by updating the front of the list as the 513 514 search continues. Before the handler at a node is called the head of the list … … 554 555 Cancellation also uses libunwind to do its stack traversal and unwinding, 555 556 however it uses a different primary function @_Unwind_ForcedUnwind@. Details 556 of its interface can be found in the \ VRef{s:ForcedUnwind}.557 of its interface can be found in the \vref{s:ForcedUnwind}. 557 558 558 559 The first step of cancellation is to find the cancelled stack and its type: -
doc/theses/andrew_beach_MMath/uw-ethesis.tex
rc993b15 r3eb55f98 66 66 % Tip: Photographs should be cropped and compressed so as not to be too large. 67 67 68 % To create a PDF output that is optimized for double-sided printing:69 % 1) comment-out the \documentclass statement in the preamble below, and70 % un-comment the second \documentclass line.71 % 2) change the value assigned below to the boolean variable "PrintVersion"72 % from "false" to "true".73 74 68 % ====================================================================== 75 69 % D O C U M E N T P R E A M B L E … … 87 81 } 88 82 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} 97 85 98 86 % For a nomenclature (optional; available from ctan.org) … … 107 95 % Adds todos (Must be included after comment.) 108 96 \usepackage{todonotes} 97 % cfa macros used in the document 98 \usepackage{cfalab} 109 99 110 100 % Hyperlinks make it very easy to navigate an electronic document. … … 208 198 \makeglossaries 209 199 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}]{@}{@}} 235 204 % Annotations from Peter: 236 205 \newcommand{\PAB}[1]{{\color{blue}PAB: #1}} -
doc/user/user.tex
rc993b15 r3eb55f98 11 11 %% Created On : Wed Apr 6 14:53:29 2016 12 12 %% Last Modified By : Peter A. Buhr 13 %% Last Modified On : Sun Apr 25 19:03:03202114 %% Update Count : 495113 %% Last Modified On : Wed Apr 28 21:48:59 2021 14 %% Update Count : 5051 15 15 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 16 16 … … 3312 3312 3313 3313 \section{Tuples} 3314 \label{tuples} 3314 3315 3315 3316 In C and \CFA, lists of elements appear in several contexts, such as the parameter list for a routine call. … … 3420 3421 3421 3422 \subsection{Tuple Coercions} 3423 \label{tuple coercions}\label{coercions!tuple} 3422 3424 3423 3425 There are four coercions that can be performed on tuples and tuple variables: closing, opening, flattening and structuring. … … 3464 3466 3465 3467 \subsection{Mass Assignment} 3468 \label{mass assignment}\label{assignment!mass} 3466 3469 3467 3470 \CFA permits assignment to several variables at once using mass assignment~\cite{CLU}. … … 3504 3507 3505 3508 \subsection{Multiple Assignment} 3509 \label{multiple assignment}\label{assignment!multiple} 3506 3510 3507 3511 \CFA also supports the assignment of several values at once, known as multiple assignment~\cite{CLU,Galletly96}. … … 3545 3549 3546 3550 \subsection{Cascade Assignment} 3551 \index{cascade assignment}\index{assignment!cascade} 3547 3552 3548 3553 As in C, \CFA mass and multiple assignments can be cascaded, producing cascade assignment. … … 3564 3569 \section{Stream I/O Library} 3565 3570 \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} 3568 3573 3569 3574 The goal of \CFA stream input/output (I/O) is to simplify the common cases\index{I/O!common case}, while fully supporting polymorphism and user defined types in a consistent way. 3570 3575 Stream 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.3576 Implicit formatting means \CFA selects the output or input format for values that matches the variable's type. 3572 3577 Explicit formatting means additional information is specified to augment how an output or input of value is interpreted. 3573 \CFA formatting i s 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. 3574 3579 Specifically: 3575 3580 \begin{itemize} … … 3584 3589 Hence, it is common programming practice to toggle manipulators on and then back to the default to prevent downstream side-effects. 3585 3590 Without 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 valuesthan Python, plus implicit newline at the end of a print.3591 Furthermore, 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. 3589 3594 \end{itemize} 3595 3596 The standard polymorphic I/Os stream are ©stdin©/©sin© (input), ©stdout©/©sout© and ©stderr©/©serr© (output) (like C++ ©cin©/©cout©/©cerr©). 3597 Polymorphic streams ©exit© and ©abort© provide implicit program termination without and with generating a stack trace and core file. 3598 Stream ©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} 3603 Note, \CFA stream variables ©stdin©, ©stdout©, ©stderr©, ©exit©, and ©abort© overload C variables ©stdin©, ©stdout©, ©stderr©, and functions ©exit© and ©abort©, respectively. 3590 3604 The \CFA header file for the I/O library is \Indexc{fstream.hfa}. 3605 3606 3607 \subsection{Basic I/O} 3591 3608 3592 3609 For implicit formatted output, the common case is printing a series of variables separated by whitespace. … … 3601 3618 \begin{cfa} 3602 3619 3603 cout << x ®<< " "® << y ®<< " "® << z<< endl;3620 cout << x ®<< " "® << y ®<< " "® << z << endl; 3604 3621 \end{cfa} 3605 3622 & … … 3653 3670 \end{tabular} 3654 3671 \end{cquote} 3655 Input and output use a uniform operator, ©|©, rather than separate operators, as in ©>>© and ©<<© for \CC.3672 Input and output use a uniform operator, ©|©, rather than \CC's ©>>© and ©<<© input/output operators. 3656 3673 There is a weak similarity between the \CFA logical-or operator and the \Index{Shell pipe-operator} for moving data, where data flows in the correct direction for input but the opposite direction for output. 3657 3674 … … 3698 3715 \end{cquote} 3699 3716 3717 \VRef[Figure]{f:CFACommand-LineProcessing} shows idiomatic \CFA command-line processing and copying an input file to an output file. 3718 Note, a stream variable may be copied because it is a reference to an underlying stream data-structures. 3719 All I/O errors are handles as exceptions, but end-of-file is not an exception as C programmers are use to explicitly checking for it. 3720 3721 \begin{figure} 3722 \begin{cfa} 3723 #include ®<fstream.hfa>® 3724 3725 int 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. 3770 Returns 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. 3777 The bytes are written lazily to file when internal buffers fill. 3778 Eager 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. 3783 Pushed-back characters returned by subsequent reads in the reverse order of pushing. 3784 \end{itemize} 3785 The constructor functions: 3786 \begin{itemize}[topsep=4pt,itemsep=2pt,parsep=0pt] 3787 \item 3788 create an unbound stream, which is subsequently bound to a file with ©open©. 3789 \item 3790 create a bound stream to the associated file with given ©mode©. 3791 \end{itemize} 3792 The destructor closes the stream. 3793 3794 \begin{figure} 3795 \begin{cfa} 3796 // *********************************** ofstream *********************************** 3797 3798 bool fail( ofstream & );$\indexc{fail}\index{ofstream@©ofstream©!©fail©}$ 3799 void clear( ofstream & );$\indexc{clear}\index{ofstream@©ofstream©!©clear©}$ 3800 int flush( ofstream & );$\indexc{flush}\index{ofstream@©ofstream©!©flush©}$ 3801 void open( ofstream &, const char name[], const char mode[] = "w" );$\indexc{open}\index{ofstream@©ofstream©!©open©}$ 3802 void close( ofstream & );$\indexc{close}\index{ofstream@©ofstream©!©close©}$ 3803 ofstream & write( ofstream &, const char data[], size_t size );$\indexc{write}\index{ofstream@©ofstream©!©write©}$ 3804 3805 void ?{}( ofstream & );$\index{ofstream@©ofstream©!©?{}©}$ 3806 void ?{}( ofstream &, const char name[], const char mode[] = "w" ); 3807 void ^?{}( ofstream & );$\index{ofstream@©ofstream©!©^?{}©}$ 3808 3809 // *********************************** ifstream *********************************** 3810 3811 bool fail( ifstream & is );$\indexc{fail}\index{ifstream@©ifstream©!©fail©}$ 3812 void clear( ifstream & );$\indexc{clear}\index{ifstream@©ifstream©!©clear©}$ 3813 bool eof( ifstream & is );$\indexc{eof}\index{ifstream@©ifstream©!©eof©}$ 3814 void open( ifstream & is, const char name[], const char mode[] = "r" );$\indexc{open}\index{ifstream@©ifstream©!©open©}$ 3815 void close( ifstream & is );$\indexc{close}\index{ifstream@©ifstream©!©close©}$ 3816 ifstream & read( ifstream & is, char data[], size_t size );$\indexc{read}\index{ifstream@©ifstream©!©read©}$ 3817 ifstream & ungetc( ifstream & is, char c );$\indexc{unget}\index{ifstream@©ifstream©!©unget©}$ 3818 3819 void ?{}( ifstream & is );$\index{ifstream@©ifstream©!©?{}©}$ 3820 void ?{}( ifstream & is, const char name[], const char mode[] = "r" ); 3821 void ^?{}( ifstream & is );$\index{ifstream@©ifstream©!©^?{}©}$ 3822 \end{cfa} 3823 \caption{Stream Functions} 3824 \label{f:StreamFunctions} 3825 \end{figure} 3700 3826 3701 3827 … … 4030 4156 sout | wd( 4, "ab" ) | wd( 3, "ab" ) | wd( 2, "ab" ); 4031 4157 \end{cfa} 4032 \begin{cfa}[showspaces=true,aboveskip=0pt ,belowskip=0pt]4158 \begin{cfa}[showspaces=true,aboveskip=0pt] 4033 4159 ® ®34 ® ®34 34 4034 4160 ® ®4.000000 ® ®4.000000 4.000000 … … 4378 4504 \end{cfa} 4379 4505 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 4509 All 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 4516 int 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} 4543 The constructor functions: 4544 \begin{itemize}[topsep=4pt,itemsep=2pt,parsep=0pt] 4545 \item 4546 create 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 4553 ostrstream & write( ostrstream & os, FILE * stream = stdout ); 4554 4555 void ?{}( ostrstream &, char buf[], size_t size ); 4556 4557 // *********************************** istrstream *********************************** 4558 4559 void ?{}( istrstream & is, char buf[] ); 4560 \end{cfa} 4561 \caption{String Stream Functions} 4562 \label{f:StringStreamFunctions} 4563 \end{figure} 4387 4564 4388 4565 … … 8111 8288 \begin{cquote} 8112 8289 \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}} \\ 8114 8291 \hline 8115 8292 \begin{cfa} 8116 #include <gmp >$\indexc{gmp}$8293 #include <gmp.hfa>$\indexc{gmp}$ 8117 8294 int main( void ) { 8118 8295 sout | "Factorial Numbers"; -
libcfa/src/fstream.cfa
rc993b15 r3eb55f98 10 10 // Created On : Wed May 27 17:56:53 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Tue Apr 27 22:08:57202113 // Update Count : 44 212 // Last Modified On : Wed Apr 28 20:37:53 2021 13 // Update Count : 445 14 14 // 15 15 … … 114 114 } // fail 115 115 116 void clear( ofstream & os ) { 117 clearerr( (FILE *)(os.file$) ); 118 } // clear 119 116 120 int flush( ofstream & os ) { 117 121 return fflush( (FILE *)(os.file$) ); … … 207 211 } // nl 208 212 213 209 214 // *********************************** ifstream *********************************** 210 215 … … 240 245 } // fail 241 246 247 void clear( ifstream & is ) { 248 clearerr( (FILE *)(is.file$) ); 249 } // clear 250 242 251 void ends( ifstream & is ) { 243 252 if ( is.acquired$ ) { is.acquired$ = false; release( is ); } 244 253 } // ends 245 254 246 inteof( ifstream & is ) {255 bool eof( ifstream & is ) { 247 256 return feof( (FILE *)(is.file$) ); 248 257 } // eof … … 273 282 } // close 274 283 275 ifstream & read( ifstream & is, char * data, size_t size ) {284 ifstream & read( ifstream & is, char data[], size_t size ) { 276 285 if ( fail( is ) ) { 277 286 abort | IO_MSG "attempt read I/O on failed stream"; -
libcfa/src/fstream.hfa
rc993b15 r3eb55f98 10 10 // Created On : Wed May 27 17:56:53 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Tue Apr 27 22:00:30202113 // Update Count : 2 2612 // Last Modified On : Wed Apr 28 20:37:57 2021 13 // Update Count : 230 14 14 // 15 15 … … 70 70 71 71 bool fail( ofstream & ); 72 void clear( ofstream & ); 72 73 int flush( ofstream & ); 73 74 void open( ofstream &, const char name[], const char mode[] ); // FIX ME: use default = "w" … … 119 120 120 121 bool fail( ifstream & is ); 121 int eof( ifstream & is ); 122 void clear( ifstream & ); 123 bool eof( ifstream & is ); 122 124 void open( ifstream & is, const char name[], const char mode[] ); // FIX ME: use default = "r" 123 125 void open( ifstream & is, const char name[] ); 124 126 void close( ifstream & is ); 125 ifstream & read( ifstream & is, char * data, size_t size );127 ifstream & read( ifstream & is, char data[], size_t size ); 126 128 ifstream & ungetc( ifstream & is, char c ); 127 129 -
libcfa/src/iostream.hfa
rc993b15 r3eb55f98 10 10 // Created On : Wed May 27 17:56:53 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Tue Apr 27 17:59:21202113 // Update Count : 39812 // Last Modified On : Wed Apr 28 20:37:56 2021 13 // Update Count : 401 14 14 // 15 15 … … 52 52 53 53 trait ostream( ostype & | basic_ostream( ostype ) ) { 54 bool fail( ostype & ); // operation failed? 55 void clear( ostype & ); 54 56 int flush( ostype & ); 55 bool fail( ostype & ); // operation failed?56 57 void open( ostype &, const char name[], const char mode[] ); 57 58 void close( ostype & ); … … 302 303 int fmt( istype &, const char format[], ... ) __attribute__(( format(scanf, 2, 3) )); 303 304 istype & ungetc( istype &, char ); 304 inteof( istype & );305 bool eof( istype & ); 305 306 }; // basic_istream 306 307 307 308 trait istream( istype & | basic_istream( istype ) ) { 308 309 bool fail( istype & ); 310 void clear( istype & ); 309 311 void open( istype & is, const char name[] ); 310 312 void close( istype & is ); 311 istype & read( istype &, char *, size_t );313 istype & read( istype &, char [], size_t ); 312 314 void acquire( istype & ); // concurrent access 313 315 }; // 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 1 13 #include <fstream.hfa> 2 14 #include <strstream.hfa> 3 15 4 16 int main() { 5 6 char buf[size]; 7 ostrstream osstr = { buf, size }; 8 9 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; 10 22 11 osstr | i | hex(j) | wd(10, k) | sci(x) | unit(eng(y)); 12 13 14 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)); 15 27 16 // char buf2[] = "12 14 15 3.5 7e4"; 17 18 19 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; 20 32 } 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.
