doc/clang.tex: Squish the `\desclabel' mess for simple C types.

[sod] / doc / clang.tex

diff --git a/doc/clang.tex b/doc/clang.tex
index f5ccbb1..0213269 100644 (file)
--- a/doc/clang.tex
+++ b/doc/clang.tex
@@ -91,6 +91,9 @@ similar names.
 Neither generic function defines a default primary method; subclasses of
 @|c-type| must define their own methods in order to print correctly.
 
+\begin{describe}{fun}{c-name-case @<name> @> @<string>}
+\end{describe}
+
 
 \subsection{The C type root class} \label{sec:clang.c-types.root}
 
@@ -347,12 +350,16 @@ methods to \descref{gf}{c-qualifier-keyword}.
   The class @|qualifiable-c-type| is abstract.
 \end{describe}
 
+\begin{describe}{fun}
+    {canonify-qualifiers @<qualifiers> @> @<canonfied-qualifiers>}
+\end{describe}
+
 \begin{describe}{gf}{c-type-qualifiers @<c-type> @> @<list>}
   Returns the qualifiers of the @|qualifiable-c-type| instance @<c-type> as
   an immutable list.
 \end{describe}
 
-\begin{describe}{fun}{qualify-type @<c-type> @<qualifiers> @> @<c-type>}
+\begin{describe}{fun}{qualify-c-type @<c-type> @<qualifiers> @> @<c-type>}
   The argument @<c-type> must be an instance of @|qualifiable-c-type|,
   currently bearing no qualifiers, and @<qualifiers> a list of qualifier
   keywords.  The result is a C type object like @<c-type> except that it
@@ -501,16 +508,13 @@ In Sod, the leaf types are
   Two simple type objects are equal if and only if they have @|string=| names
   and matching qualifiers.
 
-  \def\x#1{\desclabel{const}{#1}}
-  \x{c-type-bool} \x{c-type-char} \x{c-type-wchar-t} \x{c-type-signed-char}
-  \x{c-type-unsigned-char} \x{c-type-short} \x{c-type-unsigned-short}
-  \x{c-type-int} \x{c-type-unsigned} \x{c-type-long} \x{c-type-unsigned-long}
-  \x{c-type-long-long} \x{c-type-unsigned-long-long} \x{c-type-size-t}
-  \x{c-type-ptrdiff-t} \x{c-type-float} \x{c-type-double}
-  \x{c-type-long-double} \x{c-type-float-imaginary}
-  \x{c-type-double-imaginary} \x{c-type-long-double-imaginary}
-  \x{c-type-float-complex} \x{c-type-double-complex}
-  \x{c-type-long-double-complex} \x{c-type-va-list} \x{c-type-void}
+  \def\x#1{\desclabel{const}{c-type-#1}}
+  \x{bool} \x{char} \x{wchar-t} \x{signed-char} \x{unsigned-char} \x{short}
+  \x{unsigned-short} \x{int} \x{unsigned} \x{long} \x{unsigned-long}
+  \x{long-long} \x{unsigned-long-long} \x{size-t} \x{ptrdiff-t} \x{float}
+  \x{double} \x{long-double} \x{float-imaginary} \x{double-imaginary}
+  \x{long-double-imaginary} \x{float-complex} \x{double-complex}
+  \x{long-double-complex} \x{va-list} \x{void}
   A number of symbolic type specifiers for builtin types are predefined as
   shown in \xref{tab:codegen.c-types.simple}.  These are all defined as if by
   @|define-simple-c-type|, so can be used to construct qualified types.
@@ -620,6 +624,14 @@ In Sod, the leaf types are
   structs and unions.
 \end{boxy}
 
+\begin{describe}{gf}{c-type-tag @<c-type> @> @<keyword>}
+\end{describe}
+
+\begin{describe}{fun}
+    {make-c-tagged-type @<kind> @<tag> \&optional @<qualifiers>
+      @> @<tagged-type>}
+\end{describe}
+
 \begin{describe}{gf}{c-tagged-type-kind @<c-type> @> @<keyword>}
   Returns a keyword classifying the tagged @<c-type>: one of @|:enum|,
   @|:struct| or @|:union|.  User-defined subclasses of @|tagged-c-type|
@@ -646,6 +658,7 @@ In Sod, the leaf types are
   interned) enumerated type with the given @<tag> and @<qualifier>s (all
   evaluated).
 \end{describe}
+
 \begin{describe}{fun}
     {make-enum-type @<tag> \&optional @<qualifiers> @> @<c-enum-type>}
   Return the (unique interned) C type object for the enumerated C type whose
@@ -661,6 +674,7 @@ In Sod, the leaf types are
   interned) structured type with the given @<tag> and @<qualifier>s (all
   evaluated).
 \end{describe}
+
 \begin{describe}{fun}
     {make-struct-type @<tag> \&optional @<qualifiers> @> @<c-struct-type>}
   Return the (unique interned) C type object for the structured C type whose
@@ -964,9 +978,9 @@ function type is the type of the function's return value.
 
   Keyword functions are never considered to be the same as ordinary
   functions.  Two keyword function types are considered to be the same if
-  their return types are the same, and their positional argument lists consist of
-  arguments with the same type, in the same order: the keyword arguments
-  accepted by the functions is not significant.
+  their return types are the same, and their positional argument lists
+  consist of arguments with the same type, in the same order: the keyword
+  arguments accepted by the functions is not significant.
 
   Keyword functions are constructed using an extended version of the @|fun|
   specifier used for ordinary C function types.  The extended syntax is as
@@ -1011,7 +1025,12 @@ function type is the type of the function's return value.
 
 \begin{describe}{gf}
     {c-function-arguments @<c-function-type> @> @<arguments>}
-  Return the arguments list of the @<c-function-type>.
+  Return the (non-keyword) argument list of the @<c-function-type>.
+\end{describe}
+
+\begin{describe}{gf}
+    {c-function-keywords @<c-function-type> @> @<keywords>}
+  Return the keyword-argument list of the @<c-function-type>.
 \end{describe}
 
 \begin{describe}{fun}
@@ -1177,6 +1196,9 @@ Temporary names are represented by objects which implement a simple protocol.
   subclasses, but is also usable on its own.
 \end{describe}
 
+\begin{describe}{gf}{temp-tag @<name> @> @<tag>}
+\end{describe}
+
 \begin{describe}{meth}{temporary-name}
     {commentify-argument-name (@<name> temporary-name) @> nil}
 \end{describe}
@@ -1398,8 +1420,11 @@ Temporary names are represented by objects which implement a simple protocol.
 \begin{describe}{cls}{c-fragment () \&key :location :text}
 \end{describe}
 
-\begin{describe}{gf}{c-fragment-text @<fragment> @> @<string>}
-\end{describe}
+\begin{describe*}
+    {\dhead{gf}{c-fragment-text @<fragment> @> @<string>}
+     \dhead{meth}{c-fragment}
+       {file-location (@<fragment> c-fragment) @> @<floc>}}
+\end{describe*}
 
 \begin{describe}{fun}
     {scan-c-fragment @<scanner> @<end-chars>