Index: doc/theses/andrew_beach_MMath/cfalab.sty =================================================================== --- doc/theses/andrew_beach_MMath/cfalab.sty (revision d286e94d541ce120a5b7bf87ada0ae8fd56f923b) +++ doc/theses/andrew_beach_MMath/cfalab.sty (revision 090a7c53db0d6d3e6332f455573fe3ab0c9f4336) @@ -40,4 +40,5 @@ \def\Cpp{C++} \def\lstinline{} + \def\code#1#2{#2} } }{} Index: doc/theses/andrew_beach_MMath/features.tex =================================================================== --- doc/theses/andrew_beach_MMath/features.tex (revision d286e94d541ce120a5b7bf87ada0ae8fd56f923b) +++ doc/theses/andrew_beach_MMath/features.tex (revision 090a7c53db0d6d3e6332f455573fe3ab0c9f4336) @@ -150,6 +150,9 @@ It is important to note that these are virtual members, not virtual methods of object-orientated programming, and can be of any type. -However, since \CFA has function pointers and they are allowed, virtual -members can be used to mimic virtual methods. +\CFA still supports virtual methods as a special case of virtual members. +Function pointers that take a pointer to the virtual type will be modified +with each level of inheritance so that refers to the new type. +This means an object can always be passed to a function in its virtual table +as if it were a method. Each virtual type has a unique id. Index: doc/theses/andrew_beach_MMath/implement.tex =================================================================== --- doc/theses/andrew_beach_MMath/implement.tex (revision d286e94d541ce120a5b7bf87ada0ae8fd56f923b) +++ doc/theses/andrew_beach_MMath/implement.tex (revision 090a7c53db0d6d3e6332f455573fe3ab0c9f4336) @@ -71,13 +71,36 @@ \begin{cfa} -struct /* type name */ { - /* parent type name */ const * parent; +struct TYPE_ID_TYPE { + PARENT_ID_TYPE const * parent; }; -__attribute__((section(".gnu.linkonce./* instance name */"))) -/* type name */ const /* instance name */ = { - &/* parent instance name */, +__attribute__((cfa_linkonce)) +TYPE_ID_TYPE const TYPE_ID_NAME = { + &PARENT_ID_NAME, }; \end{cfa} + +\subsubsection{cfa\_linkonce Attribute} +Another feature added to \CFA is a new attribute: \texttt{cfa\_linkonce}. +This attribute can be put on an object or function definition +(any global declaration with a name and a type). +This allows you to define that object or function multiple times. +All definitions should have the link-once attribute on them and all should +be identical. + +The simplist way to use it is to put a definition in a header where the +forward declaration would usually go. +This is how it is used for type-id instances. There was is no unique location +associated with a type except for the type definition which is in a header. +This allows the unique type-id object to be generated there. + +Internally @cfa_linkonce@ removes all @section@ attributes +from the declaration (as well as itself) and replaces them with +@section(".gnu.linkonce.NAME")@ where \texttt{NAME} is replaced by the +mangled name of the object. +The prefix \texttt{.gnu.linkonce} in section names is recognized by the +linker. If two of these sections with the same name, including everything +that comes after the special prefix, then only one will be used and the other +will be discarded. \subsection{Virtual Table} @@ -124,5 +147,4 @@ underlying object, access any of the virtual members and pass the object to any of the method-like virtual members. -\todo{Introduce method-like virtual members.} When a virtual table is declared the user decides where to declare it and its @@ -144,5 +166,41 @@ the instance is created as well. The definition of the virtual table is created at the definition of the main function. -\todo{Add an example with code snipits.} + +\begin{figure} +\begin{cfa} +coroutine Example { + // fields +} +\end{cfa} + +\begin{cfa} +__attribute__((cfa_linkonce)) +struct __cfatid_struct_CoroutineCancelled(Example) + __cfatid_CoroutineCancelled = { + &EXCEPTION_TYPE_ID, +}; +extern CoroutineCancelled_vtable _default_vtable_object_declaration; +extern CoroutineCancelled_vtable & _default_vtable; +\end{cfa} + +\begin{cfa} +void main(Example & this) { + // body +} +\end{cfa} + +\begin{cfa} +CoroutineCancelled_vtable _default_vtable_object_declaration = { + __cfatid_CoroutineCancelled, + // Virtual member initialization. +}; + +CoroutineCancelled_vtable & _default_vtable = + &_default_vtable_object_declaration; +\end{cfa} +\caption{Concurrency Transformations} +\label{f:ConcurrencyTransformations} +\end{figure} +\todo{Improve Concurrency Transformations figure.} \subsection{Virtual Cast} @@ -155,9 +213,7 @@ \begin{cfa} void * __cfa__virtual_cast( - struct __cfa__parent_vtable const * parent, - struct __cfa__parent_vtable const * const * child ); -\end{cfa} -\todo{Get rid of \_\_cfa\_\_parent\_vtable in the standard library and then -the document.} + struct __cfavir_type_td parent, + struct __cfavir_type_id const * child ); +\end{cfa} The type id of target type of the virtual cast is passed in as @parent@ and the cast target is passed in as @child@. @@ -572,5 +628,60 @@ the LSDA. Using this pattern, \CFA implements destructors with the cleanup attribute. -\todo{Add an example of the conversion from try statement to functions.} + +\begin{figure} +\begin{cfa} +try { + // TRY BLOCK +} catch (Exception1 * name1 ; check(name1)) { + // CATCH BLOCK 1 +} catch (Exception2 * name2) { + // CATCH BLOCK 2 +} +\end{cfa} + +\begin{cfa} +void try(void) { + // TRY BLOCK +} +int match(exception_t * __exception_inst) { + { + Exception1 * name1; + if (name1 = (virtual Exception1 *)__exception_inst && check(name1)) { + return 1; + } + } + { + Exception2 * name2; + if (name2 = (virtual Exception2 *)__exception_inst) { + return 2; + } + } + return 0; +} +void catch(exception_t * __exception_inst, int __handler_index) { + switch (__handler_index) { + case 1: + { + Exception1 * name1 = (virtual Exception1 *)__exception_inst; + // CATCH BLOCK 1 + } + return; + case 2: + { + Exception2 * name2 = (virtual Exception2 *)__exception_inst; + // CATCH BLOCK 2 + } + return; + } +} +{ + __cfaehm_try_terminate(try, catch, match); +} +\end{cfa} + +\caption{Termination Transformation} +\label{f:TerminationTransformation} +\todo*{Improve (compress?) Termination Transformations.} +\end{figure} \section{Resumption} @@ -606,5 +717,42 @@ the next clause the function returns false as no handler could be found. -\todo{Diagram showing a try statement being converted into resumption handlers.} +\begin{figure} +\begin{cfa} +try { + // TRY BLOCK +} catchResume (Exception1 * name1 ; check(name1)) { + // CATCH BLOCK 1 +} catchResume (Exception2 * name2) { + // CATCH BLOCK 2 +} +\end{cfa} + +\begin{cfa} +bool handle(exception_t * __exception_inst) { + { + Exception1 * name1; + if (name1 = (virtual Exception1 *)__exception_inst && check(name1)) { + // CATCH BLOCK 1 + return 1; + } + } + { + Exception2 * name2; + if (name2 = (virtual Exception2 *)__exception_inst) { + // CATCH BLOCK 2 + return 2; + } + } + return false; +} +struct __try_resume_node __resume_node + __attribute__((cleanup( __cfaehm_try_resume_cleanup ))); +__cfaehm_try_resume_setup( &__resume_node, handler ); +\end{cfa} + +\caption{Resumption Transformation} +\label{f:ResumptionTransformation} +\todo*{Improve (compress?) Resumption Transformations.} +\end{figure} % Recursive Resumption Stuff: @@ -625,5 +773,66 @@ stack -- the first one points over all the checked handlers -- and the ordering is maintained. -\todo{Add a diagram for resumption marking.} + +\begin{figure} +\begin{minipage}[l][][b]{0,2\textwidth} +\begin{verbatim} + + + X <- + | + V + X + | + V + X +\end{verbatim} +Initial State +\end{minipage} +\begin{minipage}[l][][b]{0,2\textwidth} +\begin{verbatim} + + + X + | + V + X <- + | + V + X +\end{verbatim} +Handler Found +\end{minipage} +\begin{minipage}[l][][b]{0,2\textwidth} +\begin{verbatim} + X <- + / +/ X +| | +\ V + X + | + V + X +\end{verbatim} +Try Block Added +\end{minipage} +\begin{minipage}[l][][b]{0,2\textwidth} +\begin{verbatim} + + + X <- + | + V + X + | + V + X +\end{verbatim} +Handler Done +\end{minipage} +\caption{Resumption Marking} +\label{f:ResumptionMarking} +\todo*{Convert Resumption Marking into a line figure.} +\end{figure} \label{p:zero-cost}