mirror/emacs
1
0
Fork 0
mirror of https://git.savannah.gnu.org/git/emacs.git synced 2024-12-23 10:34:07 +00:00
Code Issues Releases Activity

Avoid (most) uses of XCAR/XCDR as lvalues, for flexibility in experimenting

Browse Source 
with lisp system changes.
This commit is contained in:
Ken Raeburn 2001-10-16 09:09:51 +00:00
parent 018ba359ab
commit f3fbd15535
29 changed files with 350 additions and 193 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

78
src/ChangeLog
View File

@ -1,3 +1,81 @@
2001-10-16 Ken Raeburn <raeburn@gnu.org>
Avoid the assumption that car and cdr slots of cons cells are
addressable lvalues; this allows for easier experimentation with
other lisp implementations that may not permit such accesses for
various reasons. Not quite complete -- buffer.c still needs some
work, and w32/mac files need rechecking -- so compile-time
enforcement is left disabled for now.
* lisp.h (LISP_MAKE_RVALUE): New macro, or function in the case of
gcc with a union-based Lisp object rep. Redefine as no-op for
now.
(XCAR_AS_LVALUE, XCDR_AS_LVALUE): Rename from old XCAR, XCDR.
(XCAR, XCDR): Apply LISP_MAKE_RVALUE to the _AS_LVALUE versions.
(XSETCAR, XSETCDR): New macros.
(XSETCARFASTINT, XSETCDRFASTINT): New macros.
(CHECK_NUMBER_CAR, CHECK_NUMBER_CDR): New macros.
* keyboard.h (POSN_BUFFER_SET_POSN): New macro.
* alloc.c (Fcons, pure_cons, Fgarbage_collect): Use XSETCAR and
XSETCDR.
(mark_buffer): Use XCAR_AS_LVALUE, XCDR_AS_LVALUE.
* buffer.c (record_buffer, Fbury_buffer,
swap_out_buffer_local_variables, recenter_overlay_lists,
Foverlay_put): Use XSETCAR and XSETCDR to set the car and cdr
fields of a cons cell respectively.
* callint.c (quotify_args, Fcall_interactively): Likewise.
* ccl.c (Fregister_code_conversion_map): Likewise.
* coding.c (detect_coding_system): Likewise.
* composite.c (get_composition_id, make_composition_value_copy):
Likewise.
* data.c (Fsetcar, Fsetcdr, swap_in_global_binding,
swap_in_symval_forwarding, set_internal, Fset_default,
Fmake_variable_buffer_local, Fmake_local_variable,
Fmake_variable_frame_local): Likewise.
* fns.c (concat, Fcopy_alist, Fwidget_put): Likewise.
* keymap.c (Fset_keymap_parent, store_in_keymap,
accessible_keymaps_1, where_is_internal_2, Fcopy_keymap):
Likewise.
* minibuf.c (get_minibuffer): Likewise.
* search.c (Fmatch_data): Likewise.
* textprop.c (extend_property_ranges): Likewise.
* undo.c (record_insert, Fundo_boundary, truncate_undo_list):
Likewise.
* w32fns.c (w32_msg_pump, Fw32_register_hot_key, w32_list_fonts):
Likewise.
* w32term.c (x_delete_display): Likewise.
* xfaces.c (remove_duplicates, Finternal_set_lisp_face_attribute):
Likewise.
* xterm.c (x_list_fonts, x_load_font, x_delete_display):
Likewise.
* doc.c (store_function_docstring): Use XSETCARFASTINT.
* fileio.c (Fdo_auto_save): Use XSETCARFASTINT and
XSETCDRFASTINT.
(Fread_file_name): Use XSETCAR.
* fontset.c (Fset_fontset_font): Use CHECK_NUMBER_CAR and
CHECK_NUMBER_CDR.
(accumulate_font_info, Ffontset_info): Use XSETCAR and XSETCDR.
* frame.c (Fmake_terminal_frame): Use XSETCDR.
* indent.c (Fcompute_motion): Use CHECK_NUMBER_CAR and
CHECK_NUMBER_CDR.
* keyboard.c (read_char): Alter list traversal to avoid taking the
address of cons cell slots. Use POSN_BUFFER_SET_POSN.
(parse_menu_item): Use XSETCAR and XSETCDR.
(reach_char_x_menu_prompt): Use XSETCAR.
(read_key_sequence): Use POSN_BUFFER_SET_POSN.
(Fcommand_execute): Use XSETCDR.
* lread.c (Fload): Use XSETCARFASTINT and XSETCDRFASTINT.
(openp): Change list traversal to avoid using XCAR as lvalue.
(read_list): Use XSETCDR.
* process.c (wait_reading_process_input): Change wait_for_cell
handling to avoid taking addresses of cons cell slots.
* xselect.c (x_own_selection, x_handle_selection_clear,
x_clear_frame_selections): Use XSETCDR.
(wait_for_property_change): Use XSETCARFASTINT and
XSETCDRFASTINT.
(x_handle_property_notify, x_get_foreign_selection,
x_handle_selection_notify): Use XSETCAR.
2001-10-15 Pavel Jan,Bm(Bk <Pavel@Janik.cz>
* buffer.c: Put doc strings in comments.

19
src/alloc.c
View File

@ -2087,8 +2087,8 @@ DEFUN ("cons", Fcons, Scons, 2, 2, 0,
XSETCONS (val, &cons_block->conses[cons_block_index++]);
}
XCAR (val) = car;
XCDR (val) = cdr;
XSETCAR (val, car);
XSETCDR (val, cdr);
consing_since_gc += sizeof (struct Lisp_Cons);
cons_cells_consed++;
return val;
@ -3878,8 +3878,8 @@ pure_cons (car, cdr)
p = (struct Lisp_Cons *) pure_alloc (sizeof *p, Lisp_Cons);
XSETCONS (new, p);
XCAR (new) = Fpurecopy (car);
XCDR (new) = Fpurecopy (cdr);
XSETCAR (new, Fpurecopy (car));
XSETCDR (new, Fpurecopy (cdr));
return new;
}
@ -4189,7 +4189,10 @@ Garbage collection happens automatically if you cons more than
if (NILP (prev))
nextb->undo_list = tail = XCDR (tail);
else
tail = XCDR (prev) = XCDR (tail);
{
tail = XCDR (tail);
XSETCDR (prev, tail);
}
}
else
{
@ -4800,8 +4803,8 @@ mark_buffer (buf)
&& ! XMARKBIT (XCAR (ptr->car))
&& GC_MARKERP (XCAR (ptr->car)))
{
XMARK (XCAR (ptr->car));
mark_object (&XCDR (ptr->car));
XMARK (XCAR_AS_LVALUE (ptr->car));
mark_object (&XCDR_AS_LVALUE (ptr->car));
}
else
mark_object (&ptr->car);
@ -4812,7 +4815,7 @@ mark_buffer (buf)
break;
}
mark_object (&XCDR (tail));
mark_object (&XCDR_AS_LVALUE (tail));
}
else
mark_object (&buffer->undo_list);

30
src/buffer.c
View File

@ -1415,9 +1415,9 @@ record_buffer (buf)
if (NILP (prev))
Vbuffer_alist = XCDR (Vbuffer_alist);
else
XCDR (prev) = XCDR (XCDR (prev));
XSETCDR (prev, XCDR (XCDR (prev)));
XCDR (link) = Vbuffer_alist;
XSETCDR (link, Vbuffer_alist);
Vbuffer_alist = link;
/* Now move this buffer to the front of frame_buffer_list also. */
@ -1439,9 +1439,9 @@ record_buffer (buf)
set_frame_buffer_list (frame,
XCDR (frame_buffer_list (frame)));
else
XCDR (prev) = XCDR (XCDR (prev));
XSETCDR (prev, XCDR (XCDR (prev)));
XCDR (link) = frame_buffer_list (frame);
XSETCDR (link, frame_buffer_list (frame));
set_frame_buffer_list (frame, link);
}
else
@ -1863,7 +1863,7 @@ selected window if it is displayed there. */
aelt = Frassq (buffer, Vbuffer_alist);
link = Fmemq (aelt, Vbuffer_alist);
Vbuffer_alist = Fdelq (aelt, Vbuffer_alist);
XCDR (link) = Qnil;
XSETCDR (link, Qnil);
Vbuffer_alist = nconc2 (Vbuffer_alist, link);
frames_bury_buffer (buffer);
@ -2286,10 +2286,10 @@ swap_out_buffer_local_variables (b)
it is currently set up for. This is so that, if the
local is marked permanent, and we make it local again
later in Fkill_all_local_variables, we don't lose the value. */
XCDR (XCAR (tem))
= do_symval_forwarding (XBUFFER_LOCAL_VALUE (SYMBOL_VALUE (sym))->realvalue);
XSETCDR (XCAR (tem),
do_symval_forwarding (XBUFFER_LOCAL_VALUE (SYMBOL_VALUE (sym))->realvalue));
/* Switch to the symbol's default-value alist entry. */
XCAR (tem) = tem;
XSETCAR (tem, tem);
/* Mark it as current for buffer B. */
XBUFFER_LOCAL_VALUE (SYMBOL_VALUE (sym))->buffer = buffer;
/* Store the current value into any forwarding in the symbol. */
@ -3008,7 +3008,7 @@ recenter_overlay_lists (buf, pos)
/* Splice the cons cell TAIL out of overlays_before. */
if (!NILP (prev))
XCDR (prev) = next;
XSETCDR (prev, next);
else
buf->overlays_before = next;
@ -3030,9 +3030,9 @@ recenter_overlay_lists (buf, pos)
}
/* Add TAIL to overlays_after before OTHER. */
XCDR (tail) = other;
XSETCDR (tail, other);
if (!NILP (other_prev))
XCDR (other_prev) = tail;
XSETCDR (other_prev, tail);
else
buf->overlays_after = tail;
tail = prev;
@ -3085,7 +3085,7 @@ recenter_overlay_lists (buf, pos)
/* Splice the cons cell TAIL out of overlays_after. */
if (!NILP (prev))
XCDR (prev) = next;
XSETCDR (prev, next);
else
buf->overlays_after = next;
@ -3107,9 +3107,9 @@ recenter_overlay_lists (buf, pos)
}
/* Add TAIL to overlays_before before OTHER. */
XCDR (tail) = other;
XSETCDR (tail, other);
if (!NILP (other_prev))
XCDR (other_prev) = tail;
XSETCDR (other_prev, tail);
else
buf->overlays_before = tail;
tail = prev;
@ -3841,7 +3841,7 @@ DEFUN ("overlay-put", Foverlay_put, Soverlay_put, 3, 3, 0,
if (EQ (XCAR (tail), prop))
{
changed = !EQ (XCAR (XCDR (tail)), value);
XCAR (XCDR (tail)) = value;
XSETCAR (XCDR (tail), value);
goto found;
}
/* It wasn't in the list, so add it to the front. */

6
src/callint.c
View File

@ -156,7 +156,7 @@ quotify_args (exp)
for (tail = exp; CONSP (tail); tail = next)
{
next = XCDR (tail);
XCAR (tail) = quotify_arg (XCAR (tail));
XSETCAR (tail, quotify_arg (XCAR (tail)));
}
return exp;
}
@ -358,7 +358,7 @@ supply if the command inquires which events were used to invoke it.")
{
teml = Fnthcdr (Vhistory_length, Vcommand_history);
if (CONSP (teml))
XCDR (teml) = Qnil;
XSETCDR (teml, Qnil);
}
}
single_kboard_state ();
@ -776,7 +776,7 @@ supply if the command inquires which events were used to invoke it.")
{
teml = Fnthcdr (Vhistory_length, Vcommand_history);
if (CONSP (teml))
XCDR (teml) = Qnil;
XSETCDR (teml, Qnil);
}
}

2
src/ccl.c
View File

@ -2274,7 +2274,7 @@ Return index number of the registered map.")
if (EQ (symbol, XCAR (slot)))
{
index = make_number (i);
XCDR (slot) = map;
XSETCDR (slot, map);
Fput (symbol, Qcode_conversion_map, map);
Fput (symbol, Qcode_conversion_map_id, index);
return index;

2
src/coding.c
View File

@ -6212,7 +6212,7 @@ detect_coding_system (src, src_bytes, highest, multibytep)
Lisp_Object eol;
eol = Fget (XCAR (tmp), Qeol_type);
if (VECTORP (eol))
XCAR (tmp) = XVECTOR (eol)->contents[eol_type];
XSETCAR (tmp, XVECTOR (eol)->contents[eol_type]);
}
}
return (highest ? XCAR (val) : val);

10
src/composite.c
View File

@ -249,8 +249,8 @@ get_composition_id (charpos, bytepos, nchars, prop, string)
modify the cons cell of PROP because it is not shared. */
key = HASH_KEY (hash_table, hash_index);
id = HASH_VALUE (hash_table, hash_index);
XCAR (prop) = id;
XCDR (prop) = Fcons (make_number (nchars), Fcons (key, XCDR (prop)));
XSETCAR (prop, id);
XSETCDR (prop, Fcons (make_number (nchars), Fcons (key, XCDR (prop))));
return XINT (id);
}
@ -297,8 +297,8 @@ get_composition_id (charpos, bytepos, nchars, prop, string)
/* Change PROP from Form-A above to Form-B. We can directly modify
the cons cell of PROP because it is not shared. */
XSETFASTINT (id, n_compositions);
XCAR (prop) = id;
XCDR (prop) = Fcons (make_number (nchars), Fcons (key, XCDR (prop)));
XSETCAR (prop, id);
XSETCDR (prop, Fcons (make_number (nchars), Fcons (key, XCDR (prop))));
/* Register the composition in composition_hash_table. */
hash_index = hash_put (hash_table, key, id, hash_code);
@ -569,7 +569,7 @@ make_composition_value_copy (list)
{
if (EQ (XCAR (plist), Qcomposition)
&& (val = XCAR (XCDR (plist)), CONSP (val)))
XCAR (XCDR (plist)) = Fcons (XCAR (val), XCDR (val));
XSETCAR (XCDR (plist), Fcons (XCAR (val), XCDR (val)));
plist = XCDR (XCDR (plist));
}
}

22
src/data.c
View File

@ -582,7 +582,7 @@ DEFUN ("setcar", Fsetcar, Ssetcar, 2, 2, 0,
cell = wrong_type_argument (Qconsp, cell);
CHECK_IMPURE (cell);
XCAR (cell) = newcar;
XSETCAR (cell, newcar);
return newcar;
}
@ -595,7 +595,7 @@ DEFUN ("setcdr", Fsetcdr, Ssetcdr, 2, 2, 0,
cell = wrong_type_argument (Qconsp, cell);
CHECK_IMPURE (cell);
XCDR (cell) = newcdr;
XSETCDR (cell, newcdr);
return newcdr;
}
@ -937,7 +937,7 @@ swap_in_global_binding (symbol)
do_symval_forwarding (XBUFFER_LOCAL_VALUE (valcontents)->realvalue));
/* Select the global binding in the symbol. */
XCAR (cdr) = cdr;
XSETCAR (cdr, cdr);
store_symval_forwarding (symbol, valcontents, XCDR (cdr), NULL);
/* Indicate that the global binding is set up now. */
@ -991,7 +991,7 @@ swap_in_symval_forwarding (symbol, valcontents)
XBUFFER_LOCAL_VALUE (valcontents)->found_for_buffer = 1;
/* Load the new binding. */
XCAR (XBUFFER_LOCAL_VALUE (valcontents)->cdr) = tem1;
XSETCAR (XBUFFER_LOCAL_VALUE (valcontents)->cdr, tem1);
XSETBUFFER (XBUFFER_LOCAL_VALUE (valcontents)->buffer, current_buffer);
XBUFFER_LOCAL_VALUE (valcontents)->frame = selected_frame;
store_symval_forwarding (symbol,
@ -1210,8 +1210,8 @@ set_internal (symbol, newval, buf, bindflag)
}
/* Record which binding is now loaded. */
XCAR (XBUFFER_LOCAL_VALUE (valcontents)->cdr)
= tem1;
XSETCAR (XBUFFER_LOCAL_VALUE (valcontents)->cdr,
tem1);
/* Set `buffer' and `frame' slots for thebinding now loaded. */
XSETBUFFER (XBUFFER_LOCAL_VALUE (valcontents)->buffer, buf);
@ -1243,7 +1243,7 @@ set_internal (symbol, newval, buf, bindflag)
the default binding is loaded, the loaded binding may be the
wrong one. */
if (XBUFFER_LOCAL_VALUE (valcontents)->found_for_frame)
XCDR (current_alist_element) = newval;
XSETCDR (current_alist_element, newval);
}
return newval;
@ -1362,7 +1362,7 @@ for this variable.")
return Fset (symbol, value);
/* Store new value into the DEFAULT-VALUE slot. */
XCDR (XBUFFER_LOCAL_VALUE (valcontents)->cdr) = value;
XSETCDR (XBUFFER_LOCAL_VALUE (valcontents)->cdr, value);
/* If the default binding is now loaded, set the REALVALUE slot too. */
current_alist_element
@ -1448,7 +1448,7 @@ The function `default-value' gets the default value and `set-default' sets it.")
if (EQ (valcontents, Qunbound))
SET_SYMBOL_VALUE (variable, Qnil);
tem = Fcons (Qnil, Fsymbol_value (variable));
XCAR (tem) = tem;
XSETCAR (tem, tem);
newval = allocate_misc ();
XMISCTYPE (newval) = Lisp_Misc_Buffer_Local_Value;
XBUFFER_LOCAL_VALUE (newval)->realvalue = SYMBOL_VALUE (variable);
@ -1505,7 +1505,7 @@ Use `make-local-hook' instead.")
{
Lisp_Object newval;
tem = Fcons (Qnil, do_symval_forwarding (valcontents));
XCAR (tem) = tem;
XSETCAR (tem, tem);
newval = allocate_misc ();
XMISCTYPE (newval) = Lisp_Misc_Some_Buffer_Local_Value;
XBUFFER_LOCAL_VALUE (newval)->realvalue = SYMBOL_VALUE (variable);
@ -1644,7 +1644,7 @@ See `modify-frame-parameters'.")
if (EQ (valcontents, Qunbound))
SET_SYMBOL_VALUE (variable, Qnil);
tem = Fcons (Qnil, Fsymbol_value (variable));
XCAR (tem) = tem;
XSETCAR (tem, tem);
newval = allocate_misc ();
XMISCTYPE (newval) = Lisp_Misc_Some_Buffer_Local_Value;
XBUFFER_LOCAL_VALUE (newval)->realvalue = SYMBOL_VALUE (variable);

2
src/doc.c
View File

@ -445,7 +445,7 @@ store_function_docstring (fun, offset)
{
tem = Fcdr (Fcdr (fun));
if (CONSP (tem) && INTEGERP (XCAR (tem)))
XSETFASTINT (XCAR (tem), offset);
XSETCARFASTINT (tem, offset);
}
else if (EQ (tem, Qmacro))
store_function_docstring (XCDR (fun), offset);

6
src/fileio.c
View File

@ -5499,8 +5499,8 @@ A non-nil CURRENT-ONLY argument means save only current buffer.")
/* Arrange to close that file whether or not we get an error.
Also reset auto_saving to 0. */
lispstream = Fcons (Qnil, Qnil);
XSETFASTINT (XCAR (lispstream), (EMACS_UINT)stream >> 16);
XSETFASTINT (XCDR (lispstream), (EMACS_UINT)stream & 0xffff);
XSETCARFASTINT (lispstream, (EMACS_UINT)stream >> 16);
XSETCDRFASTINT (lispstream, (EMACS_UINT)stream & 0xffff);
}
else
lispstream = Qnil;
@ -5939,7 +5939,7 @@ provides a file dialog box..")
if (replace_in_history)
/* Replace what Fcompleting_read added to the history
with what we will actually return. */
XCAR (Fsymbol_value (Qfile_name_history)) = double_dollars (val);
XSETCAR (Fsymbol_value (Qfile_name_history), double_dollars (val));
else if (add_to_history)
{
/* Add the value to the history--but not if it matches

8
src/fns.c
View File

@ -782,7 +782,7 @@ concat (nargs, args, target_type, last_special)
/* Store this element into the result. */
if (toindex < 0)
{
XCAR (tail) = elt;
XSETCAR (tail, elt);
prev = tail;
tail = XCDR (tail);
}
@ -823,7 +823,7 @@ concat (nargs, args, target_type, last_special)
}
}
if (!NILP (prev))
XCDR (prev) = last_tail;
XSETCDR (prev, last_tail);
if (num_textprops > 0)
{
@ -1159,7 +1159,7 @@ Elements of ALIST that are not conses are also shared. */
car = XCAR (tem);
if (CONSP (car))
XCAR (tem) = Fcons (XCAR (car), XCDR (car));
XSETCAR (tem, Fcons (XCAR (car), XCDR (car)));
}
return alist;
}
@ -3153,7 +3153,7 @@ The value can later be retrieved with `widget-get'. */
Lisp_Object widget, property, value;
{
CHECK_CONS (widget, 1);
XCDR (widget) = Fplist_put (XCDR (widget), property, value);
XSETCDR (widget, Fplist_put (XCDR (widget), property, value));
return value;
}

16
src/fontset.c
View File

@ -994,8 +994,8 @@ name of a font, REGSITRY is a registry name of a font.")
{
/* CH should be (FROM . TO) where FROM and TO are non-generic
characters. */
CHECK_NUMBER (XCAR (character), 1);
CHECK_NUMBER (XCDR (character), 1);
CHECK_NUMBER_CAR (character, 1);
CHECK_NUMBER_CDR (character, 1);
from = XINT (XCAR (character));
to = XINT (XCDR (character));
if (!char_valid_p (from, 0) || !char_valid_p (to, 0))
@ -1214,7 +1214,7 @@ accumulate_font_info (arg, character, elt)
{
if (this_charset == CHAR_CHARSET (XINT (XCAR (last_char))))
{
XCDR (last_char) = character;
XSETCDR (last_char, character);
return;
}
}
@ -1222,12 +1222,12 @@ accumulate_font_info (arg, character, elt)
return;
else if (this_charset == CHAR_CHARSET (XINT (last_char)))
{
XCAR (XCAR (last)) = Fcons (last_char, character);
XSETCAR (XCAR (last), Fcons (last_char, character));
return;
}
}
XCDR (last) = Fcons (Fcons (character, Fcons (elt, Qnil)), Qnil);
XCAR (arg) = XCDR (last);
XSETCDR (last, Fcons (Fcons (character, Fcons (elt, Qnil)), Qnil));
XSETCAR (arg, XCDR (last));
}
@ -1306,7 +1306,7 @@ If FRAME is omitted, it defaults to the currently selected frame.")
c = XINT (XCAR (elt));
SPLIT_CHAR (c, charset, c1, c2);
if (c1 == 0)
XCAR (elt) = CHARSET_SYMBOL (charset);
XSETCAR (elt, CHARSET_SYMBOL (charset));
}
else
c = XINT (XCAR (XCAR (elt)));
@ -1323,7 +1323,7 @@ If FRAME is omitted, it defaults to the currently selected frame.")
{
font = build_string (face->font_name);
if (NILP (Fmember (font, XCDR (XCDR (elt)))))
XCDR (XCDR (elt)) = Fcons (font, XCDR (XCDR (elt)));
XSETCDR (XCDR (elt), Fcons (font, XCDR (XCDR (elt))));
}
}
}

2
src/frame.c
View File

@ -543,7 +543,7 @@ Note that changing the size of one terminal frame automatically affects all.")
the vectors which are the CDRs of associations in face_alist to
be copied as well. */
for (tem = f->face_alist; CONSP (tem); tem = XCDR (tem))
XCDR (XCAR (tem)) = Fcopy_sequence (XCDR (XCAR (tem)));
XSETCDR (XCAR (tem), Fcopy_sequence (XCDR (XCAR (tem))));
return frame;
}

12
src/indent.c
View File

@ -1755,18 +1755,18 @@ DEFUN ("compute-motion", Fcompute_motion, Scompute_motion, 7, 7, 0,
CHECK_NUMBER_COERCE_MARKER (from, 0);
CHECK_CONS (frompos, 0);
CHECK_NUMBER (XCAR (frompos), 0);
CHECK_NUMBER (XCDR (frompos), 0);
CHECK_NUMBER_CAR (frompos, 0);
CHECK_NUMBER_CDR (frompos, 0);
CHECK_NUMBER_COERCE_MARKER (to, 0);
CHECK_CONS (topos, 0);
CHECK_NUMBER (XCAR (topos), 0);
CHECK_NUMBER (XCDR (topos), 0);
CHECK_NUMBER_CAR (topos, 0);
CHECK_NUMBER_CDR (topos, 0);
CHECK_NUMBER (width, 0);
if (!NILP (offsets))
{
CHECK_CONS (offsets, 0);
CHECK_NUMBER (XCAR (offsets), 0);
CHECK_NUMBER (XCDR (offsets), 0);
CHECK_NUMBER_CAR (offsets, 0);
CHECK_NUMBER_CDR (offsets, 0);
hscroll = XINT (XCAR (offsets));
tab_offset = XINT (XCDR (offsets));
}

62
src/keyboard.c
View File

@ -2358,15 +2358,21 @@ read_char (commandflag, nmaps, maps, prev_event, used_mouse_menu)
KBOARD *kb = FRAME_KBOARD (XFRAME (selected_frame));
if (kb != current_kboard)
{
Lisp_Object *tailp = &kb->kbd_queue;
Lisp_Object link = kb->kbd_queue;
/* We shouldn't get here if we were in single-kboard mode! */
if (single_kboard)
abort ();
while (CONSP (*tailp))
tailp = &XCDR (*tailp);
if (!NILP (*tailp))
abort ();
*tailp = Fcons (c, Qnil);
if (CONSP (link))
{
while (CONSP (XCDR (link)))
link = XCDR (link);
if (!NILP (XCDR (link)))
abort ();
}
if (!CONSP (link))
kb->kbd_queue = Fcons (c, Qnil);
else
XSETCDR (link, Fcons (c, Qnil));
kb->kbd_queue_has_data = 1;
current_kboard = kb;
/* This is going to exit from read_char
@ -2581,12 +2587,18 @@ read_char (commandflag, nmaps, maps, prev_event, used_mouse_menu)
#ifdef MULTI_KBOARD
if (! NILP (c) && (kb != current_kboard))
{
Lisp_Object *tailp = &kb->kbd_queue;
while (CONSP (*tailp))
tailp = &XCDR (*tailp);
if (!NILP (*tailp))
abort ();
*tailp = Fcons (c, Qnil);
Lisp_Object link = kb->kbd_queue;
if (CONSP (link))
{
while (CONSP (XCDR (link)))
link = XCDR (link);
if (!NILP (XCDR (link)))
abort ();
}
if (!CONSP (link))
kb->kbd_queue = Fcons (c, Qnil);
else
XSETCDR (link, Fcons (c, Qnil));
kb->kbd_queue_has_data = 1;
c = Qnil;
if (single_kboard)
@ -2702,7 +2714,7 @@ read_char (commandflag, nmaps, maps, prev_event, used_mouse_menu)
if (EQ (posn, Qmenu_bar) || EQ (posn, Qtool_bar))
{
/* Change menu-bar to (menu-bar) as the event "position". */
POSN_BUFFER_POSN (EVENT_START (c)) = Fcons (posn, Qnil);
POSN_BUFFER_SET_POSN (EVENT_START (c), Fcons (posn, Qnil));
also_record = c;
Vunread_command_events = Fcons (c, Vunread_command_events);
@ -6854,19 +6866,19 @@ parse_menu_item (item, notreal, inmenubar)
{
/* We have to create a cachelist. */
CHECK_IMPURE (start);
XCDR (start) = Fcons (Fcons (Qnil, Qnil), XCDR (start));
XSETCDR (start, Fcons (Fcons (Qnil, Qnil), XCDR (start)));
cachelist = XCAR (XCDR (start));
newcache = 1;
tem = AREF (item_properties, ITEM_PROPERTY_KEYEQ);
if (!NILP (keyhint))
{
XCAR (cachelist) = XCAR (keyhint);
XSETCAR (cachelist, XCAR (keyhint));
newcache = 0;
}
else if (STRINGP (tem))
{
XCDR (cachelist) = Fsubstitute_command_keys (tem);
XCAR (cachelist) = Qt;
XSETCDR (cachelist, Fsubstitute_command_keys (tem));
XSETCAR (cachelist, Qt);
}
}
@ -6924,10 +6936,10 @@ parse_menu_item (item, notreal, inmenubar)
&& ! NILP (Fget (def, Qmenu_alias)))
def = XSYMBOL (def)->function;
tem = Fwhere_is_internal (def, Qnil, Qt, Qnil);
XCAR (cachelist) = tem;
XSETCAR (cachelist, tem);
if (NILP (tem))
{
XCDR (cachelist) = Qnil;
XSETCDR (cachelist, Qnil);
chkcache = 0;
}
}
@ -6948,7 +6960,7 @@ parse_menu_item (item, notreal, inmenubar)
if (STRINGP (XCDR (prefix)))
tem = concat2 (tem, XCDR (prefix));
}
XCDR (cachelist) = tem;
XSETCDR (cachelist, tem);
}
}
@ -6956,7 +6968,7 @@ parse_menu_item (item, notreal, inmenubar)
if (newcache && !NILP (tem))
{
tem = concat3 (build_string (" ("), tem, build_string (")"));
XCDR (cachelist) = tem;
XSETCDR (cachelist, tem);
}
/* If we only want to precompute equivalent key bindings, stop here. */
@ -7474,7 +7486,7 @@ read_char_x_menu_prompt (nmaps, maps, prev_event, used_mouse_menu)
record_menu_key (XCAR (tem));
if (SYMBOLP (XCAR (tem))
|| INTEGERP (XCAR (tem)))
XCAR (tem) = Fcons (XCAR (tem), Qdisabled);
XSETCAR (tem, Fcons (XCAR (tem), Qdisabled));
}
/* If we got more than one event, put all but the first
@ -8466,8 +8478,8 @@ read_key_sequence (keybuf, bufsize, prompt, dont_downcase_last,
/* Zap the position in key, so we know that we've
expanded it, and don't try to do so again. */
POSN_BUFFER_POSN (EVENT_START (key))
= Fcons (posn, Qnil);
POSN_BUFFER_SET_POSN (EVENT_START (key),
Fcons (posn, Qnil));
mock_input = t + 2;
goto replay_sequence;
@ -9203,7 +9215,7 @@ a special event, so ignore the prefix argument and don't clear it.")
{
tem = Fnthcdr (Vhistory_length, Vcommand_history);
if (CONSP (tem))
XCDR (tem) = Qnil;
XSETCDR (tem, Qnil);
}
}

1
src/keyboard.h
View File

@ -260,6 +260,7 @@ extern Lisp_Object item_properties;
/* Extract the fields of a position. */
#define POSN_WINDOW(posn) (XCAR (posn))
#define POSN_BUFFER_POSN(posn) (XCAR (XCDR (posn)))
#define POSN_BUFFER_SET_POSN(posn,x) (XSETCAR (XCDR (posn), (x)))
#define POSN_WINDOW_POSN(posn) (XCAR (XCDR (XCDR (posn))))
#define POSN_TIMESTAMP(posn) \
(XCAR (XCDR (XCDR (XCDR (posn)))))

46
src/keymap.c
View File

@ -363,7 +363,7 @@ PARENT should be nil or another keymap.")
if (EQ (XCDR (prev), parent))
RETURN_UNGCPRO (parent);
XCDR (prev) = parent;
XSETCDR (prev, parent);
break;
}
prev = list;
@ -769,7 +769,7 @@ store_in_keymap (keymap, idx, def)
{
if (EQ (idx, XCAR (elt)))
{
XCDR (elt) = def;
XSETCDR (elt, def);
return def;
}
}
@ -786,8 +786,8 @@ store_in_keymap (keymap, idx, def)
keymap_end:
/* We have scanned the entire keymap, and not found a binding for
IDX. Let's add one. */
XCDR (insertion_point)
= Fcons (Fcons (idx, def), XCDR (insertion_point));
XSETCDR (insertion_point,
Fcons (Fcons (idx, def), XCDR (insertion_point)));
}
return def;
@ -830,7 +830,7 @@ is not copied.")
Lisp_Object indices[3];
elt = Fcopy_sequence (elt);
XCAR (tail) = elt;
XSETCAR (tail, elt);
map_char_table (copy_keymap_1, Qnil, elt, elt, 0, indices);
}
@ -839,7 +839,7 @@ is not copied.")
int i;
elt = Fcopy_sequence (elt);
XCAR (tail) = elt;
XSETCAR (tail, elt);
for (i = 0; i < ASIZE (elt); i++)
if (CONSP (AREF (elt, i)) && EQ (XCAR (AREF (elt, i)), Qkeymap))
@ -854,15 +854,15 @@ is not copied.")
if (EQ (XCAR (tem),Qmenu_item))
{
/* Copy cell with menu-item marker. */
XCDR (elt)
= Fcons (XCAR (tem), XCDR (tem));
XSETCDR (elt,
Fcons (XCAR (tem), XCDR (tem)));
elt = XCDR (elt);
tem = XCDR (elt);
if (CONSP (tem))
{
/* Copy cell with menu-item name. */
XCDR (elt)
= Fcons (XCAR (tem), XCDR (tem));
XSETCDR (elt,
Fcons (XCAR (tem), XCDR (tem)));
elt = XCDR (elt);
tem = XCDR (elt);
};
@ -870,16 +870,16 @@ is not copied.")
{
/* Copy cell with binding and if the binding is a keymap,
copy that. */
XCDR (elt)
= Fcons (XCAR (tem), XCDR (tem));
XSETCDR (elt,
Fcons (XCAR (tem), XCDR (tem)));
elt = XCDR (elt);
tem = XCAR (elt);
if (CONSP (tem) && EQ (XCAR (tem), Qkeymap))
XCAR (elt) = Fcopy_keymap (tem);
XSETCAR (elt, Fcopy_keymap (tem));
tem = XCDR (elt);
if (CONSP (tem) && CONSP (XCAR (tem)))
/* Delete cache for key equivalences. */
XCDR (elt) = XCDR (tem);
XSETCDR (elt, XCDR (tem));
}
}
else
@ -890,15 +890,15 @@ is not copied.")
if (STRINGP (XCAR (tem)))
{
/* Copy the cell, since copy-alist didn't go this deep. */
XCDR (elt)
= Fcons (XCAR (tem), XCDR (tem));
XSETCDR (elt,
Fcons (XCAR (tem), XCDR (tem)));
elt = XCDR (elt);
tem = XCDR (elt);
/* Also skip the optional menu help string. */
if (CONSP (tem) && STRINGP (XCAR (tem)))
{
XCDR (elt)
= Fcons (XCAR (tem), XCDR (tem));
XSETCDR (elt,
Fcons (XCAR (tem), XCDR (tem)));
elt = XCDR (elt);
tem = XCDR (elt);
}
@ -908,12 +908,12 @@ is not copied.")
&& CONSP (XCAR (tem))
&& (NILP (XCAR (XCAR (tem)))
|| VECTORP (XCAR (XCAR (tem)))))
XCDR (elt) = XCDR (tem);
XSETCDR (elt, XCDR (tem));
}
if (CONSP (elt)
&& CONSP (XCDR (elt))
&& EQ (XCAR (XCDR (elt)), Qkeymap))
XCDR (elt) = Fcopy_keymap (XCDR (elt));
XSETCDR (elt, Fcopy_keymap (XCDR (elt)));
}
}
@ -1548,8 +1548,8 @@ accessible_keymaps_1 (key, cmd, maps, tail, thisseq, is_metized)
/* This new sequence is the same length as
thisseq, so stick it in the list right
after this one. */
XCDR (tail)
= Fcons (Fcons (tem, cmd), XCDR (tail));
XSETCDR (tail,
Fcons (Fcons (tem, cmd), XCDR (tail)));
}
else
{
@ -2396,7 +2396,7 @@ where_is_internal_2 (args, key, binding)
this, last, nomenus, last_is_meta);
if (!NILP (sequence))
XCDR (XCAR (args)) = Fcons (sequence, result);
XSETCDR (XCAR (args), Fcons (sequence, result));
UNGCPRO;
}

64
src/lisp.h
View File

@ -248,6 +248,16 @@ Lisp_Object;
#endif /* WORDS_BIG_ENDIAN */
#ifdef __GNUC__
static __inline__ Lisp_Object
LISP_MAKE_RVALUE (Lisp_Object o)
{
return o;
}
#else
#define LISP_MAKE_RVALUE(o) (o) /* XXX - keeps arg as rvalue. */
#endif
#endif /* NO_UNION_TYPE */
@ -255,6 +265,7 @@ Lisp_Object;
#ifdef NO_UNION_TYPE
#define Lisp_Object EMACS_INT
#define LISP_MAKE_RVALUE(o) (0+(o))
#endif /* NO_UNION_TYPE */
#ifndef VALMASK
@ -616,14 +627,43 @@ struct Lisp_Cons
};
/* Take the car or cdr of something known to be a cons cell. */
/* The _AS_LVALUE macros shouldn't be used outside of the minimal set
of code that has to know what a cons cell looks like. Other code not
part of the basic lisp implementation should assume that the car and cdr
fields are not accessible as lvalues. (What if we want to switch to
a copying collector someday? Cached cons cell field addresses may be
invalidated at arbitrary points.) */
#ifdef HIDE_LISP_IMPLEMENTATION
#define XCAR(c) (XCONS ((c))->car_)
#define XCDR(c) (XCONS ((c))->cdr_)
#define XCAR_AS_LVALUE(c) (XCONS ((c))->car_)
#define XCDR_AS_LVALUE(c) (XCONS ((c))->cdr_)
#else
#define XCAR(c) (XCONS ((c))->car)
#define XCDR(c) (XCONS ((c))->cdr)
#define XCAR_AS_LVALUE(c) (XCONS ((c))->car)
#define XCDR_AS_LVALUE(c) (XCONS ((c))->cdr)
#endif
/* Okay, we're not quite ready to turn this on yet. A few files still
need to be updated and tested. */
#undef LISP_MAKE_RVALUE
#define LISP_MAKE_RVALUE(x) (x)
/* Use these from normal code. */
#define XCAR(c) LISP_MAKE_RVALUE(XCAR_AS_LVALUE(c))
#define XCDR(c) LISP_MAKE_RVALUE(XCDR_AS_LVALUE(c))
/* Use these to set the fields of a cons cell.
Note that both arguments may refer to the same object, so 'n'
should not be read after 'c' is first modified. Also, neither
argument should be evaluated more than once; side effects are
especially common in the second argument. */
#define XSETCAR(c,n) (XCAR_AS_LVALUE(c) = (n))
#define XSETCDR(c,n) (XCDR_AS_LVALUE(c) = (n))
/* For performance: Fast storage of positive integers into the
fields of a cons cell. See above caveats. */
#define XSETCARFASTINT(c,n) XSETFASTINT(XCAR_AS_LVALUE(c),(n))
#define XSETCDRFASTINT(c,n) XSETFASTINT(XCDR_AS_LVALUE(c),(n))
/* Take the car or cdr of something whose type is not known. */
#define CAR(c) \
(CONSP ((c)) ? XCAR ((c)) \
@ -1474,6 +1514,22 @@ typedef unsigned char UCHAR;
#define CHECK_OVERLAY(x, i) \
do { if (!OVERLAYP ((x))) x = wrong_type_argument (Qoverlayp, (x));} while (0)
/* Since we can't assign directly to the CAR or CDR fields of a cons
cell, use these when checking that those fields contain numbers. */
#define CHECK_NUMBER_CAR(x, i) \
do { \
Lisp_Object tmp = XCAR (x); \
CHECK_NUMBER (tmp, (i)); \
XSETCAR ((x), tmp); \
} while (0)
#define CHECK_NUMBER_CDR(x, i) \
do { \
Lisp_Object tmp = XCDR (x); \
CHECK_NUMBER (tmp, (i)); \
XSETCDR ((x), tmp); \
} while (0)
/* Cast pointers to this type to compare them. Some machines want int. */
#ifndef PNTR_COMPARISON_TYPE
#define PNTR_COMPARISON_TYPE EMACS_UINT

25
src/lread.c
View File

@ -832,8 +832,8 @@ Return t if file exists.")
GCPRO1 (file);
lispstream = Fcons (Qnil, Qnil);
XSETFASTINT (XCAR (lispstream), (EMACS_UINT)stream >> 16);
XSETFASTINT (XCDR (lispstream), (EMACS_UINT)stream & 0xffff);
XSETCARFASTINT (lispstream, (EMACS_UINT)stream >> 16);
XSETCDRFASTINT (lispstream, (EMACS_UINT)stream & 0xffff);
record_unwind_protect (load_unwind, lispstream);
record_unwind_protect (load_descriptor_unwind, load_descriptor_list);
specbind (Qload_file_name, found);
@ -963,16 +963,19 @@ openp (path, str, suffixes, storeptr, exec_only)
Lisp_Object string, tail;
int max_suffix_len = 0;
for (tail = suffixes; CONSP (tail); tail = XCDR (tail))
{
CHECK_STRING (XCAR (tail), 0);
max_suffix_len = max (max_suffix_len,
STRING_BYTES (XSTRING (XCAR (tail))));
}
string = filename = Qnil;
GCPRO5 (str, string, filename, path, suffixes);
for (tail = suffixes; CONSP (tail); tail = XCDR (tail))
{
string = XCAR (tail);
CHECK_STRING (string, 0);
if (! EQ (string, XCAR (tail)))
XSETCAR (tail, string);
max_suffix_len = max (max_suffix_len,
STRING_BYTES (XSTRING (string)));
}
if (storeptr)
*storeptr = Qnil;
@ -2724,7 +2727,7 @@ read_list (flag, readcharfun)
{
GCPRO2 (val, tail);
if (!NILP (tail))
XCDR (tail) = read0 (readcharfun);
XSETCDR (tail, read0 (readcharfun));
else
val = read0 (readcharfun);
read1 (readcharfun, &ch, 0);
@ -2817,7 +2820,7 @@ read_list (flag, readcharfun)
? pure_cons (elt, Qnil)
: Fcons (elt, Qnil));
if (!NILP (tail))
XCDR (tail) = tem;
XSETCDR (tail, tem);
else
val = tem;
tail = tem;

2
src/minibuf.c
View File

@ -723,7 +723,7 @@ get_minibuffer (depth)
enabled in it. */
Fbuffer_enable_undo (buf);
XCAR (tail) = buf;
XSETCAR (tail, buf);
}
else
{

32
src/process.c
View File

@ -2367,7 +2367,9 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
int wait_channel = -1;
struct Lisp_Process *wait_proc = 0;
int got_some_input = 0;
Lisp_Object *wait_for_cell = 0;
/* Either nil or a cons cell, the car of which is of interest and
may be changed outside of this routine. */
Lisp_Object wait_for_cell = Qnil;
FD_ZERO (&Available);
@ -2383,7 +2385,7 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
/* If waiting for non-nil in a cell, record where. */
if (CONSP (read_kbd))
{
wait_for_cell = &XCAR (read_kbd);
wait_for_cell = read_kbd;
XSETFASTINT (read_kbd, 0);
}
@ -2417,7 +2419,7 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
QUIT;
/* Exit now if the cell we're waiting for became non-nil. */
if (wait_for_cell && ! NILP (*wait_for_cell))
if (! NILP (wait_for_cell) && ! NILP (XCAR (wait_for_cell)))
break;
/* Compute time from now till when time limit is up */
@ -2446,7 +2448,7 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
But not if wait_for_cell; in those cases,
the wait is supposed to be short,
and those callers cannot handle running arbitrary Lisp code here. */
if (! wait_for_cell)
if (NILP (wait_for_cell))
{
EMACS_TIME timer_delay;
@ -2567,7 +2569,7 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
/* Wait till there is something to do */
if (wait_for_cell)
if (!NILP (wait_for_cell))
Available = non_process_wait_mask;
else if (! XINT (read_kbd))
Available = non_keyboard_wait_mask;
@ -2723,7 +2725,7 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
}
/* Exit now if the cell we're waiting for became non-nil. */
if (wait_for_cell && ! NILP (*wait_for_cell))
if (! NILP (wait_for_cell) && ! NILP (XCAR (wait_for_cell)))
break;
#ifdef SIGIO
@ -2742,7 +2744,7 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
/* If checking input just got us a size-change event from X,
obey it now if we should. */
if (XINT (read_kbd) || wait_for_cell)
if (XINT (read_kbd) || ! NILP (wait_for_cell))
do_pending_window_change (0);
/* Check for data from a process. */
@ -4768,12 +4770,14 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
EMACS_TIME end_time, timeout;
SELECT_TYPE waitchannels;
int xerrno;
Lisp_Object *wait_for_cell = 0;
/* Either nil or a cons cell, the car of which is of interest and
may be changed outside of this routine. */
Lisp_Object wait_for_cell = Qnil;
/* If waiting for non-nil in a cell, record where. */
if (CONSP (read_kbd))
{
wait_for_cell = &XCAR (read_kbd);
wait_for_cell = read_kbd;
XSETFASTINT (read_kbd, 0);
}
@ -4800,7 +4804,7 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
QUIT;
/* Exit now if the cell we're waiting for became non-nil. */
if (wait_for_cell && ! NILP (*wait_for_cell))
if (! NILP (wait_for_cell) && ! NILP (XCAR (wait_for_cell)))
break;
/* Compute time from now till when time limit is up */
@ -4829,7 +4833,7 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
run timer events directly.
(Callers that will immediately read keyboard events
call timer_delay on their own.) */
if (! wait_for_cell)
if (NILP (wait_for_cell))
{
EMACS_TIME timer_delay;
@ -4870,7 +4874,7 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
/* Wait till there is something to do. */
if (! XINT (read_kbd) && wait_for_cell == 0)
if (! XINT (read_kbd) && NILP (wait_for_cell))
FD_ZERO (&waitchannels);
else
FD_SET (0, &waitchannels);
@ -4946,7 +4950,7 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
input at all when wait_for_cell, but the code
has been this way since July 1994.
Try changing this after version 19.31.) */
if (wait_for_cell
if (! NILP (wait_for_cell)
&& detect_input_pending ())
{
swallow_events (do_display);
@ -4955,7 +4959,7 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
}
/* Exit now if the cell we're waiting for became non-nil. */
if (wait_for_cell && ! NILP (*wait_for_cell))
if (! NILP (wait_for_cell) && ! NILP (XCAR (wait_for_cell)))
break;
}

6
src/search.c
View File

@ -2691,16 +2691,16 @@ to hold all the values, and if INTEGERS is non-nil, no consing is done.")
i++, tail = XCDR (tail))
{
if (i < 2 * len + 2)
XCAR (tail) = data[i];
XSETCAR (tail, data[i]);
else
XCAR (tail) = Qnil;
XSETCAR (tail, Qnil);
prev = tail;
}
/* If we couldn't fit all value elements into REUSE,
cons up the rest of them and add them to the end of REUSE. */
if (i < 2 * len + 2)
XCDR (prev) = Flist (2 * len + 2 - i, data + i);
XSETCDR (prev, Flist (2 * len + 2 - i, data + i));
return reuse;
}

2
src/textprop.c
View File

@ -1738,7 +1738,7 @@ extend_property_ranges (list, old_end, new_end)
end = XCAR (XCDR (item));
if (EQ (end, old_end))
XCAR (XCDR (item)) = new_end;
XSETCAR (XCDR (item), new_end);
}
}

6
src/undo.c
View File

@ -73,7 +73,7 @@ record_insert (beg, length)
&& INTEGERP (XCDR (elt))
&& XINT (XCDR (elt)) == beg)
{
XSETINT (XCDR (elt), beg + length);
XSETCDR (elt, make_number (beg + length));
return;
}
}
@ -273,7 +273,7 @@ but another undo command will undo to the previous boundary.")
{
/* If we have preallocated the cons cell to use here,
use that one. */
XCDR (pending_boundary) = current_buffer->undo_list;
XSETCDR (pending_boundary, current_buffer->undo_list);
current_buffer->undo_list = pending_boundary;
pending_boundary = Qnil;
}
@ -378,7 +378,7 @@ truncate_undo_list (list, minsize, maxsize)
/* Truncate at the boundary where we decided to truncate. */
if (!NILP (last_boundary))
{
XCDR (last_boundary) = Qnil;
XSETCDR (last_boundary, Qnil);
return list;
}
else

14
src/w32fns.c
View File

@ -3784,7 +3784,7 @@ w32_msg_pump (deferred_msg * msg_buf)
thread-safe. The next line is okay because the cons
cell is never made into garbage and is not relocated by
GC. */
XCAR ((Lisp_Object) msg.lParam) = Qnil;
XSETCAR ((Lisp_Object) msg.lParam, Qnil);
if (!PostThreadMessage (dwMainThreadId, WM_EMACS_DONE, 0, 0))
abort ();
break;
@ -6866,9 +6866,9 @@ w32_list_fonts (f, pattern, size, maxnames)
/* Make a list of the fonts we got back.
Store that in the font cache for the display. */
XCDR (dpyinfo->name_list_element)
= Fcons (Fcons (tpat, list),
XCDR (dpyinfo->name_list_element));
XSETCDR (dpyinfo->name_list_element,
Fcons (Fcons (tpat, list),
XCDR (dpyinfo->name_list_element)));
label_cached:
if (NILP (list)) continue; /* Try the remaining alternatives. */
@ -6915,9 +6915,9 @@ w32_list_fonts (f, pattern, size, maxnames)
hdc = GetDC (dpyinfo->root_window);
oldobj = SelectObject (hdc, thisinfo.hfont);
if (GetTextMetrics (hdc, &thisinfo.tm))
XCDR (tem) = make_number (FONT_WIDTH (&thisinfo));
XSETCDR (tem, make_number (FONT_WIDTH (&thisinfo)));
else
XCDR (tem) = make_number (0);
XSETCDR (tem, make_number (0));
SelectObject (hdc, oldobj);
ReleaseDC (dpyinfo->root_window, hdc);
DeleteObject(thisinfo.hfont);
@ -13240,7 +13240,7 @@ The return value is the hotkey-id if registered, otherwise nil.")
if (NILP (item))
w32_grabbed_keys = Fcons (key, w32_grabbed_keys);
else
XCAR (item) = key;
XSETCAR (item, key);
/* Notify input thread about new hot-key definition, so that it
takes effect without needing to switch focus. */

2
src/w32term.c
View File

@ -10286,7 +10286,7 @@ x_delete_display (dpyinfo)
{
if (EQ (XCAR (XCDR (tail)), dpyinfo->name_list_element))
{
XCDR (tail) = XCDR (XCDR (tail));
XSETCDR (tail, XCDR (XCDR (tail)));
break;
}
tail = XCDR (tail);

6
src/xfaces.c
View File

@ -2684,7 +2684,7 @@ remove_duplicates (list)
{
Lisp_Object next = XCDR (tail);
if (!NILP (Fequal (XCAR (next), XCAR (tail))))
XCDR (tail) = XCDR (next);
XSETCDR (tail, XCDR (next));
else
tail = XCDR (tail);
}
@ -4199,8 +4199,8 @@ FRAME 0 means change the face on all frames, and change the default
{
Lisp_Object cons;
cons = XCAR (Vparam_value_alist);
XCAR (cons) = param;
XCDR (cons) = value;
XSETCAR (cons, param);
XSETCDR (cons, value);
Fmodify_frame_parameters (frame, Vparam_value_alist);
}
}

20
src/xselect.c
View File

@ -338,7 +338,7 @@ x_own_selection (selection_name, selection_value)
for (rest = Vselection_alist; !NILP (rest); rest = Fcdr (rest))
if (EQ (prev_value, Fcar (XCDR (rest))))
{
XCDR (rest) = Fcdr (XCDR (rest));
XSETCDR (rest, Fcdr (XCDR (rest)));
break;
}
}
@ -905,7 +905,7 @@ x_handle_selection_clear (event)
for (rest = Vselection_alist; !NILP (rest); rest = Fcdr (rest))
if (EQ (local_selection_data, Fcar (XCDR (rest))))
{
XCDR (rest) = Fcdr (XCDR (rest));
XSETCDR (rest, Fcdr (XCDR (rest)));
break;
}
}
@ -982,7 +982,7 @@ x_clear_frame_selections (f)
redisplay_preserve_echo_area (22);
#endif
}
XCDR (rest) = Fcdr (XCDR (rest));
XSETCDR (rest, Fcdr (XCDR (rest)));
break;
}
}
@ -1076,13 +1076,13 @@ wait_for_property_change (location)
Lisp_Object tem;
tem = Fcons (Qnil, Qnil);
XSETFASTINT (XCAR (tem), (EMACS_UINT)location >> 16);
XSETFASTINT (XCDR (tem), (EMACS_UINT)location & 0xffff);
XSETCARFASTINT (tem, (EMACS_UINT)location >> 16);
XSETCDRFASTINT (tem, (EMACS_UINT)location & 0xffff);
/* Make sure to do unexpect_property_change if we quit or err. */
record_unwind_protect (wait_for_property_change_unwind, tem);
XCAR (property_change_reply) = Qnil;
XSETCAR (property_change_reply, Qnil);
property_change_reply_object = location;
/* If the event we are waiting for arrives beyond here, it will set
@ -1128,7 +1128,7 @@ x_handle_property_notify (event)
/* If this is the one wait_for_property_change is waiting for,
tell it to wake up. */
if (rest == property_change_reply_object)
XCAR (property_change_reply) = Qt;
XSETCAR (property_change_reply, Qt);
if (prev)
prev->next = rest->next;
@ -1239,7 +1239,7 @@ x_get_foreign_selection (selection_symbol, target_type)
/* Prepare to block until the reply has been read. */
reading_selection_window = requestor_window;
reading_which_selection = selection_atom;
XCAR (reading_selection_reply) = Qnil;
XSETCAR (reading_selection_reply, Qnil);
frame = some_frame_on_display (dpyinfo);
@ -1942,8 +1942,8 @@ x_handle_selection_notify (event)
return;
TRACE0 ("Received SelectionNotify");
XCAR (reading_selection_reply)
= (event->property != 0 ? Qt : Qlambda);
XSETCAR (reading_selection_reply,
(event->property != 0 ? Qt : Qlambda));
}

40
src/xterm.c
View File

@ -13714,8 +13714,8 @@ x_list_fonts (f, pattern, size, maxnames)
}
/* Now store the result in the cache. */
XCDR (dpyinfo->name_list_element)
= Fcons (Fcons (key, list), XCDR (dpyinfo->name_list_element));
XSETCDR (dpyinfo->name_list_element,
Fcons (Fcons (key, list), XCDR (dpyinfo->name_list_element)));
label_cached:
if (NILP (list)) continue; /* Try the remaining alternatives. */
@ -13758,10 +13758,10 @@ x_list_fonts (f, pattern, size, maxnames)
if (thisinfo)
{
XCDR (tem)
= (thisinfo->min_bounds.width == 0
? make_number (0)
: make_number (thisinfo->max_bounds.width));
XSETCDR (tem,
(thisinfo->min_bounds.width == 0
? make_number (0)
: make_number (thisinfo->max_bounds.width)));
BLOCK_INPUT;
XFreeFont (dpy, thisinfo);
UNBLOCK_INPUT;
@ -13770,7 +13770,7 @@ x_list_fonts (f, pattern, size, maxnames)
/* For unknown reason, the previous call of XListFont had
returned a font which can't be opened. Record the size
as 0 not to try to open it again. */
XCDR (tem) = make_number (0);
XSETCDR (tem, make_number (0));
}
found_size = XINT (XCDR (tem));
@ -14036,22 +14036,22 @@ x_load_font (f, fontname, size)
Lisp_Object key = Fcons (Fcons (lispy_name, make_number (256)),
Qnil);
XCDR (dpyinfo->name_list_element)
= Fcons (Fcons (key,
Fcons (Fcons (lispy_full_name,
make_number (fontp->size)),
Qnil)),
XCDR (dpyinfo->name_list_element));
XSETCDR (dpyinfo->name_list_element,
Fcons (Fcons (key,
Fcons (Fcons (lispy_full_name,
make_number (fontp->size)),
Qnil)),
XCDR (dpyinfo->name_list_element)));
if (full_name)
{
key = Fcons (Fcons (lispy_full_name, make_number (256)),
Qnil);
XCDR (dpyinfo->name_list_element)
= Fcons (Fcons (key,
Fcons (Fcons (lispy_full_name,
make_number (fontp->size)),
Qnil)),
XCDR (dpyinfo->name_list_element));
XSETCDR (dpyinfo->name_list_element,
Fcons (Fcons (key,
Fcons (Fcons (lispy_full_name,
make_number (fontp->size)),
Qnil)),
XCDR (dpyinfo->name_list_element)));
}
}
@ -14622,7 +14622,7 @@ x_delete_display (dpyinfo)
{
if (EQ (XCAR (XCDR (tail)), dpyinfo->name_list_element))
{
XCDR (tail) = XCDR (XCDR (tail));
XSETCDR (tail, XCDR (XCDR (tail)));
break;
}
tail = XCDR (tail);