\xref{sec:structures.layout.additional} for the formal description.
%%%--------------------------------------------------------------------------
+\section{Keyword arguments} \label{sec:concepts.keywords}
+
+In standard C, the actual arguments provided to a function are matched up
+with the formal arguments given in the function definition according to their
+ordering in a list. Unless the (rather cumbersome) machinery for dealing
+with variable-length argument tails (@|<stdarg.h>|) is used, exactly the
+correct number of arguments must be supplied, and in the correct order.
+
+A \emph{keyword argument} is matched by its distinctive \emph{name}, rather
+than by its position in a list. Keyword arguments may be \emph{omitted},
+causing some default behaviour by the function. A function can detect
+whether a particular keyword argument was supplied: so the default behaviour
+need not be the same as that caused by any specific value of the argument.
+
+Keyword arguments can be provided in three ways.
+\begin{enumerate}
+\item Directly, as a variable-length argument tail, consisting (for the most
+ part) of alternating keyword names, as pointers to null-terminated strings,
+ and argument values, and terminated by a null pointer. This is somewhat
+ error-prone, and the support library defines some macros which help ensure
+ that keyword argument lists are well formed.
+\item Indirectly, through a @|va_list| object capturing a variable-length
+ argument tail passed to some other function. Such indirect argument tails
+ have the same structure as the direct argument tails described above.
+ Because @|va_list| objects are hard to copy, the keyword-argument support
+ library consistently passes @|va_list| objects \emph{by reference}
+ throughout its programming interface.
+\item Indirectly, through a vector of @|struct kwval| objects, each of which
+ contains a keyword name, as a pointer to a null-terminated string, and the
+ \emph{address} of a corresponding argument value. (This indirection is
+ necessary so that the items in the vector can be of uniform size.)
+ Argument vectors are rather inconvenient to use, but are the only practical
+ way in which a caller can decide at runtime which arguments to include in a
+ call, which is useful when writing wrapper functions.
+\end{enumerate}
+
+Keyword arguments are provided as a general feature for C functions.
+However, Sod has special support for messages which accept keyword arguments
+(\xref{sec:concepts.methods.keywords}).
+
+%%%--------------------------------------------------------------------------
\section{Messages and methods} \label{sec:concepts.methods}
Objects can be sent \emph{messages}. A message has a \emph{name}, and
$M$ is a more (resp.\ less) specific superclass of~$C$ than the class
defining $N$.
-\subsection{The standard method combination}
-\label{sec:concepts.methods.standard}
-
+\subsubsection{The standard method combination}
The default method combination is called the \emph{standard method
combination}; other method combinations are useful occasionally for special
effects. The standard method combination accepts four direct method roles,
@|CALL_NEXT_METHOD| will pass along the updated values, rather than the
original ones.
-\subsection{Aggregating method combinations}
-\label{sec:concepts.methods.aggregating}
-
+\subsubsection{Aggregating method combinations}
A number of other method combinations are provided. They are called
`aggregating' method combinations because, instead of invoking just the most
specific primary method, as the standard method combination does, they invoke
There is also a @|custom| aggregating method combination, which is described
in \xref{sec:fixme.custom-aggregating-method-combination}.
+
+\subsection{Messages with keyword arguments}
+\label{sec:concepts.methods.keywords}
+
+A message or a direct method may declare that it accepts keyword arguments.
+A message which accepts keyword arguments is called a \emph{keyword message};
+a direct method which accepts keyword arguments is called a \emph{keyword
+method}.
+
+While method combinations may set their own rules, usually keyword methods
+can only be defined on keyword messages, and all methods defined on a keyword
+message must be keyword methods. The direct methods defined on a keyword
+message may differ in the keywords they accept, both from each other, and
+from the message. If two superclasses of some common class both define
+keyword methods on the same message, and the methods both accept a keyword
+argument with the same name, then these two keyword arguments must also have
+the same type. Different applicable methods may declare keyword arguments
+with the same name but different defaults; see below.
+
+The keyword arguments acceptable in a message sent to an object are the
+keywords listed in the message definition, together with all of the keywords
+accepted by any applicable method. There is no easy way to determine at
+runtime whether a particular keyword is acceptable in a message to a given
+instance.
+
+At runtime, a direct method which accepts one or more keyword arguments
+receives an additional argument named @|suppliedp|. This argument is a small
+structure. For each keyword argument named $k$ accepted by the direct
+method, @|suppliedp| contains a one-bit-wide bitfield member of type
+@|unsigned|, also named $k$. If a keyword argument named $k$ was passed in
+the message, then @|suppliedp.$k$| is one, and $k$ contains the argument
+value; otherwise @|suppliedp.$k$| is zero, and $k$ contains the default value
+from the direct method definition if there was one, or an unspecified value
+otherwise.
+
%%%--------------------------------------------------------------------------
\section{Metaclasses} \label{sec:concepts.metaclasses}
~mdw / sod / blobdiff