doc/list-exports: Use `documentation' to find more categories.

[sod] / doc / list-exports

diff --git a/doc/list-exports b/doc/list-exports
index 3a444e1..1d9b0c4 100755 (executable)
--- a/doc/list-exports
+++ b/doc/list-exports
@@ -159,6 +159,42 @@
       (and export
           (list* (symbolicate 'c-type- (car names)) names)))))
 
+(defmethod form-list-exports
+    ((head (eql 'sod::define-cross-product-types)) tail)
+  "Return the symbols exported by a `define-cross-product-types' form.
+
+   This is a scummy internal macro in `c-types-impl.lisp'.  The syntax is
+
+       (define-cross-product-types PIECES)
+
+   Each piece can be a list of strings, or an atomic string (which is
+   equivalent to a list containing just that string).  For each string formed
+   by concatenating one element from each list in order, define a C type with
+   that name; the Lisp name is constructed by translating the letters to
+   uppercase and replacing underscores by hyphens.  For each such name,
+   export `NAME' and `c-type-NAME'."
+
+  ;; Huh.  I feel a hack coming on.
+  (mapcar (lambda (row)
+           (intern (with-output-to-string (out)
+                     (dolist (s row)
+                       (dotimes (i (length s))
+                         (let ((ch (char s i)))
+                           (if (char= ch #\_)
+                               (write-char #\- out)
+                               (write-char (char-upcase ch) out))))))))
+         (reduce (lambda (piece tails)
+                   (mapcan (lambda (tail)
+                             (mapcar (lambda (head)
+                                       (cons head tail))
+                                     (if (listp piece) piece
+                                         (list piece))))
+                           tails))
+                 (cons '("" "c-type_") tail)
+                 :from-end t
+                 :initial-value '(nil))))
+
+
 (defmethod form-list-exports ((head (eql 'cl:macrolet)) tail)
   "Return the symbols expored by a toplevel `macrolet' form.
 
@@ -322,9 +358,9 @@
    categorizing the kinds of definitions that SYMBOL has."
 
   (let ((things nil))
-    (when (boundp symbol)
+    (when (or (boundp symbol) (documentation symbol 'variable))
       (push (if (constantp symbol) :constant :variable) things))
-    (when (fboundp symbol)
+    (when (or (fboundp symbol) (documentation symbol 'function))
       (push (cond ((macro-function symbol) :macro)
                  ((typep (fdefinition symbol) 'generic-function)
                   :generic)
@@ -334,8 +370,8 @@
        (generic-function (push :setf-generic things))
        (function (push :setf-function things))
        (null)))
-    (when (find-class symbol nil)
-      (push :class things))
+    (when (or (find-class symbol nil) (documentation symbol 'type))
+      (push (if (find-class symbol nil) :class :type) things))
     (when (specialized-on-p #'sod:expand-c-type-spec 0 symbol)
       (push :c-type-spec things))
     (when (specialized-on-p #'sod:expand-c-type-form 0 symbol)