Changeset a4da45e for doc

Timestamp:

Feb 26, 2024, 3:53:42 AM (22 months ago)

Author:

JiadaL <j82liang@…>

Branches:

master

Children:

3f9a8d0

Parents:

0522ebe (diff), 022bce0 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Resolve conflict

Location:

doc

Files:

• LaTeXmacros/common.sty (modified) (6 diffs)
• LaTeXmacros/common.tex (modified) (6 diffs)
• LaTeXmacros/lstlang.sty (modified) (2 diffs)
• bibliography/pl.bib (modified) (2 diffs)
• proposals/enum.tex (modified) (11 diffs)
• theses/jiada_liang_MMath/CFAenum.tex (added)
• theses/jiada_liang_MMath/background.tex (modified) (1 diff)
• theses/jiada_liang_MMath/content1.tex (deleted)
• theses/jiada_liang_MMath/content2.tex (deleted)
• theses/jiada_liang_MMath/implementation.tex (added)
• theses/jiada_liang_MMath/intro.tex (modified) (1 diff)
• theses/jiada_liang_MMath/relatedwork.tex (added)
• theses/jiada_liang_MMath/uw-ethesis-frontpgs.tex (modified) (1 diff)
• theses/jiada_liang_MMath/uw-ethesis.tex (modified) (2 diffs)
• user/user.tex (modified) (12 diffs)

doc/LaTeXmacros/common.sty

@@ -11 +11 @@
 %% Created On       : Sat Apr  9 10:06:17 2016
 %% Last Modified By : Peter A. Buhr
-%% Last Modified On : Sun Jan 21 13:17:48 2024
-%% Update Count     : 633
+%% Last Modified On : Sun Feb 25 17:37:46 2024
+%% Update Count     : 640
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
@@ -40 +40 @@
 \newcommand{\CFA}{\protect\CFAIcon\xspace}                              % CFA symbolic name
 \newcommand{\CFL}{\textrm{Cforall}\xspace}                              % Cforall non-icon name
-\newcommand{\Celeven}{\textrm{C11}\xspace}                              % C11 symbolic name
+\newcommand{\Celeven}{\textrm{C1\!1}\xspace}                    % C11 symbolic name
+
 \newcommand{\CCIcon}{\textrm{C}\kern-.1em\hbox{+\kern-.25em+}} % C++ icon
-\newcommand{\CC}[1][]{\protect\CCIcon{#1}\xspace}               % C++ symbolic name
-\newcommand{\Cpp}[1][]{\CC{#1}}                                                 % C++ synonym
 % numbers disallowed in latex variables names => use number names
-\newcommand{\CCeleven}{\protect\CCIcon{11}\xspace}              % C++11 symbolic name
+\newcommand{\CCeleven}{\protect\CCIcon{1\!1}\xspace}    % C++11 symbolic name
 \newcommand{\CCfourteen}{\protect\CCIcon{14}\xspace}    % C++14 symbolic name
 \newcommand{\CCseventeen}{\protect\CCIcon{17}\xspace}   % C++17 symbolic name
 \newcommand{\CCtwenty}{\protect\CCIcon{20}\xspace}              % C++20 symbolic name
+\newcommand{\CC}[1][]{\protect\CCIcon{#1}\xspace}               % C++ symbolic name
+\newcommand{\Cpp}[1][]{\CC{#1}}                                                 % C++ synonym
+
 \newcommand{\Csharp}{C\raisebox{-0.7ex}{\relsize{2}$^\sharp$}\xspace} % C# symbolic name
 
@@ -293 +295 @@
 xleftmargin=\parindentlnth,                             % indent code to paragraph indentation
 extendedchars=true,                                             % allow ASCII characters in the range 128-255
-escapechar=§,                                                   % LaTeX escape in CFA code §...§ (section symbol), emacs: C-q M-'
 mathescape=false,                                               % disable LaTeX math escape in CFA code $...$
 keepspaces=true,                                                %
@@ -304 +305 @@
 literate=
 %  {-}{\makebox[1ex][c]{\raisebox{0.4ex}{\rule{0.75ex}{0.1ex}}}}1
-  {-}{\raisebox{-1pt}{\texttt{-}}}1
+  {-}{\raisebox{-1pt}{\ttfamily-}}1
   {^}{\raisebox{0.6ex}{$\scriptstyle\land\,$}}1
   {~}{\raisebox{0.3ex}{$\scriptstyle\sim\,$}}1
+  {'}{\ttfamily'\!}1
   {`}{\ttfamily\upshape\hspace*{-0.3ex}`}1
   {<-}{$\leftarrow$}2
@@ -318 +320 @@
 \lstset{
 language=CFA,
-%moredelim=**[is][\color{red}]{@}{@},   % red highlighting @...@
+escapechar=§,                                                   % LaTeX escape in CFA code §...§ (section symbol), emacs: C-q M-'
 moredelim=**[is][\color{red}]{®}{®},    % red highlighting ®...® (registered trademark symbol) emacs: C-q M-.
 %moredelim=**[is][\color{blue}]{ß}{ß},  % blue highlighting ß...ß (sharp s symbol) emacs: C-q M-_
@@ -328 +330 @@
 % inline code ©...© (copyright symbol) emacs: C-q M-)
 \lstMakeShortInline©                                    % single-character for \lstinline
+
 \else% regular ASCI characters
+
 \lstnewenvironment{cfa}[1][]{% necessary
 \lstset{
 language=CFA,
 escapechar=\$,                                                  % LaTeX escape in CFA code
-mathescape=false,                                               % LaTeX math escape in CFA code $...$
 moredelim=**[is][\color{red}]{@}{@},    % red highlighting @...@
 }% lstset

doc/LaTeXmacros/common.tex

@@ -11 +11 @@
 %% Created On       : Sat Apr  9 10:06:17 2016
 %% Last Modified By : Peter A. Buhr
-%% Last Modified On : Wed Jan 24 08:43:57 2024
-%% Update Count     : 593
+%% Last Modified On : Sun Feb 25 18:11:56 2024
+%% Update Count     : 614
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
@@ -40 +40 @@
 \newcommand{\CFA}{\protect\CFAIcon\xspace}                              % CFA symbolic name
 \newcommand{\CFL}{\textrm{Cforall}\xspace}                              % Cforall non-icon name
-\newcommand{\Celeven}{\textrm{C11}\xspace}                              % C11 symbolic name
+\newcommand{\Celeven}{\textrm{C1\!1}\xspace}                    % C11 symbolic name
+
 \newcommand{\CCIcon}{\textrm{C}\kern-.1em\hbox{+\kern-.25em+}} % C++ icon
-\newcommand{\CC}[1][]{\protect\CCIcon{#1}\xspace}               % C++ symbolic name
-\newcommand{\Cpp}[1][]{\CC{#1}}                                                 % C++ synonym
 % numbers disallowed in latex variables names => use number names
-\newcommand{\CCeleven}{\protect\CCIcon{11}\xspace}              % C++11 symbolic name
+\newcommand{\CCeleven}{\protect\CCIcon{1\!1}\xspace}    % C++11 symbolic name
 \newcommand{\CCfourteen}{\protect\CCIcon{14}\xspace}    % C++14 symbolic name
 \newcommand{\CCseventeen}{\protect\CCIcon{17}\xspace}   % C++17 symbolic name
 \newcommand{\CCtwenty}{\protect\CCIcon{20}\xspace}              % C++20 symbolic name
+\newcommand{\CC}[1][]{\protect\CCIcon{#1}\xspace}               % C++ symbolic name
+\newcommand{\Cpp}[1][]{\CC{#1}}                                                 % C++ synonym
+
 \newcommand{\Csharp}{C\raisebox{-0.7ex}{\relsize{2}$^\sharp$}\xspace} % C# symbolic name
 
@@ -297 +299 @@
 xleftmargin=\parindentlnth,                             % indent code to paragraph indentation
 extendedchars=true,                                             % allow ASCII characters in the range 128-255
-escapechar=§,                                                   % LaTeX escape in CFA code §...§ (section symbol), emacs: C-q M-'
 mathescape=false,                                               % disable LaTeX math escape in CFA code $...$
 keepspaces=true,                                                %
@@ -308 +309 @@
 literate=
 %  {-}{\makebox[1ex][c]{\raisebox{0.4ex}{\rule{0.75ex}{0.1ex}}}}1
-  {-}{\raisebox{-1pt}{\texttt{-}}}1
+  {-}{\raisebox{-1pt}{\ttfamily-}}1
   {^}{\raisebox{0.6ex}{$\scriptstyle\land\,$}}1
   {~}{\raisebox{0.3ex}{$\scriptstyle\sim\,$}}1
+  {'}{\ttfamily'\!}1
   {`}{\ttfamily\upshape\hspace*{-0.3ex}`}1
   {<-}{$\leftarrow$}2
@@ -322 +324 @@
 \lstset{
 language=CFA,
-%moredelim=**[is][\color{red}]{@}{@},   % red highlighting @...@
+escapechar=§,                                                   % LaTeX escape in CFA code §...§ (section symbol), emacs: C-q M-'
 moredelim=**[is][\color{red}]{®}{®},    % red highlighting ®...® (registered trademark symbol) emacs: C-q M-.
 %moredelim=**[is][\color{blue}]{ß}{ß},  % blue highlighting ß...ß (sharp s symbol) emacs: C-q M-_
@@ -332 +334 @@
 % inline code ©...© (copyright symbol) emacs: C-q M-)
 \lstMakeShortInline©                                    % single-character for \lstinline
+
 \else% regular ASCI characters
+
 \lstnewenvironment{cfa}[1][]{% necessary
 \lstset{
 language=CFA,
 escapechar=\$,                                                  % LaTeX escape in CFA code
-mathescape=false,                                               % LaTeX math escape in CFA code $...$
 moredelim=**[is][\color{red}]{@}{@},    % red highlighting @...@
 }% lstset

doc/LaTeXmacros/lstlang.sty

@@ -8 +8 @@
 %% Created On       : Sat May 13 16:34:42 2017
 %% Last Modified By : Peter A. Buhr
-%% Last Modified On : Thu Sep 21 08:40:05 2023
-%% Update Count     : 31
+%% Last Modified On : Fri Feb 16 07:59:29 2024
+%% Update Count     : 37
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
@@ -125 +125 @@
 }
 
-% C++ programming language
-\lstdefinelanguage{C++}[ANSI]{C++}{
-        morekeywords={nullptr,}
-}
-
 % uC++ programming language, based on ANSI C++
-\lstdefinelanguage{uC++}[ANSI]{C++}{
+\lstdefinelanguage{uC++}[GNU]{C++}{
         morekeywords={
                 _Accept, _AcceptReturn, _AcceptWait, _Actor, _At, _Catch, _CatchResume, _CorActor, _Cormonitor, _Coroutine,

doc/bibliography/pl.bib

@@ -3742 +3742 @@
     month       = jul, year = 1987,
     volume      = 4, number = 4, pages = {9-16}
+}
+
+@manual{FreePascal,
+    keywords    = {Pascal, object oriented},
+    contributer = {pabuhr@plg},
+    author      = {Micha\"{e}l Van Canneyt},
+    title       = {{F}ree {P}ascal Reference Guide, version 3.2.2},
+    month       = may,
+    year        = 2021,
+    note        = {\url{http://downloads.freepascal.org/fpc/docs-pdf/ref.pdf}},
 }
 
@@ -8243 +8253 @@
 }
 
+@manual{Swift,
+    keywords    = {Swift programming language},
+    contributer = {pabuhr@plg},
+    key         = {Swift},
+    author      = {Chris Lattner and Doug Gregor and John McCall and Ted Kremenek and Joe Groff and Apple Inc.},
+    title       = {The Swift Programming Language},
+    edition     = {5.9.2},
+    organization= {Apple Inc.},
+    address     = {Cupertino, CA, USA},
+    year        = 2024,
+    note        = {\url{https://docs.swift.org/swift-book/documentation/the-swift-programming-language}},
+}
+
 @inproceedings{Burns81,
     keywords    = {N-thread software-solution mutual exclusion},

doc/proposals/enum.tex

@@ -117 +117 @@
 \end{abstract}
 
-\section{Background}
+\section{Introduction}
 
 Naming values is a common practice in mathematics and engineering, e.g., $\pi$, $\tau$ (2$\pi$), $\phi$ (golden ratio), MHz (1E6), etc.
-Naming is also commonly used to represent many other numerical phenomenon, such as days of the week, months of a year, floors of a building (basement), time (noon, New Years).
+Naming is also commonly used to represent many other numerical phenomenon, such as days of the week, months of a year, floors of a building (basement), specific times (noon, New Years).
 Many programming languages capture this important software-engineering capability through a mechanism called an \newterm{enumeration}.
 An enumeration is similar to other programming-language types by providing a set of constrained values, but adds the ability to name \emph{all} the values in its set.
@@ -126 +126 @@
 
 Specifically, an enumerated type restricts its values to a fixed set of named constants.
-Fundamentally, all types are restricted to a fixed set of values because of the underlying von Neumann architecture, and hence, to a corresponding set of constants, e.g., @3@, @3.5@, @3.5+2.1i@, @'c'@, @"abc"@, etc.
-However, the values for basic types are not named, other than the programming-language supplied constants.
-
-
-\section{C-Style Enum}
-
-The C-Style enumeration has the following syntax and semantics, and is representative of enumerations in many other programming languages (see Section~\ref{s:RelatedWork}).
-\begin{lstlisting}[label=lst:weekday]
-enum Weekday { Monday, Tuesday, Wednesday, Thursday@ = 10@, Friday, Saturday, Sunday };
-                $\(\uparrow\)$                                                                        $\(\uparrow\)$
-    ${\rm \newterm{enumeration name}}$                                          ${\rm \newterm{enumerator names}}
-\end{lstlisting}
-Here, the enumeration type @Weekday@ defines the ordered \newterm{enumerator}s @Monday@, @Tuesday@, @Wednesday@, @Thursday@, @Friday@, @Saturday@ and @Sunday@.
-By convention, the successor of @Tuesday@ is @Monday@ and the predecessor of @Tuesday@ is @Wednesday@, independent of the associated enumerator constants.
-Because an enumerator is a constant, it cannot appear in a mutable context, e.g. @Mon = Sun@ is meaningless, and has no address, it is an rvalue\footnote{
-The term rvalue defines an expression that can only appear on the right-hand side of an assignment.}.
-Enumerators without explicitly designated constants are auto-initialized by the compiler: from left to right, starting at zero or the next explicitly initialized constant, incrementing by @1@.
-For example, @Monday@ to @Wednesday@ are implicitly assigned with constants 0--2, @Thursday@ is explicitly set to constant @10@, and @Friday@ to @Sunday@ are implicitly assigned with constants 11--13.
-Hence, there are 3 universal enumeration attributes: \newterm{position}, \newterm{label}, and \newterm{value}:
+While all types are restricted to a fixed set of values because of the underlying von Neumann architecture, and hence, to a corresponding set of constants, e.g., @3@, @3.5@, @3.5+2.1i@, @'c'@, @"abc"@, etc., these values are not named, other than the programming-language supplied constant names.
+
+Fundamentally, all enumeration systems have an \newterm{enumeration} type with an associated set of \newterm{enumerator} names.
+An enumeration has three universal attributes, \newterm{position}, \newterm{label}, and \newterm{value}, as shown by this representative enumeration, where position and value can be different.
 \begin{cquote}
 \small\sf\setlength{\tabcolsep}{3pt}
 \begin{tabular}{rccccccccccc}
-@enum@ Weekday \{       & Monday,       & Tuesday,      & Wednesday,    & Thursday = 10,& Friday,       & Saturday,     & Sunday \}; \\
-\it\color{red}position          & 0                     & 1                     & 2                             & 3                             & 4                     & 5                     & 6                     \\
-\it\color{red}label                     & Monday        & Tuesday       & Wednesday             & Thursday              & Friday        & Saturday      & Sunday        \\
-\it\color{red}value                     & 0                     & 1                     & 2                             & {\color{red}10}& 11           & 12            & 13
+\it\color{red}enumeration & \multicolumn{7}{c}{\it\color{red}enumerators}       \\
+$\downarrow$\hspace*{25pt} & \multicolumn{7}{c}{$\downarrow$}                           \\
+@enum@ Weekday \{                               & Monday,       & Tuesday,      & Wednesday,    & Thursday,& Friday,    & Saturday,     & Sunday \}; \\
+\it\color{red}position                  & 0                     & 1                     & 2                             & 3                             & 4                     & 5                     & 6                     \\
+\it\color{red}label                             & Monday        & Tuesday       & Wednesday             & Thursday              & Friday        & Saturday      & Sunday        \\
+\it\color{red}value                             & 0                     & 1                     & 2                             & 3                             & 4                     & 5             & 6
 \end{tabular}
 \end{cquote}
-Finally, C enumerators are \newterm{unscoped}, i.e., enumerators declared inside of an @enum@ are visible in the enclosing scope of the @enum@ type.
+Here, the \newterm{enumeration} @Weekday@ defines the ordered \newterm{enumerator}s @Monday@, @Tuesday@, @Wednesday@, @Thursday@, @Friday@, @Saturday@ and @Sunday@.
+By convention, the successor of @Tuesday@ is @Monday@ and the predecessor of @Tuesday@ is @Wednesday@, independent of the associated enumerator constant values.
+Because an enumerator is a constant, it cannot appear in a mutable context, e.g. @Mon = Sun@ is meaningless, and an enumerator has no address, it is an \newterm{rvalue}\footnote{
+The term rvalue defines an expression that can only appear on the right-hand side of an assignment.}.
+
+
+\section{C-Style Enum}
+
+The C-Style enumeration has the following syntax and semantics.
+\begin{lstlisting}
+enum Weekday { Monday, Tuesday, Wednesday, Thursday@ = 10@, Friday, Saturday, Sunday };
+\end{lstlisting}
+Enumerators without an explicitly designated constant value are \newterm{auto-initialized} by the compiler: from left to right, starting at zero or the next explicitly initialized constant, incrementing by @1@.
+For example, @Monday@ to @Wednesday@ are implicitly assigned with constants @0@--@2@, @Thursday@ is explicitly set to constant @10@, and @Friday@ to @Sunday@ are implicitly assigned with constants @11@--@13@.
+Initialization may occur in any order.
+\begin{lstlisting}
+enum Weekday { Thursday@ = 10@, Friday, Saturday, Sunday, Monday@ = 0@, Tuesday, Wednesday };
+\end{lstlisting}
+Note, the comma in the enumerator list can be a terminator or a separator, allowing the list to end with a dangling comma.
+\begin{lstlisting}
+enum Weekday {
+        Thursday = 10, Friday, Saturday, Sunday,
+        Monday = 0, Tuesday, Wednesday@,@ // terminating comma
+};
+\end{lstlisting}
+This feature allow enumerator lines to be interchanged without moving a comma.\footnote{
+A terminating comma appears in other C syntax, e.g., the initializer list.}
+Finally, C enumerators are \newterm{unscoped}, i.e., enumerators declared inside of an @enum@ are visible (projected) into the enclosing scope of the @enum@ type.
 
 In theory, a C enumeration \emph{variable} is an implementation-defined integral type large enough to hold all enumerated values.
-In practice, since integral constants in C have type @int@ (unless qualified with a size suffix), C uses @int@ as the underlying type for enumeration variables.
-Furthermore, there is an implicit bidirectional conversion between an enumeration and integral types.
+In practice, since integral constants are used, which have type @int@ (unless qualified with a size suffix), C uses @int@ as the underlying type for enumeration variables.
+Finally, there is an implicit bidirectional conversion between an enumeration and integral types.
 \begin{lstlisting}[label=lst:enum_scope]
 {
-        enum Weekday { ... };                           $\C{// enumerators implicitly projected into local scope}$
+        enum Weekday { /* as above */ };        $\C{// enumerators implicitly projected into local scope}$
         Weekday weekday = Monday;                       $\C{// weekday == 0}$
         weekday = Friday;                                       $\C{// weekday == 11}$
-        int i = Sunday                                          $\C{// implicit conversion to int, i == 13}$
+        int i = Sunday;                                         $\C{// implicit conversion to int, i == 13}$
         weekday = 10000;                                        $\C{// UNDEFINED! implicit conversion to Weekday}$
 }
@@ -171 +185 @@
 The implicit conversion from @int@ to an enumeration type is an unnecessary source of error.
 
+It is common for C programmers to ``believe'' there are 3 equivalent forms of constant enumeration.
+\begin{lstlisting}[label=lst:enum_scope]
+#define Monday 0
+static const int Monday = 0;
+enum { Monday };
+\end{lstlisting}
+For @#define@, the programmer has to play compiler and explicitly manage the enumeration values;
+furthermore, these are independent constants outside of any language type mechanism.
+The same explicit management is true for @const@ declarations, and the @const@ variable cannot appear in constant-expression locations, like @case@ labels, array dimensions,\footnote{
+C allows variable-length array-declarations (VLA), so this case does work, but it fails in \CC, which does not support VLAs, unless it is \lstinline{g++}.} and immediate operands of assembler instructions.
+Only the @enum@ form is managed by the compiler, is part of the language type-system, and works in all C constant-expression locations.
+
+
 \section{\CFA-Style Enum}
 
@@ -176 +203 @@
 \CFA also extends C-Style enumeration by adding a number of new features that bring enumerations inline with other modern programming languages.
 
+
+\subsection{Enumerator Name Resolution}
+\label{s:EnumeratorNameResolution}
+
+In C, unscoping of enumerators presents a \newterm{naming problem} when multiple enumeration types appear in the same scope with duplicate enumerator names.
+There is no mechanism in C to resolve these naming conflicts other than renaming of one of the duplicates, which may be impossible.
+
+The \CFA type-system allows extensive overloading, including enumerators.
+Furthermore, \CFA uses the left-hand of assignment in type resolution to pinpoint the best overloaded name.
+Finally, qualification is provided to disambiguate any ambiguous situations.
+\begin{lstlisting}
+enum C1 { First, Second, Third, Fourth };
+enum C2 { @Fourth@, @Third@, @Second@, @First@ };
+C1 p() { return Third; }                                $\C{// correctly resolved duplicate names}$
+C2 p() { return Fourth; }
+void foo() {
+        C1 e1 = First;   C2 e2 = First;
+        e1 = Second;   e2 = Second;
+        e1 = p();   e2 = p();                           $\C{// correctly resolved function call}$
+        int i = @C1.@First + @C2.@First;        $\C{// ambiguous without qualification}$
+}
+\end{lstlisting}
+\CFA overloading allows programmers to use the most meaningful names without fear of unresolvable clashes from included files, which are correctable with qualification.
+
+
+\subsection{Enumerator Scoping}
+
+An enumeration can be scoped, so the enumerator constants are not projected into the enclosing scope, using @'!'@.
+\begin{lstlisting}
+enum Weekday @!@ { /* as above */ };
+enum( char * ) Names @!@ { /* as above */ };
+\end{lstlisting}
+Now the enumerators \emph{must} be qualified with the associated enumeration.
+\begin{lstlisting}
+Weekday weekday = @Weekday@.Monday;
+Names names = @Names.@Fred;
+names = @Names.@Jane;
+\end{lstlisting}
+It is possible to toggle back to unscoping using the \CFA @with@ clause/statement (see also \CC \lstinline[language=c++]{using enum} in Section~\ref{s:C++RelatedWork}).
+\begin{lstlisting}
+Weekday weekday;
+with ( @Weekday@, @Names@ ) {                   $\C{// type names}$
+         Names names = @Fred@;
+         names = @Jane@;
+         weekday = Saturday;
+}
+\end{lstlisting}
+As in Section~\ref{s:EnumeratorNameResolution}, opening multiple unscoped enumerations can result in duplicate enumeration names, but \CFA type resolution and falling back to explicit qualification handles name resolution.
+
 \subsection{Enumerator Typing}
 
-\CFA extends the enumeration by parameterizing the enumeration with a type for the enumerators, allowing enumerators to be assigned any values from the declared type.
-Figure~\ref{f:EumeratorTyping} shows a series of examples illustrating that all \CFA types can be use with an enumeration and each type's constants used to set the enumerators.
-
-Typed enumerates deals with \emph{harmonizing} problem between an enumeration and its companion data.
-The following example is from the \CFA compiler, written in \CC.
-\begin{lstlisting}
-enum integral_types { chr, schar, uschar, sshort, ushort, sint, usint, ..., NO_OF_ITYPES };
-char * integral_names[NO_OF_ITYPES] = {
-        "char", "signed char", "unsigned char",
-        "signed short int", "unsigned short int",
-        "signed int", "unsigned int",
-        ...
-};
-\end{lstlisting}
-The \emph{harmonizing} problem occurs because the enumeration declaration is in one header file and the names are declared in another translation unit.
-It is up to the programmer to ensure changes made in one location are harmonized with the other location (by identifying this requirement within a comment).
-The typed enumeration largely solves this problem by combining and managing the two data types.
-\begin{lstlisting}
-enum( char * ) integral_types {
-        chr = "char", schar = "signed char", uschar = "unsigned char",
-        sshort = "signed short int", ushort = "unsigned short int",
-        sint = "signed int", usint = "unsigned int",
-        ...
-};
+\CFA extends the enumeration declaration by parameterizing with a type (like a generic type), allowing enumerators to be assigned any values from the declared type.
+Figure~\ref{f:EumeratorTyping} shows a series of examples illustrating that all \CFA types can be use with an enumeration and each type's constants used to set the enumerator constants.
+Note, the synonyms @Liz@ and @Beth@ in the last declaration.
+
+Because enumerators are constants, the enumeration type is implicitly @const@, so all the enumerator types in Figure~\ref{f:EumeratorTyping} are rewritten with @const@.
+A typed enumeration has an implicit (safe) conversion to its base type.
+\begin{lstlisting}
+char currency = Dollar;
+string fred = Fred;                                             $\C{// implicit conversion from char * to \CFA string type}$
+Person student = Beth;
 \end{lstlisting}
 
@@ -223 +285 @@
         enum( @_Complex@ ) Plane { X = 1.5+3.4i, Y = 7+3i, Z = 0+0.5i };
 // pointer
-        enum( @char *@ ) Names { Fred = "Fred", Mary = "Mary", Jane = "Jane" };
+        enum( @char *@ ) Names { Fred = "FRED", Mary = "MARY", Jane = "JANE" };
         int i, j, k;
         enum( @int *@ ) ptr { I = &i,  J = &j,  K = &k };
         enum( @int &@ ) ref { I = i,   J = j,   K = k };
 // tuple
-        enum( @[int, int]@ ) { T = [ 1, 2 ] };
+        enum( @[int, int]@ ) { T = [ 1, 2 ] }; $\C{// new \CFA type}$
 // function
         void f() {...}   void g() {...}
@@ -234 +296 @@
 // aggregate
         struct Person { char * name; int age, height; };
-        enum( @Person@ ) friends { Liz = { "Elizabeth", 22, 170 }, Beth = Liz, Jon = { "Jonathan", 35, 190 } };
+@***@enum( @Person@ ) friends { @Liz@ = { "ELIZABETH", 22, 170 }, @Beth@ = Liz, Jon = { "JONATHAN", 35, 190 } };
 \end{lstlisting}
 \caption{Enumerator Typing}
@@ -240 +302 @@
 \end{figure}
 
+Typed enumerations deals with the \emph{harmonizing} problem between an enumeration and any companion data.
+The following example is from the \CFA compiler, written in \CC.
+\begin{lstlisting}
+enum integral_types { chr, schar, uschar, sshort, ushort, sint, usint, ..., NO_OF_ITYPES };
+char * integral_names[NO_OF_ITYPES] = {
+        "char", "signed char", "unsigned char",
+        "signed short int", "unsigned short int",
+        "signed int", "unsigned int",
+        ...
+};
+\end{lstlisting}
+The \emph{harmonizing} problem occurs because the enumeration declaration is in one header file and the names are declared in another translation unit.
+It is up to the programmer to ensure changes made in one location are harmonized with the other location (by identifying this requirement within a comment).
+The typed enumeration largely solves this problem by combining and managing the two data types.
+\begin{lstlisting}
+enum( char * ) integral_types {
+        chr = "char", schar = "signed char", uschar = "unsigned char",
+        sshort = "signed short int", ushort = "unsigned short int",
+        sint = "signed int", usint = "unsigned int",
+        ...
+};
+\end{lstlisting}
+Note, the enumeration type can be a structure (see @Person@ in Figure~\ref{f:EumeratorTyping}), so it is possible to have the equivalent of multiple arrays of companion data using an array of structures.
+
+
 \subsection{Pure Enumerators}
 
-An empty type, @enum()@, implies the enumerators are pure symbols without values;
+An empty enumerator type, @enum()@, implies the enumerators are pure symbols without values but set properties;
 hence, there is no default conversion to @int@. 
 
 \begin{lstlisting}
 enum() Mode { O_RDONLY, O_WRONLY, O_CREAT, O_TRUNC, O_APPEND };
-Mode iomode = O_RDONLY;
+@***@Mode iomode = O_RDONLY;
+bool b = iomode == O_RDONLY || iomode < O_APPEND;
 int i = iomode;                                                 $\C{\color{red}// disallowed}$
-sout | O_TRUNC;                                                 $\C{\color{red}// disallowed}$
 \end{lstlisting}
 
 \subsection{Enumerator Subset}
 
-If follows from enumerator typing that the type of the enumerators can be another enumerator.
-\begin{lstlisting}
+If follows from enumerator typing that the enumerator type can be another enumerator.
+\begin{lstlisting}
+enum( @char@ ) Currency { Dollar = '$\textdollar$', Euro = '$\texteuro$', Pound = '$\textsterling$'  };
+enum( @Currency@ ) Europe { Euro = Currency.Euro, Pound = Currency.Pound }; // intersection
 enum( char ) Letter { A = 'A',  B = 'B', C = 'C', ..., Z = 'Z' };
-enum( Letter ) Greek { Alph = A, Beta = B, ..., Zeta = Z }; // alphabet intersection
+enum( @Letter@ ) Greek { Alph = A, Beta = B, ..., Zeta = Z }; // intersection
+\end{lstlisting}
+Subset enumerations may have more or less enumerators than their typed enumeration, but the enumerator values must be from the typed enumeration.
+For example, @Greek@ enumerators are a subset of type @Letter@ and are type compatible with enumeration @Letter@, but @Letter@ enumerators are not type compatible with enumeration @Greek@. 
+\begin{lstlisting}
 Letter letter = A;
-Greak greek = Alph;
-letter = Alph;                                                  $\C{// allowed}$
+@***@Greak greek = Beta;
+letter = Beta;                                                  $\C{// allowed, letter == B}$
 greek = A;                                                              $\C{\color{red}// disallowed}$
 \end{lstlisting}
-Enumeration @Greek@ may have more or less enumerators than @Letter@, but the enumerator values must be from @Letter@.
-Therefore, @Greek@ enumerators are a subset of type @Letter@ and are type compatible with enumeration @Letter@, but @Letter@ enumerators are not type compatible with enumeration @Greek@. 
+
 
 \subsection{Enumeration Inheritance}
 
-\CFA Plan-9 inheritance may be used with enumerations.
-\begin{lstlisting}
-enum( char * ) Name2 { @inline Name@, Jack = "Jack", Jill = "Jill" };
-enum /* inferred */ Name3 { @inline Name2@, Sue = "Sue", Tom = "Tom" };
-\end{lstlisting}
-Enumeration @Name2@ inherits all the enumerators and their values from enumeration @Name@ by containment, and a @Name@ enumeration is a subtype of enumeration @Name2@.
+\CFA Plan-9 inheritance may be used with enumerations, where Plan-9 inheritance is containment inheritance with implicit unscoping (like a nested unnamed @struct@/@union@ in C).
+\begin{lstlisting}
+enum( char * ) Names { /* as above */ };
+enum( char * ) Names2 { @inline Names@, Jack = "JACK", Jill = "JILL" };
+@***@enum /* inferred */ Names3 { @inline Names2@, Sue = "SUE", Tom = "TOM" };
+\end{lstlisting}
+Enumeration @Name2@ inherits all the enumerators and their values from enumeration @Names@ by containment, and a @Names@ enumeration is a subtype of enumeration @Name2@.
 Note, enumerators must be unique in inheritance but enumerator values may be repeated.
 
 The enumeration type for the inheriting type must be the same as the inherited type;
 hence the enumeration type may be omitted for the inheriting enumeration and it is inferred from the inherited enumeration, as for @Name3@.
-When inheriting from integral types, automatic numbering may be used, so the inheritance placement left to right is important.
-
-Specifically, the inheritance relationship for Names is:
-\begin{lstlisting}
-Name $\(\subset\)$ Name2 $\(\subset\)$ Name3 $\(\subset\)$ const char *         // enum type of Name
+% When inheriting from integral types, automatic numbering may be used, so the inheritance placement left to right is important.
+Specifically, the inheritance relationship for @Names@ is:
+\begin{lstlisting}
+Names $\(\subset\)$ Names2 $\(\subset\)$ Names3 $\(\subset\)$ const char * $\C{// enum type of Names}$
 \end{lstlisting}
 For the given function prototypes, the following calls are valid.
@@ -288 +380 @@
 \begin{tabular}{ll}
 \begin{lstlisting}
-void f( Name );
-void g( Name2 );
-void h( Name3 );
+void f( Names );
+void g( Names2 );
+void h( Names3 );
 void j( const char * );
 \end{lstlisting}
@@ -298 +390 @@
 g( Fred );   g( Jill );
 h( Fred );   h( Jill );   h( Sue );
-j( Fred );   j( Jill );   j( Sue );   j( "Will" );
+j( Fred );   j( Jill );   j( Sue );   j( "WILL" );
 \end{lstlisting}
 \end{tabular}
 \end{cquote}
-Note, the validity of calls is the same for call-by-reference as for call-by-value, and const restrictions are the same as for other types.
-
-\subsection{Enumerator Scoping}
-
-A \CFA-enum can be scoped, meaning the enumerator constants are not projected into the enclosing scope.
-\begin{lstlisting}
-enum Weekday @!@ { /* as above */ };
-enum Colour( char * ) @!@ { /* as above */ };
-\end{lstlisting}
-where the @'!'@ implies the enumerators are \emph{not} projected.
-The enumerators of a scoped enumeration are accessed using qualifications, like the fields of an aggregate.
-% The syntax of $qualified\_expression$ for \CFA-enum is the following:
-% $$<qualified\_expression> := <enum\_type>.<enumerator>$$
-\begin{lstlisting}
-Weekday weekday = @Weekday.Monday@;             $\C{// qualification}$
-Colour colour = @Colour.@Red;
-colour = @Colour.@Blue;
-\end{lstlisting}
+Note, the validity of calls is the same for call-by-reference as for call-by-value, and @const@ restrictions are the same as for other types.
+
 
 \subsection{Enumeration Pseudo-functions}
 
-Pseudo-functions are function-like operators that do not result in any run-time computations, i.e., like @sizeof@.
+Pseudo-functions are function-like operators that do not result in any run-time computations, i.e., like @sizeof@, @offsetof@, @typeof@.
 Often a call to a pseudo-function is substituted with information extracted from the symbol table at compilation time, like storage size or alignment associated with the underlying architecture..
 
-\subsubsection{Enumerator Attributes}
 The attributes of an enumerator are accessed by pseudo-functions @position@, @value@, and @label@.
 \begin{lstlisting}
-int green_pos = @position@( Colour.Green );     $\C{// 1}$
-char * green_value = @value@( Colour.Green ); $\C{// "G"}$
-char * green_label = @label@( Colour.Green ); $\C{// "Green"}$
-\end{lstlisting}
-
-Enumeration Greek may have more or less enumerators than Letter, but the enumerator values must be from Letter.
-Therefore, Greek enumerators are a subset of type Letter and are type compatible with enumeration Letter, but Letter enumerators are not type compatible with enumeration Greek. 
-
-% An instance of \CFA-enum (denoted as @<enum_instance>@) is a label for the defined enum name.
-% The label can be retrieved by calling the function @label( <enum_instance> )@.
-% Similarly, the @value()@ function returns the value used to initialize the \CFA-enum.
-
-\subsubsection{\lstinline{enumerate()}}
-
-\begin{lstlisting}[label=lst:c_switch]
-enum(int) C_ENUM { First, Second, Third = First, Fourth };
-int v( C_ENUM e ) {
-        switch( e ) {
-                case First: return 0; break;
-                case Second: return 1; break;
-                // case Third: return 2; break;
-                // case Fourth: return 3; break;
-        };
-};
-\end{lstlisting}
-In the @C_ENUM@ example, @Third@ is an alias of @First@ and @Fourth@ is an alias of @Second@.
-Programmers cannot make case branches for @Third@ and @Fourth@ because the switch statement matches cases by the enumerator's value.
-Case @First@ and @Third@, or @Second@ and @Fourth@, has duplicate case values.
-
-@enumerate()@ is a pseudo-function that makes the switch statement match by an enumerator instead.
-\begin{lstlisting}[label=lst:c_switch_enumerate]
-enum(double) C_ENUM { First, Second, Third = First, Fourth };
-C_ENUM variable_a = First, variable_b = Second, variable_c = Third, variable_d = Fourth;
-int v(C_ENUM e) {
-        switch( enumeratate( e ) ) {
-                case First: return e; break;
-                case Second: return value( e ); break;
-                case Third: return label( e ); break;
-                case Fourth: return position( e ); break;
-        };
-};
+@***@int jane_pos = @position@( Names.Jane );   $\C{// 2}$
+@***@char * jane_value = @value@( Names.Jane ); $\C{// "JANE"}$
+@***@char * jane_label = @label@( Names.Jane ); $\C{// "Jane"}$
+sout | @label@( Names.Jane ) | @value@( Names.Jane );
+\end{lstlisting}
+Note the ability to print both enumerator label and value.
+
+
+\subsection{Enumerator Position or Value}
+
+Enumerators can be used in multiple contexts.
+In most programming languages, an enumerator is implicitly converted to its value (like a typed macro substitution).
+However, enumerator synonyms and typed enumerations make this implicit conversion to value incorrect in some contexts.
+In these contexts, a programmer's initition assumes an implicit conversion to postion.
+
+For example, an intuitive use of enumerations is with the \CFA @switch@/@choose@ statement, where @choose@ performs an implict @break@ rather than a fall-through at the end of a @case@ clause.
+\begin{cquote}
+\begin{lstlisting}
+enum Count { First, Second, Third, Fourth };
+Count e;
+\end{lstlisting}
+\begin{tabular}{ll}
+\begin{lstlisting}
+
+choose( e ) {
+        case @First@: ...;
+        case @Second@: ...;
+        case @Third@: ...;
+        case @Fourth@: ...;
+}
+\end{lstlisting}
+&
+\begin{lstlisting}
+// rewrite
+choose( @value@( e ) ) {
+        case @value@( First ): ...;
+        case @value@( Second ): ...;
+        case @value@( Third ): ...;
+        case @value@( Fourth ): ...;
+}
+\end{lstlisting}
+\end{tabular}
+\end{cquote}
+Here, the intuitive code on the left is implicitly transformed into the statndard implementation on the right, using the value of the enumeration variable and enumerators.
+However, this implementation is fragile, e.g., if the enumeration is changed to:
+\begin{lstlisting}
+enum Count { First, Second, Third @= First@, Fourth };
+\end{lstlisting}
+which make @Third == First@ and @Fourth == Second@, causing a compilation error because of duplicase @case@ clauses.
+To better match with programmer intuition, \CFA toggles between value and position semantics depneding on the language context.
+For conditional clauses and switch statments, \CFA uses the robust position implementation.
+\begin{lstlisting}
+choose( @position@( e ) ) {
+        case @position@( First ): ...;
+        case @position@( Second ): ...;
+        case @position@( Third ): ...;
+        case @position@( Fourth ): ...;
+}
+\end{lstlisting}
+
+\begin{lstlisting}
+Count variable_a = First, variable_b = Second, variable_c = Third, variable_d = Fourth;
 p(variable_a); // 0
 p(variable_b); // 1
@@ -1015 +1111 @@
 If the @aggregation_name@ is identified as a \CFA enumeration, the compiler checks if @field@ presents in the declared \CFA enumeration.
 
-\subsection{\lstinline{with} Clause/Statement}
-
-Instead of qualifying an enumeration expression every time, the @with@ can be used to expose enumerators to the current scope, making them directly accessible.
-\begin{lstlisting}[label=lst:declaration]
-enum Color( char * ) { Red="R", Green="G", Blue="B" };
-enum Animal( int ) { Cat=10, Dog=20 };
-with ( Color, Animal ) {
-        char * red_string = Red; // value( Color.Red )
-        int cat = Cat; // value( Animal.Cat )
-}
-\end{lstlisting}
-The \lstinline{with} might introduce ambiguity to a scope. Consider the example:
-\begin{lstlisting}[label=lst:declaration]
-enum Color( char * ) { Red="R", Green="G", Blue="B" };
-enum RGB( int ) { Red=0, Green=1, Blue=2 };
-with ( Color, RGB ) {
-        // int red = Red;
-}
-\end{lstlisting}
-\CFA will not try to resolve the expression with ambiguity. It would report an error. In this case, it is necessary to qualify @Red@ even inside of the \lstinline{with} clause.
-
 \subsection{Instance Declaration}
 
@@ -1218 +1293 @@
 
 \subsection{\CC}
-
-\CC is backwards compatible with C, so it inherited C's enumerations, except there is no implicit conversion from an integral value to an enumeration;
-hence, the values in a \CC enumeration can only be its enumerators (without a cast).
-There is no mechanism to iterate through an enumeration.
-
-\CC{11} added a scoped enumeration, \lstinline[language=c++]{enum class} (or \lstinline[language=c++]{enum struct}), so the enumerators are local to the enumeration and must be accessed using type qualification, e.g., @Weekday::Monday@.
+\label{s:C++RelatedWork}
+
+\CC is backwards compatible with C, so it inherited C's enumerations.
+However, the following non-backwards compatible changes have been made.
+\begin{quote}
+7.2 Change: \CC objects of enumeration type can only be assigned values of the same enumeration type.
+In C, objects of enumeration type can be assigned values of any integral type. \\
+Example:
+\begin{lstlisting}
+enum color { red, blue, green };
+color c = 1;                                                    $\C{// valid C, invalid C++}$
+\end{lstlisting}
+\textbf{Rationale}: The type-safe nature of C++. \\
+\textbf{Effect on original feature}: Deletion of semantically well-defined feature. \\
+\textbf{Difficulty of converting}: Syntactic transformation. (The type error produced by the assignment can be automatically corrected by applying an explicit cast.) \\
+\textbf{How widely used}: Common.
+\end{quote}
+\begin{quote}
+7.2 Change: In \CC, the type of an enumerator is its enumeration.
+In C, the type of an enumerator is @int@. \\
+Example:
+\begin{lstlisting}
+enum e { A };
+sizeof(A) == sizeof(int)                                $\C{// in C}$
+sizeof(A) == sizeof(e)                                  $\C{// in C++}$
+/* and sizeof(int) is not necessary equal to sizeof(e) */
+\end{lstlisting}
+\textbf{Rationale}: In C++, an enumeration is a distinct type. \\
+\textbf{Effect on original feature}: Change to semantics of well-defined feature. \\
+\textbf{Difficulty of converting}: Semantic transformation. \\
+\textbf{How widely used}: Seldom. The only time this affects existing C code is when the size of an enumerator is taken.
+Taking the size of an enumerator is not a common C coding practice.
+\end{quote}
+Hence, the values in a \CC enumeration can only be its enumerators (without a cast).
+While the storage size of an enumerator is up to the compiler, there is still an implicit cast to @int@.
+\begin{lstlisting}
+enum E { A, B, C };
+E e = A;
+int i = A;   i = e;                                             $\C{// implicit casts to int}$
+\end{lstlisting}
+\CC{11} added a scoped enumeration, \lstinline[language=c++]{enum class} (or \lstinline[language=c++]{enum struct}), so the enumerators are local to the enumeration and must be accessed using type qualification.
+\begin{lstlisting}[language=c++,{moredelim=**[is][\color{red}]{@}{@}}]
+enum class E { A, B, C };
+E e = @E::@A;                                                   $\C{// qualified enumerator}$
+e = B;                                                                  $\C{// B not in scope}$
+\end{lstlisting}
 \CC{20} supports unscoped access with a \lstinline[language=c++]{using enum} declaration.
-
-For both unscoped and scoped enumerations, the underlying type is an implementation-defined integral type large enough to hold all enumerated values; it does not have to be the smallest possible type.
-In \CC{11}, the underlying integral type can be explicitly specified:
 \begin{lstlisting}[language=c++,{moredelim=**[is][\color{red}]{@}{@}}]
-enum class RGB : @long@ { Red, Green, Blue };
-enum class rgb : @char@ { Red = 'r', Green = 'g', Blue = 'b' };
-enum class srgb : @signed char@ { Red = -1, Green = 0, Blue = 1 };
-RGB colour1 = @RGB::@Red;
-rgb colour2 = @rgb::@Red;
-srgb colour3 = @srgb::@Red;
-\end{lstlisting}
+enum class E { A, B, C };
+@using enum E;@
+E e = A;                                                                $\C{// direct access}$
+e = B;                                                                  $\C{// direct access}$
+\end{lstlisting}
+\CC{11} added the ability to explicitly declare the underlying integral type for \lstinline[language=c++]{enum class}.
+\begin{lstlisting}[language=c++,{moredelim=**[is][\color{red}]{@}{@}}]
+enum class RGB @: long@ { Red, Green, Blue };
+enum class rgb @: char@ { Red = 'r', Green = 'g', Blue = 'b' };
+enum class srgb @: signed char@ { Red = -1, Green = 0, Blue = 1 };
+\end{lstlisting}
+There is no implicit conversion from the \lstinline[language=c++]{enum class} type and to its type.
+\begin{lstlisting}[language=c++,{moredelim=**[is][\color{red}]{@}{@}}]
+rgb crgb = rgb::Red;
+char ch = rgb::Red;   ch = crgb;                $\C{// disallowed}$
+\end{lstlisting}
+Finally, there is no mechanism to iterate through an enumeration nor use the enumeration type to declare an array dimension.
+
 
 \subsection{Go}

doc/theses/jiada_liang_MMath/background.tex

@@ -1 +1 @@
 \chapter{Background}
+
+
+\section{C-Style Enum}
+
+The C-Style enumeration has the following syntax and semantics.
+\begin{cfa}
+enum Weekday { Monday, Tuesday, Wednesday, Thursday@ = 10@, Friday, Saturday, Sunday };
+\end{cfa}
+Enumerators without an explicitly designated constant value are \Newterm{auto-initialized} by the compiler: from left to right, starting at zero or the next explicitly initialized constant, incrementing by @1@.
+For example, @Monday@ to @Wednesday@ are implicitly assigned with constants @0@--@2@, @Thursday@ is explicitly set to constant @10@, and @Friday@ to @Sunday@ are implicitly assigned with constants @11@--@13@.
+Initialization may occur in any order.
+\begin{cfa}
+enum Weekday { Thursday@ = 10@, Friday, Saturday, Sunday, Monday@ = 0@, Tuesday, Wednesday };
+\end{cfa}
+Note, the comma in the enumerator list can be a terminator or a separator, allowing the list to end with a dangling comma.
+\begin{cfa}
+enum Weekday {
+        Thursday = 10, Friday, Saturday, Sunday,
+        Monday = 0, Tuesday, Wednesday@,@ // terminating comma
+};
+\end{cfa}
+This feature allow enumerator lines to be interchanged without moving a comma.\footnote{
+A terminating comma appears in other C syntax, \eg the initializer list.}
+Finally, C enumerators are \Newterm{unscoped}, \ie enumerators declared inside of an @enum@ are visible (projected) into the enclosing scope of the @enum@ type.
+
+In theory, a C enumeration \emph{variable} is an implementation-defined integral type large enough to hold all enumerated values.
+In practice, since integral constants are used, which have type @int@ (unless qualified with a size suffix), C uses @int@ as the underlying type for enumeration variables.
+Finally, there is an implicit bidirectional conversion between an enumeration and its integral type.
+\begin{cfa}
+{
+        enum Weekday { /* as above */ };        $\C{// enumerators implicitly projected into local scope}$
+        Weekday weekday = Monday;                       $\C{// weekday == 0}$
+        weekday = Friday;                                       $\C{// weekday == 11}$
+        int i = Sunday;                                         $\C{// implicit conversion to int, i == 13}$
+        weekday = 10000;                                        $\C{// UNDEFINED! implicit conversion to Weekday}$
+}
+int j = Wednesday;                                              $\C{// ERROR! Wednesday is not declared in this scope}$
+\end{cfa}
+The implicit conversion from @int@ to an enumeration type is an unnecessary source of error.
+
+It is common for C programmers to ``believe'' there are 3 equivalent forms of constant enumeration.
+\begin{cfa}
+#define Monday 0
+static const int Monday = 0;
+enum { Monday };
+\end{cfa}
+For @#define@, the programmer has to play compiler and explicitly manage the enumeration values;
+furthermore, these are independent constants outside of any language type mechanism.
+The same explicit management is true for @const@ declarations, and the @const@ variable cannot appear in constant-expression locations, like @case@ labels, array dimensions,\footnote{
+C allows variable-length array-declarations (VLA), so this case does work, but it fails in \CC, which does not support VLAs, unless it is \lstinline{g++}.} and immediate operands of assembler instructions.
+Only the @enum@ form is managed by the compiler, is part of the language type-system, and works in all C constant-expression locations.

doc/theses/jiada_liang_MMath/intro.tex

@@ -1 +1 @@
 \chapter{Introduction}
 
-Testing glossy abbreviations \gls{foo} and \gls{bar}, and glossy definitions \gls{git} and \gls{gulp}.
+Naming values is a common practice in mathematics and engineering, \eg $\pi$, $\tau$ (2$\pi$), $\phi$ (golden ratio), MHz (1E6), etc.
+Naming is also commonly used to represent many other numerical phenomenon, such as days of the week, months of a year, floors of a building (basement), specific times (noon, New Years).
+Many programming languages capture this important software engineering capability through a mechanism called an \Newterm{enumeration}.
+An enumeration is similar to other programming-language types by providing a set of constrained values, but adds the ability to name \emph{all} the values in its set.
+Note, all enumeration names must be unique but different names can represent the same value (eight note, quaver), which are synonyms.
 
-And use the glossy abbreviations \gls{foo} and \gls{bar}, and definitions \gls{git} and \gls{gulp} again.
+Specifically, an enumerated type restricts its values to a fixed set of named constants.
+While all types are restricted to a fixed set of values because of the underlying von Neumann architecture, and hence, to a corresponding set of constants, \eg @3@, @3.5@, @3.5+2.1i@, @'c'@, @"abc"@, etc., these values are not named, other than the programming-language supplied constant names.
+
+Fundamentally, all enumeration systems have an \Newterm{enumeration} type with an associated set of \Newterm{enumerator} names.
+An enumeration has three universal attributes, \Newterm{position}, \Newterm{label}, and \Newterm{value}, as shown by this representative enumeration, where position and value can be different.
+\begin{cquote}
+\small\sf\setlength{\tabcolsep}{3pt}
+\begin{tabular}{rccccccccccc}
+\it\color{red}enumeration & \multicolumn{7}{c}{\it\color{red}enumerators}       \\
+$\downarrow$\hspace*{25pt} & \multicolumn{7}{c}{$\downarrow$}                           \\
+@enum@ Weekday \{                               & Monday,       & Tuesday,      & Wednesday,    & Thursday,& Friday,    & Saturday,     & Sunday \}; \\
+\it\color{red}position                  & 0                     & 1                     & 2                             & 3                             & 4                     & 5                     & 6                     \\
+\it\color{red}label                             & Monday        & Tuesday       & Wednesday             & Thursday              & Friday        & Saturday      & Sunday        \\
+\it\color{red}value                             & 0                     & 1                     & 2                             & 3                             & 4                     & 5             & 6
+\end{tabular}
+\end{cquote}
+Here, the \Newterm{enumeration} @Weekday@ defines the ordered \Newterm{enumerator}s @Monday@, @Tuesday@, @Wednesday@, @Thursday@, @Friday@, @Saturday@ and @Sunday@.
+By convention, the successor of @Tuesday@ is @Monday@ and the predecessor of @Tuesday@ is @Wednesday@, independent of the associated enumerator constant values.
+Because an enumerator is a constant, it cannot appear in a mutable context, \eg @Mon = Sun@ is meaningless, and an enumerator has no address, it is an \Newterm{rvalue}\footnote{
+The term rvalue defines an expression that can only appear on the right-hand side of an assignment.}.
+
+\section{Contributions}

doc/theses/jiada_liang_MMath/uw-ethesis-frontpgs.tex

@@ -131 +131 @@
 \begin{center}\textbf{Abstract}\end{center}
 
-Enumerated type ...
+An enumeration is a type defining an ordered set of named constant values, where a name abstracts a value, \eg @PI@ versus @3.145159@.
+C restrict an enumeration type to the integral type @signed int@, which \CC support , meaning enumeration names bind to integer constants.
+\CFA extends C enumerations to allow all basic and custom types for the enumeration type, like other modern programming languages.
+Furthermore, \CFA adds other useful features for enumerations to support better software-engineering practices and simplify program development.
 
 \cleardoublepage

doc/theses/jiada_liang_MMath/uw-ethesis.tex

@@ -91 +91 @@
 % cfa macros used in the document
 \input{common}
-%\usepackageinput{common}
+%\usepackage{common}
 \CFAStyle                                               % CFA code-style
-\lstset{language=CFA}                                   % default language
-\lstset{basicstyle=\linespread{0.9}\sf}                 % CFA typewriter font
+\lstset{language=cfa,belowskip=-1pt}                                    % set default language to CFA
+
 \newcommand{\newtermFont}{\emph}
 \newcommand{\Newterm}[1]{\newtermFont{#1}}
@@ -211 +211 @@
 \input{intro}
 \input{background}
-\input{content1}
-\input{content2}
+\input{CFAenum}
+\input{implementation}
+\input{relatedwork}
 \input{performance}
 \input{conclusion}

doc/user/user.tex

@@ -11 +11 @@
 %% Created On       : Wed Apr  6 14:53:29 2016
 %% Last Modified By : Peter A. Buhr
-%% Last Modified On : Tue Jan 30 09:02:41 2024
-%% Update Count     : 6046
+%% Last Modified On : Mon Feb 12 11:50:26 2024
+%% Update Count     : 6199
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
@@ -4177 +4177 @@
 The \CFA header file for the I/O library is \Indexc{fstream.hfa}.
 
+
+\subsubsection{Stream Output}
+
 For implicit formatted output, the common case is printing a series of variables separated by whitespace.
 \begin{cquote}
@@ -4255 +4258 @@
 Note, \CFA stream variables ©stdin©, ©stdout©, ©stderr©, ©exit©, and ©abort© overload C variables ©stdin©, ©stdout©, ©stderr©, and functions ©exit© and ©abort©, respectively.
 
+
+\subsubsection{Stream Input}
+
 For implicit formatted input, the common case is reading a sequence of values separated by whitespace, where the type of an input constant must match with the type of the input variable.
 \begin{cquote}
 \begin{lrbox}{\myboxA}
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
-int x;   double y   char z;
+char c;   int i;   double d
 \end{cfa}
 \end{lrbox}
@@ -4266 +4272 @@
 \multicolumn{1}{c@{\hspace{2em}}}{\textbf{\CFA}}        & \multicolumn{1}{c@{\hspace{2em}}}{\textbf{\CC}}       & \multicolumn{1}{c}{\textbf{Python}}   \\
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
-sin | x | y | z;
+sin | c | i | d;
 \end{cfa}
 &
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
-cin >> x >> y >> z;
+cin >> c >> i >> d;
 \end{cfa}
 &
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
-x = int(input());  y = float(input());  z = input();
+c = input();   i = int(input());   d = float(input());
 \end{cfa}
 \\
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
-®1® ®2.5® ®A®
+®A® ®1® ®2.5®
 
 
@@ -4284 +4290 @@
 &
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
-®1® ®2.5® ®A®
+®A® ®1® ®2.5®
 
 
@@ -4290 +4296 @@
 &
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
+®A®
 ®1®
 ®2.5®
-®A®
 \end{cfa}
 \end{tabular}
@@ -4309 +4315 @@
 For floating-point types, any number of decimal digits, optionally preceded by a sign (©+© or ©-©), optionally containing a decimal point, and optionally followed by an exponent, ©e© or ©E©, with signed (optional) decimal digits.
 Floating-point values can also be written in hexadecimal format preceded by ©0x© or ©0X© with hexadecimal digits and exponent denoted by ©p© or ©P©.
-In all cases, all whitespace characters are skipped until an appropriate value is found.
-\Textbf{If an appropriate value is not found, the exception ©missing_data© is raised.}
-
-For the C-string type, there are two input forms: any number of \Textbf{non-whitespace} characters or a quoted sequence containing any characters except the closing quote, \ie there is no escape character supported in the string..
-In both cases, the string is null terminated ©'\0'©.
-For the quoted string, the start and end quote characters can be any character and do not have to match \see{\ref{XXX}}.
-
-\VRef[Figure]{f:IOStreamFunctions} shows the I/O stream operations for interacting with files other than ©cin©, ©cout©, and ©cerr©.
+In all cases, whitespace characters are skipped until an appropriate value is found.
+\begin{cfa}[belowskip=0pt]
+char ch;  int i;  float f; double d;  _Complex double cxd;
+sin | ch | i | f | d | cxd;
+X   42   1234.5     0xfffp-2    3.5+7.1i
+\end{cfa}
+It is also possible to scan and ignore specific strings and whitespace using a string format.
+\begin{cfa}[belowskip=0pt]
+sin | "abc def";                                                §\C{// space matches arbitrary whitespace (2 blanks, 2 tabs)}§
+\end{cfa}
+\begin{cfa}[showspaces=true,showtabs=true,aboveskip=0pt,belowskip=0pt]
+®abc            def®
+\end{cfa}
+A non-whitespace format character reads the next input character, compares the format and input characters, and if equal, the input character is discarded and the next format character is tested.
+Note, a single whitespace in the format string matches \Textbf{any} quantity of whitespace characters from the stream (including none).
+
+For the C-string type, the default input format is any number of \Textbf{non-whitespace} characters.
+There is no escape character supported in an input string, but any Latin-1 character can be typed directly in the input string.
+For example, if the following non-whitespace output is redirected into a file by the shell:
+\begin{cfa}[belowskip=0pt]
+sout | "\n\t\f\0234\x23";
+\end{cfa}
+it can be read back from the file by redirecting the file as input using:
+\begin{cfa}[belowskip=0pt]
+char s[64];
+sin | wdi( sizeof(s), s );                              §\C{// must specify string size}§
+\end{cfa}
+The input string is always null terminated ©'\0'© in the input variable.
+Because of potential buffer overrun when reading C strings, strings are restricted to work with input manipulators \see{\VRef{s:InputManipulators}}.
+As well, there are multiple input-manipulators for scanning complex input string formats, \eg a quoted character or string.
+
+\Textbf{In all cases, if an invalid data value is not found for a type or format string, the exception ©missing_data© is raised and the input variable is unchanged.}
+For example, when reading an integer and the string ©"abc"© is found, the exception ©missing_data© is raised to ensure the program does not proceed erroneously.
+If a valid data value is found, but it is larger than the capacity of the input variable, such reads are undefined.
+
+
+\subsubsection{Stream Files}
+
+\VRef[Figure]{f:IOStreamFunctions} shows the I/O stream operations for interacting with files other than ©sin©, ©sout©, and ©cerr©.
 \begin{itemize}[topsep=4pt,itemsep=2pt,parsep=0pt]
 \item
@@ -4932 +4969 @@
 
 \subsection{Input Manipulators}
-
-The following \Index{manipulator}s control scanning of input values (reading), and only affect the format of the argument.
-
-Certain manipulators support a \newterm{scanset}, which is a simple regular expression, where the matching set contains any Latin-1 character (8-bits) or character ranges using minus.
+\label{s:InputManipulators}
+
+A string variable \emph{must} be large enough to contain the input sequence.
+To force programmers to consider buffer overruns for C-string input, C-strings may only be read with a width field, which should specify a size less than or equal to the C-string size, \eg:
+\begin{cfa}
+char line[64];
+sin | wdi( ®sizeof(line)®, line );              §\C{// must specify string size}§
+\end{cfa}
+
+Certain input manipulators support a \newterm{scanset}, which is a simple regular expression, where the matching set contains any Latin-1 character (8-bits) or character ranges using minus.
 For example, the scanset \lstinline{"a-zA-Z -/?§"} matches any number of characters between ©'a'© and ©'z'©, between ©'A'© and ©'Z'©, between space and ©'/'©, and characters ©'?'© and (Latin-1) ©'§'©.
 The following string is matched by this scanset:
 \begin{cfa}
-!&%$  abAA () ZZZ  ??  xx§\S\S\S§
-\end{cfa}
-To match a minus, put it as the first character, ©"-0-9"©.
-Other complex forms of regular-expression matching are not supported.
-
-A string variable \emph{must} be large enough to contain the input sequence.
-To force programmers to consider buffer overruns for C-string input, C-strings can only be read with a width field, which should specify a size less than or equal to the C-string size, \eg:
-\begin{cfa}
-char line[64];
-sin | wdi( ®sizeof(line)®, line ); // must specify size
-\end{cfa}
-
-Currently, there is no mechanism to detect if a value read exceeds the capwhen Most types are finite sized, \eg integral types only store value that fit into their corresponding storage, 8, 16, 32, 64, 128 bits.
-Hence, an input value may be too large, and the result of the read is often considered undefined, which leads to difficlt to locate runtime errors.
-All reads in \CFA check if values do not fit into the argument variable's type and raise the exception 
-All types are
+!&%$  abAA () ZZZ  ??§\S§  xx§\S\S§
+\end{cfa}
+To match a minus, make it the first character in the set, \eg ©"©{\color{red}\raisebox{-1pt}{\texttt{-}}}©0-9"©.
+Other complex forms of regular-expression matching are unsupported.
+
+The following \Index{manipulator}s control scanning of input values (reading) and only affect the format of the argument.
 
 \begin{enumerate}
 \item
-\Indexc{skip}( scanset )\index{manipulator!skip@©skip©}, ©skip©( $N$ )
-The first form uses a scanset to skip matching characters.
-The second form skips the next $N$ characters, including newline.
-If the match successes, the input characters are discarded, and input continues with the next character.
+\Indexc{skip}( \textit{scanset} )\index{manipulator!skip@©skip©}, ©skip©( $N$ )
+consumes either the \textit{scanset} or the next $N$ characters, including newlines.
+If the match successes, the input characters are ignored, and input continues with the next character.
 If the match fails, the input characters are left unread.
 \begin{cfa}[belowskip=0pt]
-char sk[§\,§] = "abc";
-sin | "abc " | skip( sk ) | skip( 5 ); // match input sequence
+char scanset[§\,§] = "abc";
+sin | "abc§\textvisiblespace§" | skip( scanset ) | skip( 5 ); §\C{// match and skip input sequence}§
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
-®abc   ®
-®abc  ®
-®xx®
-\end{cfa}
-
-\item
-\Indexc{wdi}( maximum, variable )\index{manipulator!wdi@©wdi©}
-For all types except ©char *©, whitespace is skipped until an appropriate value is found for the specified variable type.
-maximum is the maximum number of characters read for the current operation.
+®abc   abc  xxx®
+\end{cfa}
+Again, the blank in the format string ©"abc©\textvisiblespace©"© matches any number of whitespace characters.
+
+\item
+\Indexc{wdi}( \textit{maximum}, ©T & v© )\index{manipulator!wdi@©wdi©}
+For all types except ©char *©, whitespace is skipped and the longest sequence of non-whitespace characters matching an appropriate typed (©T©) value is read, converted into its corresponding internal form, and written into the ©T© variable.
+\textit{maximum} is the maximum number of characters read for the current value rather than the longest sequence.
 \begin{cfa}[belowskip=0pt]
 char ch;   char ca[3];   int i;   double d;   
@@ -4985 +5016 @@
 \end{cfa}
 Here, ©ca[0]© is type ©char©, so the width reads 3 characters \Textbf{without} a null terminator.
+If an input value is not found for a variable, the exception ©missing_data© is raised, and the input variable is unchanged.
 
 Note, input ©wdi© cannot be overloaded with output ©wd© because both have the same parameters but return different types.
@@ -4990 +5022 @@
 
 \item
-\Indexc{wdi}( maximum size, ©char s[]© )\index{manipulator!wdi@©wdi©}
-For type ©char *©, maximum is the maximum number of characters read for the current operation.
-Any number of non-whitespace characters, stopping at the first whitespace character found. A terminating null character is automatically added at the end of the stored sequence
+\Indexc{wdi}( $maximum\ size$, ©char s[]© )\index{manipulator!wdi@©wdi©}
+For type ©char *©, whitespace is skippped and the longest sequence of non-whitespace characters is read, without conversion, and written into the string variable (null terminated).
+$maximum\ size$ is the maximum number of characters in the string variable.
+If the non-whitespace sequence of input characters is greater than $maximum\ size - 1$ (null termination), the exception ©cstring_length© is raised.
 \begin{cfa}[belowskip=0pt]
-char cstr[10];
-sin | wdi( sizeof(cstr), cstr );
+char cs[10];
+sin | wdi( sizeof(cs), cs );
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
-®abcd1233.456E+2®
-\end{cfa}
-
-\item
-\Indexc{wdi}( maximum size, maximum read, ©char s[]© )\index{manipulator!wdi@©wdi©}
-For type ©char *©, maximum is the maximum number of characters read for the current operation.
+®012345678®
+\end{cfa}
+Nine non-whitespace character are read and the null character is added to make ten.
+
+\item
+\Indexc{wdi}( $maximum\ size$, $maximum\ read$, ©char s[]© )\index{manipulator!wdi@©wdi©}
+This manipulator is the same as the previous one, except $maximum$ $read$ is the maximum number of characters read for the current value rather than the longest sequence, where $maximum\ read$ $\le$ $maximum\ size$.
 \begin{cfa}[belowskip=0pt]
-char ch;   char ca[3];   int i;   double d;   
-sin | wdi( sizeof(ch), ch ) | wdi( sizeof(ca), ca[0] ) | wdi( 3, i ) | wdi( 8, d );  // c == 'a', ca == "bcd", i == 123, d == 345.6
+char cs[10];
+sin | wdi( sizeof(cs), 9, cs );
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
-®abcd1233.456E+2®
-\end{cfa}
-
-\item
-\Indexc{ignore}( reference-value )\index{manipulator!ignore@©ignore©}
-For all types, the data is read from the stream depending on the argument type but ignored, \ie it is not stored in the argument.
+®012345678®9
+\end{cfa}
+The exception ©cstring_length© is not raised, because the read stops reading after nine characters.
+
+\item
+\Indexc{getline}( $wdi\ manipulator$, ©const char delimiter = '\n'© )\index{manipulator!getline@©getline©}
+consumes the scanset ©"[^D]D"©, where ©D© is the ©delimiter© character, which reads all characters from the current input position to the delimiter character into the string (null terminated), and consumes and ignores the delimiter.
+If the delimiter character is omitted, it defaults to ©'\n'© (newline).
 \begin{cfa}[belowskip=0pt]
-double d;
-sin | ignore( d );  // d is unchanged
+char cs[10];
+sin | getline( wdi( sizeof(cs), cs ) );
+sin | getline( wdi( sizeof(cs), cs ), 'X' ); §\C{// X is the line delimiter}§
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
-®  -75.35e-4® 25
-\end{cfa}
-
-\item
-\Indexc{incl}( scanset, wdi-input-string )\index{manipulator!incl@©incl©}
-For C-string types only, the scanset matches any number of characters \emph{in} the set.
-Matching characters are read into the C input-string and null terminated.
+®abc ?? #@%®
+®abc ?? #@%X® w
+\end{cfa}
+The same value is read for both input strings.
+
+\item
+\Indexc{quoted}( ©char & ch©, ©const char Ldelimiter = '\''©, ©const char Rdelimiter = '\0'© )\index{manipulator!quoted@©quoted©}
+consumes the string ©"LCR"©, where ©L© is the left ©delimiter© character, ©C© is the value in ©ch©, and ©R© is the right delimiter character, which skips whitespace, consumes and ignores the left delimiter, reads a single character into ©ch©, and consumes and ignores the right delimiter (3 characters).
+If the delimit character is omitted, it defaults to ©'\''© (single quote).
 \begin{cfa}[belowskip=0pt]
-char s[10];
-sin | incl( "abc", s );
+char ch;
+sin | quoted( ch );   sin | quoted( ch, '"' );   sin | quoted( ch, '[', ']' );
+\end{cfa}
+\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
+®   'a'  "a"[a]®
+\end{cfa}
+
+\item
+\begin{sloppypar}
+\Indexc{quoted}( $wdi\ manipulator$, ©const char Ldelimiter = '\''©, ©const char Rdelimiter = '\0'© )\index{manipulator!quoted@©quoted©}
+consumes the scanset ©"L[^R]R"©, where ©L© is the left ©delimiter© character and ©R© is the right delimiter character, which skips whitespace, consumes and ignores the left delimiter, reads characters until the right-delimiter into the string variable (null terminated), and consumes and ignores the right delimiter.
+If the delimit character is omitted, it defaults to ©'\''© (single quote).
+\end{sloppypar}
+\begin{cfa}[belowskip=0pt]
+char cs[10];
+sin | quoted( wdi( sizeof(cs), cs ) ); §\C[3in]{// " is the start/end delimiter}§
+sin | quoted( wdi( sizeof(cs), cs ), '\'' ); §\C{// ' is the start/end delimiter}§
+sin | quoted( wdi( sizeof(cs), cs ), '[', ']' ); §\C{// [ is the start and ] is the end delimiter}\CRT§
+\end{cfa}
+\begin{cfa}[showspaces=true]
+®   "abc"  'abc'[abc]®
+\end{cfa}
+
+\item
+\Indexc{incl}( scanset, $wdi\ manipulator$ )\index{manipulator!incl@©incl©}
+consumes the scanset, which reads all the scanned characters into the string variable (null terminated).
+\begin{cfa}[belowskip=0pt]
+char cs[10];
+sin | incl( "abc", cs );
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
@@ -5036 +5102 @@
 
 \item
-\Indexc{excl}( scanset, wdi-input-string )\index{manipulator!excl@©excl©}
-For C-string types, the scanset matches any number of characters \emph{not in} the set.
-Non-matching characters are read into the C input-string and null terminated.
+\Indexc{excl}( scanset, $wdi\ manipulator$ )\index{manipulator!excl@©excl©}
+consumes the \emph{not} scanset, which reads all the scanned characters into the string variable (null terminated).
 \begin{cfa}[belowskip=0pt]
-char s[10];
-sin | excl( "abc", s );
+char cs[10];
+sin | excl( "abc", cs );
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
@@ -5047 +5112 @@
 \end{cfa}
 
-\Indexc{quoted}( char delimit, wdi-input-string )\index{manipulator!quoted@©quoted©}
-Is an ©excl© with scanset ©"delimit"©, which consumes all characters up to the delimit character.
-If the delimit character is omitted, it defaults to ©'\n'© (newline).
-
-\item
-\Indexc{getline}( char delimit, wdi-input-string )\index{manipulator!getline@©getline©}
-Is an ©excl© with scanset ©"delimit"©, which consumes all characters up to the delimit character.
-If the delimit character is omitted, it defaults to ©'\n'© (newline).
+\item
+\Indexc{ignore}( ©T & v© or ©const char cs[]© or $string\ manipulator$ )\index{manipulator!ignore@©ignore©}
+consumes the appropriate characters for the type and ignores them, so the input variable is unchanged.
+\begin{cfa}
+double d;
+char cs[10];
+sin | ignore( d );                                              §\C{// d is unchanged}§
+sin | ignore( cs );                                             §\C{// cs is unchanged, no wdi required}§
+sin | ignore( quoted( wdi( sizeof(cs), cs ) ) ); §\C{// cs is unchanged}§
+\end{cfa}
+\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
+®  -75.35e-4 25 "abc"®
+\end{cfa}
 \end{enumerate}