Changeset ed4d7c1 for doc

Timestamp:

Aug 18, 2021, 6:57:55 PM (3 years ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

ADT, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, pthread-emulation, qualifiedEnum

Children:

1a6a6f2

Parents:

e3984a68

Message:

Andrew MMath: Updated features to include the new exception syntax.

File:

• doc/theses/andrew_beach_MMath/features.tex (modified) (2 diffs)

doc/theses/andrew_beach_MMath/features.tex

@@ -233 +233 @@
 through the object.
 
+This means virtual tables are declared and named in \CFA.
+They are declared as variables, using the type
+@vtable(VIRTUAL_TYPE)@ and any valid name. For example:
+\begin{cfa}
+vtable(virtual_type_name) table_name;
+\end{cfa}
+
+Like any variable they may be forward declared with the @extern@ keyword.
+Forward declaring virtual tables is relatively common.
+Many virtual types have an ``obvious" implementation that works in most
+cases.
+A pattern that has appeared in the early work using virtuals is to
+implement a virtual table with the the obvious definition and place a forward
+declaration of it in the header beside the definition of the virtual type.
+
+Even on the full declaration, no initializer should be used.
+Initialization is automatic.
+The type id and special virtual members ``size" and ``align" only depend on
+the virtual type, which is fixed given the type of the virtual table and
+so the compiler fills in a fixed value.
+The other virtual members are resolved, using the best match to the member's
+name and type, in the same context as the virtual table is declared using
+\CFA's normal resolution rules.
+
 While much of the virtual infrastructure is created, it is currently only used
 internally for exception handling. The only user-level feature is the virtual
@@ -247 +271 @@
 @EXPRESSION@ object, otherwise it returns @0p@ (null pointer).
 
-\section{Exception}
-% Leaving until later, hopefully it can talk about actual syntax instead
-% of my many strange macros. Syntax aside I will also have to talk about the
-% features all exceptions support.
-
-Exceptions are defined by the trait system; there are a series of traits, and
+\section{Exceptions}
+
+The syntax for declaring an exception is the same as declaring a structure
+except the keyword that is swapped out:
+\begin{cfa}
+exception TYPE_NAME {
+        FIELDS
+};
+\end{cfa}
+
+Fields are filled in the same way as a structure as well. However an extra
+field is added, this field contains the pointer to the virtual table.
+It must be explicitly initialised by the user when the exception is
+constructed.
+
+Here is an example of declaring an exception type along with a virtual table,
+assuming the exception has an ``obvious" implementation and a default
+virtual table makes sense.
+
+\begin{minipage}[t]{0.4\textwidth}
+Header:
+\begin{cfa}
+exception Example {
+        int data;
+};
+
+extern vtable(Example)
+        example_base_vtable;
+\end{cfa}
+\end{minipage}
+\begin{minipage}[t]{0.6\textwidth}
+Source:
+\begin{cfa}
+vtable(Example) example_base_vtable
+\end{cfa}
+\vfil
+\end{minipage}
+
+%\subsection{Exception Details}
+If one is only raising and handling exceptions, that is the only interface
+that is needed. However it is actually a short hand for a more complex
+trait based interface.
+
+The language views exceptions through a series of traits,
 if a type satisfies them, then it can be used as an exception. The following
 is the base trait all exceptions need to match.