+ they're much faster and can't fail.
+
+ When the target class is known statically, it's slightly more convenient to
+ use the @|SOD_CONVERT| macro than the @|sod_convert| function, since the
+ class object name is longer and uglier, and the macro returns a pointer of
+ the correct type.
+\end{describe*}
+
+
+\subsection{Instance lifecycle}
+\label{sec:runtime.object.lifecycle}
+
+The following macros and functions manage the standard steps along an
+instance's lifecycle.
+
+\subsubsection{Low-level operations}
+The following macros and functions are agnostic with respect to storage
+allocation strategies. They don't concern themselves with allocation or
+deallocation, and applications are free to use any suitable mechanism.
+
+\begin{describe*}
+ {\dhead{mac}[SOD_INIT]
+ {@<cls> *SOD_INIT(@<cls>, void *@<p>, @<keywords>);}
+ \dhead{fun}[sod_init]
+ {void *sod_init(const SodClass *@<cls>, void *@<p>, \dots);}
+ \dhead{fun}[sod_initv]
+ {void *sod_initv(const SodClass *@<cls>, void *@<p>, va_list @<ap>);}}
+ Imprints and initializes an instance of a class @<cls> in the storage
+ starting at address~@<p>.
+
+ The direct class for the new instance is specified as a class name to
+ @|SOD_INIT|, or a pointer to a class object to the functions.
+
+ Keyword arguments for the initialization message may be provided. The
+ @|SOD_INIT| macro expects a single preprocessor-time argument which is
+ a use of one of \descref*{mac}{KWARGS} or \descref{mac}{NO_KWARGS}; the
+ @|sod_init| function expects the keywords as a variable-length argument
+ tail; and @|sod_initv| expects the keywords to be passed indirectly,
+ through the captured argument-tail cursor @<ap>.
+
+ The return value is an instance pointer for the class @<cls>; the
+ @|SOD_INIT| macro will have converted it to the correct type, so it should
+ probably be used where possible. In fact, this is guaranteed to be equal
+ to @<p> by the layout rules described in
+ \xref{sec:structures.layout.instance}.
+\end{describe*}
+
+\begin{describe}{fun}[sod_teardown]{int sod_teardown(void *@<p>);}
+ Tears down an instance of a class, releasing any resources it holds.
+
+ This function is a very thin wrapper around sending the
+ \descref*{msg}{obj.teardown} message. See the description of that message
+ (\autopageref{msg:obj.teardown}) and \xref{sec:concepts.lifecycle.death}
+ for details.
+\end{describe}
+
+\subsubsection{Automatic storage duration}
+The following macro constructs an instance with automatic storage duration.
+
+\begin{describe}{mac}[SOD_DECL]{SOD_DECL(@<cls>, @<var>, @<keywords>);}
+ Declares and initializes an instance with automatic storage duration.
+
+ Given a class name @<cls> and an identifier @<var>, @|SOD_DECL| declares
+ @<var> to be a pointer to an instance of @<cls>. The instance is
+ initialized in the sense that its vtable and class pointers have been set
+ up, and slots for which initializers are defined are set to the appropriate
+ initial values.
+
+ Keyword arguments for the initialization message may be provided. The
+ macro expects a single preprocessor-time argument which is a use of one of
+ \descref*{mac}{KWARGS} or \descref{mac}{NO_KWARGS}.
+
+ The instance has automatic storage duration: pointers to it will become
+ invalid when control exits the scope of the declaration. If necessary, the
+ instance should be torn down before this happens, using the
+ \descref{fun}{sod_teardown}[function]. It may be appropriate to @|assert|
+ that the object is ready for deallocation at this time.
+
+ By default, this macro will abort the program if the size allocated for the
+ instance doesn't match the size required by the class object; set
+ \descref{feat}{SOD_RECKLESS} to inhibit this check.
+\end{describe}
+
+\subsubsection{Dynamic allocation}
+The following macros and functions deal with objects allocated from the
+standard C heap. They don't work in freestanding implementations where
+@|malloc| and @|free| are not available.
+
+\begin{describe*}
+ {\dhead{mac}[SOD_MAKE]{@<cls> *SOD_MAKE(@<cls>, @<keywords>);}
+ \dhead{fun}[sod_make]{void *sod_make(const SodClass *@<cls>, \dots);}
+ \dhead{fun}[sod_makev]
+ {void *sod_makev(const SodClass *@<cls>, va_list @<ap>);}}
+ Constructs and returns a pointer to a new instance of @<cls>.
+
+ The direct class for the new instance is specified as a class name to
+ @|SOD_MAKE|, or a class object to the functions.
+
+ Keyword arguments for the initialization message may be provided. The
+ @|SOD_MAKE| macro expects a single preprocessor-time argument which is
+ a use of one of \descref*{mac}{KWARGS} or \descref{mac}{NO_KWARGS}; the
+ @|sod_make| function expects the keywords as a variable-length argument
+ tail; and @|sod_makev| expects the keywords to be passed indirectly,
+ through the captured argument-tail cursor @<ap>.
+
+ Storage for the new instance will have been allocated using the standard
+ @|malloc| function. The easiest way to destroy the instance, when it is no
+ longer needed, is probably to call the
+ \descref{fun}{sod_destroy}[function].
+
+ The return value is an instance pointer for the class @<cls>; the
+ @|SOD_MAKE| macro will have converted it to the correct type, so it should
+ probably be used where possible.
+\end{describe*}
+
+\begin{describe}{fun}[sod_destroy]{int sod_destroy(void *@<p>);}
+ Tears down and frees an instance allocated using @|malloc|.
+
+ The pointer @<p> should be an instance pointer, i.e., a pointer to any of
+ an instance's chains. The instance is torn down, by sending it the
+ \descref{msg}{obj.teardown}[message]. If the instance reports itself ready
+ for deallocation, then its storage is released using @|free|. The return
+ value is the value returned by the @|obj.teardown| message.