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.

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  <[email protected]>
+
+	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  <[email protected]>
 
 	* 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.  */