Changes in doc/theses/jiada_liang_MMath/relatedwork.tex [f632117:566cc33]

File:

• doc/theses/jiada_liang_MMath/relatedwork.tex (modified) (6 diffs)

doc/theses/jiada_liang_MMath/relatedwork.tex

@@ -18 +18 @@
 \end{comment}
 
-Enumeration-like features exist in many popular programming languages, both past and present, \eg Pascal~\cite{Pascal}, Ada~\cite{Ada}, \Csharp~\cite{Csharp}, OCaml~\cite{OCaml} \CC, Go~\cite{Go}, Haskell~\cite{Haskell}, Java~\cite{Java}, Modula-3~\cite{Modula-3}, Rust~\cite{Rust}, Swift~\cite{Swift}, Python~\cite{Python}.
+Enumeration types exist in many popular programming languages, both past and present, \eg Pascal~\cite{Pascal}, Ada~\cite{Ada}, \Csharp~\cite{Csharp}, OCaml~\cite{OCaml} \CC, Go~\cite{Go}, Java~\cite{Java}, Modula-3~\cite{Modula-3}, Rust~\cite{Rust}, Swift~\cite{Swift}, Python~\cite{Python}.
 Among theses languages, there are a large set of overlapping features, but each language has its own unique extensions and restrictions.
 
@@ -24 +24 @@
 \label{s:Pascal}
 
-Classic Pascal has the \lstinline[language=Pascal]{const} aliasing declaration binding a name to a constant literal/expression.
+Classic Pascal has the \lstinline[language=pascal]{const} declaration binding a name to a constant literal/expression.
 \begin{pascal}
 const one = 0 + 1;   Vowels = set of (A,E,I,O,U);   NULL = NIL;
                  PI = 3.14159;   Plus = '+';   Fred = 'Fred';
 \end{pascal}
-As stated, this mechanism is not an enumeration because there is no specific type (pseudo enumeration).
+This mechanism is not an enumeration because there is no specific type (pseudo enumeration).
 Hence, there is no notion of a (possibly ordered) set, modulo the \lstinline[language=pascal]{set of} type.
 The type of each constant name (enumerator) is inferred from the constant-expression type.
@@ -139 +139 @@
 Ops : array( 0..3 ) of Operator;
 Ops := @"+-*/"@;            -- string assignment to array elements
-Ops := "+-" @&@ "*/";   -- string concatenation and assignment
+Ops := @"+-" & "*/"@;   -- string concatenation and assignment
 \end{ada}
 Ada's @Character@ type is defined as a character enumeration across all Latin-1 characters.
@@ -215 +215 @@
 \label{s:C++RelatedWork}
 
-\CC enumeration is largely backwards compatible with C, so it inherited C's enumerations with some modifications and additions.
-
-\CC has aliasing using @const@ declarations, like C \see{\VRef{s:Cconst}}, with type inferencing, plus static/dynamic initialization.
-(Note, a \CC @constexpr@ declaration is the same @const@ with the restriction that the initialization is a compile-time expression.)
+\CC has the equivalent of Pascal typed @const@ declarations \see{\VRef{s:Pascal}}, with static and dynamic initialization.
 \begin{c++}
-const @auto@ one = 0 + 1;                               $\C{// static initialization}$
-const @auto@ NIL = nullptr;
-const @auto@ PI = 3.14159;
-const @auto@ Plus = '+';
-const @auto@ Fred = "Fred";
-const @auto@ Mon = 0, Tue = Mon + 1, Wed = Tue + 1, Thu = Wed + 1, Fri = Thu + 1,
+const auto one = 0 + 1;                                 $\C{// static initialization}$
+const auto NULL = nullptr;
+const auto PI = 3.14159;
+const auto Plus = '+';
+const auto Fred = "Fred";
+const auto Mon = 0, Tue = Mon + 1, Wed = Tue + 1, Thu = Wed + 1, Fri = Thu + 1,
                                 Sat = Fri + 1, Sun = Sat + 1;
-void foo() {
-        const @auto@ r = random();                      $\C{// dynamic initialization}$
-        int va[r];                                                      $\C{// VLA, auto scope only}$
-}
+int sa[Sun];
+const auto r = random();                                $\C{// dynamic initialization}$
+int da[r];                                                              $\C{// VLA}$
 \end{c++}
 Statically initialized identifiers may appear in any constant-expression context, \eg @case@.
-Dynamically initialized identifiers may appear as array dimensions in @g++@, which allows variable-sized arrays.
-Interestingly, global \CC @const@ declarations are implicitly marked @static@ (@r@, read-only local, rather than @R@, read-only external)
+Dynamically intialized identifiers may appear as array dimensions in @g++@, which allows variable-sized arrays.
+Interestingly, global \CC @const@ declarations are implicitly marked @static@ (@r@ rather than @R@).
 \begin{c++}
 $\$$ nm test.o
 0000000000000018 @r@ Mon
 \end{c++}
-whereas C @const@ declarations without @static@ are marked @R@.
-
-The following non-backwards compatible changes are made \see{\cite[\S~7.2]{ANSI98:C++}}.
+
+\CC enumeration is largely backwards compatible with C, so it inherited C's enumerations.
+However, the following non-backwards compatible changes are made.
+
 \begin{cquote}
-Change: \CC objects of enumeration type can only be assigned values of the same enumeration type.
+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:
@@ -257 +254 @@
 
 \begin{cquote}
-Change: In \CC, the type of an enumerator is its enumeration.
+7.2 Change: In \CC, the type of an enumerator is its enumeration.
 In C, the type of an enumerator is @int@. \\
 Example:
@@ -272 +269 @@
 Taking the size of an enumerator is not a common C coding practice.
 \end{cquote}
+
 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@.