X-Git-Url: https://git.distorted.org.uk/~mdw/sod/blobdiff_plain/e048fa5955190d01ea6069e0d0705279108b6851..4b3a72700ae8799ba6ba07969e2677f2168d32a9:/doc/clang.tex

diff --git a/doc/clang.tex b/doc/clang.tex
index 0047efb..d35387d 100644
--- 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}
 
@@ -318,11 +321,11 @@ is shown in \xref{tab:clang.ctypes.qual}.
 
 \begin{table}
   \begin{tabular}[C]{*2{>{\codeface}l}l}                           \hlx*{hv}
-    \thd{\textbf{C name}}       & \thd{\textbf{Lisp name}}      \\ \hlx{vhv}
-    _Atomic                     & :atomic                       \\
-    const                       & :const                        \\
-    restrict                    & :restrict                     \\
-    volatile                    & :volatile                     \\ \hlx*{vh}
+    \thd{C name}        & \thd{Lisp name}                       \\ \hlx{vhv}
+    _Atomic             & :atomic                               \\
+    const               & :const                                \\
+    restrict            & :restrict                             \\
+    volatile            & :volatile                             \\ \hlx*{vh}
   \end{tabular}
   \caption{C and Lisp qualifier names} \label{tab:clang.ctypes.qual}
 \end{table}
@@ -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,16 @@ 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}
+  \crossproduct\x{{{int}{uint}}{{}{-least}{-fast}}{{8}{16}{32}{64}}{{-t}}}
+  \crossproduct\x{{{int}{uint}}{{ptr}{max}}{{-t}}}
+
   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.
@@ -545,6 +552,18 @@ In Sod, the leaf types are
                           @|ullong|                             \\ \hlx{v}
     @|size_t|           & @|size-t|                             \\ \hlx{}
     @|ptrdiff_t|        & @|ptrdiff-t|                          \\ \hlx{v}
+    @|int$n$_t|         & @|int$n$-t|
+                          (for $n \in \{ @|8|, @|16|, @|32|, @|64| \}$)
+                                                                \\ \hlx{}
+    @|uint$n$_t|        & @|uint$n$-t|                          \\ \hlx{}
+    @|int_least$n$_t|   & @|int_least$n$-t|                     \\ \hlx{}
+    @|uint_least$n$_t|  & @|uint_least$n$-t|                    \\ \hlx{}
+    @|int_fast$n$_t|    & @|int_fast$n$-t|                      \\ \hlx{}
+    @|uint_fast$n$_t|   & @|uint_fast$n$-t|                     \\ \hlx{v}
+    @|intptr_t|         & @|intptr-t|                           \\ \hlx{}
+    @|uintptr_t|        & @|uintptr-t|                          \\ \hlx{}
+    @|intmax_t|         & @|intmax-t|                           \\ \hlx{}
+    @|uintmax_t|        & @|uintmax-t|                          \\ \hlx{v}
     @|float|            & @|float|                              \\ \hlx{}
     @|double|           & @|double|                             \\ \hlx{}
     @|long double|      & @|long-double|                        \\ \hlx{v}
@@ -620,6 +639,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|
@@ -1016,6 +1043,11 @@ function type is the type of the function's return value.
   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}
     {commentify-function-type @<c-function-type> @> @<commentified-c-type>}
   Return a commentified version of the @<c-function-type>.
@@ -1179,17 +1211,20 @@ 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}
 
 \begin{table}
   \begin{tabular}[C]{*2{>{\codeface}l}}                            \hlx*{hv}
-    \thd{\textbf{Class}} & \thd{\textbf{Name format}}           \\ \hlx{vhv}
-    temporary-name              & @<tag>                        \\
-    temporary-argument          & sod__a@<tag>                  \\
-    temporary-function          & sod__f@<tag>                  \\
-    temporary-variable          & sod__v@<tag>                  \\ \hlx*{vh}
+    \thd{Class}         & \thd{Name format}                     \\ \hlx{vhv}
+    temporary-name      & @<tag>                                \\
+    temporary-argument  & sod__a@<tag>                          \\
+    temporary-function  & sod__f@<tag>                          \\
+    temporary-variable  & sod__v@<tag>                          \\ \hlx*{vh}
   \end{tabular}
   \caption{Temporary name formats}
   \label{tab:codegen.codegen.temps-format}
@@ -1214,10 +1249,10 @@ Temporary names are represented by objects which implement a simple protocol.
   \def\x#1{\desclabel{var}{#1}}
   \x{*sod-ap*} \x{*sod-master-ap*} \x{*null-pointer*}
   \begin{tabular}[C]{*2{>{\codeface}l}}                            \hlx*{hv}
-    \thd{\textbf{Variable}} & \thd{\textbf{Name format}}        \\ \hlx{vhv}
-    {}*sod-ap*                  & sod__ap                       \\
-    {}*sod-master-ap*           & sod__master_ap                \\
-    {}*null-pointer*            & NULL                          \\ \hlx*{vh}
+    \thd{Variable}      & \thd{Name format}                     \\ \hlx{vhv}
+    {}*sod-ap*          & sod__ap                               \\
+    {}*sod-master-ap*   & sod__master_ap                        \\
+    {}*null-pointer*    & NULL                                  \\ \hlx*{vh}
   \end{tabular}
   \caption{Well-known temporary names}
   \label{tab:codegen.codegen.well-known-temps}
@@ -1253,8 +1288,8 @@ Temporary names are represented by objects which implement a simple protocol.
 \begin{table}
   \begin{tabular}[C]{ll>{\codeface}l}                              \hlx*{hv}
     \thd{Class name} &
-    \thd{Arguments} &
-    \thd{Output format}                                         \\ \hlx{vhv}
+                  \thd{Arguments} &
+                                             \thd{Output format}\\ \hlx{vhv}
     @|var|      & @<name> @<type> @|\&optional| @<init>
                                            & @<type> @<name> @[= @<init>@];
                                                                 \\ \hlx{v}
@@ -1300,7 +1335,7 @@ Temporary names are represented by objects which implement a simple protocol.
 
 \begin{describe*}
     {\dhead*{cls}{@<code>-inst (inst) \&key \dots}
-     \dhead*{fn}{make-@<code>-inst \dots}
+     \dhead*{fun}{make-@<code>-inst \dots}
      \dhead*{gf}{inst-@<slot> @<inst> @> @<value>}}
   \def\instclass#1#2#3{%
     #1{cls}{#3-inst}[#2]%
@@ -1400,8 +1435,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>
