static bool
deadp (Lisp_Object x)
{
- return EQ (x, dead_object ());
+ return BASE_EQ (x, dead_object ());
}
#ifdef GC_MALLOC_CHECK
eassert (XSYMBOL (sym)->u.s.redirect == SYMBOL_LOCALIZED);
/* Need not do anything if some other buffer's binding is
now cached. */
- if (EQ (SYMBOL_BLV (XSYMBOL (sym))->where, buffer))
+ if (BASE_EQ (SYMBOL_BLV (XSYMBOL (sym))->where, buffer))
{
/* Symbol is set up for this buffer's old local value:
swap it out! */
static bool
candidate_buffer (Lisp_Object b, Lisp_Object buffer)
{
- return (BUFFERP (b) && !EQ (b, buffer)
+ return (BUFFERP (b) && !BASE_EQ (b, buffer)
&& BUFFER_LIVE_P (XBUFFER (b))
&& !BUFFER_HIDDEN_P (XBUFFER (b)));
}
since anything can happen within do_yes_or_no_p. */
/* Don't kill the minibuffer now current. */
- if (EQ (buffer, XWINDOW (minibuf_window)->contents))
+ if (BASE_EQ (buffer, XWINDOW (minibuf_window)->contents))
return Qnil;
/* When we kill an ordinary buffer which shares its buffer text
is the sole other buffer give up. */
XSETBUFFER (tem, current_buffer);
if (EQ (tem, XWINDOW (minibuf_window)->contents)
- && EQ (buffer, Fother_buffer (buffer, Qnil, Qnil)))
+ && BASE_EQ (buffer, Fother_buffer (buffer, Qnil, Qnil)))
return Qnil;
/* Now there is no question: we can kill the buffer. */
{
ws = Fcons (w, ws);
if (MARKERP (XWINDOW (w)->pointm)
- && (EQ (XWINDOW (w)->contents, buf1)
- || EQ (XWINDOW (w)->contents, buf2)))
+ && (BASE_EQ (XWINDOW (w)->contents, buf1)
+ || BASE_EQ (XWINDOW (w)->contents, buf2)))
Fset_marker (XWINDOW (w)->pointm,
make_fixnum
(BUF_BEGV (XBUFFER (XWINDOW (w)->contents))),
XWINDOW (w)->contents);
/* Blindly copied from pointm part. */
if (MARKERP (XWINDOW (w)->old_pointm)
- && (EQ (XWINDOW (w)->contents, buf1)
- || EQ (XWINDOW (w)->contents, buf2)))
+ && (BASE_EQ (XWINDOW (w)->contents, buf1)
+ || BASE_EQ (XWINDOW (w)->contents, buf2)))
Fset_marker (XWINDOW (w)->old_pointm,
make_fixnum
(BUF_BEGV (XBUFFER (XWINDOW (w)->contents))),
XWINDOW (w)->contents);
if (MARKERP (XWINDOW (w)->start)
- && (EQ (XWINDOW (w)->contents, buf1)
- || EQ (XWINDOW (w)->contents, buf2)))
+ && (BASE_EQ (XWINDOW (w)->contents, buf1)
+ || BASE_EQ (XWINDOW (w)->contents, buf2)))
Fset_marker (XWINDOW (w)->start,
make_fixnum
(XBUFFER (XWINDOW (w)->contents)->last_window_start),
}
if (current_buffer->text->intervals)
- (eassert (EQ (current_buffer->text->intervals->up.obj, buffer)),
+ (eassert (BASE_EQ (current_buffer->text->intervals->up.obj, buffer)),
XSETBUFFER (current_buffer->text->intervals->up.obj, current_buffer));
if (other_buffer->text->intervals)
- (eassert (EQ (other_buffer->text->intervals->up.obj, Fcurrent_buffer ())),
+ (eassert (BASE_EQ (other_buffer->text->intervals->up.obj,
+ Fcurrent_buffer ())),
XSETBUFFER (other_buffer->text->intervals->up.obj, other_buffer));
return Qnil;
else
CHECK_BUFFER (buffer);
- if (MARKERP (beg) && !EQ (Fmarker_buffer (beg), buffer))
+ if (MARKERP (beg) && !BASE_EQ (Fmarker_buffer (beg), buffer))
signal_error ("Marker points into wrong buffer", beg);
- if (MARKERP (end) && !EQ (Fmarker_buffer (end), buffer))
+ if (MARKERP (end) && !BASE_EQ (Fmarker_buffer (end), buffer))
signal_error ("Marker points into wrong buffer", end);
CHECK_FIXNUM_COERCE_MARKER (beg);
if (NILP (Fbuffer_live_p (buffer)))
error ("Attempt to move overlay to a dead buffer");
- if (MARKERP (beg) && !EQ (Fmarker_buffer (beg), buffer))
+ if (MARKERP (beg) && !BASE_EQ (Fmarker_buffer (beg), buffer))
signal_error ("Marker points into wrong buffer", beg);
- if (MARKERP (end) && !EQ (Fmarker_buffer (end), buffer))
+ if (MARKERP (end) && !BASE_EQ (Fmarker_buffer (end), buffer))
signal_error ("Marker points into wrong buffer", end);
CHECK_FIXNUM_COERCE_MARKER (beg);
&& (w = XCAR (w), WINDOWP (w)))
{
if (MINI_WINDOW_P (XWINDOW (w))
- && ! (minibuf_level > 0 && EQ (w, minibuf_window)))
+ && ! (minibuf_level > 0 && BASE_EQ (w, minibuf_window)))
error ("Attempt to select inactive minibuffer window");
/* If the current buffer wants to clean up, let it. */
case 'b': /* Name of existing buffer. */
args[i] = Fcurrent_buffer ();
- if (EQ (selected_window, minibuf_window))
+ if (BASE_EQ (selected_window, minibuf_window))
args[i] = Fother_buffer (args[i], Qnil, Qnil);
args[i] = Fread_buffer (callint_message, args[i], Qt, Qnil);
break;
if (saved_pt >= 0)
{
/* This is the case of:
- (BUFFERP (src_object) && EQ (src_object, dst_object))
+ (BUFFERP (src_object) && BASE_EQ (src_object, dst_object))
As we have moved PT while replacing the original buffer
contents, we must recover it now. */
set_buffer_internal (XBUFFER (src_object));
attrs = CODING_ID_ATTRS (coding->id);
bool same_buffer = false;
- if (EQ (src_object, dst_object) && BUFFERP (src_object))
+ if (BASE_EQ (src_object, dst_object) && BUFFERP (src_object))
{
struct Lisp_Marker *tail;
if (BUFFERP (dst_object))
{
coding->dst_object = dst_object;
- if (EQ (src_object, dst_object))
+ if (BASE_EQ (src_object, dst_object))
{
coding->dst_pos = from;
coding->dst_pos_byte = from_byte;
if (saved_pt >= 0)
{
/* This is the case of:
- (BUFFERP (src_object) && EQ (src_object, dst_object))
+ (BUFFERP (src_object) && BASE_EQ (src_object, dst_object))
As we have moved PT while replacing the original buffer
contents, we must recover it now. */
set_buffer_internal (XBUFFER (src_object));
setup_coding_system (coding_system, &coding);
coding.mode |= CODING_MODE_LAST_BLOCK;
- if (BUFFERP (dst_object) && !EQ (dst_object, src_object))
+ if (BUFFERP (dst_object) && !BASE_EQ (dst_object, src_object))
{
struct buffer *buf = XBUFFER (dst_object);
ptrdiff_t buf_pt = BUF_PT (buf);
&& ((STRINGP (target)
&& STRINGP (XCAR (elt))
&& fast_string_match (XCAR (elt), target) >= 0)
- || (FIXNUMP (target) && EQ (target, XCAR (elt)))))
+ || (FIXNUMP (target) && BASE_EQ (target, XCAR (elt)))))
{
val = XCDR (elt);
/* Here, if VAL is both a valid coding system and a valid
{
Lisp_Object match_idx =
Fstring_match (XCAR (lds_re_tail), filename, Qnil, Qnil);
- if (EQ (match_idx, make_fixnum (0)))
+ if (BASE_EQ (match_idx, make_fixnum (0)))
{
filename =
Freplace_match (build_string ("//"), Qt, Qt, filename, Qnil);
/* Tell regex.c to use a type compatible with Emacs. */
#define RE_TRANSLATE_TYPE Lisp_Object
#define RE_TRANSLATE(TBL, C) char_table_translate (TBL, C)
-#define RE_TRANSLATE_P(TBL) (!EQ (TBL, make_fixnum (0)))
+#define RE_TRANSLATE_P(TBL) (!BASE_EQ (TBL, make_fixnum (0)))
#endif
/* Tell time_rz.c to use Emacs's getter and setter for TZ.
forwarded objects won't work right. */
{
Lisp_Object buf; XSETBUFFER (buf, current_buffer);
- if (EQ (buf, blv->where))
+ if (BASE_EQ (buf, blv->where))
swap_in_global_binding (sym);
}
if (! FIXNUMP (count))
{
- if (EQ (value, make_fixnum (0)))
+ if (BASE_EQ (value, make_fixnum (0)))
return value;
if (mpz_sgn (*xbignum_val (count)) < 0)
{
expt_integer (Lisp_Object x, Lisp_Object y)
{
/* Special cases for -1 <= x <= 1, which never overflow. */
- if (EQ (x, make_fixnum (1)))
+ if (BASE_EQ (x, make_fixnum (1)))
return x;
- if (EQ (x, make_fixnum (0)))
- return EQ (x, y) ? make_fixnum (1) : x;
- if (EQ (x, make_fixnum (-1)))
+ if (BASE_EQ (x, make_fixnum (0)))
+ return BASE_EQ (x, y) ? make_fixnum (1) : x;
+ if (BASE_EQ (x, make_fixnum (-1)))
return ((FIXNUMP (y) ? XFIXNUM (y) & 1 : mpz_odd_p (*xbignum_val (y)))
? x : make_fixnum (1));
name = DECODE_FILE (name);
ptrdiff_t name_blen = SBYTES (name), name_len = SCHARS (name);
if (completion_ignore_case
- && !EQ (Fcompare_strings (name, zero, file_len, file, zero, file_len,
- Qt),
- Qt))
+ && !BASE_EQ (Fcompare_strings (name, zero, file_len, file, zero,
+ file_len, Qt),
+ Qt))
continue;
switch (dirent_type (dp))
skip = name_len - elt_len;
cmp_len = make_fixnum (elt_len);
if (skip < 0
- || !EQ (Fcompare_strings (name, make_fixnum (skip),
- Qnil,
- elt, zero, cmp_len, Qt),
- Qt))
+ || !BASE_EQ (Fcompare_strings (name,
+ make_fixnum (skip),
+ Qnil,
+ elt, zero, cmp_len,
+ Qt),
+ Qt))
continue;
}
break;
skip = name_len - elt_len;
cmp_len = make_fixnum (elt_len);
if (skip < 0
- || !EQ (Fcompare_strings (name, make_fixnum (skip),
- Qnil,
- elt, zero, cmp_len, Qt),
- Qt))
+ || !BASE_EQ (Fcompare_strings (name,
+ make_fixnum (skip),
+ Qnil,
+ elt, zero, cmp_len,
+ Qt),
+ Qt))
continue;
}
break;
= Fcompare_strings (name, zero, make_fixnum (compare),
file, zero, make_fixnum (compare),
completion_ignore_case ? Qt : Qnil);
- if (!EQ (cmp, Qt))
+ if (!BASE_EQ (cmp, Qt))
continue;
}
= Fcompare_strings (bestmatch, zero, make_fixnum (compare),
name, zero, make_fixnum (compare),
completion_ignore_case ? Qt : Qnil);
- ptrdiff_t matchsize = EQ (cmp, Qt) ? compare : eabs (XFIXNUM (cmp)) - 1;
+ ptrdiff_t matchsize = BASE_EQ (cmp, Qt)
+ ? compare : eabs (XFIXNUM (cmp)) - 1;
if (completion_ignore_case)
{
file, zero,
Qnil,
Qnil),
- EQ (Qt, cmp))
+ BASE_EQ (Qt, cmp))
&& (cmp = Fcompare_strings (bestmatch, zero,
make_fixnum (SCHARS (file)),
file, zero,
Qnil,
Qnil),
- ! EQ (Qt, cmp))))
+ ! BASE_EQ (Qt, cmp))))
bestmatch = name;
}
bestmatchsize = matchsize;
/* If we are showing a message instead of the mini-buffer,
show the cursor for the message instead. */
&& XWINDOW (minibuf_window) == w
- && EQ (minibuf_window, echo_area_window)
+ && BASE_EQ (minibuf_window, echo_area_window)
/* These cases apply only to the frame that contains
the active mini-buffer window. */
&& FRAME_HAS_MINIBUF_P (f)
- && EQ (FRAME_MINIBUF_WINDOW (f), echo_area_window))
+ && BASE_EQ (FRAME_MINIBUF_WINDOW (f), echo_area_window))
{
cx = cy = vpos = hpos = 0;
/* If we are showing a message instead of the mini-buffer,
show the cursor for the message instead of for the
(now hidden) mini-buffer contents. */
- || (EQ (minibuf_window, selected_window)
- && EQ (minibuf_window, echo_area_window)
+ || (BASE_EQ (minibuf_window, selected_window)
+ && BASE_EQ (minibuf_window, echo_area_window)
&& !NILP (echo_area_buffer[0])))
/* These cases apply only to the frame that contains
the active mini-buffer window. */
&& FRAME_HAS_MINIBUF_P (f)
- && EQ (FRAME_MINIBUF_WINDOW (f), echo_area_window))
+ && BASE_EQ (FRAME_MINIBUF_WINDOW (f), echo_area_window))
{
int top = WINDOW_TOP_EDGE_LINE (XWINDOW (FRAME_MINIBUF_WINDOW (f)));
int col;
{
if (idx == ASIZE (state))
goto changed;
- if (!EQ (AREF (state, idx++), frame))
+ if (!BASE_EQ (AREF (state, idx++), frame))
goto changed;
if (idx == ASIZE (state))
goto changed;
continue;
if (idx == ASIZE (state))
goto changed;
- if (!EQ (AREF (state, idx++), buf))
+ if (!BASE_EQ (AREF (state, idx++), buf))
goto changed;
if (idx == ASIZE (state))
goto changed;
/* If DOC is 0, it's typically because of a dumped file missing
from the DOC file (bug in src/Makefile.in). */
- if (EQ (doc, make_fixnum (0)))
+ if (BASE_EQ (doc, make_fixnum (0)))
doc = Qnil;
if (FIXNUMP (doc) || CONSP (doc))
{
tem = Fget (indirect, prop);
}
- if (EQ (tem, make_fixnum (0)))
+ if (BASE_EQ (tem, make_fixnum (0)))
tem = Qnil;
/* See if we want to look for the string in the DOC file. */
Lisp_Object dv = DISP_CHAR_VECTOR (XCHAR_TABLE (Vstandard_display_table),
LEFT_SINGLE_QUOTATION_MARK);
return (VECTORP (dv) && ASIZE (dv) == 1
- && EQ (AREF (dv, 0), make_fixnum ('`')));
+ && BASE_EQ (AREF (dv, 0), make_fixnum ('`')));
}
DEFUN ("text-quoting-style", Ftext_quoting_style,
prev_new = make_fixnum (XFIXNUM (new_pos) - 1);
if (NILP (Vinhibit_field_text_motion)
- && !EQ (new_pos, old_pos)
+ && !BASE_EQ (new_pos, old_pos)
&& (!NILP (Fget_char_property (new_pos, Qfield, Qnil))
|| !NILP (Fget_char_property (old_pos, Qfield, Qnil))
/* To recognize field boundaries, we must also look at the
pdl->unwind_excursion.marker = Fpoint_marker ();
/* Selected window if current buffer is shown in it, nil otherwise. */
pdl->unwind_excursion.window
- = (EQ (XWINDOW (selected_window)->contents, Fcurrent_buffer ())
+ = (BASE_EQ (XWINDOW (selected_window)->contents, Fcurrent_buffer ())
? selected_window : Qnil);
}
/* If buffer was visible in a window, and a different window was
selected, and the old selected window is still showing this
buffer, restore point in that window. */
- if (WINDOWP (window) && !EQ (window, selected_window))
+ if (WINDOWP (window) && !BASE_EQ (window, selected_window))
{
/* Set window point if WINDOW is live and shows the current buffer. */
Lisp_Object contents = XWINDOW (window)->contents;
CHECK_INTEGER (n);
/* Placeholder implementation until we get our act together. */
- return EQ (n, make_fixnum (1)) ? msgid : msgid_plural;
+ return BASE_EQ (n, make_fixnum (1)) ? msgid : msgid_plural;
}
\f
DEFUN ("message", Fmessage, Smessage, 1, MANY, 0,
&& !AUTOLOADP (XSYMBOL (function)->u.s.function))
return Qnil;
- if (!NILP (Vpurify_flag) && EQ (docstring, make_fixnum (0)))
+ if (!NILP (Vpurify_flag) && BASE_EQ (docstring, make_fixnum (0)))
/* `read1' in lread.c has found the docstring starting with "\
and assumed the docstring will be provided by Snarf-documentation, so it
passed us 0 instead. But that leads to accidental sharing in purecopy's
while (CONSP (queue))
{
Lisp_Object first = XCAR (queue);
- if (CONSP (first) && EQ (XCAR (first), make_fixnum (0)))
+ if (CONSP (first) && BASE_EQ (XCAR (first), make_fixnum (0)))
Vfeatures = XCDR (first);
else
Ffset (first, Fcar (Fcdr (Fget (first, Qfunction_history))));
specpdl_ptr->let.where = Fcurrent_buffer ();
eassert (sym->u.s.redirect != SYMBOL_LOCALIZED
- || (EQ (SYMBOL_BLV (sym)->where, Fcurrent_buffer ())));
+ || (BASE_EQ (SYMBOL_BLV (sym)->where, Fcurrent_buffer ())));
if (sym->u.s.redirect == SYMBOL_LOCALIZED)
{
memset (data + prefix_len, 'X', nX);
memcpy (data + prefix_len + nX, SSDATA (encoded_suffix), suffix_len);
int kind = (NILP (dir_flag) ? GT_FILE
- : EQ (dir_flag, make_fixnum (0)) ? GT_NOCREATE
+ : BASE_EQ (dir_flag, make_fixnum (0)) ? GT_NOCREATE
: GT_DIR);
int fd = gen_tempname (data, suffix_len, O_BINARY | O_CLOEXEC, kind);
bool failed = fd < 0;
if (best_above == best_above_byte)
return char_index;
- if (EQ (string, string_char_byte_cache_string))
+ if (BASE_EQ (string, string_char_byte_cache_string))
{
if (string_char_byte_cache_charpos < char_index)
{
if (best_above == best_above_byte)
return byte_index;
- if (EQ (string, string_char_byte_cache_string))
+ if (BASE_EQ (string, string_char_byte_cache_string))
{
if (string_char_byte_cache_bytepos < byte_index)
{
{
/* If the tortoise just jumped (which is rare),
update TORTOISE_NUM accordingly. */
- if (EQ (tail, li.tortoise))
+ if (BASE_EQ (tail, li.tortoise))
tortoise_num = num;
saved_tail = XCDR (tail);
next = XCDR (tail);
/* If SEQ contains a cycle, attempting to reverse it
in-place will inevitably come back to SEQ. */
- if (EQ (next, seq))
+ if (BASE_EQ (next, seq))
circular_list (seq);
Fsetcdr (tail, prev);
prev = tail;
/* If the window contains this buffer, use it for getting text properties.
Otherwise use the current buffer as arg for doing that. */
- if (EQ (w->contents, Fcurrent_buffer ()))
+ if (BASE_EQ (w->contents, Fcurrent_buffer ()))
text_prop_object = window;
else
text_prop_object = Fcurrent_buffer ();
/* Assign a watch ID that is not already in use, by looking
for a gap in the existing sorted list. */
for (; ! NILP (XCDR (tail)); tail = XCDR (tail), id++)
- if (!EQ (XCAR (XCAR (XCDR (tail))), make_fixnum (id)))
+ if (!BASE_EQ (XCAR (XCAR (XCDR (tail))), make_fixnum (id)))
break;
if (MOST_POSITIVE_FIXNUM < id)
emacs_abort ();
if (minibuf_level
&& !NILP (echo_area_buffer[0])
- && EQ (minibuf_window, echo_area_window)
+ && BASE_EQ (minibuf_window, echo_area_window)
&& NUMBERP (Vminibuffer_message_timeout))
{
/* Bind inhibit-quit to t so that C-g gets read in
&& (input_was_pending || !redisplay_dont_pause)))
{
input_was_pending = input_pending;
- if (help_echo_showing_p && !EQ (selected_window, minibuf_window))
+ if (help_echo_showing_p && !BASE_EQ (selected_window, minibuf_window))
redisplay_preserve_echo_area (5);
else
redisplay ();
goto exit;
}
- if (EQ (c, make_fixnum (-2)))
+ if (BASE_EQ (c, make_fixnum (-2)))
return c;
if (CONSP (c) && EQ (XCAR (c), Qt))
unbind_to (count, Qnil);
redisplay ();
- if (EQ (c, make_fixnum (040)))
+ if (BASE_EQ (c, make_fixnum (040)))
{
cancel_echoing ();
do
if (!FIXNUMP (obj) || XFIXNUM (obj) == -2
|| (! EQ (obj, menu_prompt_more_char)
&& (!FIXNUMP (menu_prompt_more_char)
- || ! EQ (obj, make_fixnum (Ctl (XFIXNUM (menu_prompt_more_char)))))))
+ || ! BASE_EQ (obj, make_fixnum (Ctl (XFIXNUM (menu_prompt_more_char)))))))
{
if (!NILP (KVAR (current_kboard, defining_kbd_macro)))
store_kbd_macro_char (obj);
hash = hash_string (ptr, size_byte) % obsize;
bucket = AREF (obarray, hash);
oblookup_last_bucket_number = hash;
- if (EQ (bucket, make_fixnum (0)))
+ if (BASE_EQ (bucket, make_fixnum (0)))
;
else if (!SYMBOLP (bucket))
/* Like CADR error message. */
cfnumber_get_font_symbolic_traits_value (num, &sym_traits);
CFRelease (dict);
}
- if (EQ (AREF (entity, FONT_SIZE_INDEX), make_fixnum (0)))
+ if (BASE_EQ (AREF (entity, FONT_SIZE_INDEX), make_fixnum (0)))
ASET (entity, FONT_AVGWIDTH_INDEX, make_fixnum (0));
ASET (entity, FONT_EXTRA_INDEX, Fcopy_sequence (extra));
name = CTFontDescriptorCopyAttribute (desc, kCTFontNameAttribute);
macfont_info->cgfont = CTFontCopyGraphicsFont (macfont, NULL);
val = assq_no_quit (QCdestination, AREF (entity, FONT_EXTRA_INDEX));
- if (CONSP (val) && EQ (XCDR (val), make_fixnum (1)))
+ if (CONSP (val) && BASE_EQ (XCDR (val), make_fixnum (1)))
macfont_info->screen_font = mac_screen_font_create_with_name (font_name,
size);
else
{
if (NILP (buffer))
buffer = Fcurrent_buffer ();
- return EQ (buffer, (Fcar (Fnthcdr (make_fixnum (minibuf_level),
- Vminibuffer_list))))
+ return BASE_EQ (buffer, (Fcar (Fnthcdr (make_fixnum (minibuf_level),
+ Vminibuffer_list))))
? Qt
: Qnil;
}
if (bestmatchsize != SCHARS (eltstring)
|| bestmatchsize != matchsize
|| (completion_ignore_case
- && !EQ (Fcompare_strings (old_bestmatch, zero, lcompare,
- eltstring, zero, lcompare,
- Qnil),
- Qt)))
+ && !BASE_EQ (Fcompare_strings (old_bestmatch, zero,
+ lcompare, eltstring, zero,
+ lcompare, Qnil),
+ Qt)))
/* Don't count the same string multiple times. */
matchcount += matchcount <= 1;
bestmatchsize = matchsize;
if (SYMBOLP (tail))
while (1)
{
- if (EQ (Fcompare_strings (string, make_fixnum (0), Qnil,
- Fsymbol_name (tail),
- make_fixnum (0) , Qnil, Qt),
- Qt))
+ if (BASE_EQ (Fcompare_strings (string, make_fixnum (0),
+ Qnil,
+ Fsymbol_name (tail),
+ make_fixnum (0) , Qnil, Qt),
+ Qt))
{
tem = tail;
break;
if (BASE_EQ (tem, Qunbound)) continue;
Lisp_Object strkey = (SYMBOLP (tem) ? Fsymbol_name (tem) : tem);
if (!STRINGP (strkey)) continue;
- if (EQ (Fcompare_strings (string, Qnil, Qnil,
- strkey, Qnil, Qnil,
- completion_ignore_case ? Qt : Qnil),
+ if (BASE_EQ (Fcompare_strings (string, Qnil, Qnil,
+ strkey, Qnil, Qnil,
+ completion_ignore_case ? Qt : Qnil),
Qt))
goto found_matching_key;
}
/* See if it's changed. */
if (STRINGP (arg))
{
- if (STRINGP (oldval) && EQ (Fstring_equal (oldval, arg), Qt))
+ if (STRINGP (oldval) && BASE_EQ (Fstring_equal (oldval, arg), Qt))
return;
}
else if (!STRINGP (oldval) && NILP (oldval) == NILP (arg))
static Lisp_Object
dump_queue_dequeue (struct dump_queue *dump_queue, dump_off basis)
{
- eassert (EQ (Fhash_table_count (dump_queue->sequence_numbers),
- Fhash_table_count (dump_queue->link_weights)));
+ eassert (BASE_EQ (Fhash_table_count (dump_queue->sequence_numbers),
+ Fhash_table_count (dump_queue->link_weights)));
eassert (XFIXNUM (Fhash_table_count (dump_queue->sequence_numbers))
<= (dump_tailq_length (&dump_queue->fancy_weight_objects)
if (STRINGP (arg))
{
- if (STRINGP (oldval) && EQ (Fstring_equal (oldval, arg), Qt))
+ if (STRINGP (oldval) && BASE_EQ (Fstring_equal (oldval, arg), Qt))
return;
}
else if (!STRINGP (oldval) && NILP (oldval) == NILP (arg))
if (STRINGP (arg))
{
- if (STRINGP (oldval) && EQ (Fstring_equal (oldval, arg), Qt))
+ if (STRINGP (oldval) && BASE_EQ (Fstring_equal (oldval, arg), Qt))
return;
}
else if (!NILP (arg) || NILP (oldval))
/* Can't wait for a process that is dedicated to a different
thread. */
- if (!NILP (proc->thread) && !EQ (proc->thread, Fcurrent_thread ()))
+ if (!NILP (proc->thread) && !BASE_EQ (proc->thread, Fcurrent_thread ()))
{
Lisp_Object proc_thread_name = XTHREAD (proc->thread)->name;
/* If we want no properties for a whole string,
get rid of its intervals. */
if (NILP (properties) && STRINGP (object)
- && EQ (start, make_fixnum (0))
- && EQ (end, make_fixnum (SCHARS (object))))
+ && BASE_EQ (start, make_fixnum (0))
+ && BASE_EQ (end, make_fixnum (SCHARS (object))))
{
if (!string_intervals (object))
return Qnil;
return;
if (STRINGP (arg) && STRINGP (oldval)
- && EQ (Fstring_equal (oldval, arg), Qt))
+ && BASE_EQ (Fstring_equal (oldval, arg), Qt))
return;
if (SYMBOLP (arg) && SYMBOLP (oldval) && EQ (arg, oldval))
{
if (STRINGP (arg))
{
- if (STRINGP (oldval) && EQ (Fstring_equal (oldval, arg), Qt))
+ if (STRINGP (oldval) && BASE_EQ (Fstring_equal (oldval, arg), Qt))
return;
}
else if (!NILP (arg) || NILP (oldval))
eol_type = Fcoding_system_eol_type (coding_system);
/* Already a DOS coding system? */
- if (EQ (eol_type, make_fixnum (1)))
+ if (BASE_EQ (eol_type, make_fixnum (1)))
return coding_system;
/* Get EOL_TYPE vector of the base of CODING_SYSTEM. */
? miniwin : Qnil);
else if (EQ (*all_frames, Qvisible))
;
- else if (EQ (*all_frames, make_fixnum (0)))
+ else if (BASE_EQ (*all_frames, make_fixnum (0)))
;
else if (FRAMEP (*all_frames))
;
if (f)
frame_arg = Qlambda;
- else if (EQ (frames, make_fixnum (0)))
+ else if (BASE_EQ (frames, make_fixnum (0)))
frame_arg = frames;
else if (EQ (frames, Qvisible))
frame_arg = frames;
hare = XCDR (hare);
tortoise = XCDR (tortoise);
- if (EQ (hare, tortoise))
+ if (BASE_EQ (hare, tortoise))
/* Reset Vwindow_persistent_parameters to Qnil. */
{
Vwindow_persistent_parameters = Qnil;
wset_redisplay (struct window *w)
{
/* Beware: selected_window can be nil during early stages. */
- if (!EQ (make_lisp_ptr (w, Lisp_Vectorlike), selected_window))
+ if (!BASE_EQ (make_lisp_ptr (w, Lisp_Vectorlike), selected_window))
redisplay_other_windows ();
w->redisplay = true;
}
/* If the font was specified in a way
different from XLFD (e.g., on MS-Windows),
we will have a number there, not 'p'. */
- || EQ (spacing,
- make_fixnum (FONT_SPACING_PROPORTIONAL)))
+ || BASE_EQ (spacing,
+ make_fixnum
+ (FONT_SPACING_PROPORTIONAL)))
? Qnil : Qt,
Ffont_xlfd_name (font, Qnil),
AREF (font, FONT_REGISTRY_INDEX));
break;
tortoise = Fget (tortoise, Qface_alias);
- if (EQ (hare, tortoise))
+ if (BASE_EQ (hare, tortoise))
{
if (signal_p)
circular_list (orig_face);
return true;
s1 = SYMBOL_NAME (face->font->props[i]);
s2 = SYMBOL_NAME (def_face->font->props[i]);
- if (! EQ (Fcompare_strings (s1, make_fixnum (0), Qnil,
- s2, make_fixnum (0), Qnil, Qt), Qt))
+ if (! BASE_EQ (Fcompare_strings (s1, make_fixnum (0), Qnil,
+ s2, make_fixnum (0), Qnil, Qt),
+ Qt))
return true;
}
return false;
if (STRINGP (arg))
{
- if (STRINGP (oldval) && EQ (Fstring_equal (oldval, arg), Qt))
+ if (STRINGP (oldval) && BASE_EQ (Fstring_equal (oldval, arg), Qt))
return;
}
else if (!STRINGP (oldval) && NILP (oldval) == NILP (arg))
if (STRINGP (arg))
{
- if (STRINGP (oldval) && EQ (Fstring_equal (oldval, arg), Qt))
+ if (STRINGP (oldval) && BASE_EQ (Fstring_equal (oldval, arg), Qt))
return;
}
else if (!NILP (arg) || NILP (oldval))
&& INTEGERP (XCAR (obj))
&& FIXNUMP (XCDR (obj)))
{
- if (EQ (XCAR (obj), make_fixnum (0)))
+ if (BASE_EQ (XCAR (obj), make_fixnum (0)))
return XCDR (obj);
- if (EQ (XCAR (obj), make_fixnum (-1)))
+ if (BASE_EQ (XCAR (obj), make_fixnum (-1)))
return make_fixnum (- XFIXNUM (XCDR (obj)));
}
if (VECTORP (obj))
projects / emacs.git / commitdiff