From e17d08b83e753a772ee4f6a126c6919e09b02f21 Mon Sep 17 00:00:00 2001
From: Noah Lavine <noah.b.lavine@gmail.com>
Date: Wed, 11 Jul 2012 13:55:45 -0400
Subject: [PATCH] Remove @twerp comments in documentation

 * doc/ref/calling.texi:
 * doc/ref/common-list.texi:
 * doc/ref/gap-buffer.texi:
 * doc/ref/hcons.texi:
 * doc/ref/lineio.texi:
 * doc/ref/ls.texi:
 * doc/ref/mapping.texi:
 * doc/ref/poe.texi:
 * doc/ref/popen.texi:
 * doc/ref/runq.texi:
 * doc/ref/session.texi:
 * doc/ref/stack-catch.texi:
 * doc/ref/string-fun.texi:
 * doc/ref/threads.texi: remove @twerp comments. They seem to have
 been generated by an old documentation system.
---
 doc/ref/calling.texi     |   26 +++-------
 doc/ref/common-list.texi |   72 ++++++++++--------------------
 doc/ref/gap-buffer.texi  |  112 +++++++++++++--------------------------------
 doc/ref/hcons.texi       |   25 +++-------
 doc/ref/lineio.texi      |   11 +---
 doc/ref/ls.texi          |   14 ++----
 doc/ref/mapping.texi     |   17 ++-----
 doc/ref/poe.texi         |    6 +--
 doc/ref/popen.texi       |   10 +---
 doc/ref/runq.texi        |   23 +++-------
 doc/ref/session.texi     |   25 +++--------
 doc/ref/stack-catch.texi |    4 --
 doc/ref/string-fun.texi  |    2 -
 doc/ref/threads.texi     |   10 ----
 14 files changed, 99 insertions(+), 258 deletions(-)

diff --git a/doc/ref/calling.texi b/doc/ref/calling.texi
index 172f744..ec6b229 100644
--- a/doc/ref/calling.texi
+++ b/doc/ref/calling.texi
@@ -18,8 +18,6 @@ To make use of idiomatic calling-convention macros, evaluate the form:
 (use-modules (ice-9 calling))
 @end smalllisp
 
-@c @twerpmacdoc (save-bindings-excursion)
-@c ../../ice-9/calling.doc
 @deffn {Scheme Macro} save-bindings-excursion vars [body...]
 Expand to a form that saves the values for each binding named in
 @var{vars}, a list of unevaluated symbols naming bindings in the
@@ -39,8 +37,7 @@ then restores the values.  These operations form the three branches of a
   (chk!))
 @end example
 @end deffn
-@c @twerpmacdoc (with-excursion-function)
-@c ../../ice-9/calling.doc
+
 @deffn {Scheme Macro} with-excursion-function vars collect
 Expand to an application of @var{collect} to an excursion proc @var{ex}.
 @var{ex} takes one argument, a thunk, which forms the middle branch of a
@@ -65,8 +62,7 @@ excursion proc is named @code{ex}.  Note that this is functionally
 equivalent to the one for @code{save-bindings-excursion} (with setup
 definitions elided).
 @end deffn
-@c @twerpmacdoc (with-getter-and-setter)
-@c ../../ice-9/calling.doc
+
 @deffn {Scheme Macro} with-getter-and-setter vars collect
 Expand to an application of @var{collect} to @var{getter} and @var{setter}
 procs for @var{vars}, an unevaluated list of symbols naming bindings in
@@ -114,13 +110,11 @@ These calling sequences supports two handy idioms:
   (lambda (foo bar) ....))
 @end example
 @end deffn
-@c @twerpmacdoc (with-getter)
-@c ../../ice-9/calling.doc
+
 @deffn {Scheme Macro} with-getter vars collect
 Like @code{with-getter-and-setter} but collect only @var{getter}.
 @end deffn
-@c @twerpmacdoc (with-delegating-getter-and-setter)
-@c ../../ice-9/calling.doc
+
 @deffn {Scheme Macro} with-delegating-getter-and-setter vars sub-g sub-s collect
 Expand to an application of @var{collect} to @var{getter} and @var{setter}
 procs for @var{vars}, an unevaluated list of symbols naming bindings in
@@ -134,8 +128,7 @@ like:
 If given a name not in @var{vars}, @var{getter} and @var{setter} call
 @var{sub-g} and @var{sub-s}, respectively.
 @end deffn
-@c @twerpmacdoc (with-excursion-getter-and-setter)
-@c ../../ice-9/calling.doc
+
 @deffn {Scheme Macro} with-excursion-getter-and-setter vars collect
 Expand to an application of @var{collect} to excursion proc @var{ex},
 @var{getter} and @var{setter} procs for @var{vars}, an unevaluated list of
@@ -148,8 +141,7 @@ symbols naming bindings in the caller of
 
 See @code{with-excursion-function} and @code{with-getter-and-setter}.
 @end deffn
-@c @twerpmacdoc (with-configuration-getter-and-setter)
-@c ../../ice-9/calling.doc
+
 @deffn {Scheme Macro} with-configuration-getter-and-setter vars-etc collect
 Expand to an application of @var{collect} to @var{getter} and @var{setter}
 procs for @var{vars-etc}, a list of binding specifiers for bindings
@@ -176,14 +168,12 @@ name.  If omitted (or #f is passed), use the normal value of @code{name}.
 @var{setter-hook} is a procedure of one argument that accepts a new value
 for @var{name}.  If omitted, @var{name} is simply updated with @code{set!}.
 @end deffn
-@c @twerpmacdoc (with-delegating-configuration-getter-and-setter)
-@c ../../ice-9/calling.doc
+
 @deffn {Scheme Macro} with-delegating-configuration-getter-and-setter vars-etc sub-g sub-s collect
 Like @code{with-delegating-getter-and-setter} but using @var{vars-etc}
 as with @code{with-configuration-getter-and-setter}.
 @end deffn
-@c @twerpmacdoc (let-with-configuration-getter-and-setter)
-@c ../../ice-9/calling.doc
+
 @deffn {Scheme Macro} let-with-configuration-getter-and-setter vars-etc collect
 Like @code{with-configuration-getter-and-setter}
 except that each element of @var{vars-etc} is:
diff --git a/doc/ref/common-list.texi b/doc/ref/common-list.texi
index 2741c53..03648db 100644
--- a/doc/ref/common-list.texi
+++ b/doc/ref/common-list.texi
@@ -22,43 +22,36 @@ for Guile.  To load it:
 
 @xref{SRFI-1}, for another list library.
 
-@c @twerpdoc (adjoin)
-@c ../../ice-9/common-list.doc
+
 @deffn {Scheme Procedure} adjoin e l
 Return list L, possibly with element E added if it is not already in L.
 @end deffn
-@c @twerpdoc (union)
-@c ../../ice-9/common-list.doc
+
 @deffn {Scheme Procedure} union l1 l2
 Return a new list that is the union of L1 and L2.
 Elements that occur in both lists occur only once in
 the result list.
 @end deffn
-@c @twerpdoc (intersection)
-@c ../../ice-9/common-list.doc
+
 @deffn {Scheme Procedure} intersection l1 l2
 Return a new list that is the intersection of L1 and L2.
 Only elements that occur in both lists occur in the result list.
 @end deffn
-@c @twerpdoc (set-difference)
-@c ../../ice-9/common-list.doc
+
 @deffn {Scheme Procedure} set-difference l1 l2
 Return elements from list L1 that are not in list L2.
 @end deffn
-@c @twerpdoc (reduce-init)
-@c ../../ice-9/common-list.doc
+
 @deffn {Scheme Procedure} reduce-init p init l
 Same as `reduce' except it implicitly inserts INIT at the start of L.
 @end deffn
-@c @twerpdoc (reduce)
-@c ../../srfi/srfi-1.doc
+
 @deffn {Scheme Procedure} reduce f ridentity lst
 @code{reduce} is a variant of @code{fold}.  If @var{lst} is
 @code{()}, @var{ridentity} is returned.  Otherwise, @code{(fold (car
 @var{lst}) (cdr @var{lst}))} is returned.
 @end deffn
-@c @twerpdoc (some)
-@c ../../ice-9/common-list.doc
+
 @deffn {Scheme Procedure} some pred l [rest...]
 PRED is a boolean function of as many arguments as there are list
 arguments to `some', i.e., L plus any optional arguments.  PRED is
@@ -67,100 +60,83 @@ as one of these applications returns a true value, return that value.
 If no application returns a true value, return #f.
 All the lists should have the same length.
 @end deffn
-@c @twerpdoc (every)
-@c ../../srfi/srfi-1.doc
+
 @deffn {Scheme Procedure} every pred ls [lists...]
 Apply @var{pred} across the lists and return a true value if the
 predicate returns true for every of the list elements(s); return
 @code{#f} otherwise.  The true value returned is always the result of
 the final successful application of @var{pred}.
 @end deffn
-@c @twerpdoc (notany)
-@c ../../ice-9/common-list.doc
+
 @deffn {Scheme Procedure} notany pred [ls...]
 Return #t iff every application of PRED to L, etc., returns #f.
 Analogous to some but returns #t if no application of PRED returns a
 true value or #f as soon as any one does.
 @end deffn
-@c @twerpdoc (notevery)
-@c ../../ice-9/common-list.doc
+
 @deffn {Scheme Procedure} notevery pred [ls...]
 Return #t iff there is an application of PRED to L, etc., that returns #f.
 Analogous to some but returns #t as soon as an application of PRED returns #f,
 or #f otherwise.
 @end deffn
-@c @twerpdoc (count-if)
-@c ../../ice-9/common-list.doc
+
 @deffn {Scheme Procedure} count-if pred l
 Return the number of elements in L for which (PRED element) returns true.
 @end deffn
-@c @twerpdoc (find-if)
-@c ../../ice-9/common-list.doc
+
 @deffn {Scheme Procedure} find-if pred l
 Search for the first element in L for which (PRED element) returns true.
 If found, return that element, otherwise return #f.
 @end deffn
-@c @twerpdoc (member-if)
-@c ../../ice-9/common-list.doc
+
 @deffn {Scheme Procedure} member-if pred l
 Return the first sublist of L for whose car PRED is true.
 @end deffn
-@c @twerpdoc (remove-if)
-@c ../../ice-9/common-list.doc
+
 @deffn {Scheme Procedure} remove-if pred l
 Remove all elements from L where (PRED element) is true.
 Return everything that's left.
 @end deffn
-@c @twerpdoc (remove-if-not)
-@c ../../ice-9/common-list.doc
+
 @deffn {Scheme Procedure} remove-if-not pred l
 Remove all elements from L where (PRED element) is #f.
 Return everything that's left.
 @end deffn
-@c @twerpdoc (delete-if!)
-@c ../../ice-9/common-list.doc
+
 @deffn {Scheme Procedure} delete-if! pred l
 Destructive version of `remove-if'.
 @end deffn
-@c @twerpdoc (delete-if-not!)
-@c ../../ice-9/common-list.doc
+
 @deffn {Scheme Procedure} delete-if-not! pred l
 Destructive version of `remove-if-not'.
 @end deffn
-@c @twerpdoc (butlast)
-@c ../../ice-9/common-list.doc
+
 @deffn {Scheme Procedure} butlast lst n
 Return all but the last N elements of LST.
 @end deffn
-@c @twerpdoc (and?)
-@c ../../ice-9/common-list.doc
+
 @deffn {Scheme Procedure} and? [args...]
 Return #t iff all of ARGS are true.
 @end deffn
-@c @twerpdoc (or?)
-@c ../../ice-9/common-list.doc
+
 @deffn {Scheme Procedure} or? [args...]
 Return #t iff any of ARGS is true.
 @end deffn
-@c @twerpdoc (has-duplicates?)
-@c ../../ice-9/common-list.doc
+
 @deffn {Scheme Procedure} has-duplicates? lst
 Return #t iff 2 members of LST are equal?, else #f.
 @end deffn
-@c @twerpdoc (pick)
-@c ../../ice-9/common-list.doc
+
 @deffn {Scheme Procedure} pick p l
 Apply P to each element of L, returning a list of elts
 for which P returns a non-#f value.
 @end deffn
-@c @twerpdoc (pick-mappings)
-@c ../../ice-9/common-list.doc
+
 @deffn {Scheme Procedure} pick-mappings p l
 Apply P to each element of L, returning a list of the
 non-#f return values of P.
 @end deffn
-@c @twerpdoc (uniq)
-@c ../../ice-9/common-list.doc
+
 @deffn {Scheme Procedure} uniq l
 Return a list containing elements of L, with duplicates removed.
 @end deffn
diff --git a/doc/ref/gap-buffer.texi b/doc/ref/gap-buffer.texi
index 363550c..3273075 100644
--- a/doc/ref/gap-buffer.texi
+++ b/doc/ref/gap-buffer.texi
@@ -18,7 +18,6 @@ To load support for efficient insert/delete operations on strings:
 (use-modules (ice-9 gap-buffer))
 @end lisp
 
-@c @twerpcommentary (verbatim (ice-9 gap-buffer))
 @verbatim
 A gap buffer is a structure that models a string but allows relatively
 efficient insertion of text somewhere in the middle.  The insertion
@@ -66,21 +65,17 @@ with all fields (GAP-SIZE, ALLOC-SIZE, MINT-MIN, POINT, and POINT-MAX)
 integers, and everything else as shown here.
 @end verbatim
 
-@c @twerpdoc (gb?)
-@c ../../ice-9/gap-buffer.doc
 @deffn {Scheme Procedure} gb? object
 Return #t iff @var{object} is a gap buffer object.
 @end deffn
-@c @twerpdoc (make-gap-buffer)
-@c ../../ice-9/gap-buffer.doc
+
 @deffn {Scheme Procedure} make-gap-buffer [init]
 Return a new gap buffer.  Optional arg @var{init} is either a port
 to read from; a string, used to initialize the buffer contents;
 or an integer specifying the memory allocation (in bytes) requested.
 Point is left at the maximum position.
 @end deffn
-@c @twerpdoc (gb-toggle-read-only)
-@c ../../ice-9/gap-buffer.doc
+
 @deffn {Scheme Procedure} gb-toggle-read-only gb [arg]
 Change whether @var{gb} is read-only.
 With arg, set read-only iff arg is positive.
@@ -93,74 +88,60 @@ wasteful data motion.
 
 @subsection querying
 
-@c @twerpdoc (gb-point)
-@c ../../ice-9/gap-buffer.doc
 @deffn {Scheme Procedure} gb-point gb
 Return the position of point in @var{gb}.
 This is an integer starting with 1 (one).
 @end deffn
-@c @twerpdoc (gb-point-min)
-@c ../../ice-9/gap-buffer.doc
+
 @deffn {Scheme Procedure} gb-point-min gb
 Return the minimum position possible for point in @var{gb}.
 At this time, this value is always 1 (one).
 @end deffn
-@c @twerpdoc (gb-point-max)
-@c ../../ice-9/gap-buffer.doc
+
 @deffn {Scheme Procedure} gb-point-max gb
 Return the maximum position possible for point in @var{gb}.
 This value can be changed by inserting text into the buffer,
 and is limited by Guile's string implementation.
 @end deffn
-@c @twerpdoc (gb-char-after)
-@c ../../ice-9/gap-buffer.doc
+
 @deffn {Scheme Procedure} gb-char-after gb [pos...]
 Return char after @var{pos}, or #f if there is no char there.
 If @var{pos} is not specified, it defaults to point.
 @end deffn
-@c @twerpdoc (gb-char-before)
-@c ../../ice-9/gap-buffer.doc
+
 @deffn {Scheme Procedure} gb-char-before gb [pos...]
 Return char before @var{pos}, or #f if there is no char there.
 If @var{pos} is not specified, it defaults to point.
 @end deffn
-@c @twerpdoc (gb-bolp)
-@c ../../ice-9/gap-buffer.doc
+
 @deffn {Scheme Procedure} gb-bolp gb
 Return #t if point in @var{gb} is at the beginning of a line.
 @end deffn
-@c @twerpdoc (gb-eolp)
-@c ../../ice-9/gap-buffer.doc
+
 @deffn {Scheme Procedure} gb-eolp gb
 Return #t if point in @var{gb} is at the end of a line.
 @end deffn
-@c @twerpdoc (gb-bobp)
-@c ../../ice-9/gap-buffer.doc
+
 @deffn {Scheme Procedure} gb-bobp gb
 Return #t if point is at the beginning of @var{gb}.
 @end deffn
-@c @twerpdoc (gb-eobp)
-@c ../../ice-9/gap-buffer.doc
+
 @deffn {Scheme Procedure} gb-eobp gb
 Return #t if point is at the end of @var{gb}.
 @end deffn
 
 @subsection munging
 
-@c @twerpdoc (gb-insert-string!)
-@c ../../ice-9/gap-buffer.doc
 @deffn {Scheme Procedure} gb-insert-string! gb string
 Insert into @var{gb} a @var{string}, moving point forward as well as
 increasing the value that would be returned by @code{gb-point-max}.
 @end deffn
-@c @twerpdoc (gb-insert-char!)
-@c ../../ice-9/gap-buffer.doc
+
 @deffn {Scheme Procedure} gb-insert-char! gb char
 Insert into @var{gb} a single @var{char}, moving point forward as well as
 increasing the value that would be returned by @code{gb-point-max}.
 @end deffn
-@c @twerpdoc (gb-insert)
-@c ../../ice-9/gap-buffer.doc
+
 @deffn {Scheme Procedure} gb-insert gb [args...]
 Insert the arguments at point.
 If an arg is a gap-buffer, insert its contents.
@@ -169,8 +150,7 @@ If an arg is a number, insert the result of @code{number->string}.
 Other types accepted: char, string, symbol.
 Point moves forward to end up after the inserted text.
 @end deffn
-@c @twerpdoc (gb-delete-char!)
-@c ../../ice-9/gap-buffer.doc
+
 @deffn {Scheme Procedure} gb-delete-char! gb count
 In @var{gb}, delete @var{count} characters from point, forward if
 @var{count} is positive, backward if @var{count} is negative.  (If
@@ -178,13 +158,11 @@ In @var{gb}, delete @var{count} characters from point, forward if
 backwards.  Deleting forwards or backwards decreases the value that would
 be returned by @code{gb-point-max}.
 @end deffn
-@c @twerpdoc (gb-delete-region)
-@c ../../ice-9/gap-buffer.doc
+
 @deffn {Scheme Procedure} gb-delete-region gb beg end
 Delete text between @var{beg} and @var{end}.
 @end deffn
-@c @twerpdoc (gb-erase!)
-@c ../../ice-9/gap-buffer.doc
+
 @deffn {Scheme Procedure} gb-erase! gb
 Completely erase @var{gb}.  Point is left at the minimum position possible
 (which happens to be also the maximum position possible since the buffer
@@ -193,26 +171,21 @@ is empty).
 
 @subsection moving
 
-@c @twerpdoc (gb-goto-char)
-@c ../../ice-9/gap-buffer.doc
 @deffn {Scheme Procedure} gb-goto-char gb new-point
 In @var{gb}, move point to @var{new-point} and return it.  If
 @var{new-point} is outside the minimum and maximum positions possible, it
 is adjusted to the the nearest boundary (however, the return value is
 @var{new-point} unchanged).
 @end deffn
-@c @twerpdoc (gb-forward-char)
-@c ../../ice-9/gap-buffer.doc
+
 @deffn {Scheme Procedure} gb-forward-char gb n
 In gap-buffer @var{gb}, move point forward @var{n} characters.
 @end deffn
-@c @twerpdoc (gb-backward-char)
-@c ../../ice-9/gap-buffer.doc
+
 @deffn {Scheme Procedure} gb-backward-char gb n
 In gap-buffer @var{gb}, move point backward @var{n} characters.
 @end deffn
-@c @twerpdoc (gb-forward-line)
-@c ../../ice-9/gap-buffer.doc
+
 @deffn {Scheme Procedure} gb-forward-line gb [n...]
 In gap-buffer @var{gb}, move point @var{n} lines forward (backward if
 @var{n} is negative).  Precisely, if point is on line @code{I}, move to the
@@ -222,15 +195,13 @@ is @var{n} - number of lines moved; if backward, @var{n} + number moved.
 With positive @var{n}, a non-empty line at the end counts as one line
 successfully moved (for the return value).
 @end deffn
-@c @twerpdoc (gb-beginning-of-line)
-@c ../../ice-9/gap-buffer.doc
+
 @deffn {Scheme Procedure} gb-beginning-of-line gb [n...]
 In gap-buffer @var{gb}, move point to beginning of current line.
 With argument @var{n} not #f or 1, move forward @var{n} - 1 lines first.
 If point reaches the beginning or end of buffer, it stops there.
 @end deffn
-@c @twerpdoc (gb-end-of-line)
-@c ../../ice-9/gap-buffer.doc
+
 @deffn {Scheme Procedure} gb-end-of-line gb [n...]
 In gap-buffer @var{gb}, move point to end of current line.
 With argument @var{n} not #f or 1, move forward @var{n} - 1 lines first.
@@ -239,8 +210,6 @@ If point reaches the beginning or end of buffer, it stops there.
 
 @subsection search (and replace)
 
-@c @twerpdoc (gb-match-string)
-@c ../../ice-9/gap-buffer.doc
 @deffn {Scheme Procedure} gb-match-string gb n
 Return string of text matched by last search.
 @var{n} specifies which parenthesized expression in the last regexp.
@@ -248,16 +217,14 @@ Value is #f if @var{n}th pair didn't match, or there were less than
 @var{n} pairs.  Zero means the entire text matched by the whole regexp
 or whole string.
 @end deffn
-@c @twerpdoc (gb-looking-at)
-@c ../../ice-9/gap-buffer.doc
+
 @deffn {Scheme Procedure} gb-looking-at gb re-str
 Return #t if text after point matches regular expression @var{re-str}.
 This function modifies the match data that @code{gb-match-beginning},
 @code{gb-match-end} and @code{gb-match-data} access; save and restore
 the match data if you want to preserve them.
 @end deffn
-@c @twerpdoc (gb-match-beginning)
-@c ../../ice-9/gap-buffer.doc
+
 @deffn {Scheme Procedure} gb-match-beginning [n]
 Return position of start of text matched by last search.
 @var{subexp}, a number, specifies which parenthesized expression
@@ -265,8 +232,7 @@ in the last regexp.  Value is #f if @var{subexp}th pair didn't match,
 or there were less than @var{subexp} pairs.  Zero means the entire text
 matched by the whole regexp.
 @end deffn
-@c @twerpdoc (gb-match-end)
-@c ../../ice-9/gap-buffer.doc
+
 @deffn {Scheme Procedure} gb-match-end [n]
 Return position of end of text matched by last search.
 @var{subexp}, a number, specifies which parenthesized expression in the
@@ -274,8 +240,7 @@ last regexp.  Value is nil if @var{subexp}th pair didn't match, or there
 were less than @var{subexp} pairs.  Zero means the entire text matched by
 the whole regexp.
 @end deffn
-@c @twerpdoc (gb-search-forward)
-@c ../../ice-9/gap-buffer.doc
+
 @deffn {Scheme Procedure} gb-search-forward string [bound [noerror [count]]]
 Search forward from point for @var{string}.
 Set point to the end of the occurrence found, and return point.
@@ -286,8 +251,7 @@ Optional third argument, if #t, means if fail just return #f (no error).
   If not #f and not #t, move to limit of search and return #f.
 Optional fourth argument is repeat count--search for successive occurrences.
 @end deffn
-@c @twerpdoc (gb-search-backward)
-@c ../../ice-9/gap-buffer.doc
+
 @deffn {Scheme Procedure} gb-search-backward string [bound [noerror [repeat]]]
 Search backward from point for @var{string}.
 Set point to the beginning of the occurrence found, and return point.
@@ -297,8 +261,7 @@ Optional third argument, if t, means if fail just return nil (no error).
  If not nil and not t, position at limit of search and return nil.
 Optional fourth argument is repeat count--search for successive occurrences.
 @end deffn
-@c @twerpdoc (gb-re-search-forward)
-@c ../../ice-9/gap-buffer.doc
+
 @deffn {Scheme Procedure} gb-re-search-forward regexp [bound [noerror [repeat]]]
 Search forward from point for regular expression @var{regexp}.
 Set point to the end of the occurrence found, and return point.
@@ -313,8 +276,7 @@ Optional fourth argument is repeat count--search for successive occurrences.
 not to include the flag @code{regexp/newline} (normally used when
 @var{regexp} is a string to compile it internally).
 @end deffn
-@c @twerpdoc (gb-replace-match)
-@c ../../ice-9/gap-buffer.doc
+
 @deffn {Scheme Procedure} gb-replace-match newtext [IGNORED [literal]]
 Replace text matched by last search with @var{newtext}.
 The second arg is optional and ignored (for now -- in the
@@ -334,48 +296,40 @@ Leave point at end of replacement text.
 
 @subsection misc
 
-@c @twerpdoc (gb->port!)
-@c ../../ice-9/gap-buffer.doc
 @deffn {Scheme Procedure} gb->port! gb port [beg [end]]
 Send the contents of @var{gb} to the output @var{port}.
 Optional args @var{beg} and @var{end} specify a region to send.
 Point does not move.
 @end deffn
-@c @twerpdoc (gb->string)
-@c ../../ice-9/gap-buffer.doc
+
 @deffn {Scheme Procedure} gb->string gb
 Return a new string representing the text of @var{gb}.
 Point does not move.
 @end deffn
-@c @twerpdoc (gb->substring)
-@c ../../ice-9/gap-buffer.doc
+
 @deffn {Scheme Procedure} gb->substring gb start end
 Return the region of @var{gb} from @var{start} to @var{end} as a string.
 @end deffn
-@c @twerpdoc (gb-filter!)
-@c ../../ice-9/gap-buffer.doc
+
 @deffn {Scheme Procedure} gb-filter! gb string-proc
 Pass the string representing the text of @var{gb} to @var{string-proc} and
 use its return value to completely replace the contents of @var{gb}.
 Point is left at the maximum position.
 @end deffn
-@c @twerpdoc (gb->lines)
-@c ../../ice-9/gap-buffer.doc
+
 @deffn {Scheme Procedure} gb->lines gb
 Return a list of strings representing the lines of text of @var{gb}.
 Newlines are automatically removed.  A buffer with N newlines results
 in a list of length N+1.  Point does not move.
 @end deffn
-@c @twerpdoc (gb-filter-lines!)
-@c ../../ice-9/gap-buffer.doc
+
 @deffn {Scheme Procedure} gb-filter-lines! gb lines-proc
 Pass the list of strings representing the lines of text of @var{gb} to
 @var{lines-proc} and use its return value (another list of strings) to
 completely replace the contents of @var{gb}.  Newlines are automatically
 removed and added back.  Point is left at the maximum position.
 @end deffn
-@c @twerpdoc (make-gap-buffer-port)
-@c ../../ice-9/gap-buffer.doc
+
 @deffn {Scheme Procedure} make-gap-buffer-port gb
 Return a "soft port" on @var{gb} that supports the write-character,
 write-string and read-character operations (flush-output and close-port
diff --git a/doc/ref/hcons.texi b/doc/ref/hcons.texi
index 273a871..fd5c7be 100644
--- a/doc/ref/hcons.texi
+++ b/doc/ref/hcons.texi
@@ -23,50 +23,41 @@ To use eq?-hash consers, evaluate
 (use-modules (ice-9 hcons))
 @end smalllisp
 
-@c @twerpdoc (hashq-cons-hash)
-@c ../../ice-9/hcons.doc
 @deffn {Scheme Procedure} hashq-cons-hash pair n
 Return the hash of @var{pair} modulo @var{n}.
 Use an @code{eq?} hash of the @sc{car} and
 @sc{cdr} of @var{pair} for the computation.
 @end deffn
-@c @twerpdoc (hashq-cons-assoc)
-@c ../../ice-9/hcons.doc
+
 @deffn {Scheme Procedure} hashq-cons-assoc key alist
 Return the first element in @var{alist} whose @sc{car} and @sc{cdr} are
 @code{eq?} to that of the pair @var{key}.  Return #f if no match exists.
 @end deffn
-@c @twerpdoc (hashq-cons-get-handle)
-@c ../../ice-9/hcons.doc
+
 @deffn {Scheme Procedure} hashq-cons-get-handle table key
 Return the handle from hash @var{table} whose @sc{car} and @sc{cdr}
 are @code{eq?} to that of the pair @var{key}.
 @end deffn
-@c @twerpdoc (hashq-cons-create-handle!)
-@c ../../ice-9/hcons.doc
+
 @deffn {Scheme Procedure} hashq-cons-create-handle! table key init
 Create a handle in hash @var{table} for pair @var{key} and
 store the initial value @var{init} there.  Return the handle.
 @end deffn
-@c @twerpdoc (hashq-cons-ref)
-@c ../../ice-9/hcons.doc
+
 @deffn {Scheme Procedure} hashq-cons-ref table key
 Return the value associated with pair @var{key} in hash @var{table},
 or #f if @var{key} is not to be found.
 @end deffn
-@c @twerpdoc (hashq-cons-set!)
-@c ../../ice-9/hcons.doc
+
 @deffn {Scheme Procedure} hashq-cons-set! table key val
 In hash @var{table}, associate with pair @var{key} the value @var{val}.
 @end deffn
-@c @twerpdoc (hashq-cons)
-@c ../../ice-9/hcons.doc
+
 @deffn {Scheme Procedure} hashq-cons table a d
 Add to hash @var{table} an entry for the double-key @var{a} and
 @var{d}.  The associated value is #f.  Return the combined key (pair).
 @end deffn
-@c @twerpdoc (hashq-conser)
-@c ../../ice-9/hcons.doc
+
 @deffn {Scheme Procedure} hashq-conser hash-tab-or-size
 Return a procedure that does @code{hashq-cons} on @var{hash-tab-or-size}.
 If @var{hash-tab-or-size} is a number, allocate and a hash table of that
@@ -76,8 +67,6 @@ same as the latter two args of @code{hashq-cons}.
 
 @c [The following proc really doesn't belong here. --ttn]
 
-@c @twerpdoc (make-gc-buffer)
-@c ../../ice-9/hcons.doc
 @deffn {Scheme Procedure} make-gc-buffer n
 Construct a private ring (circular list) of @var{n} elements and return a
 procedure @var{proc} that updates it.  @var{proc} takes one argument,
diff --git a/doc/ref/lineio.texi b/doc/ref/lineio.texi
index 1d15494..f7b96b4 100644
--- a/doc/ref/lineio.texi
+++ b/doc/ref/lineio.texi
@@ -33,14 +33,11 @@ are put back using @code{unread-string}, they can be broken arbitrarily --
 that is, @code{read-string} returns strings passed to @code{unread-string} (or
 shared substrings of them).
 
-@c @twerpdoc (lineio-port?)
-@c ../../ice-9/lineio.doc
 @deffn {Scheme Procedure} lineio-port? port
 Return #t iff @var{port} is a port capable of handling
 @code{read-string} and @code{unread-string}.
 @end deffn
-@c @twerpdoc (make-line-buffering-input-port)
-@c ../../ice-9/lineio.doc
+
 @deffn {Scheme Procedure} make-line-buffering-input-port underlying-port
 Return a wrapper port for @var{underlying-port}.
 
@@ -48,14 +45,12 @@ The wrapper port buffers characters read from @var{underlying-port}
 internally, and parcels them out via calls to @code{read-char},
 @code{read-string} and @code{unread-string}.
 @end deffn
-@c @twerpdoc (read-string)
-@c ../../ice-9/lineio.doc
+
 @deffn {Scheme Procedure} read-string line-buffering-input-port
 Read a line from @var{line-buffering-input-port}.
 Return it as a string, ending with newline.
 @end deffn
-@c @twerpdoc (unread-string)
-@c ../../ice-9/lineio.doc
+
 @deffn {Scheme Procedure} unread-string str line-buffering-input-port
 Return string @var{str} to @var{line-buffering-input-port}.
 A subsequent call to @code{read-string} or @code{read-char} from
diff --git a/doc/ref/ls.texi b/doc/ref/ls.texi
index 7fe5e2d..9fb4bae 100644
--- a/doc/ref/ls.texi
+++ b/doc/ref/ls.texi
@@ -25,21 +25,17 @@ this hierarchy, evaluate the form:
 This provides several procedures that are roughly akin to the unixoid ls(1)
 command, hence the name.
 
-@c @twerpdoc (local-definitions-in)
-@c ../../ice-9/ls.doc
 @deffn {Scheme Procedure} local-definitions-in root names
 Return a list of names defined locally in the named subdirectory of
 @var{root}.
 @end deffn
-@c @twerpdoc (definitions-in)
-@c ../../ice-9/ls.doc
+
 @deffn {Scheme Procedure} definitions-in root names
 Return a list of all names defined in the named subdirectory of
 @var{root}.  The list includes all locally defined names as well as
 all names inherited from a member of a use-list.
 @end deffn
-@c @twerpdoc (ls)
-@c ../../ice-9/ls.doc
+
 @deffn {Scheme Procedure} ls [various-refs...]
 With no arguments, return a list of definitions in the current module.
 
@@ -56,13 +52,11 @@ return a list:
  ...)
 @end smalllisp
 @end deffn
-@c @twerpdoc (lls)
-@c ../../ice-9/ls.doc
+
 @deffn {Scheme Procedure} lls [various-refs...]
 Analogous to @code{ls}, but with local definitions only.
 @end deffn
-@c @twerpdoc (recursive-local-define)
-@c ../../ice-9/ls.doc
+
 @deffn {Scheme Procedure} recursive-local-define name value
 Define @var{name} to have value @var{value}.
 @var{name} is a list of symbols, the last one being the
diff --git a/doc/ref/mapping.texi b/doc/ref/mapping.texi
index 5bcf9a0..a398290 100644
--- a/doc/ref/mapping.texi
+++ b/doc/ref/mapping.texi
@@ -18,8 +18,6 @@ To create and use new hash table mappings, evaluate the form:
 (use-modules (ice-9 mapping))
 @end smalllisp
 
-@c @twerpdoc (hash-table-mapping)
-@c ../../ice-9/mapping.doc
 @deffn {Scheme Procedure} hash-table-mapping [options...]
 Return a mapping object, configured by @var{options}.
 
@@ -45,33 +43,28 @@ The mapping object prints using hash notation:
 @result{} #<mapping hash/string-ci=? 3 4022fcf8>
 @end example
 @end deffn
-@c @twerpdoc (mapping-get-handle)
-@c ../../ice-9/mapping.doc
+
 @deffn {Scheme Procedure} mapping-get-handle map key
 Return the handle from mapping @var{map} for @var{key}, or #f
 if @var{key} is not in @var{map}.
 @end deffn
-@c @twerpdoc (mapping-create-handle!)
-@c ../../ice-9/mapping.doc
+
 @deffn {Scheme Procedure} mapping-create-handle! map key [default]
 Return the handle from mapping @var{map} for @var{key}, or if
 @var{key} is not in @var{map}, create a new handle with value
 @var{default} and return the new handle.
 @end deffn
-@c @twerpdoc (mapping-remove!)
-@c ../../ice-9/mapping.doc
+
 @deffn {Scheme Procedure} mapping-remove! map key
 Remove @var{key} and its associated value from mappping @var{map}.
 Return the handle.
 @end deffn
-@c @twerpdoc (mapping-ref)
-@c ../../ice-9/mapping.doc
+
 @deffn {Scheme Procedure} mapping-ref map key [default]
 Return the value associated with @var{key} in mapping @var{map},
 or @var{default} if there is no such association.
 @end deffn
-@c @twerpdoc (mapping-set!)
-@c ../../ice-9/mapping.doc
+
 @deffn {Scheme Procedure} mapping-set! map key val
 Associate @var{key} with @var{val} in mapping @var{map}.
 Return @var{val}.
diff --git a/doc/ref/poe.texi b/doc/ref/poe.texi
index 5c377e9..66ef9f8 100644
--- a/doc/ref/poe.texi
+++ b/doc/ref/poe.texi
@@ -21,7 +21,6 @@ To make use of the memoization facilities, evaluate the form:
 This provides two ``purity of essence'' [insert actual Vonnegut allusion here,
 someday, or not] procedures for memoizing @dfn{pure functions}.
 
-@c @twerpcommentary (include (ice-9 poe))
 A pure function (of some sort) is characterized by two equality
 relations: one on argument lists and one on return values.
 A pure function is one that when applied to equal arguments lists
@@ -34,15 +33,12 @@ equality relation on arguments is tricky.
 The simplest case of pure functions are those in which results
 are only certainly @code{eq?} if all of the arguments are.
 
-@c @twerpdoc (pure-funcq)
-@c ../../ice-9/poe.doc
 @deffn {Scheme Procedure} pure-funcq base
 Return a procedure @var{pf} that wraps procedure @var{base}, associating
 the arg list of each call to @var{pf} to its return value in a globally
 shared (but bounded nonetheless) table.
 @end deffn
-@c @twerpdoc (perfect-funcq)
-@c ../../ice-9/poe.doc
+
 @deffn {Scheme Procedure} perfect-funcq size base
 Return a procedure @var{pf} that wraps procedure @var{base}, associating
 the arg list of each call to @var{pf} to its return value in a private
diff --git a/doc/ref/popen.texi b/doc/ref/popen.texi
index 3203d88..a210fea 100644
--- a/doc/ref/popen.texi
+++ b/doc/ref/popen.texi
@@ -21,8 +21,7 @@ module:
 @end smalllisp
 
 @findex popen
-@c @twerpdoc (open-pipe)
-@c ../../ice-9/popen.doc
+
 @deffn {Scheme Procedure} open-pipe command mode
 Execute the shell command @var{command} (a string) in a subprocess.
 A pipe to the process is created and returned.  @var{modes} specifies
@@ -30,21 +29,16 @@ whether an input or output pipe to the process is created: it should
 be the value of @code{OPEN_READ} or @code{OPEN_WRITE}.
 @end deffn
 
-@c @twerpdoc (open-input-pipe)
-@c ../../ice-9/popen.doc
 @deffn {Scheme Procedure} open-input-pipe command
 Equivalent to @code{open-pipe} with mode @code{OPEN_READ}.
 @end deffn
 
-@c @twerpdoc (open-output-pipe)
-@c ../../ice-9/popen.doc
 @deffn {Scheme Procedure} open-output-pipe command
 Equivalent to @code{open-pipe} with mode @code{OPEN_WRITE}.
 @end deffn
 
 @findex pclose
-@c @twerpdoc (close-pipe)
-@c ../../ice-9/popen.doc
+
 @deffn {Scheme Procedure} close-pipe p
 Close the pipe created by @code{open-pipe}, wait for the process
 to terminate, and return its status value.  @xref{Processes, waitpid},
diff --git a/doc/ref/runq.texi b/doc/ref/runq.texi
index f66e2c4..1388090 100644
--- a/doc/ref/runq.texi
+++ b/doc/ref/runq.texi
@@ -19,8 +19,6 @@ computations, evaluate the form:
 (use-modules (ice-9 runq))
 @end smalllisp
 
-@c @twerpcommentary (verbatim (ice-9 runq))
-@verbatim
 One way to schedule parallel computations in a serial environment is
 to explicitly divide each task up into small, finite execution time,
 strips.  Then you interleave the execution of strips from various
@@ -45,10 +43,7 @@ original strip if that strip has 2+ elements.  The runq puts whichever
 of these strips exist back on the queue.  (The exact order in which
 strips are put back on the queue determines the scheduling behavior of
 a particular queue -- it's a parameter.)
-@end verbatim
 
-@c @twerpdoc (runq-control)
-@c ../../ice-9/runq.doc
 @deffn {Scheme Procedure} runq-control q msg [args...]
 For runq @var{q}, process in the default way the control
 message @var{msg} (a symbol) and its @var{args}.  These
@@ -75,14 +70,12 @@ Empty the runq.
 Signal error for any other message, with key @code{not-understood}
 and two arguments @var{msg} and @var{args}.
 @end deffn
-@c @twerpdoc (make-void-runq)
-@c ../../ice-9/runq.doc
+
 @deffn {Scheme Procedure} make-void-runq
 Return a runq that discards all messages except @code{length},
 for which it returns 0.
 @end deffn
-@c @twerpdoc (make-fair-runq)
-@c ../../ice-9/runq.doc
+
 @deffn {Scheme Procedure} make-fair-runq
 Return a runq procedure.
 Called with no arguments, the procedure processes one strip from the queue.
@@ -92,8 +85,7 @@ In a fair runq, if a strip returns a new strip @code{X}, that is added
 to the end of the queue, meaning it will be the last to execute
 of all the remaining strips.
 @end deffn
-@c @twerpdoc (make-exclusive-runq)
-@c ../../ice-9/runq.doc
+
 @deffn {Scheme Procedure} make-exclusive-runq
 Return a runq procedure.
 Called with no arguments, the procedure processes one strip from the queue.
@@ -109,8 +101,7 @@ queue, the @sc{cdr} of the list of strips is pushed in front of that (if
 the @sc{cdr} is not empty).  This way, the rest of the thunks in the list
 that contained @code{W} have priority over @code{X}.
 @end deffn
-@c @twerpdoc (make-subordinate-runq-to)
-@c ../../ice-9/runq.doc
+
 @deffn {Scheme Procedure} make-subordinate-runq-to superior basic-inferior
 Return a runq proxy for the runq @var{basic-inferior}.
 
@@ -122,13 +113,11 @@ of that task processes @code{N} strips from @var{basic-inferior} where
 @code{N} is the length of @var{basic-inferior} when the proxy
 strip is entered.  [Countless scheduling variations are possible.]
 @end deffn
-@c @twerpdoc (strip-sequence)
-@c ../../ice-9/runq.doc
+
 @deffn {Scheme Procedure} strip-sequence [strips...]
 Return a new strip which is the concatenation of @var{strips}.
 @end deffn
-@c @twerpdoc (fair-strip-subtask)
-@c ../../ice-9/runq.doc
+
 @deffn {Scheme Procedure} fair-strip-subtask [initial-strips...]
 Return a new strip which is the synchronous, fair,
 parallel execution of the @var{initial-strips}.
diff --git a/doc/ref/session.texi b/doc/ref/session.texi
index d59e790..ae3f6db 100644
--- a/doc/ref/session.texi
+++ b/doc/ref/session.texi
@@ -29,14 +29,11 @@ however, you can load them explicitly with the expression:
 The rest of this section describes the procedures and macros available
 by loading module @code{(ice-9 sesssion)}.
 
-@c @twerpdoc (add-to-load-path!)
-@c ../../ice-9/session.doc
 @deffn {Scheme Procedure} add-to-load-path! directory [append?]
 Add @var{directory} to @code{%load-path}, if it is not already there.
 Add at the beginning, unless optional arg @var{append?} is non-#f.
 @end deffn
-@c @twerpdoc (set-fancy-repl-prompt!)
-@c ../../ice-9/session.doc
+
 @deffn {Scheme Procedure} set-fancy-repl-prompt! format-string
 Set the repl prompt based on @var{format-string}.
 Each character in @var{format-string} stands for itself,
@@ -54,19 +51,15 @@ Display various forms of help depending on @var{args}, or a
 detailed description of @code{help} usage if given no args.
 @end deffn
 
-@c @twerpdoc (apropos)
-@c ../../ice-9/session.doc
 @deffn {Scheme Procedure} apropos rgx [options...]
 Search for bindings matching @var{rgx}, a regular expression string.
 @var{options} are symbols: @code{full}, @code{shadow}, @code{value}.
 @end deffn
-@c @twerpdoc (apropos-internal)
-@c ../../ice-9/session.doc
+
 @deffn {Scheme Procedure} apropos-internal rgx
 Return a list of accessible variable names for @var{rgx}.
 @end deffn
-@c @twerpdoc (apropos-fold)
-@c ../../ice-9/session.doc
+
 @deffn {Scheme Procedure} apropos-fold proc init rgx folder
 Fold PROCEDURE over bindings matching third arg REGEXP.
 
@@ -89,25 +82,19 @@ Fourth arg FOLDER is one of
   apropos-fold-all                 ;fold over all bindings
 @end example
 @end deffn
-@c @twerpdoc (apropos-fold-accessible)
-@c ../../ice-9/session.doc
+
 @deffn {Scheme Procedure} apropos-fold-accessible module
 FIXME: Docs incomplete.
 @end deffn
-@c + @twerpdoc (apropos-fold-exported)
-@c + @twerpdoc (apropos-fold-all)
-@c @twerpdoc (source)
-@c ../../ice-9/session.doc
+
 @deffn {Scheme Procedure} source obj
 Return the source code for @var{obj}, a procedure or macro.
 The source code is an acyclic structured expression (tree of symbols, etc).
 If @var{obj} does not have source code associated with it, return #f.
 @end deffn
-@c @twerpdoc (arity)
-@c ../../ice-9/session.doc
+
 @deffn {Scheme Procedure} arity proc
 Display the arity of procedure @var{proc}.
 @end deffn
-@c + @twerpdoc (system-module)
 
 @c session.texi ends here
diff --git a/doc/ref/stack-catch.texi b/doc/ref/stack-catch.texi
index 196268c..8020e89 100644
--- a/doc/ref/stack-catch.texi
+++ b/doc/ref/stack-catch.texi
@@ -19,8 +19,6 @@ one important respect: the handler procedure is executed without
 unwinding the call stack from the context of the @code{throw} expression
 that caused the handler to be invoked.
 
-@c @twerpdoc (lazy-catch (C scm_lazy_catch))
-@c ../../libguile/throw.doc
 @deffn {Scheme Procedure} lazy-catch tag thunk handler
 @deffnx {C Function} scm_lazy_catch (tag, thunk, handler)
 Behave like @code{catch}, except that the stack is
@@ -106,8 +104,6 @@ available after evaluating the form:
 (use-modules (ice-9 stack-catch))
 @end lisp
 
-@c @twerpdoc (stack-catch)
-@c ../../ice-9/stack-catch.doc
 @deffn {Scheme Procedure} stack-catch key thunk handler
 Like @code{catch}, invoke @var{thunk} in the dynamic context of
 @var{handler} for exceptions matching @var{key}, but also save the
diff --git a/doc/ref/string-fun.texi b/doc/ref/string-fun.texi
index 9a70738..cca6688 100644
--- a/doc/ref/string-fun.texi
+++ b/doc/ref/string-fun.texi
@@ -21,8 +21,6 @@ shared substring capability.  These are available by evaluating:
 (use-modules (ice-9 string-fun))
 @end lisp
 
-@c @twerpcommentary (verbatim (ice-9 string-fun))
-
 This module provides the following procedures:
 
 @verbatim
diff --git a/doc/ref/threads.texi b/doc/ref/threads.texi
index f225239..1933028 100644
--- a/doc/ref/threads.texi
+++ b/doc/ref/threads.texi
@@ -21,8 +21,6 @@ Higher level thread procedures are available by evaluating:
 The following procedures and macros provide standardized
 thread creation and mutex interaction.
 
-@c @twerpdoc (%thread-handler)
-@c ../../ice-9/threads.doc
 @deffn {Scheme Procedure} %thread-handler tag [args...]
 This procedure is specified as the standard error-handler for
 @code{make-thread} and @code{begin-thread}.  If the number of @var{args}
@@ -36,31 +34,23 @@ and signals are unmasked with @code{unmask-signals}.
 @c [FIXME: Why distinguish based on number of args?!  Cue voodoo music here.]
 @end deffn
 
-@c @twerpmacdoc (make-thread)
-@c ../../ice-9/threads.doc
 @deffn {Scheme Macro} make-thread proc [args...]
 Apply @var{proc} to @var{args} in a new thread formed by
 @code{call-with-new-thread} using @code{%thread-handler} as the error
 handler.
 @end deffn
 
-@c @twerpmacdoc (begin-thread)
-@c ../../ice-9/threads.doc
 @deffn {Scheme Macro} begin-thread first [rest...]
 Evaluate forms @var{first} and @var{rest} in a new thread formed by
 @code{call-with-new-thread} using @code{%thread-handler} as the error
 handler.
 @end deffn
 
-@c @twerpmacdoc (with-mutex)
-@c ../../ice-9/threads.doc
 @deffn {Scheme Macro} with-mutex m [body...]
 Lock mutex @var{m}, evaluate @var{body}, and then unlock @var{m}.
 These sub-operations form the branches of a @code{dynamic-wind}.
 @end deffn
 
-@c @twerpmacdoc (monitor)
-@c ../../ice-9/threads.doc
 @deffn {Scheme Macro} monitor first [rest...]
 Evaluate forms @var{first} and @var{rest} under a newly created
 anonymous mutex, using @code{with-mutex}.
-- 
1.7.6

