You should have received a copy of the GNU General Public License
along with GNU Emacs; see the file COPYING. If not, write to
-the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
+the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA. */
#include <config.h>
Lisp_Object Qstring_lessp, Qprovide, Qrequire;
Lisp_Object Qyes_or_no_p_history;
+Lisp_Object Qcursor_in_echo_area;
static int internal_equal ();
\f
On most systems, this is 28 bits' worth.\n\
With positive integer argument N, return random number in interval [0,N).\n\
With argument t, set the random number seed from the current time and pid.")
- (limit)
- Lisp_Object limit;
+ (n)
+ Lisp_Object n;
{
EMACS_INT val;
Lisp_Object lispy_val;
unsigned long denominator;
- if (EQ (limit, Qt))
+ if (EQ (n, Qt))
seed_random (getpid () + time (NULL));
- if (NATNUMP (limit) && XFASTINT (limit) != 0)
+ if (NATNUMP (n) && XFASTINT (n) != 0)
{
/* Try to take our random number from the higher bits of VAL,
not the lower, since (says Gentzel) the low bits of `random'
are less random than the higher ones. We do this by using the
quotient rather than the remainder. At the high end of the RNG
- it's possible to get a quotient larger than limit; discarding
+ it's possible to get a quotient larger than n; discarding
these values eliminates the bias that would otherwise appear
- when using a large limit. */
- denominator = ((unsigned long)1 << VALBITS) / XFASTINT (limit);
+ when using a large n. */
+ denominator = ((unsigned long)1 << VALBITS) / XFASTINT (n);
do
val = get_random () / denominator;
- while (val >= XFASTINT (limit));
+ while (val >= XFASTINT (n));
}
else
val = get_random ();
DEFUN ("length", Flength, Slength, 1, 1, 0,
"Return the length of vector, list or string SEQUENCE.\n\
A byte-code function object is also allowed.")
- (obj)
- register Lisp_Object obj;
+ (sequence)
+ register Lisp_Object sequence;
{
register Lisp_Object tail, val;
register int i;
retry:
- if (STRINGP (obj))
- XSETFASTINT (val, XSTRING (obj)->size);
- else if (VECTORP (obj))
- XSETFASTINT (val, XVECTOR (obj)->size);
- else if (COMPILEDP (obj))
- XSETFASTINT (val, XVECTOR (obj)->size & PSEUDOVECTOR_SIZE_MASK);
- else if (CONSP (obj))
+ if (STRINGP (sequence))
+ XSETFASTINT (val, XSTRING (sequence)->size);
+ else if (VECTORP (sequence))
+ XSETFASTINT (val, XVECTOR (sequence)->size);
+ else if (CHAR_TABLE_P (sequence))
+ XSETFASTINT (val, CHAR_TABLE_ORDINARY_SLOTS);
+ else if (BOOL_VECTOR_P (sequence))
+ XSETFASTINT (val, XBOOL_VECTOR (sequence)->size);
+ else if (COMPILEDP (sequence))
+ XSETFASTINT (val, XVECTOR (sequence)->size & PSEUDOVECTOR_SIZE_MASK);
+ else if (CONSP (sequence))
{
- for (i = 0, tail = obj; !NILP (tail); i++)
+ for (i = 0, tail = sequence; !NILP (tail); i++)
{
QUIT;
tail = Fcdr (tail);
XSETFASTINT (val, i);
}
- else if (NILP (obj))
+ else if (NILP (sequence))
XSETFASTINT (val, 0);
else
{
- obj = wrong_type_argument (Qsequencep, obj);
+ sequence = wrong_type_argument (Qsequencep, sequence);
goto retry;
}
return val;
if (EQ (tail, halftail) && len != 0)
break;
len++;
- if (len & 1 == 0)
+ if ((len & 1) == 0)
halftail = XCONS (halftail)->cdr;
}
Lisp_Object arg;
{
if (NILP (arg)) return arg;
+
+ if (CHAR_TABLE_P (arg))
+ {
+ int i, size;
+ Lisp_Object copy;
+
+ /* Calculate the number of extra slots. */
+ size = CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (arg));
+ copy = Fmake_char_table (XCHAR_TABLE (arg)->purpose, Qnil);
+ /* Copy all the slots, including the extra ones. */
+ bcopy (XCHAR_TABLE (arg)->contents, XCHAR_TABLE (copy)->contents,
+ (XCHAR_TABLE (arg)->size & PSEUDOVECTOR_SIZE_MASK) * sizeof (Lisp_Object));
+
+ /* Recursively copy any char-tables in the ordinary slots. */
+ for (i = 0; i < CHAR_TABLE_ORDINARY_SLOTS; i++)
+ if (CHAR_TABLE_P (XCHAR_TABLE (arg)->contents[i]))
+ XCHAR_TABLE (copy)->contents[i]
+ = Fcopy_sequence (XCHAR_TABLE (copy)->contents[i]);
+
+ return copy;
+ }
+
+ if (BOOL_VECTOR_P (arg))
+ {
+ Lisp_Object val;
+ int size_in_chars
+ = (XBOOL_VECTOR (arg)->size + BITS_PER_CHAR) / BITS_PER_CHAR;
+
+ val = Fmake_bool_vector (Flength (arg), Qnil);
+ bcopy (XBOOL_VECTOR (arg)->data, XBOOL_VECTOR (val)->data,
+ size_in_chars);
+ return val;
+ }
+
if (!CONSP (arg) && !VECTORP (arg) && !STRINGP (arg))
arg = wrong_type_argument (Qsequencep, arg);
return concat (1, &arg, CONSP (arg) ? Lisp_Cons : XTYPE (arg), 0);
{
this = args[argnum];
if (!(CONSP (this) || NILP (this) || VECTORP (this) || STRINGP (this)
- || COMPILEDP (this)))
+ || COMPILEDP (this) || BOOL_VECTOR_P (this)))
{
if (INTEGERP (this))
args[argnum] = Fnumber_to_string (this);
if (thisindex >= thisleni) break;
if (STRINGP (this))
XSETFASTINT (elt, XSTRING (this)->data[thisindex++]);
+ else if (BOOL_VECTOR_P (this))
+ {
+ int size_in_chars
+ = ((XBOOL_VECTOR (this)->size + BITS_PER_CHAR)
+ / BITS_PER_CHAR);
+ int byte;
+ byte = XBOOL_VECTOR (val)->data[thisindex / BITS_PER_CHAR];
+ if (byte & (1 << thisindex))
+ elt = Qt;
+ else
+ elt = Qnil;
+ }
else
elt = XVECTOR (this)->contents[thisindex++];
}
DEFUN ("substring", Fsubstring, Ssubstring, 2, 3, 0,
"Return a substring of STRING, starting at index FROM and ending before TO.\n\
TO may be nil or omitted; then the substring runs to the end of STRING.\n\
-If FROM or TO is negative, it counts from the end.")
+If FROM or TO is negative, it counts from the end.\n\
+\n\
+This function allows vectors as well as strings.")
(string, from, to)
Lisp_Object string;
register Lisp_Object from, to;
{
Lisp_Object res;
+ int size;
+
+ if (! (STRINGP (string) || VECTORP (string)))
+ wrong_type_argument (Qarrayp, string);
- CHECK_STRING (string, 0);
CHECK_NUMBER (from, 1);
+
+ if (STRINGP (string))
+ size = XSTRING (string)->size;
+ else
+ size = XVECTOR (string)->size;
+
if (NILP (to))
- to = Flength (string);
+ to = size;
else
CHECK_NUMBER (to, 2);
if (XINT (from) < 0)
- XSETINT (from, XINT (from) + XSTRING (string)->size);
+ XSETINT (from, XINT (from) + size);
if (XINT (to) < 0)
- XSETINT (to, XINT (to) + XSTRING (string)->size);
+ XSETINT (to, XINT (to) + size);
if (!(0 <= XINT (from) && XINT (from) <= XINT (to)
- && XINT (to) <= XSTRING (string)->size))
+ && XINT (to) <= size))
args_out_of_range_3 (string, from, to);
- res = make_string (XSTRING (string)->data + XINT (from),
- XINT (to) - XINT (from));
- copy_text_properties (from, to, string, make_number (0), res, Qnil);
+ if (STRINGP (string))
+ {
+ res = make_string (XSTRING (string)->data + XINT (from),
+ XINT (to) - XINT (from));
+ copy_text_properties (from, to, string, make_number (0), res, Qnil);
+ }
+ else
+ res = Fvector (XINT (to) - XINT (from),
+ XVECTOR (string)->contents + XINT (from));
+
return res;
}
\f
DEFUN ("elt", Felt, Selt, 2, 2, 0,
"Return element of SEQUENCE at index N.")
- (seq, n)
- register Lisp_Object seq, n;
+ (sequence, n)
+ register Lisp_Object sequence, n;
{
CHECK_NUMBER (n, 0);
while (1)
{
- if (CONSP (seq) || NILP (seq))
- return Fcar (Fnthcdr (n, seq));
- else if (STRINGP (seq) || VECTORP (seq))
- return Faref (seq, n);
+ if (CONSP (sequence) || NILP (sequence))
+ return Fcar (Fnthcdr (n, sequence));
+ else if (STRINGP (sequence) || VECTORP (sequence)
+ || BOOL_VECTOR_P (sequence) || CHAR_TABLE_P (sequence))
+ return Faref (sequence, n);
else
- seq = wrong_type_argument (Qsequencep, seq);
+ sequence = wrong_type_argument (Qsequencep, sequence);
}
}
Returns the sorted list. LIST is modified by side effects.\n\
PREDICATE is called with two elements of LIST, and should return T\n\
if the first element is \"less\" than the second.")
- (list, pred)
- Lisp_Object list, pred;
+ (list, predicate)
+ Lisp_Object list, predicate;
{
Lisp_Object front, back;
register Lisp_Object len, tem;
Fsetcdr (tem, Qnil);
GCPRO2 (front, back);
- front = Fsort (front, pred);
- back = Fsort (back, pred);
+ front = Fsort (front, predicate);
+ back = Fsort (back, predicate);
UNGCPRO;
- return merge (front, back, pred);
+ return merge (front, back, predicate);
}
Lisp_Object
\f
DEFUN ("plist-get", Fplist_get, Splist_get, 2, 2, 0,
- "Extract a value from a property list.\n\
+ "Extract a value from a property list.\n\
PLIST is a property list, which is a list of the form\n\
\(PROP1 VALUE1 PROP2 VALUE2...). This function returns the value\n\
corresponding to the given PROP, or nil if PROP is not\n\
one of the properties on the list.")
- (val, prop)
- Lisp_Object val;
+ (plist, prop)
+ Lisp_Object plist;
register Lisp_Object prop;
{
register Lisp_Object tail;
- for (tail = val; !NILP (tail); tail = Fcdr (Fcdr (tail)))
+ for (tail = plist; !NILP (tail); tail = Fcdr (Fcdr (tail)))
{
register Lisp_Object tem;
tem = Fcar (tail);
same size. */
if (XVECTOR (o2)->size != size)
return 0;
- /* But only true vectors and compiled functions are actually sensible
- to compare, so eliminate the others now. */
+ /* Boolvectors are compared much like strings. */
+ if (BOOL_VECTOR_P (o1))
+ {
+ int size_in_chars
+ = (XBOOL_VECTOR (o1)->size + BITS_PER_CHAR) / BITS_PER_CHAR;
+
+ if (XBOOL_VECTOR (o1)->size != XBOOL_VECTOR (o2)->size)
+ return 0;
+ if (bcmp (XBOOL_VECTOR (o1)->data, XBOOL_VECTOR (o2)->data,
+ size_in_chars))
+ return 0;
+ return 1;
+ }
+
+ /* Aside from them, only true vectors, char-tables, and compiled
+ functions are sensible to compare, so eliminate the others now. */
if (size & PSEUDOVECTOR_FLAG)
{
- if (!(size & PVEC_COMPILED))
+ if (!(size & (PVEC_COMPILED | PVEC_CHAR_TABLE)))
return 0;
size &= PSEUDOVECTOR_SIZE_MASK;
}
}
\f
DEFUN ("fillarray", Ffillarray, Sfillarray, 2, 2, 0,
- "Store each element of ARRAY with ITEM. ARRAY is a vector or string.")
+ "Store each element of ARRAY with ITEM.\n\
+ARRAY is a vector, string, char-table, or bool-vector.")
(array, item)
Lisp_Object array, item;
{
for (index = 0; index < size; index++)
p[index] = item;
}
+ else if (CHAR_TABLE_P (array))
+ {
+ register Lisp_Object *p = XCHAR_TABLE (array)->contents;
+ size = CHAR_TABLE_ORDINARY_SLOTS;
+ for (index = 0; index < size; index++)
+ p[index] = item;
+ XCHAR_TABLE (array)->defalt = Qnil;
+ }
else if (STRINGP (array))
{
register unsigned char *p = XSTRING (array)->data;
for (index = 0; index < size; index++)
p[index] = charval;
}
+ else if (BOOL_VECTOR_P (array))
+ {
+ register unsigned char *p = XBOOL_VECTOR (array)->data;
+ int size_in_chars
+ = (XBOOL_VECTOR (array)->size + BITS_PER_CHAR) / BITS_PER_CHAR;
+
+ charval = (! NILP (item) ? -1 : 0);
+ for (index = 0; index < size_in_chars; index++)
+ p[index] = charval;
+ }
else
{
array = wrong_type_argument (Qarrayp, array);
return array;
}
+DEFUN ("char-table-subtype", Fchar_table_subtype, Schar_table_subtype,
+ 1, 1, 0,
+ "Return the subtype of char-table CHAR-TABLE. The value is a symbol.")
+ (char_table)
+ Lisp_Object char_table;
+{
+ CHECK_CHAR_TABLE (char_table, 0);
+
+ return XCHAR_TABLE (char_table)->purpose;
+}
+
+DEFUN ("char-table-parent", Fchar_table_parent, Schar_table_parent,
+ 1, 1, 0,
+ "Return the parent char-table of CHAR-TABLE.\n\
+The value is either nil or another char-table.\n\
+If CHAR-TABLE holds nil for a given character,\n\
+then the actual applicable value is inherited from the parent char-table\n\
+\(or from its parents, if necessary).")
+ (char_table)
+ Lisp_Object char_table;
+{
+ CHECK_CHAR_TABLE (char_table, 0);
+
+ return XCHAR_TABLE (char_table)->parent;
+}
+
+DEFUN ("set-char-table-parent", Fset_char_table_parent, Sset_char_table_parent,
+ 2, 2, 0,
+ "Set the parent char-table of CHAR-TABLE to PARENT.\n\
+PARENT must be either nil or another char-table.")
+ (char_table, parent)
+ Lisp_Object char_table, parent;
+{
+ Lisp_Object temp;
+
+ CHECK_CHAR_TABLE (char_table, 0);
+
+ if (!NILP (parent))
+ {
+ CHECK_CHAR_TABLE (parent, 0);
+
+ for (temp = parent; !NILP (temp); temp = XCHAR_TABLE (temp)->parent)
+ if (EQ (temp, char_table))
+ error ("Attempt to make a chartable be its own parent");
+ }
+
+ XCHAR_TABLE (char_table)->parent = parent;
+
+ return parent;
+}
+
+DEFUN ("char-table-extra-slot", Fchar_table_extra_slot, Schar_table_extra_slot,
+ 2, 2, 0,
+ "Return the value in extra-slot number N of char-table CHAR-TABLE.")
+ (char_table, n)
+ Lisp_Object char_table, n;
+{
+ CHECK_CHAR_TABLE (char_table, 1);
+ CHECK_NUMBER (n, 2);
+ if (XINT (n) < 0
+ || XINT (n) >= CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (char_table)))
+ args_out_of_range (char_table, n);
+
+ return XCHAR_TABLE (char_table)->extras[XINT (n)];
+}
+
+DEFUN ("set-char-table-extra-slot", Fset_char_table_extra_slot,
+ Sset_char_table_extra_slot,
+ 3, 3, 0,
+ "Set extra-slot number N of CHAR-TABLE to VALUE.")
+ (char_table, n, value)
+ Lisp_Object char_table, n, value;
+{
+ CHECK_CHAR_TABLE (char_table, 1);
+ CHECK_NUMBER (n, 2);
+ if (XINT (n) < 0
+ || XINT (n) >= CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (char_table)))
+ args_out_of_range (char_table, n);
+
+ return XCHAR_TABLE (char_table)->extras[XINT (n)] = value;
+}
+
+DEFUN ("char-table-range", Fchar_table_range, Schar_table_range,
+ 2, 2, 0,
+ "Return the value in CHAR-TABLE for a range of characters RANGE.\n\
+RANGE should be t (for all characters), nil (for the default value)\n\
+a vector which identifies a character set or a row of a character set,\n\
+or a character code.")
+ (char_table, range)
+ Lisp_Object char_table, range;
+{
+ int i;
+
+ CHECK_CHAR_TABLE (char_table, 0);
+
+ if (EQ (range, Qnil))
+ return XCHAR_TABLE (char_table)->defalt;
+ else if (INTEGERP (range))
+ return Faref (char_table, range);
+ else if (VECTORP (range))
+ {
+ for (i = 0; i < XVECTOR (range)->size - 1; i++)
+ char_table = Faref (char_table, XVECTOR (range)->contents[i]);
+
+ if (EQ (XVECTOR (range)->contents[i], Qnil))
+ return XCHAR_TABLE (char_table)->defalt;
+ else
+ return Faref (char_table, XVECTOR (range)->contents[i]);
+ }
+ else
+ error ("Invalid RANGE argument to `char-table-range'");
+}
+
+DEFUN ("set-char-table-range", Fset_char_table_range, Sset_char_table_range,
+ 3, 3, 0,
+ "Set the value in CHAR-TABLE for a range of characters RANGE to VALUE.\n\
+RANGE should be t (for all characters), nil (for the default value)\n\
+a vector which identifies a character set or a row of a character set,\n\
+or a character code.")
+ (char_table, range, value)
+ Lisp_Object char_table, range, value;
+{
+ int i;
+
+ CHECK_CHAR_TABLE (char_table, 0);
+
+ if (EQ (range, Qt))
+ for (i = 0; i < CHAR_TABLE_ORDINARY_SLOTS; i++)
+ XCHAR_TABLE (char_table)->contents[i] = value;
+ else if (EQ (range, Qnil))
+ XCHAR_TABLE (char_table)->defalt = value;
+ else if (INTEGERP (range))
+ Faset (char_table, range, value);
+ else if (VECTORP (range))
+ {
+ for (i = 0; i < XVECTOR (range)->size - 1; i++)
+ char_table = Faref (char_table, XVECTOR (range)->contents[i]);
+
+ if (EQ (XVECTOR (range)->contents[i], Qnil))
+ XCHAR_TABLE (char_table)->defalt = value;
+ else
+ Faset (char_table, XVECTOR (range)->contents[i], value);
+ }
+ else
+ error ("Invalid RANGE argument to `set-char-table-range'");
+
+ return value;
+}
+\f
+/* Map C_FUNCTION or FUNCTION over CHARTABLE, calling it for each
+ character or group of characters that share a value.
+ DEPTH is the current depth in the originally specified
+ chartable, and INDICES contains the vector indices
+ for the levels our callers have descended. */
+
+void
+map_char_table (c_function, function, chartable, depth, indices)
+ Lisp_Object (*c_function) (), function, chartable, *indices;
+ int depth;
+{
+ int i;
+ int size = CHAR_TABLE_ORDINARY_SLOTS;
+
+ /* Make INDICES longer if we are about to fill it up. */
+ if ((depth % 10) == 9)
+ {
+ Lisp_Object *new_indices
+ = (Lisp_Object *) alloca ((depth += 10) * sizeof (Lisp_Object));
+ bcopy (indices, new_indices, depth * sizeof (Lisp_Object));
+ indices = new_indices;
+ }
+
+ for (i = 0; i < size; i++)
+ {
+ Lisp_Object elt;
+ indices[depth] = i;
+ elt = XCHAR_TABLE (chartable)->contents[i];
+ if (CHAR_TABLE_P (elt))
+ map_char_table (c_function, function, chartable, depth + 1, indices);
+ else if (c_function)
+ (*c_function) (depth + 1, indices, elt);
+ /* Here we should handle all cases where the range is a single character
+ by passing that character as a number. Currently, that is
+ all the time, but with the MULE code this will have to be changed. */
+ else if (depth == 0)
+ call2 (function, make_number (i), elt);
+ else
+ call2 (function, Fvector (depth + 1, indices), elt);
+ }
+}
+
+DEFUN ("map-char-table", Fmap_char_table, Smap_char_table,
+ 2, 2, 0,
+ "Call FUNCTION for each range of like characters in CHAR-TABLE.\n\
+FUNCTION is called with two arguments--a key and a value.\n\
+The key is always a possible RANGE argument to `set-char-table-range'.")
+ (function, char_table)
+ Lisp_Object function, char_table;
+{
+ Lisp_Object keyvec;
+ Lisp_Object *indices = (Lisp_Object *) alloca (10 * sizeof (Lisp_Object));
+
+ map_char_table (NULL, function, char_table, 0, indices);
+ return Qnil;
+}
+\f
/* ARGSUSED */
Lisp_Object
nconc2 (s1, s2)
}
DEFUN ("mapconcat", Fmapconcat, Smapconcat, 3, 3, 0,
- "Apply FN to each element of SEQ, and concat the results as strings.\n\
-In between each pair of results, stick in SEP.\n\
-Thus, \" \" as SEP results in spaces between the values returned by FN.")
- (fn, seq, sep)
- Lisp_Object fn, seq, sep;
+ "Apply FUNCTION to each element of SEQUENCE, and concat the results as strings.\n\
+In between each pair of results, stick in SEPARATOR. Thus, \" \" as\n\
+SEPARATOR results in spaces between the values returned by FUNCTION.")
+ (function, sequence, separator)
+ Lisp_Object function, sequence, separator;
{
Lisp_Object len;
register int leni;
register int i;
struct gcpro gcpro1;
- len = Flength (seq);
+ len = Flength (sequence);
leni = XINT (len);
nargs = leni + leni - 1;
if (nargs < 0) return build_string ("");
args = (Lisp_Object *) alloca (nargs * sizeof (Lisp_Object));
- GCPRO1 (sep);
- mapcar1 (leni, args, fn, seq);
+ GCPRO1 (separator);
+ mapcar1 (leni, args, function, sequence);
UNGCPRO;
for (i = leni - 1; i >= 0; i--)
args[i + i] = args[i];
for (i = 1; i < nargs; i += 2)
- args[i] = sep;
+ args[i] = separator;
return Fconcat (nargs, args);
}
"Apply FUNCTION to each element of SEQUENCE, and make a list of the results.\n\
The result is a list just as long as SEQUENCE.\n\
SEQUENCE may be a list, a vector or a string.")
- (fn, seq)
- Lisp_Object fn, seq;
+ (function, sequence)
+ Lisp_Object function, sequence;
{
register Lisp_Object len;
register int leni;
register Lisp_Object *args;
- len = Flength (seq);
+ len = Flength (sequence);
leni = XFASTINT (len);
args = (Lisp_Object *) alloca (leni * sizeof (Lisp_Object));
- mapcar1 (leni, args, fn, seq);
+ mapcar1 (leni, args, function, sequence);
return Flist (leni, args);
}
register int answer;
Lisp_Object xprompt;
Lisp_Object args[2];
- int ocech = cursor_in_echo_area;
struct gcpro gcpro1, gcpro2;
+ int count = specpdl_ptr - specpdl;
+
+ specbind (Qcursor_in_echo_area, Qt);
map = Fsymbol_value (intern ("query-replace-map"));
while (1)
{
-#ifdef HAVE_X_MENU
+
+
+#ifdef HAVE_MENUS
if ((NILP (last_nonmenu_event) || CONSP (last_nonmenu_event))
- && using_x_p ())
+ && have_menus_p ())
{
Lisp_Object pane, menu;
redisplay_preserve_echo_area ();
answer = !NILP (obj);
break;
}
-#endif
+#endif /* HAVE_MENUS */
cursor_in_echo_area = 1;
+ choose_minibuf_frame ();
message_nolog ("%s(y or n) ", XSTRING (xprompt)->data);
obj = read_filtered_event (1, 0, 0);
QUIT;
key = Fmake_vector (make_number (1), obj);
- def = Flookup_key (map, key);
+ def = Flookup_key (map, key, Qt);
answer_string = Fsingle_key_description (obj);
if (EQ (def, intern ("skip")))
cursor_in_echo_area = -1;
message_nolog ("%s(y or n) %c",
XSTRING (xprompt)->data, answer ? 'y' : 'n');
- cursor_in_echo_area = ocech;
}
+ unbind_to (count, Qnil);
return answer ? Qt : Qnil;
}
\f
CHECK_STRING (prompt, 0);
-#ifdef HAVE_X_MENU
- if ((NILP (last_nonmenu_event) || CONSP (last_nonmenu_event))
- && using_x_p ())
+#ifdef HAVE_MENUS
+ if ((NILP (last_nonmenu_event) || CONSP (last_nonmenu_event))
+ && have_menus_p ())
{
Lisp_Object pane, menu, obj;
redisplay_preserve_echo_area ();
UNGCPRO;
return obj;
}
-#endif
+#endif /* HAVE_MENUS */
args[0] = prompt;
args[1] = build_string ("(yes or no) ");
staticpro (&Qrequire);
Qyes_or_no_p_history = intern ("yes-or-no-p-history");
staticpro (&Qyes_or_no_p_history);
+ Qcursor_in_echo_area = intern ("cursor-in-echo-area");
+ staticpro (&Qcursor_in_echo_area);
+
+ Fset (Qyes_or_no_p_history, Qnil);
DEFVAR_LISP ("features", &Vfeatures,
"A list of symbols which are the features of the executing emacs.\n\
defsubr (&Sput);
defsubr (&Sequal);
defsubr (&Sfillarray);
+ defsubr (&Schar_table_subtype);
+ defsubr (&Schar_table_parent);
+ defsubr (&Sset_char_table_parent);
+ defsubr (&Schar_table_extra_slot);
+ defsubr (&Sset_char_table_extra_slot);
+ defsubr (&Schar_table_range);
+ defsubr (&Sset_char_table_range);
+ defsubr (&Smap_char_table);
defsubr (&Snconc);
defsubr (&Smapcar);
defsubr (&Smapconcat);
HCoop / bpt / emacs.git / blobdiff