From 020b9e2b4364c61a668d47c4c5405295349817d8 Mon Sep 17 00:00:00 2001
From: Mark Wooding <mdw@distorted.org.uk>
Date: Thu, 26 May 2016 09:26:09 +0100
Subject: [PATCH] doc/: Align layout control commands to right margin in
 `tabbing' etc.

This is mostly clean in `--word-diff'.  Here are the exceptions.

  * doc/parsing.tex: `--word-diff' gets confused around the various
    `condition-with-location' subclasses.  This is clean in `-b', so
    there's not actually anything complicated happening here.

  * doc/parsing.tex: I've sneakily removed a pointless trailing `%'.

  * doc/runtime.tex: I've inserted a couple of linebreaks with `%' so as
    to shorten the source-file lines.

  * doc/runtime.tex: Some `\-' have harmlessly moved past `@\\' macro-
    backslashes to take their proper places on the right margin.
---
 doc/clang.tex      |  77 +++++++++++------------
 doc/concepts.tex   |  24 ++++----
 doc/layout.tex     |  24 ++++----
 doc/lispintro.tex  |   4 +-
 doc/meta.tex       |  22 ++++---
 doc/misc.tex       |  51 +++++++--------
 doc/output.tex     |   4 +-
 doc/parsing.tex    |  86 +++++++++++++-------------
 doc/runtime.tex    |  78 +++++++++++------------
 doc/structures.tex | 178 +++++++++++++++++++++++++++--------------------------
 doc/syntax.tex     |  30 ++++-----
 doc/tutorial.tex   |  66 ++++++++++----------
 12 files changed, 329 insertions(+), 315 deletions(-)

diff --git a/doc/clang.tex b/doc/clang.tex
index 0c6c4bb..c4a6a53 100644
--- a/doc/clang.tex
+++ b/doc/clang.tex
@@ -38,19 +38,19 @@ The class hierarchy is shown in~\xref{fig:codegen.c-types.classes}.
 
 \begin{figure} \centering
   \parbox{10pt}{\begin{tabbing}
-    @|c-type| \\ \ind
-      @|qualifiable-c-type| \\ \ind
-        @|simple-c-type| \\ \ind
-          @|c-class-type| \- \\
-        @|tagged-c-type| \\ \ind
-          @|c-struct-type| \\
-          @|c-union-type| \\
-          @|c-enum-type| \- \\
-        @|c-atomic-type| \\
-        @|c-pointer-type| \- \\
-      @|c-array-type| \\
-      @|c-function-type| \\ \ind
-        @|c-keyword-function-type| \-
+    @|c-type|                                                   \\ \ind
+      @|qualifiable-c-type|                                     \\ \ind
+        @|simple-c-type|                                        \\ \ind
+          @|c-class-type|                                     \-\\
+        @|tagged-c-type|                                        \\ \ind
+          @|c-struct-type|                                      \\
+          @|c-union-type|                                       \\
+          @|c-enum-type|                                      \-\\
+        @|c-atomic-type|                                        \\
+        @|c-pointer-type|                                     \-\\
+      @|c-array-type|                                           \\
+      @|c-function-type|                                        \\ \ind
+        @|c-keyword-function-type|                            \-
   \end{tabbing}}
   \caption{Classes representing C types}
 \label{fig:codegen.c-types.classes}
@@ -125,9 +125,9 @@ type specifier.  Type specifiers fit into two syntactic categories.
 \end{describe}
 
 \begin{describe}{mac}
-    {defctype \=@{ @<name> @! (@<name>^+) @} @<type-spec> \+ \\
-                @[[ @|:export| @<export-flag> @]]^* \-
-       \nlret @<names>}
+    {defctype \=@{ @<name> @! (@<name>^+) @} @<type-spec>     \+\\
+                @[[ @|:export| @<export-flag> @]]^*
+       \-\nlret @<names>}
   Defines a new symbolic type specifier @<name>; if a list of @<name>s is
   given, then all are defined in the same way.  The type constructed by using
   any of the @<name>s is as described by the type specifier @<type-spec>.
@@ -151,10 +151,10 @@ type specifier.  Type specifiers fit into two syntactic categories.
 \end{describe}
 
 \begin{describe}{mac}
-    {define-c-type-syntax @<name> @<lambda-list> \\ \ind
-      @[[ @<declaration>^* @! @<doc-string> @]] \\
-      @<form>^* \-
-     \nlret @<name>}
+    {define-c-type-syntax @<name> @<lambda-list>                \\ \ind
+      @[[ @<declaration>^* @! @<doc-string> @]]                 \\
+      @<form>^*
+     \-\nlret @<name>}
   Defines the symbol @<name> as a new type operator.  When a list of the form
   @|(@<name> @<argument>^*)| is used as a type specifier, the @<argument>s
   are bound to fresh variables according to @<lambda-list> (a destructuring
@@ -564,9 +564,10 @@ In Sod, the leaf types are
 \end{describe}
 
 \begin{describe}{mac}
-    {define-simple-c-type \=@{ @<name> @! (@<name>^+) @} @<string> \+ \\
-                            @[[ @|:export| @<export-flag> @]] \-
-      \nlret @<name>}
+    {define-simple-c-type
+       \=@{ @<name> @! (@<name>^+) @} @<string>               \+\\
+         @[[ @|:export| @<export-flag> @]]
+      \-\nlret @<name>}
   Define type specifiers for a new simple C type.  Each symbol @<name> is
   defined as a symbolic type specifier for the (unique interned) simple C
   type whose name is the value of @<string>.  Further, each @<name> is
@@ -903,15 +904,15 @@ function type is the type of the function's return value.
 
   For example,
   \begin{prog}
-    (c-type (fun \=(lisp (c-type-subtype other-func)) \+ \\
+    (c-type (fun \=(lisp (c-type-subtype other-func))         \+\\
                    ("first" int) . (c-function-arguments other-func))
   \end{prog}
   evaluates to a function type like @|other-func|, only with an additional
   argument of type @|int| added to the front of its argument list.  This
   could also have been written
   \begin{prog}
-    (let (\=(args (c-function-arguments other-func)) \+ \\
-            (ret (c-type-subtype other-func))) \- \\ \ind
+    (let (\=(args (c-function-arguments other-func))          \+\\
+            (ret (c-type-subtype other-func)))                \-\\ \ind
       (c-type (fun \=(lisp ret) ("first" int) . args)
   \end{prog}
 \end{describe}
@@ -948,9 +949,9 @@ function type is the type of the function's return value.
   follows.
   \begin{prog}
     (fun \=@<return-type>
-           @{ (@<arg-name> @<arg-type>) @}^* \+ \\
+           @{ (@<arg-name> @<arg-type>) @}^*                  \+\\
            @{ \=:keys @{ (@<kw-name> @<kw-type> @[@<kw-default>@]) @}^*
-                   @[. @<form>@] @! \+ \\
+                   @[. @<form>@] @!                           \+\\
                  . @<form> @}
   \end{prog}
   where either the symbol @|:keys| appears literally in the specifier, or the
@@ -1187,16 +1188,16 @@ Temporary names are represented by objects which implement a simple protocol.
 \end{describe}
 
 \begin{describe}{mac}
-    {definst @<code> (@<streamvar> \&key @<export>) (@<arg>^*) \\ \ind
-      @[[ @<declaration>^* @! @<doc-string> @]] \\
-      @<form>^* \-
-     \nlret @<code>}
+    {definst @<code> (@<streamvar> \&key @<export>) (@<arg>^*)  \\ \ind
+      @[[ @<declaration>^* @! @<doc-string> @]]                 \\
+      @<form>^*
+     \-\nlret @<code>}
 \end{describe}
 
 \begin{describe}{mac}
     {format-compound-statement
-        (@<stream> @<child> \&optional @<morep>) \\ \ind
-      @<declaration>^* \\
+        (@<stream> @<child> \&optional @<morep>)                \\ \ind
+      @<declaration>^*                                          \\
       @<form>^*}
 \end{describe}
 
@@ -1302,10 +1303,10 @@ Temporary names are represented by objects which implement a simple protocol.
 \end{describe}
 
 \begin{describe}{mac}
-    {with-temporary-var (@<codegen> @<var> @<type>) \\ \ind
-      @<declaration>^* \\
-      @<form>^* \-
-     \nlret @<value>^*}
+    {with-temporary-var (@<codegen> @<var> @<type>)             \\ \ind
+      @<declaration>^*                                          \\
+      @<form>^*
+     \-\nlret @<value>^*}
 \end{describe}
 
 \begin{describe}{fun}{deliver-expr @<codegen> @<target> @<expr>}
diff --git a/doc/concepts.tex b/doc/concepts.tex
index 30c6735..b4e80ca 100644
--- a/doc/concepts.tex
+++ b/doc/concepts.tex
@@ -704,7 +704,7 @@ the platform's strictest alignment requirement applies.
 The following simple function correctly allocates and returns space for an
 instance of a class given a pointer to its class object @<cls>.
 \begin{prog}
-  void *allocate_instance(const SodClass *cls) \\ \ind
+  void *allocate_instance(const SodClass *cls)                  \\ \ind
     \{ return malloc(cls@->cls.initsz); \}
 \end{prog}
 
@@ -728,7 +728,7 @@ of any use unless they've been written specifically for the purpose.
 The following simple function imprints storage at address @<p> as an instance
 of a class, given a pointer to its class object @<cls>.
 \begin{prog}
-  void imprint_instance(const SodClass *cls, void *p) \\ \ind
+  void imprint_instance(const SodClass *cls, void *p)           \\ \ind
     \{ cls@->cls.imprint(p); \}
 \end{prog}
 
@@ -853,16 +853,16 @@ program may be in an inconsistent state and should not continue.
 This simple protocol can be used, for example, to implement a reference
 counting system, as follows.
 \begin{prog}
-  [nick = ref] \\
-  class ReferenceCountedObject \{ \\ \ind
-    unsigned nref = 1; \\-
-    void inc() \{ me@->ref.nref++; \} \\-
-    [role = around] \\
-    int obj.teardown() \\
-    \{ \\ \ind
-      if (--\,--me@->ref.nref) return (1); \\
-      else return (CALL_NEXT_METHOD); \- \\
-    \} \- \\
+  [nick = ref]                                                  \\
+  class ReferenceCountedObject \{                               \\ \ind
+    unsigned nref = 1;                                          \\-
+    void inc() \{ me@->ref.nref++; \}                           \\-
+    [role = around]                                             \\
+    int obj.teardown()                                          \\
+    \{                                                          \\ \ind
+      if (--\,--me@->ref.nref) return (1);                      \\
+      else return (CALL_NEXT_METHOD);                         \-\\
+    \}                                                        \-\\
   \}
 \end{prog}
 
diff --git a/doc/layout.tex b/doc/layout.tex
index 7a82634..cbc7cd0 100644
--- a/doc/layout.tex
+++ b/doc/layout.tex
@@ -301,7 +301,7 @@
 
 
 \begin{describe}{cls}
-    {method-codegen (codegen) \\ \ind
+    {method-codegen (codegen)                                   \\ \ind
       \&key :vars :insts :temp-index
             :message :class :method :target}
 \end{describe}
@@ -372,17 +372,17 @@
 \end{describe}
 
 \begin{describe}{cls}
-    {daemon-direct-method (basic-direct-method) \\ \ind
+    {daemon-direct-method (basic-direct-method)                 \\ \ind
       \&key :message :location :class :type :body :role}
 \end{describe}
 
 \begin{describe}{cls}
-    {delegating-direct-method (basic-direct-method) \\ \ind
+    {delegating-direct-method (basic-direct-method)             \\ \ind
       \&key :message :location :class :type :body :role}
 \end{describe}
 
 \begin{describe}{cls}
-    {basic-effective-method (effective-method) \\ \ind
+    {basic-effective-method (effective-method)                  \\ \ind
       \&key :message :class :around-methods :before-methods :after-methods}
 \end{describe}
 
@@ -397,7 +397,7 @@
 \end{describe*}
 
 \begin{describe}{cls}
-    {simple-effective-method (basic-effective-method) \\ \ind
+    {simple-effective-method (basic-effective-method)           \\ \ind
       \&key :message :class
             :around-methods :before-methods :after-methods :primary-methods}
 \end{describe}
@@ -411,7 +411,7 @@
 \end{describe}
 
 \begin{describe}{cls}
-    {standard-effective-method (simple-effective-method) \\ \ind
+    {standard-effective-method (simple-effective-method)        \\ \ind
       \&key :message :class
             :around-methods :before-methods :after-methods :primary-methods}
 \end{describe}
@@ -427,7 +427,7 @@
 
 \begin{describe}{gf}
     {compute-aggregating-message-kernel
-      \=@<message> @<combination> @<target> \+ \\
+      \=@<message> @<combination> @<target>                   \+\\
         @<methods> @<arg-names> \&key}
 \end{describe}
 
@@ -436,21 +436,21 @@
 \end{describe}
 
 \begin{describe}{cls}
-     {aggregating-effective-method (simple-effective-method) \\ \ind
+     {aggregating-effective-method (simple-effective-method)    \\ \ind
       \&key :message :class
             :around-methods :before-methods :after-methods :primary-methods}
 \end{describe}
 
 \begin{describe}{mac}
-    {define-aggregating-method-combination @<combination> \\ \ind\ind
+    {define-aggregating-method-combination @<combination>       \\ \ind\ind
         ((@<var-name>^*)
          @[[ :codegen @<codegen-var> @!
-             :methods @<methods-var> @]]) \- \\
+             :methods @<methods-var> @]])                     \-\\
       @[[ \=:properties (@{ (@{ @<name> @! (@[@<keyword>@] @<name>) @}
                              @<c-type>
                              @[@<default>
-                               @[@<suppliedp-var>@]@]) @}^*) @! \+ \\
-            :return-type @<c-type> @! \\
+                               @[@<suppliedp-var>@]@]) @}^*) @! \+\\
+            :return-type @<c-type> @!                           \\
             :around @<around-func> @!
             :first-method @<first-method-func> @!
             :method @<method-func> @]]}
diff --git a/doc/lispintro.tex b/doc/lispintro.tex
index 02105d0..c628a2c 100644
--- a/doc/lispintro.tex
+++ b/doc/lispintro.tex
@@ -183,8 +183,8 @@ category (function, class, macro, etc.) on the right.
 
 \begin{describe}{mac}
     {example-macro
-        (@{ @<symbol> @! (@<symbol> @<form>) @}^*) \\ \ind
-      @[[ @<declaration>^* @! @<doc-string> @]] \\
+        (@{ @<symbol> @! (@<symbol> @<form>) @}^*)              \\ \ind
+      @[[ @<declaration>^* @! @<doc-string> @]]                 \\
       @<form>^*
      \nlret @<value>^*}
   The synopsis for a macro describes the acceptable syntax using the
diff --git a/doc/meta.tex b/doc/meta.tex
index 6707c42..bbe1964 100644
--- a/doc/meta.tex
+++ b/doc/meta.tex
@@ -29,11 +29,11 @@
 \section{Base metaobject classes} \label{sec:meta.classes}
 
 \begin{describe}{cls}
-    {sod-class () \\ \ind
-      \&key \=:name :nick :location :pset \+ \\
-              :superclasses :link :metaclass \\
+    {sod-class ()                                               \\ \ind
+      \&key \=:name :nick :location :pset                     \+\\
+              :superclasses :link :metaclass                    \\
               :slots :instance-initializers :class-initializers \\
-              :initargs :initfrags :tearfrags \\
+              :initargs :initfrags :tearfrags                   \\
               :messages :methods}
 \end{describe}
 
@@ -125,7 +125,7 @@
 \end{describe}
 
 \begin{describe}{cls}
-    {sod-class-slot (sod-slot) \\ \ind
+    {sod-class-slot (sod-slot)                                  \\ \ind
       \&key :name :location :pset :class :type
             :initializer-function :prepare-function}
 \end{describe}
@@ -252,15 +252,17 @@
 \end{describe*}
 
 \begin{describe}{gf}
-    {make-sod-method \=@<class> @<nick> @<name> @<type> @<body> \+ \\
-                       @<pset> \&optional @<floc> \-
+    {make-sod-method
+        \=@<class> @<nick> @<name> @<type> @<body>            \+\\
+          @<pset> \&optional @<floc>                          \-
       \nlret @<method>}
 \end{describe}
 
 \begin{describe}{gf}
-    {make-sod-method-using-message \=@<message> @<class>
-                                     @<type> @<body> \+ \\
-                                     @<pset> \&optional @<floc> \-
+    {make-sod-method-using-message
+        \=@<message> @<class>
+          @<type> @<body>                                     \+\\
+          @<pset> \&optional @<floc>                          \-
       \nlret @<method>}
 \end{describe}
 
diff --git a/doc/misc.tex b/doc/misc.tex
index dce192e..5bf3e18 100644
--- a/doc/misc.tex
+++ b/doc/misc.tex
@@ -31,15 +31,15 @@
 These symbols are defined in the @|sod-utilities| package.
 
 \begin{describe}{mac}
-    {with-gensyms (@{ @<var> @! (@<var> @[@<name>@]) @}^*) \\ \ind
-      @<declaration>^* \\
+    {with-gensyms (@{ @<var> @! (@<var> @[@<name>@]) @}^*)      \\ \ind
+      @<declaration>^*                                          \\
       @<form>^*}
 \end{describe}
 
 \begin{describe}{mac}
     {once-only (@[[ :environment @<env> @]]
-                @{ @<var> @! (@<var> @[@<value-form>@]) @}^*) \\ \ind
-      @<declaration>^* \\
+                @{ @<var> @! (@<var> @[@<value-form>@]) @}^*)   \\ \ind
+      @<declaration>^*                                          \\
       @<form>^*}
 \end{describe}
 
@@ -65,8 +65,8 @@ These symbols are defined in the @|sod-utilities| package.
 \begin{describe}{mac}
     {with-locatives
         @{ @<var> @! (@{ @<var> @!
-                         (@<var> @[@<locative>@]) @}^*) @} \\ \ind
-      @<declaration>^* \\
+                         (@<var> @[@<locative>@]) @}^*) @}      \\ \ind
+      @<declaration>^*                                          \\
       @<form>^*}
 \end{describe}
 
@@ -138,12 +138,13 @@ These symbols are defined in the @|sod-utilities| package.
 
 \begin{describe}{mac}
     {categorize (\=@<item-var> @<items>
-                   @[[ :bind (@{ @<var> @! (@<var> @[@<value>@]) @}^*) @]])
-                                                                 \\ \ind\ind
-        (@{ (@<cat-var> @<cat-predicate>) @}^*) \- \\
-      @<declaration>^* \\
-      @<body-form>^* \-
-     \nlret @<value>^*}
+                   @[[ :bind (@{ @<var> @!
+                                 (@<var> @[@<value>@]) @}^*) @]])
+                                                                \\ \ind\ind
+        (@{ (@<cat-var> @<cat-predicate>) @}^*)               \-\\
+      @<declaration>^*                                          \\
+      @<body-form>^*
+     \-\nlret @<value>^*}
 \end{describe}
 
 \begin{describe}{fun}
@@ -172,10 +173,11 @@ These symbols are defined in the @|sod-utilities| package.
 \end{describe}
 
 \begin{describe}{mac}
-    {maybe-print-unreadable-object (@<object> @<stream>
-                                    @[[ :type @<type> @!
-                                        :identity @<identity> @]]) \\ \ind
-      @<declaration>^* \\
+    {maybe-print-unreadable-object
+        (@<object> @<stream>
+         @[[ :type @<type> @!
+             :identity @<identity> @]])                         \\ \ind
+      @<declaration>^*                                          \\
       @<form>^*}
 \end{describe}
 
@@ -185,8 +187,8 @@ These symbols are defined in the @|sod-utilities| package.
 \begin{describe}{mac}
     {dosequence (@<var> @<sequence>
                  @[[ :start @<start> @! :end @<end> @!
-                     :indexvar @<var> @]]) \\ \ind
-      @<declaration>^* \\
+                     :indexvar @<var> @]])                      \\ \ind
+      @<declaration>^*                                          \\
       @{ @<tag> @! @<statement> @}^*}
 \end{describe}
 
@@ -196,13 +198,13 @@ These symbols are defined in the @|sod-utilities| package.
 \end{describe}
 
 \begin{describe}{mac}
-    {default-slot (@<instance> @<slot> @[@<slot-names>@]) \\ \ind
+    {default-slot (@<instance> @<slot> @[@<slot-names>@])       \\ \ind
       @<form>^*}
 \end{describe}
 
 \begin{describe}{mac}
-    {define-on-demand-slot @<class> @<slot> (@<instance>) \\ \ind
-      @[[ @<declaration>^* @! @<doc-string> @]] \\
+    {define-on-demand-slot @<class> @<slot> (@<instance>)       \\ \ind
+      @[[ @<declaration>^* @! @<doc-string> @]]                 \\
       @<form>^*}
 \end{describe}
 
@@ -254,9 +256,10 @@ These symbols are defined in the @!optparse| package.
 \end{describe}
 
 \begin{describe}{fun}
-    {make-option \=@<long-name> @<short-name> \+ \\
-                   \&optional @<arg-name> \\
-                   \&key :tag :negated-tag :arg-optional-p :documentation \-
+    {make-option \=@<long-name> @<short-name>                 \+\\
+                   \&optional @<arg-name>                       \\
+                   \&key :tag :negated-tag
+                         :arg-optional-p :documentation       \-
       \nlret @<option>}
 \end{describe}
 
diff --git a/doc/output.tex b/doc/output.tex
index b5b06a3..4571b6a 100644
--- a/doc/output.tex
+++ b/doc/output.tex
@@ -156,8 +156,8 @@ until the third.  So the final processing order is
 \end{describe}
 
 \begin{describe}{mac}
-    {sequence-output (@<stream-var> @<sequencer>) \\ \ind
-      @{ :constraint (@<item-name>^*) @} \\
+    {sequence-output (@<stream-var> @<sequencer>)               \\ \ind
+      @{ :constraint (@<item-name>^*) @}                        \\
       @{ (@<item-name> @<form>^*) @}^*}
 \end{describe}
 
diff --git a/doc/parsing.tex b/doc/parsing.tex
index faa7a22..adcc9e1 100644
--- a/doc/parsing.tex
+++ b/doc/parsing.tex
@@ -89,30 +89,30 @@ consumed any input items.
 \begin{describe*}
     {\quad\=\quad\=\kill
      \dhead{cls}
-       {error-with-location (condition-with-location error) \\ \>
+       {error-with-location (condition-with-location error)     \\ \>
          \&key :location}
      \dhead{cls}
        {warning-with-location (condition-with-location warning) \\ \>
          \&key :location}
      \dhead{cls}
        {enclosing-error-with-location
-           (enclosing-error-with-location error) \\ \>
+           (enclosing-error-with-location error)                \\ \>
          \&key :condition :location}
      \dhead{cls}
        {enclosing-warning-with-location
-           (enclosing-condition-with-location warning) \\ \>
+           (enclosing-condition-with-location warning)          \\ \>
          \&key :condition :location}
      \dhead{cls}
        {simple-condition-with-location
-           (condition-with-location simple-condition) \\ \>
+           (condition-with-location simple-condition)           \\ \>
          \&key :format-control :format-arguments :location}
      \dhead{cls}
        {simple-error-with-location
-           (error-with-location simple-error) \\ \>
+           (error-with-location simple-error)                   \\ \>
          \&key :format-control :format-arguments :location}
      \dhead{cls}
        {simple-warning-with-location
-           (warning-with-location simple-warning) \\ \>
+           (warning-with-location simple-warning)               \\ \>
          \&key :format-control :format-arguments :location}}
 \end{describe*}
 
@@ -377,8 +377,8 @@ file-location protocols.
   characters from a scanner in bulk.  The function @<func> is invoked
   repeatedly, as if by
   \begin{prog}
-    (multiple-value-bind (@<donep> @<used>) \\ \ind\ind
-        (funcall @<func> @<buf> @<start> @<end>) \- \\
+    (multiple-value-bind (@<donep> @<used>)                     \\ \ind\ind
+        (funcall @<func> @<buf> @<start> @<end>)              \-\\
       \textrm\ldots)
   \end{prog}
   The argument @<buf> is a simple string; @<start> and @<end> are two
@@ -394,8 +394,8 @@ file-location protocols.
   fails: the @<fail> function is called with no arguments, and is expected to
   return two values.  If omitted, @<fail> defaults to
   \begin{prog}
-    (lambda () \\ \ind
-      (values nil nil))%
+    (lambda ()                                                  \\ \ind
+      (values nil nil))
   \end{prog}
 
   The @|charbuf-scanner-map| function returns three values.  The first value
@@ -454,18 +454,18 @@ file-location protocols.
 
 \begin{describe}{mac}
     {defparse @<name> (@[[ :context (@<var> @<context-class>) @]]
-                       @<destructuring-lambda-list-item>^*) \\ \ind
-      @[[ @<declaration>^* @! @<doc-string> @]] \\
-      @<form>^* \-
-     \nlret @<name>}
+                       @<destructuring-lambda-list-item>^*)     \\ \ind
+      @[[ @<declaration>^* @! @<doc-string> @]]                 \\
+      @<form>^*
+     \-\nlret @<name>}
 \end{describe}
 
 \begin{describe}{mac}
     {with-parser-context
-        (@<context-class> @{ @<init-keyword> @<value> @}^*) \\ \ind
-      @<declaration>^* \\
-      @<form>^* \-
-     \nlret @<value>^*}
+        (@<context-class> @{ @<init-keyword> @<value> @}^*)     \\ \ind
+      @<declaration>^*                                          \\
+      @<form>^*
+     \-\nlret @<value>^*}
 \end{describe}
 
 \begin{describe}{lmac}
@@ -490,26 +490,26 @@ file-location protocols.
 
 \begin{describe}{mac}
     {if-parse (@[[ \=:result @<result-var> @!
-                     :expected @<expected-var> @! \+ \\
-                     :consumedp @<consumed-var> @]]) \- \\ \ind\ind
-        @<parser> \- \\
-      @<consequent> \\
-      @[@<alternatve>@] \-
-     \nlret @<value>^*}
+                     :expected @<expected-var> @!             \+\\
+                     :consumedp @<consumed-var> @]])          \-\\ \ind\ind
+        @<parser>                                             \-\\
+      @<consequent>                                             \\
+      @[@<alternatve>@]
+     \-\nlret @<value>^*}
 \end{describe}
 
 \begin{describe}{mac}
-    {when-parse (@[@<result-var>@]) @<parser> \\ \ind
-      @<form>^* \-
-     \nlret @<value>^*}
+    {when-parse (@[@<result-var>@]) @<parser>                   \\ \ind
+      @<form>^*
+     \-\nlret @<value>^*}
 \end{describe}
 
 \begin{describe}{mac}
     {cond-parse (@[[ \=:result @<result-var> @!
-                       :expected @<expected-var> @! \+ \\
-                       :consumedp @<consumed-var> @]]) \- \\ \ind
-      @{ (@<parser> @<form>^*) @}^* \-
-     \nlret @<value>^*}
+                       :expected @<expected-var> @!           \+\\
+                       :consumedp @<consumed-var> @]])        \-\\ \ind
+      @{ (@<parser> @<form>^*) @}^*
+     \-\nlret @<value>^*}
 \end{describe}
 
 \begin{describe}{parse}{:eof}
@@ -537,7 +537,8 @@ file-location protocols.
 \end{describe}
 
 \begin{describe}{parseform}
-    {seq (@{ @<atomic-parser-spec> @! (@[@<var>@] @<parser>) @}^*) \\ \ind
+    {seq (@{ @<atomic-parser-spec> @!
+             (@[@<var>@] @<parser>) @}^*)                       \\ \ind
       @<body-form>^*}
 \end{describe}
 
@@ -551,22 +552,22 @@ file-location protocols.
 \end{describe}
 
 \begin{describe}{parseform}
-    {many (\=@<accumulator-var> @<init-form> @<update-form> \+ \\
-           @[[ \=:new @<new-var> @! :final @<final-form> @! \+ \\
-                 :min @<minimum> @! :max @<maximum> @! \\
-                 :commitp @<commitp> @]]) \-\- \\ \ind
+    {many (\=@<accumulator-var> @<init-form> @<update-form>   \+\\
+           @[[ \=:new @<new-var> @! :final @<final-form> @!   \+\\
+                 :min @<minimum> @! :max @<maximum> @!          \\
+                 :commitp @<commitp> @]])                   \-\-\\ \ind
       @<item-parser> @[@<sep-parser>@]}
 \end{describe}
 
 \begin{describe}{parseform}
     {list (@[[ :min @<minimum> @! :max @<maximum> @!
-               :commitp @<commitp> @]])\\ \ind
+               :commitp @<commitp> @]])                         \\ \ind
       @<item-parser> @[@<sep-parser>@]}
 \end{describe}
 
 \begin{describe}{parseform}
     {skip-many (@[[ :min @<minimum> @! :max @<maximum> @!
-                    :commitp @<commitp> @]])\\ \ind
+                    :commitp @<commitp> @]])                    \\ \ind
       @<item-parser> @[@<sep-parser>@]}
 \end{describe}
 
@@ -692,7 +693,7 @@ file-location protocols.
 \end{describe}
 
 \begin{describe}{parseform}
-    {expr \=(@[[ :nestedp @<nestedp-var> @]]) \+ \\
+    {expr \=(@[[ :nestedp @<nestedp-var> @]])                 \+\\
             @<operand-parser> @<binop-parser>
             @<preop-parser> @<postop-parser>}
 \end{describe}
@@ -718,12 +719,13 @@ file-location protocols.
 
 \begin{describe*}
     {\quad\=\kill
-     \dhead{cls}{simple-binary-operator (simple-operator) \\ \>
-                  \&key :name :function :lprec :rprec :associativity}
+     \dhead{cls}{simple-binary-operator (simple-operator)       \\ \>
+                  \&key :name :function
+                        :lprec :rprec :associativity}
      \dhead{cls}{simple-postfix-operator (simple-unary-operator) \\ \>
                   \&key :name :function :lprec :rprec}
      \dhead{cls}{simple-prefix-operator
-                    (prefix-operator simple-unary-operator) \\ \>
+                    (prefix-operator simple-unary-operator)     \\ \>
                   \&key :name :function :rprec}}
 \end{describe*}
 
diff --git a/doc/runtime.tex b/doc/runtime.tex
index 0490763..75055e5 100644
--- a/doc/runtime.tex
+++ b/doc/runtime.tex
@@ -43,9 +43,9 @@ The header file defines two simple structure types, and a function type which
 will be described later.
 
 \begin{describe}[struct kwval]{type}
-    {struct kwval \{ \\ \ind
-       const char *kw; \\
-       const void *val; \- \\
+    {struct kwval \{                                            \\ \ind
+       const char *kw;                                          \\
+       const void *val;                                       \-\\
      \};}
 
   The @|kwval| structure describes a keyword argument name/value pair.  The
@@ -56,9 +56,9 @@ will be described later.
 \end{describe}
 
 \begin{describe}[struct kwtab]{type}
-    {struct kwtab \{ \\ \ind
-       const struct kwval *v; \\
-       size_t n; \- \\
+    {struct kwtab \{                                            \\ \ind
+       const struct kwval *v;                                   \\
+       size_t n;                                              \-\\
      \};}
 
   The @|kwtab| structure describes a list of keyword arguments, represented
@@ -203,8 +203,8 @@ list items of the form
 \end{prog}
 with no separation between them.  For example:
 \begin{prog}
-  \#define example_KWSET(_) @\\ \\ \ind
-    _(int, x, 0) @\\ \\
+  \#define example_KWSET(_) @\\                                 \\ \ind
+    _(int, x, 0) @\\                                            \\
     _(const char *, y, NULL)
 \end{prog}
 
@@ -285,9 +285,10 @@ keyword arguments.
   The macro @|KWSET_PARSEFN| defines a keyword argument \emph{parser
   function}
   \begin{prog}
-    void @<set>{}_kwparse(\=struct @<set>{}_kwargs *@<kw>,
-                            const char *@<kwfirst>, va_list *@<ap>, \+ \\
-                            const struct kwval *@<v>, size_t @<n>);
+    void @<set>{}_kwparse%
+      (\=struct @<set>{}_kwargs *@<kw>,
+         const char *@<kwfirst>, va_list *@<ap>,              \+\\
+         const struct kwval *@<v>, size_t @<n>);
   \end{prog}
   The macro call can (and usually will) be preceded by storage class
   specifiers such as @|static|, for example to adjust the linkage of the
@@ -417,9 +418,10 @@ allow keyword arguments.
 \end{describe}
 
 \begin{describe}[kw_parseempty]{fun}
-    {void kw_parseempty(\=const char *@<set>,
-                          const char *@<kwfirst>, va_list *@<ap>, \+ \\
-                          const struct kwval *@<v>, size_t @<n>);}
+    {void kw_parseempty%
+      (\=const char *@<set>,
+         const char *@<kwfirst>, va_list *@<ap>,              \+\\
+         const struct kwval *@<v>, size_t @<n>);}
   This function checks an keyword argument list to make sure that contains no
   keyword arguments (other than the special ones described in
   \xref{sec:runtime.keywords.calling}).
@@ -551,33 +553,33 @@ particular keyword argument.
 
 \begin{prog}
   \#define KWARGS_TEST(k, val) KWARGS(K(k, val) K(kw.unknown, 0))
-  \\+
+                                                                \\+
   static jmp_buf kw_test_jmp;
-  \\+
-  static void kw_test_unknown(const char *set, const char *kw) \\
-  \{ \\ \ind
-    if (strcmp(kw, "kw.unknown")) longjmp(kw_test_jmp, 1); \\
-    else longjmp(kw_test_jmp, 2); \- \\
-  \}
-  \\+
-  \#define KW_TEST(flag, set, call) do \{ @\\ \\ \ind
-    kw_unkhookfn *oldunk = kw_unkhook; @\\ \\
-    kw_unkhook = kw_test_unknown; @\\ \\
-    switch (setjmp(kw_test_jmp)) \{ @\\ \\ \ind
-      case 0: call; abort(); @\\ \\
-      case 1: flag = 1; break; @\\ \\
-      case 2: flag = 0; break; @\\ \\
-      default: abort(); \- @\\ \\
-    \} @\\ \\
-    kw_unkhook = oldunk; \- @\\ \\
-  \} while (0)
-  \\+
-  @/* Example of use */ \\
-  int f; \\
+                                                                \\+
+  static void kw_test_unknown(const char *set, const char *kw)  \\
+  \{                                                            \\ \ind
+    if (strcmp(kw, "kw.unknown")) longjmp(kw_test_jmp, 1);      \\
+    else longjmp(kw_test_jmp, 2);                             \-\\
+  \}                                                            \\+
+
+  \#define KW_TEST(flag, set, call) do \{ @\\                   \\ \ind
+    kw_unkhookfn *oldunk = kw_unkhook; @\\                      \\
+    kw_unkhook = kw_test_unknown; @\\                           \\
+    switch (setjmp(kw_test_jmp)) \{ @\\                         \\ \ind
+      case 0: call; abort(); @\\                                \\
+      case 1: flag = 1; break; @\\                              \\
+      case 2: flag = 0; break; @\\                              \\
+      default: abort(); @\\                                   \-\\
+    \} @\\                                                      \\
+    kw_unkhook = oldunk; @\\                                  \-\\
+  \} while (0)                                                  \\+
+
+  @/* Example of use */                                         \\
+  int f;                                                        \\
   KW_TEST(f, somefunc(1, "two", 3, KWARGS_TEST("shiny", 68.7))); \\
   /\=* \comment{now @|f| is nonzero if @|somefunc| accepts the
-        @|shiny| keyword} \+ \\
-   {}* \comment{(which we hope wants a @|double| argument)} \\
+        @|shiny| keyword}                                     \+\\
+   {}* \comment{(which we hope wants a @|double| argument)}     \\
    {}*/
 \end{prog}
 
diff --git a/doc/structures.tex b/doc/structures.tex
index 3826bdc..2cebaa1 100644
--- a/doc/structures.tex
+++ b/doc/structures.tex
@@ -46,8 +46,8 @@ Instance chains contain slots and vtable pointers, as described below.  All
 instances have the basic structure of a @|struct sod_instance|.
 
 \begin{describe}[struct sod_instance]{type}
-    {struct sod_instance \{ \\ \ind
-       const struct sod_vtable *_vt; \- \\
+    {struct sod_instance \{                                     \\ \ind
+       const struct sod_vtable *_vt;                          \-\\
      \};}
 
   The basic structure of all instances.  Members are as follows.
@@ -58,9 +58,9 @@ instances have the basic structure of a @|struct sod_instance|.
 \end{describe}
 
 \begin{describe}[struct sod_vtable]{type}
-    {struct sod_vtable \{ \\ \ind
-       const SodClass *_class; \\
-       size_t _base; \- \\
+    {struct sod_vtable \{                                       \\ \ind
+       const SodClass *_class;                                  \\
+       size_t _base;                                          \-\\
      \};}
 
   A vtable contains static metadata needed for efficient conversions and
@@ -93,34 +93,35 @@ recommended.
 \begin{figure}[tbp]
   \begin{tabular}{p{10pt}p{10pt}}
     \begin{nprog}
-      struct SodObject__ilayout \{ \\ \ind
-        union \{ \\ \ind
-          struct SodObject__ichain_obj \{ \\ \ind
-            const struct SodObject__vt_obj *_vt; \- \\
-          \} obj; \- \\
-        \} obj; \- \\
+      struct SodObject__ilayout \{                              \\ \ind
+        union \{                                                \\ \ind
+          struct SodObject__ichain_obj \{                       \\ \ind
+            const struct SodObject__vt_obj *_vt;              \-\\
+          \} obj;                                             \-\\
+        \} obj;                                               \-\\
       \};
     \end{nprog}
     &
     \begin{nprog}
-      struct SodObject__vt_obj \{ \\ \ind
-        const SodClass *_class; \\
-        size_t _base; \\
-        struct SodObject__vtmsgs_obj \{ \\ \ind
-          void (*init)(SodObject *me, ...); \\
-          void (*init__v)(SodObject *me, va_list); \\
-          int (*teardown)(SodObject *me); \- \\
-        \} obj; \- \\
+      struct SodObject__vt_obj \{                               \\ \ind
+        const SodClass *_class;                                 \\
+        size_t _base;                                           \\
+        struct SodObject__vtmsgs_obj \{                         \\ \ind
+          void (*init)(SodObject *me, ...);                     \\
+          void (*init__v)(SodObject *me, va_list);              \\
+          int (*teardown)(SodObject *me);                     \-\\
+        \} obj;                                               \-\\
       \};
-    \end{nprog} \\
+    \end{nprog}                                                 \\
   \end{tabular}
   \caption{Instance and vtable layout of @|SodObject|}
   \label{fig:structures.root.sodobject}
 \end{figure}
 
 \begin{describe}[SodObject]{cls}
-    {[nick = obj, metaclass = SodClass, lisp_metaclass = sod_class] \\
-     class SodObject \{ \\ \ind
+    {[nick = obj, metaclass = SodClass,
+      lisp_metaclass = sod_class]                               \\
+     class SodObject \{                                         \\ \ind
        void init(?);
      \}}
 
@@ -199,24 +200,24 @@ recommended.
 \subsection{The SodClass class} \label{sec:structures.root.sodclass}
 
 \begin{describe}[SodClass]{cls}
-    {[nick = cls, link = SodObject] \\
-     class SodClass : SodObject \{ \\ \ind
-       const char *name; \\
-       const char *nick; \\
-       size_t initsz; \\
-       size_t align; \\
-       void *(*imprint)(void *@<p>); \\
-       size_t n_supers; \\
-       const SodClass *const *supers; \\
-       size_t n_cpl; \\
-       const SodClass *const *cpl; \\
-       const SodClass *link; \\
-       const SodClass *head; \\
-       size_t level; \\
-       size_t n_chains; \\
-       const struct sod_chain *chains; \\
-       size_t off_islots; \\
-       size_t islotsz; \- \\
+    {[nick = cls, link = SodObject]                             \\
+     class SodClass : SodObject \{                              \\ \ind
+       const char *name;                                        \\
+       const char *nick;                                        \\
+       size_t initsz;                                           \\
+       size_t align;                                            \\
+       void *(*imprint)(void *@<p>);                            \\
+       size_t n_supers;                                         \\
+       const SodClass *const *supers;                           \\
+       size_t n_cpl;                                            \\
+       const SodClass *const *cpl;                              \\
+       const SodClass *link;                                    \\
+       const SodClass *head;                                    \\
+       size_t level;                                            \\
+       size_t n_chains;                                         \\
+       const struct sod_chain *chains;                          \\
+       size_t off_islots;                                       \\
+       size_t islotsz;                                        \-\\
      \}}
 
   The @|SodClass| class defines no additional messages , but there are a
@@ -289,12 +290,12 @@ recommended.
 \end{describe}
 
 \begin{describe}[struct sod_chain]{type}
-    {struct sod_chain \{ \\ \ind
-       size_t n_classes; \\
-       const SodClass *const *classes; \\
-       size_t off_ichain; \\
-       const struct sod_vtable *vt; \\
-       size_t ichainsz; \- \\
+    {struct sod_chain \{                                        \\ \ind
+       size_t n_classes;                                        \\
+       const SodClass *const *classes;                          \\
+       size_t off_ichain;                                       \\
+       const struct sod_vtable *vt;                             \\
+       size_t ichainsz;                                       \-\\
      \};}
 
   The @|struct sod_chain| structure describes an individual chain of
@@ -350,25 +351,25 @@ The entire state of an instance of $C$ is contained in a single structure of
 type @|struct $C$__ilayout|.
 
 \begin{prog}
-  struct $C$__ilayout \{ \\ \ind
-    union $C$__ichainu_$h$ \{ \\ \ind
-      struct $C$__ichain_$h$ \{ \\ \ind
-        const struct $C$__vt_$h$ *_vt; \\
-        struct $H$__islots $h$; \\
-        \quad$\vdots$ \\
-        struct $C$__islots \{ \\ \ind
-          @<type>_1 @<slot>_1; \\
-          \quad$\vdots$ \\
-          @<type>_n @<slot>_n; \- \\
-        \} $c$; \- \\
-      \} $c$; \\
-      struct $H$__ichain_$h$ $h$; \\
-      \quad$\vdots$ \- \\
-    \} $h$; \\
-    union $B$__ichainu_$i$ $i$; \\
-    \quad$\vdots$ \- \\
-  \};
-  \\+
+  struct $C$__ilayout \{                                        \\ \ind
+    union $C$__ichainu_$h$ \{                                   \\ \ind
+      struct $C$__ichain_$h$ \{                                 \\ \ind
+        const struct $C$__vt_$h$ *_vt;                          \\
+        struct $H$__islots $h$;                                 \\
+        \quad$\vdots$                                           \\
+        struct $C$__islots \{                                   \\ \ind
+          @<type>_1 @<slot>_1;                                  \\
+          \quad$\vdots$                                         \\
+          @<type>_n @<slot>_n;                                \-\\
+        \} $c$;                                               \-\\
+      \} $c$;                                                   \\
+      struct $H$__ichain_$h$ $h$;                               \\
+      \quad$\vdots$                                           \-\\
+    \} $h$;                                                     \\
+    union $B$__ichainu_$i$ $i$;                                 \\
+    \quad$\vdots$                                             \-\\
+  \};                                                           \\+
+
   typedef struct $C$__ichain_$h$ $C$;
 \end{prog}
 
@@ -457,23 +458,23 @@ method.
 A vtable for a class $C$ with chain head $H$ has the following general
 structure.
 \begin{prog}
-  union $C$__vtu_$h$ \{ \\ \ind
-    struct $C$__vt_$h$ \{ \\ \ind
-      const $P$ *_class; \\
-      size_t _base; \\
-      \quad$\vdots$ \\
-      const $Q$ *_cls_$j$; \\
-      \quad$\vdots$ \\
-      ptrdiff_t _off_$i$; \\
-      \quad$\vdots$ \\
-      struct $C$__vtmsgs_$a$ \{ \\ \ind
-        @<type> (*@<msg>)($C$ *, $\dots$); \\
-        \quad$\vdots$ \- \\
-      \} $a$; \\
-      \quad$\vdots$ \- \\
-    \} $c$; \- \\
-  \};
-  \\+
+  union $C$__vtu_$h$ \{                                         \\ \ind
+    struct $C$__vt_$h$ \{                                       \\ \ind
+      const $P$ *_class;                                        \\
+      size_t _base;                                             \\
+      \quad$\vdots$                                             \\
+      const $Q$ *_cls_$j$;                                      \\
+      \quad$\vdots$                                             \\
+      ptrdiff_t _off_$i$;                                       \\
+      \quad$\vdots$                                             \\
+      struct $C$__vtmsgs_$a$ \{                                 \\ \ind
+        @<type> (*@<msg>)($C$ *, $\dots$);                      \\
+        \quad$\vdots$                                         \-\\
+      \} $a$;                                                   \\
+      \quad$\vdots$                                           \-\\
+    \} $c$;                                                   \-\\
+  \};                                                           \\+
+
   extern const union $C$__vtu_$h$ $C$__vtable_$h$;
 \end{prog}
 
@@ -589,9 +590,12 @@ defined as
 \end{prog}
 or a standard message which takes keyword arguments, defined as
 \begin{prog}
-  @<type>_0 $m$(\=@<type>_1 @<arg>_1, $\ldots$, @<type>_n @<arg>_n? \+ \\
-                  @<type>_{n+1} @<kw>_{n+1} @[= @<dflt>_{n+1}@], $\ldots$,
-                  @<type>_m @<kw>_m @[= @<dflt>_m@]);
+  @<type>_0 $m$(\=@<type>_1 @<arg>_1,
+                    $\ldots$,
+                    @<type>_n @<arg>_n?                       \+\\
+                  @<type>_{n+1} @<kw>_{n+1} @[= @<dflt>_{n+1}@],
+                    $\ldots$,
+                    @<type>_m @<kw>_m @[= @<dflt>_m@]);
 \end{prog}
 two entry points are defined: the usual `main' entry point which accepts a
 variable number of arguments, and a `valist' entry point which accepts an
@@ -599,7 +603,7 @@ argument of type @|va_list| in place of the variable portion of the argument
 list or keywords.
 \begin{prog}
   @<type>_0 $m$($C$ *me, @<type>_1 @<arg>_1, $\ldots$,
-                @<type>_n @<arg>_n, \dots); \\
+                @<type>_n @<arg>_n, \dots);                     \\
   @<type>_0 $m$__v($C$ *me, @<type>_1 @<arg>_1, $\ldots$,
                    @<type>_n @<arg>_n, va_list sod__ap);
 \end{prog}
@@ -638,7 +642,7 @@ defined for the sake of completeness.
 
 Finally, the class object is defined as
 \begin{prog}
-  extern const struct $R$__ilayout $C$__classobj; \\
+  extern const struct $R$__ilayout $C$__classobj;               \\
   \#define $C$__class (\&$C$__classobj.$j$.$r$)
 \end{prog}
 The exported symbol @|$C$__classobj| contains the entire class instance.
diff --git a/doc/syntax.tex b/doc/syntax.tex
index 0b7456f..65bd727 100644
--- a/doc/syntax.tex
+++ b/doc/syntax.tex
@@ -579,14 +579,14 @@ A @<class-forward-declaration> informs Sod that an @<identifier> will be used
 to name a class which is currently undefined.  Forward declarations are
 necessary in order to resolve certain kinds of circularity.  For example,
 \begin{prog}
-class Sub;
-\\+
-class Super : SodObject \{ \\ \ind
-  Sub *sub; \- \\
-\};
-\\+
-class Sub : Super \{ \\ \ind
-  /* \dots */ \- \\
+class Sub;                                                      \\+
+
+class Super : SodObject \{                                      \\ \ind
+  Sub *sub;                                                   \-\\
+\};                                                             \\+
+
+class Sub : Super \{                                            \\ \ind
+  /* \dots\ */                                                \-\\
 \};
 \end{prog}
 
@@ -665,17 +665,17 @@ An @<initializer>, if present, is treated as if a separate
 @<initializer-item> containing the slot name and initializer were present.
 For example,
 \begin{prog}
-[nick = eg] \\-
-class Example : Super \{ \\ \ind
-  int foo = 17; \- \\
+[nick = eg]                                                     \\
+class Example : Super \{                                        \\ \ind
+  int foo = 17;                                               \-\\
 \};
 \end{prog}
 means the same as
 \begin{prog}
-[nick = eg] \\-
-class Example : Super \{ \\ \ind
-  int foo; \\
-  eg.foo = 17; \- \\
+[nick = eg]                                                     \\
+class Example : Super \{                                        \\ \ind
+  int foo;                                                      \\
+  eg.foo = 17;                                                \-\\
 \};
 \end{prog}
 
diff --git a/doc/tutorial.tex b/doc/tutorial.tex
index f313e0e..ac38e06 100644
--- a/doc/tutorial.tex
+++ b/doc/tutorial.tex
@@ -96,10 +96,10 @@ The main consequences of this are as follows.
 Of course, this means that your build system needs to become more
 complicated.  If you use \man{make}{1}, then something like
 \begin{prog}
-  SOD = sod
-  \\+
-  .SUFFIXES: .sod .c .h \\
-  .sod.c:; \$(SOD) -tc \$< \\
+  SOD = sod                                                     \\+
+
+  .SUFFIXES: .sod .c .h                                         \\
+  .sod.c:; \$(SOD) -tc \$<                                      \\
   .sod.h:; \$(SOD) -th \$<
 \end{prog}
 ought to do the job.
@@ -109,21 +109,21 @@ ought to do the job.
 
 The following is a simple Sod input file.
 \begin{prog}
-  /* -*-sod-*- */
-  \\+
-  code c : includes \{ \\
-  \#include "greeter.h" \\
-  \}
-  \\+
-  code h : includes \{ \\
-  \#include <stdio.h> \\
-  \#include <sod/sod.h> \\
-  \}
-  \\+
-  class Greeter : SodObject \{ \\ \ind
-    void greet(FILE *fp) \{ \\ \ind
-      fputs("Hello, world!\textbackslash n", fp); \- \\
-    \} \- \\
+  /* -*-sod-*- */                                               \\+
+
+  code c : includes \{                                          \\
+  \#include "greeter.h"                                         \\
+  \}                                                            \\+
+
+  code h : includes \{                                          \\
+  \#include <stdio.h>                                           \\
+  \#include <sod/sod.h>                                         \\
+  \}                                                            \\+
+
+  class Greeter : SodObject \{                                  \\ \ind
+    void greet(FILE *fp) \{                                     \\ \ind
+      fputs("Hello, world!\textbackslash n", fp);             \-\\
+    \}                                                        \-\\
   \}
 \end{prog}
 Save it as @"greeter.sod", and run
@@ -133,21 +133,21 @@ Save it as @"greeter.sod", and run
 This will create files @"greeter.c" and @"greeter.h" in the current
 directory.  Here's how we might use such a simple thing.
 \begin{prog}
-  \#include "greeter.h"
-  \\+
-  int main(void) \\
-  \{ \\ \ind
-    SOD_DECL(Greeter, g);
-    \\+
-    Greeter_greet(g, stdout); \\
-    return (0); \- \\
+  \#include "greeter.h"                                         \\+
+
+  int main(void)                                                \\
+  \{                                                            \\ \ind
+    SOD_DECL(Greeter, g);                                       \\+
+
+    Greeter_greet(g, stdout);                                   \\
+    return (0);                                               \-\\
   \}
 \end{prog}
 Compare this to the traditional
 \begin{prog}
-  \#include <stdio.h>
-  \\+
-  int main(void) \\ \ind
+  \#include <stdio.h>                                           \\+
+
+  int main(void)                                                \\ \ind
     \{ fputs("Hello, world@\\n", stdout); return (0); \}
 \end{prog}
 and I'm sure you'll appreciate the benefits of using Sod already -- mostly to
@@ -164,7 +164,7 @@ c"~\ldots, says that
 \end{prog}
 needs to appear in the generated @|greeter.c| file; the second says that
 \begin{prog}
-  \#include <stdio.h> \\
+  \#include <stdio.h>                                           \\
   \#include <sod/sod.h>
 \end{prog}
 needs to appear in the header file @|greeter.h|.  The generated C files need
@@ -175,8 +175,8 @@ approach to all of this: it expects you, the programmer, to deal with it.
 
 The basic syntax for @"code" stanzas is
 \begin{prog}
-  code @<file-label> : @<section> \{ \\ \ind
-    @<code> \- \\
+  code @<file-label> : @<section> \{                            \\ \ind
+    @<code>                                                   \-\\
   \}
 \end{prog}
 The @<file-label> is either @"c" or @"h", and says which output file the code
-- 
2.11.0