X-Git-Url: https://code.delx.au/gnu-emacs/blobdiff_plain/cb938d466064a865f7b6f9748d44b5f5baccdd6c..b3561514f631090ea1af4b6a04aaa8790654595d:/src/data.c

diff --git a/src/data.c b/src/data.c
index 336afa98d8..266a1946fa 100644
--- a/src/data.c
+++ b/src/data.c
@@ -177,8 +177,8 @@ sign_extend_lisp_int (num)
 /* Data type predicates */
 
 DEFUN ("eq", Feq, Seq, 2, 2, 0,
-  "Return t if the two args are the same Lisp object.")
-  (obj1, obj2)
+       doc: /* Return t if the two args are the same Lisp object.  */)
+     (obj1, obj2)
      Lisp_Object obj1, obj2;
 {
   if (EQ (obj1, obj2))
@@ -186,8 +186,9 @@ DEFUN ("eq", Feq, Seq, 2, 2, 0,
   return Qnil;
 }
 
-DEFUN ("null", Fnull, Snull, 1, 1, 0, "Return t if OBJECT is nil.")
-  (object)
+DEFUN ("null", Fnull, Snull, 1, 1, 0,
+       doc: /* Return t if OBJECT is nil.  */)
+     (object)
      Lisp_Object object;
 {
   if (NILP (object))
@@ -196,10 +197,10 @@ DEFUN ("null", Fnull, Snull, 1, 1, 0, "Return t if OBJECT is nil.")
 }
 
 DEFUN ("type-of", Ftype_of, Stype_of, 1, 1, 0,
-  "Return a symbol representing the type of OBJECT.\n\
-The symbol returned names the object's basic type;\n\
-for example, (type-of 1) returns `integer'.")
-  (object)
+       doc: /* Return a symbol representing the type of OBJECT.
+The symbol returned names the object's basic type;
+for example, (type-of 1) returns `integer'.  */)
+     (object)
      Lisp_Object object;
 {
   switch (XGCTYPE (object))
@@ -259,8 +260,9 @@ for example, (type-of 1) returns `integer'.")
     }
 }
 
-DEFUN ("consp", Fconsp, Sconsp, 1, 1, 0, "Return t if OBJECT is a cons cell.")
-  (object)
+DEFUN ("consp", Fconsp, Sconsp, 1, 1, 0,
+       doc: /* Return t if OBJECT is a cons cell.  */)
+     (object)
      Lisp_Object object;
 {
   if (CONSP (object))
@@ -269,8 +271,8 @@ DEFUN ("consp", Fconsp, Sconsp, 1, 1, 0, "Return t if OBJECT is a cons cell.")
 }
 
 DEFUN ("atom", Fatom, Satom, 1, 1, 0,
-       "Return t if OBJECT is not a cons cell.  This includes nil.")
-  (object)
+       doc: /* Return t if OBJECT is not a cons cell.  This includes nil.  */)
+     (object)
      Lisp_Object object;
 {
   if (CONSP (object))
@@ -279,8 +281,8 @@ DEFUN ("atom", Fatom, Satom, 1, 1, 0,
 }
 
 DEFUN ("listp", Flistp, Slistp, 1, 1, 0,
-       "Return t if OBJECT is a list.  This includes nil.")
-  (object)
+       doc: /* Return t if OBJECT is a list.  This includes nil.  */)
+     (object)
      Lisp_Object object;
 {
   if (CONSP (object) || NILP (object))
@@ -289,8 +291,8 @@ DEFUN ("listp", Flistp, Slistp, 1, 1, 0,
 }
 
 DEFUN ("nlistp", Fnlistp, Snlistp, 1, 1, 0,
-       "Return t if OBJECT is not a list.  Lists include nil.")
-  (object)
+       doc: /* Return t if OBJECT is not a list.  Lists include nil.  */)
+     (object)
      Lisp_Object object;
 {
   if (CONSP (object) || NILP (object))
@@ -299,8 +301,8 @@ DEFUN ("nlistp", Fnlistp, Snlistp, 1, 1, 0,
 }
 
 DEFUN ("symbolp", Fsymbolp, Ssymbolp, 1, 1, 0,
-       "Return t if OBJECT is a symbol.")
-  (object)
+       doc: /* Return t if OBJECT is a symbol.  */)
+     (object)
      Lisp_Object object;
 {
   if (SYMBOLP (object))
@@ -311,10 +313,10 @@ DEFUN ("symbolp", Fsymbolp, Ssymbolp, 1, 1, 0,
 /* Define this in C to avoid unnecessarily consing up the symbol
    name.  */
 DEFUN ("keywordp", Fkeywordp, Skeywordp, 1, 1, 0,
-       "Return t if OBJECT is a keyword.\n\
-This means that it is a symbol with a print name beginning with `:'\n\
-interned in the initial obarray.")
-  (object)
+       doc: /* Return t if OBJECT is a keyword.
+This means that it is a symbol with a print name beginning with `:'
+interned in the initial obarray.  */)
+     (object)
      Lisp_Object object;
 {
   if (SYMBOLP (object)
@@ -325,8 +327,8 @@ interned in the initial obarray.")
 }
 
 DEFUN ("vectorp", Fvectorp, Svectorp, 1, 1, 0,
-       "Return t if OBJECT is a vector.")
-  (object)
+       doc: /* Return t if OBJECT is a vector.  */)
+     (object)
      Lisp_Object object;
 {
   if (VECTORP (object))
@@ -335,8 +337,8 @@ DEFUN ("vectorp", Fvectorp, Svectorp, 1, 1, 0,
 }
 
 DEFUN ("stringp", Fstringp, Sstringp, 1, 1, 0,
-       "Return t if OBJECT is a string.")
-  (object)
+       doc: /* Return t if OBJECT is a string.  */)
+     (object)
      Lisp_Object object;
 {
   if (STRINGP (object))
@@ -345,8 +347,9 @@ DEFUN ("stringp", Fstringp, Sstringp, 1, 1, 0,
 }
 
 DEFUN ("multibyte-string-p", Fmultibyte_string_p, Smultibyte_string_p,
-       1, 1, 0, "Return t if OBJECT is a multibyte string.")
-  (object)
+       1, 1, 0,
+       doc: /* Return t if OBJECT is a multibyte string.  */)
+     (object)
      Lisp_Object object;
 {
   if (STRINGP (object) && STRING_MULTIBYTE (object))
@@ -355,8 +358,8 @@ DEFUN ("multibyte-string-p", Fmultibyte_string_p, Smultibyte_string_p,
 }
 
 DEFUN ("char-table-p", Fchar_table_p, Schar_table_p, 1, 1, 0,
-       "Return t if OBJECT is a char-table.")
-  (object)
+       doc: /* Return t if OBJECT is a char-table.  */)
+     (object)
      Lisp_Object object;
 {
   if (CHAR_TABLE_P (object))
@@ -366,8 +369,8 @@ DEFUN ("char-table-p", Fchar_table_p, Schar_table_p, 1, 1, 0,
 
 DEFUN ("vector-or-char-table-p", Fvector_or_char_table_p,
        Svector_or_char_table_p, 1, 1, 0,
-       "Return t if OBJECT is a char-table or vector.")
-  (object)
+       doc: /* Return t if OBJECT is a char-table or vector.  */)
+     (object)
      Lisp_Object object;
 {
   if (VECTORP (object) || CHAR_TABLE_P (object))
@@ -375,8 +378,9 @@ DEFUN ("vector-or-char-table-p", Fvector_or_char_table_p,
   return Qnil;
 }
 
-DEFUN ("bool-vector-p", Fbool_vector_p, Sbool_vector_p, 1, 1, 0, "Return t if OBJECT is a bool-vector.")
-  (object)
+DEFUN ("bool-vector-p", Fbool_vector_p, Sbool_vector_p, 1, 1, 0,
+       doc: /* Return t if OBJECT is a bool-vector.  */)
+     (object)
      Lisp_Object object;
 {
   if (BOOL_VECTOR_P (object))
@@ -384,8 +388,9 @@ DEFUN ("bool-vector-p", Fbool_vector_p, Sbool_vector_p, 1, 1, 0, "Return t if OB
   return Qnil;
 }
 
-DEFUN ("arrayp", Farrayp, Sarrayp, 1, 1, 0, "Return t if OBJECT is an array (string or vector).")
-  (object)
+DEFUN ("arrayp", Farrayp, Sarrayp, 1, 1, 0,
+       doc: /* Return t if OBJECT is an array (string or vector).  */)
+     (object)
      Lisp_Object object;
 {
   if (VECTORP (object) || STRINGP (object)
@@ -395,8 +400,8 @@ DEFUN ("arrayp", Farrayp, Sarrayp, 1, 1, 0, "Return t if OBJECT is an array (str
 }
 
 DEFUN ("sequencep", Fsequencep, Ssequencep, 1, 1, 0,
-  "Return t if OBJECT is a sequence (list or array).")
-  (object)
+       doc: /* Return t if OBJECT is a sequence (list or array).  */)
+     (object)
      register Lisp_Object object;
 {
   if (CONSP (object) || NILP (object) || VECTORP (object) || STRINGP (object)
@@ -405,8 +410,9 @@ DEFUN ("sequencep", Fsequencep, Ssequencep, 1, 1, 0,
   return Qnil;
 }
 
-DEFUN ("bufferp", Fbufferp, Sbufferp, 1, 1, 0, "Return t if OBJECT is an editor buffer.")
-  (object)
+DEFUN ("bufferp", Fbufferp, Sbufferp, 1, 1, 0,
+       doc: /* Return t if OBJECT is an editor buffer.  */)
+     (object)
      Lisp_Object object;
 {
   if (BUFFERP (object))
@@ -414,8 +420,9 @@ DEFUN ("bufferp", Fbufferp, Sbufferp, 1, 1, 0, "Return t if OBJECT is an editor
   return Qnil;
 }
 
-DEFUN ("markerp", Fmarkerp, Smarkerp, 1, 1, 0, "Return t if OBJECT is a marker (editor pointer).")
-  (object)
+DEFUN ("markerp", Fmarkerp, Smarkerp, 1, 1, 0,
+       doc: /* Return t if OBJECT is a marker (editor pointer).  */)
+     (object)
      Lisp_Object object;
 {
   if (MARKERP (object))
@@ -423,8 +430,9 @@ DEFUN ("markerp", Fmarkerp, Smarkerp, 1, 1, 0, "Return t if OBJECT is a marker (
   return Qnil;
 }
 
-DEFUN ("subrp", Fsubrp, Ssubrp, 1, 1, 0, "Return t if OBJECT is a built-in function.")
-  (object)
+DEFUN ("subrp", Fsubrp, Ssubrp, 1, 1, 0,
+       doc: /* Return t if OBJECT is a built-in function.  */)
+     (object)
      Lisp_Object object;
 {
   if (SUBRP (object))
@@ -433,8 +441,9 @@ DEFUN ("subrp", Fsubrp, Ssubrp, 1, 1, 0, "Return t if OBJECT is a built-in funct
 }
 
 DEFUN ("byte-code-function-p", Fbyte_code_function_p, Sbyte_code_function_p,
-       1, 1, 0, "Return t if OBJECT is a byte-compiled function object.")
-  (object)
+       1, 1, 0,
+       doc: /* Return t if OBJECT is a byte-compiled function object.  */)
+     (object)
      Lisp_Object object;
 {
   if (COMPILEDP (object))
@@ -443,8 +452,8 @@ DEFUN ("byte-code-function-p", Fbyte_code_function_p, Sbyte_code_function_p,
 }
 
 DEFUN ("char-or-string-p", Fchar_or_string_p, Schar_or_string_p, 1, 1, 0,
-  "Return t if OBJECT is a character (an integer) or a string.")
-  (object)
+       doc: /* Return t if OBJECT is a character (an integer) or a string.  */)
+     (object)
      register Lisp_Object object;
 {
   if (INTEGERP (object) || STRINGP (object))
@@ -452,8 +461,9 @@ DEFUN ("char-or-string-p", Fchar_or_string_p, Schar_or_string_p, 1, 1, 0,
   return Qnil;
 }
 
-DEFUN ("integerp", Fintegerp, Sintegerp, 1, 1, 0, "Return t if OBJECT is an integer.")
-  (object)
+DEFUN ("integerp", Fintegerp, Sintegerp, 1, 1, 0,
+       doc: /* Return t if OBJECT is an integer.  */)
+     (object)
      Lisp_Object object;
 {
   if (INTEGERP (object))
@@ -462,8 +472,8 @@ DEFUN ("integerp", Fintegerp, Sintegerp, 1, 1, 0, "Return t if OBJECT is an inte
 }
 
 DEFUN ("integer-or-marker-p", Finteger_or_marker_p, Sinteger_or_marker_p, 1, 1, 0,
-  "Return t if OBJECT is an integer or a marker (editor pointer).")
-  (object)
+       doc: /* Return t if OBJECT is an integer or a marker (editor pointer).  */)
+     (object)
      register Lisp_Object object;
 {
   if (MARKERP (object) || INTEGERP (object))
@@ -472,8 +482,8 @@ DEFUN ("integer-or-marker-p", Finteger_or_marker_p, Sinteger_or_marker_p, 1, 1,
 }
 
 DEFUN ("natnump", Fnatnump, Snatnump, 1, 1, 0,
-  "Return t if OBJECT is a nonnegative integer.")
-  (object)
+       doc: /* Return t if OBJECT is a nonnegative integer.  */)
+     (object)
      Lisp_Object object;
 {
   if (NATNUMP (object))
@@ -482,8 +492,8 @@ DEFUN ("natnump", Fnatnump, Snatnump, 1, 1, 0,
 }
 
 DEFUN ("numberp", Fnumberp, Snumberp, 1, 1, 0,
-       "Return t if OBJECT is a number (floating point or integer).")
-  (object)
+       doc: /* Return t if OBJECT is a number (floating point or integer).  */)
+     (object)
      Lisp_Object object;
 {
   if (NUMBERP (object))
@@ -494,8 +504,8 @@ DEFUN ("numberp", Fnumberp, Snumberp, 1, 1, 0,
 
 DEFUN ("number-or-marker-p", Fnumber_or_marker_p,
        Snumber_or_marker_p, 1, 1, 0,
-       "Return t if OBJECT is a number or a marker.")
-  (object)
+       doc: /* Return t if OBJECT is a number or a marker.  */)
+     (object)
      Lisp_Object object;
 {
   if (NUMBERP (object) || MARKERP (object))
@@ -504,8 +514,8 @@ DEFUN ("number-or-marker-p", Fnumber_or_marker_p,
 }
 
 DEFUN ("floatp", Ffloatp, Sfloatp, 1, 1, 0,
-       "Return t if OBJECT is a floating point number.")
-  (object)
+       doc: /* Return t if OBJECT is a floating point number.  */)
+     (object)
      Lisp_Object object;
 {
   if (FLOATP (object))
@@ -517,9 +527,9 @@ DEFUN ("floatp", Ffloatp, Sfloatp, 1, 1, 0,
 /* Extract and set components of lists */
 
 DEFUN ("car", Fcar, Scar, 1, 1, 0,
-  "Return the car of LIST.  If arg is nil, return nil.\n\
-Error if arg is not nil and not a cons cell.  See also `car-safe'.")
-  (list)
+       doc: /* Return the car of LIST.  If arg is nil, return nil.
+Error if arg is not nil and not a cons cell.  See also `car-safe'.  */)
+     (list)
      register Lisp_Object list;
 {
   while (1)
@@ -534,8 +544,8 @@ Error if arg is not nil and not a cons cell.  See also `car-safe'.")
 }
 
 DEFUN ("car-safe", Fcar_safe, Scar_safe, 1, 1, 0,
-  "Return the car of OBJECT if it is a cons cell, or else nil.")
-  (object)
+       doc: /* Return the car of OBJECT if it is a cons cell, or else nil.  */)
+     (object)
      Lisp_Object object;
 {
   if (CONSP (object))
@@ -545,10 +555,9 @@ DEFUN ("car-safe", Fcar_safe, Scar_safe, 1, 1, 0,
 }
 
 DEFUN ("cdr", Fcdr, Scdr, 1, 1, 0,
-  "Return the cdr of LIST.  If arg is nil, return nil.\n\
-Error if arg is not nil and not a cons cell.  See also `cdr-safe'.")
-
-  (list)
+       doc: /* Return the cdr of LIST.  If arg is nil, return nil.
+Error if arg is not nil and not a cons cell.  See also `cdr-safe'.  */)
+     (list)
      register Lisp_Object list;
 {
   while (1)
@@ -563,8 +572,8 @@ Error if arg is not nil and not a cons cell.  See also `cdr-safe'.")
 }
 
 DEFUN ("cdr-safe", Fcdr_safe, Scdr_safe, 1, 1, 0,
-  "Return the cdr of OBJECT if it is a cons cell, or else nil.")
-  (object)
+       doc: /* Return the cdr of OBJECT if it is a cons cell, or else nil.  */)
+     (object)
      Lisp_Object object;
 {
   if (CONSP (object))
@@ -574,39 +583,40 @@ DEFUN ("cdr-safe", Fcdr_safe, Scdr_safe, 1, 1, 0,
 }
 
 DEFUN ("setcar", Fsetcar, Ssetcar, 2, 2, 0,
-  "Set the car of CELL to be NEWCAR.  Returns NEWCAR.")
-  (cell, newcar)
+       doc: /* Set the car of CELL to be NEWCAR.  Returns NEWCAR.  */)
+     (cell, newcar)
      register Lisp_Object cell, newcar;
 {
   if (!CONSP (cell))
     cell = wrong_type_argument (Qconsp, cell);
 
   CHECK_IMPURE (cell);
-  XCAR (cell) = newcar;
+  XSETCAR (cell, newcar);
   return newcar;
 }
 
 DEFUN ("setcdr", Fsetcdr, Ssetcdr, 2, 2, 0,
-  "Set the cdr of CELL to be NEWCDR.  Returns NEWCDR.")
-  (cell, newcdr)
+       doc: /* Set the cdr of CELL to be NEWCDR.  Returns NEWCDR.  */)
+     (cell, newcdr)
      register Lisp_Object cell, newcdr;
 {
   if (!CONSP (cell))
     cell = wrong_type_argument (Qconsp, cell);
 
   CHECK_IMPURE (cell);
-  XCDR (cell) = newcdr;
+  XSETCDR (cell, newcdr);
   return newcdr;
 }
 
 /* Extract and set components of symbols */
 
-DEFUN ("boundp", Fboundp, Sboundp, 1, 1, 0, "Return t if SYMBOL's value is not void.")
-  (symbol)
+DEFUN ("boundp", Fboundp, Sboundp, 1, 1, 0,
+       doc: /* Return t if SYMBOL's value is not void.  */)
+     (symbol)
      register Lisp_Object symbol;
 {
   Lisp_Object valcontents;
-  CHECK_SYMBOL (symbol, 0);
+  CHECK_SYMBOL (symbol);
 
   valcontents = SYMBOL_VALUE (symbol);
 
@@ -617,30 +627,33 @@ DEFUN ("boundp", Fboundp, Sboundp, 1, 1, 0, "Return t if SYMBOL's value is not v
   return (EQ (valcontents, Qunbound) ? Qnil : Qt);
 }
 
-DEFUN ("fboundp", Ffboundp, Sfboundp, 1, 1, 0, "Return t if SYMBOL's function definition is not void.")
-  (symbol)
+DEFUN ("fboundp", Ffboundp, Sfboundp, 1, 1, 0,
+       doc: /* Return t if SYMBOL's function definition is not void.  */)
+     (symbol)
      register Lisp_Object symbol;
 {
-  CHECK_SYMBOL (symbol, 0);
+  CHECK_SYMBOL (symbol);
   return (EQ (XSYMBOL (symbol)->function, Qunbound) ? Qnil : Qt);
 }
 
-DEFUN ("makunbound", Fmakunbound, Smakunbound, 1, 1, 0, "Make SYMBOL's value be void.")
-  (symbol)
+DEFUN ("makunbound", Fmakunbound, Smakunbound, 1, 1, 0,
+       doc: /* Make SYMBOL's value be void.  */)
+     (symbol)
      register Lisp_Object symbol;
 {
-  CHECK_SYMBOL (symbol, 0);
+  CHECK_SYMBOL (symbol);
   if (XSYMBOL (symbol)->constant)
     return Fsignal (Qsetting_constant, Fcons (symbol, Qnil));
   Fset (symbol, Qunbound);
   return symbol;
 }
 
-DEFUN ("fmakunbound", Ffmakunbound, Sfmakunbound, 1, 1, 0, "Make SYMBOL's function definition be void.")
-  (symbol)
+DEFUN ("fmakunbound", Ffmakunbound, Sfmakunbound, 1, 1, 0,
+       doc: /* Make SYMBOL's function definition be void.  */)
+     (symbol)
      register Lisp_Object symbol;
 {
-  CHECK_SYMBOL (symbol, 0);
+  CHECK_SYMBOL (symbol);
   if (NILP (symbol) || EQ (symbol, Qt))
     return Fsignal (Qsetting_constant, Fcons (symbol, Qnil));
   XSYMBOL (symbol)->function = Qunbound;
@@ -648,41 +661,43 @@ DEFUN ("fmakunbound", Ffmakunbound, Sfmakunbound, 1, 1, 0, "Make SYMBOL's functi
 }
 
 DEFUN ("symbol-function", Fsymbol_function, Ssymbol_function, 1, 1, 0,
-  "Return SYMBOL's function definition.  Error if that is void.")
-  (symbol)
+       doc: /* Return SYMBOL's function definition.  Error if that is void.  */)
+     (symbol)
      register Lisp_Object symbol;
 {
-  CHECK_SYMBOL (symbol, 0);
+  CHECK_SYMBOL (symbol);
   if (EQ (XSYMBOL (symbol)->function, Qunbound))
     return Fsignal (Qvoid_function, Fcons (symbol, Qnil));
   return XSYMBOL (symbol)->function;
 }
 
-DEFUN ("symbol-plist", Fsymbol_plist, Ssymbol_plist, 1, 1, 0, "Return SYMBOL's property list.")
-  (symbol)
+DEFUN ("symbol-plist", Fsymbol_plist, Ssymbol_plist, 1, 1, 0,
+       doc: /* Return SYMBOL's property list.  */)
+     (symbol)
      register Lisp_Object symbol;
 {
-  CHECK_SYMBOL (symbol, 0);
+  CHECK_SYMBOL (symbol);
   return XSYMBOL (symbol)->plist;
 }
 
-DEFUN ("symbol-name", Fsymbol_name, Ssymbol_name, 1, 1, 0, "Return SYMBOL's name, a string.")
-  (symbol)
+DEFUN ("symbol-name", Fsymbol_name, Ssymbol_name, 1, 1, 0,
+       doc: /* Return SYMBOL's name, a string.  */)
+     (symbol)
      register Lisp_Object symbol;
 {
   register Lisp_Object name;
 
-  CHECK_SYMBOL (symbol, 0);
+  CHECK_SYMBOL (symbol);
   XSETSTRING (name, XSYMBOL (symbol)->name);
   return name;
 }
 
 DEFUN ("fset", Ffset, Sfset, 2, 2, 0,
-  "Set SYMBOL's function definition to DEFINITION, and return DEFINITION.")
-  (symbol, definition)
+       doc: /* Set SYMBOL's function definition to DEFINITION, and return DEFINITION.  */)
+     (symbol, definition)
      register Lisp_Object symbol, definition;
 {
-  CHECK_SYMBOL (symbol, 0);
+  CHECK_SYMBOL (symbol);
   if (NILP (symbol) || EQ (symbol, Qt))
     return Fsignal (Qsetting_constant, Fcons (symbol, Qnil));
   if (!NILP (Vautoload_queue) && !EQ (XSYMBOL (symbol)->function, Qunbound))
@@ -699,9 +714,9 @@ DEFUN ("fset", Ffset, Sfset, 2, 2, 0,
 }
 
 DEFUN ("defalias", Fdefalias, Sdefalias, 2, 2, 0,
-  "Set SYMBOL's function definition to DEFINITION, and return DEFINITION.\n\
-Associates the function with the current load file, if any.")
-  (symbol, definition)
+       doc: /* Set SYMBOL's function definition to DEFINITION, and return DEFINITION.
+Associates the function with the current load file, if any.  */)
+     (symbol, definition)
      register Lisp_Object symbol, definition;
 {
   definition = Ffset (symbol, definition);
@@ -710,22 +725,22 @@ Associates the function with the current load file, if any.")
 }
 
 DEFUN ("setplist", Fsetplist, Ssetplist, 2, 2, 0,
-  "Set SYMBOL's property list to NEWVAL, and return NEWVAL.")
-  (symbol, newplist)
+       doc: /* Set SYMBOL's property list to NEWVAL, and return NEWVAL.  */)
+     (symbol, newplist)
      register Lisp_Object symbol, newplist;
 {
-  CHECK_SYMBOL (symbol, 0);
+  CHECK_SYMBOL (symbol);
   XSYMBOL (symbol)->plist = newplist;
   return newplist;
 }
 
 DEFUN ("subr-arity", Fsubr_arity, Ssubr_arity, 1, 1, 0,
-  "Return minimum and maximum number of args allowed for SUBR.\n\
-SUBR must be a built-in function.\n\
-The returned value is a pair (MIN . MAX).  MIN is the minimum number\n\
-of args.  MAX is the maximum number or the symbol `many', for a\n\
-function with `&rest' args, or `unevalled' for a special form.")
-  (subr)
+       doc: /* Return minimum and maximum number of args allowed for SUBR.
+SUBR must be a built-in function.
+The returned value is a pair (MIN . MAX).  MIN is the minimum number
+of args.  MAX is the maximum number or the symbol `many', for a
+function with `&rest' args, or `unevalled' for a special form.  */)
+     (subr)
      Lisp_Object subr;
 {
   short minargs, maxargs;
@@ -742,10 +757,10 @@ function with `&rest' args, or `unevalled' for a special form.")
 }
 
 DEFUN ("subr-interactive-form", Fsubr_interactive_form, Ssubr_interactive_form, 1, 1, 0,
-  "Return the interactive form of SUBR or nil if none.\n\
-SUBR must be a built-in function.  Value, if non-nil, is a list\n\
-\(interactive SPEC).")
-  (subr)
+       doc: /* Return the interactive form of SUBR or nil if none.
+SUBR must be a built-in function.  Value, if non-nil, is a list
+\(interactive SPEC).  */)
+     (subr)
      Lisp_Object subr;
 {
   if (!SUBRP (subr))
@@ -790,12 +805,12 @@ indirect_variable (symbol)
 
 
 DEFUN ("indirect-variable", Findirect_variable, Sindirect_variable, 1, 1, 0,
-  "Return the variable at the end of OBJECT's variable chain.\n\
-If OBJECT is a symbol, follow all variable indirections and return the final\n\
-variable.  If OBJECT is not a symbol, just return it.\n\
-Signal a cyclic-variable-indirection error if there is a loop in the\n\
-variable chain of symbols.")
-  (object)
+       doc: /* Return the variable at the end of OBJECT's variable chain.
+If OBJECT is a symbol, follow all variable indirections and return the final
+variable.  If OBJECT is not a symbol, just return it.
+Signal a cyclic-variable-indirection error if there is a loop in the
+variable chain of symbols.  */)
+     (object)
      Lisp_Object object;
 {
   if (SYMBOLP (object))
@@ -859,7 +874,7 @@ store_symval_forwarding (symbol, valcontents, newval, buf)
       switch (XMISCTYPE (valcontents))
 	{
 	case Lisp_Misc_Intfwd:
-	  CHECK_NUMBER (newval, 1);
+	  CHECK_NUMBER (newval);
 	  *XINTFWD (valcontents)->intvar = XINT (newval);
 	  if (*XINTFWD (valcontents)->intvar != XINT (newval))
 	    error ("Value out of range for variable `%s'",
@@ -937,7 +952,7 @@ swap_in_global_binding (symbol)
 	   do_symval_forwarding (XBUFFER_LOCAL_VALUE (valcontents)->realvalue));
   
   /* Select the global binding in the symbol.  */
-  XCAR (cdr) = cdr;
+  XSETCAR (cdr, cdr);
   store_symval_forwarding (symbol, valcontents, XCDR (cdr), NULL);
 
   /* Indicate that the global binding is set up now.  */
@@ -991,7 +1006,7 @@ swap_in_symval_forwarding (symbol, valcontents)
 	XBUFFER_LOCAL_VALUE (valcontents)->found_for_buffer = 1;
 
       /* Load the new binding.  */
-      XCAR (XBUFFER_LOCAL_VALUE (valcontents)->cdr) = tem1;
+      XSETCAR (XBUFFER_LOCAL_VALUE (valcontents)->cdr, tem1);
       XSETBUFFER (XBUFFER_LOCAL_VALUE (valcontents)->buffer, current_buffer);
       XBUFFER_LOCAL_VALUE (valcontents)->frame = selected_frame;
       store_symval_forwarding (symbol,
@@ -1014,7 +1029,7 @@ find_symbol_value (symbol)
   register Lisp_Object valcontents;
   register Lisp_Object val;
   
-  CHECK_SYMBOL (symbol, 0);
+  CHECK_SYMBOL (symbol);
   valcontents = SYMBOL_VALUE (symbol);
 
   if (BUFFER_LOCAL_VALUEP (valcontents)
@@ -1049,8 +1064,8 @@ find_symbol_value (symbol)
 }
 
 DEFUN ("symbol-value", Fsymbol_value, Ssymbol_value, 1, 1, 0,
-  "Return SYMBOL's value.  Error if that is void.")
-  (symbol)
+       doc: /* Return SYMBOL's value.  Error if that is void.  */)
+     (symbol)
      Lisp_Object symbol;
 {
   Lisp_Object val;
@@ -1063,8 +1078,8 @@ DEFUN ("symbol-value", Fsymbol_value, Ssymbol_value, 1, 1, 0,
 }
 
 DEFUN ("set", Fset, Sset, 2, 2, 0,
-  "Set SYMBOL's value to NEWVAL, and return NEWVAL.")
-  (symbol, newval)
+       doc: /* Set SYMBOL's value to NEWVAL, and return NEWVAL.  */)
+     (symbol, newval)
      register Lisp_Object symbol, newval;
 {
   return set_internal (symbol, newval, current_buffer, 0);
@@ -1119,7 +1134,7 @@ set_internal (symbol, newval, buf, bindflag)
   if (NILP (buf->name))
     return newval;
 
-  CHECK_SYMBOL (symbol, 0);
+  CHECK_SYMBOL (symbol);
   if (SYMBOL_CONSTANT_P (symbol)
       && (NILP (Fkeywordp (symbol))
 	  || !EQ (newval, SYMBOL_VALUE (symbol))))
@@ -1210,8 +1225,8 @@ set_internal (symbol, newval, buf, bindflag)
 	    }
 
 	  /* Record which binding is now loaded.  */
-	  XCAR (XBUFFER_LOCAL_VALUE (valcontents)->cdr)
-	    = tem1;
+	  XSETCAR (XBUFFER_LOCAL_VALUE (valcontents)->cdr,
+		   tem1);
 
 	  /* Set `buffer' and `frame' slots for thebinding now loaded.  */
 	  XSETBUFFER (XBUFFER_LOCAL_VALUE (valcontents)->buffer, buf);
@@ -1243,7 +1258,7 @@ set_internal (symbol, newval, buf, bindflag)
 	 the default binding is loaded, the loaded binding may be the
 	 wrong one.  */
       if (XBUFFER_LOCAL_VALUE (valcontents)->found_for_frame)
-	XCDR (current_alist_element) = newval;
+	XSETCDR (current_alist_element, newval);
     }
 
   return newval;
@@ -1260,7 +1275,7 @@ default_value (symbol)
 {
   register Lisp_Object valcontents;
 
-  CHECK_SYMBOL (symbol, 0);
+  CHECK_SYMBOL (symbol);
   valcontents = SYMBOL_VALUE (symbol);
 
   /* For a built-in buffer-local variable, get the default value
@@ -1294,10 +1309,10 @@ default_value (symbol)
 }
 
 DEFUN ("default-boundp", Fdefault_boundp, Sdefault_boundp, 1, 1, 0,
-  "Return t if SYMBOL has a non-void default value.\n\
-This is the value that is seen in buffers that do not have their own values\n\
-for this variable.")
-  (symbol)
+       doc: /* Return t if SYMBOL has a non-void default value.
+This is the value that is seen in buffers that do not have their own values
+for this variable.  */)
+     (symbol)
      Lisp_Object symbol;
 {
   register Lisp_Object value;
@@ -1307,11 +1322,11 @@ for this variable.")
 }
 
 DEFUN ("default-value", Fdefault_value, Sdefault_value, 1, 1, 0,
-  "Return SYMBOL's default value.\n\
-This is the value that is seen in buffers that do not have their own values\n\
-for this variable.  The default value is meaningful for variables with\n\
-local bindings in certain buffers.")
-  (symbol)
+       doc: /* Return SYMBOL's default value.
+This is the value that is seen in buffers that do not have their own values
+for this variable.  The default value is meaningful for variables with
+local bindings in certain buffers.  */)
+     (symbol)
      Lisp_Object symbol;
 {
   register Lisp_Object value;
@@ -1323,15 +1338,15 @@ local bindings in certain buffers.")
 }
 
 DEFUN ("set-default", Fset_default, Sset_default, 2, 2, 0,
-  "Set SYMBOL's default value to VAL.  SYMBOL and VAL are evaluated.\n\
-The default value is seen in buffers that do not have their own values\n\
-for this variable.")
-  (symbol, value)
+       doc: /* Set SYMBOL's default value to VAL.  SYMBOL and VAL are evaluated.
+The default value is seen in buffers that do not have their own values
+for this variable.  */)
+     (symbol, value)
      Lisp_Object symbol, value;
 {
   register Lisp_Object valcontents, current_alist_element, alist_element_buffer;
 
-  CHECK_SYMBOL (symbol, 0);
+  CHECK_SYMBOL (symbol);
   valcontents = SYMBOL_VALUE (symbol);
 
   /* Handle variables like case-fold-search that have special slots
@@ -1362,7 +1377,7 @@ for this variable.")
     return Fset (symbol, value);
 
   /* Store new value into the DEFAULT-VALUE slot.  */
-  XCDR (XBUFFER_LOCAL_VALUE (valcontents)->cdr) = value;
+  XSETCDR (XBUFFER_LOCAL_VALUE (valcontents)->cdr, value);
 
   /* If the default binding is now loaded, set the REALVALUE slot too.  */
   current_alist_element
@@ -1377,18 +1392,19 @@ for this variable.")
 }
 
 DEFUN ("setq-default", Fsetq_default, Ssetq_default, 2, UNEVALLED, 0,
-       "Set the default value of variable VAR to VALUE.\n\
-VAR, the variable name, is literal (not evaluated);\n\
-VALUE is an expression and it is evaluated.\n\
-The default value of a variable is seen in buffers\n\
-that do not have their own values for the variable.\n\
-\n\
-More generally, you can use multiple variables and values, as in\n\
-  (setq-default SYMBOL VALUE SYMBOL VALUE...)\n\
-This sets each SYMBOL's default value to the corresponding VALUE.\n\
-The VALUE for the Nth SYMBOL can refer to the new default values\n\
-of previous SYMs.")
-  (args)
+       doc: /* Set the default value of variable VAR to VALUE.
+VAR, the variable name, is literal (not evaluated);
+VALUE is an expression and it is evaluated.
+The default value of a variable is seen in buffers
+that do not have their own values for the variable.
+
+More generally, you can use multiple variables and values, as in
+  (setq-default SYMBOL VALUE SYMBOL VALUE...)
+This sets each SYMBOL's default value to the corresponding VALUE.
+The VALUE for the Nth SYMBOL can refer to the new default values
+of previous SYMs.
+usage: (setq-default SYMBOL VALUE [SYMBOL VALUE...])  */)
+     (args)
      Lisp_Object args;
 {
   register Lisp_Object args_left;
@@ -1417,22 +1433,22 @@ of previous SYMs.")
 /* Lisp functions for creating and removing buffer-local variables.  */
 
 DEFUN ("make-variable-buffer-local", Fmake_variable_buffer_local, Smake_variable_buffer_local,
-  1, 1, "vMake Variable Buffer Local: ",
-  "Make VARIABLE become buffer-local whenever it is set.\n\
-At any time, the value for the current buffer is in effect,\n\
-unless the variable has never been set in this buffer,\n\
-in which case the default value is in effect.\n\
-Note that binding the variable with `let', or setting it while\n\
-a `let'-style binding made in this buffer is in effect,\n\
-does not make the variable buffer-local.\n\
-\n\
-The function `default-value' gets the default value and `set-default' sets it.")
-  (variable)
+       1, 1, "vMake Variable Buffer Local: ",
+       doc: /* Make VARIABLE become buffer-local whenever it is set.
+At any time, the value for the current buffer is in effect,
+unless the variable has never been set in this buffer,
+in which case the default value is in effect.
+Note that binding the variable with `let', or setting it while
+a `let'-style binding made in this buffer is in effect,
+does not make the variable buffer-local.
+
+The function `default-value' gets the default value and `set-default' sets it.  */)
+     (variable)
      register Lisp_Object variable;
 {
   register Lisp_Object tem, valcontents, newval;
 
-  CHECK_SYMBOL (variable, 0);
+  CHECK_SYMBOL (variable);
 
   valcontents = SYMBOL_VALUE (variable);
   if (EQ (variable, Qnil) || EQ (variable, Qt) || KBOARD_OBJFWDP (valcontents))
@@ -1448,7 +1464,7 @@ The function `default-value' gets the default value and `set-default' sets it.")
   if (EQ (valcontents, Qunbound))
     SET_SYMBOL_VALUE (variable, Qnil);
   tem = Fcons (Qnil, Fsymbol_value (variable));
-  XCAR (tem) = tem;
+  XSETCAR (tem, tem);
   newval = allocate_misc ();
   XMISCTYPE (newval) = Lisp_Misc_Buffer_Local_Value;
   XBUFFER_LOCAL_VALUE (newval)->realvalue = SYMBOL_VALUE (variable);
@@ -1463,29 +1479,29 @@ The function `default-value' gets the default value and `set-default' sets it.")
 }
 
 DEFUN ("make-local-variable", Fmake_local_variable, Smake_local_variable,
-  1, 1, "vMake Local Variable: ",
-  "Make VARIABLE have a separate value in the current buffer.\n\
-Other buffers will continue to share a common default value.\n\
-\(The buffer-local value of VARIABLE starts out as the same value\n\
-VARIABLE previously had.  If VARIABLE was void, it remains void.\)\n\
-See also `make-variable-buffer-local'.\n\
-\n\
-If the variable is already arranged to become local when set,\n\
-this function causes a local value to exist for this buffer,\n\
-just as setting the variable would do.\n\
-\n\
-This function returns VARIABLE, and therefore\n\
-  (set (make-local-variable 'VARIABLE) VALUE-EXP)\n\
-works.\n\
-\n\
-Do not use `make-local-variable' to make a hook variable buffer-local.\n\
-Use `make-local-hook' instead.")
-  (variable)
+       1, 1, "vMake Local Variable: ",
+       doc: /* Make VARIABLE have a separate value in the current buffer.
+Other buffers will continue to share a common default value.
+\(The buffer-local value of VARIABLE starts out as the same value
+VARIABLE previously had.  If VARIABLE was void, it remains void.\)
+See also `make-variable-buffer-local'.
+
+If the variable is already arranged to become local when set,
+this function causes a local value to exist for this buffer,
+just as setting the variable would do.
+
+This function returns VARIABLE, and therefore
+  (set (make-local-variable 'VARIABLE) VALUE-EXP)
+works.
+
+Do not use `make-local-variable' to make a hook variable buffer-local.
+Instead, use `add-hook' and specify t for the LOCAL argument.  */)
+     (variable)
      register Lisp_Object variable;
 {
   register Lisp_Object tem, valcontents;
 
-  CHECK_SYMBOL (variable, 0);
+  CHECK_SYMBOL (variable);
 
   valcontents = SYMBOL_VALUE (variable);
   if (EQ (variable, Qnil) || EQ (variable, Qt) || KBOARD_OBJFWDP (valcontents))
@@ -1505,7 +1521,7 @@ Use `make-local-hook' instead.")
     {
       Lisp_Object newval;
       tem = Fcons (Qnil, do_symval_forwarding (valcontents));
-      XCAR (tem) = tem;
+      XSETCAR (tem, tem);
       newval = allocate_misc ();
       XMISCTYPE (newval) = Lisp_Misc_Some_Buffer_Local_Value;
       XBUFFER_LOCAL_VALUE (newval)->realvalue = SYMBOL_VALUE (variable);
@@ -1556,15 +1572,15 @@ Use `make-local-hook' instead.")
 }
 
 DEFUN ("kill-local-variable", Fkill_local_variable, Skill_local_variable,
-  1, 1, "vKill Local Variable: ",
-  "Make VARIABLE no longer have a separate value in the current buffer.\n\
-From now on the default value will apply in this buffer.")
-  (variable)
+       1, 1, "vKill Local Variable: ",
+       doc: /* Make VARIABLE no longer have a separate value in the current buffer.
+From now on the default value will apply in this buffer.  */)
+     (variable)
      register Lisp_Object variable;
 {
   register Lisp_Object tem, valcontents;
 
-  CHECK_SYMBOL (variable, 0);
+  CHECK_SYMBOL (variable);
 
   valcontents = SYMBOL_VALUE (variable);
 
@@ -1614,20 +1630,20 @@ From now on the default value will apply in this buffer.")
 /* Lisp functions for creating and removing buffer-local variables.  */
 
 DEFUN ("make-variable-frame-local", Fmake_variable_frame_local, Smake_variable_frame_local,
-  1, 1, "vMake Variable Frame Local: ",
-  "Enable VARIABLE to have frame-local bindings.\n\
-When a frame-local binding exists in the current frame,\n\
-it is in effect whenever the current buffer has no buffer-local binding.\n\
-A frame-local binding is actual a frame parameter value;\n\
-thus, any given frame has a local binding for VARIABLE\n\
-if it has a value for the frame parameter named VARIABLE.\n\
-See `modify-frame-parameters'.")
-  (variable)
+       1, 1, "vMake Variable Frame Local: ",
+       doc: /* Enable VARIABLE to have frame-local bindings.
+When a frame-local binding exists in the current frame,
+it is in effect whenever the current buffer has no buffer-local binding.
+A frame-local binding is actual a frame parameter value;
+thus, any given frame has a local binding for VARIABLE
+if it has a value for the frame parameter named VARIABLE.
+See `modify-frame-parameters'.  */)
+     (variable)
      register Lisp_Object variable;
 {
   register Lisp_Object tem, valcontents, newval;
 
-  CHECK_SYMBOL (variable, 0);
+  CHECK_SYMBOL (variable);
 
   valcontents = SYMBOL_VALUE (variable);
   if (EQ (variable, Qnil) || EQ (variable, Qt) || KBOARD_OBJFWDP (valcontents)
@@ -1644,7 +1660,7 @@ See `modify-frame-parameters'.")
   if (EQ (valcontents, Qunbound))
     SET_SYMBOL_VALUE (variable, Qnil);
   tem = Fcons (Qnil, Fsymbol_value (variable));
-  XCAR (tem) = tem;
+  XSETCAR (tem, tem);
   newval = allocate_misc ();
   XMISCTYPE (newval) = Lisp_Misc_Some_Buffer_Local_Value;
   XBUFFER_LOCAL_VALUE (newval)->realvalue = SYMBOL_VALUE (variable);
@@ -1659,10 +1675,10 @@ See `modify-frame-parameters'.")
 }
 
 DEFUN ("local-variable-p", Flocal_variable_p, Slocal_variable_p,
-  1, 2, 0,
-  "Non-nil if VARIABLE has a local binding in buffer BUFFER.\n\
-BUFFER defaults to the current buffer.")
-  (variable, buffer)
+       1, 2, 0,
+       doc: /* Non-nil if VARIABLE has a local binding in buffer BUFFER.
+BUFFER defaults to the current buffer.  */)
+     (variable, buffer)
      register Lisp_Object variable, buffer;
 {
   Lisp_Object valcontents;
@@ -1672,11 +1688,11 @@ BUFFER defaults to the current buffer.")
     buf = current_buffer;
   else
     {
-      CHECK_BUFFER (buffer, 0);
+      CHECK_BUFFER (buffer);
       buf = XBUFFER (buffer);
     }
 
-  CHECK_SYMBOL (variable, 0);
+  CHECK_SYMBOL (variable);
 
   valcontents = SYMBOL_VALUE (variable);
   if (BUFFER_LOCAL_VALUEP (valcontents)
@@ -1703,10 +1719,10 @@ BUFFER defaults to the current buffer.")
 }
 
 DEFUN ("local-variable-if-set-p", Flocal_variable_if_set_p, Slocal_variable_if_set_p,
-  1, 2, 0,
-  "Non-nil if VARIABLE will be local in buffer BUFFER if it is set there.\n\
-BUFFER defaults to the current buffer.")
-  (variable, buffer)
+       1, 2, 0,
+       doc: /* Non-nil if VARIABLE will be local in buffer BUFFER if it is set there.
+BUFFER defaults to the current buffer.  */)
+     (variable, buffer)
      register Lisp_Object variable, buffer;
 {
   Lisp_Object valcontents;
@@ -1716,11 +1732,11 @@ BUFFER defaults to the current buffer.")
     buf = current_buffer;
   else
     {
-      CHECK_BUFFER (buffer, 0);
+      CHECK_BUFFER (buffer);
       buf = XBUFFER (buffer);
     }
 
-  CHECK_SYMBOL (variable, 0);
+  CHECK_SYMBOL (variable);
 
   valcontents = SYMBOL_VALUE (variable);
 
@@ -1779,15 +1795,15 @@ indirect_function (object)
 }
 
 DEFUN ("indirect-function", Findirect_function, Sindirect_function, 1, 1, 0,
-  "Return the function at the end of OBJECT's function chain.\n\
-If OBJECT is a symbol, follow all function indirections and return the final\n\
-function binding.\n\
-If OBJECT is not a symbol, just return it.\n\
-Signal a void-function error if the final symbol is unbound.\n\
-Signal a cyclic-function-indirection error if there is a loop in the\n\
-function chain of symbols.")
-  (object)
-    register Lisp_Object object;
+       doc: /* Return the function at the end of OBJECT's function chain.
+If OBJECT is a symbol, follow all function indirections and return the final
+function binding.
+If OBJECT is not a symbol, just return it.
+Signal a void-function error if the final symbol is unbound.
+Signal a cyclic-function-indirection error if there is a loop in the
+function chain of symbols.  */)
+     (object)
+     register Lisp_Object object;
 {
   Lisp_Object result;
 
@@ -1801,16 +1817,16 @@ function chain of symbols.")
 /* Extract and set vector and string elements */
 
 DEFUN ("aref", Faref, Saref, 2, 2, 0,
-  "Return the element of ARRAY at index IDX.\n\
-ARRAY may be a vector, a string, a char-table, a bool-vector,\n\
-or a byte-code object.  IDX starts at 0.")
-  (array, idx)
+       doc: /* Return the element of ARRAY at index IDX.
+ARRAY may be a vector, a string, a char-table, a bool-vector,
+or a byte-code object.  IDX starts at 0.  */)
+     (array, idx)
      register Lisp_Object array;
      Lisp_Object idx;
 {
   register int idxval;
 
-  CHECK_NUMBER (idx, 1);
+  CHECK_NUMBER (idx);
   idxval = XINT (idx);
   if (STRINGP (array))
     {
@@ -1932,16 +1948,16 @@ or a byte-code object.  IDX starts at 0.")
 #define MAX_ALLOCA 16*1024
 
 DEFUN ("aset", Faset, Saset, 3, 3, 0,
-  "Store into the element of ARRAY at index IDX the value NEWELT.\n\
-ARRAY may be a vector, a string, a char-table or a bool-vector.\n\
-IDX starts at 0.")
-  (array, idx, newelt)
+       doc: /* Store into the element of ARRAY at index IDX the value NEWELT.
+ARRAY may be a vector, a string, a char-table or a bool-vector.
+IDX starts at 0.  */)
+     (array, idx, newelt)
      register Lisp_Object array;
      Lisp_Object idx, newelt;
 {
   register int idxval;
 
-  CHECK_NUMBER (idx, 1);
+  CHECK_NUMBER (idx);
   idxval = XINT (idx);
   if (!VECTORP (array) && !STRINGP (array) && !BOOL_VECTOR_P (array)
       && ! CHAR_TABLE_P (array))
@@ -2017,7 +2033,7 @@ IDX starts at 0.")
 
       if (idxval < 0 || idxval >= XSTRING (array)->size)
 	args_out_of_range (array, idx);
-      CHECK_NUMBER (newelt, 2);
+      CHECK_NUMBER (newelt);
 
       idxval_byte = string_char_to_byte (array, idxval);
       p1 = &XSTRING (array)->data[idxval_byte];
@@ -2051,7 +2067,7 @@ IDX starts at 0.")
     {
       if (idxval < 0 || idxval >= XSTRING (array)->size)
 	args_out_of_range (array, idx);
-      CHECK_NUMBER (newelt, 2);
+      CHECK_NUMBER (newelt);
 
       if (XINT (newelt) < 0 || SINGLE_BYTE_CHAR_P (XINT (newelt)))
 	XSTRING (array)->data[idxval] = XINT (newelt);
@@ -2104,8 +2120,8 @@ arithcompare (num1, num2, comparison)
   double f1 = 0, f2 = 0;
   int floatp = 0;
 
-  CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (num1, 0);
-  CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (num2, 0);
+  CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (num1);
+  CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (num2);
 
   if (FLOATP (num1) || FLOATP (num2))
     {
@@ -2152,60 +2168,61 @@ arithcompare (num1, num2, comparison)
 }
 
 DEFUN ("=", Feqlsign, Seqlsign, 2, 2, 0,
-  "Return t if two args, both numbers or markers, are equal.")
-  (num1, num2)
+       doc: /* Return t if two args, both numbers or markers, are equal.  */)
+     (num1, num2)
      register Lisp_Object num1, num2;
 {
   return arithcompare (num1, num2, equal);
 }
 
 DEFUN ("<", Flss, Slss, 2, 2, 0,
-  "Return t if first arg is less than second arg.  Both must be numbers or markers.")
-  (num1, num2)
+       doc: /* Return t if first arg is less than second arg.  Both must be numbers or markers.  */)
+     (num1, num2)
      register Lisp_Object num1, num2;
 {
   return arithcompare (num1, num2, less);
 }
 
 DEFUN (">", Fgtr, Sgtr, 2, 2, 0,
-  "Return t if first arg is greater than second arg.  Both must be numbers or markers.")
-  (num1, num2)
+       doc: /* Return t if first arg is greater than second arg.  Both must be numbers or markers.  */)
+     (num1, num2)
      register Lisp_Object num1, num2;
 {
   return arithcompare (num1, num2, grtr);
 }
 
 DEFUN ("<=", Fleq, Sleq, 2, 2, 0,
-  "Return t if first arg is less than or equal to second arg.\n\
-Both must be numbers or markers.")
-  (num1, num2)
+       doc: /* Return t if first arg is less than or equal to second arg.
+Both must be numbers or markers.  */)
+     (num1, num2)
      register Lisp_Object num1, num2;
 {
   return arithcompare (num1, num2, less_or_equal);
 }
 
 DEFUN (">=", Fgeq, Sgeq, 2, 2, 0,
-  "Return t if first arg is greater than or equal to second arg.\n\
-Both must be numbers or markers.")
-  (num1, num2)
+       doc: /* Return t if first arg is greater than or equal to second arg.
+Both must be numbers or markers.  */)
+     (num1, num2)
      register Lisp_Object num1, num2;
 {
   return arithcompare (num1, num2, grtr_or_equal);
 }
 
 DEFUN ("/=", Fneq, Sneq, 2, 2, 0,
-  "Return t if first arg is not equal to second arg.  Both must be numbers or markers.")
-  (num1, num2)
+       doc: /* Return t if first arg is not equal to second arg.  Both must be numbers or markers.  */)
+     (num1, num2)
      register Lisp_Object num1, num2;
 {
   return arithcompare (num1, num2, notequal);
 }
 
-DEFUN ("zerop", Fzerop, Szerop, 1, 1, 0, "Return t if NUMBER is zero.")
-  (number)
+DEFUN ("zerop", Fzerop, Szerop, 1, 1, 0,
+       doc: /* Return t if NUMBER is zero.  */)
+     (number)
      register Lisp_Object number;
 {
-  CHECK_NUMBER_OR_FLOAT (number, 0);
+  CHECK_NUMBER_OR_FLOAT (number);
 
   if (FLOATP (number))
     {
@@ -2249,15 +2266,15 @@ cons_to_long (c)
 }
 
 DEFUN ("number-to-string", Fnumber_to_string, Snumber_to_string, 1, 1, 0,
-  "Convert NUMBER to a string by printing it in decimal.\n\
-Uses a minus sign if negative.\n\
-NUMBER may be an integer or a floating point number.")
-  (number)
+       doc: /* Convert NUMBER to a string by printing it in decimal.
+Uses a minus sign if negative.
+NUMBER may be an integer or a floating point number.  */)
+     (number)
      Lisp_Object number;
 {
   char buffer[VALBITS];
 
-  CHECK_NUMBER_OR_FLOAT (number, 0);
+  CHECK_NUMBER_OR_FLOAT (number);
 
   if (FLOATP (number))
     {
@@ -2298,14 +2315,14 @@ digit_to_number (character, base)
 }    
 
 DEFUN ("string-to-number", Fstring_to_number, Sstring_to_number, 1, 2, 0,
-  "Convert STRING to a number by parsing it as a decimal number.\n\
-This parses both integers and floating point numbers.\n\
-It ignores leading spaces and tabs.\n\
-\n\
-If BASE, interpret STRING as a number in that base.  If BASE isn't\n\
-present, base 10 is used.  BASE must be between 2 and 16 (inclusive).\n\
-If the base used is not 10, floating point is not recognized.")
-   (string, base)
+       doc: /* Convert STRING to a number by parsing it as a decimal number.
+This parses both integers and floating point numbers.
+It ignores leading spaces and tabs.
+
+If BASE, interpret STRING as a number in that base.  If BASE isn't
+present, base 10 is used.  BASE must be between 2 and 16 (inclusive).
+If the base used is not 10, floating point is not recognized.  */)
+     (string, base)
      register Lisp_Object string, base;
 {
   register unsigned char *p;
@@ -2313,13 +2330,13 @@ If the base used is not 10, floating point is not recognized.")
   int sign = 1;
   Lisp_Object val;
 
-  CHECK_STRING (string, 0);
+  CHECK_STRING (string);
 
   if (NILP (base))
     b = 10;
   else
     {
-      CHECK_NUMBER (base, 1);
+      CHECK_NUMBER (base);
       b = XINT (base);
       if (b < 2 || b > 16)
 	Fsignal (Qargs_out_of_range, Fcons (base, Qnil));
@@ -2410,7 +2427,7 @@ arith_driver (code, nargs, args)
     {
       /* Using args[argnum] as argument to CHECK_NUMBER_... */
       val = args[argnum];
-      CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (val, argnum);
+      CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (val);
 
       if (FLOATP (val))
 	return float_arith_driver ((double) accum, argnum, code,
@@ -2479,7 +2496,7 @@ float_arith_driver (accum, argnum, code, nargs, args)
   for (; argnum < nargs; argnum++)
     {
       val = args[argnum];    /* using args[argnum] as argument to CHECK_NUMBER_... */
-      CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (val, argnum);
+      CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (val);
 
       if (FLOATP (val))
 	{
@@ -2531,8 +2548,9 @@ float_arith_driver (accum, argnum, code, nargs, args)
 
 
 DEFUN ("+", Fplus, Splus, 0, MANY, 0,
-  "Return sum of any number of arguments, which are numbers or markers.")
-  (nargs, args)
+       doc: /* Return sum of any number of arguments, which are numbers or markers.
+usage: (+ &rest NUMBERS-OR-MARKERS)  */)
+     (nargs, args)
      int nargs;
      Lisp_Object *args;
 {
@@ -2540,10 +2558,11 @@ DEFUN ("+", Fplus, Splus, 0, MANY, 0,
 }
 
 DEFUN ("-", Fminus, Sminus, 0, MANY, 0,
-  "Negate number or subtract numbers or markers.\n\
-With one arg, negates it.  With more than one arg,\n\
-subtracts all but the first from the first.")
-  (nargs, args)
+       doc: /* Negate number or subtract numbers or markers.
+With one arg, negates it.  With more than one arg,
+subtracts all but the first from the first.
+usage: (- &optional NUMBER-OR-MARKER &rest MORE-NUMBERS-OR-MARKERS)  */)
+     (nargs, args)
      int nargs;
      Lisp_Object *args;
 {
@@ -2551,8 +2570,9 @@ subtracts all but the first from the first.")
 }
 
 DEFUN ("*", Ftimes, Stimes, 0, MANY, 0,
-  "Returns product of any number of arguments, which are numbers or markers.")
-  (nargs, args)
+       doc: /* Return product of any number of arguments, which are numbers or markers.
+usage: (* &rest NUMBERS-OR-MARKERS)  */)
+     (nargs, args)
      int nargs;
      Lisp_Object *args;
 {
@@ -2560,9 +2580,10 @@ DEFUN ("*", Ftimes, Stimes, 0, MANY, 0,
 }
 
 DEFUN ("/", Fquo, Squo, 2, MANY, 0,
-  "Returns first argument divided by all the remaining arguments.\n\
-The arguments must be numbers or markers.")
-  (nargs, args)
+       doc: /* Return first argument divided by all the remaining arguments.
+The arguments must be numbers or markers.
+usage: (/ DIVIDEND DIVISOR &rest DIVISORS)  */)
+     (nargs, args)
      int nargs;
      Lisp_Object *args;
 {
@@ -2570,15 +2591,15 @@ The arguments must be numbers or markers.")
 }
 
 DEFUN ("%", Frem, Srem, 2, 2, 0,
-  "Returns remainder of X divided by Y.\n\
-Both must be integers or markers.")
-  (x, y)
+       doc: /* Return remainder of X divided by Y.
+Both must be integers or markers.  */)
+     (x, y)
      register Lisp_Object x, y;
 {
   Lisp_Object val;
 
-  CHECK_NUMBER_COERCE_MARKER (x, 0);
-  CHECK_NUMBER_COERCE_MARKER (y, 1);
+  CHECK_NUMBER_COERCE_MARKER (x);
+  CHECK_NUMBER_COERCE_MARKER (y);
 
   if (XFASTINT (y) == 0)
     Fsignal (Qarith_error, Qnil);
@@ -2611,17 +2632,17 @@ fmod (f1, f2)
 #endif /* ! HAVE_FMOD */
 
 DEFUN ("mod", Fmod, Smod, 2, 2, 0,
-  "Returns X modulo Y.\n\
-The result falls between zero (inclusive) and Y (exclusive).\n\
-Both X and Y must be numbers or markers.")
-  (x, y)
+       doc: /* Return X modulo Y.
+The result falls between zero (inclusive) and Y (exclusive).
+Both X and Y must be numbers or markers.  */)
+     (x, y)
      register Lisp_Object x, y;
 {
   Lisp_Object val;
   EMACS_INT i1, i2;
 
-  CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (x, 0);
-  CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (y, 1);
+  CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (x);
+  CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (y);
 
   if (FLOATP (x) || FLOATP (y))
     return fmod_float (x, y);
@@ -2643,9 +2664,10 @@ Both X and Y must be numbers or markers.")
 }
 
 DEFUN ("max", Fmax, Smax, 1, MANY, 0,
-  "Return largest of all the arguments (which must be numbers or markers).\n\
-The value is always a number; markers are converted to numbers.")
-  (nargs, args)
+       doc: /* Return largest of all the arguments (which must be numbers or markers).
+The value is always a number; markers are converted to numbers.
+usage: (max NUMBER-OR-MARKER &rest NUMBERS-OR-MARKERS)  */)
+     (nargs, args)
      int nargs;
      Lisp_Object *args;
 {
@@ -2653,9 +2675,10 @@ The value is always a number; markers are converted to numbers.")
 }
 
 DEFUN ("min", Fmin, Smin, 1, MANY, 0,
-  "Return smallest of all the arguments (which must be numbers or markers).\n\
-The value is always a number; markers are converted to numbers.")
-  (nargs, args)
+       doc: /* Return smallest of all the arguments (which must be numbers or markers).
+The value is always a number; markers are converted to numbers.
+usage: (min NUMBER-OR-MARKER &rest NUMBERS-OR-MARKERS)  */)
+     (nargs, args)
      int nargs;
      Lisp_Object *args;
 {
@@ -2663,9 +2686,10 @@ The value is always a number; markers are converted to numbers.")
 }
 
 DEFUN ("logand", Flogand, Slogand, 0, MANY, 0,
-  "Return bitwise-and of all the arguments.\n\
-Arguments may be integers, or markers converted to integers.")
-  (nargs, args)
+       doc: /* Return bitwise-and of all the arguments.
+Arguments may be integers, or markers converted to integers.
+usage: (logand &rest INTS-OR-MARKERS)  */)
+     (nargs, args)
      int nargs;
      Lisp_Object *args;
 {
@@ -2673,9 +2697,10 @@ Arguments may be integers, or markers converted to integers.")
 }
 
 DEFUN ("logior", Flogior, Slogior, 0, MANY, 0,
-  "Return bitwise-or of all the arguments.\n\
-Arguments may be integers, or markers converted to integers.")
-  (nargs, args)
+       doc: /* Return bitwise-or of all the arguments.
+Arguments may be integers, or markers converted to integers.
+usage: (logior &rest INTS-OR-MARKERS)  */)
+     (nargs, args)
      int nargs;
      Lisp_Object *args;
 {
@@ -2683,9 +2708,10 @@ Arguments may be integers, or markers converted to integers.")
 }
 
 DEFUN ("logxor", Flogxor, Slogxor, 0, MANY, 0,
-  "Return bitwise-exclusive-or of all the arguments.\n\
-Arguments may be integers, or markers converted to integers.")
-  (nargs, args)
+       doc: /* Return bitwise-exclusive-or of all the arguments.
+Arguments may be integers, or markers converted to integers.
+usage: (logxor &rest INTS-OR-MARKERS) */)
+     (nargs, args)
      int nargs;
      Lisp_Object *args;
 {
@@ -2693,16 +2719,16 @@ Arguments may be integers, or markers converted to integers.")
 }
 
 DEFUN ("ash", Fash, Sash, 2, 2, 0,
-  "Return VALUE with its bits shifted left by COUNT.\n\
-If COUNT is negative, shifting is actually to the right.\n\
-In this case, the sign bit is duplicated.")
-  (value, count)
+       doc: /* Return VALUE with its bits shifted left by COUNT.
+If COUNT is negative, shifting is actually to the right.
+In this case, the sign bit is duplicated.  */)
+     (value, count)
      register Lisp_Object value, count;
 {
   register Lisp_Object val;
 
-  CHECK_NUMBER (value, 0);
-  CHECK_NUMBER (count, 1);
+  CHECK_NUMBER (value);
+  CHECK_NUMBER (count);
 
   if (XINT (count) >= BITS_PER_EMACS_INT)
     XSETINT (val, 0);
@@ -2716,16 +2742,16 @@ In this case, the sign bit is duplicated.")
 }
 
 DEFUN ("lsh", Flsh, Slsh, 2, 2, 0,
-  "Return VALUE with its bits shifted left by COUNT.\n\
-If COUNT is negative, shifting is actually to the right.\n\
-In this case,  zeros are shifted in on the left.")
-  (value, count)
+       doc: /* Return VALUE with its bits shifted left by COUNT.
+If COUNT is negative, shifting is actually to the right.
+In this case,  zeros are shifted in on the left.  */)
+     (value, count)
      register Lisp_Object value, count;
 {
   register Lisp_Object val;
 
-  CHECK_NUMBER (value, 0);
-  CHECK_NUMBER (count, 1);
+  CHECK_NUMBER (value);
+  CHECK_NUMBER (count);
 
   if (XINT (count) >= BITS_PER_EMACS_INT)
     XSETINT (val, 0);
@@ -2739,12 +2765,12 @@ In this case,  zeros are shifted in on the left.")
 }
 
 DEFUN ("1+", Fadd1, Sadd1, 1, 1, 0,
-  "Return NUMBER plus one.  NUMBER may be a number or a marker.\n\
-Markers are converted to integers.")
-  (number)
+       doc: /* Return NUMBER plus one.  NUMBER may be a number or a marker.
+Markers are converted to integers.  */)
+     (number)
      register Lisp_Object number;
 {
-  CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (number, 0);
+  CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (number);
 
   if (FLOATP (number))
     return (make_float (1.0 + XFLOAT_DATA (number)));
@@ -2754,12 +2780,12 @@ Markers are converted to integers.")
 }
 
 DEFUN ("1-", Fsub1, Ssub1, 1, 1, 0,
-  "Return NUMBER minus one.  NUMBER may be a number or a marker.\n\
-Markers are converted to integers.")
-  (number)
+       doc: /* Return NUMBER minus one.  NUMBER may be a number or a marker.
+Markers are converted to integers.  */)
+     (number)
      register Lisp_Object number;
 {
-  CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (number, 0);
+  CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (number);
 
   if (FLOATP (number))
     return (make_float (-1.0 + XFLOAT_DATA (number)));
@@ -2769,11 +2795,11 @@ Markers are converted to integers.")
 }
 
 DEFUN ("lognot", Flognot, Slognot, 1, 1, 0,
-  "Return the bitwise complement of NUMBER.  NUMBER must be an integer.")
-  (number)
+       doc: /* Return the bitwise complement of NUMBER.  NUMBER must be an integer.  */)
+     (number)
      register Lisp_Object number;
 {
-  CHECK_NUMBER (number, 0);
+  CHECK_NUMBER (number);
   XSETINT (number, ~XINT (number));
   return number;
 }
@@ -3183,11 +3209,11 @@ syms_of_data ()
   XSYMBOL (Qwholenump)->function = XSYMBOL (Qnatnump)->function;
 
   DEFVAR_INT ("most-positive-fixnum", &most_positive_fixnum,
-    "The largest value that is representable in a Lisp integer.");
+	      doc: /* The largest value that is representable in a Lisp integer.  */);
   most_positive_fixnum = MOST_POSITIVE_FIXNUM;
   
   DEFVAR_INT ("most-negative-fixnum", &most_negative_fixnum,
-    "The smallest value that is representable in a Lisp integer.");
+	      doc: /* The smallest value that is representable in a Lisp integer.  */);
   most_negative_fixnum = MOST_NEGATIVE_FIXNUM;
 }
 
@@ -3230,5 +3256,3 @@ init_data ()
   signal (SIGEMT, arith_error);
 #endif /* uts */
 }
-
-