From 663e2b3f88f9be61399e06dfc0b76700f90c6ca6 Mon Sep 17 00:00:00 2001 From: Dmitry Antipov Date: Sun, 5 Aug 2012 19:47:28 +0400 Subject: [PATCH] Generalize common compile-time constants. * lisp.h (header_size, bool_header_size, word_size): Now here. (struct Lisp_Vector): Add comment. (struct Lisp_Bool_Vector): Move up to define handy constants. (VECSIZE, PSEUDOVECSIZE): Simplify. (SAFE_ALLOCA_LISP): Use new constant. Adjust indentation. * buffer.c, buffer.h, bytecode.c, callint.c, eval.c, fns.c: * font.c, fontset.c, keyboard.c, keymap.c, macros.c, menu.c: * msdos.c, w32menu.c, w32term.h, window.c, xdisp.c, xfaces.c: * xfont.c, xmenu.c: Use word_size where appropriate. --- src/ChangeLog | 13 ++++++++ src/alloc.c | 14 ++------- src/buffer.c | 9 +++--- src/buffer.h | 2 +- src/bytecode.c | 2 +- src/callint.c | 2 +- src/eval.c | 4 +-- src/fns.c | 2 +- src/font.c | 2 +- src/fontset.c | 6 ++-- src/keyboard.c | 10 +++---- src/keymap.c | 2 +- src/lisp.h | 80 +++++++++++++++++++++++++++++--------------------- src/macros.c | 4 +-- src/menu.c | 2 +- src/msdos.c | 8 ++--- src/w32menu.c | 8 ++--- src/w32term.h | 2 +- src/window.c | 2 +- src/xdisp.c | 2 +- src/xfaces.c | 4 +-- src/xfont.c | 4 +-- src/xmenu.c | 2 +- 23 files changed, 101 insertions(+), 85 deletions(-) diff --git a/src/ChangeLog b/src/ChangeLog index d760dd1df7..55433577ce 100644 --- a/src/ChangeLog +++ b/src/ChangeLog @@ -1,3 +1,16 @@ +2012-08-05 Dmitry Antipov + + Generalize common compile-time constants. + * lisp.h (header_size, bool_header_size, word_size): Now here. + (struct Lisp_Vector): Add comment. + (struct Lisp_Bool_Vector): Move up to define handy constants. + (VECSIZE, PSEUDOVECSIZE): Simplify. + (SAFE_ALLOCA_LISP): Use new constant. Adjust indentation. + * buffer.c, buffer.h, bytecode.c, callint.c, eval.c, fns.c: + * font.c, fontset.c, keyboard.c, keymap.c, macros.c, menu.c: + * msdos.c, w32menu.c, w32term.h, window.c, xdisp.c, xfaces.c: + * xfont.c, xmenu.c: Use word_size where appropriate. + 2012-08-05 Lawrence Mitchell * search.c (Freplace_match): Treat \? in the replacement text diff --git a/src/alloc.c b/src/alloc.c index 3939e70497..7d1ff7625f 100644 --- a/src/alloc.c +++ b/src/alloc.c @@ -155,7 +155,7 @@ static pthread_mutex_t alloc_mutex; /* Default value of gc_cons_threshold (see below). */ -#define GC_DEFAULT_THRESHOLD (100000 * sizeof (Lisp_Object)) +#define GC_DEFAULT_THRESHOLD (100000 * word_size) /* Global variables. */ struct emacs_globals globals; @@ -278,14 +278,6 @@ static void sweep_strings (void); static void free_misc (Lisp_Object); extern Lisp_Object which_symbols (Lisp_Object, EMACS_INT) EXTERNALLY_VISIBLE; -/* Handy constants for vectorlike objects. */ -enum - { - header_size = offsetof (struct Lisp_Vector, contents), - bool_header_size = offsetof (struct Lisp_Bool_Vector, data), - word_size = sizeof (Lisp_Object) - }; - /* When scanning the C stack for live Lisp objects, Emacs keeps track of what memory allocated via lisp_malloc is intended for what purpose. This enumeration specifies the type of memory. */ @@ -2810,9 +2802,9 @@ listn (enum constype type, ptrdiff_t count, Lisp_Object arg, ...) Lisp_Object val, *objp; /* Change to SAFE_ALLOCA if you hit this eassert. */ - eassert (count <= MAX_ALLOCA / sizeof (Lisp_Object)); + eassert (count <= MAX_ALLOCA / word_size); - objp = alloca (count * sizeof (Lisp_Object)); + objp = alloca (count * word_size); objp[0] = arg; va_start (ap, arg); for (i = 1; i < count; i++) diff --git a/src/buffer.c b/src/buffer.c index a8af8a84f7..37e520f9f5 100644 --- a/src/buffer.c +++ b/src/buffer.c @@ -99,7 +99,7 @@ static Lisp_Object Vbuffer_local_symbols; /* Maximum length of an overlay vector. */ #define OVERLAY_COUNT_MAX \ ((ptrdiff_t) min (MOST_POSITIVE_FIXNUM, \ - min (PTRDIFF_MAX, SIZE_MAX) / sizeof (Lisp_Object))) + min (PTRDIFF_MAX, SIZE_MAX) / word_size)) /* Flags indicating which built-in buffer-local variables are permanent locals. */ @@ -4267,7 +4267,7 @@ report_overlay_modification (Lisp_Object start, Lisp_Object end, int after, ptrdiff_t i; memcpy (copy, XVECTOR (last_overlay_modification_hooks)->contents, - size * sizeof (Lisp_Object)); + size * word_size); gcpro1.var = copy; gcpro1.nvars = size; @@ -4886,8 +4886,7 @@ init_buffer_once (void) sure that this is still correct. Otherwise, mark_vectorlike may not trace all Lisp_Objects in buffer_defaults and buffer_local_symbols. */ const int pvecsize - = (offsetof (struct buffer, own_text) - sizeof (struct vectorlike_header)) - / sizeof (Lisp_Object); + = (offsetof (struct buffer, own_text) - header_size) / word_size; memset (buffer_permanent_local_flags, 0, sizeof buffer_permanent_local_flags); @@ -4972,7 +4971,7 @@ init_buffer_once (void) The local flag bits are in the local_var_flags slot of the buffer. */ /* Nothing can work if this isn't true */ - { verify (sizeof (EMACS_INT) == sizeof (Lisp_Object)); } + { verify (sizeof (EMACS_INT) == word_size); } /* 0 means not a lisp var, -1 means always local, else mask */ memset (&buffer_local_flags, 0, sizeof buffer_local_flags); diff --git a/src/buffer.h b/src/buffer.h index b13aab8443..9ca714b670 100644 --- a/src/buffer.h +++ b/src/buffer.h @@ -1029,7 +1029,7 @@ extern int last_per_buffer_idx; #define FOR_EACH_PER_BUFFER_OBJECT_AT(offset) \ for (offset = PER_BUFFER_VAR_OFFSET (name); \ offset <= PER_BUFFER_VAR_OFFSET (cursor_in_non_selected_windows); \ - offset += sizeof (Lisp_Object)) + offset += word_size) /* Return the index of buffer-local variable VAR. Each per-buffer variable has an index > 0 associated with it, except when it always diff --git a/src/bytecode.c b/src/bytecode.c index 523d56bc97..49369de33e 100644 --- a/src/bytecode.c +++ b/src/bytecode.c @@ -536,7 +536,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth, stack.byte_string = bytestr; stack.pc = stack.byte_string_start = SDATA (bytestr); stack.constants = vector; - if (MAX_ALLOCA / sizeof (Lisp_Object) <= XFASTINT (maxdepth)) + if (MAX_ALLOCA / word_size <= XFASTINT (maxdepth)) memory_full (SIZE_MAX); top = alloca ((XFASTINT (maxdepth) + 1) * sizeof *top); #if BYTE_MAINTAIN_TOP diff --git a/src/callint.c b/src/callint.c index 4b53b5df34..51d0a5fa2e 100644 --- a/src/callint.c +++ b/src/callint.c @@ -465,7 +465,7 @@ invoke it. If KEYS is omitted or nil, the return value of } if (min (MOST_POSITIVE_FIXNUM, - min (PTRDIFF_MAX, SIZE_MAX) / sizeof (Lisp_Object)) + min (PTRDIFF_MAX, SIZE_MAX) / word_size) < nargs) memory_full (SIZE_MAX); diff --git a/src/eval.c b/src/eval.c index 64f384f2ca..5eb144eb0b 100644 --- a/src/eval.c +++ b/src/eval.c @@ -2301,7 +2301,7 @@ usage: (apply FUNCTION &rest ARGUMENTS) */) gcpro1.nvars = 1 + numargs; } - memcpy (funcall_args, args, nargs * sizeof (Lisp_Object)); + memcpy (funcall_args, args, nargs * word_size); /* Spread the last arg we got. Its first element goes in the slot that it used to occupy, hence this value of I. */ i = nargs - 1; @@ -2794,7 +2794,7 @@ usage: (funcall FUNCTION &rest ARGUMENTS) */) { internal_args = alloca (XSUBR (fun)->max_args * sizeof *internal_args); - memcpy (internal_args, args + 1, numargs * sizeof (Lisp_Object)); + memcpy (internal_args, args + 1, numargs * word_size); for (i = numargs; i < XSUBR (fun)->max_args; i++) internal_args[i] = Qnil; } diff --git a/src/fns.c b/src/fns.c index 3f988699a2..739ffcaea2 100644 --- a/src/fns.c +++ b/src/fns.c @@ -3569,7 +3569,7 @@ hashfn_user_defined (struct Lisp_Hash_Table *h, Lisp_Object key) /* An upper bound on the size of a hash table index. It must fit in ptrdiff_t and be a valid Emacs fixnum. */ #define INDEX_SIZE_BOUND \ - ((ptrdiff_t) min (MOST_POSITIVE_FIXNUM, PTRDIFF_MAX / sizeof (Lisp_Object))) + ((ptrdiff_t) min (MOST_POSITIVE_FIXNUM, PTRDIFF_MAX / word_size)) /* Create and initialize a new hash table. diff --git a/src/font.c b/src/font.c index c70c2abdc2..ca0ccc171e 100644 --- a/src/font.c +++ b/src/font.c @@ -2138,7 +2138,7 @@ static Lisp_Object font_vconcat_entity_vectors (Lisp_Object list) { int nargs = XINT (Flength (list)); - Lisp_Object *args = alloca (sizeof (Lisp_Object) * nargs); + Lisp_Object *args = alloca (word_size * nargs); int i; for (i = 0; i < nargs; i++, list = XCDR (list)) diff --git a/src/fontset.c b/src/fontset.c index 858a2e3cd3..7ea1deeaec 100644 --- a/src/fontset.c +++ b/src/fontset.c @@ -429,7 +429,7 @@ reorder_font_vector (Lisp_Object font_group, struct font *font) } if (score_changed) - qsort (XVECTOR (vec)->contents, size, sizeof (Lisp_Object), + qsort (XVECTOR (vec)->contents, size, word_size, fontset_compare_rfontdef); XSETCAR (font_group, make_number (charset_ordered_list_tick)); } @@ -1893,7 +1893,7 @@ format is the same as above. */) /* Recode fontsets realized on FRAME from the base fontset FONTSET in the table `realized'. */ - realized[0] = alloca (sizeof (Lisp_Object) * ASIZE (Vfontset_table)); + realized[0] = alloca (word_size * ASIZE (Vfontset_table)); for (i = j = 0; i < ASIZE (Vfontset_table); i++) { elt = FONTSET_FROM_ID (i); @@ -1904,7 +1904,7 @@ format is the same as above. */) } realized[0][j] = Qnil; - realized[1] = alloca (sizeof (Lisp_Object) * ASIZE (Vfontset_table)); + realized[1] = alloca (word_size * ASIZE (Vfontset_table)); for (i = j = 0; ! NILP (realized[0][i]); i++) { elt = FONTSET_DEFAULT (realized[0][i]); diff --git a/src/keyboard.c b/src/keyboard.c index 39112479eb..de77f7cf33 100644 --- a/src/keyboard.c +++ b/src/keyboard.c @@ -7527,7 +7527,7 @@ menu_bar_items (Lisp_Object old) if (end > i + 4) memmove (aref_addr (menu_bar_items_vector, i), aref_addr (menu_bar_items_vector, i + 4), - (end - i - 4) * sizeof (Lisp_Object)); + (end - i - 4) * word_size); ASET (menu_bar_items_vector, end - 4, tem0); ASET (menu_bar_items_vector, end - 3, tem1); ASET (menu_bar_items_vector, end - 2, tem2); @@ -7577,7 +7577,7 @@ menu_bar_item (Lisp_Object key, Lisp_Object item, Lisp_Object dummy1, void *dumm if (menu_bar_items_index > i + 4) memmove (aref_addr (menu_bar_items_vector, i), aref_addr (menu_bar_items_vector, i + 4), - (menu_bar_items_index - i - 4) * sizeof (Lisp_Object)); + (menu_bar_items_index - i - 4) * word_size); menu_bar_items_index -= 4; } } @@ -8082,7 +8082,7 @@ process_tool_bar_item (Lisp_Object key, Lisp_Object def, Lisp_Object data, void if (ntool_bar_items > i + TOOL_BAR_ITEM_NSLOTS) memmove (v, v + TOOL_BAR_ITEM_NSLOTS, ((ntool_bar_items - i - TOOL_BAR_ITEM_NSLOTS) - * sizeof (Lisp_Object))); + * word_size)); ntool_bar_items -= TOOL_BAR_ITEM_NSLOTS; break; } @@ -10425,9 +10425,9 @@ DEFUN ("recent-keys", Frecent_keys, Srecent_keys, 0, 0, 0, { val = Fvector (NUM_RECENT_KEYS, keys); memcpy (XVECTOR (val)->contents, keys + recent_keys_index, - (NUM_RECENT_KEYS - recent_keys_index) * sizeof (Lisp_Object)); + (NUM_RECENT_KEYS - recent_keys_index) * word_size); memcpy (XVECTOR (val)->contents + NUM_RECENT_KEYS - recent_keys_index, - keys, recent_keys_index * sizeof (Lisp_Object)); + keys, recent_keys_index * word_size); return val; } } diff --git a/src/keymap.c b/src/keymap.c index ed65a5f3d8..bd2f3c99c2 100644 --- a/src/keymap.c +++ b/src/keymap.c @@ -2069,7 +2069,7 @@ The `kbd' macro is an approximate inverse of this. */) size += XINT (Flength (prefix)); /* This has one extra element at the end that we don't pass to Fconcat. */ - if (min (PTRDIFF_MAX, SIZE_MAX) / sizeof (Lisp_Object) / 4 < size) + if (min (PTRDIFF_MAX, SIZE_MAX) / word_size / 4 < size) memory_full (SIZE_MAX); SAFE_ALLOCA_LISP (args, size * 4); diff --git a/src/lisp.h b/src/lisp.h index dda6797df8..8a6a2a9979 100644 --- a/src/lisp.h +++ b/src/lisp.h @@ -824,25 +824,49 @@ struct vectorlike_header } next; }; +/* Regular vector is just a header plus array of Lisp_Objects. */ + struct Lisp_Vector { struct vectorlike_header header; Lisp_Object contents[1]; }; +/* A boolvector is a kind of vectorlike, with contents are like a string. */ + +struct Lisp_Bool_Vector + { + /* HEADER.SIZE is the vector's size field. It doesn't have the real size, + just the subtype information. */ + struct vectorlike_header header; + /* This is the size in bits. */ + EMACS_INT size; + /* This contains the actual bits, packed into bytes. */ + unsigned char data[1]; + }; + +/* Some handy constants for calculating sizes + and offsets, mostly of vectorlike objects. */ + +enum + { + header_size = offsetof (struct Lisp_Vector, contents), + bool_header_size = offsetof (struct Lisp_Bool_Vector, data), + word_size = sizeof (Lisp_Object) + }; + /* If a struct is made to look like a vector, this macro returns the length of the shortest vector that would hold that struct. */ -#define VECSIZE(type) ((sizeof (type) \ - - offsetof (struct Lisp_Vector, contents[0]) \ - + sizeof (Lisp_Object) - 1) /* Round up. */ \ - / sizeof (Lisp_Object)) + +#define VECSIZE(type) \ + ((sizeof (type) - header_size + word_size - 1) / word_size) /* Like VECSIZE, but used when the pseudo-vector has non-Lisp_Object fields at the end and we need to compute the number of Lisp_Object fields (the ones that the GC needs to trace). */ -#define PSEUDOVECSIZE(type, nonlispfield) \ - ((offsetof (type, nonlispfield) - offsetof (struct Lisp_Vector, contents[0])) \ - / sizeof (Lisp_Object)) + +#define PSEUDOVECSIZE(type, nonlispfield) \ + ((offsetof (type, nonlispfield) - header_size) / word_size) /* A char-table is a kind of vectorlike, with contents are like a vector but with a few other slots. For some purposes, it makes @@ -978,18 +1002,6 @@ struct Lisp_Sub_Char_Table Lisp_Object contents[1]; }; -/* A boolvector is a kind of vectorlike, with contents are like a string. */ -struct Lisp_Bool_Vector - { - /* HEADER.SIZE is the vector's size field. It doesn't have the real size, - just the subtype information. */ - struct vectorlike_header header; - /* This is the size in bits. */ - EMACS_INT size; - /* This contains the actual bits, packed into bytes. */ - unsigned char data[1]; - }; - /* This structure describes a built-in function. It is generated by the DEFUN macro only. defsubr makes it into a Lisp object. @@ -3483,21 +3495,21 @@ extern void *record_xmalloc (size_t); /* SAFE_ALLOCA_LISP allocates an array of Lisp_Objects. */ -#define SAFE_ALLOCA_LISP(buf, nelt) \ - do { \ - if ((nelt) < MAX_ALLOCA / sizeof (Lisp_Object)) \ - buf = alloca ((nelt) * sizeof (Lisp_Object)); \ - else if ((nelt) < min (PTRDIFF_MAX, SIZE_MAX) / sizeof (Lisp_Object)) \ - { \ - Lisp_Object arg_; \ - buf = xmalloc ((nelt) * sizeof (Lisp_Object)); \ - arg_ = make_save_value (buf, nelt); \ - XSAVE_VALUE (arg_)->dogc = 1; \ - sa_must_free = 1; \ - record_unwind_protect (safe_alloca_unwind, arg_); \ - } \ - else \ - memory_full (SIZE_MAX); \ +#define SAFE_ALLOCA_LISP(buf, nelt) \ + do { \ + if ((nelt) < MAX_ALLOCA / word_size) \ + buf = alloca ((nelt) * word_size); \ + else if ((nelt) < min (PTRDIFF_MAX, SIZE_MAX) / word_size) \ + { \ + Lisp_Object arg_; \ + buf = xmalloc ((nelt) * word_size); \ + arg_ = make_save_value (buf, nelt); \ + XSAVE_VALUE (arg_)->dogc = 1; \ + sa_must_free = 1; \ + record_unwind_protect (safe_alloca_unwind, arg_); \ + } \ + else \ + memory_full (SIZE_MAX); \ } while (0) diff --git a/src/macros.c b/src/macros.c index a07d8ddbd2..8a4361fc1f 100644 --- a/src/macros.c +++ b/src/macros.c @@ -63,7 +63,7 @@ macro before appending to it. */) if (!current_kboard->kbd_macro_buffer) { - current_kboard->kbd_macro_buffer = xmalloc (30 * sizeof (Lisp_Object)); + current_kboard->kbd_macro_buffer = xmalloc (30 * word_size); current_kboard->kbd_macro_bufsize = 30; } update_mode_lines++; @@ -73,7 +73,7 @@ macro before appending to it. */) { current_kboard->kbd_macro_buffer = xrealloc (current_kboard->kbd_macro_buffer, - 30 * sizeof (Lisp_Object)); + 30 * word_size); current_kboard->kbd_macro_bufsize = 30; } current_kboard->kbd_macro_ptr = current_kboard->kbd_macro_buffer; diff --git a/src/menu.c b/src/menu.c index eaf05ff3cb..3e466b46aa 100644 --- a/src/menu.c +++ b/src/menu.c @@ -976,7 +976,7 @@ find_and_return_menu_selection (FRAME_PTR f, int keymaps, void *client_data) prefix = entry = Qnil; i = 0; - subprefix_stack = alloca (menu_items_used * sizeof (Lisp_Object)); + subprefix_stack = alloca (menu_items_used * word_size); while (i < menu_items_used) { diff --git a/src/msdos.c b/src/msdos.c index 481526d935..93af0d6e26 100644 --- a/src/msdos.c +++ b/src/msdos.c @@ -1594,9 +1594,9 @@ IT_set_frame_parameters (struct frame *f, Lisp_Object alist) Lisp_Object tail; int i, j, length = XINT (Flength (alist)); Lisp_Object *parms - = (Lisp_Object *) alloca (length * sizeof (Lisp_Object)); + = (Lisp_Object *) alloca (length * word_size); Lisp_Object *values - = (Lisp_Object *) alloca (length * sizeof (Lisp_Object)); + = (Lisp_Object *) alloca (length * word_size); /* Do we have to reverse the foreground and background colors? */ int reverse = EQ (Fcdr (Fassq (Qreverse, FVAR (f, param_alist))), Qt); int redraw = 0, fg_set = 0, bg_set = 0; @@ -2435,9 +2435,9 @@ and then the scan code. */) { val = Fvector (NUM_RECENT_DOSKEYS, keys); memcpy (XVECTOR (val)->contents, keys + recent_doskeys_index, - (NUM_RECENT_DOSKEYS - recent_doskeys_index) * sizeof (Lisp_Object)); + (NUM_RECENT_DOSKEYS - recent_doskeys_index) * word_size); memcpy (XVECTOR (val)->contents + NUM_RECENT_DOSKEYS - recent_doskeys_index, - keys, recent_doskeys_index * sizeof (Lisp_Object)); + keys, recent_doskeys_index * word_size); return val; } } diff --git a/src/w32menu.c b/src/w32menu.c index 67bd575258..f6b7e62049 100644 --- a/src/w32menu.c +++ b/src/w32menu.c @@ -276,7 +276,7 @@ menubar_selection_callback (FRAME_PTR f, void * client_data) if (!f) return; entry = Qnil; - subprefix_stack = (Lisp_Object *) alloca (f->menu_bar_items_used * sizeof (Lisp_Object)); + subprefix_stack = (Lisp_Object *) alloca (f->menu_bar_items_used * word_size); vector = FVAR (f, menu_bar_vector); prefix = Qnil; i = 0; @@ -387,7 +387,7 @@ set_frame_menubar (FRAME_PTR f, int first_time, int deep_p) int previous_menu_items_used = f->menu_bar_items_used; Lisp_Object *previous_items = (Lisp_Object *) alloca (previous_menu_items_used - * sizeof (Lisp_Object)); + * word_size); /* If we are making a new widget, its contents are empty, do always reinitialize them. */ @@ -420,7 +420,7 @@ set_frame_menubar (FRAME_PTR f, int first_time, int deep_p) /* Save the frame's previous menu bar contents data. */ if (previous_menu_items_used) memcpy (previous_items, XVECTOR (FVAR (f, menu_bar_vector))->contents, - previous_menu_items_used * sizeof (Lisp_Object)); + previous_menu_items_used * word_size); /* Fill in menu_items with the current menu bar contents. This can evaluate Lisp code. */ @@ -665,7 +665,7 @@ w32_menu_show (FRAME_PTR f, int x, int y, int for_click, int keymaps, widget_value **submenu_stack = (widget_value **) alloca (menu_items_used * sizeof (widget_value *)); Lisp_Object *subprefix_stack - = (Lisp_Object *) alloca (menu_items_used * sizeof (Lisp_Object)); + = (Lisp_Object *) alloca (menu_items_used * word_size); int submenu_depth = 0; int first_pane; diff --git a/src/w32term.h b/src/w32term.h index c0a958ba5e..ccbf3c42c0 100644 --- a/src/w32term.h +++ b/src/w32term.h @@ -429,7 +429,7 @@ struct scroll_bar { #define SCROLL_BAR_VEC_SIZE \ ((sizeof (struct scroll_bar) \ - sizeof (EMACS_INT) - sizeof (struct Lisp_Vector *)) \ - / sizeof (Lisp_Object)) + / word_size) /* Turning a lisp vector value into a pointer to a struct scroll_bar. */ #define XSCROLL_BAR(vec) ((struct scroll_bar *) XVECTOR (vec)) diff --git a/src/window.c b/src/window.c index beabc28cf6..f4f6e3c2ee 100644 --- a/src/window.c +++ b/src/window.c @@ -3263,7 +3263,7 @@ make_parent_window (Lisp_Object window, int horflag) p = allocate_window (); memcpy ((char *) p + sizeof (struct vectorlike_header), (char *) o + sizeof (struct vectorlike_header), - sizeof (Lisp_Object) * VECSIZE (struct window)); + word_size * VECSIZE (struct window)); XSETWINDOW (parent, p); p->sequence_number = ++sequence_number; diff --git a/src/xdisp.c b/src/xdisp.c index 2af15acbe6..300e16bb4a 100644 --- a/src/xdisp.c +++ b/src/xdisp.c @@ -2420,7 +2420,7 @@ safe_call (ptrdiff_t nargs, Lisp_Object func, ...) ptrdiff_t i; ptrdiff_t count = SPECPDL_INDEX (); struct gcpro gcpro1; - Lisp_Object *args = alloca (nargs * sizeof (Lisp_Object)); + Lisp_Object *args = alloca (nargs * word_size); args[0] = func; va_start (ap, func); diff --git a/src/xfaces.c b/src/xfaces.c index df6cf6a368..6aab7edd5f 100644 --- a/src/xfaces.c +++ b/src/xfaces.c @@ -1657,7 +1657,7 @@ the face font sort order. */) vec = Fvconcat (ndrivers, drivers); nfonts = ASIZE (vec); - qsort (XVECTOR (vec)->contents, nfonts, sizeof (Lisp_Object), + qsort (XVECTOR (vec)->contents, nfonts, word_size, compare_fonts_by_sort_order); result = Qnil; @@ -2768,7 +2768,7 @@ The value is TO. */) } memcpy (XVECTOR (copy)->contents, XVECTOR (lface)->contents, - LFACE_VECTOR_SIZE * sizeof (Lisp_Object)); + LFACE_VECTOR_SIZE * word_size); /* Changing a named face means that all realized faces depending on that face are invalid. Since we cannot tell which realized faces diff --git a/src/xfont.c b/src/xfont.c index 1ebac6100f..e3e2eb18c2 100644 --- a/src/xfont.c +++ b/src/xfont.c @@ -464,11 +464,11 @@ xfont_list_pattern (Display *display, const char *pattern, continue; } if (memcmp (props, aref_addr (entity, FONT_FOUNDRY_INDEX), - sizeof (Lisp_Object) * 7) + word_size * 7) || ! EQ (AREF (entity, FONT_SPACING_INDEX), props[7])) { memcpy (props, aref_addr (entity, FONT_FOUNDRY_INDEX), - sizeof (Lisp_Object) * 7); + word_size * 7); props[7] = AREF (entity, FONT_SPACING_INDEX); scripts = xfont_supported_scripts (display, indices[i], xfont_scratch_props, encoding); diff --git a/src/xmenu.c b/src/xmenu.c index e7ed9d6962..eff4bb1ccd 100644 --- a/src/xmenu.c +++ b/src/xmenu.c @@ -1015,7 +1015,7 @@ set_frame_menubar (FRAME_PTR f, int first_time, int deep_p) /* Save the frame's previous menu bar contents data. */ if (previous_menu_items_used) memcpy (previous_items, XVECTOR (FVAR (f, menu_bar_vector))->contents, - previous_menu_items_used * sizeof (Lisp_Object)); + previous_menu_items_used * word_size); /* Fill in menu_items with the current menu bar contents. This can evaluate Lisp code. */ -- 2.20.1