Changeset 6aa84e0 for doc

Timestamp:

Sep 20, 2021, 11:46:19 AM (3 years ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

ADT, ast-experimental, enum, forall-pointer-decay, master, pthread-emulation, qualifiedEnum

Children:

6cc87c0

Parents:

432bffe

Message:

Andrew MMath: Removed (updated one) the remaining \todo items.

Location:

doc/theses/andrew_beach_MMath

Files:

• existing.tex (modified) (1 diff)
• features.tex (modified) (3 diffs)
• implement.tex (modified) (2 diffs)
• intro.tex (modified) (1 diff)
• performance.tex (modified) (1 diff)

doc/theses/andrew_beach_MMath/existing.tex

@@ -49 +49 @@
 asterisk (@*@) is replaced with a ampersand (@&@);
 this includes cv-qualifiers (\snake{const} and \snake{volatile})
-%\todo{Should I go into even more detail on cv-qualifiers.}
 and multiple levels of reference.
 

doc/theses/andrew_beach_MMath/features.tex

@@ -129 +129 @@
 \section{Virtuals}
 \label{s:virtuals}
-%\todo{Maybe explain what "virtual" actually means.}
+A common feature in many programming languages is a tool to pair code
+(behaviour) with data.
+In \CFA this is done with the virtual system,
+which allow type information to be abstracted away, recovered and allow
+operations to be performed on the abstract objects.
+
 Virtual types and casts are not part of \CFA's EHM nor are they required for
 an EHM.
@@ -488 +493 @@
 Since it is so general, a more specific handler can be defined,
 overriding the default behaviour for the specific exception types.
-%\todo{Examples?}
+
+For example, consider an error reading a configuration file.
+This is most likely a problem with the configuration file @config_error@,
+but the function could have been passed the wrong file name @arg_error@.
+In this case the function could raise one exception and then, if it is
+unhandled, raise the other.
+This is not usual behaviour for either exception so changing the
+default handler will be done locally:
+\begin{cfa}
+{
+        void defaultTerminationHandler(config_error &) {
+                throw (arg_error){arg_vt};
+        }
+        throw (config_error){config_vt};
+}
+\end{cfa}
 
 \subsection{Resumption}
@@ -551 +571 @@
 the just handled exception came from, and continues executing after it,
 not after the try statement.
-%\todo{Examples?}
+
+For instance, a resumption used to send messages to the logger may not
+need to be handled at all. Putting the following default handler
+at the global scope can make handling the exception optional by default.
+\begin{cfa}
+void defaultResumptionHandler(log_message &) {
+    // Nothing, it is fine not to handle logging.
+}
+// ... No change at raise sites. ...
+throwResume (log_message){strlit_log, "Begin event processing."}
+\end{cfa}
 
 \subsubsection{Resumption Marking}

doc/theses/andrew_beach_MMath/implement.tex

@@ -50 +50 @@
 The problem is that a type ID may appear in multiple TUs that compose a
 program (see \autoref{ss:VirtualTable}), so the initial solution would seem
-to be make it external in each translation unit. Hovever, the type ID must
+to be make it external in each translation unit. However, the type ID must
 have a declaration in (exactly) one of the TUs to create the storage.
 No other declaration related to the virtual type has this property, so doing
@@ -167 +167 @@
 \subsection{Virtual Table}
 \label{ss:VirtualTable}
-%\todo{Clarify virtual table type vs. virtual table instance.}
 Each virtual type has a virtual table type that stores its type ID and
 virtual members.
-Each virtual type instance is bound to a table instance that is filled with
-the values of virtual members.
-Both the layout of the fields and their value are decided by the rules given
+An instance of a virtual type is bound to a virtual table instance,
+which have the values of the virtual members.
+Both the layout of the fields (in the virtual table type)
+and their value (in the virtual table instance) are decided by the rules given
 below.
 

doc/theses/andrew_beach_MMath/intro.tex

@@ -44 +44 @@
 \input{termhandle.pstex_t}
 \end{center}
-%\todo{What does the right half of termination.fig mean?}
+\todo*{Can I make the new diagrams fit the old style?}
 
 Resumption exception handling searches the stack for a handler and then calls

doc/theses/andrew_beach_MMath/performance.tex

@@ -312 +312 @@
 \CFA, \Cpp and Java.
 % To be exact, the Match All and Match None cases.
-%\todo{Not true in Python.}
-The most likely explanation is that, since exceptions
-are rarely considered to be the common case, the more optimized languages
-make that case expensive to improve other cases.
+The most likely explination is that,
+the generally faster languages have made ``common cases fast" at the expense
+of the rarer cases. Since exceptions are considered rare, they are made
+expensive to help speed up common actions, such as entering and leaving try
+statements.
+Python on the other hand, while generally slower than the other languages,
+uses exceptions more and has not scarified their performance.
 In addition, languages with high-level representations have a much
 easier time scanning the stack as there is less to decode.