Change doc-string comments to `new style' [w/`doc:' keyword].

11 files changed, 1462 insertions, 1498 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index e558c665d2f..cedd5ff8b8e 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -7,7 +7,7 @@
         0 because unused.
 
         * bytecode.c, callint.c, callproc.c, casefiddle.c, casetab.c
-        * category.c, ccl.c, charset.c, process.c, window.c: Change
+        * category.c, ccl.c, charset.c, process.c, syntax.c, window.c: Change
         doc-string comments to `new style' [w/`doc:' keyword].
 
 2001-10-20  Miles Bader  <miles@gnu.org>
diff --git a/src/callint.c b/src/callint.c
index 329911cda6e..1299a82f6c6 100644
--- a/src/callint.c
+++ b/src/callint.c
@@ -21,6 +21,7 @@ Boston, MA 02111-1307, USA.  */
 
 
 #include <config.h>
+
 #include "lisp.h"
 #include "buffer.h"
 #include "commands.h"
@@ -62,72 +63,66 @@ static char *callint_message;
 /* Allocated length of that buffer.  */
 static int callint_message_size;
 
-/* This comment supplies the doc string for interactive,
-   for make-docfile to see.  We cannot put this in the real DEFUN
-   due to limits in the Unix cpp.
-
-DEFUN ("interactive", Ffoo, Sfoo, 0, 0, 0,
- "Specify a way of parsing arguments for interactive use of a function.\n\
-For example, write\n\
-  (defun foo (arg) \"Doc string\" (interactive \"p\") ...use arg...)\n\
-to make ARG be the prefix argument when `foo' is called as a command.\n\
-The \"call\" to `interactive' is actually a declaration rather than a function;\n\
- it tells `call-interactively' how to read arguments\n\
- to pass to the function.\n\
-When actually called, `interactive' just returns nil.\n\
-\n\
-The argument of `interactive' is usually a string containing a code letter\n\
- followed by a prompt.  (Some code letters do not use I/O to get\n\
- the argument and do not need prompts.)  To prompt for multiple arguments,\n\
- give a code letter, its prompt, a newline, and another code letter, etc.\n\
- Prompts are passed to format, and may use % escapes to print the\n\
- arguments that have already been read.\n\
-If the argument is not a string, it is evaluated to get a list of\n\
- arguments to pass to the function.\n\
-Just `(interactive)' means pass no args when calling interactively.\n\
-\nCode letters available are:\n\
-a -- Function name: symbol with a function definition.\n\
-b -- Name of existing buffer.\n\
-B -- Name of buffer, possibly nonexistent.\n\
-c -- Character (no input method is used).\n\
-C -- Command name: symbol with interactive function definition.\n\
-d -- Value of point as number.  Does not do I/O.\n\
-D -- Directory name.\n\
-e -- Parametrized event (i.e., one that's a list) that invoked this command.\n\
-     If used more than once, the Nth `e' returns the Nth parameterized event.\n\
-     This skips events that are integers or symbols.\n\
-f -- Existing file name.\n\
-F -- Possibly nonexistent file name.\n\
-i -- Ignored, i.e. always nil.  Does not do I/O.\n\
-k -- Key sequence (downcase the last event if needed to get a definition).\n\
-K -- Key sequence to be redefined (do not downcase the last event).\n\
-m -- Value of mark as number.  Does not do I/O.\n\
-M -- Any string.  Inherits the current input method.\n\
-n -- Number read using minibuffer.\n\
-N -- Raw prefix arg, or if none, do like code `n'.\n\
-p -- Prefix arg converted to number.  Does not do I/O.\n\
-P -- Prefix arg in raw form.  Does not do I/O.\n\
-r -- Region: point and mark as 2 numeric args, smallest first.  Does no I/O.\n\
-s -- Any string.  Does not inherit the current input method.\n\
-S -- Any symbol.\n\
-v -- Variable name: symbol that is user-variable-p.\n\
-x -- Lisp expression read but not evaluated.\n\
-X -- Lisp expression read and evaluated.\n\
-z -- Coding system.\n\
-Z -- Coding system, nil if no prefix arg.\n\
-In addition, if the string begins with `*'\n\
- then an error is signaled if the buffer is read-only.\n\
- This happens before reading any arguments.\n\
-If the string begins with `@', then Emacs searches the key sequence\n\
- which invoked the command for its first mouse click (or any other\n\
- event which specifies a window), and selects that window before\n\
- reading any arguments.  You may use both `@' and `*'; they are\n\
- processed in the order that they appear." */
-
 /* ARGSUSED */
 DEFUN ("interactive", Finteractive, Sinteractive, 0, UNEVALLED, 0,
-  0 /* See immediately above */)
-  (args)
+       doc: /* Specify a way of parsing arguments for interactive use of a function.
+For example, write
+  (defun foo (arg) "Doc string" (interactive "p") ...use arg...)
+to make ARG be the prefix argument when `foo' is called as a command.
+The "call" to `interactive' is actually a declaration rather than a function;
+ it tells `call-interactively' how to read arguments
+ to pass to the function.
+When actually called, `interactive' just returns nil.
+
+The argument of `interactive' is usually a string containing a code letter
+ followed by a prompt.  (Some code letters do not use I/O to get
+ the argument and do not need prompts.)  To prompt for multiple arguments,
+ give a code letter, its prompt, a newline, and another code letter, etc.
+ Prompts are passed to format, and may use % escapes to print the
+ arguments that have already been read.
+If the argument is not a string, it is evaluated to get a list of
+ arguments to pass to the function.
+Just `(interactive)' means pass no args when calling interactively.
+
+Code letters available are:
+a -- Function name: symbol with a function definition.
+b -- Name of existing buffer.
+B -- Name of buffer, possibly nonexistent.
+c -- Character (no input method is used).
+C -- Command name: symbol with interactive function definition.
+d -- Value of point as number.  Does not do I/O.
+D -- Directory name.
+e -- Parametrized event (i.e., one that's a list) that invoked this command.
+     If used more than once, the Nth `e' returns the Nth parameterized event.
+     This skips events that are integers or symbols.
+f -- Existing file name.
+F -- Possibly nonexistent file name.
+i -- Ignored, i.e. always nil.  Does not do I/O.
+k -- Key sequence (downcase the last event if needed to get a definition).
+K -- Key sequence to be redefined (do not downcase the last event).
+m -- Value of mark as number.  Does not do I/O.
+M -- Any string.  Inherits the current input method.
+n -- Number read using minibuffer.
+N -- Raw prefix arg, or if none, do like code `n'.
+p -- Prefix arg converted to number.  Does not do I/O.
+P -- Prefix arg in raw form.  Does not do I/O.
+r -- Region: point and mark as 2 numeric args, smallest first.  Does no I/O.
+s -- Any string.  Does not inherit the current input method.
+S -- Any symbol.
+v -- Variable name: symbol that is user-variable-p.
+x -- Lisp expression read but not evaluated.
+X -- Lisp expression read and evaluated.
+z -- Coding system.
+Z -- Coding system, nil if no prefix arg.
+In addition, if the string begins with `*'
+ then an error is signaled if the buffer is read-only.
+ This happens before reading any arguments.
+If the string begins with `@', then Emacs searches the key sequence
+ which invoked the command for its first mouse click (or any other
+ event which specifies a window), and selects that window before
+ reading any arguments.  You may use both `@' and `*'; they are
+ processed in the order that they appear.  */)
+     (args)
      Lisp_Object args;
 {
   return Qnil;
@@ -178,19 +173,19 @@ check_mark ()
 
 
 DEFUN ("call-interactively", Fcall_interactively, Scall_interactively, 1, 3, 0,
-  "Call FUNCTION, reading args according to its interactive calling specs.\n\
-Return the value FUNCTION returns.\n\
-The function contains a specification of how to do the argument reading.\n\
-In the case of user-defined functions, this is specified by placing a call\n\
-to the function `interactive' at the top level of the function body.\n\
-See `interactive'.\n\
-\n\
-Optional second arg RECORD-FLAG non-nil\n\
-means unconditionally put this command in the command-history.\n\
-Otherwise, this is done only if an arg is read using the minibuffer.\n\
-Optional third arg KEYS, if given, specifies the sequence of events to\n\
-supply if the command inquires which events were used to invoke it.")
-  (function, record_flag, keys)
+       doc: /* Call FUNCTION, reading args according to its interactive calling specs.
+Return the value FUNCTION returns.
+The function contains a specification of how to do the argument reading.
+In the case of user-defined functions, this is specified by placing a call
+to the function `interactive' at the top level of the function body.
+See `interactive'.
+
+Optional second arg RECORD-FLAG non-nil
+means unconditionally put this command in the command-history.
+Otherwise, this is done only if an arg is read using the minibuffer.
+Optional third arg KEYS, if given, specifies the sequence of events to
+supply if the command inquires which events were used to invoke it.  */)
+     (function, record_flag, keys)
      Lisp_Object function, record_flag, keys;
 {
   Lisp_Object *args, *visargs;
@@ -799,11 +794,11 @@ supply if the command inquires which events were used to invoke it.")
 }  
 
 DEFUN ("prefix-numeric-value", Fprefix_numeric_value, Sprefix_numeric_value,
-  1, 1, 0,
-  "Return numeric meaning of raw prefix argument RAW.\n\
-A raw prefix argument is what you get from `(interactive \"P\")'.\n\
-Its numeric meaning is what you would get from `(interactive \"p\")'.")
-  (raw)
+       1, 1, 0,
+       doc: /* Return numeric meaning of raw prefix argument RAW.
+A raw prefix argument is what you get from `(interactive "P")'.
+Its numeric meaning is what you would get from `(interactive "p")'.  */)
+     (raw)
      Lisp_Object raw;
 {
   Lisp_Object val;
@@ -866,51 +861,51 @@ syms_of_callint ()
 
 
   DEFVAR_KBOARD ("prefix-arg", Vprefix_arg,
-    "The value of the prefix argument for the next editing command.\n\
-It may be a number, or the symbol `-' for just a minus sign as arg,\n\
-or a list whose car is a number for just one or more C-u's\n\
-or nil if no argument has been specified.\n\
-\n\
-You cannot examine this variable to find the argument for this command\n\
-since it has been set to nil by the time you can look.\n\
-Instead, you should use the variable `current-prefix-arg', although\n\
-normally commands can get this prefix argument with (interactive \"P\").");
+                 doc: /* The value of the prefix argument for the next editing command.
+It may be a number, or the symbol `-' for just a minus sign as arg,
+or a list whose car is a number for just one or more C-u's
+or nil if no argument has been specified.
+
+You cannot examine this variable to find the argument for this command
+since it has been set to nil by the time you can look.
+Instead, you should use the variable `current-prefix-arg', although
+normally commands can get this prefix argument with (interactive "P").  */);
 
   DEFVAR_KBOARD ("last-prefix-arg", Vlast_prefix_arg,
-    "The value of the prefix argument for the previous editing command.\n\
-See `prefix-arg' for the meaning of the value.");
+                 doc: /* The value of the prefix argument for the previous editing command.
+See `prefix-arg' for the meaning of the value.  */);
 
   DEFVAR_LISP ("current-prefix-arg", &Vcurrent_prefix_arg,
-    "The value of the prefix argument for this editing command.\n\
-It may be a number, or the symbol `-' for just a minus sign as arg,\n\
-or a list whose car is a number for just one or more C-u's\n\
-or nil if no argument has been specified.\n\
-This is what `(interactive \"P\")' returns.");
+               doc: /* The value of the prefix argument for this editing command.
+It may be a number, or the symbol `-' for just a minus sign as arg,
+or a list whose car is a number for just one or more C-u's
+or nil if no argument has been specified.
+This is what `(interactive \"P\")' returns.  */);
   Vcurrent_prefix_arg = Qnil;
 
   DEFVAR_LISP ("command-history", &Vcommand_history,
-    "List of recent commands that read arguments from terminal.\n\
-Each command is represented as a form to evaluate.");
+               doc: /* List of recent commands that read arguments from terminal.
+Each command is represented as a form to evaluate.  */);
   Vcommand_history = Qnil;
 
   DEFVAR_LISP ("command-debug-status", &Vcommand_debug_status,
-    "Debugging status of current interactive command.\n\
-Bound each time `call-interactively' is called;\n\
-may be set by the debugger as a reminder for itself.");
+               doc: /* Debugging status of current interactive command.
+Bound each time `call-interactively' is called;
+may be set by the debugger as a reminder for itself.  */);
   Vcommand_debug_status = Qnil;
 
   DEFVAR_LISP ("mark-even-if-inactive", &Vmark_even_if_inactive,
-    "*Non-nil means you can use the mark even when inactive.\n\
-This option makes a difference in Transient Mark mode.\n\
-When the option is non-nil, deactivation of the mark\n\
-turns off region highlighting, but commands that use the mark\n\
-behave as if the mark were still active.");
+               doc: /* *Non-nil means you can use the mark even when inactive.
+This option makes a difference in Transient Mark mode.
+When the option is non-nil, deactivation of the mark
+turns off region highlighting, but commands that use the mark
+behave as if the mark were still active.  */);
   Vmark_even_if_inactive = Qnil;
 
   DEFVAR_LISP ("mouse-leave-buffer-hook", &Vmouse_leave_buffer_hook,
-    "Hook to run when about to switch windows with a mouse command.\n\
-Its purpose is to give temporary modes such as Isearch mode\n\
-a way to turn themselves off when a mouse command switches windows.");
+               doc: /* Hook to run when about to switch windows with a mouse command.
+Its purpose is to give temporary modes such as Isearch mode
+a way to turn themselves off when a mouse command switches windows.  */);
   Vmouse_leave_buffer_hook = Qnil;
 
   defsubr (&Sinteractive);
diff --git a/src/callproc.c b/src/callproc.c
index 2c98933afba..f8709ee42d0 100644
--- a/src/callproc.c
+++ b/src/callproc.c
@@ -189,25 +189,25 @@ call_process_cleanup (fdpid)
 }
 
 DEFUN ("call-process", Fcall_process, Scall_process, 1, MANY, 0,
-  "Call PROGRAM synchronously in separate process.\n\
-The remaining arguments are optional.\n\
-The program's input comes from file INFILE (nil means `/dev/null').\n\
-Insert output in BUFFER before point; t means current buffer;\n\
- nil for BUFFER means discard it; 0 means discard and don't wait.\n\
-BUFFER can also have the form (REAL-BUFFER STDERR-FILE); in that case,\n\
-REAL-BUFFER says what to do with standard output, as above,\n\
-while STDERR-FILE says what to do with standard error in the child.\n\
-STDERR-FILE may be nil (discard standard error output),\n\
-t (mix it with ordinary output), or a file name string.\n\
-\n\
-Fourth arg DISPLAY non-nil means redisplay buffer as output is inserted.\n\
-Remaining arguments are strings passed as command arguments to PROGRAM.\n\
-\n\
-If BUFFER is 0, `call-process' returns immediately with value nil.\n\
-Otherwise it waits for PROGRAM to terminate\n\
-and returns a numeric exit status or a signal description string.\n\
-If you quit, the process is killed with SIGINT, or SIGKILL if you quit again.")
-  (nargs, args)
+       doc: /* Call PROGRAM synchronously in separate process.
+The remaining arguments are optional.
+The program's input comes from file INFILE (nil means `/dev/null').
+Insert output in BUFFER before point; t means current buffer;
+ nil for BUFFER means discard it; 0 means discard and don't wait.
+BUFFER can also have the form (REAL-BUFFER STDERR-FILE); in that case,
+REAL-BUFFER says what to do with standard output, as above,
+while STDERR-FILE says what to do with standard error in the child.
+STDERR-FILE may be nil (discard standard error output),
+t (mix it with ordinary output), or a file name string.
+
+Fourth arg DISPLAY non-nil means redisplay buffer as output is inserted.
+Remaining arguments are strings passed as command arguments to PROGRAM.
+
+If BUFFER is 0, `call-process' returns immediately with value nil.
+Otherwise it waits for PROGRAM to terminate
+and returns a numeric exit status or a signal description string.
+If you quit, the process is killed with SIGINT, or SIGKILL if you quit again.  */)
+     (nargs, args)
      int nargs;
      register Lisp_Object *args;
 {
@@ -971,27 +971,27 @@ delete_temp_file (name)
 }
 
 DEFUN ("call-process-region", Fcall_process_region, Scall_process_region,
-  3, MANY, 0,
-  "Send text from START to END to a synchronous process running PROGRAM.\n\
-The remaining arguments are optional.\n\
-Delete the text if fourth arg DELETE is non-nil.\n\
-\n\
-Insert output in BUFFER before point; t means current buffer;\n\
- nil for BUFFER means discard it; 0 means discard and don't wait.\n\
-BUFFER can also have the form (REAL-BUFFER STDERR-FILE); in that case,\n\
-REAL-BUFFER says what to do with standard output, as above,\n\
-while STDERR-FILE says what to do with standard error in the child.\n\
-STDERR-FILE may be nil (discard standard error output),\n\
-t (mix it with ordinary output), or a file name string.\n\
-\n\
-Sixth arg DISPLAY non-nil means redisplay buffer as output is inserted.\n\
-Remaining args are passed to PROGRAM at startup as command args.\n\
-\n\
-If BUFFER is nil, `call-process-region' returns immediately with value nil.\n\
-Otherwise it waits for PROGRAM to terminate\n\
-and returns a numeric exit status or a signal description string.\n\
-If you quit, the process is killed with SIGINT, or SIGKILL if you quit again.")
-  (nargs, args)
+       3, MANY, 0,
+       doc: /* Send text from START to END to a synchronous process running PROGRAM.
+The remaining arguments are optional.
+Delete the text if fourth arg DELETE is non-nil.
+
+Insert output in BUFFER before point; t means current buffer;
+ nil for BUFFER means discard it; 0 means discard and don't wait.
+BUFFER can also have the form (REAL-BUFFER STDERR-FILE); in that case,
+REAL-BUFFER says what to do with standard output, as above,
+while STDERR-FILE says what to do with standard error in the child.
+STDERR-FILE may be nil (discard standard error output),
+t (mix it with ordinary output), or a file name string.
+
+Sixth arg DISPLAY non-nil means redisplay buffer as output is inserted.
+Remaining args are passed to PROGRAM at startup as command args.
+
+If BUFFER is nil, `call-process-region' returns immediately with value nil.
+Otherwise it waits for PROGRAM to terminate
+and returns a numeric exit status or a signal description string.
+If you quit, the process is killed with SIGINT, or SIGKILL if you quit again.  */)
+     (nargs, args)
      int nargs;
      register Lisp_Object *args;
 {
@@ -1406,10 +1406,10 @@ getenv_internal (var, varlen, value, valuelen)
 }
 
 DEFUN ("getenv-internal", Fgetenv_internal, Sgetenv_internal, 1, 1, 0,
-  "Return the value of environment variable VAR, as a string.\n\
-VAR should be a string.  Value is nil if VAR is undefined in the environment.\n\
-This function consults the variable ``process-environment'' for its value.")
-  (var)
+       doc: /* Return the value of environment variable VAR, as a string.
+VAR should be a string.  Value is nil if VAR is undefined in the environment.
+This function consults the variable ``process-environment'' for its value.  */)
+     (var)
      Lisp_Object var;
 {
   char *value;
@@ -1579,50 +1579,50 @@ syms_of_callproc ()
 #endif /* DOS_NT */
 
   DEFVAR_LISP ("shell-file-name", &Vshell_file_name,
-    "*File name to load inferior shells from.\n\
-Initialized from the SHELL environment variable.");
+               doc: /* *File name to load inferior shells from.
+Initialized from the SHELL environment variable.  */);
 
   DEFVAR_LISP ("exec-path", &Vexec_path,
-    "*List of directories to search programs to run in subprocesses.\n\
-Each element is a string (directory name) or nil (try default directory).");
+               doc: /* *List of directories to search programs to run in subprocesses.
+Each element is a string (directory name) or nil (try default directory).  */);
 
   DEFVAR_LISP ("exec-suffixes", &Vexec_suffixes,
-    "*List of suffixes to try to find executable file names.\n\
-Each element is a string");
+               doc: /* *List of suffixes to try to find executable file names.
+Each element is a string.  */);
   Vexec_suffixes = Qnil;
 
   DEFVAR_LISP ("exec-directory", &Vexec_directory,
-    "Directory for executables for Emacs to invoke.\n\
-More generally, this includes any architecture-dependent files\n\
-that are built and installed from the Emacs distribution.");
+               doc: /* Directory for executables for Emacs to invoke.
+More generally, this includes any architecture-dependent files
+that are built and installed from the Emacs distribution.  */);
 
   DEFVAR_LISP ("data-directory", &Vdata_directory,
-    "Directory of machine-independent files that come with GNU Emacs.\n\
-These are files intended for Emacs to use while it runs.");
+               doc: /* Directory of machine-independent files that come with GNU Emacs.
+These are files intended for Emacs to use while it runs.  */);
 
   DEFVAR_LISP ("doc-directory", &Vdoc_directory,
-    "Directory containing the DOC file that comes with GNU Emacs.\n\
-This is usually the same as data-directory.");
+               doc: /* Directory containing the DOC file that comes with GNU Emacs.
+This is usually the same as data-directory.  */);
 
   DEFVAR_LISP ("configure-info-directory", &Vconfigure_info_directory,
-    "For internal use by the build procedure only.\n\
-This is the name of the directory in which the build procedure installed\n\
-Emacs's info files; the default value for Info-default-directory-list\n\
-includes this.");
+               doc: /* For internal use by the build procedure only.
+This is the name of the directory in which the build procedure installed
+Emacs's info files; the default value for Info-default-directory-list
+includes this.  */);
   Vconfigure_info_directory = build_string (PATH_INFO);
 
   DEFVAR_LISP ("temp-file-name-pattern", &Vtemp_file_name_pattern,
-    "Pattern for making names for temporary files.\n\
-This is used by `call-process-region'.");
+               doc: /* Pattern for making names for temporary files.
+This is used by `call-process-region'.  */);
   /* This variable is initialized in init_callproc.  */
 
   DEFVAR_LISP ("process-environment", &Vprocess_environment,
-    "List of environment variables for subprocesses to inherit.\n\
-Each element should be a string of the form ENVVARNAME=VALUE.\n\
-If multiple entries define the same variable, the first one always\n\
-takes precedence.\n\
-The environment which Emacs inherits is placed in this variable\n\
-when Emacs starts.");
+               doc: /* List of environment variables for subprocesses to inherit.
+Each element should be a string of the form ENVVARNAME=VALUE.
+If multiple entries define the same variable, the first one always
+takes precedence.
+The environment which Emacs inherits is placed in this variable
+when Emacs starts.  */);
 
 #ifndef VMS
   defsubr (&Scall_process);
diff --git a/src/casefiddle.c b/src/casefiddle.c
index 61928794ec1..47f355461a8 100644
--- a/src/casefiddle.c
+++ b/src/casefiddle.c
@@ -134,33 +134,33 @@ casify_object (flag, obj)
 }
 
 DEFUN ("upcase", Fupcase, Supcase, 1, 1, 0,
-  "Convert argument to upper case and return that.\n\
-The argument may be a character or string.  The result has the same type.\n\
-The argument object is not altered--the value is a copy.\n\
-See also `capitalize', `downcase' and `upcase-initials'.")
-  (obj)
+       doc: /* Convert argument to upper case and return that.
+The argument may be a character or string.  The result has the same type.
+The argument object is not altered--the value is a copy.
+See also `capitalize', `downcase' and `upcase-initials'.  */)
+     (obj)
      Lisp_Object obj;
 {
   return casify_object (CASE_UP, obj);
 }
 
 DEFUN ("downcase", Fdowncase, Sdowncase, 1, 1, 0,
-  "Convert argument to lower case and return that.\n\
-The argument may be a character or string.  The result has the same type.\n\
-The argument object is not altered--the value is a copy.")
-  (obj)
+       doc: /* Convert argument to lower case and return that.
+The argument may be a character or string.  The result has the same type.
+The argument object is not altered--the value is a copy.  */)
+     (obj)
      Lisp_Object obj;
 {
   return casify_object (CASE_DOWN, obj);
 }
 
 DEFUN ("capitalize", Fcapitalize, Scapitalize, 1, 1, 0,
-  "Convert argument to capitalized form and return that.\n\
-This means that each word's first character is upper case\n\
-and the rest is lower case.\n\
-The argument may be a character or string.  The result has the same type.\n\
-The argument object is not altered--the value is a copy.")
-  (obj)
+       doc: /* Convert argument to capitalized form and return that.
+This means that each word's first character is upper case
+and the rest is lower case.
+The argument may be a character or string.  The result has the same type.
+The argument object is not altered--the value is a copy.  */)
+     (obj)
      Lisp_Object obj;
 {
   return casify_object (CASE_CAPITALIZE, obj);
@@ -169,11 +169,11 @@ The argument object is not altered--the value is a copy.")
 /* Like Fcapitalize but change only the initials.  */
 
 DEFUN ("upcase-initials", Fupcase_initials, Supcase_initials, 1, 1, 0,
-  "Convert the initial of each word in the argument to upper case.\n\
-Do not change the other letters of each word.\n\
-The argument may be a character or string.  The result has the same type.\n\
-The argument object is not altered--the value is a copy.")
-  (obj)
+       doc: /* Convert the initial of each word in the argument to upper case.
+Do not change the other letters of each word.
+The argument may be a character or string.  The result has the same type.
+The argument object is not altered--the value is a copy.  */)
+     (obj)
      Lisp_Object obj;
 {
   return casify_object (CASE_CAPITALIZE_UP, obj);
@@ -293,12 +293,12 @@ casify_region (flag, b, e)
 }
 
 DEFUN ("upcase-region", Fupcase_region, Supcase_region, 2, 2, "r",
-  "Convert the region to upper case.  In programs, wants two arguments.\n\
-These arguments specify the starting and ending character numbers of\n\
-the region to operate on.  When used as a command, the text between\n\
-point and the mark is operated on.\n\
-See also `capitalize-region'.")
-  (beg, end)
+       doc: /* Convert the region to upper case.  In programs, wants two arguments.
+These arguments specify the starting and ending character numbers of
+the region to operate on.  When used as a command, the text between
+point and the mark is operated on.
+See also `capitalize-region'.  */)
+     (beg, end)
      Lisp_Object beg, end;
 {
   casify_region (CASE_UP, beg, end);
@@ -306,11 +306,11 @@ See also `capitalize-region'.")
 }
 
 DEFUN ("downcase-region", Fdowncase_region, Sdowncase_region, 2, 2, "r",
-  "Convert the region to lower case.  In programs, wants two arguments.\n\
-These arguments specify the starting and ending character numbers of\n\
-the region to operate on.  When used as a command, the text between\n\
-point and the mark is operated on.")
-  (beg, end)
+       doc: /* Convert the region to lower case.  In programs, wants two arguments.
+These arguments specify the starting and ending character numbers of
+the region to operate on.  When used as a command, the text between
+point and the mark is operated on.  */)
+     (beg, end)
      Lisp_Object beg, end;
 {
   casify_region (CASE_DOWN, beg, end);
@@ -318,12 +318,12 @@ point and the mark is operated on.")
 }
 
 DEFUN ("capitalize-region", Fcapitalize_region, Scapitalize_region, 2, 2, "r",
-  "Convert the region to capitalized form.\n\
-Capitalized form means each word's first character is upper case\n\
-and the rest of it is lower case.\n\
-In programs, give two arguments, the starting and ending\n\
-character positions to operate on.")
-  (beg, end)
+       doc: /* Convert the region to capitalized form.
+Capitalized form means each word's first character is upper case
+and the rest of it is lower case.
+In programs, give two arguments, the starting and ending
+character positions to operate on.  */)
+     (beg, end)
      Lisp_Object beg, end;
 {
   casify_region (CASE_CAPITALIZE, beg, end);
@@ -334,11 +334,11 @@ character positions to operate on.")
 
 DEFUN ("upcase-initials-region", Fupcase_initials_region,
        Supcase_initials_region, 2, 2, "r",
-  "Upcase the initial of each word in the region.\n\
-Subsequent letters of each word are not changed.\n\
-In programs, give two arguments, the starting and ending\n\
-character positions to operate on.")
-  (beg, end)
+       doc: /* Upcase the initial of each word in the region.
+Subsequent letters of each word are not changed.
+In programs, give two arguments, the starting and ending
+character positions to operate on.  */)
+     (beg, end)
      Lisp_Object beg, end;
 {
   casify_region (CASE_CAPITALIZE_UP, beg, end);
@@ -367,10 +367,10 @@ operate_on_word (arg, newpoint)
 }
 
 DEFUN ("upcase-word", Fupcase_word, Supcase_word, 1, 1, "p",
-  "Convert following word (or ARG words) to upper case, moving over.\n\
-With negative argument, convert previous words but do not move.\n\
-See also `capitalize-word'.")
-  (arg)
+       doc: /* Convert following word (or ARG words) to upper case, moving over.
+With negative argument, convert previous words but do not move.
+See also `capitalize-word'.  */)
+     (arg)
      Lisp_Object arg;
 {
   Lisp_Object beg, end;
@@ -383,9 +383,9 @@ See also `capitalize-word'.")
 }
 
 DEFUN ("downcase-word", Fdowncase_word, Sdowncase_word, 1, 1, "p",
-  "Convert following word (or ARG words) to lower case, moving over.\n\
-With negative argument, convert previous words but do not move.")
-  (arg)
+       doc: /* Convert following word (or ARG words) to lower case, moving over.
+With negative argument, convert previous words but do not move.  */)
+     (arg)
      Lisp_Object arg;
 {
   Lisp_Object beg, end;
@@ -398,11 +398,11 @@ With negative argument, convert previous words but do not move.")
 }
 
 DEFUN ("capitalize-word", Fcapitalize_word, Scapitalize_word, 1, 1, "p",
-  "Capitalize the following word (or ARG words), moving over.\n\
-This gives the word(s) a first character in upper case\n\
-and the rest lower case.\n\
-With negative argument, capitalize previous words but do not move.")
-  (arg)
+       doc: /* Capitalize the following word (or ARG words), moving over.
+This gives the word(s) a first character in upper case
+and the rest lower case.
+With negative argument, capitalize previous words but do not move.  */)
+     (arg)
      Lisp_Object arg;
 {
   Lisp_Object beg, end;
diff --git a/src/casetab.c b/src/casetab.c
index aa87f5ad8fb..de504e2e335 100644
--- a/src/casetab.c
+++ b/src/casetab.c
@@ -39,9 +39,9 @@ static void set_identity ();
 static void shuffle ();
 
 DEFUN ("case-table-p", Fcase_table_p, Scase_table_p, 1, 1, 0,
-  "Return t iff OBJECT is a case table.\n\
-See `set-case-table' for more information on these data structures.")
-  (object)
+       doc: /* Return t iff OBJECT is a case table.
+See `set-case-table' for more information on these data structures.  */)
+     (object)
      Lisp_Object object;
 {
   Lisp_Object up, canon, eqv;
@@ -74,16 +74,16 @@ check_case_table (obj)
 }   
 
 DEFUN ("current-case-table", Fcurrent_case_table, Scurrent_case_table, 0, 0, 0,
-  "Return the case table of the current buffer.")
-  ()
+       doc: /* Return the case table of the current buffer.  */)
+     ()
 {
   return current_buffer->downcase_table;
 }
 
 DEFUN ("standard-case-table", Fstandard_case_table, Sstandard_case_table, 0, 0, 0,
-  "Return the standard case table.\n\
-This is the one used for new buffers.")
-  ()
+       doc: /* Return the standard case table.
+This is the one used for new buffers.  */)
+     ()
 {
   return Vascii_downcase_table;
 }
@@ -91,31 +91,31 @@ This is the one used for new buffers.")
 static Lisp_Object set_case_table ();
 
 DEFUN ("set-case-table", Fset_case_table, Sset_case_table, 1, 1, 0,
-  "Select a new case table for the current buffer.\n\
-A case table is a char-table which maps characters\n\
-to their lower-case equivalents.  It also has three \"extra\" slots\n\
-which may be additional char-tables or nil.\n\
-These slots are called UPCASE, CANONICALIZE and EQUIVALENCES.\n\
-UPCASE maps each character to its upper-case equivalent;\n\
- if lower and upper case characters are in 1-1 correspondence,\n\
- you may use nil and the upcase table will be deduced from DOWNCASE.\n\
-CANONICALIZE maps each character to a canonical equivalent;\n\
- any two characters that are related by case-conversion have the same\n\
- canonical equivalent character; it may be nil, in which case it is\n\
- deduced from DOWNCASE and UPCASE.\n\
-EQUIVALENCES is a map that cyclicly permutes each equivalence class\n\
- (of characters with the same canonical equivalent); it may be nil,\n\
- in which case it is deduced from CANONICALIZE.")
-  (table)
+       doc: /* Select a new case table for the current buffer.
+A case table is a char-table which maps characters
+to their lower-case equivalents.  It also has three \"extra\" slots
+which may be additional char-tables or nil.
+These slots are called UPCASE, CANONICALIZE and EQUIVALENCES.
+UPCASE maps each character to its upper-case equivalent;
+ if lower and upper case characters are in 1-1 correspondence,
+ you may use nil and the upcase table will be deduced from DOWNCASE.
+CANONICALIZE maps each character to a canonical equivalent;
+ any two characters that are related by case-conversion have the same
+ canonical equivalent character; it may be nil, in which case it is
+ deduced from DOWNCASE and UPCASE.
+EQUIVALENCES is a map that cyclicly permutes each equivalence class
+ (of characters with the same canonical equivalent); it may be nil,
+ in which case it is deduced from CANONICALIZE.  */)
+     (table)
      Lisp_Object table;
 {
   return set_case_table (table, 0);
 }
 
 DEFUN ("set-standard-case-table", Fset_standard_case_table, Sset_standard_case_table, 1, 1, 0,
-  "Select a new standard case table for new buffers.\n\
-See `set-case-table' for more info on case tables.")
-  (table)
+       doc: /* Select a new standard case table for new buffers.
+See `set-case-table' for more info on case tables.  */)
+     (table)
      Lisp_Object table;
 {
   return set_case_table (table, 1);
diff --git a/src/category.c b/src/category.c
index c09e32e8d47..40804367528 100644
--- a/src/category.c
+++ b/src/category.c
@@ -53,11 +53,11 @@ Lisp_Object _temp_category_set;
 /* Category set staff.  */
 
 DEFUN ("make-category-set", Fmake_category_set, Smake_category_set, 1, 1, 0,
-  "Return a newly created category-set which contains CATEGORIES.\n\
-CATEGORIES is a string of category mnemonics.\n\
-The value is a bool-vector which has t at the indices corresponding to\n\
-those categories.")
-  (categories)
+       doc: /* Return a newly created category-set which contains CATEGORIES.
+CATEGORIES is a string of category mnemonics.
+The value is a bool-vector which has t at the indices corresponding to
+those categories.  */)
+     (categories)
      Lisp_Object categories;
 {
   Lisp_Object val;
@@ -87,12 +87,12 @@ those categories.")
 Lisp_Object check_category_table ();
 
 DEFUN ("define-category", Fdefine_category, Sdefine_category, 2, 3, 0,
-  "Define CHAR as a category which is described by DOCSTRING.\n\
-CHAR should be an ASCII printing character in the range ` ' to `~'.\n\
-DOCSTRING is a documentation string of the category.\n\
-The category is defined only in category table TABLE, which defaults to\n\
- the current buffer's category table.")
-  (category, docstring, table)
+       doc: /* Define CHAR as a category which is described by DOCSTRING.
+CHAR should be an ASCII printing character in the range ` ' to `~'.
+DOCSTRING is a documentation string of the category.
+The category is defined only in category table TABLE, which defaults to
+ the current buffer's category table.  */)
+     (category, docstring, table)
      Lisp_Object category, docstring, table;
 {
   CHECK_CATEGORY (category, 0);
@@ -107,8 +107,8 @@ The category is defined only in category table TABLE, which defaults to\n\
 }
 
 DEFUN ("category-docstring", Fcategory_docstring, Scategory_docstring, 1, 2, 0,
-  "Return the documentation string of CATEGORY, as defined in CATEGORY-TABLE.")
-  (category, table)
+       doc: /* Return the documentation string of CATEGORY, as defined in CATEGORY-TABLE.  */)
+     (category, table)
      Lisp_Object category, table;
 {
   CHECK_CATEGORY (category, 0);
@@ -119,11 +119,11 @@ DEFUN ("category-docstring", Fcategory_docstring, Scategory_docstring, 1, 2, 0,
 
 DEFUN ("get-unused-category", Fget_unused_category, Sget_unused_category,
        0, 1, 0,
-  "Return a category which is not yet defined in CATEGORY-TABLE.\n\
-If no category remains available, return nil.\n\
-The optional argument CATEGORY-TABLE specifies which category table\n\
-to modify; it defaults to the current buffer's category table.")
-  (table)
+       doc: /* Return a category which is not yet defined in CATEGORY-TABLE.  If no
+category remains available, return nil.  The optional argument CATEGORY-TABLE
+specifies which category table to modify; it defaults to the current
+buffer's category table.  */)
+     (table)
      Lisp_Object table;
 {
   int i;
@@ -141,8 +141,8 @@ to modify; it defaults to the current buffer's category table.")
 /* Category-table staff.  */
 
 DEFUN ("category-table-p", Fcategory_table_p, Scategory_table_p, 1, 1, 0,
-  "Return t if ARG is a category table.")
-  (arg)
+       doc: /* Return t if ARG is a category table.  */)
+     (arg)
      Lisp_Object arg;
 {
   if (CHAR_TABLE_P (arg)
@@ -169,18 +169,18 @@ check_category_table (table)
 }   
 
 DEFUN ("category-table", Fcategory_table, Scategory_table, 0, 0, 0,
-  "Return the current category table.\n\
-This is the one specified by the current buffer.")
-  ()
+       doc: /* Return the current category table.
+This is the one specified by the current buffer.  */)
+     ()
 {
   return current_buffer->category_table;
 }
 
 DEFUN ("standard-category-table", Fstandard_category_table,
    Sstandard_category_table, 0, 0, 0,
-  "Return the standard category table.\n\
-This is the one used for new buffers.")
-  ()
+       doc: /* Return the standard category table.
+This is the one used for new buffers.  */)
+     ()
 {
   return Vstandard_category_table;
 }
@@ -238,9 +238,9 @@ copy_category_table (table)
 
 DEFUN ("copy-category-table", Fcopy_category_table, Scopy_category_table,
        0, 1, 0,
-  "Construct a new category table and return it.\n\
-It is a copy of the TABLE, which defaults to the standard category table.")
-  (table)
+       doc: /* Construct a new category table and return it.
+It is a copy of the TABLE, which defaults to the standard category table.  */)
+     (table)
      Lisp_Object table;
 {
   if (!NILP (table))
@@ -253,8 +253,8 @@ It is a copy of the TABLE, which defaults to the standard category table.")
 
 DEFUN ("make-category-table", Fmake_category_table, Smake_category_table,
        0, 0, 0,
-  "Construct a new and empty category table and return it.")
-  ()
+       doc: /* Construct a new and empty category table and return it.  */)
+     ()
 {
   Lisp_Object val;
 
@@ -266,8 +266,8 @@ DEFUN ("make-category-table", Fmake_category_table, Smake_category_table,
 }
 
 DEFUN ("set-category-table", Fset_category_table, Sset_category_table, 1, 1, 0,
-  "Specify TABLE as the category table for the current buffer.")
-  (table)
+       doc: /* Specify TABLE as the category table for the current buffer.  */)
+     (table)
      Lisp_Object table;
 {
   int idx;
@@ -281,8 +281,8 @@ DEFUN ("set-category-table", Fset_category_table, Sset_category_table, 1, 1, 0,
 
 
 DEFUN ("char-category-set", Fchar_category_set, Schar_category_set, 1, 1, 0,
-  "Return the category set of CHAR.")
-  (ch)
+       doc: /* Return the category set of CHAR.  */)
+     (ch)
      Lisp_Object ch;
 {
   CHECK_NUMBER (ch, 0);
@@ -291,11 +291,11 @@ DEFUN ("char-category-set", Fchar_category_set, Schar_category_set, 1, 1, 0,
 
 DEFUN ("category-set-mnemonics", Fcategory_set_mnemonics,
        Scategory_set_mnemonics, 1, 1, 0,
-  "Return a string containing mnemonics of the categories in CATEGORY-SET.\n\
-CATEGORY-SET is a bool-vector, and the categories \"in\" it are those\n\
-that are indexes where t occurs the bool-vector.\n\
-The return value is a string containing those same categories.")
-  (category_set)
+       doc: /* Return a string containing mnemonics of the categories in CATEGORY-SET.
+CATEGORY-SET is a bool-vector, and the categories \"in\" it are those
+that are indexes where t occurs the bool-vector.
+The return value is a string containing those same categories.  */)
+     (category_set)
      Lisp_Object category_set;
 {
   int i, j;
@@ -357,12 +357,12 @@ set_category_set (category_set, category, val)
 
 DEFUN ("modify-category-entry", Fmodify_category_entry,
        Smodify_category_entry, 2, 4, 0,
-  "Modify the category set of CHARACTER by adding CATEGORY to it.\n\
-The category is changed only for table TABLE, which defaults to\n\
- the current buffer's category table.\n\
-If optional fourth argument RESET is non-nil,\n\
- then delete CATEGORY from the category set instead of adding it.")
-  (character, category, table, reset)
+       doc: /* Modify the category set of CHARACTER by adding CATEGORY to it.
+The category is changed only for table TABLE, which defaults to
+ the current buffer's category table.
+If optional fourth argument RESET is non-nil,
+then delete CATEGORY from the category set instead of adding it.  */)
+     (character, category, table, reset)
      Lisp_Object character, category, table, reset;
 {
   int c, charset, c1, c2;
@@ -553,9 +553,9 @@ describe_category_1 (vector)
 }
 
 DEFUN ("describe-categories", Fdescribe_categories, Sdescribe_categories, 0, 0, "",
-  "Describe the category specifications in the current category table.\n\
-The descriptions are inserted in a buffer, which is then displayed.")
-  ()
+       doc: /* Describe the category specifications in the current category table.
+The descriptions are inserted in a buffer, which is then displayed.  */)
+     ()
 {
   internal_with_output_to_temp_buffer
      ("*Help*", describe_category_1, current_buffer->category_table);
@@ -643,45 +643,45 @@ syms_of_category ()
   staticpro (&Qcategory_table_p);
 
   DEFVAR_LISP ("word-combining-categories", &Vword_combining_categories,
-    "List of pair (cons) of categories to determine word boundary.\n\
-\n\
-Emacs treats a sequence of word constituent characters as a single\n\
-word (i.e. finds no word boundary between them) iff they belongs to\n\
-the same charset.  But, exceptions are allowed in the following cases.\n\
-\n\
-\(1) The case that characters are in different charsets is controlled\n\
-by the variable `word-combining-categories'.\n\
-\n\
-Emacs finds no word boundary between characters of different charsets\n\
-if they have categories matching some element of this list.\n\
-\n\
-More precisely, if an element of this list is a cons of category CAT1\n\
-and CAT2, and a multibyte character C1 which has CAT1 is followed by\n\
-C2 which has CAT2, there's no word boundary between C1 and C2.\n\
-\n\
-For instance, to tell that ASCII characters and Latin-1 characters can\n\
-form a single word, the element `(?l . ?l)' should be in this list\n\
-because both characters have the category `l' (Latin characters).\n\
-\n\
-\(2) The case that character are in the same charset is controlled by\n\
-the variable `word-separating-categories'.\n\
-\n\
-Emacs find a word boundary between characters of the same charset\n\
-if they have categories matching some element of this list.\n\
-\n\
-More precisely, if an element of this list is a cons of category CAT1\n\
-and CAT2, and a multibyte character C1 which has CAT1 is followed by\n\
-C2 which has CAT2, there's a word boundary between C1 and C2.\n\
-\n\
-For instance, to tell that there's a word boundary between Japanese\n\
-Hiragana and Japanese Kanji (both are in the same charset), the\n\
-element `(?H . ?C) should be in this list.");
+               doc: /* List of pair (cons) of categories to determine word boundary.
+
+Emacs treats a sequence of word constituent characters as a single
+word (i.e. finds no word boundary between them) iff they belongs to
+the same charset.  But, exceptions are allowed in the following cases.
+
+\(1) The case that characters are in different charsets is controlled
+by the variable `word-combining-categories'.
+
+Emacs finds no word boundary between characters of different charsets
+if they have categories matching some element of this list.
+
+More precisely, if an element of this list is a cons of category CAT1
+and CAT2, and a multibyte character C1 which has CAT1 is followed by
+C2 which has CAT2, there's no word boundary between C1 and C2.
+
+For instance, to tell that ASCII characters and Latin-1 characters can
+form a single word, the element `(?l . ?l)' should be in this list
+because both characters have the category `l' (Latin characters).
+
+\(2) The case that character are in the same charset is controlled by
+the variable `word-separating-categories'.
+
+Emacs find a word boundary between characters of the same charset
+if they have categories matching some element of this list.
+
+More precisely, if an element of this list is a cons of category CAT1
+and CAT2, and a multibyte character C1 which has CAT1 is followed by
+C2 which has CAT2, there's a word boundary between C1 and C2.
+
+For instance, to tell that there's a word boundary between Japanese
+Hiragana and Japanese Kanji (both are in the same charset), the
+element `(?H . ?C) should be in this list.  */);
 
   Vword_combining_categories = Qnil;
 
   DEFVAR_LISP ("word-separating-categories", &Vword_separating_categories,
-    "List of pair (cons) of categories to determine word boundary.\n\
-See the documentation of the variable `word-combining-categories'.");
+               doc: /* List of pair (cons) of categories to determine word boundary.
+See the documentation of the variable `word-combining-categories'.  */);
 
   Vword_separating_categories = Qnil;
 
diff --git a/src/ccl.c b/src/ccl.c
index 52a4ff3c388..e8ddc959d2c 100644
--- a/src/ccl.c
+++ b/src/ccl.c
@@ -2010,9 +2010,9 @@ setup_ccl_program (ccl, ccl_prog)
 #ifdef emacs
 
 DEFUN ("ccl-program-p", Fccl_program_p, Sccl_program_p, 1, 1, 0,
-  "Return t if OBJECT is a CCL program name or a compiled CCL program code.\n\
-See the documentation of  `define-ccl-program' for the detail of CCL program.")
-  (object)
+       doc: /* Return t if OBJECT is a CCL program name or a compiled CCL program code.
+See the documentation of  `define-ccl-program' for the detail of CCL program.  */)
+     (object)
      Lisp_Object object;
 {
   Lisp_Object val;
@@ -2032,22 +2032,22 @@ See the documentation of  `define-ccl-program' for the detail of CCL program.")
 }
 
 DEFUN ("ccl-execute", Fccl_execute, Sccl_execute, 2, 2, 0,
-  "Execute CCL-PROGRAM with registers initialized by REGISTERS.\n\
-\n\
-CCL-PROGRAM is a CCL program name (symbol)\n\
-or compiled code generated by `ccl-compile' (for backward compatibility.\n\
-In the latter case, the execution overhead is bigger than in the former).\n\
-No I/O commands should appear in CCL-PROGRAM.\n\
-\n\
-REGISTERS is a vector of [R0 R1 ... R7] where RN is an initial value\n\
-for the Nth register.\n\
-\n\
-As side effect, each element of REGISTERS holds the value of\n\
-the corresponding register after the execution.\n\
-\n\
-See the documentation of `define-ccl-program' for a definition of CCL\n\
-programs.")
-  (ccl_prog, reg)
+       doc: /* Execute CCL-PROGRAM with registers initialized by REGISTERS.
+
+CCL-PROGRAM is a CCL program name (symbol)
+or compiled code generated by `ccl-compile' (for backward compatibility.
+In the latter case, the execution overhead is bigger than in the former).
+No I/O commands should appear in CCL-PROGRAM.
+
+REGISTERS is a vector of [R0 R1 ... R7] where RN is an initial value
+for the Nth register.
+
+As side effect, each element of REGISTERS holds the value of
+the corresponding register after the execution.
+
+See the documentation of `define-ccl-program' for a definition of CCL
+programs.  */)
+     (ccl_prog, reg)
      Lisp_Object ccl_prog, reg;
 {
   struct ccl_program ccl;
@@ -2077,31 +2077,31 @@ programs.")
 
 DEFUN ("ccl-execute-on-string", Fccl_execute_on_string, Sccl_execute_on_string,
        3, 5, 0,
-  "Execute CCL-PROGRAM with initial STATUS on STRING.\n\
-\n\
-CCL-PROGRAM is a symbol registered by register-ccl-program,\n\
-or a compiled code generated by `ccl-compile' (for backward compatibility,\n\
-in this case, the execution is slower).\n\
-\n\
-Read buffer is set to STRING, and write buffer is allocated automatically.\n\
-\n\
-STATUS is a vector of [R0 R1 ... R7 IC], where\n\
- R0..R7 are initial values of corresponding registers,\n\
- IC is the instruction counter specifying from where to start the program.\n\
-If R0..R7 are nil, they are initialized to 0.\n\
-If IC is nil, it is initialized to head of the CCL program.\n\
-\n\
-If optional 4th arg CONTINUE is non-nil, keep IC on read operation\n\
-when read buffer is exausted, else, IC is always set to the end of\n\
-CCL-PROGRAM on exit.\n\
-\n\
-It returns the contents of write buffer as a string,\n\
- and as side effect, STATUS is updated.\n\
-If the optional 5th arg UNIBYTE-P is non-nil, the returned string\n\
-is a unibyte string.  By default it is a multibyte string.\n\
-\n\
-See the documentation of `define-ccl-program' for the detail of CCL program.")
-  (ccl_prog, status, str, contin, unibyte_p)
+       doc: /* Execute CCL-PROGRAM with initial STATUS on STRING.
+
+CCL-PROGRAM is a symbol registered by register-ccl-program,
+or a compiled code generated by `ccl-compile' (for backward compatibility,
+in this case, the execution is slower).
+
+Read buffer is set to STRING, and write buffer is allocated automatically.
+
+STATUS is a vector of [R0 R1 ... R7 IC], where
+ R0..R7 are initial values of corresponding registers,
+ IC is the instruction counter specifying from where to start the program.
+If R0..R7 are nil, they are initialized to 0.
+If IC is nil, it is initialized to head of the CCL program.
+
+If optional 4th arg CONTINUE is non-nil, keep IC on read operation
+when read buffer is exausted, else, IC is always set to the end of
+CCL-PROGRAM on exit.
+
+It returns the contents of write buffer as a string,
+ and as side effect, STATUS is updated.
+If the optional 5th arg UNIBYTE-P is non-nil, the returned string
+is a unibyte string.  By default it is a multibyte string.
+
+See the documentation of `define-ccl-program' for the detail of CCL program.  */)
+     (ccl_prog, status, str, contin, unibyte_p)
      Lisp_Object ccl_prog, status, str, contin, unibyte_p;
 {
   Lisp_Object val;
@@ -2167,11 +2167,11 @@ See the documentation of `define-ccl-program' for the detail of CCL program.")
 
 DEFUN ("register-ccl-program", Fregister_ccl_program, Sregister_ccl_program,
        2, 2, 0,
-  "Register CCL program CCL_PROG as NAME in `ccl-program-table'.\n\
-CCL_PROG should be a compiled CCL program (vector), or nil.\n\
-If it is nil, just reserve NAME as a CCL program name.\n\
-Return index number of the registered CCL program.")
-  (name, ccl_prog)
+       doc: /* Register CCL program CCL_PROG as NAME in `ccl-program-table'.
+CCL_PROG should be a compiled CCL program (vector), or nil.
+If it is nil, just reserve NAME as a CCL program name.
+Return index number of the registered CCL program.  */)
+     (name, ccl_prog)
      Lisp_Object name, ccl_prog;
 {
   int len = XVECTOR (Vccl_program_table)->size;
@@ -2252,9 +2252,9 @@ Return index number of the registered CCL program.")
 DEFUN ("register-code-conversion-map", Fregister_code_conversion_map,
        Sregister_code_conversion_map,
        2, 2, 0,
-  "Register SYMBOL as code conversion map MAP.\n\
-Return index number of the registered map.")
-  (symbol, map)
+       doc: /* Register SYMBOL as code conversion map MAP.
+Return index number of the registered map.  */)
+     (symbol, map)
      Lisp_Object symbol, map;
 {
   int len = XVECTOR (Vcode_conversion_map_vector)->size;
@@ -2319,20 +2319,20 @@ syms_of_ccl ()
   staticpro (&Qcode_conversion_map_id);
 
   DEFVAR_LISP ("code-conversion-map-vector", &Vcode_conversion_map_vector,
-    "Vector of code conversion maps.");
+               doc: /* Vector of code conversion maps.  */);
   Vcode_conversion_map_vector = Fmake_vector (make_number (16), Qnil);
 
   DEFVAR_LISP ("font-ccl-encoder-alist", &Vfont_ccl_encoder_alist,
-    "Alist of fontname patterns vs corresponding CCL program.\n\
-Each element looks like (REGEXP . CCL-CODE),\n\
- where CCL-CODE is a compiled CCL program.\n\
-When a font whose name matches REGEXP is used for displaying a character,\n\
- CCL-CODE is executed to calculate the code point in the font\n\
- from the charset number and position code(s) of the character which are set\n\
- in CCL registers R0, R1, and R2 before the execution.\n\
-The code point in the font is set in CCL registers R1 and R2\n\
- when the execution terminated.\n\
-If the font is single-byte font, the register R2 is not used.");
+               doc: /* Alist of fontname patterns vs corresponding CCL program.
+Each element looks like (REGEXP . CCL-CODE),
+ where CCL-CODE is a compiled CCL program.
+When a font whose name matches REGEXP is used for displaying a character,
+ CCL-CODE is executed to calculate the code point in the font
+ from the charset number and position code(s) of the character which are set
+ in CCL registers R0, R1, and R2 before the execution.
+The code point in the font is set in CCL registers R1 and R2
+ when the execution terminated.
+ If the font is single-byte font, the register R2 is not used.  */);
   Vfont_ccl_encoder_alist = Qnil;
 
   defsubr (&Sccl_program_p);
diff --git a/src/charset.c b/src/charset.c
index 38d22121f98..7c50d245ebe 100644
--- a/src/charset.c
+++ b/src/charset.c
@@ -631,37 +631,37 @@ get_new_private_charset_id (dimension, width)
 }
 
 DEFUN ("define-charset", Fdefine_charset, Sdefine_charset, 3, 3, 0,
-  "Define CHARSET-ID as the identification number of CHARSET with INFO-VECTOR.\n\
-If CHARSET-ID is nil, it is decided automatically, which means CHARSET is\n\
- treated as a private charset.\n\
-INFO-VECTOR is a vector of the format:\n\
-   [DIMENSION CHARS WIDTH DIRECTION ISO-FINAL-CHAR ISO-GRAPHIC-PLANE\n\
-    SHORT-NAME LONG-NAME DESCRIPTION]\n\
-The meanings of each elements is as follows:\n\
-DIMENSION (integer) is the number of bytes to represent a character: 1 or 2.\n\
-CHARS (integer) is the number of characters in a dimension: 94 or 96.\n\
-WIDTH (integer) is the number of columns a character in the charset\n\
-occupies on the screen: one of 0, 1, and 2.\n\
-\n\
-DIRECTION (integer) is the rendering direction of characters in the\n\
-charset when rendering.  If 0, render from left to right, else\n\
-render from right to left.\n\
-\n\
-ISO-FINAL-CHAR (character) is the final character of the\n\
-corresponding ISO 2022 charset.\n\
-It may be -1 if the charset is internal use only.\n\
-\n\
-ISO-GRAPHIC-PLANE (integer) is the graphic plane to be invoked\n\
-while encoding to variants of ISO 2022 coding system, one of the\n\
-following: 0/graphic-plane-left(GL), 1/graphic-plane-right(GR).\n\
-It may be -1 if the charset is internal use only.\n\
-\n\
-SHORT-NAME (string) is the short name to refer to the charset.\n\
-\n\
-LONG-NAME (string) is the long name to refer to the charset.\n\
-\n\
-DESCRIPTION (string) is the description string of the charset.")
-  (charset_id, charset_symbol, info_vector)
+       doc: /* Define CHARSET-ID as the identification number of CHARSET with INFO-VECTOR.
+If CHARSET-ID is nil, it is decided automatically, which means CHARSET is
+ treated as a private charset.
+INFO-VECTOR is a vector of the format:
+   [DIMENSION CHARS WIDTH DIRECTION ISO-FINAL-CHAR ISO-GRAPHIC-PLANE
+    SHORT-NAME LONG-NAME DESCRIPTION]
+The meanings of each elements is as follows:
+DIMENSION (integer) is the number of bytes to represent a character: 1 or 2.
+CHARS (integer) is the number of characters in a dimension: 94 or 96.
+WIDTH (integer) is the number of columns a character in the charset
+occupies on the screen: one of 0, 1, and 2.
+
+DIRECTION (integer) is the rendering direction of characters in the
+charset when rendering.  If 0, render from left to right, else
+render from right to left.
+
+ISO-FINAL-CHAR (character) is the final character of the
+corresponding ISO 2022 charset.
+It may be -1 if the charset is internal use only.
+
+ISO-GRAPHIC-PLANE (integer) is the graphic plane to be invoked
+while encoding to variants of ISO 2022 coding system, one of the
+following: 0/graphic-plane-left(GL), 1/graphic-plane-right(GR).
+It may be -1 if the charset is internal use only.
+
+SHORT-NAME (string) is the short name to refer to the charset.
+
+LONG-NAME (string) is the long name to refer to the charset.
+
+DESCRIPTION (string) is the description string of the charset.  */)
+       (charset_id, charset_symbol, info_vector)
      Lisp_Object charset_id, charset_symbol, info_vector;
 {
   Lisp_Object *vec;
@@ -713,23 +713,23 @@ DESCRIPTION (string) is the description string of the charset.")
 
 DEFUN ("generic-character-list", Fgeneric_character_list,
        Sgeneric_character_list, 0, 0, 0,
-  "Return a list of all possible generic characters.\n\
-It includes a generic character for a charset not yet defined.")
-  ()
+       doc: /* Return a list of all possible generic characters.
+It includes a generic character for a charset not yet defined.  */)
+     ()
 {
   return Vgeneric_character_list;
 }
 
 DEFUN ("get-unused-iso-final-char", Fget_unused_iso_final_char,
        Sget_unused_iso_final_char, 2, 2, 0,
-  "Return an unsed ISO's final char for a charset of DIMENISION and CHARS.\n\
-DIMENSION is the number of bytes to represent a character: 1 or 2.\n\
-CHARS is the number of characters in a dimension: 94 or 96.\n\
-\n\
-This final char is for private use, thus the range is `0' (48) .. `?' (63).\n\
-If there's no unused final char for the specified kind of charset,\n\
-return nil.")
-  (dimension, chars)
+       doc: /* Return an unsed ISO's final char for a charset of DIMENISION and CHARS.
+DIMENSION is the number of bytes to represent a character: 1 or 2.
+CHARS is the number of characters in a dimension: 94 or 96.
+
+This final char is for private use, thus the range is `0' (48) .. `?' (63).
+If there's no unused final char for the specified kind of charset,
+return nil.  */)
+     (dimension, chars)
      Lisp_Object dimension, chars;
 {
   int final_char;
@@ -752,9 +752,9 @@ return nil.")
 
 DEFUN ("declare-equiv-charset", Fdeclare_equiv_charset, Sdeclare_equiv_charset,
        4, 4, 0,
-  "Declare a charset of DIMENSION, CHARS, FINAL-CHAR is the same as CHARSET.\n\
-CHARSET should be defined by `defined-charset' in advance.")
-  (dimension, chars, final_char, charset_symbol)
+       doc: /* Declare a charset of DIMENSION, CHARS, FINAL-CHAR is the same as CHARSET.
+CHARSET should be defined by `defined-charset' in advance.  */)
+     (dimension, chars, final_char, charset_symbol)
      Lisp_Object dimension, chars, final_char, charset_symbol;
 {
   int charset;
@@ -860,16 +860,16 @@ find_charset_in_text (ptr, nchars, nbytes, charsets, table)
 
 DEFUN ("find-charset-region", Ffind_charset_region, Sfind_charset_region,
        2, 3, 0,
-  "Return a list of charsets in the region between BEG and END.\n\
-BEG and END are buffer positions.\n\
-Optional arg TABLE if non-nil is a translation table to look up.\n\
-\n\
-If the region contains invalid multibyte characters,\n\
-`unknown' is included in the returned list.\n\
-\n\
-If the current buffer is unibyte, the returned list may contain\n\
-only `ascii', `eight-bit-control', and `eight-bit-graphic'.")
-  (beg, end, table)
+       doc: /* Return a list of charsets in the region between BEG and END.
+BEG and END are buffer positions.
+Optional arg TABLE if non-nil is a translation table to look up.
+
+If the region contains invalid multibyte characters,
+`unknown' is included in the returned list.
+
+If the current buffer is unibyte, the returned list may contain
+only `ascii', `eight-bit-control', and `eight-bit-graphic'.  */)
+     (beg, end, table)
      Lisp_Object beg, end, table;
 {
   int charsets[MAX_CHARSET + 1];
@@ -917,15 +917,15 @@ only `ascii', `eight-bit-control', and `eight-bit-graphic'.")
 
 DEFUN ("find-charset-string", Ffind_charset_string, Sfind_charset_string,
        1, 2, 0,
-  "Return a list of charsets in STR.\n\
-Optional arg TABLE if non-nil is a translation table to look up.\n\
-\n\
-If the string contains invalid multibyte characters,\n\
-`unknown' is included in the returned list.\n\
-\n\
-If STR is unibyte, the returned list may contain\n\
-only `ascii', `eight-bit-control', and `eight-bit-graphic'.")
-  (str, table)
+       doc: /* Return a list of charsets in STR.
+Optional arg TABLE if non-nil is a translation table to look up.
+
+If the string contains invalid multibyte characters,
+`unknown' is included in the returned list.
+
+If STR is unibyte, the returned list may contain
+only `ascii', `eight-bit-control', and `eight-bit-graphic'.  */)
+     (str, table)
      Lisp_Object str, table;
 {
   int charsets[MAX_CHARSET + 1];
@@ -951,8 +951,9 @@ only `ascii', `eight-bit-control', and `eight-bit-graphic'.")
 
 
 DEFUN ("make-char-internal", Fmake_char_internal, Smake_char_internal, 1, 3, 0,
-  "")
-  (charset, code1, code2)
+       doc: /* Return a character made from arguments.
+Internal use only.  */)
+     (charset, code1, code2)
      Lisp_Object charset, code1, code2;
 {
   int charset_id, c1, c2;
@@ -1016,10 +1017,10 @@ DEFUN ("make-char-internal", Fmake_char_internal, Smake_char_internal, 1, 3, 0,
 }
 
 DEFUN ("split-char", Fsplit_char, Ssplit_char, 1, 1, 0,
-  "Return list of charset and one or two position-codes of CHAR.\n\
-If CHAR is invalid as a character code,\n\
-return a list of symbol `unknown' and CHAR.")
-  (ch)
+       doc: /* Return list of charset and one or two position-codes of CHAR.
+If CHAR is invalid as a character code,
+return a list of symbol `unknown' and CHAR.  */)
+     (ch)
      Lisp_Object ch;
 {
   int c, charset, c1, c2;
@@ -1036,8 +1037,8 @@ return a list of symbol `unknown' and CHAR.")
 }
 
 DEFUN ("char-charset", Fchar_charset, Schar_charset, 1, 1, 0,
-  "Return charset of CHAR.")
-  (ch)
+       doc: /* Return charset of CHAR.  */)
+     (ch)
      Lisp_Object ch;
 {
   CHECK_NUMBER (ch, 0);
@@ -1046,10 +1047,10 @@ DEFUN ("char-charset", Fchar_charset, Schar_charset, 1, 1, 0,
 }
 
 DEFUN ("charset-after", Fcharset_after, Scharset_after, 0, 1, 0,
-  "Return charset of a character in the current buffer at position POS.\n\
-If POS is nil, it defauls to the current point.\n\
-If POS is out of range, the value is nil.")
-  (pos)
+       doc: /* Return charset of a character in the current buffer at position POS.
+If POS is nil, it defauls to the current point.
+If POS is out of range, the value is nil.  */)
+     (pos)
      Lisp_Object pos;
 {
   Lisp_Object ch;
@@ -1063,14 +1064,14 @@ If POS is out of range, the value is nil.")
 }
 
 DEFUN ("iso-charset", Fiso_charset, Siso_charset, 3, 3, 0,
-  "Return charset of ISO's specification DIMENSION, CHARS, and FINAL-CHAR.\n\
-\n\
-ISO 2022's designation sequence (escape sequence) distinguishes charsets\n\
-by their DIMENSION, CHARS, and FINAL-CHAR,\n\
-where as Emacs distinguishes them by charset symbol.\n\
-See the documentation of the function `charset-info' for the meanings of\n\
-DIMENSION, CHARS, and FINAL-CHAR.")
-  (dimension, chars, final_char)
+       doc: /* Return charset of ISO's specification DIMENSION, CHARS, and FINAL-CHAR.
+
+ISO 2022's designation sequence (escape sequence) distinguishes charsets
+by their DIMENSION, CHARS, and FINAL-CHAR,
+where as Emacs distinguishes them by charset symbol.
+See the documentation of the function `charset-info' for the meanings of
+DIMENSION, CHARS, and FINAL-CHAR.  */)
+     (dimension, chars, final_char)
      Lisp_Object dimension, chars, final_char;
 {
   int charset;
@@ -1115,10 +1116,10 @@ char_valid_p (c, genericp)
 }
 
 DEFUN ("char-valid-p", Fchar_valid_p, Schar_valid_p, 1, 2, 0,
-  "Return t if OBJECT is a valid normal character.\n\
-If optional arg GENERICP is non-nil, also return t if OBJECT is\n\
-a valid generic character.")
-  (object, genericp)
+       doc: /* Return t if OBJECT is a valid normal character.
+If optional arg GENERICP is non-nil, also return t if OBJECT is
+a valid generic character.  */)
+     (object, genericp)
      Lisp_Object object, genericp;
 {
   if (! NATNUMP (object))
@@ -1128,10 +1129,10 @@ a valid generic character.")
 
 DEFUN ("unibyte-char-to-multibyte", Funibyte_char_to_multibyte,
        Sunibyte_char_to_multibyte, 1, 1, 0,
-  "Convert the unibyte character CH to multibyte character.\n\
-The conversion is done based on `nonascii-translation-table' (which see)\n\
- or `nonascii-insert-offset' (which see).")
-  (ch)
+       doc: /* Convert the unibyte character CH to multibyte character.
+The conversion is done based on `nonascii-translation-table' (which see)
+ or `nonascii-insert-offset' (which see).  */)
+     (ch)
      Lisp_Object ch;
 {
   int c;
@@ -1148,10 +1149,10 @@ The conversion is done based on `nonascii-translation-table' (which see)\n\
 
 DEFUN ("multibyte-char-to-unibyte", Fmultibyte_char_to_unibyte,
        Smultibyte_char_to_unibyte, 1, 1, 0,
-  "Convert the multibyte character CH to unibyte character.\n\
-The conversion is done based on `nonascii-translation-table' (which see)\n\
- or `nonascii-insert-offset' (which see).")
-  (ch)
+       doc: /* Convert the multibyte character CH to unibyte character.
+The conversion is done based on `nonascii-translation-table' (which see)
+ or `nonascii-insert-offset' (which see).  */)
+     (ch)
      Lisp_Object ch;
 {
   int c;
@@ -1167,9 +1168,9 @@ The conversion is done based on `nonascii-translation-table' (which see)\n\
 }
 
 DEFUN ("char-bytes", Fchar_bytes, Schar_bytes, 1, 1, 0,
-  "Return 1 regardless of the argument CHAR.\n\
-This is now an obsolete function.  We keep it just for backward compatibility.")
-  (ch)
+       doc: /* Return 1 regardless of the argument CHAR.
+This is now an obsolete function.  We keep it just for backward compatibility.  */)
+     (ch)
      Lisp_Object ch;
 {
   CHECK_NUMBER (ch, 0);
@@ -1212,11 +1213,11 @@ char_bytes (c)
             : 4))))
 
 DEFUN ("char-width", Fchar_width, Schar_width, 1, 1, 0,
-  "Return width of CHAR when displayed in the current buffer.\n\
-The width is measured by how many columns it occupies on the screen.\n\
-Tab is taken to occupy `tab-width' columns.")
-  (ch)
-       Lisp_Object ch;
+       doc: /* Return width of CHAR when displayed in the current buffer.
+The width is measured by how many columns it occupies on the screen.
+Tab is taken to occupy `tab-width' columns.  */)
+     (ch)
+     Lisp_Object ch;
 {
   Lisp_Object val, disp;
   int c;
@@ -1389,13 +1390,13 @@ lisp_string_width (string, precision, nchars, nbytes)
 }
 
 DEFUN ("string-width", Fstring_width, Sstring_width, 1, 1, 0,
-  "Return width of STRING when displayed in the current buffer.\n\
-Width is measured by how many columns it occupies on the screen.\n\
-When calculating width of a multibyte character in STRING,\n\
-only the base leading-code is considered; the validity of\n\
-the following bytes is not checked.  Tabs in STRING are always\n\
-taken to occupy `tab-width' columns.")
-  (str)
+       doc: /* Return width of STRING when displayed in the current buffer.
+Width is measured by how many columns it occupies on the screen.
+When calculating width of a multibyte character in STRING,
+only the base leading-code is considered; the validity of
+the following bytes is not checked.  Tabs in STRING are always
+taken to occupy `tab-width' columns.  */)
+     (str)
      Lisp_Object str;
 {
   Lisp_Object val;
@@ -1406,9 +1407,9 @@ taken to occupy `tab-width' columns.")
 }
 
 DEFUN ("char-direction", Fchar_direction, Schar_direction, 1, 1, 0,
-  "Return the direction of CHAR.\n\
-The returned value is 0 for left-to-right and 1 for right-to-left.")
-  (ch)
+       doc: /* Return the direction of CHAR.
+The returned value is 0 for left-to-right and 1 for right-to-left.  */)
+     (ch)
      Lisp_Object ch;
 {
   int charset;
@@ -1421,8 +1422,8 @@ The returned value is 0 for left-to-right and 1 for right-to-left.")
 }
 
 DEFUN ("chars-in-region", Fchars_in_region, Schars_in_region, 2, 2, 0,
-  "Return number of characters between BEG and END.")
-  (beg, end)
+       doc: /* Return number of characters between BEG and END.  */)
+     (beg, end)
      Lisp_Object beg, end;
 {
   int from, to;
@@ -1628,8 +1629,8 @@ str_as_unibyte (str, bytes)
 
 
 DEFUN ("string", Fstring, Sstring, 1, MANY, 0,
-  "Concatenate all the argument characters and make the result a string.")
-  (n, args)
+       doc: /* Concatenate all the argument characters and make the result a string.  */)
+     (n, args)
      int n;
      Lisp_Object *args;
 {
@@ -1674,8 +1675,8 @@ charset_id_internal (charset_name)
 }
 
 DEFUN ("setup-special-charsets", Fsetup_special_charsets,
-       Ssetup_special_charsets, 0, 0, 0, "Internal use only.")
-   ()
+       Ssetup_special_charsets, 0, 0, 0, doc: /* Internal use only.  */)
+     ()
 {
   charset_latin_iso8859_1 = charset_id_internal ("latin-iso8859-1");
   charset_jisx0208_1978 = charset_id_internal ("japanese-jisx0208-1978");
@@ -1840,56 +1841,59 @@ syms_of_charset ()
   defsubr (&Ssetup_special_charsets);
 
   DEFVAR_LISP ("charset-list", &Vcharset_list,
-    "List of charsets ever defined.");
+               doc: /* List of charsets ever defined.  */);
   Vcharset_list = Fcons (Qascii, Fcons (Qeight_bit_control,
                                         Fcons (Qeight_bit_graphic, Qnil)));
 
   DEFVAR_LISP ("translation-table-vector",  &Vtranslation_table_vector,
-    "Vector of cons cell of a symbol and translation table ever defined.\n\
-An ID of a translation table is an index of this vector.");
+               doc: /* Vector of cons cell of a symbol and translation table ever defined.
+An ID of a translation table is an index of this vector.  */);
   Vtranslation_table_vector = Fmake_vector (make_number (16), Qnil);
 
   DEFVAR_INT ("leading-code-private-11", &leading_code_private_11,
-    "Leading-code of private TYPE9N charset of column-width 1.");
+              doc: /* Leading-code of private TYPE9N charset of column-width 1.  */);
   leading_code_private_11 = LEADING_CODE_PRIVATE_11;
 
   DEFVAR_INT ("leading-code-private-12", &leading_code_private_12,
-    "Leading-code of private TYPE9N charset of column-width 2.");
+              doc: /* Leading-code of private TYPE9N charset of column-width 2.  */);
   leading_code_private_12 = LEADING_CODE_PRIVATE_12;
 
   DEFVAR_INT ("leading-code-private-21", &leading_code_private_21,
-    "Leading-code of private TYPE9Nx9N charset of column-width 1.");
+              doc: /* Leading-code of private TYPE9Nx9N charset of column-width 1.  */);
   leading_code_private_21 = LEADING_CODE_PRIVATE_21;
 
   DEFVAR_INT ("leading-code-private-22", &leading_code_private_22,
-    "Leading-code of private TYPE9Nx9N charset of column-width 2.");
+              doc: /* Leading-code of private TYPE9Nx9N charset of column-width 2.  */);
   leading_code_private_22 = LEADING_CODE_PRIVATE_22;
 
   DEFVAR_INT ("nonascii-insert-offset", &nonascii_insert_offset,
-    "Offset for converting non-ASCII unibyte codes 0240...0377 to multibyte.\n\
-This is used for converting unibyte text to multibyte,\n\
-and for inserting character codes specified by number.\n\n\
-This serves to convert a Latin-1 or similar 8-bit character code\n\
-to the corresponding Emacs multibyte character code.\n\
-Typically the value should be (- (make-char CHARSET 0) 128),\n\
-for your choice of character set.\n\
-If `nonascii-translation-table' is non-nil, it overrides this variable.");
+              doc: /* Offset for converting non-ASCII unibyte codes 0240...0377 to multibyte.
+This is used for converting unibyte text to multibyte,
+and for inserting character codes specified by number.
+
+This serves to convert a Latin-1 or similar 8-bit character code
+to the corresponding Emacs multibyte character code.
+Typically the value should be (- (make-char CHARSET 0) 128),
+for your choice of character set.
+If `nonascii-translation-table' is non-nil, it overrides this variable.  */);
   nonascii_insert_offset = 0;
 
   DEFVAR_LISP ("nonascii-translation-table", &Vnonascii_translation_table,
-    "Translation table to convert non-ASCII unibyte codes to multibyte.\n\
-This is used for converting unibyte text to multibyte,\n\
-and for inserting character codes specified by number.\n\n\
-Conversion is performed only when multibyte characters are enabled,\n\
-and it serves to convert a Latin-1 or similar 8-bit character code\n\
-to the corresponding Emacs character code.\n\n\
-If this is nil, `nonascii-insert-offset' is used instead.\n\
-See also the docstring of `make-translation-table'.");
+               doc: /* Translation table to convert non-ASCII unibyte codes to multibyte.
+This is used for converting unibyte text to multibyte,
+and for inserting character codes specified by number.
+
+Conversion is performed only when multibyte characters are enabled,
+and it serves to convert a Latin-1 or similar 8-bit character code
+to the corresponding Emacs character code.
+
+If this is nil, `nonascii-insert-offset' is used instead.
+See also the docstring of `make-translation-table'.  */);
   Vnonascii_translation_table = Qnil;
 
   DEFVAR_LISP ("auto-fill-chars", &Vauto_fill_chars,
-    "A char-table for characters which invoke auto-filling.\n\
-Such characters have value t in this table.");
+               doc: /* A char-table for characters which invoke auto-filling.
+Such characters have value t in this table.  */);
   Vauto_fill_chars = Fmake_char_table (Qauto_fill_chars, Qnil);
   CHAR_TABLE_SET (Vauto_fill_chars, make_number (' '), Qt);
   CHAR_TABLE_SET (Vauto_fill_chars, make_number ('\n'), Qt);
diff --git a/src/process.c b/src/process.c
index 956f2b8fdb3..c833e9c3bef 100644
--- a/src/process.c
+++ b/src/process.c
@@ -481,16 +481,16 @@ remove_process (proc)
 }
 
 DEFUN ("processp", Fprocessp, Sprocessp, 1, 1, 0,
-  "Return t if OBJECT is a process.")
-  (object)
+       doc: /* Return t if OBJECT is a process.  */)
+     (object)
      Lisp_Object object;
 {
   return PROCESSP (object) ? Qt : Qnil;
 }
 
 DEFUN ("get-process", Fget_process, Sget_process, 1, 1, 0,
-  "Return the process named NAME, or nil if there is none.")
-  (name)
+       doc: /* Return the process named NAME, or nil if there is none.  */)
+     (name)
      register Lisp_Object name;
 {
   if (PROCESSP (name))
@@ -500,9 +500,9 @@ DEFUN ("get-process", Fget_process, Sget_process, 1, 1, 0,
 }
 
 DEFUN ("get-buffer-process", Fget_buffer_process, Sget_buffer_process, 1, 1, 0,
-  "Return the (or a) process associated with BUFFER.\n\
-BUFFER may be a buffer or the name of one.")
-  (buffer)
+       doc: /* Return the (or a) process associated with BUFFER.
+BUFFER may be a buffer or the name of one.  */)
+     (buffer)
      register Lisp_Object buffer;
 {
   register Lisp_Object buf, tail, proc;
@@ -560,10 +560,10 @@ get_process (name)
 }
 
 DEFUN ("delete-process", Fdelete_process, Sdelete_process, 1, 1, 0,
-  "Delete PROCESS: kill it and forget about it immediately.\n\
-PROCESS may be a process, a buffer, the name of a process or buffer, or\n\
-nil, indicating the current buffer's process.")
-  (process)
+       doc: /* Delete PROCESS: kill it and forget about it immediately.
+PROCESS may be a process, a buffer, the name of a process or buffer, or
+nil, indicating the current buffer's process.  */)
+     (process)
      register Lisp_Object process;
 {
   process = get_process (process);
@@ -588,18 +588,18 @@ nil, indicating the current buffer's process.")
 }
 
 DEFUN ("process-status", Fprocess_status, Sprocess_status, 1, 1, 0,
-  "Return the status of PROCESS.\n\
-The returned value is one of the following symbols:\n\
-run  -- for a process that is running.\n\
-stop -- for a process stopped but continuable.\n\
-exit -- for a process that has exited.\n\
-signal -- for a process that has got a fatal signal.\n\
-open -- for a network stream connection that is open.\n\
-closed -- for a network stream connection that is closed.\n\
-nil -- if arg is a process name and no such process exists.\n\
-PROCESS may be a process, a buffer, the name of a process, or\n\
-nil, indicating the current buffer's process.")
-  (process)
+       doc: /* Return the status of PROCESS.
+The returned value is one of the following symbols:
+run  -- for a process that is running.
+stop -- for a process stopped but continuable.
+exit -- for a process that has exited.
+signal -- for a process that has got a fatal signal.
+open -- for a network stream connection that is open.
+closed -- for a network stream connection that is closed.
+nil -- if arg is a process name and no such process exists.
+PROCESS may be a process, a buffer, the name of a process, or
+nil, indicating the current buffer's process.  */)
+     (process)
      register Lisp_Object process;
 {
   register struct Lisp_Process *p;
@@ -631,9 +631,9 @@ nil, indicating the current buffer's process.")
 
 DEFUN ("process-exit-status", Fprocess_exit_status, Sprocess_exit_status,
        1, 1, 0,
-  "Return the exit status of PROCESS or the signal number that killed it.\n\
-If PROCESS has not yet exited or died, return 0.")
-  (process)
+       doc: /* Return the exit status of PROCESS or the signal number that killed it.
+If PROCESS has not yet exited or died, return 0.  */)
+     (process)
      register Lisp_Object process;
 {
   CHECK_PROCESS (process, 0);
@@ -645,10 +645,10 @@ If PROCESS has not yet exited or died, return 0.")
 }
 
 DEFUN ("process-id", Fprocess_id, Sprocess_id, 1, 1, 0,
-  "Return the process id of PROCESS.\n\
-This is the pid of the Unix process which PROCESS uses or talks to.\n\
-For a network connection, this value is nil.")
-  (process)
+       doc: /* Return the process id of PROCESS.
+This is the pid of the Unix process which PROCESS uses or talks to.
+For a network connection, this value is nil.  */)
+     (process)
      register Lisp_Object process;
 {
   CHECK_PROCESS (process, 0);
@@ -656,10 +656,10 @@ For a network connection, this value is nil.")
 }
 
 DEFUN ("process-name", Fprocess_name, Sprocess_name, 1, 1, 0,
-  "Return the name of PROCESS, as a string.\n\
-This is the name of the program invoked in PROCESS,\n\
-possibly modified to make it unique among process names.")
-  (process)
+       doc: /* Return the name of PROCESS, as a string.
+This is the name of the program invoked in PROCESS,
+possibly modified to make it unique among process names.  */)
+     (process)
      register Lisp_Object process;
 {
   CHECK_PROCESS (process, 0);
@@ -667,11 +667,11 @@ possibly modified to make it unique among process names.")
 }
 
 DEFUN ("process-command", Fprocess_command, Sprocess_command, 1, 1, 0,
-  "Return the command that was executed to start PROCESS.\n\
-This is a list of strings, the first string being the program executed\n\
-and the rest of the strings being the arguments given to it.\n\
-For a non-child channel, this is nil.")
-  (process)
+       doc: /* Return the command that was executed to start PROCESS.
+This is a list of strings, the first string being the program executed
+and the rest of the strings being the arguments given to it.
+For a non-child channel, this is nil.  */)
+     (process)
      register Lisp_Object process;
 {
   CHECK_PROCESS (process, 0);
@@ -679,10 +679,10 @@ For a non-child channel, this is nil.")
 }
 
 DEFUN ("process-tty-name", Fprocess_tty_name, Sprocess_tty_name, 1, 1, 0,
-  "Return the name of the terminal PROCESS uses, or nil if none.\n\
-This is the terminal that the process itself reads and writes on,\n\
-not the name of the pty that Emacs uses to talk with that terminal.")
-  (process)
+       doc: /* Return the name of the terminal PROCESS uses, or nil if none.
+This is the terminal that the process itself reads and writes on,
+not the name of the pty that Emacs uses to talk with that terminal.  */)
+     (process)
      register Lisp_Object process;
 {
   CHECK_PROCESS (process, 0);
@@ -690,9 +690,9 @@ not the name of the pty that Emacs uses to talk with that terminal.")
 }
 
 DEFUN ("set-process-buffer", Fset_process_buffer, Sset_process_buffer,
-  2, 2, 0,
-  "Set buffer associated with PROCESS to BUFFER (a buffer, or nil).")
-  (process, buffer)
+       2, 2, 0,
+       doc: /* Set buffer associated with PROCESS to BUFFER (a buffer, or nil).  */)
+     (process, buffer)
      register Lisp_Object process, buffer;
 {
   CHECK_PROCESS (process, 0);
@@ -703,10 +703,10 @@ DEFUN ("set-process-buffer", Fset_process_buffer, Sset_process_buffer,
 }
 
 DEFUN ("process-buffer", Fprocess_buffer, Sprocess_buffer,
-  1, 1, 0,
-  "Return the buffer PROCESS is associated with.\n\
-Output from PROCESS is inserted in this buffer unless PROCESS has a filter.")
-  (process)
+       1, 1, 0,
+       doc: /* Return the buffer PROCESS is associated with.
+Output from PROCESS is inserted in this buffer unless PROCESS has a filter.  */)
+     (process)
      register Lisp_Object process;
 {
   CHECK_PROCESS (process, 0);
@@ -714,9 +714,9 @@ Output from PROCESS is inserted in this buffer unless PROCESS has a filter.")
 }
 
 DEFUN ("process-mark", Fprocess_mark, Sprocess_mark,
-  1, 1, 0,
-  "Return the marker for the end of the last output from PROCESS.")
-  (process)
+       1, 1, 0,
+       doc: /* Return the marker for the end of the last output from PROCESS.  */)
+     (process)
      register Lisp_Object process;
 {
   CHECK_PROCESS (process, 0);
@@ -724,14 +724,14 @@ DEFUN ("process-mark", Fprocess_mark, Sprocess_mark,
 }
 
 DEFUN ("set-process-filter", Fset_process_filter, Sset_process_filter,
-  2, 2, 0,
-  "Give PROCESS the filter function FILTER; nil means no filter.\n\
-t means stop accepting output from the process.\n\
-When a process has a filter, each time it does output\n\
-the entire string of output is passed to the filter.\n\
-The filter gets two arguments: the process and the string of output.\n\
-If the process has a filter, its buffer is not used for output.")
-  (process, filter)
+       2, 2, 0,
+       doc: /* Give PROCESS the filter function FILTER; nil means no filter.
+t means stop accepting output from the process.
+When a process has a filter, each time it does output
+the entire string of output is passed to the filter.
+The filter gets two arguments: the process and the string of output.
+If the process has a filter, its buffer is not used for output.  */)
+     (process, filter)
      register Lisp_Object process, filter;
 {
   struct Lisp_Process *p;
@@ -766,10 +766,10 @@ If the process has a filter, its buffer is not used for output.")
 }
 
 DEFUN ("process-filter", Fprocess_filter, Sprocess_filter,
-  1, 1, 0,
-  "Returns the filter function of PROCESS; nil if none.\n\
-See `set-process-filter' for more info on filter functions.")
-  (process)
+       1, 1, 0,
+       doc: /* Returns the filter function of PROCESS; nil if none.
+See `set-process-filter' for more info on filter functions.  */)
+     (process)
      register Lisp_Object process;
 {
   CHECK_PROCESS (process, 0);
@@ -777,11 +777,11 @@ See `set-process-filter' for more info on filter functions.")
 }
 
 DEFUN ("set-process-sentinel", Fset_process_sentinel, Sset_process_sentinel,
-  2, 2, 0,
-  "Give PROCESS the sentinel SENTINEL; nil for none.\n\
-The sentinel is called as a function when the process changes state.\n\
-It gets two arguments: the process, and a string describing the change.")
-  (process, sentinel)
+       2, 2, 0,
+       doc: /* Give PROCESS the sentinel SENTINEL; nil for none.
+The sentinel is called as a function when the process changes state.
+It gets two arguments: the process, and a string describing the change.  */)
+     (process, sentinel)
      register Lisp_Object process, sentinel;
 {
   CHECK_PROCESS (process, 0);
@@ -790,10 +790,10 @@ It gets two arguments: the process, and a string describing the change.")
 }
 
 DEFUN ("process-sentinel", Fprocess_sentinel, Sprocess_sentinel,
-  1, 1, 0,
-  "Return the sentinel of PROCESS; nil if none.\n\
-See `set-process-sentinel' for more info on sentinels.")
-  (process)
+       1, 1, 0,
+       doc: /* Return the sentinel of PROCESS; nil if none.
+See `set-process-sentinel' for more info on sentinels.  */)
+     (process)
      register Lisp_Object process;
 {
   CHECK_PROCESS (process, 0);
@@ -801,9 +801,9 @@ See `set-process-sentinel' for more info on sentinels.")
 }
 
 DEFUN ("set-process-window-size", Fset_process_window_size,
-  Sset_process_window_size, 3, 3, 0,
-  "Tell PROCESS that it has logical window size HEIGHT and WIDTH.")
-  (process, height, width)
+       Sset_process_window_size, 3, 3, 0,
+       doc: /* Tell PROCESS that it has logical window size HEIGHT and WIDTH.  */)
+     (process, height, width)
      register Lisp_Object process, height, width;
 {
   CHECK_PROCESS (process, 0);
@@ -819,23 +819,23 @@ DEFUN ("set-process-window-size", Fset_process_window_size,
 }
 
 DEFUN ("set-process-inherit-coding-system-flag",
-  Fset_process_inherit_coding_system_flag,
-  Sset_process_inherit_coding_system_flag, 2, 2, 0,
-  "Determine whether buffer of PROCESS will inherit coding-system.\n\
-If the second argument FLAG is non-nil, then the variable\n\
-`buffer-file-coding-system' of the buffer associated with PROCESS\n\
-will be bound to the value of the coding system used to decode\n\
-the process output.\n\
-\n\
-This is useful when the coding system specified for the process buffer\n\
-leaves either the character code conversion or the end-of-line conversion\n\
-unspecified, or if the coding system used to decode the process output\n\
-is more appropriate for saving the process buffer.\n\
-\n\
-Binding the variable `inherit-process-coding-system' to non-nil before\n\
-starting the process is an alternative way of setting the inherit flag\n\
-for the process which will run.")
-  (process, flag)
+       Fset_process_inherit_coding_system_flag,
+       Sset_process_inherit_coding_system_flag, 2, 2, 0,
+       doc: /* Determine whether buffer of PROCESS will inherit coding-system.
+If the second argument FLAG is non-nil, then the variable
+`buffer-file-coding-system' of the buffer associated with PROCESS
+will be bound to the value of the coding system used to decode
+the process output.
+
+This is useful when the coding system specified for the process buffer
+leaves either the character code conversion or the end-of-line conversion
+unspecified, or if the coding system used to decode the process output
+is more appropriate for saving the process buffer.
+
+Binding the variable `inherit-process-coding-system' to non-nil before
+starting the process is an alternative way of setting the inherit flag
+for the process which will run.  */)
+     (process, flag)
      register Lisp_Object process, flag;
 {
   CHECK_PROCESS (process, 0);
@@ -844,13 +844,13 @@ for the process which will run.")
 }
 
 DEFUN ("process-inherit-coding-system-flag",
-  Fprocess_inherit_coding_system_flag, Sprocess_inherit_coding_system_flag,
-  1, 1, 0,
-  "Return the value of inherit-coding-system flag for PROCESS.\n\
-If this flag is t, `buffer-file-coding-system' of the buffer\n\
-associated with PROCESS will inherit the coding system used to decode\n\
-the process output.")
-  (process)
+       Fprocess_inherit_coding_system_flag, Sprocess_inherit_coding_system_flag,
+       1, 1, 0,
+       doc: /* Return the value of inherit-coding-system flag for PROCESS.
+If this flag is t, `buffer-file-coding-system' of the buffer
+associated with PROCESS will inherit the coding system used to decode
+the process output.  */)
+     (process)
      register Lisp_Object process;
 {
   CHECK_PROCESS (process, 0);
@@ -858,11 +858,11 @@ the process output.")
 }
 
 DEFUN ("process-kill-without-query", Fprocess_kill_without_query,
-  Sprocess_kill_without_query, 1, 2, 0,
-  "Say no query needed if PROCESS is running when Emacs is exited.\n\
-Optional second argument if non-nil says to require a query.\n\
-Value is t if a query was formerly required.")
-  (process, value)
+       Sprocess_kill_without_query, 1, 2, 0,
+       doc: /* Say no query needed if PROCESS is running when Emacs is exited.
+Optional second argument if non-nil says to require a query.
+Value is t if a query was formerly required.  */)
+     (process, value)
      register Lisp_Object process, value;
 {
   Lisp_Object tem;
@@ -875,10 +875,10 @@ Value is t if a query was formerly required.")
 }
 
 DEFUN ("process-contact", Fprocess_contact, Sprocess_contact,
-  1, 1, 0,
-  "Return the contact info of PROCESS; t for a real child.\n\
-For a net connection, the value is a cons cell of the form (HOST SERVICE).")
-  (process)
+       1, 1, 0,
+       doc: /* Return the contact info of PROCESS; t for a real child.
+For a net connection, the value is a cons cell of the form (HOST SERVICE).  */)
+     (process)
      register Lisp_Object process;
 {
   CHECK_PROCESS (process, 0);
@@ -888,10 +888,10 @@ For a net connection, the value is a cons cell of the form (HOST SERVICE).")
 #if 0 /* Turned off because we don't currently record this info
          in the process.  Perhaps add it.  */
 DEFUN ("process-connection", Fprocess_connection, Sprocess_connection, 1, 1, 0,
- "Return the connection type of PROCESS.\n\
-The value is nil for a pipe, t or `pty' for a pty, or `stream' for\n\
-a socket connection.")
-  (process)
+       doc: /* Return the connection type of PROCESS.
+The value is nil for a pipe, t or `pty' for a pty, or `stream' for
+a socket connection.  */)
+     (process)
      Lisp_Object process;
 {
   return XPROCESS (process)->type;
@@ -1015,10 +1015,10 @@ Proc         Status   Buffer         Tty         Command\n\
 }
 
 DEFUN ("list-processes", Flist_processes, Slist_processes, 0, 0, "",
-  "Display a list of all processes.\n\
-Any process listed as exited or signaled is actually eliminated\n\
-after the listing is made.")
-  ()
+       doc: /* Display a list of all processes.
+Any process listed as exited or signaled is actually eliminated
+after the listing is made.  */)
+     ()
 {
   internal_with_output_to_temp_buffer ("*Process List*",
                                        list_processes_1, Qnil);
@@ -1026,8 +1026,8 @@ after the listing is made.")
 }
 
 DEFUN ("process-list", Fprocess_list, Sprocess_list, 0, 0, 0,
-  "Return a list of all processes.")
-  ()
+       doc: /* Return a list of all processes.  */)
+     ()
 {
   return Fmapcar (Qcdr, Vprocess_alist);
 }
@@ -1037,16 +1037,16 @@ DEFUN ("process-list", Fprocess_list, Sprocess_list, 0, 0, 0,
 static Lisp_Object start_process_unwind ();
 
 DEFUN ("start-process", Fstart_process, Sstart_process, 3, MANY, 0,
-  "Start a program in a subprocess.  Return the process object for it.\n\
-NAME is name for process.  It is modified if necessary to make it unique.\n\
-BUFFER is the buffer or (buffer-name) to associate with the process.\n\
- Process output goes at end of that buffer, unless you specify\n\
- an output stream or filter function to handle the output.\n\
- BUFFER may be also nil, meaning that this process is not associated\n\
- with any buffer.\n\
-Third arg is program file name.  It is searched for in PATH.\n\
-Remaining arguments are strings to give program as arguments.")
-  (nargs, args)
+       doc: /* Start a program in a subprocess.  Return the process object for it.
+NAME is name for process.  It is modified if necessary to make it unique.
+BUFFER is the buffer or (buffer-name) to associate with the process.
+ Process output goes at end of that buffer, unless you specify
+ an output stream or filter function to handle the output.
+ BUFFER may be also nil, meaning that this process is not associated
+ with any buffer.
+Third arg is program file name.  It is searched for in PATH.
+Remaining arguments are strings to give program as arguments.  */)
+     (nargs, args)
      int nargs;
      register Lisp_Object *args;
 {
@@ -1744,20 +1744,20 @@ create_process (process, new_argv, current_dir)
 
 DEFUN ("open-network-stream", Fopen_network_stream, Sopen_network_stream, 
        4, 4, 0, 
-  "Open a TCP connection for a service to a host.\n\
-Returns a subprocess-object to represent the connection.\n\
-Input and output work as for subprocesses; `delete-process' closes it.\n\
-Args are NAME BUFFER HOST SERVICE.\n\
-NAME is name for process.  It is modified if necessary to make it unique.\n\
-BUFFER is the buffer (or buffer-name) to associate with the process.\n\
- Process output goes at end of that buffer, unless you specify\n\
- an output stream or filter function to handle the output.\n\
- BUFFER may be also nil, meaning that this process is not associated\n\
- with any buffer\n\
-Third arg is name of the host to connect to, or its IP address.\n\
-Fourth arg SERVICE is name of the service desired, or an integer\n\
- specifying a port number to connect to.")
-   (name, buffer, host, service)
+       doc: /* Open a TCP connection for a service to a host.
+Returns a subprocess-object to represent the connection.
+Input and output work as for subprocesses; `delete-process' closes it.
+Args are NAME BUFFER HOST SERVICE.
+NAME is name for process.  It is modified if necessary to make it unique.
+BUFFER is the buffer (or buffer-name) to associate with the process.
+ Process output goes at end of that buffer, unless you specify
+ an output stream or filter function to handle the output.
+ BUFFER may be also nil, meaning that this process is not associated
+ with any buffer
+Third arg is name of the host to connect to, or its IP address.
+Fourth arg SERVICE is name of the service desired, or an integer
+specifying a port number to connect to.  */)
+     (name, buffer, host, service)
       Lisp_Object name, buffer, host, service;
 {
   Lisp_Object proc;
@@ -2236,16 +2236,16 @@ close_process_descs ()
 }
 
 DEFUN ("accept-process-output", Faccept_process_output, Saccept_process_output,
-  0, 3, 0,
-  "Allow any pending output from subprocesses to be read by Emacs.\n\
-It is read into the process' buffers or given to their filter functions.\n\
-Non-nil arg PROCESS means do not return until some output has been received\n\
-from PROCESS.\n\
-Non-nil second arg TIMEOUT and third arg TIMEOUT-MSECS are number of\n\
-seconds and microseconds to wait; return after that much time whether\n\
-or not there is input.\n\
-Return non-nil iff we received any output before the timeout expired.")
-  (process, timeout, timeout_msecs)
+       0, 3, 0,
+       doc: /* Allow any pending output from subprocesses to be read by Emacs.
+It is read into the process' buffers or given to their filter functions.
+Non-nil arg PROCESS means do not return until some output has been received
+from PROCESS.
+Non-nil second arg TIMEOUT and third arg TIMEOUT-MSECS are number of
+seconds and microseconds to wait; return after that much time whether
+or not there is input.
+Return non-nil iff we received any output before the timeout expired.  */)
+     (process, timeout, timeout_msecs)
      register Lisp_Object process, timeout, timeout_msecs;
 {
   int seconds;
@@ -3210,9 +3210,9 @@ read_process_output (proc, channel)
 
 DEFUN ("waiting-for-user-input-p", Fwaiting_for_user_input_p, Swaiting_for_user_input_p,
        0, 0, 0,
-  "Returns non-nil if emacs is waiting for input from the user.\n\
-This is intended for use by asynchronous process output filters and sentinels.")
-       ()
+       doc: /* Returns non-nil if emacs is waiting for input from the user.
+This is intended for use by asynchronous process output filters and sentinels.  */)
+     ()
 {
   return (waiting_for_user_input_p ? Qt : Qnil);
 }
@@ -3523,15 +3523,15 @@ send_process (proc, buf, len, object)
 }
 
 DEFUN ("process-send-region", Fprocess_send_region, Sprocess_send_region,
-  3, 3, 0,
-  "Send current contents of region as input to PROCESS.\n\
-PROCESS may be a process, a buffer, the name of a process or buffer, or\n\
-nil, indicating the current buffer's process.\n\
-Called from program, takes three arguments, PROCESS, START and END.\n\
-If the region is more than 500 characters long,\n\
-it is sent in several bunches.  This may happen even for shorter regions.\n\
-Output from processes can arrive in between bunches.")
-  (process, start, end)
+       3, 3, 0,
+       doc: /* Send current contents of region as input to PROCESS.
+PROCESS may be a process, a buffer, the name of a process or buffer, or
+nil, indicating the current buffer's process.
+Called from program, takes three arguments, PROCESS, START and END.
+If the region is more than 500 characters long,
+it is sent in several bunches.  This may happen even for shorter regions.
+Output from processes can arrive in between bunches.  */)
+     (process, start, end)
      Lisp_Object process, start, end;
 {
   Lisp_Object proc;
@@ -3552,14 +3552,14 @@ Output from processes can arrive in between bunches.")
 }
 
 DEFUN ("process-send-string", Fprocess_send_string, Sprocess_send_string,
-  2, 2, 0,
-  "Send PROCESS the contents of STRING as input.\n\
-PROCESS may be a process, a buffer, the name of a process or buffer, or\n\
-nil, indicating the current buffer's process.\n\
-If STRING is more than 500 characters long,\n\
-it is sent in several bunches.  This may happen even for shorter strings.\n\
-Output from processes can arrive in between bunches.")
-  (process, string)
+       2, 2, 0,
+       doc: /* Send PROCESS the contents of STRING as input.
+PROCESS may be a process, a buffer, the name of a process or buffer, or
+nil, indicating the current buffer's process.
+If STRING is more than 500 characters long,
+it is sent in several bunches.  This may happen even for shorter strings.
+Output from processes can arrive in between bunches.  */)
+     (process, string)
      Lisp_Object process, string;
 {
   Lisp_Object proc;
@@ -3572,10 +3572,10 @@ Output from processes can arrive in between bunches.")
 
 DEFUN ("process-running-child-p", Fprocess_running_child_p,
        Sprocess_running_child_p, 0, 1, 0,
-  "Return t if PROCESS has given the terminal to a child.\n\
-If the operating system does not make it possible to find out,\n\
-return t unconditionally.")
-  (process)
+       doc: /* Return t if PROCESS has given the terminal to a child.
+If the operating system does not make it possible to find out,
+return t unconditionally.  */)
+     (process)
      Lisp_Object process;
 {
   /* Initialize in case ioctl doesn't exist or gives an error,
@@ -3832,18 +3832,18 @@ process_send_signal (process, signo, current_group, nomsg)
 }
 
 DEFUN ("interrupt-process", Finterrupt_process, Sinterrupt_process, 0, 2, 0,
-  "Interrupt process PROCESS.\n\
-PROCESS may be a process, a buffer, or the name of a process or buffer.\n\
-nil or no arg means current buffer's process.\n\
-Second arg CURRENT-GROUP non-nil means send signal to\n\
-the current process-group of the process's controlling terminal\n\
-rather than to the process's own process group.\n\
-If the process is a shell, this means interrupt current subjob\n\
-rather than the shell.\n\
-\n\
-If CURRENT-GROUP is `lambda', and if the shell owns the terminal,\n\
-don't send the signal.")
-  (process, current_group)
+       doc: /* Interrupt process PROCESS.
+PROCESS may be a process, a buffer, or the name of a process or buffer.
+nil or no arg means current buffer's process.
+Second arg CURRENT-GROUP non-nil means send signal to
+the current process-group of the process's controlling terminal
+rather than to the process's own process group.
+If the process is a shell, this means interrupt current subjob
+rather than the shell.
+
+If CURRENT-GROUP is `lambda', and if the shell owns the terminal,
+don't send the signal.  */)
+     (process, current_group)
      Lisp_Object process, current_group;
 {
   process_send_signal (process, SIGINT, current_group, 0);
@@ -3851,9 +3851,9 @@ don't send the signal.")
 }
 
 DEFUN ("kill-process", Fkill_process, Skill_process, 0, 2, 0,
-  "Kill process PROCESS.  May be process or name of one.\n\
-See function `interrupt-process' for more details on usage.")
-  (process, current_group)
+       doc: /* Kill process PROCESS.  May be process or name of one.
+See function `interrupt-process' for more details on usage.  */)
+     (process, current_group)
      Lisp_Object process, current_group;
 {
   process_send_signal (process, SIGKILL, current_group, 0);
@@ -3861,9 +3861,9 @@ See function `interrupt-process' for more details on usage.")
 }
 
 DEFUN ("quit-process", Fquit_process, Squit_process, 0, 2, 0,
-  "Send QUIT signal to process PROCESS.  May be process or name of one.\n\
-See function `interrupt-process' for more details on usage.")
-  (process, current_group)
+       doc: /* Send QUIT signal to process PROCESS.  May be process or name of one.
+See function `interrupt-process' for more details on usage.  */)
+     (process, current_group)
      Lisp_Object process, current_group;
 {
   process_send_signal (process, SIGQUIT, current_group, 0);
@@ -3871,9 +3871,9 @@ See function `interrupt-process' for more details on usage.")
 }
 
 DEFUN ("stop-process", Fstop_process, Sstop_process, 0, 2, 0,
-  "Stop process PROCESS.  May be process or name of one.\n\
-See function `interrupt-process' for more details on usage.")
-  (process, current_group)
+       doc: /* Stop process PROCESS.  May be process or name of one.
+See function `interrupt-process' for more details on usage.  */)
+     (process, current_group)
      Lisp_Object process, current_group;
 {
 #ifndef SIGTSTP
@@ -3885,9 +3885,9 @@ See function `interrupt-process' for more details on usage.")
 }
 
 DEFUN ("continue-process", Fcontinue_process, Scontinue_process, 0, 2, 0,
-  "Continue process PROCESS.  May be process or name of one.\n\
-See function `interrupt-process' for more details on usage.")
-  (process, current_group)
+       doc: /* Continue process PROCESS.  May be process or name of one.
+See function `interrupt-process' for more details on usage.  */)
+     (process, current_group)
      Lisp_Object process, current_group;
 {
 #ifdef SIGCONT
@@ -3899,11 +3899,11 @@ See function `interrupt-process' for more details on usage.")
 }
 
 DEFUN ("signal-process", Fsignal_process, Ssignal_process,
-  2, 2, "nProcess number: \nnSignal code: ",
-  "Send the process with process id PID the signal with code SIGCODE.\n\
-PID must be an integer.  The process need not be a child of this Emacs.\n\
-SIGCODE may be an integer, or a symbol whose name is a signal name.")
-  (pid, sigcode)
+       2, 2, "nProcess number: \nnSignal code: ",
+       doc: /* Send the process with process id PID the signal with code SIGCODE.
+PID must be an integer.  The process need not be a child of this Emacs.
+SIGCODE may be an integer, or a symbol whose name is a signal name.  */)
+     (pid, sigcode)
      Lisp_Object pid, sigcode;
 {
   CHECK_NUMBER (pid, 0);
@@ -4023,14 +4023,14 @@ SIGCODE may be an integer, or a symbol whose name is a signal name.")
 }
 
 DEFUN ("process-send-eof", Fprocess_send_eof, Sprocess_send_eof, 0, 1, 0,
-  "Make PROCESS see end-of-file in its input.\n\
-EOF comes after any text already sent to it.\n\
-PROCESS may be a process, a buffer, the name of a process or buffer, or\n\
-nil, indicating the current buffer's process.\n\
-If PROCESS is a network connection, or is a process communicating\n\
-through a pipe (as opposed to a pty), then you cannot send any more\n\
-text to PROCESS after you call this function.")
-  (process)
+       doc: /* Make PROCESS see end-of-file in its input.
+EOF comes after any text already sent to it.
+PROCESS may be a process, a buffer, the name of a process or buffer, or
+nil, indicating the current buffer's process.
+If PROCESS is a network connection, or is a process communicating
+through a pipe (as opposed to a pty), then you cannot send any more
+text to PROCESS after you call this function.  */)
+     (process)
      Lisp_Object process;
 {
   Lisp_Object proc;
@@ -4510,10 +4510,10 @@ status_notify ()
 
 DEFUN ("set-process-coding-system", Fset_process_coding_system,
        Sset_process_coding_system, 1, 3, 0,
-  "Set coding systems of PROCESS to DECODING and ENCODING.\n\
-DECODING will be used to decode subprocess output and ENCODING to\n\
-encode subprocess input.")
-  (proc, decoding, encoding)
+       doc: /* Set coding systems of PROCESS to DECODING and ENCODING.
+DECODING will be used to decode subprocess output and ENCODING to
+encode subprocess input.  */)
+     (proc, decoding, encoding)
      register Lisp_Object proc, decoding, encoding;
 {
   register struct Lisp_Process *p;
@@ -4537,8 +4537,8 @@ encode subprocess input.")
 
 DEFUN ("process-coding-system",
        Fprocess_coding_system, Sprocess_coding_system, 1, 1, 0,
-  "Return a cons of coding systems for decoding and encoding of PROCESS.")
-  (proc)
+       doc: /* Return a cons of coding systems for decoding and encoding of PROCESS.  */)
+     (proc)
      register Lisp_Object proc;
 {
   CHECK_PROCESS (proc, 0);
@@ -4660,17 +4660,17 @@ syms_of_process ()
   staticpro (&Vprocess_alist);
 
   DEFVAR_BOOL ("delete-exited-processes", &delete_exited_processes,
-    "*Non-nil means delete processes immediately when they exit.\n\
-nil means don't delete them until `list-processes' is run.");
+               doc: /* *Non-nil means delete processes immediately when they exit.
+nil means don't delete them until `list-processes' is run.  */);
 
   delete_exited_processes = 1;
 
   DEFVAR_LISP ("process-connection-type", &Vprocess_connection_type,
-    "Control type of device used to communicate with subprocesses.\n\
-Values are nil to use a pipe, or t or `pty' to use a pty.\n\
-The value has no effect if the system has no ptys or if all ptys are busy:\n\
-then a pipe is used in any case.\n\
-The value takes effect when `start-process' is called.");
+               doc: /* Control type of device used to communicate with subprocesses.
+Values are nil to use a pipe, or t or `pty' to use a pty.
+The value has no effect if the system has no ptys or if all ptys are busy:
+then a pipe is used in any case.
+The value takes effect when `start-process' is called.  */);
   Vprocess_connection_type = Qt;
 
   defsubr (&Sprocessp);
@@ -4972,8 +4972,8 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
 /* Don't confuse make-docfile by having two doc strings for this function.
    make-docfile does not pay attention to #if, for good reason!  */
 DEFUN ("get-buffer-process", Fget_buffer_process, Sget_buffer_process, 1, 1, 0,
-  0)
-  (name)
+       0)
+     (name)
      register Lisp_Object name;
 {
   return Qnil;
@@ -4982,10 +4982,10 @@ DEFUN ("get-buffer-process", Fget_buffer_process, Sget_buffer_process, 1, 1, 0,
   /* Don't confuse make-docfile by having two doc strings for this function.
      make-docfile does not pay attention to #if, for good reason!  */
 DEFUN ("process-inherit-coding-system-flag",
-  Fprocess_inherit_coding_system_flag, Sprocess_inherit_coding_system_flag,
-  1, 1, 0,
-  0)
-  (process)
+       Fprocess_inherit_coding_system_flag, Sprocess_inherit_coding_system_flag,
+       1, 1, 0,
+       0)
+     (process)
      register Lisp_Object process;
 {
   /* Ignore the argument and return the value of
diff --git a/src/syntax.c b/src/syntax.c
index 6a17e659979..72df6697602 100644
--- a/src/syntax.c
+++ b/src/syntax.c
@@ -714,9 +714,9 @@ back_comment (from, from_byte, stop, comnested, comstyle, charpos_ptr, bytepos_p
 }
 
 DEFUN ("syntax-table-p", Fsyntax_table_p, Ssyntax_table_p, 1, 1, 0,
-  "Return t if OBJECT is a syntax table.\n\
-Currently, any char-table counts as a syntax table.")
-  (object)
+       doc: /* Return t if OBJECT is a syntax table.
+Currently, any char-table counts as a syntax table.  */)
+     (object)
      Lisp_Object object;
 {
   if (CHAR_TABLE_P (object)
@@ -735,26 +735,26 @@ check_syntax_table (obj)
 }   
 
 DEFUN ("syntax-table", Fsyntax_table, Ssyntax_table, 0, 0, 0,
-  "Return the current syntax table.\n\
-This is the one specified by the current buffer.")
-  ()
+       doc: /* Return the current syntax table.
+This is the one specified by the current buffer.  */)
+     ()
 {
   return current_buffer->syntax_table;
 }
 
 DEFUN ("standard-syntax-table", Fstandard_syntax_table,
    Sstandard_syntax_table, 0, 0, 0,
-  "Return the standard syntax table.\n\
-This is the one used for new buffers.")
-  ()
+       doc: /* Return the standard syntax table.
+This is the one used for new buffers.  */)
+     ()
 {
   return Vstandard_syntax_table;
 }
 
 DEFUN ("copy-syntax-table", Fcopy_syntax_table, Scopy_syntax_table, 0, 1, 0,
-  "Construct a new syntax table and return it.\n\
-It is a copy of the TABLE, which defaults to the standard syntax table.")
-  (table)
+       doc: /* Construct a new syntax table and return it.
+It is a copy of the TABLE, which defaults to the standard syntax table.  */)
+     (table)
      Lisp_Object table;
 {
   Lisp_Object copy;
@@ -779,9 +779,9 @@ It is a copy of the TABLE, which defaults to the standard syntax table.")
 }
 
 DEFUN ("set-syntax-table", Fset_syntax_table, Sset_syntax_table, 1, 1, 0,
-  "Select a new syntax table for the current buffer.\n\
-One argument, a syntax table.")
-  (table)
+       doc: /* Select a new syntax table for the current buffer.
+One argument, a syntax table.  */)
+     (table)
      Lisp_Object table;
 {
   int idx;
@@ -859,12 +859,12 @@ syntax_parent_lookup (table, character)
 }
 
 DEFUN ("char-syntax", Fchar_syntax, Schar_syntax, 1, 1, 0,
-  "Return the syntax code of CHARACTER, described by a character.\n\
-For example, if CHARACTER is a word constituent,\n\
-the character `w' is returned.\n\
-The characters that correspond to various syntax codes\n\
-are listed in the documentation of `modify-syntax-entry'.")
-  (character)
+       doc: /* Return the syntax code of CHARACTER, described by a character.
+For example, if CHARACTER is a word constituent,
+the character `w' is returned.
+The characters that correspond to various syntax codes
+are listed in the documentation of `modify-syntax-entry'.  */)
+     (character)
      Lisp_Object character;
 {
   int char_int;
@@ -877,8 +877,8 @@ are listed in the documentation of `modify-syntax-entry'.")
 }
 
 DEFUN ("matching-paren", Fmatching_paren, Smatching_paren, 1, 1, 0,
-  "Return the matching parenthesis of CHARACTER, or nil if none.")
-  (character)
+       doc: /* Return the matching parenthesis of CHARACTER, or nil if none.  */)
+     (character)
      Lisp_Object character;
 {
   int char_int, code;
@@ -893,12 +893,12 @@ DEFUN ("matching-paren", Fmatching_paren, Smatching_paren, 1, 1, 0,
 }
 
 DEFUN ("string-to-syntax", Fstring_to_syntax, Sstring_to_syntax, 1, 1, 0,
-  "Convert a syntax specification STRING into syntax cell form.\n\
-STRING should be a string as it is allowed as argument of\n\
-`modify-syntax-entry'.  Value is the equivalent cons cell\n\
-\(CODE . MATCHING-CHAR) that can be used as value of a `syntax-table'\n\
-text property.")
-  (string)
+       doc: /* Convert a syntax specification STRING into syntax cell form.
+STRING should be a string as it is allowed as argument of
+`modify-syntax-entry'.  Value is the equivalent cons cell
+(CODE . MATCHING-CHAR) that can be used as value of a `syntax-table'
+text property.  */)
+     (string)
      Lisp_Object string;
 {
   register unsigned char *p;
@@ -969,56 +969,47 @@ text property.")
     return Fcons (make_number (val), match);
 }
 
-/* This comment supplies the doc string for modify-syntax-entry,
-   for make-docfile to see.  We cannot put this in the real DEFUN
-   due to limits in the Unix cpp.
-
-DEFUN ("modify-syntax-entry", foo, bar, 2, 3, 0,
-  "Set syntax for character CHAR according to string S.\n\
-The syntax is changed only for table TABLE, which defaults to\n\
- the current buffer's syntax table.\n\
-The first character of S should be one of the following:\n\
-  Space or -  whitespace syntax.    w   word constituent.\n\
-  _           symbol constituent.   .   punctuation.\n\
-  (           open-parenthesis.     )   close-parenthesis.\n\
-  \"           string quote.         \\   escape.\n\
-  $           paired delimiter.     '   expression quote or prefix operator.\n\
-  <           comment starter.      >   comment ender.\n\
-  /           character-quote.      @   inherit from `standard-syntax-table'.\n\
-  |           generic string fence. !   generic comment fence.\n\
-\n\
-Only single-character comment start and end sequences are represented thus.\n\
-Two-character sequences are represented as described below.\n\
-The second character of S is the matching parenthesis,\n\
- used only if the first character is `(' or `)'.\n\
-Any additional characters are flags.\n\
-Defined flags are the characters 1, 2, 3, 4, b, p, and n.\n\
- 1 means CHAR is the start of a two-char comment start sequence.\n\
- 2 means CHAR is the second character of such a sequence.\n\
- 3 means CHAR is the start of a two-char comment end sequence.\n\
- 4 means CHAR is the second character of such a sequence.\n\
-\n\
-There can be up to two orthogonal comment sequences.  This is to support\n\
-language modes such as C++.  By default, all comment sequences are of style\n\
-a, but you can set the comment sequence style to b (on the second character\n\
-of a comment-start, or the first character of a comment-end sequence) using\n\
-this flag:\n\
- b means CHAR is part of comment sequence b.\n\
- n means CHAR is part of a nestable comment sequence.\n\
-\n\
- p means CHAR is a prefix character for `backward-prefix-chars';\n\
-   such characters are treated as whitespace when they occur\n\
-   between expressions.")
-  (char, s, table)
+/* I really don't know why this is interactive
+   help-form should at least be made useful whilst reading the second arg
 */
-
 DEFUN ("modify-syntax-entry", Fmodify_syntax_entry, Smodify_syntax_entry, 2, 3, 
-  /* I really don't know why this is interactive
-     help-form should at least be made useful whilst reading the second arg
-   */
   "cSet syntax for character: \nsSet syntax for %s to: ",
-  0 /* See immediately above */)
-  (c, newentry, syntax_table)
+       doc: /* Set syntax for character C according to string NEWENTRY.
+The syntax is changed only for table SYNTAX_TABLE, which defaults to
+ the current buffer's syntax table.
+The first character of NEWENTRY should be one of the following:
+  Space or -  whitespace syntax.    w   word constituent.
+  _           symbol constituent.   .   punctuation.
+  (           open-parenthesis.     )   close-parenthesis.
+  "           string quote.         \\   escape.
+  $           paired delimiter.     '   expression quote or prefix operator.
+  <           comment starter.      >   comment ender.
+  /           character-quote.      @   inherit from `standard-syntax-table'.
+  |           generic string fence. !   generic comment fence.
+
+Only single-character comment start and end sequences are represented thus.
+Two-character sequences are represented as described below.
+The second character of NEWENTRY is the matching parenthesis,
+ used only if the first character is `(' or `)'.
+Any additional characters are flags.
+Defined flags are the characters 1, 2, 3, 4, b, p, and n.
+ 1 means C is the start of a two-char comment start sequence.
+ 2 means C is the second character of such a sequence.
+ 3 means C is the start of a two-char comment end sequence.
+ 4 means C is the second character of such a sequence.
+
+There can be up to two orthogonal comment sequences.  This is to support
+language modes such as C++.  By default, all comment sequences are of style
+a, but you can set the comment sequence style to b (on the second character
+of a comment-start, or the first character of a comment-end sequence) using
+this flag:
+ b means C is part of comment sequence b.
+ n means C is part of a nestable comment sequence.
+
+ p means C is a prefix character for `backward-prefix-chars';
+   such characters are treated as whitespace when they occur
+   between expressions.  */)
+     (c, newentry, syntax_table)
      Lisp_Object c, newentry, syntax_table;
 {
   CHECK_NUMBER (c, 0);
@@ -1201,9 +1192,9 @@ describe_syntax_1 (vector)
 }
 
 DEFUN ("describe-syntax", Fdescribe_syntax, Sdescribe_syntax, 0, 0, "",
-  "Describe the syntax specifications in the syntax table.\n\
-The descriptions are inserted in a buffer, which is then displayed.")
-  ()
+       doc: /* Describe the syntax specifications in the syntax table.
+The descriptions are inserted in a buffer, which is then displayed.  */)
+     ()
 {
   internal_with_output_to_temp_buffer
      ("*Help*", describe_syntax_1, current_buffer->syntax_table);
@@ -1315,12 +1306,12 @@ scan_words (from, count)
 }
 
 DEFUN ("forward-word", Fforward_word, Sforward_word, 1, 1, "p",
-  "Move point forward ARG words (backward if ARG is negative).\n\
-Normally returns t.\n\
-If an edge of the buffer or a field boundary is reached, point is left there\n\
-and the function returns nil.  Field boundaries are not noticed if\n\
-`inhibit-field-text-motion' is non-nil.")
-  (count)
+       doc: /* Move point forward ARG words (backward if ARG is negative).
+Normally returns t.
+If an edge of the buffer or a field boundary is reached, point is left there
+and the function returns nil.  Field boundaries are not noticed if
+`inhibit-field-text-motion' is non-nil.  */)
+     (count)
      Lisp_Object count;
 {
   int orig_val, val;
@@ -1341,48 +1332,48 @@ and the function returns nil.  Field boundaries are not noticed if\n\
 Lisp_Object skip_chars ();
 
 DEFUN ("skip-chars-forward", Fskip_chars_forward, Sskip_chars_forward, 1, 2, 0,
-  "Move point forward, stopping before a char not in STRING, or at pos LIM.\n\
-STRING is like the inside of a `[...]' in a regular expression\n\
-except that `]' is never special and `\\' quotes `^', `-' or `\\'\n\
- (but not as the end of a range; quoting is never needed there).\n\
-Thus, with arg \"a-zA-Z\", this skips letters stopping before first nonletter.\n\
-With arg \"^a-zA-Z\", skips nonletters stopping before first letter.\n\
-Returns the distance traveled, either zero or positive.")
-  (string, lim)
+       doc: /* Move point forward, stopping before a char not in STRING, or at pos LIM.
+STRING is like the inside of a `[...]' in a regular expression
+except that `]' is never special and `\\' quotes `^', `-' or `\\'
+ (but not as the end of a range; quoting is never needed there).
+Thus, with arg "a-zA-Z", this skips letters stopping before first nonletter.
+With arg "^a-zA-Z", skips nonletters stopping before first letter.
+Returns the distance traveled, either zero or positive.  */)
+     (string, lim)
      Lisp_Object string, lim;
 {
   return skip_chars (1, 0, string, lim);
 }
 
 DEFUN ("skip-chars-backward", Fskip_chars_backward, Sskip_chars_backward, 1, 2, 0,
-  "Move point backward, stopping after a char not in STRING, or at pos LIM.\n\
-See `skip-chars-forward' for details.\n\
-Returns the distance traveled, either zero or negative.")
-  (string, lim)
+       doc: /* Move point backward, stopping after a char not in STRING, or at pos LIM.
+See `skip-chars-forward' for details.
+Returns the distance traveled, either zero or negative.  */)
+     (string, lim)
      Lisp_Object string, lim;
 {
   return skip_chars (0, 0, string, lim);
 }
 
 DEFUN ("skip-syntax-forward", Fskip_syntax_forward, Sskip_syntax_forward, 1, 2, 0,
-  "Move point forward across chars in specified syntax classes.\n\
-SYNTAX is a string of syntax code characters.\n\
-Stop before a char whose syntax is not in SYNTAX, or at position LIM.\n\
-If SYNTAX starts with ^, skip characters whose syntax is NOT in SYNTAX.\n\
-This function returns the distance traveled, either zero or positive.")
-  (syntax, lim)
+       doc: /* Move point forward across chars in specified syntax classes.
+SYNTAX is a string of syntax code characters.
+Stop before a char whose syntax is not in SYNTAX, or at position LIM.
+If SYNTAX starts with ^, skip characters whose syntax is NOT in SYNTAX.
+This function returns the distance traveled, either zero or positive.  */)
+     (syntax, lim)
      Lisp_Object syntax, lim;
 {
   return skip_chars (1, 1, syntax, lim);
 }
 
 DEFUN ("skip-syntax-backward", Fskip_syntax_backward, Sskip_syntax_backward, 1, 2, 0,
-  "Move point backward across chars in specified syntax classes.\n\
-SYNTAX is a string of syntax code characters.\n\
-Stop on reaching a char whose syntax is not in SYNTAX, or at position LIM.\n\
-If SYNTAX starts with ^, skip characters whose syntax is NOT in SYNTAX.\n\
-This function returns the distance traveled, either zero or negative.")
-  (syntax, lim)
+       doc: /* Move point backward across chars in specified syntax classes.
+SYNTAX is a string of syntax code characters.
+Stop on reaching a char whose syntax is not in SYNTAX, or at position LIM.
+If SYNTAX starts with ^, skip characters whose syntax is NOT in SYNTAX.
+This function returns the distance traveled, either zero or negative.  */)
+     (syntax, lim)
      Lisp_Object syntax, lim;
 {
   return skip_chars (0, 1, syntax, lim);
@@ -1811,12 +1802,12 @@ forw_comment (from, from_byte, stop, nesting, style, prev_syntax,
 }
 
 DEFUN ("forward-comment", Fforward_comment, Sforward_comment, 1, 1, 0,
-  "Move forward across up to N comments.  If N is negative, move backward.\n\
-Stop scanning if we find something other than a comment or whitespace.\n\
-Set point to where scanning stops.\n\
-If N comments are found as expected, with nothing except whitespace\n\
-between them, return t; otherwise return nil.")
-  (count)
+       doc: /* Move forward across up to N comments.  If N is negative, move backward.
+Stop scanning if we find something other than a comment or whitespace.
+Set point to where scanning stops.
+If N comments are found as expected, with nothing except whitespace
+between them, return t; otherwise return nil.  */)
+     (count)
      Lisp_Object count;
 {
   register int from;
@@ -2399,20 +2390,20 @@ scan_lists (from, count, depth, sexpflag)
 }
 
 DEFUN ("scan-lists", Fscan_lists, Sscan_lists, 3, 3, 0,
-  "Scan from character number FROM by COUNT lists.\n\
-Returns the character number of the position thus found.\n\
-\n\
-If DEPTH is nonzero, paren depth begins counting from that value,\n\
-only places where the depth in parentheses becomes zero\n\
-are candidates for stopping; COUNT such places are counted.\n\
-Thus, a positive value for DEPTH means go out levels.\n\
-\n\
-Comments are ignored if `parse-sexp-ignore-comments' is non-nil.\n\
-\n\
-If the beginning or end of (the accessible part of) the buffer is reached\n\
-and the depth is wrong, an error is signaled.\n\
-If the depth is right but the count is not used up, nil is returned.")
-  (from, count, depth)
+       doc: /* Scan from character number FROM by COUNT lists.
+Returns the character number of the position thus found.
+
+If DEPTH is nonzero, paren depth begins counting from that value,
+only places where the depth in parentheses becomes zero
+are candidates for stopping; COUNT such places are counted.
+Thus, a positive value for DEPTH means go out levels.
+
+Comments are ignored if `parse-sexp-ignore-comments' is non-nil.
+
+If the beginning or end of (the accessible part of) the buffer is reached
+and the depth is wrong, an error is signaled.
+If the depth is right but the count is not used up, nil is returned.  */)
+     (from, count, depth)
      Lisp_Object from, count, depth;
 {
   CHECK_NUMBER (from, 0);
@@ -2423,17 +2414,17 @@ If the depth is right but the count is not used up, nil is returned.")
 }
 
 DEFUN ("scan-sexps", Fscan_sexps, Sscan_sexps, 2, 2, 0,
-  "Scan from character number FROM by COUNT balanced expressions.\n\
-If COUNT is negative, scan backwards.\n\
-Returns the character number of the position thus found.\n\
-\n\
-Comments are ignored if `parse-sexp-ignore-comments' is non-nil.\n\
-\n\
-If the beginning or end of (the accessible part of) the buffer is reached\n\
-in the middle of a parenthetical grouping, an error is signaled.\n\
-If the beginning or end is reached between groupings\n\
-but before count is used up, nil is returned.")
-  (from, count)
+       doc: /* Scan from character number FROM by COUNT balanced expressions.
+If COUNT is negative, scan backwards.
+Returns the character number of the position thus found.
+
+Comments are ignored if `parse-sexp-ignore-comments' is non-nil.
+
+If the beginning or end of (the accessible part of) the buffer is reached
+in the middle of a parenthetical grouping, an error is signaled.
+If the beginning or end is reached between groupings
+but before count is used up, nil is returned.  */)
+     (from, count)
      Lisp_Object from, count;
 {
   CHECK_NUMBER (from, 0);
@@ -2443,10 +2434,10 @@ but before count is used up, nil is returned.")
 }
 
 DEFUN ("backward-prefix-chars", Fbackward_prefix_chars, Sbackward_prefix_chars,
-  0, 0, 0,
-  "Move point backward over any number of chars with prefix syntax.\n\
-This includes chars with \"quote\" or \"prefix\" syntax (' or p).")
-  ()
+       0, 0, 0,
+       doc: /* Move point backward over any number of chars with prefix syntax.
+This includes chars with "quote" or "prefix" syntax (' or p).  */)
+     ()
 {
   int beg = BEGV;
   int opoint = PT;
@@ -2836,47 +2827,38 @@ do { prev_from = from;				\
   *stateptr = state;
 }
 
-/* This comment supplies the doc string for parse-partial-sexp,
-   for make-docfile to see.  We cannot put this in the real DEFUN
-   due to limits in the Unix cpp.
-
-DEFUN ("parse-partial-sexp", Ffoo, Sfoo, 2, 6, 0,
-  "Parse Lisp syntax starting at FROM until TO; return status of parse at TO.\n\
-Parsing stops at TO or when certain criteria are met;\n\
- point is set to where parsing stops.\n\
-If fifth arg STATE is omitted or nil,\n\
- parsing assumes that FROM is the beginning of a function.\n\
-Value is a list of ten elements describing final state of parsing:\n\
- 0. depth in parens.\n\
- 1. character address of start of innermost containing list; nil if none.\n\
- 2. character address of start of last complete sexp terminated.\n\
- 3. non-nil if inside a string.\n\
-    (it is the character that will terminate the string,\n\
-     or t if the string should be terminated by a generic string delimiter.)\n\
- 4. nil if outside a comment, t if inside a non-nestable comment, \n\
-    else an integer (the current comment nesting).\n\
- 5. t if following a quote character.\n\
- 6. the minimum paren-depth encountered during this scan.\n\
- 7. t if in a comment of style b; symbol `syntax-table' if the comment\n\
-    should be terminated by a generic comment delimiter.\n\
- 8. character address of start of comment or string; nil if not in one.\n\
- 9. Intermediate data for continuation of parsing (subject to change).\n\
-If third arg TARGETDEPTH is non-nil, parsing stops if the depth\n\
-in parentheses becomes equal to TARGETDEPTH.\n\
-Fourth arg STOPBEFORE non-nil means stop when come to\n\
- any character that starts a sexp.\n\
-Fifth arg STATE is a nine-element list like what this function returns.\n\
- It is used to initialize the state of the parse.  Elements number 1, 2, 6\n\
- and 8 are ignored; you can leave off element 8 (the last) entirely.\n\
-Sixth arg COMMENTSTOP non-nil means stop at the start of a comment.\n\
- If it is symbol `syntax-table', stop after the start of a comment or a\n\
- string, or after end of a comment or a string.")
-  (from, to, targetdepth, stopbefore, state, commentstop)
-*/
-
 DEFUN ("parse-partial-sexp", Fparse_partial_sexp, Sparse_partial_sexp, 2, 6, 0,
-  0 /* See immediately above */)
-  (from, to, targetdepth, stopbefore, oldstate, commentstop)
+       doc: /* Parse Lisp syntax starting at FROM until TO; return status of parse at TO.
+Parsing stops at TO or when certain criteria are met;
+ point is set to where parsing stops.
+If fifth arg OLDSTATE is omitted or nil,
+ parsing assumes that FROM is the beginning of a function.
+Value is a list of ten elements describing final state of parsing:
+ 0. depth in parens.
+ 1. character address of start of innermost containing list; nil if none.
+ 2. character address of start of last complete sexp terminated.
+ 3. non-nil if inside a string.
+    (it is the character that will terminate the string,
+     or t if the string should be terminated by a generic string delimiter.)
+ 4. nil if outside a comment, t if inside a non-nestable comment, 
+    else an integer (the current comment nesting).
+ 5. t if following a quote character.
+ 6. the minimum paren-depth encountered during this scan.
+ 7. t if in a comment of style b; symbol `syntax-table' if the comment
+    should be terminated by a generic comment delimiter.
+ 8. character address of start of comment or string; nil if not in one.
+ 9. Intermediate data for continuation of parsing (subject to change).
+If third arg TARGETDEPTH is non-nil, parsing stops if the depth
+in parentheses becomes equal to TARGETDEPTH.
+Fourth arg STOPBEFORE non-nil means stop when come to
+ any character that starts a sexp.
+Fifth arg OLDSTATE is a nine-element list like what this function returns.
+ It is used to initialize the state of the parse.  Elements number 1, 2, 6
+ and 8 are ignored; you can leave off element 8 (the last) entirely.
+Sixth arg COMMENTSTOP non-nil means stop at the start of a comment.
+ If it is symbol `syntax-table', stop after the start of a comment or a
+ string, or after end of a comment or a string.  */)
+     (from, to, targetdepth, stopbefore, oldstate, commentstop)
      Lisp_Object from, to, targetdepth, stopbefore, oldstate, commentstop;
 {
   struct lisp_parse_state state;
@@ -3014,25 +2996,25 @@ syms_of_syntax ()
         build_string ("Scan error"));
 
   DEFVAR_BOOL ("parse-sexp-ignore-comments", &parse_sexp_ignore_comments,
-    "Non-nil means `forward-sexp', etc., should treat comments as whitespace.");
+               doc: /* Non-nil means `forward-sexp', etc., should treat comments as whitespace.  */);
 
   DEFVAR_BOOL ("parse-sexp-lookup-properties", &parse_sexp_lookup_properties,
-    "Non-nil means `forward-sexp', etc., obey `syntax-table' property.\n\
-Otherwise, that text property is simply ignored.\n\
-See the info node `(elisp)Syntax Properties' for a description of the\n\
-`syntax-table' property.");
+               doc: /* Non-nil means `forward-sexp', etc., obey `syntax-table' property.
+Otherwise, that text property is simply ignored.
+See the info node `(elisp)Syntax Properties' for a description of the
+`syntax-table' property.  */);
 
   words_include_escapes = 0;
   DEFVAR_BOOL ("words-include-escapes", &words_include_escapes,
-    "Non-nil means `forward-word', etc., should treat escape chars part of words.");
+               doc: /* Non-nil means `forward-word', etc., should treat escape chars part of words.  */);
 
   DEFVAR_BOOL ("multibyte-syntax-as-symbol", &multibyte_syntax_as_symbol,
-    "Non-nil means `scan-sexps' treats all multibyte characters as symbol.");
+               doc: /* Non-nil means `scan-sexps' treats all multibyte characters as symbol.  */);
   multibyte_syntax_as_symbol = 0;
 
   DEFVAR_BOOL ("open-paren-in-column-0-is-defun-start",
                &open_paren_in_column_0_is_defun_start,
-    "Non-nil means an open paren in column 0 denotes the start of a defun.");
+               doc: /* Non-nil means an open paren in column 0 denotes the start of a defun.  */);
   open_paren_in_column_0_is_defun_start = 1;
 
   defsubr (&Ssyntax_table_p);
diff --git a/src/window.c b/src/window.c
index 4c629113d9d..c8a348bf626 100644
--- a/src/window.c
+++ b/src/window.c
@@ -227,15 +227,15 @@ extern int scroll_margin;
 extern Lisp_Object Qwindow_scroll_functions, Vwindow_scroll_functions;
 
 DEFUN ("windowp", Fwindowp, Swindowp, 1, 1, 0,
-  "Returns t if OBJECT is a window.")
-  (object)
+       doc: /* Returns t if OBJECT is a window.  */)
+     (object)
      Lisp_Object object;
 {
   return WINDOWP (object) ? Qt : Qnil;
 }
 
 DEFUN ("window-live-p", Fwindow_live_p, Swindow_live_p, 1, 1, 0,
-  "Returns t if OBJECT is a window which is currently visible.")
+       doc: /* Returns t if OBJECT is a window which is currently visible.  */)
      (object)
      Lisp_Object object;
 {
@@ -283,17 +283,17 @@ make_window ()
 }
 
 DEFUN ("selected-window", Fselected_window, Sselected_window, 0, 0, 0,
-  "Return the window that the cursor now appears in and commands apply to.")
-  ()
+       doc: /* Return the window that the cursor now appears in and commands apply to.  */)
+     ()
 {
   return selected_window;
 }
 
 DEFUN ("minibuffer-window", Fminibuffer_window, Sminibuffer_window, 0, 1, 0,
-  "Return the window used now for minibuffers.\n\
-If the optional argument FRAME is specified, return the minibuffer window\n\
-used by that frame.")
-  (frame)
+       doc: /* Return the window used now for minibuffers.
+If the optional argument FRAME is specified, return the minibuffer window
+used by that frame.  */)
+     (frame)
     Lisp_Object frame;
 {
   if (NILP (frame))
@@ -303,8 +303,8 @@ used by that frame.")
 }
 
 DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p, Swindow_minibuffer_p, 0, 1, 0,
-  "Returns non-nil if WINDOW is a minibuffer window.")
-  (window)
+       doc: /* Returns non-nil if WINDOW is a minibuffer window.  */)
+     (window)
      Lisp_Object window;
 {
   struct window *w = decode_window (window);
@@ -313,13 +313,13 @@ DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p, Swindow_minibuffer_p, 0, 1,
 
 
 DEFUN ("pos-visible-in-window-p", Fpos_visible_in_window_p,
-  Spos_visible_in_window_p, 0, 3, 0,
-  "Return t if position POS is currently on the frame in WINDOW.\n\
-Return nil if that position is scrolled vertically out of view.\n\
-If a character is only partially visible, nil is returned, unless the\n\
-optional argument PARTIALLY is non-nil.\n\
-POS defaults to point in WINDOW; WINDOW defaults to the selected window.")
-  (pos, window, partially)
+       Spos_visible_in_window_p, 0, 3, 0,
+       doc: /* Return t if position POS is currently on the frame in WINDOW.
+Return nil if that position is scrolled vertically out of view.
+If a character is only partially visible, nil is returned, unless the
+optional argument PARTIALLY is non-nil.
+POS defaults to point in WINDOW; WINDOW defaults to the selected window.  */)
+     (pos, window, partially)
      Lisp_Object pos, window, partially;
 {
   register struct window *w;
@@ -391,44 +391,44 @@ decode_window (window)
 }
 
 DEFUN ("window-buffer", Fwindow_buffer, Swindow_buffer, 0, 1, 0,
-  "Return the buffer that WINDOW is displaying.")
-  (window)
+       doc: /* Return the buffer that WINDOW is displaying.  */)
+     (window)
      Lisp_Object window;
 {
   return decode_window (window)->buffer;
 }
 
 DEFUN ("window-height", Fwindow_height, Swindow_height, 0, 1, 0,
-  "Return the number of lines in WINDOW (including its mode line).")
-  (window)
+       doc: /* Return the number of lines in WINDOW (including its mode line).  */)
+     (window)
      Lisp_Object window;
 {
   return decode_window (window)->height;
 }
 
 DEFUN ("window-width", Fwindow_width, Swindow_width, 0, 1, 0,
-  "Return the number of display columns in WINDOW.\n\
-This is the width that is usable columns available for text in WINDOW.\n\
-If you want to find out how many columns WINDOW takes up,\n\
-use  (let ((edges (window-edges))) (- (nth 2 edges) (nth 0 edges))).")
-  (window)
+       doc: /* Return the number of display columns in WINDOW.
+This is the width that is usable columns available for text in WINDOW.
+If you want to find out how many columns WINDOW takes up,
+use  (let ((edges (window-edges))) (- (nth 2 edges) (nth 0 edges))).  */)
+     (window)
      Lisp_Object window;
 {
   return make_number (window_internal_width (decode_window (window)));
 }
 
 DEFUN ("window-hscroll", Fwindow_hscroll, Swindow_hscroll, 0, 1, 0,
-  "Return the number of columns by which WINDOW is scrolled from left margin.")
-  (window)
+       doc: /* Return the number of columns by which WINDOW is scrolled from left margin.  */)
+     (window)
      Lisp_Object window;
 {
   return decode_window (window)->hscroll;
 }
 
 DEFUN ("set-window-hscroll", Fset_window_hscroll, Sset_window_hscroll, 2, 2, 0,
-  "Set number of columns WINDOW is scrolled from left margin to NCOL.\n\
-NCOL should be zero or positive.")
-  (window, ncol)
+       doc: /* Set number of columns WINDOW is scrolled from left margin to NCOL.
+NCOL should be zero or positive.  */)
+     (window, ncol)
      Lisp_Object window, ncol;
 {
   struct window *w = decode_window (window);
@@ -447,9 +447,9 @@ NCOL should be zero or positive.")
 
 DEFUN ("window-redisplay-end-trigger", Fwindow_redisplay_end_trigger,
        Swindow_redisplay_end_trigger, 0, 1, 0,
-  "Return WINDOW's redisplay end trigger value.\n\
-See `set-window-redisplay-end-trigger' for more information.")
-  (window)
+       doc: /* Return WINDOW's redisplay end trigger value.
+See `set-window-redisplay-end-trigger' for more information.  */)
+     (window)
      Lisp_Object window;
 {
   return decode_window (window)->redisplay_end_trigger;
@@ -457,13 +457,13 @@ See `set-window-redisplay-end-trigger' for more information.")
 
 DEFUN ("set-window-redisplay-end-trigger", Fset_window_redisplay_end_trigger,
        Sset_window_redisplay_end_trigger, 2, 2, 0,
-  "Set WINDOW's redisplay end trigger value to VALUE.\n\
-VALUE should be a buffer position (typically a marker) or nil.\n\
-If it is a buffer position, then if redisplay in WINDOW reaches a position\n\
-beyond VALUE, the functions in `redisplay-end-trigger-functions' are called\n\
-with two arguments: WINDOW, and the end trigger value.\n\
-Afterwards the end-trigger value is reset to nil.")
-  (window, value)
+       doc: /* Set WINDOW's redisplay end trigger value to VALUE.
+VALUE should be a buffer position (typically a marker) or nil.
+If it is a buffer position, then if redisplay in WINDOW reaches a position
+beyond VALUE, the functions in `redisplay-end-trigger-functions' are called
+with two arguments: WINDOW, and the end trigger value.
+Afterwards the end-trigger value is reset to nil.  */)
+     (window, value)
      register Lisp_Object window, value;
 {
   register struct window *w;
@@ -474,12 +474,12 @@ Afterwards the end-trigger value is reset to nil.")
 }
 
 DEFUN ("window-edges", Fwindow_edges, Swindow_edges, 0, 1, 0,
-  "Return a list of the edge coordinates of WINDOW.\n\
-\(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.\n\
-RIGHT is one more than the rightmost column used by WINDOW,\n\
-and BOTTOM is one more than the bottommost row used by WINDOW\n\
- and its mode-line.")
-  (window)
+       doc: /* Return a list of the edge coordinates of WINDOW.
+\(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
+RIGHT is one more than the rightmost column used by WINDOW,
+and BOTTOM is one more than the bottommost row used by WINDOW
+ and its mode-line.  */)
+     (window)
      Lisp_Object window;
 {
   register struct window *w = decode_window (window);
@@ -659,22 +659,22 @@ coordinates_in_window (w, x, y)
 
 
 DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p,
-  Scoordinates_in_window_p, 2, 2, 0,
-  "Return non-nil if COORDINATES are in WINDOW.\n\
-COORDINATES is a cons of the form (X . Y), X and Y being distances\n\
-measured in characters from the upper-left corner of the frame.\n\
-\(0 .  0) denotes the character in the upper left corner of the\n\
-frame.\n\
-If COORDINATES are in the text portion of WINDOW,\n\
-   the coordinates relative to the window are returned.\n\
-If they are in the mode line of WINDOW, `mode-line' is returned.\n\
-If they are in the top mode line of WINDOW, `header-line' is returned.\n\
-If they are in the fringe to the left of the window,\n\
-   `left-fringe' is returned, if they are in the area on the right of\n\
-   the window, `right-fringe' is returned.\n\
-If they are on the border between WINDOW and its right sibling,\n\
-   `vertical-line' is returned.")
-  (coordinates, window)
+       Scoordinates_in_window_p, 2, 2, 0,
+       doc: /* Return non-nil if COORDINATES are in WINDOW.
+COORDINATES is a cons of the form (X . Y), X and Y being distances
+measured in characters from the upper-left corner of the frame.
+\(0 .  0) denotes the character in the upper left corner of the
+frame.
+If COORDINATES are in the text portion of WINDOW,
+   the coordinates relative to the window are returned.
+If they are in the mode line of WINDOW, `mode-line' is returned.
+If they are in the top mode line of WINDOW, `header-line' is returned.
+If they are in the fringe to the left of the window,
+   `left-fringe' is returned, if they are in the area on the right of
+   the window, `right-fringe' is returned.
+If they are on the border between WINDOW and its right sibling,
+  `vertical-line' is returned.  */)
+     (coordinates, window)
      register Lisp_Object coordinates, window;
 {
   struct window *w;
@@ -808,12 +808,12 @@ window_from_coordinates (f, x, y, part, tool_bar_p)
 }
 
 DEFUN ("window-at", Fwindow_at, Swindow_at, 2, 3, 0,
-  "Return window containing coordinates X and Y on FRAME.\n\
-If omitted, FRAME defaults to the currently selected frame.\n\
-The top left corner of the frame is considered to be row 0,\n\
-column 0.")
-  (x, y, frame)
-      Lisp_Object x, y, frame;
+       doc: /* Return window containing coordinates X and Y on FRAME.
+If omitted, FRAME defaults to the currently selected frame.
+The top left corner of the frame is considered to be row 0,
+column 0.  */)
+     (x, y, frame)
+     Lisp_Object x, y, frame;
 {
   int part;
   struct frame *f;
@@ -834,16 +834,16 @@ column 0.")
 }
 
 DEFUN ("window-point", Fwindow_point, Swindow_point, 0, 1, 0,
-  "Return current value of point in WINDOW.\n\
-For a nonselected window, this is the value point would have\n\
-if that window were selected.\n\
-\n\
-Note that, when WINDOW is the selected window and its buffer\n\
-is also currently selected, the value returned is the same as (point).\n\
-It would be more strictly correct to return the `top-level' value\n\
-of point, outside of any save-excursion forms.\n\
-But that is hard to define.")
-  (window)
+       doc: /* Return current value of point in WINDOW.
+For a nonselected window, this is the value point would have
+if that window were selected.
+
+Note that, when WINDOW is the selected window and its buffer
+is also currently selected, the value returned is the same as (point).
+It would be more strictly correct to return the `top-level' value
+of point, outside of any save-excursion forms.
+But that is hard to define.  */)
+     (window)
      Lisp_Object window;
 {
   register struct window *w = decode_window (window);
@@ -855,9 +855,9 @@ But that is hard to define.")
 }
 
 DEFUN ("window-start", Fwindow_start, Swindow_start, 0, 1, 0,
-  "Return position at which display currently starts in WINDOW.\n\
-This is updated by redisplay or by calling `set-window-start'.")
-  (window)
+       doc: /* Return position at which display currently starts in WINDOW.
+This is updated by redisplay or by calling `set-window-start'.  */)
+     (window)
      Lisp_Object window;
 {
   return Fmarker_position (decode_window (window)->start);
@@ -865,23 +865,23 @@ This is updated by redisplay or by calling `set-window-start'.")
 
 /* This is text temporarily removed from the doc string below.
 
-This function returns nil if the position is not currently known.\n\
-That happens when redisplay is preempted and doesn't finish.\n\
-If in that case you want to compute where the end of the window would\n\
-have been if redisplay had finished, do this:\n\
-    (save-excursion\n\
-      (goto-char (window-start window))\n\
-      (vertical-motion (1- (window-height window)) window)\n\
+This function returns nil if the position is not currently known.
+That happens when redisplay is preempted and doesn't finish.
+If in that case you want to compute where the end of the window would
+have been if redisplay had finished, do this:
+    (save-excursion
+      (goto-char (window-start window))
+      (vertical-motion (1- (window-height window)) window)
       (point))")  */
 
 DEFUN ("window-end", Fwindow_end, Swindow_end, 0, 2, 0,
-  "Return position at which display currently ends in WINDOW.\n\
-This is updated by redisplay, when it runs to completion.\n\
-Simply changing the buffer text or setting `window-start'\n\
-does not update this value.\n\
-If UPDATE is non-nil, compute the up-to-date position\n\
-if it isn't already recorded.")
-  (window, update)
+       doc: /* Return position at which display currently ends in WINDOW.
+This is updated by redisplay, when it runs to completion.
+Simply changing the buffer text or setting `window-start'
+does not update this value.
+If UPDATE is non-nil, compute the up-to-date position
+if it isn't already recorded.  */)
+     (window, update)
      Lisp_Object window, update;
 {
   Lisp_Object value;
@@ -944,8 +944,8 @@ if it isn't already recorded.")
 }
 
 DEFUN ("set-window-point", Fset_window_point, Sset_window_point, 2, 2, 0,
-  "Make point value in WINDOW be at position POS in WINDOW's buffer.")
-  (window, pos)
+       doc: /* Make point value in WINDOW be at position POS in WINDOW's buffer.  */)
+     (window, pos)
      Lisp_Object window, pos;
 {
   register struct window *w = decode_window (window);
@@ -966,10 +966,10 @@ DEFUN ("set-window-point", Fset_window_point, Sset_window_point, 2, 2, 0,
 }
 
 DEFUN ("set-window-start", Fset_window_start, Sset_window_start, 2, 3, 0,
-  "Make display in WINDOW start at position POS in WINDOW's buffer.\n\
-Optional third arg NOFORCE non-nil inhibits next redisplay\n\
-from overriding motion of point in order to display at this exact start.")
-  (window, pos, noforce)
+       doc: /* Make display in WINDOW start at position POS in WINDOW's buffer.
+Optional third arg NOFORCE non-nil inhibits next redisplay
+from overriding motion of point in order to display at this exact start.  */)
+     (window, pos, noforce)
      Lisp_Object window, pos, noforce;
 {
   register struct window *w = decode_window (window);
@@ -991,9 +991,9 @@ from overriding motion of point in order to display at this exact start.")
 
 DEFUN ("window-dedicated-p", Fwindow_dedicated_p, Swindow_dedicated_p,
        1, 1, 0,
-  "Return WINDOW's dedicated object, usually t or nil.\n\
-See also `set-window-dedicated-p'.")
-  (window)
+       doc: /* Return WINDOW's dedicated object, usually t or nil.
+See also `set-window-dedicated-p'.  */)
+     (window)
      Lisp_Object window;
 {
   return decode_window (window)->dedicated;
@@ -1001,13 +1001,13 @@ See also `set-window-dedicated-p'.")
 
 DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p,
        Sset_window_dedicated_p, 2, 2, 0,
-  "Control whether WINDOW is dedicated to the buffer it displays.\n\
-If it is dedicated, Emacs will not automatically change\n\
-which buffer appears in it.\n\
-The second argument is the new value for the dedication flag;\n\
-non-nil means yes.")
-  (window, arg)
-       Lisp_Object window, arg;
+       doc: /* Control whether WINDOW is dedicated to the buffer it displays.
+If it is dedicated, Emacs will not automatically change
+which buffer appears in it.
+The second argument is the new value for the dedication flag;
+non-nil means yes. */)
+     (window, arg)
+     Lisp_Object window, arg;
 {
   register struct window *w = decode_window (window);
 
@@ -1021,8 +1021,8 @@ non-nil means yes.")
 
 DEFUN ("window-display-table", Fwindow_display_table, Swindow_display_table,
        0, 1, 0,
-  "Return the display-table that WINDOW is using.")
-  (window)
+       doc: /* Return the display-table that WINDOW is using.  */)
+     (window)
      Lisp_Object window;
 {
   return decode_window (window)->display_table;
@@ -1055,8 +1055,8 @@ window_display_table (w)
 }
 
 DEFUN ("set-window-display-table", Fset_window_display_table, Sset_window_display_table, 2, 2, 0,
-  "Set WINDOW's display-table to TABLE.")
-  (window, table)
+       doc: /* Set WINDOW's display-table to TABLE.  */)
+     (window, table)
      register Lisp_Object window, table;
 {
   register struct window *w;
@@ -1171,8 +1171,8 @@ children be children of that parent instead.  ***/
 }
 
 DEFUN ("delete-window", Fdelete_window, Sdelete_window, 0, 1, "",
-  "Remove WINDOW from the display.  Default is selected window.")
-  (window)
+       doc: /* Remove WINDOW from the display.  Default is selected window.  */)
+     (window)
      register Lisp_Object window;
 {
   delete_window (window);
@@ -1558,83 +1558,66 @@ next_window (window, minibuf, all_frames, next_p)
 }
 
 
-/* This comment supplies the doc string for `next-window',
-   for make-docfile to see.  We cannot put this in the real DEFUN
-   due to limits in the Unix cpp.
-
-DEFUN ("next-window", Ffoo, Sfoo, 0, 3, 0,
-  "Return next window after WINDOW in canonical ordering of windows.\n\
-If omitted, WINDOW defaults to the selected window.\n\
-\n\
-Optional second arg MINIBUF t means count the minibuffer window even\n\
-if not active.  MINIBUF nil or omitted means count the minibuffer iff\n\
-it is active.  MINIBUF neither t nor nil means not to count the\n\
-minibuffer even if it is active.\n\
-\n\
-Several frames may share a single minibuffer; if the minibuffer\n\
-counts, all windows on all frames that share that minibuffer count\n\
-too.  Therefore, `next-window' can be used to iterate through the\n\
-set of windows even when the minibuffer is on another frame.  If the\n\
-minibuffer does not count, only windows from WINDOW's frame count.\n\
-\n\
-Optional third arg ALL-FRAMES t means include windows on all frames.\n\
-ALL-FRAMES nil or omitted means cycle within the frames as specified\n\
-above.  ALL-FRAMES = `visible' means include windows on all visible frames.\n\
-ALL-FRAMES = 0 means include windows on all visible and iconified frames.\n\
-If ALL-FRAMES is a frame, restrict search to windows on that frame.\n\
-Anything else means restrict to WINDOW's frame.\n\
-\n\
-If you use consistent values for MINIBUF and ALL-FRAMES, you can use\n\
-`next-window' to iterate through the entire cycle of acceptable\n\
-windows, eventually ending up back at the window you started with.\n\
-`previous-window' traverses the same cycle, in the reverse order.")
-  (window, minibuf, all_frames) */
-
 DEFUN ("next-window", Fnext_window, Snext_window, 0, 3, 0,
-       0)
-  (window, minibuf, all_frames)
+       doc: /* Return next window after WINDOW in canonical ordering of windows.
+If omitted, WINDOW defaults to the selected window.
+
+Optional second arg MINIBUF t means count the minibuffer window even
+if not active.  MINIBUF nil or omitted means count the minibuffer iff
+it is active.  MINIBUF neither t nor nil means not to count the
+minibuffer even if it is active.
+
+Several frames may share a single minibuffer; if the minibuffer
+counts, all windows on all frames that share that minibuffer count
+too.  Therefore, `next-window' can be used to iterate through the
+set of windows even when the minibuffer is on another frame.  If the
+minibuffer does not count, only windows from WINDOW's frame count.
+
+Optional third arg ALL-FRAMES t means include windows on all frames.
+ALL-FRAMES nil or omitted means cycle within the frames as specified
+above.  ALL-FRAMES = `visible' means include windows on all visible frames.
+ALL-FRAMES = 0 means include windows on all visible and iconified frames.
+If ALL-FRAMES is a frame, restrict search to windows on that frame.
+Anything else means restrict to WINDOW's frame.
+
+If you use consistent values for MINIBUF and ALL-FRAMES, you can use
+`next-window' to iterate through the entire cycle of acceptable
+windows, eventually ending up back at the window you started with.
+`previous-window' traverses the same cycle, in the reverse order.  */)
+     (window, minibuf, all_frames)
      Lisp_Object window, minibuf, all_frames;
 {
   return next_window (window, minibuf, all_frames, 1);
 }
 
 
-/* This comment supplies the doc string for `previous-window',
-   for make-docfile to see.  We cannot put this in the real DEFUN
-   due to limits in the Unix cpp.
-
-DEFUN ("previous-window", Ffoo, Sfoo, 0, 3, 0,
-  "Return the window preceding WINDOW in canonical ordering of windows.\n\
-If omitted, WINDOW defaults to the selected window.\n\
-\n\
-Optional second arg MINIBUF t means count the minibuffer window even\n\
-if not active.  MINIBUF nil or omitted means count the minibuffer iff\n\
-it is active.  MINIBUF neither t nor nil means not to count the\n\
-minibuffer even if it is active.\n\
-\n\
-Several frames may share a single minibuffer; if the minibuffer\n\
-counts, all windows on all frames that share that minibuffer count\n\
-too.  Therefore, `previous-window' can be used to iterate through\n\
-the set of windows even when the minibuffer is on another frame.  If\n\
-the minibuffer does not count, only windows from WINDOW's frame count\n\
-\n\
-Optional third arg ALL-FRAMES t means include windows on all frames.\n\
-ALL-FRAMES nil or omitted means cycle within the frames as specified\n\
-above.  ALL-FRAMES = `visible' means include windows on all visible frames.\n\
-ALL-FRAMES = 0 means include windows on all visible and iconified frames.\n\
-If ALL-FRAMES is a frame, restrict search to windows on that frame.\n\
-Anything else means restrict to WINDOW's frame.\n\
-\n\
-If you use consistent values for MINIBUF and ALL-FRAMES, you can use\n\
-`previous-window' to iterate through the entire cycle of acceptable\n\
-windows, eventually ending up back at the window you started with.\n\
-`next-window' traverses the same cycle, in the reverse order.")
-  (window, minibuf, all_frames)  */
-
-
 DEFUN ("previous-window", Fprevious_window, Sprevious_window, 0, 3, 0,
-       0)
-  (window, minibuf, all_frames)
+       doc: /* Return the window preceding WINDOW in canonical ordering of windows.
+If omitted, WINDOW defaults to the selected window.
+
+Optional second arg MINIBUF t means count the minibuffer window even
+if not active.  MINIBUF nil or omitted means count the minibuffer iff
+it is active.  MINIBUF neither t nor nil means not to count the
+minibuffer even if it is active.
+
+Several frames may share a single minibuffer; if the minibuffer
+counts, all windows on all frames that share that minibuffer count
+too.  Therefore, `previous-window' can be used to iterate through
+the set of windows even when the minibuffer is on another frame.  If
+the minibuffer does not count, only windows from WINDOW's frame count
+
+Optional third arg ALL-FRAMES t means include windows on all frames.
+ALL-FRAMES nil or omitted means cycle within the frames as specified
+above.  ALL-FRAMES = `visible' means include windows on all visible frames.
+ALL-FRAMES = 0 means include windows on all visible and iconified frames.
+If ALL-FRAMES is a frame, restrict search to windows on that frame.
+Anything else means restrict to WINDOW's frame.
+
+If you use consistent values for MINIBUF and ALL-FRAMES, you can use
+`previous-window' to iterate through the entire cycle of acceptable
+windows, eventually ending up back at the window you started with.
+`next-window' traverses the same cycle, in the reverse order.  */)
+     (window, minibuf, all_frames)
      Lisp_Object window, minibuf, all_frames;
 {
   return next_window (window, minibuf, all_frames, 0);
@@ -1642,12 +1625,12 @@ DEFUN ("previous-window", Fprevious_window, Sprevious_window, 0, 3, 0,
 
 
 DEFUN ("other-window", Fother_window, Sother_window, 1, 2, "p",
-  "Select the ARG'th different window on this frame.\n\
-All windows on current frame are arranged in a cyclic order.\n\
-This command selects the window ARG steps away in that order.\n\
-A negative ARG moves in the opposite order.  If the optional second\n\
-argument ALL_FRAMES is non-nil, cycle through all frames.")
-  (arg, all_frames)
+       doc: /* Select the ARG'th different window on this frame.
+All windows on current frame are arranged in a cyclic order.
+This command selects the window ARG steps away in that order.
+A negative ARG moves in the opposite order.  If the optional second
+argument ALL_FRAMES is non-nil, cycle through all frames.  */)
+     (arg, all_frames)
      Lisp_Object arg, all_frames;
 {
   Lisp_Object window;
@@ -1667,14 +1650,14 @@ argument ALL_FRAMES is non-nil, cycle through all frames.")
 
 
 DEFUN ("window-list", Fwindow_list, Swindow_list, 0, 3, 0,
-  "Return a list of windows on FRAME, starting with WINDOW.\n\
-FRAME nil or omitted means use the selected frame.\n\
-WINDOW nil or omitted means use the selected window.\n\
-MINIBUF t means include the minibuffer window, even if it isn't active.\n\
-MINIBUF nil or omitted means include the minibuffer window only\n\
-if it's active.\n\
-MINIBUF neither nil nor t means never include the minibuffer window.")
-  (frame, minibuf, window)
+       doc: /* Return a list of windows on FRAME, starting with WINDOW.
+FRAME nil or omitted means use the selected frame.
+WINDOW nil or omitted means use the selected window.
+MINIBUF t means include the minibuffer window, even if it isn't active.
+MINIBUF nil or omitted means include the minibuffer window only
+if it's active.
+MINIBUF neither nil nor t means never include the minibuffer window.  */)
+     (frame, minibuf, window)
      Lisp_Object frame, minibuf, window;
 {
   if (NILP (window))
@@ -1942,14 +1925,14 @@ check_all_windows ()
 }
 
 DEFUN ("get-lru-window", Fget_lru_window, Sget_lru_window, 0, 1, 0,
-  "Return the window least recently selected or used for display.\n\
-If optional argument FRAME is `visible', search all visible frames.\n\
-If FRAME is 0, search all visible and iconified frames.\n\
-If FRAME is t, search all frames.\n\
-If FRAME is nil, search only the selected frame.\n\
-If FRAME is a frame, search only that frame.")
-  (frame)
-    Lisp_Object frame;
+       doc: /* Return the window least recently selected or used for display.
+If optional argument FRAME is `visible', search all visible frames.
+If FRAME is 0, search all visible and iconified frames.
+If FRAME is t, search all frames.
+If FRAME is nil, search only the selected frame.
+If FRAME is a frame, search only that frame.  */)
+     (frame)
+     Lisp_Object frame;
 {
   register Lisp_Object w;
   /* First try for a window that is full-width */
@@ -1961,28 +1944,28 @@ If FRAME is a frame, search only that frame.")
 }
 
 DEFUN ("get-largest-window", Fget_largest_window, Sget_largest_window, 0, 1, 0,
-  "Return the largest window in area.\n\
-If optional argument FRAME is `visible', search all visible frames.\n\
-If FRAME is 0, search all visible and iconified frames.\n\
-If FRAME is t, search all frames.\n\
-If FRAME is nil, search only the selected frame.\n\
-If FRAME is a frame, search only that frame.")
-  (frame)
-    Lisp_Object frame;
+       doc: /* Return the largest window in area.
+If optional argument FRAME is `visible', search all visible frames.
+If FRAME is 0, search all visible and iconified frames.
+If FRAME is t, search all frames.
+If FRAME is nil, search only the selected frame.
+If FRAME is a frame, search only that frame.  */)
+     (frame)
+     Lisp_Object frame;
 {
   return window_loop (GET_LARGEST_WINDOW, Qnil, 0,
                       frame);
 }
 
 DEFUN ("get-buffer-window", Fget_buffer_window, Sget_buffer_window, 1, 2, 0,
-  "Return a window currently displaying BUFFER, or nil if none.\n\
-If optional argument FRAME is `visible', search all visible frames.\n\
-If optional argument FRAME is 0, search all visible and iconified frames.\n\
-If FRAME is t, search all frames.\n\
-If FRAME is nil, search only the selected frame.\n\
-If FRAME is a frame, search only that frame.")
-  (buffer, frame)
-    Lisp_Object buffer, frame;
+       doc: /* Return a window currently displaying BUFFER, or nil if none.
+If optional argument FRAME is `visible', search all visible frames.
+If optional argument FRAME is 0, search all visible and iconified frames.
+If FRAME is t, search all frames.
+If FRAME is nil, search only the selected frame.
+If FRAME is a frame, search only that frame.  */)
+     (buffer, frame)
+     Lisp_Object buffer, frame;
 {
   buffer = Fget_buffer (buffer);
   if (BUFFERP (buffer))
@@ -1992,16 +1975,16 @@ If FRAME is a frame, search only that frame.")
 }
 
 DEFUN ("delete-other-windows", Fdelete_other_windows, Sdelete_other_windows,
-  0, 1, "",
-  "Make WINDOW (or the selected window) fill its frame.\n\
-Only the frame WINDOW is on is affected.\n\
-This function tries to reduce display jumps\n\
-by keeping the text previously visible in WINDOW\n\
-in the same place on the frame.  Doing this depends on\n\
-the value of (window-start WINDOW), so if calling this function\n\
-in a program gives strange scrolling, make sure the window-start\n\
-value is reasonable when this function is called.")
-  (window)
+       0, 1, "",
+       doc: /* Make WINDOW (or the selected window) fill its frame.
+Only the frame WINDOW is on is affected.
+This function tries to reduce display jumps
+by keeping the text previously visible in WINDOW
+in the same place on the frame.  Doing this depends on
+the value of (window-start WINDOW), so if calling this function
+in a program gives strange scrolling, make sure the window-start
+value is reasonable when this function is called.  */)
+     (window)
      Lisp_Object window;
 {
   struct window *w;
@@ -2056,15 +2039,15 @@ value is reasonable when this function is called.")
 }
 
 DEFUN ("delete-windows-on", Fdelete_windows_on, Sdelete_windows_on,
-  1, 2, "bDelete windows on (buffer): ",
-  "Delete all windows showing BUFFER.\n\
-Optional second argument FRAME controls which frames are affected.\n\
-If optional argument FRAME is `visible', search all visible frames.\n\
-If FRAME is 0, search all visible and iconified frames.\n\
-If FRAME is nil, search all frames.\n\
-If FRAME is t, search only the selected frame.\n\
-If FRAME is a frame, search only that frame.")
-  (buffer, frame)
+       1, 2, "bDelete windows on (buffer): ",
+       doc: /* Delete all windows showing BUFFER.
+Optional second argument FRAME controls which frames are affected.
+If optional argument FRAME is `visible', search all visible frames.
+If FRAME is 0, search all visible and iconified frames.
+If FRAME is nil, search all frames.
+If FRAME is t, search only the selected frame.
+If FRAME is a frame, search only that frame.  */)
+     (buffer, frame)
      Lisp_Object buffer, frame;
 {
   /* FRAME uses t and nil to mean the opposite of what window_loop
@@ -2085,10 +2068,10 @@ If FRAME is a frame, search only that frame.")
 }
 
 DEFUN ("replace-buffer-in-windows", Freplace_buffer_in_windows,
-  Sreplace_buffer_in_windows,
-  1, 1, "bReplace buffer in windows: ",
-  "Replace BUFFER with some other buffer in all windows showing it.")
-  (buffer)
+       Sreplace_buffer_in_windows,
+       1, 1, "bReplace buffer in windows: ",
+       doc: /* Replace BUFFER with some other buffer in all windows showing it.  */)
+     (buffer)
      Lisp_Object buffer;
 {
   if (!NILP (buffer))
@@ -2671,9 +2654,9 @@ set_window_buffer (window, buffer, run_hooks_p)
 
 
 DEFUN ("set-window-buffer", Fset_window_buffer, Sset_window_buffer, 2, 2, 0,
-  "Make WINDOW display BUFFER as its contents.\n\
-BUFFER can be a buffer or buffer name.")
-  (window, buffer)
+       doc: /* Make WINDOW display BUFFER as its contents.
+BUFFER can be a buffer or buffer name.  */)
+     (window, buffer)
      register Lisp_Object window, buffer;
 {
   register Lisp_Object tem;
@@ -2704,11 +2687,11 @@ BUFFER can be a buffer or buffer name.")
 }
 
 DEFUN ("select-window", Fselect_window, Sselect_window, 1, 1, 0,
-  "Select WINDOW.  Most editing will apply to WINDOW's buffer.\n\
-If WINDOW is not already selected, also make WINDOW's buffer current.\n\
-Note that the main editor command loop\n\
-selects the buffer of the selected window before each command.")
-  (window)
+       doc: /* Select WINDOW.  Most editing will apply to WINDOW's buffer.
+If WINDOW is not already selected, also make WINDOW's buffer current.
+Note that the main editor command loop
+selects the buffer of the selected window before each command.  */)
+     (window)
      register Lisp_Object window;
 {
   return select_window_1 (window, 1);
@@ -2814,11 +2797,11 @@ display_buffer_1 (window)
 }
 
 DEFUN ("special-display-p", Fspecial_display_p, Sspecial_display_p, 1, 1, 0,
-  "Returns non-nil if a buffer named BUFFER-NAME would be created specially.\n\
-The value is actually t if the frame should be called with default frame\n\
-parameters, and a list of frame parameters if they were specified.\n\
-See `special-display-buffer-names', and `special-display-regexps'.")
-  (buffer_name)
+       doc: /* Returns non-nil if a buffer named BUFFER-NAME would be created specially.
+The value is actually t if the frame should be called with default frame
+parameters, and a list of frame parameters if they were specified.
+See `special-display-buffer-names', and `special-display-regexps'.  */)
+     (buffer_name)
      Lisp_Object buffer_name;
 {
   Lisp_Object tem;
@@ -2848,9 +2831,9 @@ See `special-display-buffer-names', and `special-display-regexps'.")
 }  
 
 DEFUN ("same-window-p", Fsame_window_p, Ssame_window_p, 1, 1, 0,
-  "Returns non-nil if a new buffer named BUFFER-NAME would use the same window.\n\
-See `same-window-buffer-names' and `same-window-regexps'.")
-  (buffer_name)
+       doc: /* Returns non-nil if a new buffer named BUFFER-NAME would use the same window.
+See `same-window-buffer-names' and `same-window-regexps'.  */)
+     (buffer_name)
      Lisp_Object buffer_name;
 {
   Lisp_Object tem;
@@ -2879,36 +2862,36 @@ See `same-window-buffer-names' and `same-window-regexps'.")
   return Qnil;
 }
 
-   /* Use B so the default is (other-buffer).  */
+/* Use B so the default is (other-buffer).  */
 DEFUN ("display-buffer", Fdisplay_buffer, Sdisplay_buffer, 1, 3,
-     "BDisplay buffer: \nP",
-  "Make BUFFER appear in some window but don't select it.\n\
-BUFFER can be a buffer or a buffer name.\n\
-If BUFFER is shown already in some window, just use that one,\n\
-unless the window is the selected window and the optional second\n\
-argument NOT-THIS-WINDOW is non-nil (interactively, with prefix arg).\n\
-If `pop-up-frames' is non-nil, make a new frame if no window shows BUFFER.\n\
-Returns the window displaying BUFFER.\n\
-If `display-reuse-frames' is non-nil, and another frame is currently\n\
-displaying BUFFER, then simply raise that frame.\n\
-\n\
-The variables `special-display-buffer-names', `special-display-regexps',\n\
-`same-window-buffer-names', and `same-window-regexps' customize how certain\n\
-buffer names are handled.\n\
-\n\
-If optional argument FRAME is `visible', search all visible frames.\n\
-If FRAME is 0, search all visible and iconified frames.\n\
-If FRAME is t, search all frames.\n\
-If FRAME is a frame, search only that frame.\n\
-If FRAME is nil, search only the selected frame\n\
- (actually the last nonminibuffer frame),\n\
- unless `pop-up-frames' or `display-buffer-reuse-frames' is non-nil,\n\
- which means search visible and iconified frames.\n\
-\n\
-If `even-window-heights' is non-nil, window heights will be evened out\n\
-if displaying the buffer causes two vertically adjacent windows to be\n\
-displayed.")
-  (buffer, not_this_window, frame)
+       "BDisplay buffer: \nP",
+       doc: /* Make BUFFER appear in some window but don't select it.
+BUFFER can be a buffer or a buffer name.
+If BUFFER is shown already in some window, just use that one,
+unless the window is the selected window and the optional second
+argument NOT-THIS-WINDOW is non-nil (interactively, with prefix arg).
+If `pop-up-frames' is non-nil, make a new frame if no window shows BUFFER.
+Returns the window displaying BUFFER.
+If `display-reuse-frames' is non-nil, and another frame is currently
+displaying BUFFER, then simply raise that frame.
+
+The variables `special-display-buffer-names', `special-display-regexps',
+`same-window-buffer-names', and `same-window-regexps' customize how certain
+buffer names are handled.
+
+If optional argument FRAME is `visible', search all visible frames.
+If FRAME is 0, search all visible and iconified frames.
+If FRAME is t, search all frames.
+If FRAME is a frame, search only that frame.
+If FRAME is nil, search only the selected frame
+ (actually the last nonminibuffer frame),
+ unless `pop-up-frames' or `display-buffer-reuse-frames' is non-nil,
+ which means search visible and iconified frames.
+
+If `even-window-heights' is non-nil, window heights will be evened out
+if displaying the buffer causes two vertically adjacent windows to be
+displayed.  */)
+     (buffer, not_this_window, frame)
      register Lisp_Object buffer, not_this_window, frame;
 {
   register Lisp_Object window, tem, swp;
@@ -3170,12 +3153,12 @@ make_dummy_parent (window)
 }
 
 DEFUN ("split-window", Fsplit_window, Ssplit_window, 0, 3, "",
-  "Split WINDOW, putting SIZE lines in the first of the pair.\n\
-WINDOW defaults to selected one and SIZE to half its size.\n\
-If optional third arg HORFLAG is non-nil, split side by side\n\
-and put SIZE columns in the first of the pair.  In that case,\n\
-SIZE includes that window's scroll bar, or the divider column to its right.")
-  (window, size, horflag)
+       doc: /* Split WINDOW, putting SIZE lines in the first of the pair.
+WINDOW defaults to selected one and SIZE to half its size.
+If optional third arg HORFLAG is non-nil, split side by side
+and put SIZE columns in the first of the pair.  In that case,
+SIZE includes that window's scroll bar, or the divider column to its right.  */)
+     (window, size, horflag)
      Lisp_Object window, size, horflag;
 {
   register Lisp_Object new;
@@ -3293,10 +3276,10 @@ SIZE includes that window's scroll bar, or the divider column to its right.")
 }
 
 DEFUN ("enlarge-window", Fenlarge_window, Senlarge_window, 1, 2, "p",
-  "Make current window ARG lines bigger.\n\
-From program, optional second arg non-nil means grow sideways ARG columns.\n\
-Interactively, if an argument is not given, make the window one line bigger.")
-  (arg, side)
+       doc: /* Make current window ARG lines bigger.
+From program, optional second arg non-nil means grow sideways ARG columns.
+Interactively, if an argument is not given, make the window one line bigger.  */)
+     (arg, side)
      register Lisp_Object arg, side;
 {
   CHECK_NUMBER (arg, 0);
@@ -3309,10 +3292,10 @@ Interactively, if an argument is not given, make the window one line bigger.")
 }
 
 DEFUN ("shrink-window", Fshrink_window, Sshrink_window, 1, 2, "p",
-  "Make current window ARG lines smaller.\n\
-From program, optional second arg non-nil means shrink sideways arg columns.\n\
-Interactively, if an argument is not given, make the window one line smaller.")
-  (arg, side)
+       doc: /* Make current window ARG lines smaller.
+From program, optional second arg non-nil means shrink sideways arg columns.
+Interactively, if an argument is not given, make the window one line smaller.  */)
+     (arg, side)
      register Lisp_Object arg, side;
 {
   CHECK_NUMBER (arg, 0);
@@ -4308,12 +4291,12 @@ scroll_command (n, direction)
 }
 
 DEFUN ("scroll-up", Fscroll_up, Sscroll_up, 0, 1, "P",
-  "Scroll text of current window upward ARG lines; or near full screen if no ARG.\n\
-A near full screen is `next-screen-context-lines' less than a full screen.\n\
-Negative ARG means scroll downward.\n\
-If ARG is the atom `-', scroll downward by nearly full screen.\n\
-When calling from a program, supply as argument a number, nil, or `-'.")
-  (arg)
+       doc: /* Scroll text of current window upward ARG lines; or near full screen if no ARG.
+A near full screen is `next-screen-context-lines' less than a full screen.
+Negative ARG means scroll downward.
+If ARG is the atom `-', scroll downward by nearly full screen.
+When calling from a program, supply as argument a number, nil, or `-'.  */)
+     (arg)
      Lisp_Object arg;
 {
   scroll_command (arg, 1);
@@ -4321,12 +4304,12 @@ When calling from a program, supply as argument a number, nil, or `-'.")
 }
 
 DEFUN ("scroll-down", Fscroll_down, Sscroll_down, 0, 1, "P",
-  "Scroll text of current window down ARG lines; or near full screen if no ARG.\n\
-A near full screen is `next-screen-context-lines' less than a full screen.\n\
-Negative ARG means scroll upward.\n\
-If ARG is the atom `-', scroll upward by nearly full screen.\n\
-When calling from a program, supply as argument a number, nil, or `-'.")
-  (arg)
+       doc: /* Scroll text of current window down ARG lines; or near full screen if no ARG.
+A near full screen is `next-screen-context-lines' less than a full screen.
+Negative ARG means scroll upward.
+If ARG is the atom `-', scroll upward by nearly full screen.
+When calling from a program, supply as argument a number, nil, or `-'.  */)
+     (arg)
      Lisp_Object arg;
 {
   scroll_command (arg, -1);
@@ -4334,12 +4317,12 @@ When calling from a program, supply as argument a number, nil, or `-'.")
 }
 
 DEFUN ("other-window-for-scrolling", Fother_window_for_scrolling, Sother_window_for_scrolling, 0, 0, 0,
-  "Return the other window for \"other window scroll\" commands.\n\
-If in the minibuffer, `minibuffer-scroll-window' if non-nil\n\
-specifies the window.\n\
-If `other-window-scroll-buffer' is non-nil, a window\n\
-showing that buffer is used.")
-  ()
+       doc: /* Return the other window for \"other window scroll\" commands.
+If in the minibuffer, `minibuffer-scroll-window' if non-nil
+specifies the window.
+If `other-window-scroll-buffer' is non-nil, a window
+showing that buffer is used.  */)
+     ()
 {
   Lisp_Object window;
 
@@ -4377,18 +4360,18 @@ showing that buffer is used.")
 }
 
 DEFUN ("scroll-other-window", Fscroll_other_window, Sscroll_other_window, 0, 1, "P",
-  "Scroll next window upward ARG lines; or near full screen if no ARG.\n\
-A near full screen is `next-screen-context-lines' less than a full screen.\n\
-The next window is the one below the current one; or the one at the top\n\
-if the current one is at the bottom.  Negative ARG means scroll downward.\n\
-If ARG is the atom `-', scroll downward by nearly full screen.\n\
-When calling from a program, supply as argument a number, nil, or `-'.\n\
-\n\
-If in the minibuffer, `minibuffer-scroll-window' if non-nil\n\
-specifies the window to scroll.\n\
-If `other-window-scroll-buffer' is non-nil, scroll the window\n\
-showing that buffer, popping the buffer up if necessary.")
-  (arg)
+       doc: /* Scroll next window upward ARG lines; or near full screen if no ARG.
+A near full screen is `next-screen-context-lines' less than a full screen.
+The next window is the one below the current one; or the one at the top
+if the current one is at the bottom.  Negative ARG means scroll downward.
+If ARG is the atom `-', scroll downward by nearly full screen.
+When calling from a program, supply as argument a number, nil, or `-'.
+
+If in the minibuffer, `minibuffer-scroll-window' if non-nil
+specifies the window to scroll.
+If `other-window-scroll-buffer' is non-nil, scroll the window
+showing that buffer, popping the buffer up if necessary.  */)
+     (arg)
      Lisp_Object arg;
 {
   Lisp_Object window;
@@ -4424,9 +4407,9 @@ showing that buffer, popping the buffer up if necessary.")
 }
 
 DEFUN ("scroll-left", Fscroll_left, Sscroll_left, 0, 1, "P",
-  "Scroll selected window display ARG columns left.\n\
-Default for ARG is window width minus 2.")
-  (arg)
+       doc: /* Scroll selected window display ARG columns left.
+Default for ARG is window width minus 2.  */)
+     (arg)
      register Lisp_Object arg;
 {
   Lisp_Object result;
@@ -4448,9 +4431,9 @@ Default for ARG is window width minus 2.")
 }
 
 DEFUN ("scroll-right", Fscroll_right, Sscroll_right, 0, 1, "P",
-  "Scroll selected window display ARG columns right.\n\
-Default for ARG is window width minus 2.")
-  (arg)
+       doc: /* Scroll selected window display ARG columns right.
+Default for ARG is window width minus 2.  */)
+     (arg)
      register Lisp_Object arg;
 {
   Lisp_Object result;
@@ -4521,16 +4504,16 @@ displayed_window_lines (w)
 
 
 DEFUN ("recenter", Frecenter, Srecenter, 0, 1, "P",
-  "Center point in window and redisplay frame.\n\
-With prefix argument ARG, recenter putting point on screen line ARG\n\
-relative to the current window.  If ARG is negative, it counts up from the\n\
-bottom of the window.  (ARG should be less than the height of the window.)\n\
-\n\
-If ARG is omitted or nil, erase the entire frame and then\n\
-redraw with point in the center of the current window.\n\
-Just C-u as prefix means put point in the center of the window\n\
-and redisplay normally--don't erase and redraw the frame.")
-  (arg)
+       doc: /* Center point in window and redisplay frame.
+With prefix argument ARG, recenter putting point on screen line ARG
+relative to the current window.  If ARG is negative, it counts up from the
+bottom of the window.  (ARG should be less than the height of the window.)
+
+If ARG is omitted or nil, erase the entire frame and then
+redraw with point in the center of the current window.
+Just C-u as prefix means put point in the center of the window
+and redisplay normally--don't erase and redraw the frame.  */)
+     (arg)
      register Lisp_Object arg;
 {
   struct window *w = XWINDOW (selected_window);
@@ -4646,11 +4629,11 @@ and redisplay normally--don't erase and redraw the frame.")
 
 
 DEFUN ("window-text-height", Fwindow_text_height, Swindow_text_height,
-  0, 1, 0,
-  "Return the height in lines of the text display area of WINDOW.\n\
-This doesn't include the mode-line (or header-line if any) or any\n\
-partial-height lines in the text display area.")
-  (window)
+       0, 1, 0,
+       doc: /* Return the height in lines of the text display area of WINDOW.
+This doesn't include the mode-line (or header-line if any) or any
+partial-height lines in the text display area.  */)
+     (window)
      Lisp_Object window;
 {
   struct window *w = decode_window (window);
@@ -4662,12 +4645,12 @@ partial-height lines in the text display area.")
 
 
 DEFUN ("move-to-window-line", Fmove_to_window_line, Smove_to_window_line,
-  1, 1, "P",
-  "Position point relative to window.\n\
-With no argument, position point at center of window.\n\
-An argument specifies vertical position within the window;\n\
-zero means top of window, negative means relative to bottom of window.")
-  (arg)
+       1, 1, "P",
+       doc: /* Position point relative to window.
+With no argument, position point at center of window.
+An argument specifies vertical position within the window;
+zero means top of window, negative means relative to bottom of window.  */)
+     (arg)
      Lisp_Object arg;
 {
   struct window *w = XWINDOW (selected_window);
@@ -4752,8 +4735,8 @@ struct saved_window
   ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
 
 DEFUN ("window-configuration-p", Fwindow_configuration_p, Swindow_configuration_p, 1, 1, 0,
-  "Return t if OBJECT is a window-configuration object.")
-  (object)
+       doc: /* Return t if OBJECT is a window-configuration object.  */)
+     (object)
      Lisp_Object object;
 {
   if (WINDOW_CONFIGURATIONP (object))
@@ -4762,8 +4745,8 @@ DEFUN ("window-configuration-p", Fwindow_configuration_p, Swindow_configuration_
 }
 
 DEFUN ("window-configuration-frame", Fwindow_configuration_frame, Swindow_configuration_frame, 1, 1, 0,
-  "Return the frame that CONFIG, a window-configuration object, is about.")
-  (config)
+       doc: /* Return the frame that CONFIG, a window-configuration object, is about.  */)
+     (config)
      Lisp_Object config;
 {
   register struct save_window_data *data;
@@ -4778,14 +4761,14 @@ DEFUN ("window-configuration-frame", Fwindow_configuration_frame, Swindow_config
 }
 
 DEFUN ("set-window-configuration", Fset_window_configuration,
-  Sset_window_configuration, 1, 1, 0,
-  "Set the configuration of windows and buffers as specified by CONFIGURATION.\n\
-CONFIGURATION must be a value previously returned\n\
-by `current-window-configuration' (which see).\n\
-If CONFIGURATION was made from a frame that is now deleted,\n\
-only frame-independent values can be restored.  In this case,\n\
-the return value is nil.  Otherwise the value is t.")
-  (configuration)
+       Sset_window_configuration, 1, 1, 0,
+       doc: /* Set the configuration of windows and buffers as specified by CONFIGURATION.
+CONFIGURATION must be a value previously returned
+by `current-window-configuration' (which see).
+If CONFIGURATION was made from a frame that is now deleted,
+only frame-independent values can be restored.  In this case,
+the return value is nil.  Otherwise the value is t.  */)
+     (configuration)
      Lisp_Object configuration;
 {
   register struct save_window_data *data;
@@ -5257,16 +5240,16 @@ save_window_save (window, vector, i)
 }
 
 DEFUN ("current-window-configuration", Fcurrent_window_configuration,
-  Scurrent_window_configuration, 0, 1, 0,
-  "Return an object representing the current window configuration of FRAME.\n\
-If FRAME is nil or omitted, use the selected frame.\n\
-This describes the number of windows, their sizes and current buffers,\n\
-and for each displayed buffer, where display starts, and the positions of\n\
-point and mark.  An exception is made for point in the current buffer:\n\
-its value is -not- saved.\n\
-This also records the currently selected frame, and FRAME's focus\n\
-redirection (see `redirect-frame-focus').")
-  (frame)
+       Scurrent_window_configuration, 0, 1, 0,
+       doc: /* Return an object representing the current window configuration of FRAME.
+If FRAME is nil or omitted, use the selected frame.
+This describes the number of windows, their sizes and current buffers,
+and for each displayed buffer, where display starts, and the positions of
+point and mark.  An exception is made for point in the current buffer:
+its value is -not- saved.
+This also records the currently selected frame, and FRAME's focus
+redirection (see `redirect-frame-focus').  */)
+     (frame)
      Lisp_Object frame;
 {
   register Lisp_Object tem;
@@ -5308,14 +5291,14 @@ redirection (see `redirect-frame-focus').")
 }
 
 DEFUN ("save-window-excursion", Fsave_window_excursion, Ssave_window_excursion,
-  0, UNEVALLED, 0,
-  "Execute body, preserving window sizes and contents.\n\
-Restore which buffer appears in which window, where display starts,\n\
-and the value of point and mark for each window.\n\
-Also restore the choice of selected window.\n\
-Also restore which buffer is current.\n\
-Does not restore the value of point in current buffer.")
-  (args)
+       0, UNEVALLED, 0,
+       doc: /* Execute body, preserving window sizes and contents.
+Restore which buffer appears in which window, where display starts,
+and the value of point and mark for each window.
+Also restore the choice of selected window.
+Also restore which buffer is current.
+Does not restore the value of point in current buffer.  */)
+     (args)
      Lisp_Object args;
 {
   register Lisp_Object val;
@@ -5334,13 +5317,13 @@ Does not restore the value of point in current buffer.")
 
 DEFUN ("set-window-margins", Fset_window_margins, Sset_window_margins,
        2, 3, 0,
-  "Set width of marginal areas of window WINDOW.\n\
-If window is nil, set margins of the currently selected window.\n\
-First parameter LEFT-WIDTH specifies the number of character\n\
-cells to reserve for the left marginal area.  Second parameter\n\
-RIGHT-WIDTH does the same for the right marginal area.\n\
-A nil width parameter means no margin.")
-  (window, left, right)
+       doc: /* Set width of marginal areas of window WINDOW.
+If window is nil, set margins of the currently selected window.
+First parameter LEFT-WIDTH specifies the number of character
+cells to reserve for the left marginal area.  Second parameter
+RIGHT-WIDTH does the same for the right marginal area.
+A nil width parameter means no margin.  */)
+     (window, left, right)
      Lisp_Object window, left, right;
 {
   struct window *w = decode_window (window);
@@ -5375,12 +5358,12 @@ A nil width parameter means no margin.")
 
 DEFUN ("window-margins", Fwindow_margins, Swindow_margins,
        0, 1, 0,
-  "Get width of marginal areas of window WINDOW.\n\
-If WINDOW is omitted or nil, use the currently selected window.\n\
-Value is a cons of the form (LEFT-WIDTH . RIGHT-WIDTH).\n\
-If a marginal area does not exist, its width will be returned\n\
-as nil.")
-  (window)
+       doc: /* Get width of marginal areas of window WINDOW.
+If WINDOW is omitted or nil, use the currently selected window.
+Value is a cons of the form (LEFT-WIDTH . RIGHT-WIDTH).
+If a marginal area does not exist, its width will be returned
+as nil.  */)
+     (window)
      Lisp_Object window;
 {
   struct window *w = decode_window (window);
@@ -5394,10 +5377,10 @@ as nil.")
  ***********************************************************************/
 
 DEFUN ("window-vscroll", Fwindow_vscroll, Swindow_vscroll, 0, 1, 0,
-  "Return the amount by which WINDOW is scrolled vertically.\n\
-Use the selected window if WINDOW is nil or omitted.\n\
-Value is a multiple of the canonical character height of WINDOW.")
-  (window)
+       doc: /* Return the amount by which WINDOW is scrolled vertically.
+Use the selected window if WINDOW is nil or omitted.
+Value is a multiple of the canonical character height of WINDOW.  */)
+     (window)
      Lisp_Object window;
 {
   Lisp_Object result;
@@ -5421,10 +5404,10 @@ Value is a multiple of the canonical character height of WINDOW.")
 
 DEFUN ("set-window-vscroll", Fset_window_vscroll, Sset_window_vscroll,
        2, 2, 0,
-  "Set amount by which WINDOW should be scrolled vertically to VSCROLL.\n\
-WINDOW nil or omitted means use the selected window.  VSCROLL is a\n\
-non-negative multiple of the canonical character height of WINDOW.")
-  (window, vscroll)
+       doc: /* Set amount by which WINDOW should be scrolled vertically to VSCROLL.
+WINDOW nil or omitted means use the selected window.  VSCROLL is a
+non-negative multiple of the canonical character height of WINDOW.  */)
+     (window, vscroll)
      Lisp_Object window, vscroll;
 {
   struct window *w;
@@ -5648,10 +5631,10 @@ compare_window_configurations (c1, c2, ignore_positions)
 
 DEFUN ("compare-window-configurations", Fcompare_window_configurations,
        Scompare_window_configurations, 2, 2, 0,
-  "Compare two window configurations as regards the structure of windows.\n\
-This function ignores details such as the values of point and mark\n\
-and scrolling positions.")
-  (x, y)
+       doc: /* Compare two window configurations as regards the structure of windows.
+This function ignores details such as the values of point and mark
+and scrolling positions.  */)
+     (x, y)
      Lisp_Object x, y;
 {
   if (compare_window_configurations (x, y, 1))
@@ -5708,166 +5691,166 @@ syms_of_window ()
   staticpro (&Vwindow_list);
 
   DEFVAR_LISP ("temp-buffer-show-function", &Vtemp_buffer_show_function,
-    "Non-nil means call as function to display a help buffer.\n\
-The function is called with one argument, the buffer to be displayed.\n\
-Used by `with-output-to-temp-buffer'.\n\
-If this function is used, then it must do the entire job of showing\n\
-the buffer; `temp-buffer-show-hook' is not run unless this function runs it.");
+               doc: /* Non-nil means call as function to display a help buffer.
+The function is called with one argument, the buffer to be displayed.
+Used by `with-output-to-temp-buffer'.
+If this function is used, then it must do the entire job of showing
+the buffer; `temp-buffer-show-hook' is not run unless this function runs it.  */);
   Vtemp_buffer_show_function = Qnil;
 
   DEFVAR_LISP ("display-buffer-function", &Vdisplay_buffer_function,
-    "If non-nil, function to call to handle `display-buffer'.\n\
-It will receive two args, the buffer and a flag which if non-nil means\n\
- that the currently selected window is not acceptable.\n\
-Commands such as `switch-to-buffer-other-window' and `find-file-other-window'\n\
-work using this function.");
+               doc: /* If non-nil, function to call to handle `display-buffer'.
+It will receive two args, the buffer and a flag which if non-nil means
+ that the currently selected window is not acceptable.
+Commands such as `switch-to-buffer-other-window' and `find-file-other-window'
+work using this function.  */);
   Vdisplay_buffer_function = Qnil;
 
   DEFVAR_LISP ("even-window-heights", &Veven_window_heights,
-    "*If non-nil, `display-buffer' should even the window heights.\n\
-If nil, `display-buffer' will leave the window configuration alone.");
+               doc: /* *If non-nil, `display-buffer' should even the window heights.
+If nil, `display-buffer' will leave the window configuration alone.  */);
   Veven_window_heights = Qt;
 
   DEFVAR_LISP ("minibuffer-scroll-window", &Vminibuf_scroll_window,
-    "Non-nil means it is the window that C-M-v in minibuffer should scroll.");
+               doc: /* Non-nil means it is the window that C-M-v in minibuffer should scroll.  */);
   Vminibuf_scroll_window = Qnil;
 
   DEFVAR_LISP ("other-window-scroll-buffer", &Vother_window_scroll_buffer,
-    "If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window.");
+               doc: /* If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window.  */);
   Vother_window_scroll_buffer = Qnil;
 
   DEFVAR_BOOL ("pop-up-frames", &pop_up_frames,
-    "*Non-nil means `display-buffer' should make a separate frame.");
+               doc: /* *Non-nil means `display-buffer' should make a separate frame.  */);
   pop_up_frames = 0;
 
   DEFVAR_BOOL ("display-buffer-reuse-frames", &display_buffer_reuse_frames,
-    "*Non-nil means `display-buffer' should reuse frames.\n\
-If the buffer in question is already displayed in a frame, raise that frame.");
+               doc: /* *Non-nil means `display-buffer' should reuse frames.
+If the buffer in question is already displayed in a frame, raise that frame.  */);
   display_buffer_reuse_frames = 0;
 
   DEFVAR_LISP ("pop-up-frame-function", &Vpop_up_frame_function,
-    "Function to call to handle automatic new frame creation.\n\
-It is called with no arguments and should return a newly created frame.\n\
-\n\
-A typical value might be `(lambda () (new-frame pop-up-frame-alist))'\n\
-where `pop-up-frame-alist' would hold the default frame parameters.");
+               doc: /* Function to call to handle automatic new frame creation.
+It is called with no arguments and should return a newly created frame.
+
+A typical value might be `(lambda () (new-frame pop-up-frame-alist))'
+where `pop-up-frame-alist' would hold the default frame parameters.  */);
   Vpop_up_frame_function = Qnil;
 
   DEFVAR_LISP ("special-display-buffer-names", &Vspecial_display_buffer_names,
-    "*List of buffer names that should have their own special frames.\n\
-Displaying a buffer whose name is in this list makes a special frame for it\n\
-using `special-display-function'.  See also `special-display-regexps'.\n\
-\n\
-An element of the list can be a list instead of just a string.\n\
-There are two ways to use a list as an element:\n\
-  (BUFFER FRAME-PARAMETERS...)   (BUFFER FUNCTION OTHER-ARGS...)\n\
-In the first case, FRAME-PARAMETERS are used to create the frame.\n\
-In the latter case, FUNCTION is called with BUFFER as the first argument,\n\
-followed by OTHER-ARGS--it can display BUFFER in any way it likes.\n\
-All this is done by the function found in `special-display-function'.\n\
-\n\
-If this variable appears \"not to work\", because you add a name to it\n\
-but that buffer still appears in the selected window, look at the\n\
-values of `same-window-buffer-names' and `same-window-regexps'.\n\
-Those variables take precedence over this one.");
+               doc: /* *List of buffer names that should have their own special frames.
+Displaying a buffer whose name is in this list makes a special frame for it
+using `special-display-function'.  See also `special-display-regexps'.
+
+An element of the list can be a list instead of just a string.
+There are two ways to use a list as an element:
+  (BUFFER FRAME-PARAMETERS...)   (BUFFER FUNCTION OTHER-ARGS...)
+In the first case, FRAME-PARAMETERS are used to create the frame.
+In the latter case, FUNCTION is called with BUFFER as the first argument,
+followed by OTHER-ARGS--it can display BUFFER in any way it likes.
+All this is done by the function found in `special-display-function'.
+
+If this variable appears \"not to work\", because you add a name to it
+but that buffer still appears in the selected window, look at the
+values of `same-window-buffer-names' and `same-window-regexps'.
+Those variables take precedence over this one.  */);
   Vspecial_display_buffer_names = Qnil;
 
   DEFVAR_LISP ("special-display-regexps", &Vspecial_display_regexps,
-    "*List of regexps saying which buffers should have their own special frames.\n\
-If a buffer name matches one of these regexps, it gets its own frame.\n\
-Displaying a buffer whose name is in this list makes a special frame for it\n\
-using `special-display-function'.\n\
-\n\
-An element of the list can be a list instead of just a string.\n\
-There are two ways to use a list as an element:\n\
-  (REGEXP FRAME-PARAMETERS...)   (REGEXP FUNCTION OTHER-ARGS...)\n\
-In the first case, FRAME-PARAMETERS are used to create the frame.\n\
-In the latter case, FUNCTION is called with the buffer as first argument,\n\
-followed by OTHER-ARGS--it can display the buffer in any way it likes.\n\
-All this is done by the function found in `special-display-function'.\n\
-\n\
-If this variable appears \"not to work\", because you add a regexp to it\n\
-but the matching buffers still appear in the selected window, look at the\n\
-values of `same-window-buffer-names' and `same-window-regexps'.\n\
-Those variables take precedence over this one.");
+               doc: /* *List of regexps saying which buffers should have their own special frames.
+If a buffer name matches one of these regexps, it gets its own frame.
+Displaying a buffer whose name is in this list makes a special frame for it
+using `special-display-function'.
+
+An element of the list can be a list instead of just a string.
+There are two ways to use a list as an element:
+  (REGEXP FRAME-PARAMETERS...)   (REGEXP FUNCTION OTHER-ARGS...)
+In the first case, FRAME-PARAMETERS are used to create the frame.
+In the latter case, FUNCTION is called with the buffer as first argument,
+followed by OTHER-ARGS--it can display the buffer in any way it likes.
+All this is done by the function found in `special-display-function'.
+
+If this variable appears \"not to work\", because you add a regexp to it
+but the matching buffers still appear in the selected window, look at the
+values of `same-window-buffer-names' and `same-window-regexps'.
+Those variables take precedence over this one.  */);
   Vspecial_display_regexps = Qnil;
 
   DEFVAR_LISP ("special-display-function", &Vspecial_display_function,
-    "Function to call to make a new frame for a special buffer.\n\
-It is called with two arguments, the buffer and optional buffer specific\n\
-data, and should return a window displaying that buffer.\n\
-The default value makes a separate frame for the buffer,\n\
-using `special-display-frame-alist' to specify the frame parameters.\n\
-\n\
-A buffer is special if its is listed in `special-display-buffer-names'\n\
-or matches a regexp in `special-display-regexps'.");
+               doc: /* Function to call to make a new frame for a special buffer.
+It is called with two arguments, the buffer and optional buffer specific
+data, and should return a window displaying that buffer.
+The default value makes a separate frame for the buffer,
+using `special-display-frame-alist' to specify the frame parameters.
+
+A buffer is special if its is listed in `special-display-buffer-names'
+or matches a regexp in `special-display-regexps'.  */);
   Vspecial_display_function = Qnil;
 
   DEFVAR_LISP ("same-window-buffer-names", &Vsame_window_buffer_names,
-    "*List of buffer names that should appear in the selected window.\n\
-Displaying one of these buffers using `display-buffer' or `pop-to-buffer'\n\
-switches to it in the selected window, rather than making it appear\n\
-in some other window.\n\
-\n\
-An element of the list can be a cons cell instead of just a string.\n\
-Then the car must be a string, which specifies the buffer name.\n\
-This is for compatibility with `special-display-buffer-names';\n\
-the cdr of the cons cell is ignored.\n\
-\n\
-See also `same-window-regexps'.");
+               doc: /* *List of buffer names that should appear in the selected window.
+Displaying one of these buffers using `display-buffer' or `pop-to-buffer'
+switches to it in the selected window, rather than making it appear
+in some other window.
+
+An element of the list can be a cons cell instead of just a string.
+Then the car must be a string, which specifies the buffer name.
+This is for compatibility with `special-display-buffer-names';
+the cdr of the cons cell is ignored.
+
+See also `same-window-regexps'.  */);
   Vsame_window_buffer_names = Qnil;
 
   DEFVAR_LISP ("same-window-regexps", &Vsame_window_regexps,
-    "*List of regexps saying which buffers should appear in the selected window.\n\
-If a buffer name matches one of these regexps, then displaying it\n\
-using `display-buffer' or `pop-to-buffer' switches to it\n\
-in the selected window, rather than making it appear in some other window.\n\
-\n\
-An element of the list can be a cons cell instead of just a string.\n\
-Then the car must be a string, which specifies the buffer name.\n\
-This is for compatibility with `special-display-buffer-names';\n\
-the cdr of the cons cell is ignored.\n\
-\n\
-See also `same-window-buffer-names'.");
+               doc: /* *List of regexps saying which buffers should appear in the selected window.
+If a buffer name matches one of these regexps, then displaying it
+using `display-buffer' or `pop-to-buffer' switches to it
+in the selected window, rather than making it appear in some other window.
+
+An element of the list can be a cons cell instead of just a string.
+Then the car must be a string, which specifies the buffer name.
+This is for compatibility with `special-display-buffer-names';
+the cdr of the cons cell is ignored.
+
+See also `same-window-buffer-names'.  */);
   Vsame_window_regexps = Qnil;
 
   DEFVAR_BOOL ("pop-up-windows", &pop_up_windows,
-    "*Non-nil means display-buffer should make new windows.");
+               doc: /* *Non-nil means display-buffer should make new windows.  */);
   pop_up_windows = 1;
 
   DEFVAR_INT ("next-screen-context-lines", &next_screen_context_lines,
-    "*Number of lines of continuity when scrolling by screenfuls.");
+              doc: /* *Number of lines of continuity when scrolling by screenfuls.  */);
   next_screen_context_lines = 2;
 
   DEFVAR_INT ("split-height-threshold", &split_height_threshold,
-    "*display-buffer would prefer to split the largest window if this large.\n\
-If there is only one window, it is split regardless of this value.");
+              doc: /* *display-buffer would prefer to split the largest window if this large.
+If there is only one window, it is split regardless of this value.  */);
   split_height_threshold = 500;
 
   DEFVAR_INT ("window-min-height", &window_min_height,
-    "*Delete any window less than this tall (including its mode line).");
+              doc: /* *Delete any window less than this tall (including its mode line).  */);
   window_min_height = 4;
 
   DEFVAR_INT ("window-min-width", &window_min_width,
-    "*Delete any window less than this wide.");
+              doc: /* *Delete any window less than this wide.  */);
   window_min_width = 10;
 
   DEFVAR_LISP ("scroll-preserve-screen-position",
                &Vscroll_preserve_screen_position,
-    "*Non-nil means scroll commands move point to keep its screen line unchanged.");
+               doc: /* *Non-nil means scroll commands move point to keep its screen line unchanged.  */);
   Vscroll_preserve_screen_position = Qnil;
 
   DEFVAR_LISP ("window-configuration-change-hook",
                &Vwindow_configuration_change_hook,
-    "Functions to call when window configuration changes.\n\
-The selected frame is the one whose configuration has changed.");
+               doc: /* Functions to call when window configuration changes.
+The selected frame is the one whose configuration has changed.  */);
   Vwindow_configuration_change_hook = Qnil;
 
   DEFVAR_BOOL ("window-size-fixed", &window_size_fixed,
-    "Non-nil in a buffer means windows displaying the buffer are fixed-size.\n\
-Emacs won't change the size of any window displaying that buffer,\n\
-unless you explicitly change the size, or Emacs has no other choice.\n\
-This variable automatically becomes buffer-local when set.");
+               doc: /* Non-nil in a buffer means windows displaying the buffer are fixed-size.
+Emacs won't change the size of any window displaying that buffer,
+unless you explicitly change the size, or Emacs has no other choice.
+This variable automatically becomes buffer-local when set.  */);
   Fmake_variable_buffer_local (Qwindow_size_fixed);
   window_size_fixed = 0;