src/: Factor out common machinery in `check-method-type' methods.

[sod] / doc / clang.tex
diff --git a/doc/clang.tex b/doc/clang.tex

index b38dc09..38e4b20 100644 (file)
--- a/doc/clang.tex
+++ b/doc/clang.tex
@@ -756,6 +756,36 @@ function type is the type of the function's return value.
    @|commentify-argument-names| to the argument list of the given type.
  \end{describe}
  
+\begin{describe}{fun}
+    {pprint-c-function-type @<return-type> @<stream>
+                            @<print-args> @<print-kernel>}
+  Provides the top-level structure for printing C function types.
+
+  Output is written to @<stream> to describe a function type returning
+  @<return-type>, whose declarator kernel (containing the name, and any
+  further type operands) will be printed by @<print-kernel>, and whose
+  arguments, if any, will be printed by @<print-args>.
+
+  The @<print-kernel> function is a standard kernel-printing function
+  following the \descref{pprint-c-type}[protocol]{gf}.
+
+  The @<print-args> function is given a single argument, which is the
+  @<stream> to print on.  It should not print the surrounding parentheses.
+
+  The output written to @<stream> looks approximately like
+  \begin{prog}
+    @<return-type> @<kernel>(@<args>)
+  \end{prog}
+\end{describe}
+
+\begin{describe}{fun}{pprint-argument-list @<args> @<stream> @> @<flag>}
+  Print an argument list to @<stream>.
+
+  The @<args> is a list of \descref{argument}[objects]{cls}, optionally
+  containing an @|:ellipsis| marker.  The function returns true if any
+  arguments were actually printed.
+\end{describe}
+
  
  \subsection{Parsing C types} \label{sec:clang.c-types.parsing}
  
@@ -902,6 +932,10 @@ Temporary names are represented by objects which implement a simple protocol.
        @<form>^*}
  \end{describe}
  
+\begin{describe}{fun}
+    {format-banner-comment @<stream> @<control> \&rest @<args>}
+\end{describe}
+
  \begin{table}
    \begin{tabular}[C]{ll>{\codeface}l}                              \hlx*{hv}
      \thd{Class name} &
@@ -913,6 +947,8 @@ Temporary names are represented by objects which implement a simple protocol.
      @|set|      & @<var> @<expr>           & @<var> = @<expr>;  \\ \hlx{v}
      @|update|   & @<var> @<op> @<expr>     & @<var> @<op>= @<expr>;
                                                                  \\ \hlx{v}
+    @|cond|     & @<cond> @<conseq> @<alt> & @<cond> ? @<conseq> : @<alt>
+                                                                \\ \hlx{v}
      @|return|   & @<expr>                  & return @[@<expr>@];
                                                                  \\ \hlx{v}
      @|break|    & ---                      & break;             \\ \hlx{v}
@@ -921,18 +957,26 @@ Temporary names are represented by objects which implement a simple protocol.
      @|call|     & @<func> @|\&rest| @<args>
                                             & @<func>(@<arg>_1,
                                                       $\ldots$,
-                                                     @<arg>_n)  \\ \hlx{vhv}
+                                                     @<arg>_n)  \\ \hlx{v}
+    @|banner|   & @<control> @|\&rest| @<args>
+                                           & /* @<banner> */    \\ \hlx{vhv}
      @|block|    & @<decls> @<body>         & \{ @[@<decls>@] @<body> \}
                                                                  \\ \hlx{v}
      @|if|       & @<cond> @<conseq> @|\&optional| @<alt>
                                             & if (@<cond>) @<conseq>
                                               @[else @<alt>@]    \\ \hlx{v}
+    @|for|      & @<init> @<cond> @<update> @<body> &
+      for (@<init>; @<cond>; @<update>) @<body>                 \\ \hlx{v}
      @|while|    & @<cond> @<body>          & while (@<cond>) @<body>
                                                                  \\ \hlx{v}
      @|do-while| & @<body> @<cond>          & do @<body> while (@<cond>);
                                                                  \\ \hlx{v}
-    @|function| & @<name> @<type> @<body>  &
-      \vtop{\hbox{\strut @<type>_0 @<name>(@<type>_1 @<arg>_1, $\ldots$,
+    @|function| &
+      \vtop{\hbox{\strut @<name> @<type> @<body>}
+            \hbox{\strut \quad @|\&optional @<banner>|}
+            \hbox{\strut \quad @|\&rest| @<banner-args>}} &
+      \vtop{\hbox{\strut @[/* @<banner> */@]}
+            \hbox{\strut @<type>_0 @<name>(@<type>_1 @<arg>_1, $\ldots$,
                                             @<type>_n @<arg>_n @[, \dots@])}
              \hbox{\strut \quad @<body>}}                        \\ \hlx*{vh}
    \end{tabular}
@@ -962,6 +1006,9 @@ Temporary names are represented by objects which implement a simple protocol.
  \begin{describe}{gf}{emit-decls @<codegen> @<decls>}
  \end{describe}
  
+\begin{describe}{fun}{emit-banner @<codegen> @<control> \&rest @<args>}
+\end{describe}
+
  \begin{describe}{gf}{codegen-push @<codegen>}
  \end{describe}