Changes in / [7329b0a:3da5885]

Location:

doc

Files:

• proposals/enum.tex (modified) (8 diffs)
• uC++toCFA/Makefile (modified) (1 diff)
• uC++toCFA/uC++toCFA.tex (modified) (5 diffs)

doc/proposals/enum.tex

@@ -7 +7 @@
 \usepackage{graphics}
 \usepackage{xspace}
+\usepackage{relsize}                                                                    % must be after change to small or selects old size
 \usepackage{calc}                                                                               % latex arithmetic
 
@@ -64 +65 @@
 \newcommand{\CCIcon}{\textrm{C}\kern-.1em\hbox{+\kern-.25em+}} % C++ icon
 \newcommand{\CC}[1][]{\protect\CCIcon{#1}\xspace}               % C++ symbolic name
+\newcommand{\Csharp}{C\raisebox{-0.7ex}{\relsize{2}$^\sharp$}\xspace} % C# symbolic name
 \newcommand{\PAB}[1]{{\color{red}PAB: #1}}
 
@@ -110 +112 @@
 \begin{abstract}
 An enumeration is a type defining an ordered set of named constant values, where a name abstracts a value, e.g., @PI@ versus @3.145159@.
-C and \CC restrict an enumeration type to the integral type @signed int@, meaning enumeration names bind to integer constants.
+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.
@@ -132 +134 @@
 The C-Style enumeration has the following syntax and semantics.
 \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}}
+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@.
@@ -190 +192 @@
 A \CFA-enum can be scoped, meaning the enumerator constants are not projected into the enclosing scope.
 \begin{lstlisting}
-enum Colour( char * ) @!@ { ... };
+enum Weekday @!@ { /* as above */ };
+enum Colour( char * ) @!@ { /* as above */ };
 \end{lstlisting}
 where the @'!'@ implies the enumerators are \emph{not} projected.
@@ -197 +200 @@
 % $$<qualified\_expression> := <enum\_type>.<enumerator>$$
 \begin{lstlisting}
-Colour colour = @Colour.@Red;                   $\C{// qualification}$
+Weekday weekday = @Weekday.Monday@;             $\C{// qualification}$
+Colour colour = @Colour.@Red;
 colour = @Colour.@Blue;
 \end{lstlisting}
 
 \subsection{Enumeration Pseudo-functions}
-Pseudo-functions are function-like operators that do not result in any run-time computations, i.e., like @sizeof@. Instead, the call to functions will be substituted into other expressions in compilation time.
+
+Pseudo-functions are function-like operators that do not result in any run-time computations, i.e., like @sizeof@.
+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}
@@ -212 +218 @@
 \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. 
+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. 
 
 \subsubsection{\lstinline{enumerate()}}
@@ -920 +927 @@
 \section{Related Work}
 
+Enumerations exist in many popular programming languages, e.g., Pascal, Ada, \Csharp, \CC, Go, Java, Modula-3, Rust, Swift, Python, and Algebraic data type in functional programming.
+There are a large set of overlapping features for all the languages, but each language has its own unique restrictions and extensions.
+
+\subsection{Pascal}
+
+\subsection{Ada}
+
+\subsection{\Csharp}
+
+\subsection{\CC}
+
+Because \CC is backwards compatible with C, 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.
+
+\CC{11} extended enumeration with a scoped enumeration, \lstinline[language=c++]{enum class} (or \lstinline[language=c++]{enum struct}), where the enumerators are local to the enumeration and are accessed using type qualification, e.g., @Weekday::Monday@.
+\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 that is large enough to hold all enumerated values; it does not have to be the smallest possible type.
+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 };
+\end{lstlisting}
+
+\subsection{Go}
+
+\subsection{Java}
+
+\subsection{Modula-3}
+
+\subsection{Rust}
+
+\subsection{Swift}
+
+\subsection{Python}
+
+\subsection{Algebraic Data Type}
 
 \end{document}

doc/uC++toCFA/Makefile

@@ -8 +8 @@
 BibTeX = BIBINPUTS=../bibliography: && export BIBINPUTS && bibtex
 
-MAKEFLAGS = --no-print-directory --silent #
+MAKEFLAGS = --no-print-directory # --silent
 VPATH = ${Build} ${Figures}
 

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

@@ -11 +11 @@
 %% Created On       : Wed Apr  6 14:53:29 2016
 %% Last Modified By : Peter A. Buhr
-%% Last Modified On : Sun Oct 15 23:09:58 2023
-%% Update Count     : 5926
+%% Last Modified On : Thu Jan 11 14:46:14 2024
+%% Update Count     : 5942
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
@@ -428 +428 @@
 \begin{uC++}
 struct S {
-        int i = 0;
+        int i = 0;  // cheat, implicit default constructor
         int setter( int j ) { int t = i; i = j; return t; }
         int getter() { return i; }
@@ -434 +434 @@
 
 S s;
-@s.@setter( 3 );  // object-oriented call
+@s.@setter( 3 );  // object-oriented calls
 int k = @s.@getter();
 \end{uC++}
@@ -442 +442 @@
         int i;
 };
-void ?{}( S & s ) { s.i = 0; }
+void ?{}( S & s ) { s.i = 0; } // explicit default constructor
 int setter( @S & s,@ int j ) @with(s)@ { int t = i; i = j; return t; }
 int getter( @S & s@ ) @with(s)@ { return i; }
 S s;
-setter( @s,@ 3 );  // normal routine call
+setter( @s,@ 3 );  // normal routine calls
 int k = getter( @s@ );
 \end{cfa}
@@ -458 +458 @@
 \begin{tabular}{l|l}
 \begin{uC++}
+
 struct S {
         int i;
-        S( int i ) { S::i = i; cout << S::i << endl; }
-};
-@uNoCtor<S>@ s[10];
+        S( int i ) { S::i = i; cout << "ctor " << S::i << endl; }
+        ~S() { S::i = i; cout << "dtor " << S::i << endl; }
+};
 int main() {
-        for ( int i = 0; i < 10; i += 1 ) {
-                s[i].ctor( i );
-        }
-        for ( int i = 0; i < 10; i += 1 ) {
-                cout << s[i]@->@i << endl;
-        }
-}
-\end{uC++}
-&
-\begin{cfa}
+        enum { N = 5 };
+        @uNoCtor<S>@ s[N];   // no constructor calls
+        for ( int i = 0; i < N; i += 1 ) @s[i].ctor( i )@;
+        for ( int i = 0; i < N; i += 1 ) cout << s[i]@->@i << endl;
+}
+\end{uC++}
+&
+\begin{cfa}
+#include @<raii.hfa>@          // uninit
 struct S {
         int i;
 };
-void ?{}( S & s, int i ) { s.i = i; sout | s.i; }
-S s[10] @$\color{red}@$= {}@;
+void ?{}( S & s, int i ) { s.i = i; sout | "ctor" | s.i; }
+void ^?{}( S & s ) { sout | "dtor" | s.i; }
 int main() {
-        for ( i; 10 ) {
-                ?{}( s[i], i );  // call constructor
-        }
-        for ( i; 10 ) {
-                sout | s[i]@.@i; // dot not arrow
-        }
+        enum { N = 5 };
+        @uninit(S)@ s[N];   // no constructor calls
+        for ( i; N ) @s[i]{ i }@;
+        for ( i; N ) sout | s[i]@.@i;
 }
 \end{cfa}