home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 5 Edit / 05-Edit.zip / e20313sr.zip / emacs / 20.3.1 / src / data.c < prev    next >
C/C++ Source or Header  |  1999-07-31  |  87KB  |  2,988 lines
  1. /* Primitive operations on Lisp data types for GNU Emacs Lisp interpreter.
  2.    Copyright (C) 1985,86,88,93,94,95,97, 1998 Free Software Foundation, Inc.
  3.  
  4. This file is part of GNU Emacs.
  5.  
  6. GNU Emacs is free software; you can redistribute it and/or modify
  7. it under the terms of the GNU General Public License as published by
  8. the Free Software Foundation; either version 2, or (at your option)
  9. any later version.
  10.  
  11. GNU Emacs is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. GNU General Public License for more details.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with GNU Emacs; see the file COPYING.  If not, write to
  18. the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19. Boston, MA 02111-1307, USA.  */
  20.  
  21.  
  22. #include <signal.h>
  23.  
  24. #include <config.h>
  25. #include "lisp.h"
  26. #include "puresize.h"
  27. #include "charset.h"
  28.  
  29. #ifndef standalone
  30. #include "buffer.h"
  31. #include "keyboard.h"
  32. #include "frame.h"
  33. #endif
  34.  
  35. #include "syssignal.h"
  36.  
  37. #ifdef LISP_FLOAT_TYPE
  38.  
  39. #ifdef STDC_HEADERS
  40. #include <stdlib.h>
  41. #include <float.h>
  42. #endif
  43.  
  44. /* If IEEE_FLOATING_POINT isn't defined, default it from FLT_*. */
  45. #ifndef IEEE_FLOATING_POINT
  46. #if (FLT_RADIX == 2 && FLT_MANT_DIG == 24 \
  47.      && FLT_MIN_EXP == -125 && FLT_MAX_EXP == 128)
  48. #define IEEE_FLOATING_POINT 1
  49. #else
  50. #define IEEE_FLOATING_POINT 0
  51. #endif
  52. #endif
  53.  
  54. /* Work around a problem that happens because math.h on hpux 7
  55.    defines two static variables--which, in Emacs, are not really static,
  56.    because `static' is defined as nothing.  The problem is that they are
  57.    here, in floatfns.c, and in lread.c.
  58.    These macros prevent the name conflict.  */
  59. #if defined (HPUX) && !defined (HPUX8)
  60. #define _MAXLDBL data_c_maxldbl
  61. #define _NMAXLDBL data_c_nmaxldbl
  62. #endif
  63.  
  64. #include <math.h>
  65. #endif /* LISP_FLOAT_TYPE */
  66.  
  67. #if !defined (atof)
  68. extern double atof ();
  69. #endif /* !atof */
  70.  
  71. /* Nonzero means it is an error to set a symbol whose name starts with
  72.    colon.  */
  73. int keyword_symbols_constant_flag;
  74.  
  75. Lisp_Object Qnil, Qt, Qquote, Qlambda, Qsubr, Qunbound;
  76. Lisp_Object Qerror_conditions, Qerror_message, Qtop_level;
  77. Lisp_Object Qerror, Qquit, Qwrong_type_argument, Qargs_out_of_range;
  78. Lisp_Object Qvoid_variable, Qvoid_function, Qcyclic_function_indirection;
  79. Lisp_Object Qsetting_constant, Qinvalid_read_syntax;
  80. Lisp_Object Qinvalid_function, Qwrong_number_of_arguments, Qno_catch;
  81. Lisp_Object Qend_of_file, Qarith_error, Qmark_inactive;
  82. Lisp_Object Qbeginning_of_buffer, Qend_of_buffer, Qbuffer_read_only;
  83. Lisp_Object Qintegerp, Qnatnump, Qwholenump, Qsymbolp, Qlistp, Qconsp;
  84. Lisp_Object Qstringp, Qarrayp, Qsequencep, Qbufferp;
  85. Lisp_Object Qchar_or_string_p, Qmarkerp, Qinteger_or_marker_p, Qvectorp;
  86. Lisp_Object Qbuffer_or_string_p;
  87. Lisp_Object Qboundp, Qfboundp;
  88. Lisp_Object Qchar_table_p, Qvector_or_char_table_p;
  89.  
  90. Lisp_Object Qcdr;
  91. Lisp_Object Qad_advice_info, Qad_activate;
  92.  
  93. Lisp_Object Qrange_error, Qdomain_error, Qsingularity_error;
  94. Lisp_Object Qoverflow_error, Qunderflow_error;
  95.  
  96. #ifdef LISP_FLOAT_TYPE
  97. Lisp_Object Qfloatp;
  98. Lisp_Object Qnumberp, Qnumber_or_marker_p;
  99. #endif
  100.  
  101. static Lisp_Object Qinteger, Qsymbol, Qstring, Qcons, Qmarker, Qoverlay;
  102. static Lisp_Object Qfloat, Qwindow_configuration, Qwindow;
  103. Lisp_Object Qprocess;
  104. static Lisp_Object Qcompiled_function, Qbuffer, Qframe, Qvector;
  105. static Lisp_Object Qchar_table, Qbool_vector;
  106.  
  107. static Lisp_Object swap_in_symval_forwarding ();
  108.  
  109. Lisp_Object set_internal ();
  110.  
  111. Lisp_Object
  112. wrong_type_argument (predicate, value)
  113.      register Lisp_Object predicate, value;
  114. {
  115.   register Lisp_Object tem;
  116.   do
  117.     {
  118.       if (!EQ (Vmocklisp_arguments, Qt))
  119.     {
  120.      if (STRINGP (value) &&
  121.          (EQ (predicate, Qintegerp) || EQ (predicate, Qinteger_or_marker_p)))
  122.        return Fstring_to_number (value, Qnil);
  123.      if (INTEGERP (value) && EQ (predicate, Qstringp))
  124.        return Fnumber_to_string (value);
  125.     }
  126.  
  127.       /* If VALUE is not even a valid Lisp object, abort here
  128.      where we can get a backtrace showing where it came from.  */
  129.       if ((unsigned int) XGCTYPE (value) >= Lisp_Type_Limit)
  130.     abort ();
  131.  
  132.       value = Fsignal (Qwrong_type_argument, Fcons (predicate, Fcons (value, Qnil)));
  133.       tem = call1 (predicate, value);
  134.     }
  135.   while (NILP (tem));
  136.   return value;
  137. }
  138.  
  139. void
  140. pure_write_error ()
  141. {
  142.   error ("Attempt to modify read-only object");
  143. }
  144.  
  145. void
  146. args_out_of_range (a1, a2)
  147.      Lisp_Object a1, a2;
  148. {
  149.   while (1)
  150.     Fsignal (Qargs_out_of_range, Fcons (a1, Fcons (a2, Qnil)));
  151. }
  152.  
  153. void
  154. args_out_of_range_3 (a1, a2, a3)
  155.      Lisp_Object a1, a2, a3;
  156. {
  157.   while (1)
  158.     Fsignal (Qargs_out_of_range, Fcons (a1, Fcons (a2, Fcons (a3, Qnil))));
  159. }
  160.  
  161. /* On some machines, XINT needs a temporary location.
  162.    Here it is, in case it is needed.  */
  163.  
  164. int sign_extend_temp;
  165.  
  166. /* On a few machines, XINT can only be done by calling this.  */
  167.  
  168. int
  169. sign_extend_lisp_int (num)
  170.      EMACS_INT num;
  171. {
  172.   if (num & (((EMACS_INT) 1) << (VALBITS - 1)))
  173.     return num | (((EMACS_INT) (-1)) << VALBITS);
  174.   else
  175.     return num & ((((EMACS_INT) 1) << VALBITS) - 1);
  176. }
  177.  
  178. /* Data type predicates */
  179.  
  180. DEFUN ("eq", Feq, Seq, 2, 2, 0,
  181.   "Return t if the two args are the same Lisp object.")
  182.   (obj1, obj2)
  183.      Lisp_Object obj1, obj2;
  184. {
  185.   if (EQ (obj1, obj2))
  186.     return Qt;
  187.   return Qnil;
  188. }
  189.  
  190. DEFUN ("null", Fnull, Snull, 1, 1, 0, "Return t if OBJECT is nil.")
  191.   (object)
  192.      Lisp_Object object;
  193. {
  194.   if (NILP (object))
  195.     return Qt;
  196.   return Qnil;
  197. }
  198.  
  199. DEFUN ("type-of", Ftype_of, Stype_of, 1, 1, 0,
  200.   "Return a symbol representing the type of OBJECT.\n\
  201. The symbol returned names the object's basic type;\n\
  202. for example, (type-of 1) returns `integer'.")
  203.   (object)
  204.      Lisp_Object object;
  205. {
  206.   switch (XGCTYPE (object))
  207.     {
  208.     case Lisp_Int:
  209.       return Qinteger;
  210.  
  211.     case Lisp_Symbol:
  212.       return Qsymbol;
  213.  
  214.     case Lisp_String:
  215.       return Qstring;
  216.  
  217.     case Lisp_Cons:
  218.       return Qcons;
  219.  
  220.     case Lisp_Misc:
  221.       switch (XMISCTYPE (object))
  222.     {
  223.     case Lisp_Misc_Marker:
  224.       return Qmarker;
  225.     case Lisp_Misc_Overlay:
  226.       return Qoverlay;
  227.     case Lisp_Misc_Float:
  228.       return Qfloat;
  229.     }
  230.       abort ();
  231.  
  232.     case Lisp_Vectorlike:
  233.       if (GC_WINDOW_CONFIGURATIONP (object))
  234.     return Qwindow_configuration;
  235.       if (GC_PROCESSP (object))
  236.     return Qprocess;
  237.       if (GC_WINDOWP (object))
  238.     return Qwindow;
  239.       if (GC_SUBRP (object))
  240.     return Qsubr;
  241.       if (GC_COMPILEDP (object))
  242.     return Qcompiled_function;
  243.       if (GC_BUFFERP (object))
  244.     return Qbuffer;
  245.       if (GC_CHAR_TABLE_P (object))
  246.     return Qchar_table;
  247.       if (GC_BOOL_VECTOR_P (object))
  248.     return Qbool_vector;
  249.       if (GC_FRAMEP (object))
  250.     return Qframe;
  251.       return Qvector;
  252.  
  253. #ifdef LISP_FLOAT_TYPE
  254.     case Lisp_Float:
  255.       return Qfloat;
  256. #endif
  257.  
  258.     default:
  259.       abort ();
  260.     }
  261. }
  262.  
  263. DEFUN ("consp", Fconsp, Sconsp, 1, 1, 0, "Return t if OBJECT is a cons cell.")
  264.   (object)
  265.      Lisp_Object object;
  266. {
  267.   if (CONSP (object))
  268.     return Qt;
  269.   return Qnil;
  270. }
  271.  
  272. DEFUN ("atom", Fatom, Satom, 1, 1, 0,
  273.        "Return t if OBJECT is not a cons cell.  This includes nil.")
  274.   (object)
  275.      Lisp_Object object;
  276. {
  277.   if (CONSP (object))
  278.     return Qnil;
  279.   return Qt;
  280. }
  281.  
  282. DEFUN ("listp", Flistp, Slistp, 1, 1, 0,
  283.        "Return t if OBJECT is a list.  This includes nil.")
  284.   (object)
  285.      Lisp_Object object;
  286. {
  287.   if (CONSP (object) || NILP (object))
  288.     return Qt;
  289.   return Qnil;
  290. }
  291.  
  292. DEFUN ("nlistp", Fnlistp, Snlistp, 1, 1, 0,
  293.        "Return t if OBJECT is not a list.  Lists include nil.")
  294.   (object)
  295.      Lisp_Object object;
  296. {
  297.   if (CONSP (object) || NILP (object))
  298.     return Qnil;
  299.   return Qt;
  300. }
  301.  
  302. DEFUN ("symbolp", Fsymbolp, Ssymbolp, 1, 1, 0,
  303.        "Return t if OBJECT is a symbol.")
  304.   (object)
  305.      Lisp_Object object;
  306. {
  307.   if (SYMBOLP (object))
  308.     return Qt;
  309.   return Qnil;
  310. }
  311.  
  312. DEFUN ("vectorp", Fvectorp, Svectorp, 1, 1, 0,
  313.        "Return t if OBJECT is a vector.")
  314.   (object)
  315.      Lisp_Object object;
  316. {
  317.   if (VECTORP (object))
  318.     return Qt;
  319.   return Qnil;
  320. }
  321.  
  322. DEFUN ("stringp", Fstringp, Sstringp, 1, 1, 0,
  323.        "Return t if OBJECT is a string.")
  324.   (object)
  325.      Lisp_Object object;
  326. {
  327.   if (STRINGP (object))
  328.     return Qt;
  329.   return Qnil;
  330. }
  331.  
  332. DEFUN ("multibyte-string-p", Fmultibyte_string_p, Smultibyte_string_p,
  333.        1, 1, 0, "Return t if OBJECT is a multibyte string.")
  334.   (object)
  335.      Lisp_Object object;
  336. {
  337.   if (STRINGP (object) && STRING_MULTIBYTE (object))
  338.     return Qt;
  339.   return Qnil;
  340. }
  341.  
  342. DEFUN ("char-table-p", Fchar_table_p, Schar_table_p, 1, 1, 0,
  343.        "Return t if OBJECT is a char-table.")
  344.   (object)
  345.      Lisp_Object object;
  346. {
  347.   if (CHAR_TABLE_P (object))
  348.     return Qt;
  349.   return Qnil;
  350. }
  351.  
  352. DEFUN ("vector-or-char-table-p", Fvector_or_char_table_p,
  353.        Svector_or_char_table_p, 1, 1, 0,
  354.        "Return t if OBJECT is a char-table or vector.")
  355.   (object)
  356.      Lisp_Object object;
  357. {
  358.   if (VECTORP (object) || CHAR_TABLE_P (object))
  359.     return Qt;
  360.   return Qnil;
  361. }
  362.  
  363. DEFUN ("bool-vector-p", Fbool_vector_p, Sbool_vector_p, 1, 1, 0, "Return t if OBJECT is a bool-vector.")
  364.   (object)
  365.      Lisp_Object object;
  366. {
  367.   if (BOOL_VECTOR_P (object))
  368.     return Qt;
  369.   return Qnil;
  370. }
  371.  
  372. DEFUN ("arrayp", Farrayp, Sarrayp, 1, 1, 0, "Return t if OBJECT is an array (string or vector).")
  373.   (object)
  374.      Lisp_Object object;
  375. {
  376.   if (VECTORP (object) || STRINGP (object)
  377.       || CHAR_TABLE_P (object) || BOOL_VECTOR_P (object))
  378.     return Qt;
  379.   return Qnil;
  380. }
  381.  
  382. DEFUN ("sequencep", Fsequencep, Ssequencep, 1, 1, 0,
  383.   "Return t if OBJECT is a sequence (list or array).")
  384.   (object)
  385.      register Lisp_Object object;
  386. {
  387.   if (CONSP (object) || NILP (object) || VECTORP (object) || STRINGP (object)
  388.       || CHAR_TABLE_P (object) || BOOL_VECTOR_P (object))
  389.     return Qt;
  390.   return Qnil;
  391. }
  392.  
  393. DEFUN ("bufferp", Fbufferp, Sbufferp, 1, 1, 0, "Return t if OBJECT is an editor buffer.")
  394.   (object)
  395.      Lisp_Object object;
  396. {
  397.   if (BUFFERP (object))
  398.     return Qt;
  399.   return Qnil;
  400. }
  401.  
  402. DEFUN ("markerp", Fmarkerp, Smarkerp, 1, 1, 0, "Return t if OBJECT is a marker (editor pointer).")
  403.   (object)
  404.      Lisp_Object object;
  405. {
  406.   if (MARKERP (object))
  407.     return Qt;
  408.   return Qnil;
  409. }
  410.  
  411. DEFUN ("subrp", Fsubrp, Ssubrp, 1, 1, 0, "Return t if OBJECT is a built-in function.")
  412.   (object)
  413.      Lisp_Object object;
  414. {
  415.   if (SUBRP (object))
  416.     return Qt;
  417.   return Qnil;
  418. }
  419.  
  420. DEFUN ("byte-code-function-p", Fbyte_code_function_p, Sbyte_code_function_p,
  421.        1, 1, 0, "Return t if OBJECT is a byte-compiled function object.")
  422.   (object)
  423.      Lisp_Object object;
  424. {
  425.   if (COMPILEDP (object))
  426.     return Qt;
  427.   return Qnil;
  428. }
  429.  
  430. DEFUN ("char-or-string-p", Fchar_or_string_p, Schar_or_string_p, 1, 1, 0,
  431.   "Return t if OBJECT is a character (an integer) or a string.")
  432.   (object)
  433.      register Lisp_Object object;
  434. {
  435.   if (INTEGERP (object) || STRINGP (object))
  436.     return Qt;
  437.   return Qnil;
  438. }
  439.  
  440. DEFUN ("integerp", Fintegerp, Sintegerp, 1, 1, 0, "Return t if OBJECT is an integer.")
  441.   (object)
  442.      Lisp_Object object;
  443. {
  444.   if (INTEGERP (object))
  445.     return Qt;
  446.   return Qnil;
  447. }
  448.  
  449. DEFUN ("integer-or-marker-p", Finteger_or_marker_p, Sinteger_or_marker_p, 1, 1, 0,
  450.   "Return t if OBJECT is an integer or a marker (editor pointer).")
  451.   (object)
  452.      register Lisp_Object object;
  453. {
  454.   if (MARKERP (object) || INTEGERP (object))
  455.     return Qt;
  456.   return Qnil;
  457. }
  458.  
  459. DEFUN ("natnump", Fnatnump, Snatnump, 1, 1, 0,
  460.   "Return t if OBJECT is a nonnegative integer.")
  461.   (object)
  462.      Lisp_Object object;
  463. {
  464.   if (NATNUMP (object))
  465.     return Qt;
  466.   return Qnil;
  467. }
  468.  
  469. DEFUN ("numberp", Fnumberp, Snumberp, 1, 1, 0,
  470.        "Return t if OBJECT is a number (floating point or integer).")
  471.   (object)
  472.      Lisp_Object object;
  473. {
  474.   if (NUMBERP (object))
  475.     return Qt;
  476.   else
  477.     return Qnil;
  478. }
  479.  
  480. DEFUN ("number-or-marker-p", Fnumber_or_marker_p,
  481.        Snumber_or_marker_p, 1, 1, 0,
  482.        "Return t if OBJECT is a number or a marker.")
  483.   (object)
  484.      Lisp_Object object;
  485. {
  486.   if (NUMBERP (object) || MARKERP (object))
  487.     return Qt;
  488.   return Qnil;
  489. }
  490.  
  491. #ifdef LISP_FLOAT_TYPE
  492. DEFUN ("floatp", Ffloatp, Sfloatp, 1, 1, 0,
  493.        "Return t if OBJECT is a floating point number.")
  494.   (object)
  495.      Lisp_Object object;
  496. {
  497.   if (FLOATP (object))
  498.     return Qt;
  499.   return Qnil;
  500. }
  501. #endif /* LISP_FLOAT_TYPE */
  502.  
  503. /* Extract and set components of lists */
  504.  
  505. DEFUN ("car", Fcar, Scar, 1, 1, 0,
  506.   "Return the car of LIST.  If arg is nil, return nil.\n\
  507. Error if arg is not nil and not a cons cell.  See also `car-safe'.")
  508.   (list)
  509.      register Lisp_Object list;
  510. {
  511.   while (1)
  512.     {
  513.       if (CONSP (list))
  514.     return XCONS (list)->car;
  515.       else if (EQ (list, Qnil))
  516.     return Qnil;
  517.       else
  518.     list = wrong_type_argument (Qlistp, list);
  519.     }
  520. }
  521.  
  522. DEFUN ("car-safe", Fcar_safe, Scar_safe, 1, 1, 0,
  523.   "Return the car of OBJECT if it is a cons cell, or else nil.")
  524.   (object)
  525.      Lisp_Object object;
  526. {
  527.   if (CONSP (object))
  528.     return XCONS (object)->car;
  529.   else
  530.     return Qnil;
  531. }
  532.  
  533. DEFUN ("cdr", Fcdr, Scdr, 1, 1, 0,
  534.   "Return the cdr of LIST.  If arg is nil, return nil.\n\
  535. Error if arg is not nil and not a cons cell.  See also `cdr-safe'.")
  536.  
  537.   (list)
  538.      register Lisp_Object list;
  539. {
  540.   while (1)
  541.     {
  542.       if (CONSP (list))
  543.     return XCONS (list)->cdr;
  544.       else if (EQ (list, Qnil))
  545.     return Qnil;
  546.       else
  547.     list = wrong_type_argument (Qlistp, list);
  548.     }
  549. }
  550.  
  551. DEFUN ("cdr-safe", Fcdr_safe, Scdr_safe, 1, 1, 0,
  552.   "Return the cdr of OBJECT if it is a cons cell, or else nil.")
  553.   (object)
  554.      Lisp_Object object;
  555. {
  556.   if (CONSP (object))
  557.     return XCONS (object)->cdr;
  558.   else
  559.     return Qnil;
  560. }
  561.  
  562. DEFUN ("setcar", Fsetcar, Ssetcar, 2, 2, 0,
  563.   "Set the car of CELL to be NEWCAR.  Returns NEWCAR.")
  564.   (cell, newcar)
  565.      register Lisp_Object cell, newcar;
  566. {
  567.   if (!CONSP (cell))
  568.     cell = wrong_type_argument (Qconsp, cell);
  569.  
  570.   CHECK_IMPURE (cell);
  571.   XCONS (cell)->car = newcar;
  572.   return newcar;
  573. }
  574.  
  575. DEFUN ("setcdr", Fsetcdr, Ssetcdr, 2, 2, 0,
  576.   "Set the cdr of CELL to be NEWCDR.  Returns NEWCDR.")
  577.   (cell, newcdr)
  578.      register Lisp_Object cell, newcdr;
  579. {
  580.   if (!CONSP (cell))
  581.     cell = wrong_type_argument (Qconsp, cell);
  582.  
  583.   CHECK_IMPURE (cell);
  584.   XCONS (cell)->cdr = newcdr;
  585.   return newcdr;
  586. }
  587.  
  588. /* Extract and set components of symbols */
  589.  
  590. DEFUN ("boundp", Fboundp, Sboundp, 1, 1, 0, "Return t if SYMBOL's value is not void.")
  591.   (symbol)
  592.      register Lisp_Object symbol;
  593. {
  594.   Lisp_Object valcontents;
  595.   CHECK_SYMBOL (symbol, 0);
  596.  
  597.   valcontents = XSYMBOL (symbol)->value;
  598.  
  599.   if (BUFFER_LOCAL_VALUEP (valcontents)
  600.       || SOME_BUFFER_LOCAL_VALUEP (valcontents))
  601.     valcontents = swap_in_symval_forwarding (symbol, valcontents);
  602.  
  603.   return (EQ (valcontents, Qunbound) ? Qnil : Qt);
  604. }
  605.  
  606. DEFUN ("fboundp", Ffboundp, Sfboundp, 1, 1, 0, "Return t if SYMBOL's function definition is not void.")
  607.   (symbol)
  608.      register Lisp_Object symbol;
  609. {
  610.   CHECK_SYMBOL (symbol, 0);
  611.   return (EQ (XSYMBOL (symbol)->function, Qunbound) ? Qnil : Qt);
  612. }
  613.  
  614. DEFUN ("makunbound", Fmakunbound, Smakunbound, 1, 1, 0, "Make SYMBOL's value be void.")
  615.   (symbol)
  616.      register Lisp_Object symbol;
  617. {
  618.   CHECK_SYMBOL (symbol, 0);
  619.   if (NILP (symbol) || EQ (symbol, Qt)
  620.       || (XSYMBOL (symbol)->name->data[0] == ':'
  621.       && EQ (XSYMBOL (symbol)->obarray, initial_obarray)
  622.       && keyword_symbols_constant_flag))
  623.     return Fsignal (Qsetting_constant, Fcons (symbol, Qnil));
  624.   Fset (symbol, Qunbound);
  625.   return symbol;
  626. }
  627.  
  628. DEFUN ("fmakunbound", Ffmakunbound, Sfmakunbound, 1, 1, 0, "Make SYMBOL's function definition be void.")
  629.   (symbol)
  630.      register Lisp_Object symbol;
  631. {
  632.   CHECK_SYMBOL (symbol, 0);
  633.   if (NILP (symbol) || EQ (symbol, Qt))
  634.     return Fsignal (Qsetting_constant, Fcons (symbol, Qnil));
  635.   XSYMBOL (symbol)->function = Qunbound;
  636.   return symbol;
  637. }
  638.  
  639. DEFUN ("symbol-function", Fsymbol_function, Ssymbol_function, 1, 1, 0,
  640.   "Return SYMBOL's function definition.  Error if that is void.")
  641.   (symbol)
  642.      register Lisp_Object symbol;
  643. {
  644.   CHECK_SYMBOL (symbol, 0);
  645.   if (EQ (XSYMBOL (symbol)->function, Qunbound))
  646.     return Fsignal (Qvoid_function, Fcons (symbol, Qnil));
  647.   return XSYMBOL (symbol)->function;
  648. }
  649.  
  650. DEFUN ("symbol-plist", Fsymbol_plist, Ssymbol_plist, 1, 1, 0, "Return SYMBOL's property list.")
  651.   (symbol)
  652.      register Lisp_Object symbol;
  653. {
  654.   CHECK_SYMBOL (symbol, 0);
  655.   return XSYMBOL (symbol)->plist;
  656. }
  657.  
  658. DEFUN ("symbol-name", Fsymbol_name, Ssymbol_name, 1, 1, 0, "Return SYMBOL's name, a string.")
  659.   (symbol)
  660.      register Lisp_Object symbol;
  661. {
  662.   register Lisp_Object name;
  663.  
  664.   CHECK_SYMBOL (symbol, 0);
  665.   XSETSTRING (name, XSYMBOL (symbol)->name);
  666.   return name;
  667. }
  668.  
  669. DEFUN ("fset", Ffset, Sfset, 2, 2, 0,
  670.   "Set SYMBOL's function definition to DEFINITION, and return DEFINITION.")
  671.   (symbol, definition)
  672.      register Lisp_Object symbol, definition;
  673. {
  674.   CHECK_SYMBOL (symbol, 0);
  675.   if (NILP (symbol) || EQ (symbol, Qt))
  676.     return Fsignal (Qsetting_constant, Fcons (symbol, Qnil));
  677.   if (!NILP (Vautoload_queue) && !EQ (XSYMBOL (symbol)->function, Qunbound))
  678.     Vautoload_queue = Fcons (Fcons (symbol, XSYMBOL (symbol)->function),
  679.                  Vautoload_queue);
  680.   XSYMBOL (symbol)->function = definition;
  681.   /* Handle automatic advice activation */
  682.   if (CONSP (XSYMBOL (symbol)->plist) && !NILP (Fget (symbol, Qad_advice_info)))
  683.     {
  684.       call2 (Qad_activate, symbol, Qnil);
  685.       definition = XSYMBOL (symbol)->function;
  686.     }
  687.   return definition;
  688. }
  689.  
  690. DEFUN ("defalias", Fdefalias, Sdefalias, 2, 2, 0,
  691.   "Set SYMBOL's function definition to DEFINITION, and return DEFINITION.\n\
  692. Associates the function with the current load file, if any.")
  693.   (symbol, definition)
  694.      register Lisp_Object symbol, definition;
  695. {
  696.   CHECK_SYMBOL (symbol, 0);
  697.   if (!NILP (Vautoload_queue) && !EQ (XSYMBOL (symbol)->function, Qunbound))
  698.     Vautoload_queue = Fcons (Fcons (symbol, XSYMBOL (symbol)->function),
  699.                  Vautoload_queue);
  700.   XSYMBOL (symbol)->function = definition;
  701.   /* Handle automatic advice activation */
  702.   if (CONSP (XSYMBOL (symbol)->plist) && !NILP (Fget (symbol, Qad_advice_info)))
  703.     {
  704.       call2 (Qad_activate, symbol, Qnil);
  705.       definition = XSYMBOL (symbol)->function;
  706.     }
  707.   LOADHIST_ATTACH (symbol);
  708.   return definition;
  709. }
  710.  
  711. DEFUN ("setplist", Fsetplist, Ssetplist, 2, 2, 0,
  712.   "Set SYMBOL's property list to NEWVAL, and return NEWVAL.")
  713.   (symbol, newplist)
  714.      register Lisp_Object symbol, newplist;
  715. {
  716.   CHECK_SYMBOL (symbol, 0);
  717.   XSYMBOL (symbol)->plist = newplist;
  718.   return newplist;
  719. }
  720.  
  721.  
  722. /* Getting and setting values of symbols */
  723.  
  724. /* Given the raw contents of a symbol value cell,
  725.    return the Lisp value of the symbol.
  726.    This does not handle buffer-local variables; use
  727.    swap_in_symval_forwarding for that.  */
  728.  
  729. Lisp_Object
  730. do_symval_forwarding (valcontents)
  731.      register Lisp_Object valcontents;
  732. {
  733.   register Lisp_Object val;
  734.   int offset;
  735.   if (MISCP (valcontents))
  736.     switch (XMISCTYPE (valcontents))
  737.       {
  738.       case Lisp_Misc_Intfwd:
  739.     XSETINT (val, *XINTFWD (valcontents)->intvar);
  740.     return val;
  741.  
  742.       case Lisp_Misc_Boolfwd:
  743.     return (*XBOOLFWD (valcontents)->boolvar ? Qt : Qnil);
  744.  
  745.       case Lisp_Misc_Objfwd:
  746.     return *XOBJFWD (valcontents)->objvar;
  747.  
  748.       case Lisp_Misc_Buffer_Objfwd:
  749.     offset = XBUFFER_OBJFWD (valcontents)->offset;
  750.     return *(Lisp_Object *)(offset + (char *)current_buffer);
  751.  
  752.       case Lisp_Misc_Kboard_Objfwd:
  753.     offset = XKBOARD_OBJFWD (valcontents)->offset;
  754.     return *(Lisp_Object *)(offset + (char *)current_kboard);
  755.       }
  756.   return valcontents;
  757. }
  758.  
  759. /* Store NEWVAL into SYMBOL, where VALCONTENTS is found in the value cell
  760.    of SYMBOL.  If SYMBOL is buffer-local, VALCONTENTS should be the
  761.    buffer-independent contents of the value cell: forwarded just one
  762.    step past the buffer-localness.  */
  763.  
  764. void
  765. store_symval_forwarding (symbol, valcontents, newval)
  766.      Lisp_Object symbol;
  767.      register Lisp_Object valcontents, newval;
  768. {
  769.   switch (SWITCH_ENUM_CAST (XTYPE (valcontents)))
  770.     {
  771.     case Lisp_Misc:
  772.       switch (XMISCTYPE (valcontents))
  773.     {
  774.     case Lisp_Misc_Intfwd:
  775.       CHECK_NUMBER (newval, 1);
  776.       *XINTFWD (valcontents)->intvar = XINT (newval);
  777.       if (*XINTFWD (valcontents)->intvar != XINT (newval))
  778.         error ("Value out of range for variable `%s'",
  779.            XSYMBOL (symbol)->name->data);
  780.       break;
  781.  
  782.     case Lisp_Misc_Boolfwd:
  783.       *XBOOLFWD (valcontents)->boolvar = NILP (newval) ? 0 : 1;
  784.       break;
  785.  
  786.     case Lisp_Misc_Objfwd:
  787.       *XOBJFWD (valcontents)->objvar = newval;
  788.       break;
  789.  
  790.     case Lisp_Misc_Buffer_Objfwd:
  791.       {
  792.         int offset = XBUFFER_OBJFWD (valcontents)->offset;
  793.         Lisp_Object type;
  794.  
  795.         type = *(Lisp_Object *)(offset + (char *)&buffer_local_types);
  796.         if (XINT (type) == -1)
  797.           error ("Variable %s is read-only", XSYMBOL (symbol)->name->data);
  798.  
  799.         if (! NILP (type) && ! NILP (newval)
  800.         && XTYPE (newval) != XINT (type))
  801.           buffer_slot_type_mismatch (offset);
  802.  
  803.         *(Lisp_Object *)(offset + (char *)current_buffer) = newval;
  804.       }
  805.       break;
  806.  
  807.     case Lisp_Misc_Kboard_Objfwd:
  808.       (*(Lisp_Object *)((char *)current_kboard
  809.                 + XKBOARD_OBJFWD (valcontents)->offset))
  810.         = newval;
  811.       break;
  812.  
  813.     default:
  814.       goto def;
  815.     }
  816.       break;
  817.  
  818.     default:
  819.     def:
  820.       valcontents = XSYMBOL (symbol)->value;
  821.       if (BUFFER_LOCAL_VALUEP (valcontents)
  822.       || SOME_BUFFER_LOCAL_VALUEP (valcontents))
  823.     XBUFFER_LOCAL_VALUE (valcontents)->realvalue = newval;
  824.       else
  825.     XSYMBOL (symbol)->value = newval;
  826.     }
  827. }
  828.  
  829. /* Set up the buffer-local symbol SYMBOL for validity in the current
  830.    buffer.  VALCONTENTS is the contents of its value cell.
  831.    Return the value forwarded one step past the buffer-local indicator.  */
  832.  
  833. static Lisp_Object
  834. swap_in_symval_forwarding (symbol, valcontents)
  835.      Lisp_Object symbol, valcontents;
  836. {
  837.   /* valcontents is a pointer to a struct resembling the cons
  838.      (REALVALUE BUFFER CURRENT-ALIST-ELEMENT . DEFAULT-VALUE)).
  839.  
  840.      CURRENT-ALIST-ELEMENT is a pointer to an element of BUFFER's
  841.      local_var_alist, that being the element whose car is this
  842.      variable.  Or it can be a pointer to the
  843.      (CURRENT-ALIST-ELEMENT . DEFAULT-VALUE), if BUFFER does not have
  844.      an element in its alist for this variable.
  845.  
  846.      If the current buffer is not BUFFER, we store the current
  847.      REALVALUE value into CURRENT-ALIST-ELEMENT, then find the
  848.      appropriate alist element for the buffer now current and set up
  849.      CURRENT-ALIST-ELEMENT.  Then we set REALVALUE out of that
  850.      element, and store into BUFFER.
  851.  
  852.      Note that REALVALUE can be a forwarding pointer. */
  853.  
  854.   register Lisp_Object tem1;
  855.   tem1 = XBUFFER_LOCAL_VALUE (valcontents)->buffer;
  856.  
  857.   if (NILP (tem1) || current_buffer != XBUFFER (tem1)
  858.       || selected_frame != XFRAME (XBUFFER_LOCAL_VALUE (valcontents)->frame))
  859.     {
  860.       tem1 = XCONS (XBUFFER_LOCAL_VALUE (valcontents)->cdr)->car;
  861.       Fsetcdr (tem1,
  862.            do_symval_forwarding (XBUFFER_LOCAL_VALUE (valcontents)->realvalue));
  863.       tem1 = assq_no_quit (symbol, current_buffer->local_var_alist);
  864.       XBUFFER_LOCAL_VALUE (valcontents)->found_for_frame = 0;
  865.       XBUFFER_LOCAL_VALUE (valcontents)->found_for_buffer = 0;
  866.       if (NILP (tem1))
  867.     {
  868.       if (XBUFFER_LOCAL_VALUE (valcontents)->check_frame)
  869.         tem1 = assq_no_quit (symbol, selected_frame->param_alist);
  870.       if (! NILP (tem1))
  871.         XBUFFER_LOCAL_VALUE (valcontents)->found_for_frame = 1;
  872.       else
  873.         tem1 = XBUFFER_LOCAL_VALUE (valcontents)->cdr;
  874.     }
  875.       else
  876.     XBUFFER_LOCAL_VALUE (valcontents)->found_for_buffer = 1;
  877.  
  878.       XCONS (XBUFFER_LOCAL_VALUE (valcontents)->cdr)->car = tem1;
  879.       XSETBUFFER (XBUFFER_LOCAL_VALUE (valcontents)->buffer, current_buffer);
  880.       XSETFRAME (XBUFFER_LOCAL_VALUE (valcontents)->frame, selected_frame);
  881.       store_symval_forwarding (symbol,
  882.                    XBUFFER_LOCAL_VALUE (valcontents)->realvalue,
  883.                    Fcdr (tem1));
  884.     }
  885.   return XBUFFER_LOCAL_VALUE (valcontents)->realvalue;
  886. }
  887.  
  888. /* Find the value of a symbol, returning Qunbound if it's not bound.
  889.    This is helpful for code which just wants to get a variable's value
  890.    if it has one, without signaling an error.
  891.    Note that it must not be possible to quit
  892.    within this function.  Great care is required for this.  */
  893.  
  894. Lisp_Object
  895. find_symbol_value (symbol)
  896.      Lisp_Object symbol;
  897. {
  898.   register Lisp_Object valcontents, tem1;
  899.   register Lisp_Object val;
  900.   CHECK_SYMBOL (symbol, 0);
  901.   valcontents = XSYMBOL (symbol)->value;
  902.  
  903.   if (BUFFER_LOCAL_VALUEP (valcontents)
  904.       || SOME_BUFFER_LOCAL_VALUEP (valcontents))
  905.     valcontents = swap_in_symval_forwarding (symbol, valcontents);
  906.  
  907.   if (MISCP (valcontents))
  908.     {
  909.       switch (XMISCTYPE (valcontents))
  910.     {
  911.     case Lisp_Misc_Intfwd:
  912.       XSETINT (val, *XINTFWD (valcontents)->intvar);
  913.       return val;
  914.  
  915.     case Lisp_Misc_Boolfwd:
  916.       return (*XBOOLFWD (valcontents)->boolvar ? Qt : Qnil);
  917.  
  918.     case Lisp_Misc_Objfwd:
  919.       return *XOBJFWD (valcontents)->objvar;
  920.  
  921.     case Lisp_Misc_Buffer_Objfwd:
  922.       return *(Lisp_Object *)(XBUFFER_OBJFWD (valcontents)->offset
  923.                   + (char *)current_buffer);
  924.  
  925.     case Lisp_Misc_Kboard_Objfwd:
  926.       return *(Lisp_Object *)(XKBOARD_OBJFWD (valcontents)->offset
  927.                   + (char *)current_kboard);
  928.     }
  929.     }
  930.  
  931.   return valcontents;
  932. }
  933.  
  934. DEFUN ("symbol-value", Fsymbol_value, Ssymbol_value, 1, 1, 0,
  935.   "Return SYMBOL's value.  Error if that is void.")
  936.   (symbol)
  937.      Lisp_Object symbol;
  938. {
  939.   Lisp_Object val;
  940.  
  941.   val = find_symbol_value (symbol);
  942.   if (EQ (val, Qunbound))
  943.     return Fsignal (Qvoid_variable, Fcons (symbol, Qnil));
  944.   else
  945.     return val;
  946. }
  947.  
  948. DEFUN ("set", Fset, Sset, 2, 2, 0,
  949.   "Set SYMBOL's value to NEWVAL, and return NEWVAL.")
  950.   (symbol, newval)
  951.      register Lisp_Object symbol, newval;
  952. {
  953.   return set_internal (symbol, newval, 0);
  954. }
  955.  
  956. /* Store the value NEWVAL into SYMBOL.
  957.    If BINDFLAG is zero, then if this symbol is supposed to become
  958.    local in every buffer where it is set, then we make it local.
  959.    If BINDFLAG is nonzero, we don't do that.  */
  960.  
  961. Lisp_Object
  962. set_internal (symbol, newval, bindflag)
  963.      register Lisp_Object symbol, newval;
  964.      int bindflag;
  965. {
  966.   int voide = EQ (newval, Qunbound);
  967.  
  968.   register Lisp_Object valcontents, tem1, current_alist_element;
  969.  
  970.   CHECK_SYMBOL (symbol, 0);
  971.   if (NILP (symbol) || EQ (symbol, Qt)
  972.       || (XSYMBOL (symbol)->name->data[0] == ':'
  973.       && EQ (XSYMBOL (symbol)->obarray, initial_obarray)
  974.       && keyword_symbols_constant_flag && ! EQ (newval, symbol)))
  975.     return Fsignal (Qsetting_constant, Fcons (symbol, Qnil));
  976.   valcontents = XSYMBOL (symbol)->value;
  977.  
  978.   if (BUFFER_OBJFWDP (valcontents))
  979.     {
  980.       register int idx = XBUFFER_OBJFWD (valcontents)->offset;
  981.       register int mask = XINT (*((Lisp_Object *)
  982.                   (idx + (char *)&buffer_local_flags)));
  983.       if (mask > 0)
  984.     current_buffer->local_var_flags |= mask;
  985.     }
  986.  
  987.   else if (BUFFER_LOCAL_VALUEP (valcontents)
  988.        || SOME_BUFFER_LOCAL_VALUEP (valcontents))
  989.     {
  990.       /* valcontents is actually a pointer to a struct resembling a cons,
  991.      with contents something like:
  992.      (REALVALUE BUFFER CURRENT-ALIST-ELEMENT . DEFAULT-VALUE).
  993.  
  994.      BUFFER is the last buffer for which this symbol's value was
  995.      made up to date.
  996.  
  997.      CURRENT-ALIST-ELEMENT is a pointer to an element of BUFFER's
  998.      local_var_alist, that being the element whose car is this
  999.      variable.  Or it can be a pointer to the
  1000.      (CURRENT-ALIST-ELEMENT . DEFAULT-VALUE), if BUFFER does not
  1001.      have an element in its alist for this variable (that is, if
  1002.      BUFFER sees the default value of this variable).
  1003.  
  1004.      If we want to examine or set the value and BUFFER is current,
  1005.      we just examine or set REALVALUE. If BUFFER is not current, we
  1006.      store the current REALVALUE value into CURRENT-ALIST-ELEMENT,
  1007.      then find the appropriate alist element for the buffer now
  1008.      current and set up CURRENT-ALIST-ELEMENT.  Then we set
  1009.      REALVALUE out of that element, and store into BUFFER.
  1010.  
  1011.      If we are setting the variable and the current buffer does
  1012.      not have an alist entry for this variable, an alist entry is
  1013.      created.
  1014.  
  1015.      Note that REALVALUE can be a forwarding pointer.  Each time
  1016.      it is examined or set, forwarding must be done.  */
  1017.  
  1018.       /* What value are we caching right now?  */
  1019.       current_alist_element
  1020.     = XCONS (XBUFFER_LOCAL_VALUE (valcontents)->cdr)->car;
  1021.  
  1022.       /* If the current buffer is not the buffer whose binding is
  1023.      currently cached, or if it's a Lisp_Buffer_Local_Value and
  1024.      we're looking at the default value, the cache is invalid; we
  1025.      need to write it out, and find the new CURRENT-ALIST-ELEMENT.  */
  1026.       if (current_buffer != XBUFFER (XBUFFER_LOCAL_VALUE (valcontents)->buffer)
  1027.       ||
  1028.       selected_frame != XFRAME (XBUFFER_LOCAL_VALUE (valcontents)->frame)
  1029.       || (BUFFER_LOCAL_VALUEP (valcontents)
  1030.           && EQ (XCONS (current_alist_element)->car,
  1031.              current_alist_element)))
  1032.     {
  1033.       /* Write out the cached value for the old buffer; copy it
  1034.          back to its alist element.  This works if the current
  1035.          buffer only sees the default value, too.  */
  1036.           Fsetcdr (current_alist_element,
  1037.            do_symval_forwarding (XBUFFER_LOCAL_VALUE (valcontents)->realvalue));
  1038.  
  1039.       /* Find the new value for CURRENT-ALIST-ELEMENT.  */
  1040.       tem1 = Fassq (symbol, current_buffer->local_var_alist);
  1041.       XBUFFER_LOCAL_VALUE (valcontents)->found_for_buffer = 1;
  1042.       XBUFFER_LOCAL_VALUE (valcontents)->found_for_frame = 0;
  1043.  
  1044.       if (NILP (tem1))
  1045.         {
  1046.           /* This buffer still sees the default value.  */
  1047.  
  1048.           /* If the variable is a Lisp_Some_Buffer_Local_Value,
  1049.          or if this is `let' rather than `set',
  1050.          make CURRENT-ALIST-ELEMENT point to itself,
  1051.          indicating that we're seeing the default value.  */
  1052.           if (bindflag || SOME_BUFFER_LOCAL_VALUEP (valcontents))
  1053.         {
  1054.           XBUFFER_LOCAL_VALUE (valcontents)->found_for_buffer = 0;
  1055.  
  1056.           if (XBUFFER_LOCAL_VALUE (valcontents)->check_frame)
  1057.             tem1 = Fassq (symbol, selected_frame->param_alist);
  1058.  
  1059.           if (! NILP (tem1))
  1060.             XBUFFER_LOCAL_VALUE (valcontents)->found_for_frame = 1;
  1061.           else
  1062.             tem1 = XBUFFER_LOCAL_VALUE (valcontents)->cdr;
  1063.         }
  1064.           /* If it's a Lisp_Buffer_Local_Value, being set not bound,
  1065.          give this buffer a new assoc for a local value and set
  1066.          CURRENT-ALIST-ELEMENT to point to that.  */
  1067.           else
  1068.         {
  1069.           tem1 = Fcons (symbol, Fcdr (current_alist_element));
  1070.           current_buffer->local_var_alist
  1071.             = Fcons (tem1, current_buffer->local_var_alist);
  1072.         }
  1073.         }
  1074.  
  1075.       /* Cache the new buffer's assoc in CURRENT-ALIST-ELEMENT.  */
  1076.       XCONS (XBUFFER_LOCAL_VALUE (valcontents)->cdr)->car
  1077.         = tem1;
  1078.  
  1079.       /* Set BUFFER and FRAME for binding now loaded.  */
  1080.       XSETBUFFER (XBUFFER_LOCAL_VALUE (valcontents)->buffer,
  1081.               current_buffer);
  1082.       XSETFRAME (XBUFFER_LOCAL_VALUE (valcontents)->frame,
  1083.              selected_frame);
  1084.     }
  1085.       valcontents = XBUFFER_LOCAL_VALUE (valcontents)->realvalue;
  1086.     }
  1087.  
  1088.   /* If storing void (making the symbol void), forward only through
  1089.      buffer-local indicator, not through Lisp_Objfwd, etc.  */
  1090.   if (voide)
  1091.     store_symval_forwarding (symbol, Qnil, newval);
  1092.   else
  1093.     store_symval_forwarding (symbol, valcontents, newval);
  1094.  
  1095.   return newval;
  1096. }
  1097.  
  1098. /* Access or set a buffer-local symbol's default value.  */
  1099.  
  1100. /* Return the default value of SYMBOL, but don't check for voidness.
  1101.    Return Qunbound if it is void.  */
  1102.  
  1103. Lisp_Object
  1104. default_value (symbol)
  1105.      Lisp_Object symbol;
  1106. {
  1107.   register Lisp_Object valcontents;
  1108.  
  1109.   CHECK_SYMBOL (symbol, 0);
  1110.   valcontents = XSYMBOL (symbol)->value;
  1111.  
  1112.   /* For a built-in buffer-local variable, get the default value
  1113.      rather than letting do_symval_forwarding get the current value.  */
  1114.   if (BUFFER_OBJFWDP (valcontents))
  1115.     {
  1116.       register int idx = XBUFFER_OBJFWD (valcontents)->offset;
  1117.  
  1118.       if (XINT (*(Lisp_Object *) (idx + (char *) &buffer_local_flags)) != 0)
  1119.     return *(Lisp_Object *)(idx + (char *) &buffer_defaults);
  1120.     }
  1121.  
  1122.   /* Handle user-created local variables.  */
  1123.   if (BUFFER_LOCAL_VALUEP (valcontents)
  1124.       || SOME_BUFFER_LOCAL_VALUEP (valcontents))
  1125.     {
  1126.       /* If var is set up for a buffer that lacks a local value for it,
  1127.      the current value is nominally the default value.
  1128.      But the current value slot may be more up to date, since
  1129.      ordinary setq stores just that slot.  So use that.  */
  1130.       Lisp_Object current_alist_element, alist_element_car;
  1131.       current_alist_element
  1132.     = XCONS (XBUFFER_LOCAL_VALUE (valcontents)->cdr)->car;
  1133.       alist_element_car = XCONS (current_alist_element)->car;
  1134.       if (EQ (alist_element_car, current_alist_element))
  1135.     return do_symval_forwarding (XBUFFER_LOCAL_VALUE (valcontents)->realvalue);
  1136.       else
  1137.     return XCONS (XBUFFER_LOCAL_VALUE (valcontents)->cdr)->cdr;
  1138.     }
  1139.   /* For other variables, get the current value.  */
  1140.   return do_symval_forwarding (valcontents);
  1141. }
  1142.  
  1143. DEFUN ("default-boundp", Fdefault_boundp, Sdefault_boundp, 1, 1, 0,
  1144.   "Return t if SYMBOL has a non-void default value.\n\
  1145. This is the value that is seen in buffers that do not have their own values\n\
  1146. for this variable.")
  1147.   (symbol)
  1148.      Lisp_Object symbol;
  1149. {
  1150.   register Lisp_Object value;
  1151.  
  1152.   value = default_value (symbol);
  1153.   return (EQ (value, Qunbound) ? Qnil : Qt);
  1154. }
  1155.  
  1156. DEFUN ("default-value", Fdefault_value, Sdefault_value, 1, 1, 0,
  1157.   "Return SYMBOL's default value.\n\
  1158. This is the value that is seen in buffers that do not have their own values\n\
  1159. for this variable.  The default value is meaningful for variables with\n\
  1160. local bindings in certain buffers.")
  1161.   (symbol)
  1162.      Lisp_Object symbol;
  1163. {
  1164.   register Lisp_Object value;
  1165.  
  1166.   value = default_value (symbol);
  1167.   if (EQ (value, Qunbound))
  1168.     return Fsignal (Qvoid_variable, Fcons (symbol, Qnil));
  1169.   return value;
  1170. }
  1171.  
  1172. DEFUN ("set-default", Fset_default, Sset_default, 2, 2, 0,
  1173.   "Set SYMBOL's default value to VAL.  SYMBOL and VAL are evaluated.\n\
  1174. The default value is seen in buffers that do not have their own values\n\
  1175. for this variable.")
  1176.   (symbol, value)
  1177.      Lisp_Object symbol, value;
  1178. {
  1179.   register Lisp_Object valcontents, current_alist_element, alist_element_buffer;
  1180.  
  1181.   CHECK_SYMBOL (symbol, 0);
  1182.   valcontents = XSYMBOL (symbol)->value;
  1183.  
  1184.   /* Handle variables like case-fold-search that have special slots
  1185.      in the buffer.  Make them work apparently like Lisp_Buffer_Local_Value
  1186.      variables.  */
  1187.   if (BUFFER_OBJFWDP (valcontents))
  1188.     {
  1189.       register int idx = XBUFFER_OBJFWD (valcontents)->offset;
  1190.       register struct buffer *b;
  1191.       register int mask = XINT (*((Lisp_Object *)
  1192.                   (idx + (char *)&buffer_local_flags)));
  1193.  
  1194.       *(Lisp_Object *)(idx + (char *) &buffer_defaults) = value;
  1195.  
  1196.       /* If this variable is not always local in all buffers,
  1197.      set it in the buffers that don't nominally have a local value.  */
  1198.       if (mask > 0)
  1199.     {
  1200.       for (b = all_buffers; b; b = b->next)
  1201.         if (!(b->local_var_flags & mask))
  1202.           *(Lisp_Object *)(idx + (char *) b) = value;
  1203.     }
  1204.       return value;
  1205.     }
  1206.  
  1207.   if (!BUFFER_LOCAL_VALUEP (valcontents)
  1208.       && !SOME_BUFFER_LOCAL_VALUEP (valcontents))
  1209.     return Fset (symbol, value);
  1210.  
  1211.   /* Store new value into the DEFAULT-VALUE slot */
  1212.   XCONS (XBUFFER_LOCAL_VALUE (valcontents)->cdr)->cdr = value;
  1213.  
  1214.   /* If that slot is current, we must set the REALVALUE slot too */
  1215.   current_alist_element
  1216.     = XCONS (XBUFFER_LOCAL_VALUE (valcontents)->cdr)->car;
  1217.   alist_element_buffer = Fcar (current_alist_element);
  1218.   if (EQ (alist_element_buffer, current_alist_element))
  1219.     store_symval_forwarding (symbol, XBUFFER_LOCAL_VALUE (valcontents)->realvalue,
  1220.                  value);
  1221.  
  1222.   return value;
  1223. }
  1224.  
  1225. DEFUN ("setq-default", Fsetq_default, Ssetq_default, 2, UNEVALLED, 0,
  1226.        "Set the default value of variable VAR to VALUE.\n\
  1227. VAR, the variable name, is literal (not evaluated);\n\
  1228. VALUE is an expression and it is evaluated.\n\
  1229. The default value of a variable is seen in buffers\n\
  1230. that do not have their own values for the variable.\n\
  1231. \n\
  1232. More generally, you can use multiple variables and values, as in\n\
  1233.   (setq-default SYMBOL VALUE SYMBOL VALUE...)\n\
  1234. This sets each SYMBOL's default value to the corresponding VALUE.\n\
  1235. The VALUE for the Nth SYMBOL can refer to the new default values\n\
  1236. of previous SYMs.")
  1237.   (args)
  1238.      Lisp_Object args;
  1239. {
  1240.   register Lisp_Object args_left;
  1241.   register Lisp_Object val, symbol;
  1242.   struct gcpro gcpro1;
  1243.  
  1244.   if (NILP (args))
  1245.     return Qnil;
  1246.  
  1247.   args_left = args;
  1248.   GCPRO1 (args);
  1249.  
  1250.   do
  1251.     {
  1252.       val = Feval (Fcar (Fcdr (args_left)));
  1253.       symbol = Fcar (args_left);
  1254.       Fset_default (symbol, val);
  1255.       args_left = Fcdr (Fcdr (args_left));
  1256.     }
  1257.   while (!NILP (args_left));
  1258.  
  1259.   UNGCPRO;
  1260.   return val;
  1261. }
  1262.  
  1263. /* Lisp functions for creating and removing buffer-local variables.  */
  1264.  
  1265. DEFUN ("make-variable-buffer-local", Fmake_variable_buffer_local, Smake_variable_buffer_local,
  1266.   1, 1, "vMake Variable Buffer Local: ",
  1267.   "Make VARIABLE have a separate value for each buffer.\n\
  1268. At any time, the value for the current buffer is in effect.\n\
  1269. There is also a default value which is seen in any buffer which has not yet\n\
  1270. set its own value.\n\
  1271. Using `set' or `setq' to set the variable causes it to have a separate value\n\
  1272. for the current buffer if it was previously using the default value.\n\
  1273. The function `default-value' gets the default value and `set-default' sets it.")
  1274.   (variable)
  1275.      register Lisp_Object variable;
  1276. {
  1277.   register Lisp_Object tem, valcontents, newval;
  1278.  
  1279.   CHECK_SYMBOL (variable, 0);
  1280.  
  1281.   valcontents = XSYMBOL (variable)->value;
  1282.   if (EQ (variable, Qnil) || EQ (variable, Qt) || KBOARD_OBJFWDP (valcontents))
  1283.     error ("Symbol %s may not be buffer-local", XSYMBOL (variable)->name->data);
  1284.  
  1285.   if (BUFFER_LOCAL_VALUEP (valcontents) || BUFFER_OBJFWDP (valcontents))
  1286.     return variable;
  1287.   if (SOME_BUFFER_LOCAL_VALUEP (valcontents))
  1288.     {
  1289.       XMISCTYPE (XSYMBOL (variable)->value) = Lisp_Misc_Buffer_Local_Value;
  1290.       return variable;
  1291.     }
  1292.   if (EQ (valcontents, Qunbound))
  1293.     XSYMBOL (variable)->value = Qnil;
  1294.   tem = Fcons (Qnil, Fsymbol_value (variable));
  1295.   XCONS (tem)->car = tem;
  1296.   newval = allocate_misc ();
  1297.   XMISCTYPE (newval) = Lisp_Misc_Buffer_Local_Value;
  1298.   XBUFFER_LOCAL_VALUE (newval)->realvalue = XSYMBOL (variable)->value;
  1299.   XBUFFER_LOCAL_VALUE (newval)->buffer = Fcurrent_buffer ();
  1300.   XBUFFER_LOCAL_VALUE (newval)->frame = Qnil;
  1301.   XBUFFER_LOCAL_VALUE (newval)->found_for_buffer = 1;
  1302.   XBUFFER_LOCAL_VALUE (newval)->found_for_frame = 0;
  1303.   XBUFFER_LOCAL_VALUE (newval)->check_frame = 0;
  1304.   XBUFFER_LOCAL_VALUE (newval)->cdr = tem;
  1305.   XSYMBOL (variable)->value = newval;
  1306.   return variable;
  1307. }
  1308.  
  1309. DEFUN ("make-local-variable", Fmake_local_variable, Smake_local_variable,
  1310.   1, 1, "vMake Local Variable: ",
  1311.   "Make VARIABLE have a separate value in the current buffer.\n\
  1312. Other buffers will continue to share a common default value.\n\
  1313. \(The buffer-local value of VARIABLE starts out as the same value\n\
  1314. VARIABLE previously had.  If VARIABLE was void, it remains void.\)\n\
  1315. See also `make-variable-buffer-local'.\n\n\
  1316. If the variable is already arranged to become local when set,\n\
  1317. this function causes a local value to exist for this buffer,\n\
  1318. just as setting the variable would do.\n\
  1319. \n\
  1320. Do not use `make-local-variable' to make a hook variable buffer-local.\n\
  1321. Use `make-local-hook' instead.")
  1322.   (variable)
  1323.      register Lisp_Object variable;
  1324. {
  1325.   register Lisp_Object tem, valcontents;
  1326.  
  1327.   CHECK_SYMBOL (variable, 0);
  1328.  
  1329.   valcontents = XSYMBOL (variable)->value;
  1330.   if (EQ (variable, Qnil) || EQ (variable, Qt) || KBOARD_OBJFWDP (valcontents))
  1331.     error ("Symbol %s may not be buffer-local", XSYMBOL (variable)->name->data);
  1332.  
  1333.   if (BUFFER_LOCAL_VALUEP (valcontents) || BUFFER_OBJFWDP (valcontents))
  1334.     {
  1335.       tem = Fboundp (variable);
  1336.  
  1337.       /* Make sure the symbol has a local value in this particular buffer,
  1338.      by setting it to the same value it already has.  */
  1339.       Fset (variable, (EQ (tem, Qt) ? Fsymbol_value (variable) : Qunbound));
  1340.       return variable;
  1341.     }
  1342.   /* Make sure symbol is set up to hold per-buffer values */
  1343.   if (!SOME_BUFFER_LOCAL_VALUEP (valcontents))
  1344.     {
  1345.       Lisp_Object newval;
  1346.       tem = Fcons (Qnil, do_symval_forwarding (valcontents));
  1347.       XCONS (tem)->car = tem;
  1348.       newval = allocate_misc ();
  1349.       XMISCTYPE (newval) = Lisp_Misc_Some_Buffer_Local_Value;
  1350.       XBUFFER_LOCAL_VALUE (newval)->realvalue = XSYMBOL (variable)->value;
  1351.       XBUFFER_LOCAL_VALUE (newval)->buffer = Qnil;
  1352.       XBUFFER_LOCAL_VALUE (newval)->frame = Qnil;
  1353.       XBUFFER_LOCAL_VALUE (newval)->found_for_buffer = 0;
  1354.       XBUFFER_LOCAL_VALUE (newval)->found_for_frame = 0;
  1355.       XBUFFER_LOCAL_VALUE (newval)->check_frame = 0;
  1356.       XBUFFER_LOCAL_VALUE (newval)->cdr = tem;
  1357.       XSYMBOL (variable)->value = newval;
  1358.     }
  1359.   /* Make sure this buffer has its own value of symbol */
  1360.   tem = Fassq (variable, current_buffer->local_var_alist);
  1361.   if (NILP (tem))
  1362.     {
  1363.       /* Swap out any local binding for some other buffer, and make
  1364.      sure the current value is permanently recorded, if it's the
  1365.      default value.  */
  1366.       find_symbol_value (variable);
  1367.  
  1368.       current_buffer->local_var_alist
  1369.         = Fcons (Fcons (variable, XCONS (XBUFFER_LOCAL_VALUE (XSYMBOL (variable)->value)->cdr)->cdr),
  1370.          current_buffer->local_var_alist);
  1371.  
  1372.       /* Make sure symbol does not think it is set up for this buffer;
  1373.      force it to look once again for this buffer's value */
  1374.       {
  1375.     Lisp_Object *pvalbuf;
  1376.  
  1377.     valcontents = XSYMBOL (variable)->value;
  1378.  
  1379.     pvalbuf = &XBUFFER_LOCAL_VALUE (valcontents)->buffer;
  1380.     if (current_buffer == XBUFFER (*pvalbuf))
  1381.       *pvalbuf = Qnil;
  1382.     XBUFFER_LOCAL_VALUE (valcontents)->found_for_buffer = 0;
  1383.       }
  1384.     }
  1385.  
  1386.   /* If the symbol forwards into a C variable, then swap in the
  1387.      variable for this buffer immediately.  If C code modifies the
  1388.      variable before we swap in, then that new value will clobber the
  1389.      default value the next time we swap.  */
  1390.   valcontents = XBUFFER_LOCAL_VALUE (XSYMBOL (variable)->value)->realvalue;
  1391.   if (INTFWDP (valcontents) || BOOLFWDP (valcontents) || OBJFWDP (valcontents))
  1392.     swap_in_symval_forwarding (variable, XSYMBOL (variable)->value);
  1393.  
  1394.   return variable;
  1395. }
  1396.  
  1397. DEFUN ("kill-local-variable", Fkill_local_variable, Skill_local_variable,
  1398.   1, 1, "vKill Local Variable: ",
  1399.   "Make VARIABLE no longer have a separate value in the current buffer.\n\
  1400. From now on the default value will apply in this buffer.")
  1401.   (variable)
  1402.      register Lisp_Object variable;
  1403. {
  1404.   register Lisp_Object tem, valcontents;
  1405.  
  1406.   CHECK_SYMBOL (variable, 0);
  1407.  
  1408.   valcontents = XSYMBOL (variable)->value;
  1409.  
  1410.   if (BUFFER_OBJFWDP (valcontents))
  1411.     {
  1412.       register int idx = XBUFFER_OBJFWD (valcontents)->offset;
  1413.       register int mask = XINT (*((Lisp_Object*)
  1414.                   (idx + (char *)&buffer_local_flags)));
  1415.  
  1416.       if (mask > 0)
  1417.     {
  1418.       *(Lisp_Object *)(idx + (char *) current_buffer)
  1419.         = *(Lisp_Object *)(idx + (char *) &buffer_defaults);
  1420.       current_buffer->local_var_flags &= ~mask;
  1421.     }
  1422.       return variable;
  1423.     }
  1424.  
  1425.   if (!BUFFER_LOCAL_VALUEP (valcontents)
  1426.       && !SOME_BUFFER_LOCAL_VALUEP (valcontents))
  1427.     return variable;
  1428.  
  1429.   /* Get rid of this buffer's alist element, if any */
  1430.  
  1431.   tem = Fassq (variable, current_buffer->local_var_alist);
  1432.   if (!NILP (tem))
  1433.     current_buffer->local_var_alist
  1434.       = Fdelq (tem, current_buffer->local_var_alist);
  1435.  
  1436.   /* If the symbol is set up for the current buffer, recompute its
  1437.      value.  We have to do it now, or else forwarded objects won't
  1438.      work right. */
  1439.   {
  1440.     Lisp_Object *pvalbuf;
  1441.     valcontents = XSYMBOL (variable)->value;
  1442.     pvalbuf = &XBUFFER_LOCAL_VALUE (valcontents)->buffer;
  1443.     if (current_buffer == XBUFFER (*pvalbuf))
  1444.       {
  1445.     *pvalbuf = Qnil;
  1446.     XBUFFER_LOCAL_VALUE (valcontents)->found_for_buffer = 0;
  1447.     find_symbol_value (variable);
  1448.       }
  1449.   }
  1450.  
  1451.   return variable;
  1452. }
  1453.  
  1454. /* Lisp functions for creating and removing buffer-local variables.  */
  1455.  
  1456. DEFUN ("make-variable-frame-local", Fmake_variable_frame_local, Smake_variable_frame_local,
  1457.   1, 1, "vMake Variable Frame Local: ",
  1458.   "Enable VARIABLE to have frame-local bindings.\n\
  1459. When a frame-local binding exists in the current frame,\n\
  1460. it is in effect whenever the current buffer has no buffer-local binding.\n\
  1461. A frame-local binding is actual a frame parameter value;\n\
  1462. thus, any given frame has a local binding for VARIABLE\n\
  1463. if it has a value for the frame parameter named VARIABLE.\n\
  1464. See `modify-frame-parameters'.")
  1465.   (variable)
  1466.      register Lisp_Object variable;
  1467. {
  1468.   register Lisp_Object tem, valcontents, newval;
  1469.  
  1470.   CHECK_SYMBOL (variable, 0);
  1471.  
  1472.   valcontents = XSYMBOL (variable)->value;
  1473.   if (EQ (variable, Qnil) || EQ (variable, Qt) || KBOARD_OBJFWDP (valcontents)
  1474.       || BUFFER_OBJFWDP (valcontents))
  1475.     error ("Symbol %s may not be frame-local", XSYMBOL (variable)->name->data);
  1476.  
  1477.   if (BUFFER_LOCAL_VALUEP (valcontents)
  1478.       || SOME_BUFFER_LOCAL_VALUEP (valcontents))
  1479.     return variable;
  1480.  
  1481.   if (EQ (valcontents, Qunbound))
  1482.     XSYMBOL (variable)->value = Qnil;
  1483.   tem = Fcons (Qnil, Fsymbol_value (variable));
  1484.   XCONS (tem)->car = tem;
  1485.   newval = allocate_misc ();
  1486.   XMISCTYPE (newval) = Lisp_Misc_Some_Buffer_Local_Value;
  1487.   XBUFFER_LOCAL_VALUE (newval)->realvalue = XSYMBOL (variable)->value;
  1488.   XBUFFER_LOCAL_VALUE (newval)->buffer = Qnil;
  1489.   XBUFFER_LOCAL_VALUE (newval)->frame = Qnil;
  1490.   XBUFFER_LOCAL_VALUE (newval)->found_for_buffer = 0;
  1491.   XBUFFER_LOCAL_VALUE (newval)->found_for_frame = 0;
  1492.   XBUFFER_LOCAL_VALUE (newval)->check_frame = 1;
  1493.   XBUFFER_LOCAL_VALUE (newval)->cdr = tem;
  1494.   XSYMBOL (variable)->value = newval;
  1495.   return variable;
  1496. }
  1497.  
  1498. DEFUN ("local-variable-p", Flocal_variable_p, Slocal_variable_p,
  1499.   1, 2, 0,
  1500.   "Non-nil if VARIABLE has a local binding in buffer BUFFER.\n\
  1501. BUFFER defaults to the current buffer.")
  1502.   (variable, buffer)
  1503.      register Lisp_Object variable, buffer;
  1504. {
  1505.   Lisp_Object valcontents;
  1506.   register struct buffer *buf;
  1507.  
  1508.   if (NILP (buffer))
  1509.     buf = current_buffer;
  1510.   else
  1511.     {
  1512.       CHECK_BUFFER (buffer, 0);
  1513.       buf = XBUFFER (buffer);
  1514.     }
  1515.  
  1516.   CHECK_SYMBOL (variable, 0);
  1517.  
  1518.   valcontents = XSYMBOL (variable)->value;
  1519.   if (BUFFER_LOCAL_VALUEP (valcontents)
  1520.       || SOME_BUFFER_LOCAL_VALUEP (valcontents))
  1521.     {
  1522.       Lisp_Object tail, elt;
  1523.       for (tail = buf->local_var_alist; CONSP (tail); tail = XCONS (tail)->cdr)
  1524.     {
  1525.       elt = XCONS (tail)->car;
  1526.       if (EQ (variable, XCONS (elt)->car))
  1527.         return Qt;
  1528.     }
  1529.     }
  1530.   if (BUFFER_OBJFWDP (valcontents))
  1531.     {
  1532.       int offset = XBUFFER_OBJFWD (valcontents)->offset;
  1533.       int mask = XINT (*(Lisp_Object *)(offset + (char *)&buffer_local_flags));
  1534.       if (mask == -1 || (buf->local_var_flags & mask))
  1535.     return Qt;
  1536.     }
  1537.   return Qnil;
  1538. }
  1539.  
  1540. DEFUN ("local-variable-if-set-p", Flocal_variable_if_set_p, Slocal_variable_if_set_p,
  1541.   1, 2, 0,
  1542.   "Non-nil if VARIABLE will be local in buffer BUFFER if it is set there.\n\
  1543. BUFFER defaults to the current buffer.")
  1544.   (variable, buffer)
  1545.      register Lisp_Object variable, buffer;
  1546. {
  1547.   Lisp_Object valcontents;
  1548.   register struct buffer *buf;
  1549.  
  1550.   if (NILP (buffer))
  1551.     buf = current_buffer;
  1552.   else
  1553.     {
  1554.       CHECK_BUFFER (buffer, 0);
  1555.       buf = XBUFFER (buffer);
  1556.     }
  1557.  
  1558.   CHECK_SYMBOL (variable, 0);
  1559.  
  1560.   valcontents = XSYMBOL (variable)->value;
  1561.  
  1562.   /* This means that make-variable-buffer-local was done.  */
  1563.   if (BUFFER_LOCAL_VALUEP (valcontents))
  1564.     return Qt;
  1565.   /* All these slots become local if they are set.  */
  1566.   if (BUFFER_OBJFWDP (valcontents))
  1567.     return Qt;
  1568.   if (SOME_BUFFER_LOCAL_VALUEP (valcontents))
  1569.     {
  1570.       Lisp_Object tail, elt;
  1571.       for (tail = buf->local_var_alist; CONSP (tail); tail = XCONS (tail)->cdr)
  1572.     {
  1573.       elt = XCONS (tail)->car;
  1574.       if (EQ (variable, XCONS (elt)->car))
  1575.         return Qt;
  1576.     }
  1577.     }
  1578.   return Qnil;
  1579. }
  1580.  
  1581. /* Find the function at the end of a chain of symbol function indirections.  */
  1582.  
  1583. /* If OBJECT is a symbol, find the end of its function chain and
  1584.    return the value found there.  If OBJECT is not a symbol, just
  1585.    return it.  If there is a cycle in the function chain, signal a
  1586.    cyclic-function-indirection error.
  1587.  
  1588.    This is like Findirect_function, except that it doesn't signal an
  1589.    error if the chain ends up unbound.  */
  1590. Lisp_Object
  1591. indirect_function (object)
  1592.      register Lisp_Object object;
  1593. {
  1594.   Lisp_Object tortoise, hare;
  1595.  
  1596.   hare = tortoise = object;
  1597.  
  1598.   for (;;)
  1599.     {
  1600.       if (!SYMBOLP (hare) || EQ (hare, Qunbound))
  1601.     break;
  1602.       hare = XSYMBOL (hare)->function;
  1603.       if (!SYMBOLP (hare) || EQ (hare, Qunbound))
  1604.     break;
  1605.       hare = XSYMBOL (hare)->function;
  1606.  
  1607.       tortoise = XSYMBOL (tortoise)->function;
  1608.  
  1609.       if (EQ (hare, tortoise))
  1610.     Fsignal (Qcyclic_function_indirection, Fcons (object, Qnil));
  1611.     }
  1612.  
  1613.   return hare;
  1614. }
  1615.  
  1616. DEFUN ("indirect-function", Findirect_function, Sindirect_function, 1, 1, 0,
  1617.   "Return the function at the end of OBJECT's function chain.\n\
  1618. If OBJECT is a symbol, follow all function indirections and return the final\n\
  1619. function binding.\n\
  1620. If OBJECT is not a symbol, just return it.\n\
  1621. Signal a void-function error if the final symbol is unbound.\n\
  1622. Signal a cyclic-function-indirection error if there is a loop in the\n\
  1623. function chain of symbols.")
  1624.   (object)
  1625.     register Lisp_Object object;
  1626. {
  1627.   Lisp_Object result;
  1628.  
  1629.   result = indirect_function (object);
  1630.  
  1631.   if (EQ (result, Qunbound))
  1632.     return Fsignal (Qvoid_function, Fcons (object, Qnil));
  1633.   return result;
  1634. }
  1635.  
  1636. /* Extract and set vector and string elements */
  1637.  
  1638. DEFUN ("aref", Faref, Saref, 2, 2, 0,
  1639.   "Return the element of ARRAY at index IDX.\n\
  1640. ARRAY may be a vector, a string, a char-table, a bool-vector,\n\
  1641. or a byte-code object.  IDX starts at 0.")
  1642.   (array, idx)
  1643.      register Lisp_Object array;
  1644.      Lisp_Object idx;
  1645. {
  1646.   register int idxval;
  1647.  
  1648.   CHECK_NUMBER (idx, 1);
  1649.   idxval = XINT (idx);
  1650.   if (STRINGP (array))
  1651.     {
  1652.       Lisp_Object val;
  1653.       int c, idxval_byte;
  1654.  
  1655.       if (idxval < 0 || idxval >= XSTRING (array)->size)
  1656.     args_out_of_range (array, idx);
  1657.       if (! STRING_MULTIBYTE (array))
  1658.     return make_number ((unsigned char) XSTRING (array)->data[idxval]);
  1659.       idxval_byte = string_char_to_byte (array, idxval);
  1660.  
  1661.       c = STRING_CHAR (&XSTRING (array)->data[idxval_byte],
  1662.                STRING_BYTES (XSTRING (array)) - idxval_byte);
  1663.       return make_number (c);
  1664.     }
  1665.   else if (BOOL_VECTOR_P (array))
  1666.     {
  1667.       int val;
  1668.  
  1669.       if (idxval < 0 || idxval >= XBOOL_VECTOR (array)->size)
  1670.     args_out_of_range (array, idx);
  1671.  
  1672.       val = (unsigned char) XBOOL_VECTOR (array)->data[idxval / BITS_PER_CHAR];
  1673.       return (val & (1 << (idxval % BITS_PER_CHAR)) ? Qt : Qnil);
  1674.     }
  1675.   else if (CHAR_TABLE_P (array))
  1676.     {
  1677.       Lisp_Object val;
  1678.  
  1679.       if (idxval < 0)
  1680.     args_out_of_range (array, idx);
  1681.       if (idxval < CHAR_TABLE_ORDINARY_SLOTS)
  1682.     {
  1683.       /* For ASCII and 8-bit European characters, the element is
  1684.              stored in the top table.  */
  1685.       val = XCHAR_TABLE (array)->contents[idxval];
  1686.       if (NILP (val))
  1687.         val = XCHAR_TABLE (array)->defalt;
  1688.       while (NILP (val))    /* Follow parents until we find some value.  */
  1689.         {
  1690.           array = XCHAR_TABLE (array)->parent;
  1691.           if (NILP (array))
  1692.         return Qnil;
  1693.           val = XCHAR_TABLE (array)->contents[idxval];
  1694.           if (NILP (val))
  1695.         val = XCHAR_TABLE (array)->defalt;
  1696.         }
  1697.       return val;
  1698.     }
  1699.       else
  1700.     {
  1701.       int code[4], i;
  1702.       Lisp_Object sub_table;
  1703.  
  1704.       SPLIT_NON_ASCII_CHAR (idxval, code[0], code[1], code[2]);
  1705.       if (code[0] != CHARSET_COMPOSITION)
  1706.         {
  1707.           if (code[1] < 32) code[1] = -1;
  1708.           else if (code[2] < 32) code[2] = -1;
  1709.         }
  1710.       /* Here, the possible range of CODE[0] (== charset ID) is
  1711.         128..MAX_CHARSET.  Since the top level char table contains
  1712.         data for multibyte characters after 256th element, we must
  1713.         increment CODE[0] by 128 to get a correct index.  */
  1714.       code[0] += 128;
  1715.       code[3] = -1;        /* anchor */
  1716.  
  1717.     try_parent_char_table:
  1718.       sub_table = array;
  1719.       for (i = 0; code[i] >= 0; i++)
  1720.         {
  1721.           val = XCHAR_TABLE (sub_table)->contents[code[i]];
  1722.           if (SUB_CHAR_TABLE_P (val))
  1723.         sub_table = val;
  1724.           else
  1725.         {
  1726.           if (NILP (val))
  1727.             val = XCHAR_TABLE (sub_table)->defalt;
  1728.           if (NILP (val))
  1729.             {
  1730.               array = XCHAR_TABLE (array)->parent;
  1731.               if (!NILP (array))
  1732.             goto try_parent_char_table;
  1733.             }
  1734.           return val;
  1735.         }
  1736.         }
  1737.       /* Here, VAL is a sub char table.  We try the default value
  1738.              and parent.  */
  1739.       val = XCHAR_TABLE (val)->defalt;
  1740.       if (NILP (val))
  1741.         {
  1742.           array = XCHAR_TABLE (array)->parent;
  1743.           if (!NILP (array))
  1744.         goto try_parent_char_table;
  1745.         }
  1746.       return val;
  1747.     }
  1748.     }
  1749.   else
  1750.     {
  1751.       int size;
  1752.       if (VECTORP (array))
  1753.     size = XVECTOR (array)->size;
  1754.       else if (COMPILEDP (array))
  1755.     size = XVECTOR (array)->size & PSEUDOVECTOR_SIZE_MASK;
  1756.       else
  1757.     wrong_type_argument (Qarrayp, array);
  1758.  
  1759.       if (idxval < 0 || idxval >= size)
  1760.     args_out_of_range (array, idx);
  1761.       return XVECTOR (array)->contents[idxval];
  1762.     }
  1763. }
  1764.  
  1765. DEFUN ("aset", Faset, Saset, 3, 3, 0,
  1766.   "Store into the element of ARRAY at index IDX the value NEWELT.\n\
  1767. ARRAY may be a vector, a string, a char-table or a bool-vector.\n\
  1768. IDX starts at 0.")
  1769.   (array, idx, newelt)
  1770.      register Lisp_Object array;
  1771.      Lisp_Object idx, newelt;
  1772. {
  1773.   register int idxval;
  1774.  
  1775.   CHECK_NUMBER (idx, 1);
  1776.   idxval = XINT (idx);
  1777.   if (!VECTORP (array) && !STRINGP (array) && !BOOL_VECTOR_P (array)
  1778.       && ! CHAR_TABLE_P (array))
  1779.     array = wrong_type_argument (Qarrayp, array);
  1780.   CHECK_IMPURE (array);
  1781.  
  1782.   if (VECTORP (array))
  1783.     {
  1784.       if (idxval < 0 || idxval >= XVECTOR (array)->size)
  1785.     args_out_of_range (array, idx);
  1786.       XVECTOR (array)->contents[idxval] = newelt;
  1787.     }
  1788.   else if (BOOL_VECTOR_P (array))
  1789.     {
  1790.       int val;
  1791.  
  1792.       if (idxval < 0 || idxval >= XBOOL_VECTOR (array)->size)
  1793.     args_out_of_range (array, idx);
  1794.  
  1795.       val = (unsigned char) XBOOL_VECTOR (array)->data[idxval / BITS_PER_CHAR];
  1796.  
  1797.       if (! NILP (newelt))
  1798.     val |= 1 << (idxval % BITS_PER_CHAR);
  1799.       else
  1800.     val &= ~(1 << (idxval % BITS_PER_CHAR));
  1801.       XBOOL_VECTOR (array)->data[idxval / BITS_PER_CHAR] = val;
  1802.     }
  1803.   else if (CHAR_TABLE_P (array))
  1804.     {
  1805.       Lisp_Object val;
  1806.  
  1807.       if (idxval < 0)
  1808.     args_out_of_range (array, idx);
  1809.       if (idxval < CHAR_TABLE_ORDINARY_SLOTS)
  1810.     XCHAR_TABLE (array)->contents[idxval] = newelt;
  1811.       else
  1812.     {
  1813.       int code[4], i;
  1814.       Lisp_Object val;
  1815.  
  1816.       SPLIT_NON_ASCII_CHAR (idxval, code[0], code[1], code[2]);
  1817.       if (code[0] != CHARSET_COMPOSITION)
  1818.         {
  1819.           if (code[1] < 32) code[1] = -1;
  1820.           else if (code[2] < 32) code[2] = -1;
  1821.         }
  1822.       /* See the comment of the corresponding part in Faref.  */
  1823.       code[0] += 128;
  1824.       code[3] = -1;        /* anchor */
  1825.       for (i = 0; code[i + 1] >= 0; i++)
  1826.         {
  1827.           val = XCHAR_TABLE (array)->contents[code[i]];
  1828.           if (SUB_CHAR_TABLE_P (val))
  1829.         array = val;
  1830.           else
  1831.         {
  1832.           Lisp_Object temp;
  1833.  
  1834.           /* VAL is a leaf.  Create a sub char table with the
  1835.              default value VAL or XCHAR_TABLE (array)->defalt
  1836.              and look into it.  */
  1837.  
  1838.           temp = make_sub_char_table (NILP (val)
  1839.                           ? XCHAR_TABLE (array)->defalt
  1840.                           : val);
  1841.           XCHAR_TABLE (array)->contents[code[i]] = temp;
  1842.           array = temp;
  1843.         }
  1844.         }
  1845.       XCHAR_TABLE (array)->contents[code[i]] = newelt;
  1846.     }
  1847.     }
  1848.   else if (STRING_MULTIBYTE (array))
  1849.     {
  1850.       Lisp_Object new_len;
  1851.       int c, idxval_byte, actual_len;
  1852.       unsigned char *p, *str;
  1853.  
  1854.       if (idxval < 0 || idxval >= XSTRING (array)->size)
  1855.     args_out_of_range (array, idx);
  1856.  
  1857.       idxval_byte = string_char_to_byte (array, idxval);
  1858.       p = &XSTRING (array)->data[idxval_byte];
  1859.  
  1860.       actual_len
  1861.     = MULTIBYTE_FORM_LENGTH (p, STRING_BYTES (XSTRING (array)) - idxval_byte);
  1862.       new_len = Fchar_bytes (newelt);
  1863.       if (actual_len != XINT (new_len))
  1864.     error ("Attempt to change byte length of a string");
  1865.  
  1866.       CHAR_STRING (XINT (newelt), p, str);
  1867.       if (p != str)
  1868.     bcopy (str, p, actual_len);
  1869.     }
  1870.   else
  1871.     {
  1872.       if (idxval < 0 || idxval >= XSTRING (array)->size)
  1873.     args_out_of_range (array, idx);
  1874.       CHECK_NUMBER (newelt, 2);
  1875.       XSTRING (array)->data[idxval] = XINT (newelt);
  1876.     }
  1877.  
  1878.   return newelt;
  1879. }
  1880.  
  1881. /* Arithmetic functions */
  1882.  
  1883. enum comparison { equal, notequal, less, grtr, less_or_equal, grtr_or_equal };
  1884.  
  1885. Lisp_Object
  1886. arithcompare (num1, num2, comparison)
  1887.      Lisp_Object num1, num2;
  1888.      enum comparison comparison;
  1889. {
  1890.   double f1, f2;
  1891.   int floatp = 0;
  1892.  
  1893. #ifdef LISP_FLOAT_TYPE
  1894.   CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (num1, 0);
  1895.   CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (num2, 0);
  1896.  
  1897.   if (FLOATP (num1) || FLOATP (num2))
  1898.     {
  1899.       floatp = 1;
  1900.       f1 = (FLOATP (num1)) ? XFLOAT (num1)->data : XINT (num1);
  1901.       f2 = (FLOATP (num2)) ? XFLOAT (num2)->data : XINT (num2);
  1902.     }
  1903. #else
  1904.   CHECK_NUMBER_COERCE_MARKER (num1, 0);
  1905.   CHECK_NUMBER_COERCE_MARKER (num2, 0);
  1906. #endif /* LISP_FLOAT_TYPE */
  1907.  
  1908.   switch (comparison)
  1909.     {
  1910.     case equal:
  1911.       if (floatp ? f1 == f2 : XINT (num1) == XINT (num2))
  1912.     return Qt;
  1913.       return Qnil;
  1914.  
  1915.     case notequal:
  1916.       if (floatp ? f1 != f2 : XINT (num1) != XINT (num2))
  1917.     return Qt;
  1918.       return Qnil;
  1919.  
  1920.     case less:
  1921.       if (floatp ? f1 < f2 : XINT (num1) < XINT (num2))
  1922.     return Qt;
  1923.       return Qnil;
  1924.  
  1925.     case less_or_equal:
  1926.       if (floatp ? f1 <= f2 : XINT (num1) <= XINT (num2))
  1927.     return Qt;
  1928.       return Qnil;
  1929.  
  1930.     case grtr:
  1931.       if (floatp ? f1 > f2 : XINT (num1) > XINT (num2))
  1932.     return Qt;
  1933.       return Qnil;
  1934.  
  1935.     case grtr_or_equal:
  1936.       if (floatp ? f1 >= f2 : XINT (num1) >= XINT (num2))
  1937.     return Qt;
  1938.       return Qnil;
  1939.  
  1940.     default:
  1941.       abort ();
  1942.     }
  1943. }
  1944.  
  1945. DEFUN ("=", Feqlsign, Seqlsign, 2, 2, 0,
  1946.   "Return t if two args, both numbers or markers, are equal.")
  1947.   (num1, num2)
  1948.      register Lisp_Object num1, num2;
  1949. {
  1950.   return arithcompare (num1, num2, equal);
  1951. }
  1952.  
  1953. DEFUN ("<", Flss, Slss, 2, 2, 0,
  1954.   "Return t if first arg is less than second arg.  Both must be numbers or markers.")
  1955.   (num1, num2)
  1956.      register Lisp_Object num1, num2;
  1957. {
  1958.   return arithcompare (num1, num2, less);
  1959. }
  1960.  
  1961. DEFUN (">", Fgtr, Sgtr, 2, 2, 0,
  1962.   "Return t if first arg is greater than second arg.  Both must be numbers or markers.")
  1963.   (num1, num2)
  1964.      register Lisp_Object num1, num2;
  1965. {
  1966.   return arithcompare (num1, num2, grtr);
  1967. }
  1968.  
  1969. DEFUN ("<=", Fleq, Sleq, 2, 2, 0,
  1970.   "Return t if first arg is less than or equal to second arg.\n\
  1971. Both must be numbers or markers.")
  1972.   (num1, num2)
  1973.      register Lisp_Object num1, num2;
  1974. {
  1975.   return arithcompare (num1, num2, less_or_equal);
  1976. }
  1977.  
  1978. DEFUN (">=", Fgeq, Sgeq, 2, 2, 0,
  1979.   "Return t if first arg is greater than or equal to second arg.\n\
  1980. Both must be numbers or markers.")
  1981.   (num1, num2)
  1982.      register Lisp_Object num1, num2;
  1983. {
  1984.   return arithcompare (num1, num2, grtr_or_equal);
  1985. }
  1986.  
  1987. DEFUN ("/=", Fneq, Sneq, 2, 2, 0,
  1988.   "Return t if first arg is not equal to second arg.  Both must be numbers or markers.")
  1989.   (num1, num2)
  1990.      register Lisp_Object num1, num2;
  1991. {
  1992.   return arithcompare (num1, num2, notequal);
  1993. }
  1994.  
  1995. DEFUN ("zerop", Fzerop, Szerop, 1, 1, 0, "Return t if NUMBER is zero.")
  1996.   (number)
  1997.      register Lisp_Object number;
  1998. {
  1999. #ifdef LISP_FLOAT_TYPE
  2000.   CHECK_NUMBER_OR_FLOAT (number, 0);
  2001.  
  2002.   if (FLOATP (number))
  2003.     {
  2004.       if (XFLOAT(number)->data == 0.0)
  2005.     return Qt;
  2006.       return Qnil;
  2007.     }
  2008. #else
  2009.   CHECK_NUMBER (number, 0);
  2010. #endif /* LISP_FLOAT_TYPE */
  2011.  
  2012.   if (!XINT (number))
  2013.     return Qt;
  2014.   return Qnil;
  2015. }
  2016.  
  2017. /* Convert between long values and pairs of Lisp integers.  */
  2018.  
  2019. Lisp_Object
  2020. long_to_cons (i)
  2021.      unsigned long i;
  2022. {
  2023.   unsigned int top = i >> 16;
  2024.   unsigned int bot = i & 0xFFFF;
  2025.   if (top == 0)
  2026.     return make_number (bot);
  2027.   if (top == (unsigned long)-1 >> 16)
  2028.     return Fcons (make_number (-1), make_number (bot));
  2029.   return Fcons (make_number (top), make_number (bot));
  2030. }
  2031.  
  2032. unsigned long
  2033. cons_to_long (c)
  2034.      Lisp_Object c;
  2035. {
  2036.   Lisp_Object top, bot;
  2037.   if (INTEGERP (c))
  2038.     return XINT (c);
  2039.   top = XCONS (c)->car;
  2040.   bot = XCONS (c)->cdr;
  2041.   if (CONSP (bot))
  2042.     bot = XCONS (bot)->car;
  2043.   return ((XINT (top) << 16) | XINT (bot));
  2044. }
  2045.  
  2046. DEFUN ("number-to-string", Fnumber_to_string, Snumber_to_string, 1, 1, 0,
  2047.   "Convert NUMBER to a string by printing it in decimal.\n\
  2048. Uses a minus sign if negative.\n\
  2049. NUMBER may be an integer or a floating point number.")
  2050.   (number)
  2051.      Lisp_Object number;
  2052. {
  2053.   char buffer[VALBITS];
  2054.  
  2055. #ifndef LISP_FLOAT_TYPE
  2056.   CHECK_NUMBER (number, 0);
  2057. #else
  2058.   CHECK_NUMBER_OR_FLOAT (number, 0);
  2059.  
  2060.   if (FLOATP (number))
  2061.     {
  2062.       char pigbuf[350];    /* see comments in float_to_string */
  2063.  
  2064.       float_to_string (pigbuf, XFLOAT(number)->data);
  2065.       return build_string (pigbuf);
  2066.     }
  2067. #endif /* LISP_FLOAT_TYPE */
  2068.  
  2069.   if (sizeof (int) == sizeof (EMACS_INT))
  2070.     sprintf (buffer, "%d", XINT (number));
  2071.   else if (sizeof (long) == sizeof (EMACS_INT))
  2072.     sprintf (buffer, "%ld", XINT (number));
  2073.   else
  2074.     abort ();
  2075.   return build_string (buffer);
  2076. }
  2077.  
  2078. INLINE static int
  2079. digit_to_number (character, base)
  2080.      int character, base;
  2081. {
  2082.   int digit;
  2083.  
  2084.   if (character >= '0' && character <= '9')
  2085.     digit = character - '0';
  2086.   else if (character >= 'a' && character <= 'z')
  2087.     digit = character - 'a' + 10;
  2088.   else if (character >= 'A' && character <= 'Z')
  2089.     digit = character - 'A' + 10;
  2090.   else
  2091.     return -1;
  2092.  
  2093.   if (digit >= base)
  2094.     return -1;
  2095.   else
  2096.     return digit;
  2097. }    
  2098.  
  2099. DEFUN ("string-to-number", Fstring_to_number, Sstring_to_number, 1, 2, 0,
  2100.   "Convert STRING to a number by parsing it as a decimal number.\n\
  2101. This parses both integers and floating point numbers.\n\
  2102. It ignores leading spaces and tabs.\n\
  2103. \n\
  2104. If BASE, interpret STRING as a number in that base.  If BASE isn't\n\
  2105. present, base 10 is used.  BASE must be between 2 and 16 (inclusive).\n\
  2106. Floating point numbers always use base 10.")
  2107.    (string, base)
  2108.      register Lisp_Object string, base;
  2109. {
  2110.   register unsigned char *p;
  2111.   register int b, digit, v = 0;
  2112.   int negative = 1;
  2113.  
  2114.   CHECK_STRING (string, 0);
  2115.  
  2116.   if (NILP (base))
  2117.     b = 10;
  2118.   else
  2119.     {
  2120.       CHECK_NUMBER (base, 1);
  2121.       b = XINT (base);
  2122.       if (b < 2 || b > 16)
  2123.     Fsignal (Qargs_out_of_range, Fcons (base, Qnil));
  2124.     }
  2125.  
  2126.   p = XSTRING (string)->data;
  2127.  
  2128.   /* Skip any whitespace at the front of the number.  Some versions of
  2129.      atoi do this anyway, so we might as well make Emacs lisp consistent.  */
  2130.   while (*p == ' ' || *p == '\t')
  2131.     p++;
  2132.  
  2133.   if (*p == '-')
  2134.     {
  2135.       negative = -1;
  2136.       p++;
  2137.     }
  2138.   else if (*p == '+')
  2139.     p++;
  2140.   
  2141. #ifdef LISP_FLOAT_TYPE
  2142.   if (isfloat_string (p))
  2143.     return make_float (negative * atof (p));
  2144. #endif /* LISP_FLOAT_TYPE */
  2145.  
  2146.   while (1)
  2147.     {
  2148.       int digit = digit_to_number (*p++, b);
  2149.       if (digit < 0)
  2150.     break;
  2151.       v = v * b + digit;
  2152.     }
  2153.   
  2154.   return make_number (negative * v);
  2155. }
  2156.  
  2157.  
  2158. enum arithop
  2159.   { Aadd, Asub, Amult, Adiv, Alogand, Alogior, Alogxor, Amax, Amin };
  2160.  
  2161. extern Lisp_Object float_arith_driver ();
  2162. extern Lisp_Object fmod_float ();
  2163.  
  2164. Lisp_Object
  2165. arith_driver (code, nargs, args)
  2166.      enum arithop code;
  2167.      int nargs;
  2168.      register Lisp_Object *args;
  2169. {
  2170.   register Lisp_Object val;
  2171.   register int argnum;
  2172.   register EMACS_INT accum;
  2173.   register EMACS_INT next;
  2174.  
  2175.   switch (SWITCH_ENUM_CAST (code))
  2176.     {
  2177.     case Alogior:
  2178.     case Alogxor:
  2179.     case Aadd:
  2180.     case Asub:
  2181.       accum = 0; break;
  2182.     case Amult:
  2183.       accum = 1; break;
  2184.     case Alogand:
  2185.       accum = -1; break;
  2186.     }
  2187.  
  2188.   for (argnum = 0; argnum < nargs; argnum++)
  2189.     {
  2190.       val = args[argnum];    /* using args[argnum] as argument to CHECK_NUMBER_... */
  2191. #ifdef LISP_FLOAT_TYPE
  2192.       CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (val, argnum);
  2193.  
  2194.       if (FLOATP (val)) /* time to do serious math */
  2195.     return (float_arith_driver ((double) accum, argnum, code,
  2196.                     nargs, args));
  2197. #else
  2198.       CHECK_NUMBER_COERCE_MARKER (val, argnum);
  2199. #endif /* LISP_FLOAT_TYPE */
  2200.       args[argnum] = val;    /* runs into a compiler bug. */
  2201.       next = XINT (args[argnum]);
  2202.       switch (SWITCH_ENUM_CAST (code))
  2203.     {
  2204.     case Aadd: accum += next; break;
  2205.     case Asub:
  2206.       if (!argnum && nargs != 1)
  2207.         next = - next;
  2208.       accum -= next;
  2209.       break;
  2210.     case Amult: accum *= next; break;
  2211.     case Adiv:
  2212.       if (!argnum) accum = next;
  2213.       else
  2214.         {
  2215.           if (next == 0)
  2216.         Fsignal (Qarith_error, Qnil);
  2217.           accum /= next;
  2218.         }
  2219.       break;
  2220.     case Alogand: accum &= next; break;
  2221.     case Alogior: accum |= next; break;
  2222.     case Alogxor: accum ^= next; break;
  2223.     case Amax: if (!argnum || next > accum) accum = next; break;
  2224.     case Amin: if (!argnum || next < accum) accum = next; break;
  2225.     }
  2226.     }
  2227.  
  2228.   XSETINT (val, accum);
  2229.   return val;
  2230. }
  2231.  
  2232. #undef isnan
  2233. #define isnan(x) ((x) != (x))
  2234.  
  2235. #ifdef LISP_FLOAT_TYPE
  2236.  
  2237. Lisp_Object
  2238. float_arith_driver (accum, argnum, code, nargs, args)
  2239.      double accum;
  2240.      register int argnum;
  2241.      enum arithop code;
  2242.      int nargs;
  2243.      register Lisp_Object *args;
  2244. {
  2245.   register Lisp_Object val;
  2246.   double next;
  2247.  
  2248.   for (; argnum < nargs; argnum++)
  2249.     {
  2250.       val = args[argnum];    /* using args[argnum] as argument to CHECK_NUMBER_... */
  2251.       CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (val, argnum);
  2252.  
  2253.       if (FLOATP (val))
  2254.     {
  2255.       next = XFLOAT (val)->data;
  2256.     }
  2257.       else
  2258.     {
  2259.       args[argnum] = val;    /* runs into a compiler bug. */
  2260.       next = XINT (args[argnum]);
  2261.     }
  2262.       switch (SWITCH_ENUM_CAST (code))
  2263.     {
  2264.     case Aadd:
  2265.       accum += next;
  2266.       break;
  2267.     case Asub:
  2268.       if (!argnum && nargs != 1)
  2269.         next = - next;
  2270.       accum -= next;
  2271.       break;
  2272.     case Amult:
  2273.       accum *= next;
  2274.       break;
  2275.     case Adiv:
  2276.       if (!argnum)
  2277.         accum = next;
  2278.       else
  2279.         {
  2280.           if (! IEEE_FLOATING_POINT && next == 0)
  2281.         Fsignal (Qarith_error, Qnil);
  2282.           accum /= next;
  2283.         }
  2284.       break;
  2285.     case Alogand:
  2286.     case Alogior:
  2287.     case Alogxor:
  2288.       return wrong_type_argument (Qinteger_or_marker_p, val);
  2289.     case Amax:
  2290.       if (!argnum || isnan (next) || next > accum)
  2291.         accum = next;
  2292.       break;
  2293.     case Amin:
  2294.       if (!argnum || isnan (next) || next < accum)
  2295.         accum = next;
  2296.       break;
  2297.     }
  2298.     }
  2299.  
  2300.   return make_float (accum);
  2301. }
  2302. #endif /* LISP_FLOAT_TYPE */
  2303.  
  2304. DEFUN ("+", Fplus, Splus, 0, MANY, 0,
  2305.   "Return sum of any number of arguments, which are numbers or markers.")
  2306.   (nargs, args)
  2307.      int nargs;
  2308.      Lisp_Object *args;
  2309. {
  2310.   return arith_driver (Aadd, nargs, args);
  2311. }
  2312.  
  2313. DEFUN ("-", Fminus, Sminus, 0, MANY, 0,
  2314.   "Negate number or subtract numbers or markers.\n\
  2315. With one arg, negates it.  With more than one arg,\n\
  2316. subtracts all but the first from the first.")
  2317.   (nargs, args)
  2318.      int nargs;
  2319.      Lisp_Object *args;
  2320. {
  2321.   return arith_driver (Asub, nargs, args);
  2322. }
  2323.  
  2324. DEFUN ("*", Ftimes, Stimes, 0, MANY, 0,
  2325.   "Returns product of any number of arguments, which are numbers or markers.")
  2326.   (nargs, args)
  2327.      int nargs;
  2328.      Lisp_Object *args;
  2329. {
  2330.   return arith_driver (Amult, nargs, args);
  2331. }
  2332.  
  2333. DEFUN ("/", Fquo, Squo, 2, MANY, 0,
  2334.   "Returns first argument divided by all the remaining arguments.\n\
  2335. The arguments must be numbers or markers.")
  2336.   (nargs, args)
  2337.      int nargs;
  2338.      Lisp_Object *args;
  2339. {
  2340.   return arith_driver (Adiv, nargs, args);
  2341. }
  2342.  
  2343. DEFUN ("%", Frem, Srem, 2, 2, 0,
  2344.   "Returns remainder of X divided by Y.\n\
  2345. Both must be integers or markers.")
  2346.   (x, y)
  2347.      register Lisp_Object x, y;
  2348. {
  2349.   Lisp_Object val;
  2350.  
  2351.   CHECK_NUMBER_COERCE_MARKER (x, 0);
  2352.   CHECK_NUMBER_COERCE_MARKER (y, 1);
  2353.  
  2354.   if (XFASTINT (y) == 0)
  2355.     Fsignal (Qarith_error, Qnil);
  2356.  
  2357.   XSETINT (val, XINT (x) % XINT (y));
  2358.   return val;
  2359. }
  2360.  
  2361. #ifndef HAVE_FMOD
  2362. double
  2363. fmod (f1, f2)
  2364.      double f1, f2;
  2365. {
  2366.   double r = f1;
  2367.  
  2368.   if (f2 < 0.0)
  2369.     f2 = -f2;
  2370.  
  2371.   /* If the magnitude of the result exceeds that of the divisor, or
  2372.      the sign of the result does not agree with that of the dividend,
  2373.      iterate with the reduced value.  This does not yield a
  2374.      particularly accurate result, but at least it will be in the
  2375.      range promised by fmod.  */
  2376.   do
  2377.     r -= f2 * floor (r / f2);
  2378.   while (f2 <= (r < 0 ? -r : r) || ((r < 0) != (f1 < 0) && ! isnan (r)));
  2379.  
  2380.   return r;
  2381. }
  2382. #endif /* ! HAVE_FMOD */
  2383.  
  2384. DEFUN ("mod", Fmod, Smod, 2, 2, 0,
  2385.   "Returns X modulo Y.\n\
  2386. The result falls between zero (inclusive) and Y (exclusive).\n\
  2387. Both X and Y must be numbers or markers.")
  2388.   (x, y)
  2389.      register Lisp_Object x, y;
  2390. {
  2391.   Lisp_Object val;
  2392.   EMACS_INT i1, i2;
  2393.  
  2394. #ifdef LISP_FLOAT_TYPE
  2395.   CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (x, 0);
  2396.   CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (y, 1);
  2397.  
  2398.   if (FLOATP (x) || FLOATP (y))
  2399.     return fmod_float (x, y);
  2400.  
  2401. #else /* not LISP_FLOAT_TYPE */
  2402.   CHECK_NUMBER_COERCE_MARKER (x, 0);
  2403.   CHECK_NUMBER_COERCE_MARKER (y, 1);
  2404. #endif /* not LISP_FLOAT_TYPE */
  2405.  
  2406.   i1 = XINT (x);
  2407.   i2 = XINT (y);
  2408.  
  2409.   if (i2 == 0)
  2410.     Fsignal (Qarith_error, Qnil);
  2411.  
  2412.   i1 %= i2;
  2413.  
  2414.   /* If the "remainder" comes out with the wrong sign, fix it.  */
  2415.   if (i2 < 0 ? i1 > 0 : i1 < 0)
  2416.     i1 += i2;
  2417.  
  2418.   XSETINT (val, i1);
  2419.   return val;
  2420. }
  2421.  
  2422. DEFUN ("max", Fmax, Smax, 1, MANY, 0,
  2423.   "Return largest of all the arguments (which must be numbers or markers).\n\
  2424. The value is always a number; markers are converted to numbers.")
  2425.   (nargs, args)
  2426.      int nargs;
  2427.      Lisp_Object *args;
  2428. {
  2429.   return arith_driver (Amax, nargs, args);
  2430. }
  2431.  
  2432. DEFUN ("min", Fmin, Smin, 1, MANY, 0,
  2433.   "Return smallest of all the arguments (which must be numbers or markers).\n\
  2434. The value is always a number; markers are converted to numbers.")
  2435.   (nargs, args)
  2436.      int nargs;
  2437.      Lisp_Object *args;
  2438. {
  2439.   return arith_driver (Amin, nargs, args);
  2440. }
  2441.  
  2442. DEFUN ("logand", Flogand, Slogand, 0, MANY, 0,
  2443.   "Return bitwise-and of all the arguments.\n\
  2444. Arguments may be integers, or markers converted to integers.")
  2445.   (nargs, args)
  2446.      int nargs;
  2447.      Lisp_Object *args;
  2448. {
  2449.   return arith_driver (Alogand, nargs, args);
  2450. }
  2451.  
  2452. DEFUN ("logior", Flogior, Slogior, 0, MANY, 0,
  2453.   "Return bitwise-or of all the arguments.\n\
  2454. Arguments may be integers, or markers converted to integers.")
  2455.   (nargs, args)
  2456.      int nargs;
  2457.      Lisp_Object *args;
  2458. {
  2459.   return arith_driver (Alogior, nargs, args);
  2460. }
  2461.  
  2462. DEFUN ("logxor", Flogxor, Slogxor, 0, MANY, 0,
  2463.   "Return bitwise-exclusive-or of all the arguments.\n\
  2464. Arguments may be integers, or markers converted to integers.")
  2465.   (nargs, args)
  2466.      int nargs;
  2467.      Lisp_Object *args;
  2468. {
  2469.   return arith_driver (Alogxor, nargs, args);
  2470. }
  2471.  
  2472. DEFUN ("ash", Fash, Sash, 2, 2, 0,
  2473.   "Return VALUE with its bits shifted left by COUNT.\n\
  2474. If COUNT is negative, shifting is actually to the right.\n\
  2475. In this case, the sign bit is duplicated.")
  2476.   (value, count)
  2477.      register Lisp_Object value, count;
  2478. {
  2479.   register Lisp_Object val;
  2480.  
  2481.   CHECK_NUMBER (value, 0);
  2482.   CHECK_NUMBER (count, 1);
  2483.  
  2484.   if (XINT (count) >= BITS_PER_EMACS_INT)
  2485.     XSETINT (val, 0);
  2486.   else if (XINT (count) > 0)
  2487.     XSETINT (val, XINT (value) << XFASTINT (count));
  2488.   else if (XINT (count) <= -BITS_PER_EMACS_INT)
  2489.     XSETINT (val, XINT (value) < 0 ? -1 : 0);
  2490.   else
  2491.     XSETINT (val, XINT (value) >> -XINT (count));
  2492.   return val;
  2493. }
  2494.  
  2495. DEFUN ("lsh", Flsh, Slsh, 2, 2, 0,
  2496.   "Return VALUE with its bits shifted left by COUNT.\n\
  2497. If COUNT is negative, shifting is actually to the right.\n\
  2498. In this case,  zeros are shifted in on the left.")
  2499.   (value, count)
  2500.      register Lisp_Object value, count;
  2501. {
  2502.   register Lisp_Object val;
  2503.  
  2504.   CHECK_NUMBER (value, 0);
  2505.   CHECK_NUMBER (count, 1);
  2506.  
  2507.   if (XINT (count) >= BITS_PER_EMACS_INT)
  2508.     XSETINT (val, 0);
  2509.   else if (XINT (count) > 0)
  2510.     XSETINT (val, (EMACS_UINT) XUINT (value) << XFASTINT (count));
  2511.   else if (XINT (count) <= -BITS_PER_EMACS_INT)
  2512.     XSETINT (val, 0);
  2513.   else
  2514.     XSETINT (val, (EMACS_UINT) XUINT (value) >> -XINT (count));
  2515.   return val;
  2516. }
  2517.  
  2518. DEFUN ("1+", Fadd1, Sadd1, 1, 1, 0,
  2519.   "Return NUMBER plus one.  NUMBER may be a number or a marker.\n\
  2520. Markers are converted to integers.")
  2521.   (number)
  2522.      register Lisp_Object number;
  2523. {
  2524. #ifdef LISP_FLOAT_TYPE
  2525.   CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (number, 0);
  2526.  
  2527.   if (FLOATP (number))
  2528.     return (make_float (1.0 + XFLOAT (number)->data));
  2529. #else
  2530.   CHECK_NUMBER_COERCE_MARKER (number, 0);
  2531. #endif /* LISP_FLOAT_TYPE */
  2532.  
  2533.   XSETINT (number, XINT (number) + 1);
  2534.   return number;
  2535. }
  2536.  
  2537. DEFUN ("1-", Fsub1, Ssub1, 1, 1, 0,
  2538.   "Return NUMBER minus one.  NUMBER may be a number or a marker.\n\
  2539. Markers are converted to integers.")
  2540.   (number)
  2541.      register Lisp_Object number;
  2542. {
  2543. #ifdef LISP_FLOAT_TYPE
  2544.   CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (number, 0);
  2545.  
  2546.   if (FLOATP (number))
  2547.     return (make_float (-1.0 + XFLOAT (number)->data));
  2548. #else
  2549.   CHECK_NUMBER_COERCE_MARKER (number, 0);
  2550. #endif /* LISP_FLOAT_TYPE */
  2551.  
  2552.   XSETINT (number, XINT (number) - 1);
  2553.   return number;
  2554. }
  2555.  
  2556. DEFUN ("lognot", Flognot, Slognot, 1, 1, 0,
  2557.   "Return the bitwise complement of NUMBER.  NUMBER must be an integer.")
  2558.   (number)
  2559.      register Lisp_Object number;
  2560. {
  2561.   CHECK_NUMBER (number, 0);
  2562.   XSETINT (number, ~XINT (number));
  2563.   return number;
  2564. }
  2565.  
  2566. void
  2567. syms_of_data ()
  2568. {
  2569.   Lisp_Object error_tail, arith_tail;
  2570.  
  2571.   Qquote = intern ("quote");
  2572.   Qlambda = intern ("lambda");
  2573.   Qsubr = intern ("subr");
  2574.   Qerror_conditions = intern ("error-conditions");
  2575.   Qerror_message = intern ("error-message");
  2576.   Qtop_level = intern ("top-level");
  2577.  
  2578.   Qerror = intern ("error");
  2579.   Qquit = intern ("quit");
  2580.   Qwrong_type_argument = intern ("wrong-type-argument");
  2581.   Qargs_out_of_range = intern ("args-out-of-range");
  2582.   Qvoid_function = intern ("void-function");
  2583.   Qcyclic_function_indirection = intern ("cyclic-function-indirection");
  2584.   Qvoid_variable = intern ("void-variable");
  2585.   Qsetting_constant = intern ("setting-constant");
  2586.   Qinvalid_read_syntax = intern ("invalid-read-syntax");
  2587.  
  2588.   Qinvalid_function = intern ("invalid-function");
  2589.   Qwrong_number_of_arguments = intern ("wrong-number-of-arguments");
  2590.   Qno_catch = intern ("no-catch");
  2591.   Qend_of_file = intern ("end-of-file");
  2592.   Qarith_error = intern ("arith-error");
  2593.   Qbeginning_of_buffer = intern ("beginning-of-buffer");
  2594.   Qend_of_buffer = intern ("end-of-buffer");
  2595.   Qbuffer_read_only = intern ("buffer-read-only");
  2596.   Qmark_inactive = intern ("mark-inactive");
  2597.  
  2598.   Qlistp = intern ("listp");
  2599.   Qconsp = intern ("consp");
  2600.   Qsymbolp = intern ("symbolp");
  2601.   Qintegerp = intern ("integerp");
  2602.   Qnatnump = intern ("natnump");
  2603.   Qwholenump = intern ("wholenump");
  2604.   Qstringp = intern ("stringp");
  2605.   Qarrayp = intern ("arrayp");
  2606.   Qsequencep = intern ("sequencep");
  2607.   Qbufferp = intern ("bufferp");
  2608.   Qvectorp = intern ("vectorp");
  2609.   Qchar_or_string_p = intern ("char-or-string-p");
  2610.   Qmarkerp = intern ("markerp");
  2611.   Qbuffer_or_string_p = intern ("buffer-or-string-p");
  2612.   Qinteger_or_marker_p = intern ("integer-or-marker-p");
  2613.   Qboundp = intern ("boundp");
  2614.   Qfboundp = intern ("fboundp");
  2615.  
  2616. #ifdef LISP_FLOAT_TYPE
  2617.   Qfloatp = intern ("floatp");
  2618.   Qnumberp = intern ("numberp");
  2619.   Qnumber_or_marker_p = intern ("number-or-marker-p");
  2620. #endif /* LISP_FLOAT_TYPE */
  2621.  
  2622.   Qchar_table_p = intern ("char-table-p");
  2623.   Qvector_or_char_table_p = intern ("vector-or-char-table-p");
  2624.  
  2625.   Qcdr = intern ("cdr");
  2626.  
  2627.   /* Handle automatic advice activation */
  2628.   Qad_advice_info = intern ("ad-advice-info");
  2629.   Qad_activate = intern ("ad-activate");
  2630.  
  2631.   error_tail = Fcons (Qerror, Qnil);
  2632.  
  2633.   /* ERROR is used as a signaler for random errors for which nothing else is right */
  2634.  
  2635.   Fput (Qerror, Qerror_conditions,
  2636.     error_tail);
  2637.   Fput (Qerror, Qerror_message,
  2638.     build_string ("error"));
  2639.  
  2640.   Fput (Qquit, Qerror_conditions,
  2641.     Fcons (Qquit, Qnil));
  2642.   Fput (Qquit, Qerror_message,
  2643.     build_string ("Quit"));
  2644.  
  2645.   Fput (Qwrong_type_argument, Qerror_conditions,
  2646.     Fcons (Qwrong_type_argument, error_tail));
  2647.   Fput (Qwrong_type_argument, Qerror_message,
  2648.     build_string ("Wrong type argument"));
  2649.  
  2650.   Fput (Qargs_out_of_range, Qerror_conditions,
  2651.     Fcons (Qargs_out_of_range, error_tail));
  2652.   Fput (Qargs_out_of_range, Qerror_message,
  2653.     build_string ("Args out of range"));
  2654.  
  2655.   Fput (Qvoid_function, Qerror_conditions,
  2656.     Fcons (Qvoid_function, error_tail));
  2657.   Fput (Qvoid_function, Qerror_message,
  2658.     build_string ("Symbol's function definition is void"));
  2659.  
  2660.   Fput (Qcyclic_function_indirection, Qerror_conditions,
  2661.     Fcons (Qcyclic_function_indirection, error_tail));
  2662.   Fput (Qcyclic_function_indirection, Qerror_message,
  2663.     build_string ("Symbol's chain of function indirections contains a loop"));
  2664.  
  2665.   Fput (Qvoid_variable, Qerror_conditions,
  2666.     Fcons (Qvoid_variable, error_tail));
  2667.   Fput (Qvoid_variable, Qerror_message,
  2668.     build_string ("Symbol's value as variable is void"));
  2669.  
  2670.   Fput (Qsetting_constant, Qerror_conditions,
  2671.     Fcons (Qsetting_constant, error_tail));
  2672.   Fput (Qsetting_constant, Qerror_message,
  2673.     build_string ("Attempt to set a constant symbol"));
  2674.  
  2675.   Fput (Qinvalid_read_syntax, Qerror_conditions,
  2676.     Fcons (Qinvalid_read_syntax, error_tail));
  2677.   Fput (Qinvalid_read_syntax, Qerror_message,
  2678.     build_string ("Invalid read syntax"));
  2679.  
  2680.   Fput (Qinvalid_function, Qerror_conditions,
  2681.     Fcons (Qinvalid_function, error_tail));
  2682.   Fput (Qinvalid_function, Qerror_message,
  2683.     build_string ("Invalid function"));
  2684.  
  2685.   Fput (Qwrong_number_of_arguments, Qerror_conditions,
  2686.     Fcons (Qwrong_number_of_arguments, error_tail));
  2687.   Fput (Qwrong_number_of_arguments, Qerror_message,
  2688.     build_string ("Wrong number of arguments"));
  2689.  
  2690.   Fput (Qno_catch, Qerror_conditions,
  2691.     Fcons (Qno_catch, error_tail));
  2692.   Fput (Qno_catch, Qerror_message,
  2693.     build_string ("No catch for tag"));
  2694.  
  2695.   Fput (Qend_of_file, Qerror_conditions,
  2696.     Fcons (Qend_of_file, error_tail));
  2697.   Fput (Qend_of_file, Qerror_message,
  2698.     build_string ("End of file during parsing"));
  2699.  
  2700.   arith_tail = Fcons (Qarith_error, error_tail);
  2701.   Fput (Qarith_error, Qerror_conditions,
  2702.     arith_tail);
  2703.   Fput (Qarith_error, Qerror_message,
  2704.     build_string ("Arithmetic error"));
  2705.  
  2706.   Fput (Qbeginning_of_buffer, Qerror_conditions,
  2707.     Fcons (Qbeginning_of_buffer, error_tail));
  2708.   Fput (Qbeginning_of_buffer, Qerror_message,
  2709.     build_string ("Beginning of buffer"));
  2710.  
  2711.   Fput (Qend_of_buffer, Qerror_conditions,
  2712.     Fcons (Qend_of_buffer, error_tail));
  2713.   Fput (Qend_of_buffer, Qerror_message,
  2714.     build_string ("End of buffer"));
  2715.  
  2716.   Fput (Qbuffer_read_only, Qerror_conditions,
  2717.     Fcons (Qbuffer_read_only, error_tail));
  2718.   Fput (Qbuffer_read_only, Qerror_message,
  2719.     build_string ("Buffer is read-only"));
  2720.  
  2721. #ifdef LISP_FLOAT_TYPE
  2722.   Qrange_error = intern ("range-error");
  2723.   Qdomain_error = intern ("domain-error");
  2724.   Qsingularity_error = intern ("singularity-error");
  2725.   Qoverflow_error = intern ("overflow-error");
  2726.   Qunderflow_error = intern ("underflow-error");
  2727.  
  2728.   Fput (Qdomain_error, Qerror_conditions,
  2729.     Fcons (Qdomain_error, arith_tail));
  2730.   Fput (Qdomain_error, Qerror_message,
  2731.     build_string ("Arithmetic domain error"));
  2732.  
  2733.   Fput (Qrange_error, Qerror_conditions,
  2734.     Fcons (Qrange_error, arith_tail));
  2735.   Fput (Qrange_error, Qerror_message,
  2736.     build_string ("Arithmetic range error"));
  2737.  
  2738.   Fput (Qsingularity_error, Qerror_conditions,
  2739.     Fcons (Qsingularity_error, Fcons (Qdomain_error, arith_tail)));
  2740.   Fput (Qsingularity_error, Qerror_message,
  2741.     build_string ("Arithmetic singularity error"));
  2742.  
  2743.   Fput (Qoverflow_error, Qerror_conditions,
  2744.     Fcons (Qoverflow_error, Fcons (Qdomain_error, arith_tail)));
  2745.   Fput (Qoverflow_error, Qerror_message,
  2746.     build_string ("Arithmetic overflow error"));
  2747.  
  2748.   Fput (Qunderflow_error, Qerror_conditions,
  2749.     Fcons (Qunderflow_error, Fcons (Qdomain_error, arith_tail)));
  2750.   Fput (Qunderflow_error, Qerror_message,
  2751.     build_string ("Arithmetic underflow error"));
  2752.  
  2753.   staticpro (&Qrange_error);
  2754.   staticpro (&Qdomain_error);
  2755.   staticpro (&Qsingularity_error);
  2756.   staticpro (&Qoverflow_error);
  2757.   staticpro (&Qunderflow_error);
  2758. #endif /* LISP_FLOAT_TYPE */
  2759.  
  2760.   staticpro (&Qnil);
  2761.   staticpro (&Qt);
  2762.   staticpro (&Qquote);
  2763.   staticpro (&Qlambda);
  2764.   staticpro (&Qsubr);
  2765.   staticpro (&Qunbound);
  2766.   staticpro (&Qerror_conditions);
  2767.   staticpro (&Qerror_message);
  2768.   staticpro (&Qtop_level);
  2769.  
  2770.   staticpro (&Qerror);
  2771.   staticpro (&Qquit);
  2772.   staticpro (&Qwrong_type_argument);
  2773.   staticpro (&Qargs_out_of_range);
  2774.   staticpro (&Qvoid_function);
  2775.   staticpro (&Qcyclic_function_indirection);
  2776.   staticpro (&Qvoid_variable);
  2777.   staticpro (&Qsetting_constant);
  2778.   staticpro (&Qinvalid_read_syntax);
  2779.   staticpro (&Qwrong_number_of_arguments);
  2780.   staticpro (&Qinvalid_function);
  2781.   staticpro (&Qno_catch);
  2782.   staticpro (&Qend_of_file);
  2783.   staticpro (&Qarith_error);
  2784.   staticpro (&Qbeginning_of_buffer);
  2785.   staticpro (&Qend_of_buffer);
  2786.   staticpro (&Qbuffer_read_only);
  2787.   staticpro (&Qmark_inactive);
  2788.  
  2789.   staticpro (&Qlistp);
  2790.   staticpro (&Qconsp);
  2791.   staticpro (&Qsymbolp);
  2792.   staticpro (&Qintegerp);
  2793.   staticpro (&Qnatnump);
  2794.   staticpro (&Qwholenump);
  2795.   staticpro (&Qstringp);
  2796.   staticpro (&Qarrayp);
  2797.   staticpro (&Qsequencep);
  2798.   staticpro (&Qbufferp);
  2799.   staticpro (&Qvectorp);
  2800.   staticpro (&Qchar_or_string_p);
  2801.   staticpro (&Qmarkerp);
  2802.   staticpro (&Qbuffer_or_string_p);
  2803.   staticpro (&Qinteger_or_marker_p);
  2804. #ifdef LISP_FLOAT_TYPE
  2805.   staticpro (&Qfloatp);
  2806.   staticpro (&Qnumberp);
  2807.   staticpro (&Qnumber_or_marker_p);
  2808. #endif /* LISP_FLOAT_TYPE */
  2809.   staticpro (&Qchar_table_p);
  2810.   staticpro (&Qvector_or_char_table_p);
  2811.  
  2812.   staticpro (&Qboundp);
  2813.   staticpro (&Qfboundp);
  2814.   staticpro (&Qcdr);
  2815.   staticpro (&Qad_advice_info);
  2816.   staticpro (&Qad_activate);
  2817.  
  2818.   /* Types that type-of returns.  */
  2819.   Qinteger = intern ("integer");
  2820.   Qsymbol = intern ("symbol");
  2821.   Qstring = intern ("string");
  2822.   Qcons = intern ("cons");
  2823.   Qmarker = intern ("marker");
  2824.   Qoverlay = intern ("overlay");
  2825.   Qfloat = intern ("float");
  2826.   Qwindow_configuration = intern ("window-configuration");
  2827.   Qprocess = intern ("process");
  2828.   Qwindow = intern ("window");
  2829.   /* Qsubr = intern ("subr"); */
  2830.   Qcompiled_function = intern ("compiled-function");
  2831.   Qbuffer = intern ("buffer");
  2832.   Qframe = intern ("frame");
  2833.   Qvector = intern ("vector");
  2834.   Qchar_table = intern ("char-table");
  2835.   Qbool_vector = intern ("bool-vector");
  2836.  
  2837.   staticpro (&Qinteger);
  2838.   staticpro (&Qsymbol);
  2839.   staticpro (&Qstring);
  2840.   staticpro (&Qcons);
  2841.   staticpro (&Qmarker);
  2842.   staticpro (&Qoverlay);
  2843.   staticpro (&Qfloat);
  2844.   staticpro (&Qwindow_configuration);
  2845.   staticpro (&Qprocess);
  2846.   staticpro (&Qwindow);
  2847.   /* staticpro (&Qsubr); */
  2848.   staticpro (&Qcompiled_function);
  2849.   staticpro (&Qbuffer);
  2850.   staticpro (&Qframe);
  2851.   staticpro (&Qvector);
  2852.   staticpro (&Qchar_table);
  2853.   staticpro (&Qbool_vector);
  2854.  
  2855.   DEFVAR_BOOL ("keyword-symbols-constant-flag", &keyword_symbols_constant_flag,
  2856.     "Non-nil means it is an error to set a keyword symbol.\n\
  2857. A keyword symbol is a symbol whose name starts with a colon (`:').");
  2858.   keyword_symbols_constant_flag = 1;
  2859.  
  2860.   defsubr (&Seq);
  2861.   defsubr (&Snull);
  2862.   defsubr (&Stype_of);
  2863.   defsubr (&Slistp);
  2864.   defsubr (&Snlistp);
  2865.   defsubr (&Sconsp);
  2866.   defsubr (&Satom);
  2867.   defsubr (&Sintegerp);
  2868.   defsubr (&Sinteger_or_marker_p);
  2869.   defsubr (&Snumberp);
  2870.   defsubr (&Snumber_or_marker_p);
  2871. #ifdef LISP_FLOAT_TYPE
  2872.   defsubr (&Sfloatp);
  2873. #endif /* LISP_FLOAT_TYPE */
  2874.   defsubr (&Snatnump);
  2875.   defsubr (&Ssymbolp);
  2876.   defsubr (&Sstringp);
  2877.   defsubr (&Smultibyte_string_p);
  2878.   defsubr (&Svectorp);
  2879.   defsubr (&Schar_table_p);
  2880.   defsubr (&Svector_or_char_table_p);
  2881.   defsubr (&Sbool_vector_p);
  2882.   defsubr (&Sarrayp);
  2883.   defsubr (&Ssequencep);
  2884.   defsubr (&Sbufferp);
  2885.   defsubr (&Smarkerp);
  2886.   defsubr (&Ssubrp);
  2887.   defsubr (&Sbyte_code_function_p);
  2888.   defsubr (&Schar_or_string_p);
  2889.   defsubr (&Scar);
  2890.   defsubr (&Scdr);
  2891.   defsubr (&Scar_safe);
  2892.   defsubr (&Scdr_safe);
  2893.   defsubr (&Ssetcar);
  2894.   defsubr (&Ssetcdr);
  2895.   defsubr (&Ssymbol_function);
  2896.   defsubr (&Sindirect_function);
  2897.   defsubr (&Ssymbol_plist);
  2898.   defsubr (&Ssymbol_name);
  2899.   defsubr (&Smakunbound);
  2900.   defsubr (&Sfmakunbound);
  2901.   defsubr (&Sboundp);
  2902.   defsubr (&Sfboundp);
  2903.   defsubr (&Sfset);
  2904.   defsubr (&Sdefalias);
  2905.   defsubr (&Ssetplist);
  2906.   defsubr (&Ssymbol_value);
  2907.   defsubr (&Sset);
  2908.   defsubr (&Sdefault_boundp);
  2909.   defsubr (&Sdefault_value);
  2910.   defsubr (&Sset_default);
  2911.   defsubr (&Ssetq_default);
  2912.   defsubr (&Smake_variable_buffer_local);
  2913.   defsubr (&Smake_local_variable);
  2914.   defsubr (&Skill_local_variable);
  2915.   defsubr (&Smake_variable_frame_local);
  2916.   defsubr (&Slocal_variable_p);
  2917.   defsubr (&Slocal_variable_if_set_p);
  2918.   defsubr (&Saref);
  2919.   defsubr (&Saset);
  2920.   defsubr (&Snumber_to_string);
  2921.   defsubr (&Sstring_to_number);
  2922.   defsubr (&Seqlsign);
  2923.   defsubr (&Slss);
  2924.   defsubr (&Sgtr);
  2925.   defsubr (&Sleq);
  2926.   defsubr (&Sgeq);
  2927.   defsubr (&Sneq);
  2928.   defsubr (&Szerop);
  2929.   defsubr (&Splus);
  2930.   defsubr (&Sminus);
  2931.   defsubr (&Stimes);
  2932.   defsubr (&Squo);
  2933.   defsubr (&Srem);
  2934.   defsubr (&Smod);
  2935.   defsubr (&Smax);
  2936.   defsubr (&Smin);
  2937.   defsubr (&Slogand);
  2938.   defsubr (&Slogior);
  2939.   defsubr (&Slogxor);
  2940.   defsubr (&Slsh);
  2941.   defsubr (&Sash);
  2942.   defsubr (&Sadd1);
  2943.   defsubr (&Ssub1);
  2944.   defsubr (&Slognot);
  2945.  
  2946.   XSYMBOL (Qwholenump)->function = XSYMBOL (Qnatnump)->function;
  2947. }
  2948.  
  2949. SIGTYPE
  2950. arith_error (signo)
  2951.      int signo;
  2952. {
  2953. #if defined(USG) && !defined(POSIX_SIGNALS)
  2954.   /* USG systems forget handlers when they are used;
  2955.      must reestablish each time */
  2956.   signal (signo, arith_error);
  2957. #endif /* USG */
  2958. #ifdef VMS
  2959.   /* VMS systems are like USG.  */
  2960.   signal (signo, arith_error);
  2961. #endif /* VMS */
  2962. #ifdef BSD4_1
  2963.   sigrelse (SIGFPE);
  2964. #else /* not BSD4_1 */
  2965.   sigsetmask (SIGEMPTYMASK);
  2966. #endif /* not BSD4_1 */
  2967.  
  2968.   Fsignal (Qarith_error, Qnil);
  2969. }
  2970.  
  2971. void
  2972. init_data ()
  2973. {
  2974.   /* Don't do this if just dumping out.
  2975.      We don't want to call `signal' in this case
  2976.      so that we don't have trouble with dumping
  2977.      signal-delivering routines in an inconsistent state.  */
  2978. #ifndef CANNOT_DUMP
  2979.   if (!initialized)
  2980.     return;
  2981. #endif /* CANNOT_DUMP */
  2982.   signal (SIGFPE, arith_error);
  2983.  
  2984. #ifdef uts
  2985.   signal (SIGEMT, arith_error);
  2986. #endif /* uts */
  2987. }
  2988.