Index: doc/bibliography/pl.bib
===================================================================
--- doc/bibliography/pl.bib	(revision c9019ce9baa8a8b2d2de47644af67760b22dca5d)
+++ doc/bibliography/pl.bib	(revision 599dc6a91726849d6977f9d3d2db97dea2de87de)
@@ -230,15 +230,4 @@
     publisher	= {MIT Press, Cambridge},
     year	= 1986
-}
-
-@inproceedings{Srinivasan08,
-    author	= {Srinivasan, Sriram and Mycroft, Alan},
-    editor	= {Vitek, Jan},
-    title	= {Kilim: Isolation-Typed Actors for Java},
-    organization= {ECOOP 2008 -- Object-Oriented Programming},
-    year	= {2008},
-    publisher	= {Springer Berlin Heidelberg},
-    address	= {Berlin, Heidelberg},
-    pages	= {104--128},
 }
 
@@ -430,4 +419,18 @@
 }
 
+@article{Delisle21,
+    keywords	= {concurrency, Cforall},
+    contributer	= {pabuhr@plg},
+    author	= {Thierry Delisle and Peter A. Buhr},
+    title	= {Advanced Control-flow and Concurrency in \textsf{C}$\mathbf{\forall}$},
+    journal	= spe,
+    month	= may,
+    year	= 2021,
+    volume	= 51,
+    number	= 5,
+    pages	= {1005-1042},
+    optnote	= {\href{https://onlinelibrary.wiley.com/doi/10.1002/spe.2925}{https://\-onlinelibrary.wiley.com/\-doi/\-10.1002/\-spe.2925}},
+}
+
 @article{Buhr00a,
     keywords	= {exception handling},
@@ -1226,4 +1229,15 @@
 }
 
+@phdthesis{Delisle22,
+    contributer	= {pabuhr@plg},
+    author	= {Delisle, Thierry},
+    title	= {The \textsf{C}$\mathbf{\forall}$ Scheduler},
+    school	= {School of Computer Science, University of Waterloo},
+    address	= {Waterloo, Ontario, Canada, N2L 3G1},
+    publisher	= {UWSpace},
+    year	= 2022,
+    note	= {\url{http://hdl.handle.net/10012/18941}}
+}
+
 @misc{CFAStackEvaluation,
     contributer	= {a3moss@plg},
@@ -1643,5 +1657,6 @@
     volume	= 21,
     number	= 8,
-    pages	= {666-677}
+    pages	= {666-677},
+    publisher	= {ACM New York, NY, USA},
 }
 
@@ -1988,21 +2003,8 @@
     title	= {Concurrency in \textsf{C}$\mathbf{\forall}$},
     school	= {School of Computer Science, University of Waterloo},
+    address	= {Waterloo, Ontario, Canada, N2L 3G1},
+    publisher	= {UWSpace},
     year	= 2018,
-    optaddress	= {Waterloo, Ontario, Canada, N2L 3G1},
-    note	= {\href{https://uwspace.uwaterloo.ca/handle/10012/12888}{https://\-uwspace.uwaterloo.ca/\-handle/\-10012/\-12888}},
-}
-
-@article{Delisle21,
-    keywords	= {concurrency, Cforall},
-    contributer	= {pabuhr@plg},
-    author	= {Thierry Delisle and Peter A. Buhr},
-    title	= {Advanced Control-flow and Concurrency in \textsf{C}$\mathbf{\forall}$},
-    journal	= spe,
-    month	= may,
-    year	= 2021,
-    volume	= 51,
-    number	= 5,
-    pages	= {1005-1042},
-    optnote	= {\href{https://onlinelibrary.wiley.com/doi/10.1002/spe.2925}{https://\-onlinelibrary.wiley.com/\-doi/\-10.1002/\-spe.2925}},
+    note	= {\url{http://hdl.handle.net/10012/12888}},
 }
 
@@ -3345,4 +3347,15 @@
 }
 
+@mastersthesis{Beach21,
+    contributer	= {pabuhr@plg},
+    author	= {Beach, Andrew James},
+    title	= {Exception Handling in \textsf{C}$\mathbf{\forall}$},
+    school	= {School of Computer Science, University of Waterloo},
+    address	= {Waterloo, Ontario, Canada, N2L 3G1},
+    publisher	= {UWSpace},
+    year	= {2021},
+    note	= {\url{http://hdl.handle.net/10012/17617}},
+}
+
 @article{Liskov79,
     keywords	= {exception handling},
@@ -4076,5 +4089,5 @@
     year	= 2022,
     address	= {Waterloo, Ontario, Canada, N2L 3G1},
-    note	= {\href{https://uwspace.uwaterloo.ca/handle/10012/18329}{https://\-uwspace.uwaterloo.ca/\-handle/\-10012/18329}},
+    note	= {\url{http://hdl.handle.net/10012/18329}},
 }
 
@@ -4328,5 +4341,5 @@
     month	= sep,
     optaddress	= {Waterloo, Ontario, Canada, N2L 3G1},
-    note	= {\href{https://uwspace.uwaterloo.ca/handle/10012/13935}{https://\-uwspace.uwaterloo.ca/\-handle/\-10012/\-13935}},
+    note	= {\url{https://uwspace.uwaterloo.ca/handle/10012/13935}},
 }
 
@@ -4725,4 +4738,15 @@
     year	= 1996,
     pages	= {80-87},
+}
+
+@inproceedings{Srinivasan08,
+    author	= {Srinivasan, Sriram and Mycroft, Alan},
+    editor	= {Vitek, Jan},
+    title	= {Kilim: Isolation-Typed Actors for Java},
+    organization= {ECOOP 2008 -- Object-Oriented Programming},
+    year	= {2008},
+    publisher	= {Springer Berlin Heidelberg},
+    address	= {Berlin, Heidelberg},
+    pages	= {104--128},
 }
 
@@ -5078,4 +5102,24 @@
 }
 
+@article{Hesselink23,
+    keywords	= {Concurrency, mutual exclusion, atomicity, critical section, efficiency},
+    contributer	= {pabuhr@plg},
+    author	= {Hesselink, Wim H. and Buhr, Peter A.},
+    title	= {MCSH, a Lock with the Standard Interface},
+    issue_date	= {June 2023},
+    publisher	= {Association for Computing Machinery},
+    address	= {New York, NY, USA},
+    volume	= 10,
+    number	= 2,
+    journal	= {ACM Trans. Parallel Comput.},
+    issn	= {2329-4949},
+    url		= {https://doi.org/10.1145/3584696},
+    doi		= {10.1145/3584696},
+    articleno	= 11,
+    numpages	= 23,
+    month	= jun,
+    year	= {2023},
+}
+
 @inproceedings{mprof,
     keywords	= {malloc},
Index: doc/user/Makefile
===================================================================
--- doc/user/Makefile	(revision c9019ce9baa8a8b2d2de47644af67760b22dca5d)
+++ doc/user/Makefile	(revision 599dc6a91726849d6977f9d3d2db97dea2de87de)
@@ -68,6 +68,6 @@
 	-${BibTeX} ${Build}/${basename $@}
 	# Some citations reference others so run again to resolve these citations
-#	${LaTeX} ${basename $@}.tex
-	-${BibTeX} ${Build}/${basename $@}
+	${LaTeX} ${basename $@}.tex
+#	-${BibTeX} ${Build}/${basename $@}
 	# Make index from *.aux entries and input index at end of document
 	makeindex -s ${Macros}/indexstyle ${Build}/${basename $@}.idx
Index: doc/user/user.tex
===================================================================
--- doc/user/user.tex	(revision c9019ce9baa8a8b2d2de47644af67760b22dca5d)
+++ doc/user/user.tex	(revision 599dc6a91726849d6977f9d3d2db97dea2de87de)
@@ -11,6 +11,6 @@
 %% Created On       : Wed Apr  6 14:53:29 2016
 %% Last Modified By : Peter A. Buhr
-%% Last Modified On : Mon Jun  5 21:18:29 2023
-%% Update Count     : 5521
+%% Last Modified On : Thu Jun 29 21:52:51 2023
+%% Update Count     : 5533
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
@@ -3981,15 +3981,15 @@
 
 The following \Index{manipulator}s control \Index{implicit output separation}.
-The effect of these manipulators is global for an output stream (except ©sepOn© and ©sepOff©).
+The effect of these manipulators is global for an output stream (except ©sep© and ©nosep©).
 \begin{enumerate}
 \item
-\Indexc{sepSet}\index{manipulator!sepSet@©sepSet©} and \Indexc{sep}\index{manipulator!sep@©sep©}/\Indexc{sepGet}\index{manipulator!sepGet@©sepGet©} set and get the separator string.
+\Indexc{sepSet}\index{manipulator!sepSet@©sepSet©} and \Indexc{sepVal}\index{manipulator!sepVal@©sepVal©}/\Indexc{sepGet}\index{manipulator!sepGet@©sepGet©} set and get the separator string.
 The separator string can be at most 16 characters including the ©'\0'© string terminator (15 printable characters).
 \begin{cfa}[belowskip=0pt]
 sepSet( sout, ", $\LstStringStyle{\textdollar}$" ); $\C{// set separator from " " to ", \$"}$
-sout | 1 | 2 | 3 | " \"" | ®sep® | "\"";
+sout | 1 | 2 | 3 | " \"" | ®sepVal® | "\"";
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt]
-1®, $\LstStringStyle{\textdollar}$®2®, $\LstStringStyle{\textdollar}$®3 ®", $\LstStringStyle{\textdollar}$"®
+1®, $\color{red}\LstStringStyle{\textdollar}$®2®, $\color{red}\LstStringStyle{\textdollar}$®3 ®", $\color{red}\LstStringStyle{\textdollar}$"®
 \end{cfa}
 \begin{cfa}[belowskip=0pt]
@@ -4019,9 +4019,9 @@
 
 \item
-\Indexc{sepSetTuple}\index{manipulator!sepSetTuple@©sepSetTuple©} and \Indexc{sepTuple}\index{manipulator!sepTuple@©sepTuple©}/\Indexc{sepGetTuple}\index{manipulator!sepGetTuple@©sepGetTuple©} get and set the tuple separator-string.
+\Indexc{sepSetTuple}\index{manipulator!sepSetTuple@©sepSetTuple©} and \Indexc{sepTupleVal}\index{manipulator!sepTupleVal@©sepTupleVal©}/\Indexc{sepGetTuple}\index{manipulator!sepGetTuple@©sepGetTuple©} get and set the tuple separator-string.
 The tuple separator-string can be at most 16 characters including the ©'\0'© string terminator (15 printable characters).
 \begin{cfa}[belowskip=0pt]
 sepSetTuple( sout, " " ); $\C{// set tuple separator from ", " to " "}$
-sout | t1 | t2 | " \"" | ®sepTuple® | "\"";
+sout | t1 | t2 | " \"" | ®sepTupleVal® | "\"";
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt]
@@ -4038,7 +4038,7 @@
 
 \item
-\Indexc{sepDisable}\index{manipulator!sepDisable@©sepDisable©} and \Indexc{sepEnable}\index{manipulator!sepEnable@©sepEnable©} globally toggle printing the separator.
+\Indexc{sepOff}\index{manipulator!sepOff@©sepOff©} and \Indexc{sepOn}\index{manipulator!sepOn@©sepOn©} globally toggle printing the separator.
 \begin{cfa}[belowskip=0pt]
-sout | sepDisable | 1 | 2 | 3; $\C{// turn off implicit separator}$
+sout | ®sepOff® | 1 | 2 | 3; $\C{// turn off implicit separator}$
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
@@ -4046,5 +4046,5 @@
 \end{cfa}
 \begin{cfa}[belowskip=0pt]
-sout | sepEnable | 1 | 2 | 3; $\C{// turn on implicit separator}$
+sout | ®sepOn® | 1 | 2 | 3; $\C{// turn on implicit separator}$
 \end{cfa}
 \begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt]
@@ -4053,7 +4053,7 @@
 
 \item
-\Indexc{sepOn}\index{manipulator!sepOn@©sepOn©} and \Indexc{sepOff}\index{manipulator!sepOff@©sepOff©} locally toggle printing the separator with respect to the next printed item, and then return to the global separator setting.
+\Indexc{sep}\index{manipulator!sep@©sep©} and \Indexc{nosep}\index{manipulator!nosep@©nosep©} locally toggle printing the separator with respect to the next printed item, and then return to the global separator setting.
 \begin{cfa}[belowskip=0pt]
-sout | 1 | sepOff | 2 | 3; $\C{// turn off implicit separator for the next item}$
+sout | 1 | ®nosep® | 2 | 3; $\C{// turn off implicit separator for the next item}$
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
@@ -4061,5 +4061,5 @@
 \end{cfa}
 \begin{cfa}[belowskip=0pt]
-sout | sepDisable | 1 | sepOn | 2 | 3; $\C{// turn on implicit separator for the next item}$
+sout | sepOff | 1 | ®sep® | 2 | 3; $\C{// turn on implicit separator for the next item}$
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
@@ -4068,13 +4068,13 @@
 The tuple separator also responses to being turned on and off.
 \begin{cfa}[belowskip=0pt]
-sout | t1 | sepOff | t2; $\C{// turn off implicit separator for the next item}$
+sout | t1 | ®nosep® | t2; $\C{// turn off implicit separator for the next item}$
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
 1, 2, 34, 5, 6
 \end{cfa}
-©sepOn© \emph{cannot} be used to start/end a line with a separator because separators do not appear at the start/end of a line;
+©sep© \emph{cannot} be used to start/end a line with a separator because separators do not appear at the start/end of a line;
 use ©sep© to accomplish this functionality.
 \begin{cfa}[belowskip=0pt]
-sout | sepOn | 1 | 2 | 3 | sepOn; $\C{// sepOn does nothing at start/end of line}$
+sout | ®sep® | 1 | 2 | 3 | ®sep®; $\C{// sep does nothing at start/end of line}$
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
@@ -4082,5 +4082,5 @@
 \end{cfa}
 \begin{cfa}[belowskip=0pt]
-sout | sep | 1 | 2 | 3 | sep ; $\C{// use sep to print separator at start/end of line}$
+sout | ®sepVal® | 1 | 2 | 3 | ®sepVal® ; $\C{// use sepVal to print separator at start/end of line}$
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
@@ -4116,8 +4116,8 @@
 \Indexc{nl}\index{manipulator!nl@©nl©} inserts a newline.
 \begin{cfa}
-sout | nl; $\C{// only print newline}$
+sout | ®nl®; $\C{// only print newline}$
 sout | 2; $\C{// implicit newline}$
-sout | 3 | nl | 4 | nl; $\C{// terminating nl merged with implicit newline}$
-sout | 5 | nl | nl; $\C{// again terminating nl merged with implicit newline}$
+sout | 3 | ®nl® | 4 | ®nl®; $\C{// terminating nl merged with implicit newline}$
+sout | 5 | ®nl® | ®nl®; $\C{// again terminating nl merged with implicit newline}$
 sout | 6; $\C{// implicit newline}$
 
@@ -4286,9 +4286,10 @@
 For the C-string type, precision is the maximum number of printed characters, so the string is truncated if it exceeds the maximum.
 \begin{cfa}[belowskip=0pt]
-sout | wd( 6,8, "abcd" ) | wd( 6,8, "abcdefghijk" ) | wd( 6,3, "abcd" );
+sout | wd( 6,8, "abcd" ) | wd( 6,8, "abcdefghijk" ) | wd( 6,3, "abcd" ) | ®wd( 10, "" )® | 'X';
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
-  abcd abcdefgh    abc
-\end{cfa}
+  abcd abcdefgh    abc®          ®X
+\end{cfa}
+Note, printing the null string with minimum width L pads with L spaces.
 
 \item
@@ -4373,13 +4374,13 @@
 	sout | t1 | t2 | " \"" | sepGetTuple( sout ) | "\"";
 
-	sout | sepDisable | 1 | 2 | 3;		// globally turn off implicit separator
-	sout | sepEnable | 1 | 2 | 3;		// globally turn on implicit separator
-
-	sout | 1 | sepOff | 2 | 3;			// locally turn on implicit separator
-	sout | sepDisable | 1 | sepOn | 2 | 3; // globally turn off implicit separator
-	sout | sepEnable;
-	sout | t1 | sepOff | t2;				// locally turn on/off implicit separator
-
-	sout | sepOn | 1 | 2 | 3 | sepOn ;	// sepOn does nothing at start/end of line
+	sout | sepOff | 1 | 2 | 3;		// globally turn off implicit separator
+	sout | sepOn | 1 | 2 | 3;		// globally turn on implicit separator
+
+	sout | 1 | nosep | 2 | 3;			// locally turn on implicit separator
+	sout | sepOff | 1 | sep | 2 | 3; // globally turn off implicit separator
+	sout | sepOn;
+	sout | t1 | nosep | t2;				// locally turn on/off implicit separator
+
+	sout | sep | 1 | 2 | 3 | sep ;	// sep does nothing at start/end of line
 	sout | sep | 1 | 2 | 3 | sep ;		// use sep to print separator at start/end of line
 }
@@ -4692,5 +4693,6 @@
 	sout  | i | j | k | x | y | s;
 }
-
+\end{cfa}
+\begin{cfa}[showspaces=true]
 3 0x5          7 1.234568e+07 987.654n abc
 3 0x5          7 1.234568e+07 987.654n abc
Index: libcfa/src/containers/string_res.cfa
===================================================================
--- libcfa/src/containers/string_res.cfa	(revision c9019ce9baa8a8b2d2de47644af67760b22dca5d)
+++ libcfa/src/containers/string_res.cfa	(revision 599dc6a91726849d6977f9d3d2db97dea2de87de)
@@ -9,7 +9,7 @@
 // Author           : Michael L. Brooks
 // Created On       : Fri Sep 03 11:00:00 2021
-// Last Modified By : Michael L. Brooks
-// Last Modified On : Fri Sep 03 11:00:00 2021
-// Update Count     : 1
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Thu Jun 29 09:29:06 2023
+// Update Count     : 2
 //
 
@@ -204,5 +204,5 @@
         out | s[i];
     }
-    out | sep;
+    out | sepVal;
     // Re-apply newlines after done, for chaining version
     if (anl) nlOn(out);
Index: libcfa/src/fstream.cfa
===================================================================
--- libcfa/src/fstream.cfa	(revision c9019ce9baa8a8b2d2de47644af67760b22dca5d)
+++ libcfa/src/fstream.cfa	(revision 599dc6a91726849d6977f9d3d2db97dea2de87de)
@@ -10,6 +10,6 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jun 17 08:51:12 2023
-// Update Count     : 528
+// Last Modified On : Thu Jun 29 11:09:52 2023
+// Update Count     : 533
 //
 
@@ -43,4 +43,8 @@
 } // ?{}
 
+inline bool getNL$( ofstream & os ) { return os.sawNL$; }
+inline void setNL$( ofstream & os, bool state ) { os.sawNL$ = state; }
+inline bool getANL$( ofstream & os ) { return os.nlOnOff$; }
+
 inline bool sepPrt$( ofstream & os ) { setNL$( os, false ); return os.sepOnOff$; }
 inline void sepReset$( ofstream & os ) { os.sepOnOff$ = os.sepDefault$; }
@@ -48,7 +52,5 @@
 inline const char * sepGetCur$( ofstream & os ) { return os.sepCur$; }
 inline void sepSetCur$( ofstream & os, const char sepCur[] ) { os.sepCur$ = sepCur; }
-inline bool getNL$( ofstream & os ) { return os.sawNL$; }
-inline void setNL$( ofstream & os, bool state ) { os.sawNL$ = state; }
-inline bool getANL$( ofstream & os ) { return os.nlOnOff$; }
+
 inline bool getPrt$( ofstream & os ) { return os.prt$; }
 inline void setPrt$( ofstream & os, bool state ) { os.prt$ = state; }
@@ -63,23 +65,23 @@
 void ^?{}( ofstream & os ) { close( os ); }
 
-void sepOn( ofstream & os ) { os.sepOnOff$ = ! getNL$( os ); }
-void sepOff( ofstream & os ) { os.sepOnOff$ = false; }
-
-bool sepDisable( ofstream & os ) {
+void nlOn( ofstream & os ) { os.nlOnOff$ = true; }
+void nlOff( ofstream & os ) { os.nlOnOff$ = false; }
+
+void sep( ofstream & os ) { os.sepOnOff$ = ! getNL$( os ); }
+void nosep( ofstream & os ) { os.sepOnOff$ = false; }
+
+bool sepOn( ofstream & os ) {
+	bool temp = os.sepDefault$;
+	os.sepDefault$ = true;
+	if ( os.sepOnOff$ ) sepReset$( os );				// start of line ?
+	return temp;
+} // sepOn
+
+bool sepOff( ofstream & os ) {
 	bool temp = os.sepDefault$;
 	os.sepDefault$ = false;
 	sepReset$( os );
 	return temp;
-} // sepDisable
-
-bool sepEnable( ofstream & os ) {
-	bool temp = os.sepDefault$;
-	os.sepDefault$ = true;
-	if ( os.sepOnOff$ ) sepReset$( os );				// start of line ?
-	return temp;
-} // sepEnable
-
-void nlOn( ofstream & os ) { os.nlOnOff$ = true; }
-void nlOff( ofstream & os ) { os.nlOnOff$ = false; }
+} // sepOff
 
 const char * sepGet( ofstream & os ) { return os.separator$; }
Index: libcfa/src/fstream.hfa
===================================================================
--- libcfa/src/fstream.hfa	(revision c9019ce9baa8a8b2d2de47644af67760b22dca5d)
+++ libcfa/src/fstream.hfa	(revision 599dc6a91726849d6977f9d3d2db97dea2de87de)
@@ -10,6 +10,6 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Jun  5 22:00:20 2023
-// Update Count     : 246
+// Last Modified On : Thu Jun 29 11:08:31 2023
+// Update Count     : 251
 //
 
@@ -40,4 +40,8 @@
 
 // private
+bool getNL$( ofstream & );
+void setNL$( ofstream &, bool );
+bool getANL$( ofstream & );
+
 bool sepPrt$( ofstream & );
 void sepReset$( ofstream & );
@@ -45,7 +49,5 @@
 const char * sepGetCur$( ofstream & );
 void sepSetCur$( ofstream &, const char [] );
-bool getNL$( ofstream & );
-void setNL$( ofstream &, bool );
-bool getANL$( ofstream & );
+
 bool getPrt$( ofstream & );
 void setPrt$( ofstream &, bool );
@@ -55,11 +57,11 @@
 
 // public
-void sepOn( ofstream & );
-void sepOff( ofstream & );
-bool sepDisable( ofstream & );
-bool sepEnable( ofstream & );
 void nlOn( ofstream & );
 void nlOff( ofstream & );
 
+void sep( ofstream & );
+void nosep( ofstream & );
+bool sepOn( ofstream & );
+bool sepOff( ofstream & );
 const char * sepGet( ofstream & );
 void sepSet( ofstream &, const char [] );
Index: libcfa/src/gmp.hfa
===================================================================
--- libcfa/src/gmp.hfa	(revision c9019ce9baa8a8b2d2de47644af67760b22dca5d)
+++ libcfa/src/gmp.hfa	(revision 599dc6a91726849d6977f9d3d2db97dea2de87de)
@@ -10,6 +10,6 @@
 // Created On       : Tue Apr 19 08:43:43 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Apr 20 20:59:21 2021
-// Update Count     : 32
+// Last Modified On : Thu Jun 29 09:43:30 2023
+// Update Count     : 33
 //
 
@@ -265,5 +265,5 @@
 			if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
 			gmp_printf( "%Zd", mp.mpz );
-			sepOn( os );
+			sep( os );
 			return os;
 		} // ?|?
Index: libcfa/src/iostream.cfa
===================================================================
--- libcfa/src/iostream.cfa	(revision c9019ce9baa8a8b2d2de47644af67760b22dca5d)
+++ libcfa/src/iostream.cfa	(revision 599dc6a91726849d6977f9d3d2db97dea2de87de)
@@ -10,6 +10,6 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Jan  9 09:27:58 2023
-// Update Count     : 1361
+// Last Modified On : Thu Jun 29 10:12:39 2023
+// Update Count     : 1380
 //
 
@@ -50,5 +50,5 @@
 		fmt( os, "%c", c );
 		if ( c == '\n' ) setNL$( os, true );
-		return sepOff( os );
+		return nosep( os );
 	} // ?|?
 	void ?|?( ostype & os, char c ) {
@@ -284,5 +284,5 @@
 
 	  if ( s == 0p ) { fmt( os, "%s", "0p" ); return os; } // null pointer
-	  if ( s[0] == '\0' ) { sepOff( os ); return os; } // null string => no separator
+	  if ( s[0] == '\0' ) { nosep( os ); return os; }	// null string => no leading/trailing separator
 
 		// first character IS NOT spacing or closing punctuation => add left separator
@@ -300,7 +300,7 @@
 		fmt( os, "%s", s );								// fmt resets seperator, but reset it again
 		if ( sepPrt$( os ) && mask[ ch ] != Open && mask[ ch ] != OpenClose ) {
-			sepOn( os );
+			sep( os );
 		} else {
-			sepOff( os );
+			nosep( os );
 		} // if
 		if ( ch == '\n' ) setNL$( os, true );			// check *AFTER* sepPrt$ call above as it resets NL flag
@@ -351,17 +351,9 @@
 	} // ?|?
 
-	ostype & sep( ostype & os ) {
-		return (ostype &)(os | sepGet( os ));
-	} // sep
-
-	ostype & sepTuple( ostype & os ) {
-		return os | sepGetTuple( os );
-	} // sepTuple
-
 	ostype & nl( ostype & os ) {
 		(ostype &)(os | '\n');
 		setPrt$( os, false );							// turn off
 		setNL$( os, true );
-		return sepOff( os );							// prepare for next line
+		return nosep( os );								// prepare for next line
 	} // nl
 
@@ -371,4 +363,32 @@
 	} // nonl
 
+	ostype & nlOn( ostype & os ) {
+		nlOn( os );										// call void returning
+		return os;
+	} // nlOn
+
+	ostype & nlOff( ostype & os ) {
+		nlOff( os );									// call void returning
+		return os;
+	} // nlOff
+
+	ostype & sepVal( ostype & os ) {
+		return (ostype &)(os | sepGet( os ));
+	} // sepVal
+
+	ostype & sepTupleVal( ostype & os ) {
+		return os | sepGetTuple( os );
+	} // sepTupleVal
+
+	ostype & sep( ostype & os ) {
+		sep( os );										// call void returning
+		return os;
+	} // sep
+
+	ostype & nosep( ostype & os ) {
+		nosep( os );									// call void returning
+		return os;
+	} // nosep
+
 	ostype & sepOn( ostype & os ) {
 		sepOn( os );									// call void returning
@@ -380,24 +400,4 @@
 		return os;
 	} // sepOff
-
-	ostype & sepEnable( ostype & os ) {
-		sepEnable( os );								// call void returning
-		return os;
-	} // sepEnable
-
-	ostype & sepDisable( ostype & os ) {
-		sepDisable( os );								// call void returning
-		return os;
-	} // sepDisable
-
-	ostype & nlOn( ostype & os ) {
-		nlOn( os );										// call void returning
-		return os;
-	} // nlOn
-
-	ostype & nlOff( ostype & os ) {
-		nlOff( os );									// call void returning
-		return os;
-	} // nlOff
 } // distribution
 
@@ -550,5 +550,5 @@
 		if ( cnt == 1 ) {
 			if ( f.flags.left ) { wd -= maxdig; f.wd = wd < 0 ? 1 : wd; } // update and restore f.wd for printing end chunk
-			sepOff( os );								// no seperator between chunks
+			nosep( os );								// no seperator between chunks
 		} // if
 	} else {											// print start chunk
@@ -595,5 +595,5 @@
 		else { f.pc = maxdig; f.flags.pc = true; }		// left pad with precision
 
-		if ( cnt != 0 ) sepOff( os );					// no seperator between chunks
+		if ( cnt != 0 ) nosep( os );					// no seperator between chunks
 		f.wd = wd;										// reset f.wd for next chunk
 		f.flags.sign = false;							// no leading +/- sign
@@ -773,5 +773,6 @@
 		} // if
 
-		if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
+		if ( f.val[0] != '\0' &&						// null string => no leading separator
+			 sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
 
 		#define SFMTNP "% * "
@@ -795,4 +796,5 @@
 			fmt( os, &fmtstr[star], f.wd, f.pc, f.val );
 		} // if
+		if ( f.val[0] == '\0' ) { nosep( os ); }		// null string => no trailing separator
 		return os;
 	} // ?|?
Index: libcfa/src/iostream.hfa
===================================================================
--- libcfa/src/iostream.hfa	(revision c9019ce9baa8a8b2d2de47644af67760b22dca5d)
+++ libcfa/src/iostream.hfa	(revision 599dc6a91726849d6977f9d3d2db97dea2de87de)
@@ -10,6 +10,6 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Jun 15 22:34:31 2023
-// Update Count     : 411
+// Last Modified On : Thu Jun 29 11:07:25 2023
+// Update Count     : 427
 //
 
@@ -36,11 +36,11 @@
 	void setPrt$( ostype &, bool );						// set fmt called in output cascade
 	// public
-	void sepOn( ostype & );								// turn separator state on
-	void sepOff( ostype & );							// turn separator state off
-	bool sepDisable( ostype & );						// set default state to off, and return previous state
-	bool sepEnable( ostype & );							// set default state to on, and return previous state
 	void nlOn( ostype & );								// turn auto-newline state on
 	void nlOff( ostype & );								// turn auto-newline state off
 
+	void sep( ostype & );								// turn separator state on
+	void nosep( ostype & );								// turn separator state off
+	bool sepOn( ostype & );								// set default state to on, and return previous state
+	bool sepOff( ostype & );							// set default state to off, and return previous state
 	const char * sepGet( ostype & );					// get separator string
 	void sepSet( ostype &, const char [] );				// set separator to string (15 character maximum)
@@ -135,14 +135,16 @@
 	ostype & ?|?( ostype &, ostype & (*)( ostype & ) );
 	void ?|?( ostype &, ostype & (*)( ostype & ) );
+
 	ostype & nl( ostype & );
 	ostype & nonl( ostype & );
+	ostype & nlOn( ostype & );
+	ostype & nlOff( ostype & );
+
+	ostype & sepVal( ostype & );
+	ostype & sepTupleVal( ostype & );
 	ostype & sep( ostype & );
-	ostype & sepTuple( ostype & );
+	ostype & nosep( ostype & );
 	ostype & sepOn( ostype & );
 	ostype & sepOff( ostype & );
-	ostype & sepDisable( ostype & );
-	ostype & sepEnable( ostype & );
-	ostype & nlOn( ostype & );
-	ostype & nlOff( ostype & );
 } // distribution
 
Index: libcfa/src/parseconfig.cfa
===================================================================
--- libcfa/src/parseconfig.cfa	(revision c9019ce9baa8a8b2d2de47644af67760b22dca5d)
+++ libcfa/src/parseconfig.cfa	(revision 599dc6a91726849d6977f9d3d2db97dea2de87de)
@@ -29,5 +29,5 @@
 // TODO: use string interface when it's ready (and implement exception msg protocol)
 [ void ] msg( * Missing_Config_Entries ex ) {
-	serr | "The config file is missing " | ex->num_missing | "entr" | sepOff | (ex->num_missing == 1 ? "y." : "ies.");
+	serr | "The config file is missing " | ex->num_missing | "entr" | nosep | (ex->num_missing == 1 ? "y." : "ies.");
 } // msg
 
Index: libcfa/src/strstream.cfa
===================================================================
--- libcfa/src/strstream.cfa	(revision c9019ce9baa8a8b2d2de47644af67760b22dca5d)
+++ libcfa/src/strstream.cfa	(revision 599dc6a91726849d6977f9d3d2db97dea2de87de)
@@ -10,6 +10,6 @@
 // Created On       : Thu Apr 22 22:24:35 2021
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Oct 10 16:13:20 2021
-// Update Count     : 101
+// Last Modified On : Thu Jun 29 10:59:00 2023
+// Update Count     : 105
 //
 
@@ -32,4 +32,7 @@
 
 // private
+inline bool getNL$( ostrstream & os ) { return os.sawNL$; }
+inline void setNL$( ostrstream & os, bool state ) { os.sawNL$ = state; }
+inline bool getANL$( ostrstream & os ) { return os.nlOnOff$; }
 inline bool sepPrt$( ostrstream & os ) { setNL$( os, false ); return os.sepOnOff$; }
 inline void sepReset$( ostrstream & os ) { os.sepOnOff$ = os.sepDefault$; }
@@ -37,11 +40,11 @@
 inline const char * sepGetCur$( ostrstream & os ) { return os.sepCur$; }
 inline void sepSetCur$( ostrstream & os, const char sepCur[] ) { os.sepCur$ = sepCur; }
-inline bool getNL$( ostrstream & os ) { return os.sawNL$; }
-inline void setNL$( ostrstream & os, bool state ) { os.sawNL$ = state; }
-inline bool getANL$( ostrstream & os ) { return os.nlOnOff$; }
 inline bool getPrt$( ostrstream & os ) { return os.prt$; }
 inline void setPrt$( ostrstream & os, bool state ) { os.prt$ = state; }
 
 // public
+void nlOn( ostrstream & os ) { os.nlOnOff$ = true; }
+void nlOff( ostrstream & os ) { os.nlOnOff$ = false; }
+
 void ?{}( ostrstream & os, char buf[], size_t size ) {
 	os.buf$ = buf;
@@ -58,23 +61,20 @@
 } // ?{}
 
-void sepOn( ostrstream & os ) { os.sepOnOff$ = ! getNL$( os ); }
-void sepOff( ostrstream & os ) { os.sepOnOff$ = false; }
+void sep( ostrstream & os ) { os.sepOnOff$ = ! getNL$( os ); }
+void nosep( ostrstream & os ) { os.sepOnOff$ = false; }
 
-bool sepDisable( ostrstream & os ) {
+bool sepOn( ostrstream & os ) {
+	bool temp = os.sepDefault$;
+	os.sepDefault$ = true;
+	if ( os.sepOnOff$ ) sepReset$( os );				// start of line ?
+	return temp;
+} // sepOn
+
+bool sepOff( ostrstream & os ) {
 	bool temp = os.sepDefault$;
 	os.sepDefault$ = false;
 	sepReset$( os );
 	return temp;
-} // sepDisable
-
-bool sepEnable( ostrstream & os ) {
-	bool temp = os.sepDefault$;
-	os.sepDefault$ = true;
-	if ( os.sepOnOff$ ) sepReset$( os );				// start of line ?
-	return temp;
-} // sepEnable
-
-void nlOn( ostrstream & os ) { os.nlOnOff$ = true; }
-void nlOff( ostrstream & os ) { os.nlOnOff$ = false; }
+} // sepOff
 
 const char * sepGet( ostrstream & os ) { return os.separator$; }
Index: libcfa/src/strstream.hfa
===================================================================
--- libcfa/src/strstream.hfa	(revision c9019ce9baa8a8b2d2de47644af67760b22dca5d)
+++ libcfa/src/strstream.hfa	(revision 599dc6a91726849d6977f9d3d2db97dea2de87de)
@@ -10,6 +10,6 @@
 // Created On       : Thu Apr 22 22:20:59 2021
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Oct 10 10:14:22 2021
-// Update Count     : 47
+// Last Modified On : Thu Jun 29 10:58:58 2023
+// Update Count     : 51
 // 
 
@@ -53,11 +53,11 @@
 
 // public
-void sepOn( ostrstream & );
-void sepOff( ostrstream & );
-bool sepDisable( ostrstream & );
-bool sepEnable( ostrstream & );
 void nlOn( ostrstream & );
 void nlOff( ostrstream & );
 
+void sep( ostrstream & );
+void nosep( ostrstream & );
+bool sepOn( ostrstream & );
+bool sepOff( ostrstream & );
 const char * sepGet( ostrstream & );
 void sepSet( ostrstream &, const char [] );
Index: src/AST/LinkageSpec.cpp
===================================================================
--- src/AST/LinkageSpec.cpp	(revision c9019ce9baa8a8b2d2de47644af67760b22dca5d)
+++ src/AST/LinkageSpec.cpp	(revision 599dc6a91726849d6977f9d3d2db97dea2de87de)
@@ -27,31 +27,30 @@
 namespace Linkage {
 
-	Spec update( CodeLocation loc, Spec spec, const std::string * cmd ) {
-		assert( cmd );
-		std::unique_ptr<const std::string> guard( cmd ); // allocated by lexer
-		if ( *cmd == "\"Cforall\"" ) {
-			spec.is_mangled = true;
-			return spec;
-		} else if ( *cmd == "\"C\"" ) {
-			spec.is_mangled = false;
-			return spec;
-		} else {
-			SemanticError( loc, "Invalid linkage specifier " + *cmd );
-		}
+Spec update( CodeLocation loc, Spec spec, const std::string * cmd ) {
+	assert( cmd );
+	std::unique_ptr<const std::string> guard( cmd ); // allocated by lexer
+	if ( *cmd == "\"Cforall\"" ) {
+		spec.is_mangled = true;
+		return spec;
+	} else if ( *cmd == "\"C\"" ) {
+		spec.is_mangled = false;
+		return spec;
+	} else {
+		SemanticError( loc, "Invalid linkage specifier " + *cmd );
 	}
+}
 
-
-	std::string name( Spec spec ) {
-		switch ( spec.val ) {
-		case Intrinsic.val:  return "intrinsic";
-		case C.val:          return "C";
-		case Cforall.val:    return "Cforall";
-		case AutoGen.val:    return "autogenerated cfa";
-		case Compiler.val:   return "compiler built-in";
-		case BuiltinCFA.val: return "cfa built-in";
-		case BuiltinC.val:   return "c built-in";
-		default:         return "<unnamed linkage spec>";
-		}
+std::string name( Spec spec ) {
+	switch ( spec.val ) {
+	case Intrinsic.val:  return "intrinsic";
+	case C.val:          return "C";
+	case Cforall.val:    return "Cforall";
+	case AutoGen.val:    return "autogenerated cfa";
+	case Compiler.val:   return "compiler built-in";
+	case BuiltinCFA.val: return "cfa built-in";
+	case BuiltinC.val:   return "c built-in";
+	default:             return "<unnamed linkage spec>";
 	}
+}
 
 }
Index: src/AST/LinkageSpec.hpp
===================================================================
--- src/AST/LinkageSpec.hpp	(revision c9019ce9baa8a8b2d2de47644af67760b22dca5d)
+++ src/AST/LinkageSpec.hpp	(revision 599dc6a91726849d6977f9d3d2db97dea2de87de)
@@ -25,54 +25,55 @@
 namespace Linkage {
 
-	/// Bitflags for linkage specifiers
-	enum {
-		Mangle       = 1 << 0,
-		Generate     = 1 << 1,
-		Overrideable = 1 << 2,
-		Builtin      = 1 << 3,
-		GccBuiltin   = 1 << 4
+/// Bitflags for linkage specifiers
+enum {
+	Mangle       = 1 << 0,
+	Generate     = 1 << 1,
+	Overrideable = 1 << 2,
+	Builtin      = 1 << 3,
+	GccBuiltin   = 1 << 4
+};
+
+/// Bitflag type for storage classes
+struct spec_flags {
+	union {
+		unsigned int val;
+		struct {
+			bool is_mangled      : 1;
+			bool is_generatable  : 1;
+			bool is_overrideable : 1;
+			bool is_builtin      : 1;
+			bool is_gcc_builtin  : 1;
+		};
 	};
 
-	/// Bitflag type for storage classes
-	struct spec_flags {
-		union {
-			unsigned int val;
-			struct {
-				bool is_mangled      : 1;
-				bool is_generatable  : 1;
-				bool is_overrideable : 1;
-				bool is_builtin      : 1;
-				bool is_gcc_builtin  : 1;
-			};
-		};
+	constexpr spec_flags( unsigned int val ) : val(val) {}
+};
 
-		constexpr spec_flags( unsigned int val ) : val(val) {}
-	};
+using Spec = bitfield<spec_flags>;
 
-	using Spec = bitfield<spec_flags>;
+/// If `cmd` = "C" returns `spec` with `is_mangled = false`.
+/// If `cmd` = "Cforall" returns `spec` with `is_mangled = true`.
+Spec update( CodeLocation loc, Spec spec, const std::string * cmd );
 
-	/// If `cmd` = "C" returns `spec` with `is_mangled = false`.
-	/// If `cmd` = "Cforall" returns `spec` with `is_mangled = true`.
-	Spec update( CodeLocation loc, Spec spec, const std::string * cmd );
+/// A human-readable name for this spec
+std::string name( Spec spec );
 
-	/// A human-readable name for this spec
-	std::string name( Spec spec );
+// Pre-defined flag combinations
 
-	// Pre-defined flag combinations
+/// C built-in defined in prelude
+constexpr Spec Intrinsic  = { Mangle | Generate | Overrideable | Builtin };
+/// Ordinary Cforall
+constexpr Spec Cforall    = { Mangle | Generate };
+/// C code: not overloadable, not mangled
+constexpr Spec C          = { Generate };
+/// Built by translator (e.g. struct assignment)
+constexpr Spec AutoGen    = { Mangle | Generate | Overrideable };
+/// GCC internal
+constexpr Spec Compiler   = { Mangle | Builtin | GccBuiltin };
+/// Mangled builtins
+constexpr Spec BuiltinCFA = { Mangle | Generate | Builtin };
+/// Non-mangled builtins
+constexpr Spec BuiltinC   = { Generate | Builtin };
 
-	/// C built-in defined in prelude
-	constexpr Spec Intrinsic  = { Mangle | Generate | Overrideable | Builtin };
-	/// Ordinary Cforall
-	constexpr Spec Cforall    = { Mangle | Generate };
-	/// C code: not overloadable, not mangled
-	constexpr Spec C          = { Generate };
-	/// Built by translator (e.g. struct assignment)
-	constexpr Spec AutoGen    = { Mangle | Generate | Overrideable };
-	/// GCC internal
-	constexpr Spec Compiler   = { Mangle | Builtin | GccBuiltin };
-	/// Mangled builtins
-	constexpr Spec BuiltinCFA = { Mangle | Generate | Builtin };
-	/// Non-mangled builtins
-	constexpr Spec BuiltinC   = { Generate | Builtin };
 }
 
Index: tests/PRNG.cfa
===================================================================
--- tests/PRNG.cfa	(revision c9019ce9baa8a8b2d2de47644af67760b22dca5d)
+++ tests/PRNG.cfa	(revision 599dc6a91726849d6977f9d3d2db97dea2de87de)
@@ -10,6 +10,6 @@
 // Created On       : Wed Dec 29 09:38:12 2021
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu May 25 15:39:52 2023
-// Update Count     : 422
+// Last Modified On : Thu Jun 29 10:18:35 2023
+// Update Count     : 424
 // 
 
@@ -144,5 +144,5 @@
 	srand( rseed );
 
-	sout | sepDisable;
+	sout | sepOff;
 	sout | nl | wd(26, "rand()" ) | wd(12, "rand(5)") | wd(12, "rand(0,5)" );
 	for ( 20 ) {
@@ -151,5 +151,5 @@
 		sout | wd(12, rand() % (5 - 0 + 1) + 0);
 	} // for
-	sout | sepEnable;
+	sout | sepOn;
 	sout | "seed" | rseed;
 
@@ -185,5 +185,5 @@
 	if ( seed != 0 ) set_seed( prng, seed );
 
-	sout | sepDisable;
+	sout | sepOff;
 	sout | nl | wd(26, "PRNG()" ) | wd(12, "PRNG(5)") | wd(12, "PRNG(0,5)" );
 	for ( 20 ) {
@@ -192,5 +192,5 @@
 		sout | wd(12, prng( prng, 0, 5 ));
 	} // for
-	sout | sepEnable;
+	sout | sepOn;
 	sout | "seed" | get_seed( prng );
 
@@ -220,5 +220,5 @@
 	if ( seed != 0 ) set_seed( seed );
 
-	sout | sepDisable;
+	sout | sepOff;
 	sout | nl | wd(26, "prng()" ) | wd(12, "prng(5)") | wd(12, "prng(0,5)" );
 	for ( 20 ) {
@@ -227,5 +227,5 @@
 		sout | wd(12, prng( 0, 5 ));
 	} // for
-	sout | sepEnable;
+	sout | sepOn;
 	sout | "seed" | get_seed( prng );
 
@@ -256,5 +256,5 @@
 	thread$ & th = *active_thread();
 
-	sout | sepDisable;
+	sout | sepOff;
 	sout | nl | wd(26, "prng(t)" ) | wd(12, "prng(t,5)") | wd(12, "prng(t,0,5)" );
 	for ( 20 ) {
@@ -263,5 +263,5 @@
 		sout | wd(12, prng( th, 0, 5 ));
 	} // for
-	sout | sepEnable;
+	sout | sepOn;
 	sout | "seed" | get_seed( prng );
 
Index: tests/designations.cfa
===================================================================
--- tests/designations.cfa	(revision c9019ce9baa8a8b2d2de47644af67760b22dca5d)
+++ tests/designations.cfa	(revision 599dc6a91726849d6977f9d3d2db97dea2de87de)
@@ -10,7 +10,9 @@
 // Created On       : Thu Jun 29 15:26:36 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Mar 28 22:41:55 2022
-// Update Count     : 15
-//
+// Last Modified On : Thu Jun 29 11:31:21 2023
+// Update Count     : 28
+//
+
+#include <fstream.hfa>
 
 // Note: this test case has been crafted so that it compiles with both cfa and with gcc without any modifications.
@@ -21,5 +23,4 @@
 #define AT @
 #else
-int printf( const char *, ...);
 #define _ =
 #define AT
@@ -28,7 +29,5 @@
 const int indentAmt = 2;
 void indent( int level ) {
-	for ( int i = 0; i < level; ++i ) {
-		printf( " " );
-	}
+	sout | wd( level, "" ) | nonl;
 }
 
@@ -40,5 +39,5 @@
 void printA( struct A a, int level ) {
 	indent( level );
-	printf( "(A){ %d %d %p }\n", a.x, a.y, a.ptr );
+	sout | "(A){ " | a.x | a.y | a.ptr | " }";
 }
 
@@ -49,9 +48,9 @@
 void printB( struct B b, int level ) {
 	indent( level );
-	printf( "(B){\n" );
+	sout | "(B){";
 	printA( b.a0, level+indentAmt );
 	printA( b.a1, level+indentAmt );
 	indent( level );
-	printf( "}\n" );
+	sout | "}";
 }
 
@@ -63,10 +62,10 @@
 void printC( struct C c, int level ) {
 	indent( level );
-	printf( "(C){\n" );
+	sout | "(C){";
 	indent( level+indentAmt );
-	printf( "(int[]{ %d %d %d }\n", c.arr[0], c.arr[1], c.arr[2]);
+	sout | "(int[]{ " | c.arr[0] | c.arr[1] | c.arr[2] | " }";
 	printB( c.b, level+indentAmt );
 	indent( level );
-	printf( "}\n" );
+	sout | "}";
 }
 
@@ -79,5 +78,5 @@
 void printD( struct D d, int level ) {
 	indent( level);
-	printf( "(D ){ %d }\n", d.x );
+	sout | "(D){ " | d.x | "}";
 }
 
@@ -92,12 +91,12 @@
 
 struct Fred {
-    double i[3];
-    int j;
-    struct Mary {
-	struct Jane {
-	    double j;
-	} j;
-	double i;
-    } m;
+	double i[3];
+	int j;
+	struct Mary {
+		struct Jane {
+			double j;
+		} j;
+		double i;
+	} m;
 };
 struct Fred s1 AT= { .m.j _ 3 };
@@ -129,9 +128,9 @@
 #endif
 
-	printf( "=====A=====\n" );
+	sout | "=====A=====";
 	printA( y0, 0 );
 	printA( y1, 0 );
 	printA( y2, 0 );
-	printf( "=====A=====\n\n" );
+	sout | "=====A=====" | nl | nl;
 
 	// initialize only first element (z0.a.x), leaving everything else default-initialized (zero), no nested curly-braces
@@ -172,5 +171,5 @@
 	};
 
-	printf( "=====B=====\n" );
+	sout | "=====B=====";
 	printB( z0, 0 );
 	printB( z1, 0 );
@@ -179,5 +178,5 @@
 	printB( z5, 0 );
 	printB( z6, 0 );
-	printf( "=====B=====\n\n" );
+	sout | "=====B=====" | nl | nl;
 
 	// TODO: what about extra things in a nested init? are empty structs skipped??
@@ -190,7 +189,7 @@
 	};
 
-	printf( "=====C=====\n" );
+	sout | "=====C=====";
 	printC( c1, 0 );
-	printf( "=====C=====\n\n" );
+	sout | "=====C=====" | nl | nl;
 
 #if ERROR
@@ -246,10 +245,10 @@
 	};
 
-	printf( "=====E=====\n" );
+	sout | "=====E=====";
 	printA( e0.a, 0 );
 	printA( e1.a, 0 );
 	printA( e2.a, 0 );
 	printB( e3.b, 0 );
-	printf( "=====E=====\n\n" );
+	sout | "=====E=====" | nl | nl;
 
 	// special case of initialization: char[] can be initialized with a string literal
Index: tests/io/.expect/io.txt
===================================================================
--- tests/io/.expect/io.txt	(revision c9019ce9baa8a8b2d2de47644af67760b22dca5d)
+++ tests/io/.expect/io.txt	(revision 599dc6a91726849d6977f9d3d2db97dea2de87de)
@@ -61,5 +61,5 @@
 1, 2, 3 4, 5, 6
 
-check sepOn/sepOff
+check sep/nosep
 1 2 3
 12 3
Index: tests/io/io.cfa
===================================================================
--- tests/io/io.cfa	(revision c9019ce9baa8a8b2d2de47644af67760b22dca5d)
+++ tests/io/io.cfa	(revision 599dc6a91726849d6977f9d3d2db97dea2de87de)
@@ -10,6 +10,6 @@
 // Created On       : Wed Mar  2 16:56:02 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Feb 21 10:56:33 2021
-// Update Count     : 121
+// Last Modified On : Thu Jun 29 10:19:31 2023
+// Update Count     : 126
 //
 
@@ -122,16 +122,16 @@
 	sout | "toggle separator";
 	sout | f | "" | d | "" | ld;						// floating point without separator
-	sout | sepDisable | fc | dc | ldc;					// complex without separator
-	sout | fc | sepOn | dc | ldc;						// local separator add
-	sout | sepEnable | fc | dc | ldc;					// complex with separator
-	sout | fc | sepOff | dc | ldc;						// local separator removal
-	sout | s1 | sepOff | s2;							// local separator removal
+	sout | sepOff | fc | dc | ldc;						// complex without separator
+	sout | fc | sep | dc | ldc;							// local separator add
+	sout | sepOn | fc | dc | ldc;						// complex with separator
+	sout | fc | nosep | dc | ldc;						// local separator removal
+	sout | s1 | nosep | s2;								// local separator removal
 	sout | s1 | "" | s2;								// local separator removal
 	sout | nl;
 
 	sout | "change separator";
-	sout | "from \"" | sep | "\"" | nonl;
+	sout | "from \"" | sepVal | "\"" | nonl;
 	sepSet( sout, ", $" );								// change separator, maximum of 15 characters
-	sout | " to \"" | sep | "\"";
+	sout | " to \"" | sepVal | "\"";
 	sout | f | d | ld;
 	sout | fc | dc | ldc;
@@ -139,7 +139,7 @@
 	sout | t1 | t2;										// print tuple
 	sout | nl;
-	sout | "from \"" | sep | "\" " | nonl;
+	sout | "from \"" | sepVal | "\" " | nonl;
 	sepSet( sout, " " );								// restore separator
-	sout | "to \"" | sep | "\"";
+	sout | "to \"" | sepVal | "\"";
 	sout | f | d | ld;
 	sout | fc | dc | ldc;
@@ -148,19 +148,19 @@
 	sout | nl;
 
-	sout | "check sepOn/sepOff";
-	sout | sepOn | 1 | 2 | 3 | sepOn;					// no separator at start/end of line
-	sout | 1 | sepOff | 2 | 3;							// locally turn off implicit separator
-	sout | sepOn | sepOn | 1 | 2 | 3 | sepOn | sepOff | sepOn | '\n' | nonl; // no separator at start/end of line
-	sout | 1 | 2 | 3 | "\n\n" | sepOn | nonl;			// no separator at start of next line
+	sout | "check sep/nosep";
+	sout | sep | 1 | 2 | 3 | sep;						// no separator at start/end of line
+	sout | 1 | nosep | 2 | 3;							// locally turn off implicit separator
+	sout | sep | sep | 1 | 2 | 3 | sep | nosep | sep | '\n' | nonl; // no separator at start/end of line
+	sout | 1 | 2 | 3 | "\n\n" | sep | nonl;				// no separator at start of next line
 	sout | 1 | 2 | 3;
 	sout | nl;
 
 	sout | "check enable/disable";
-	sout | sepDisable | 1 | 2 | 3;						// globally turn off implicit separation
-	sout | 1 | sepOn | 2 | 3;							// locally turn on implicit separator
-	sout | sepEnable | 1 | 2 | 3 | sepDisable;			// globally turn on/off implicit separation
-	sout | 1 | 2 | 3 | sepEnable;						// globally turn on implicit separation
-	sout | 1 | 2 | 3 | sepOn | sepDisable;				// ignore seperate at end of line
-	sout | 1 | 2 | 3 | sepOn | sepEnable;				// separator at end of line
+	sout | sepOff | 1 | 2 | 3;							// globally turn off implicit separation
+	sout | 1 | sep | 2 | 3;								// locally turn on implicit separator
+	sout | sepOn | 1 | 2 | 3 | sepOff;					// globally turn on/off implicit separation
+	sout | 1 | 2 | 3 | sepOn;							// globally turn on implicit separation
+	sout | 1 | 2 | 3 | sep | sepOff;					// ignore seperate at end of line
+	sout | 1 | 2 | 3 | sep | sepOn;						// separator at end of line
 	sout | 1 | 2 | 3;
 	sout | nl;
@@ -169,7 +169,7 @@
 
 	sepSetTuple( sout, " " );							// set tuple separator from ", " to " "
-	sout | t1 | t2 | " \"" | sep | "\"";
+	sout | t1 | t2 | " \"" | sepVal | "\"";
 	sepSetTuple( sout, ", " );							// reset tuple separator to ", "
-	sout | t1 | t2 | " \"" | sep | "\"";
+	sout | t1 | t2 | " \"" | sepVal | "\"";
 	sout | t1 | t2;										// print tuple
 	sout | nl;
@@ -180,5 +180,5 @@
 	sepSetTuple( sout, " " );
 	sout | t3;
-	sout | sepOn | t3 | sepDisable | t3 | sepEnable | t3;
+	sout | sep | t3 | sepOff | t3 | sepOn | t3;
 	sepSet( sout, "^" );
 	sepSetTuple( sout, "-" );
Index: tests/raii/dtor-early-exit.cfa
===================================================================
--- tests/raii/dtor-early-exit.cfa	(revision c9019ce9baa8a8b2d2de47644af67760b22dca5d)
+++ tests/raii/dtor-early-exit.cfa	(revision 599dc6a91726849d6977f9d3d2db97dea2de87de)
@@ -10,6 +10,6 @@
 // Created On       : Wed Aug 17 08:26:25 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Dec 21 08:45:19 2018
-// Update Count     : 10
+// Last Modified On : Thu Jun 29 11:15:56 2023
+// Update Count     : 11
 //
 
@@ -244,5 +244,5 @@
 
 int main() {
-	sepDisable(sout);
+	sepOff(sout);
 	for (int i = 0; i < 4; i++) {
 		f(i);