upstream

72 files changed, 3062 insertions, 1594 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index 6e49dd44fde..1956d602e6a 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,312 @@
+2012-08-18  Paul Eggert  <eggert@cs.ucla.edu>
+
+        port new setting code to Sun C 5.8 2005/10/13
+        * chartab.c, lisp.h (char_table_set, char_table_set_range):
+        Return void, not Lisp_Object.  Otherwise, the compiler
+        complains about (A?B:C) where B is void and C is Lisp_Object
+        when compiling CHAR_TABLE_SET, due to the recent change to
+        the API of sub_char_table_set_contents.
+
+2012-08-18  Chong Yidong  <cyd@gnu.org>
+
+        * xdisp.c (handle_invisible_prop): Obey TEXT_PROP_MEANS_INVISIBLE
+        for the string case (Bug#3874).
+
+2012-08-18  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * buffer.h (BSET): Remove (Bug#12215).
+        Replace all uses with calls to new setter functions.
+        (bset_bidi_paragraph_direction, bset_case_canon_table)
+        (bset_case_eqv_table, bset_directory, bset_display_count)
+        (bset_display_time, bset_downcase_table)
+        (bset_enable_multibyte_characters, bset_filename, bset_keymap)
+        (bset_last_selected_window, bset_local_var_alist)
+        (bset_mark_active, bset_point_before_scroll, bset_read_only)
+        (bset_truncate_lines, bset_undo_list, bset_upcase_table)
+        (bset_width_table):
+        * buffer.c (bset_abbrev_mode, bset_abbrev_table)
+        (bset_auto_fill_function, bset_auto_save_file_format)
+        (bset_auto_save_file_name, bset_backed_up, bset_begv_marker)
+        (bset_bidi_display_reordering, bset_buffer_file_coding_system)
+        (bset_cache_long_line_scans, bset_case_fold_search)
+        (bset_ctl_arrow, bset_cursor_in_non_selected_windows)
+        (bset_cursor_type, bset_display_table, bset_extra_line_spacing)
+        (bset_file_format, bset_file_truename, bset_fringe_cursor_alist)
+        (bset_fringe_indicator_alist, bset_fringes_outside_margins)
+        (bset_header_line_format, bset_indicate_buffer_boundaries)
+        (bset_indicate_empty_lines, bset_invisibility_spec)
+        (bset_left_fringe_width, bset_major_mode, bset_mark)
+        (bset_minor_modes, bset_mode_line_format, bset_mode_name)
+        (bset_name, bset_overwrite_mode, bset_pt_marker)
+        (bset_right_fringe_width, bset_save_length)
+        (bset_scroll_bar_width, bset_scroll_down_aggressively)
+        (bset_scroll_up_aggressively, bset_selective_display)
+        (bset_selective_display_ellipses, bset_vertical_scroll_bar_type)
+        (bset_word_wrap, bset_zv_marker):
+        * category.c (bset_category_table):
+        * syntax.c (bset_syntax_table):
+        New setter functions.
+
+        * process.h (PSET): Remove (Bug#12215).
+        Replace all uses with calls to new setter functions.
+        Use INLINE_HEADER_BEGIN, INLINE_HEADER_END.
+        (PROCESS_INLINE): New macro.
+        (pset_childp): New setter function.
+        (pset_gnutls_cred_type) [HAVE_GNUTLS]: New setter function.
+        * process.c (PROCESS_INLINE):
+        Define to EXTERN_INLINE, so that the corresponding functions
+        are compiled into code.
+        (pset_buffer, pset_command, pset_decode_coding_system)
+        (pset_decoding_buf, pset_encode_coding_system)
+        (pset_encoding_buf, pset_filter, pset_log, pset_mark, pset_name)
+        (pset_plist, pset_sentinel, pset_status, pset_tty_name)
+        (pset_type, pset_write_queue): New setter functions.
+
+        * window.h (WSET): Remove (Bug#12215).
+        Replace all uses with calls to new setter functions.
+        Use INLINE_HEADER_BEGIN, INLINE_HEADER_END.
+        (WINDOW_INLINE): New macro.
+        (wset_buffer, wset_frame, wset_left_col, wset_next, wset_prev)
+        (wset_redisplay_end_trigger, wset_top_line, wset_total_cols)
+        (wset_total_lines, wset_vertical_scroll_bar)
+        (wset_window_end_pos, wset_window_end_valid)
+        (wset_window_end_vpos): New setter functions.
+        * window.c (WINDOW_INLINE):
+        Define to EXTERN_INLINE, so that the corresponding functions
+        are compiled into code.
+        (wset_combination_limit, wset_dedicated, wset_display_table)
+        (wset_hchild, wset_left_fringe_width, wset_left_margin_cols)
+        (wset_new_normal, wset_new_total, wset_next_buffers)
+        (wset_normal_cols, wset_normal_lines, wset_parent, wset_pointm)
+        (wset_prev_buffers, wset_right_fringe_width)
+        (wset_right_margin_cols, wset_scroll_bar_width, wset_start)
+        (wset_temslot, wset_vchild, wset_vertical_scroll_bar_type)
+        (wset_window_parameters):
+        * xdisp.c (wset_base_line_number, wset_base_line_pos)
+        (wset_column_number_displayed, wset_region_showing):
+        New setter functions.
+
+        * termhooks.h (TSET): Remove (Bug#12215).
+        Replace all uses with calls to new setter functions.
+        Use INLINE_HEADER_BEGIN, INLINE_HEADER_END.
+        (TERMHOOKS_INLINE): New macro.
+        (tset_charset_list, tset_selection_alist): New setter functions.
+        * terminal.c (TERMHOOKS_INLINE):
+        Define to EXTERN_INLINE, so that the corresponding functions
+        are compiled into code.
+        (tset_param_alist): New setter function.
+
+2012-08-17  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * keyboard.h (KSET): Remove (Bug#12215).
+        Replace all uses with calls to new setter functions.
+        Use INLINE_HEADER_BEGIN, INLINE_HEADER_END.
+        (KEYBOARD_INLINE): New macro.
+        (kset_default_minibuffer_frame, kset_defining_kbd_macro)
+        (kset_input_decode_map, kset_last_command, kset_last_kbd_macro)
+        (kset_prefix_arg, kset_system_key_alist, kset_window_system):
+        New setter functions.
+        * keyboard.c (KEYBOARD_INLINE):
+        Define to EXTERN_INLINE, so that the corresponding functions
+        are compiled into code.
+        (kset_echo_string, kset_kbd_queue)
+        (kset_keyboard_translate_table, kset_last_prefix_arg)
+        (kset_last_repeatable_command, kset_local_function_key_map)
+        (kset_overriding_terminal_local_map, kset_real_last_command)
+        (kset_system_key_syms): New setter functions.
+
+        * frame.h (FSET): Remove (Bug#12215).
+        Replace all uses with calls to new setter functions.
+        Use INLINE_HEADER_BEGIN, INLINE_HEADER_END.
+        (FRAME_INLINE): New macro.
+        (fset_buffer_list, fset_buried_buffer_list, fset_condemned_scroll_bars)
+        (fset_current_tool_bar_string, fset_desired_tool_bar_string)
+        (fset_face_alist, fset_focus_frame, fset_icon_name, fset_menu_bar_items)
+        (fset_menu_bar_vector, fset_menu_bar_window, fset_name)
+        (fset_param_alist, fset_root_window, fset_scroll_bars)
+        (fset_selected_window, fset_title, fset_tool_bar_items)
+        (fset_tool_bar_position, fset_tool_bar_window): New functions.
+        * frame.c (FRAME_INLINE):
+        Define to EXTERN_INLINE, so that the corresponding functions
+        are compiled into code.
+        (fset_buffer_predicate, fset_minibuffer_window): New setter functions.
+
+        A few more naming-convention fixes for getters and setters.
+        * buffer.c (set_buffer_overlays_before): Move here from buffer.h,
+        and rename from buffer_overlays_set_before.
+        (set_buffer_overlays_after): Move here from buffer.h, and rename
+        from buffer_overlays_set_after.
+        * buffer.h (buffer_intervals): Rename from buffer_get_intervals.
+        All uses changed.
+        (set_buffer_intervals): Rename from buffer_set_intervals.
+        * intervals.c (set_interval_object): Move here from intervals.h,
+        and rename from interval_set_object.
+        (set_interval_left): Move here from intervals.h, and rename from
+        interval_set_left.
+        (set_interval_right): Move here from intervals.h, and rename from
+        interval_set_right.
+        (copy_interval_parent): Move here from intervals.h, and rename from
+        interval_copy_parent.
+        * intervals.h (set_interval_parent): Rename from interval_set_parent.
+        (set_interval_plist): Rename from interval_set_plist.
+        Return void, not Lisp_Object, since no caller uses the result.
+        * lisp.h (string_intervals): Rename from string_get_intervals.
+        (set_string_intervals): Rename from string_set_intervals.
+
+        * lisp.h (set_char_table_extras): Rename from char_table_set_extras.
+        (set_char_table_contents): Rename from char_table_set_contents.
+        (set_sub_char_table_contents): Rename from sub_char_table_set_contents.
+        All uses changed.  See the end of
+        <http://lists.gnu.org/archive/html/emacs-devel/2012-08/msg00549.html>.
+
+        * lisp.h (CSET): Remove (Bug#12215).
+        (set_char_table_ascii, set_char_table_defalt, set_char_table_parent)
+        (set_char_table_purpose): New functions,
+        replacing CSET.  All uses changed.  For example, replace
+        "CSET (XCHAR_TABLE (char_table), parent, parent);" with
+        "set_char_table_parent (char_table, parent);".
+        The old version was confusing because it used the same name
+        'parent' for two different things.
+
+2012-08-17  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Functions to get and set Lisp_Object fields of buffer-local variables.
+        * lisp.h (blv_found, set_blv_found, blv_value, set_blv_value)
+        (set_blv_where, set_blv_defcell, set_blv_valcell): New functions.
+        (BLV_FOUND, SET_BLV_FOUND, BLV_VALUE, SET_BLV_VALUE): Remove.
+        * data.c, eval.c, frame.c: Adjust users.
+
+2012-08-17  Chong Yidong  <cyd@gnu.org>
+
+        * xfaces.c (merge_face_vectors): If the target font specfies a
+        font spec, make the font's attributes take precedence over
+        directly-specified attributes.
+        (merge_face_ref): Recognize :font.
+
+2012-08-17  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Do not use memcpy for copying intervals.
+        * intervals.c (reproduce_interval): New function.
+        (reproduce_tree, reproduce_tree_obj): Use it.
+        (reproduce_tree_obj): Remove prototype.
+
+2012-08-17  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * lisp.h (duration_to_sec_usec): Remove unused decl.
+
+2012-08-17  Alp Aker  <alp.tekin.aker@gmail.com>
+
+        * nsfont.m (ns_ascii_average_width): Send initWithFormat selector
+        to an allocated instance of NSString, not to the class itself.
+
+2012-08-17  Juanma Barranquero  <lekktu@gmail.com>
+
+        * makefile.w32-in (C_CTYPE_H): New macro.
+        (LISP_H, $(BLD)/ccl.$(O), $(BLD)/doc.$(O), $(BLD)/w32console.$(O)):
+        ($(BLD)/fontset.$(O), $(BLD)/frame.$(O), $(BLD)/composite.$(O)):
+        ($(BLD)/sysdep.$(O), $(BLD)/w32uniscribe.$(O)): Update dependencies.
+
+2012-08-16  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Use ASCII tests for character types.
+        * category.c, dispnew.c, doprnt.c, editfns.c, syntax.c, term.c:
+        * xfns.c, xterm.c:
+        Don't include <ctype.h>; was not needed.
+        * charset.c, doc.c, fileio.c, font.c, frame.c, gtkutil.c, image.c:
+        * sysdep.c, xfaces.c:
+        Include <c-ctype.h> instead of <ctype.h>.
+        * nsterm.m: Include <c-ctype.h>.
+        * charset.c (read_hex):
+        * doc.c (Fsnarf_documentation):
+        * fileio.c (IS_DRIVE) [WINDOWSNT]:
+        (DRIVE_LETTER) [DOS_NT]:
+        (Ffile_name_directory, Fexpand_file_name)
+        (Fsubstitute_in_file_name):
+        * font.c (font_parse_xlfd, font_parse_fcname):
+        * frame.c (x_set_font_backend):
+        * gtkutil.c (xg_get_font):
+        * image.c (xbm_scan, xpm_scan, pbm_scan_number):
+        * nsimage.m (hexchar):
+        * nsterm.m (ns_xlfd_to_fontname):
+        * sysdep.c (system_process_attributes):
+        * xfaces.c (hash_string_case_insensitive):
+        Use C-locale tests instead of locale-specific tests for character
+        types, since we want the ASCII interpretation here, not the
+        interpretation suitable for whatever happens to be the current locale.
+
+2012-08-16  Martin Rudalics  <rudalics@gmx.at>
+
+        Consistently check windows for validity/liveness
+        (Bug#11984, Bug#12025, Bug#12026).
+        * lisp.h (CHECK_VALID_WINDOW): New macro.
+        * window.c (decode_window): Rename to decode_live_window.
+        (decode_valid_window, Fwindow_valid_p): New functions.
+        (Fwindow_frame, Fframe_root_window, Fwindow_minibuffer_p)
+        (Fframe_first_window, Fframe_selected_window, Fwindow_parent)
+        (Fwindow_top_child, Fwindow_left_child, Fwindow_next_sibling)
+        (Fwindow_prev_sibling, Fwindow_combination_limit)
+        (Fset_window_combination_limit, Fwindow_use_time)
+        (Fwindow_total_height, Fwindow_total_width, Fwindow_new_total)
+        (Fwindow_normal_size, Fwindow_new_normal, Fwindow_left_column)
+        (Fwindow_top_line, Fwindow_body_height, Fwindow_body_width)
+        (Fwindow_hscroll, Fset_window_hscroll)
+        (Fwindow_redisplay_end_trigger)
+        (Fset_window_redisplay_end_trigger, Fwindow_edges)
+        (Fwindow_pixel_edges, Fwindow_absolute_pixel_edges)
+        (Fwindow_inside_edges, Fwindow_inside_pixel_edges)
+        (Fcoordinates_in_window_p, Fwindow_point, Fwindow_start)
+        (Fwindow_end, Fset_window_point, Fset_window_start)
+        (Fpos_visible_in_window_p, Fwindow_line_height)
+        (Fwindow_dedicated_p, Fset_window_dedicated_p)
+        (Fwindow_prev_buffers, Fset_window_prev_buffers)
+        (Fwindow_next_buffers, Fwindow_parameters, Fwindow_parameter)
+        (Fset_window_parameter, Fwindow_display_table)
+        (Fset_window_display_table, Fdelete_other_windows_internal)
+        (Fset_window_buffer, Fset_window_new_total)
+        (Fset_window_new_normal, Fdelete_window_internal)
+        (Fwindow_text_height, Fset_window_margins, Fwindow_margins)
+        (Fset_window_fringes, Fwindow_fringes, Fset_window_scroll_bars)
+        (Fwindow_scroll_bars): Check whether argument window is a valid or
+        live window.  Update doc-strings.
+        (syms_of_window): New symbol Qwindow_valid_p.
+        * keyboard.c (Fposn_at_x_y): Check whether argument
+        frame_or_window denotes a valid window.
+
+2012-08-16  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Fix previous char table change.
+        * lisp.h (CHAR_TABLE_SET): Use sub_char_table_set_contents.
+        * chartab.c (optimize_sub_char_table): Likewise.
+
+2012-08-16  Chong Yidong  <cyd@gnu.org>
+
+        * gtkutil.c (xg_get_font): Demand an Xft font (Bug#3228).
+
+        * xfont.c (xfont_open):
+        * xftfont.c (xftfont_open): Set the font's max_width field.
+
+        * nsfont.m (nsfont_open): Similar to the Xft backend, set
+        min_width to space_width and average_width to the average over
+        printable ASCII characters.
+        (ns_char_width): Code cleanup.
+        (ns_ascii_average_width): New utility function.
+
+        * font.h (struct font): Update comments.
+
+2012-08-16  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Simple interface to set Lisp_Object fields of character tables.
+        * lisp.h (CSET): New macro.
+        (char_table_set_extras, char_table_set_contents)
+        (sub_char_table_set_contents): New function.
+        * casetab.c, category.c, chartab.c, fns.c, fontset.c, search.c:
+        * syntax.c: Adjust users.
+
+2012-08-16  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * eval.c (eval_sub): Bind lexical-binding.
+        * lread.c (Qlexical_binding): Make non-static.
+
 2012-08-15  Jan Djärv  <jan.h.d@swipnet.se>
 
         * nsmenu.m (popupSession): Remove.
@@ -44,8 +353,8 @@
 
         Generalize and cleanup font subsystem checks.
         * font.h (FONT_DEBUG, font_assert): Remove.
-        * font.c, fontset.c, w32font.c, xfont.c, xftfont.c: Change
-        font_assert to eassert.  Use eassert where appropriate.
+        * font.c, fontset.c, w32font.c, xfont.c, xftfont.c:
+        Change font_assert to eassert.  Use eassert where appropriate.
 
 2012-08-15  Dmitry Antipov  <dmantipov@yandex.ru>
 
@@ -53,10 +362,10 @@
 
 2012-08-15  Chong Yidong  <cyd@gnu.org>
 
-        * gtkutil.c (xg_get_font): Rename from xg_get_font_name.  When
-        using the new font chooser, use gtk_font_chooser_get_font_desc to
-        extract the font descriptor instead of just the font name.  In
-        that case, return a font spec instead of a string.
+        * gtkutil.c (xg_get_font): Rename from xg_get_font_name.
+        When using the new font chooser, use gtk_font_chooser_get_font_desc to
+        extract the font descriptor instead of just the font name.
+        In that case, return a font spec instead of a string.
         (x_last_font_name): Move to this file from xfns.c.
 
         * xfns.c (Fx_select_font): The return value can also be a font
@@ -3338,6 +3647,7 @@
         has at least microseconds now.  All uses removed.
         (update_frame, update_single_window, update_window, update_frame_1)
         (Fsleep_for, sit_for): Port to higher-resolution time stamps.
+        (duration_to_sec_usec): Remove; no longer needed.
 
         * editfns.c (time_overflow): Now extern.
         (Fcurrent_time, Fget_internal_run_time, make_time, lisp_time_argument)
diff --git a/src/alloc.c b/src/alloc.c
index 1d484d4a322..522f33f5379 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -5836,7 +5836,7 @@ mark_buffer (struct buffer *buffer)
 
   /* ...but there are some buffer-specific things.  */
 
-  MARK_INTERVAL_TREE (buffer_get_intervals (buffer));
+  MARK_INTERVAL_TREE (buffer_intervals (buffer));
 
   /* For now, we just don't mark the undo_list.  It's done later in
      a special way just before the sweep phase, and after stripping
@@ -6090,7 +6090,7 @@ mark_object (Lisp_Object arg)
           }
         if (!PURE_POINTER_P (XSTRING (ptr->name)))
           MARK_STRING (XSTRING (ptr->name));
-        MARK_INTERVAL_TREE (string_get_intervals (ptr->name));
+        MARK_INTERVAL_TREE (string_intervals (ptr->name));
 
         ptr = ptr->next;
         if (ptr)
@@ -6405,7 +6405,7 @@ gc_sweep (void)
           {
             if (!iblk->intervals[i].gcmarkbit)
               {
-                interval_set_parent (&iblk->intervals[i], interval_free_list);
+                set_interval_parent (&iblk->intervals[i], interval_free_list);
                 interval_free_list = &iblk->intervals[i];
                 this_free++;
               }
diff --git a/src/buffer.c b/src/buffer.c
index 56d6231f5f8..9373e3cd363 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -157,6 +157,228 @@ static struct Lisp_Overlay * copy_overlays (struct buffer *, struct Lisp_Overlay
 static void modify_overlay (struct buffer *, ptrdiff_t, ptrdiff_t);
 static Lisp_Object buffer_lisp_local_variables (struct buffer *, int);
 
+/* These setters are used only in this file, so they can be private.  */
+static inline void
+bset_abbrev_mode (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (abbrev_mode) = val;
+}
+static inline void
+bset_abbrev_table (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (abbrev_table) = val;
+}
+static inline void
+bset_auto_fill_function (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (auto_fill_function) = val;
+}
+static inline void
+bset_auto_save_file_format (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (auto_save_file_format) = val;
+}
+static inline void
+bset_auto_save_file_name (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (auto_save_file_name) = val;
+}
+static inline void
+bset_backed_up (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (backed_up) = val;
+}
+static inline void
+bset_begv_marker (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (begv_marker) = val;
+}
+static inline void
+bset_bidi_display_reordering (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (bidi_display_reordering) = val;
+}
+static inline void
+bset_buffer_file_coding_system (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (buffer_file_coding_system) = val;
+}
+static inline void
+bset_cache_long_line_scans (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (cache_long_line_scans) = val;
+}
+static inline void
+bset_case_fold_search (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (case_fold_search) = val;
+}
+static inline void
+bset_ctl_arrow (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (ctl_arrow) = val;
+}
+static inline void
+bset_cursor_in_non_selected_windows (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (cursor_in_non_selected_windows) = val;
+}
+static inline void
+bset_cursor_type (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (cursor_type) = val;
+}
+static inline void
+bset_display_table (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (display_table) = val;
+}
+static inline void
+bset_extra_line_spacing (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (extra_line_spacing) = val;
+}
+static inline void
+bset_file_format (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (file_format) = val;
+}
+static inline void
+bset_file_truename (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (file_truename) = val;
+}
+static inline void
+bset_fringe_cursor_alist (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (fringe_cursor_alist) = val;
+}
+static inline void
+bset_fringe_indicator_alist (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (fringe_indicator_alist) = val;
+}
+static inline void
+bset_fringes_outside_margins (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (fringes_outside_margins) = val;
+}
+static inline void
+bset_header_line_format (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (header_line_format) = val;
+}
+static inline void
+bset_indicate_buffer_boundaries (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (indicate_buffer_boundaries) = val;
+}
+static inline void
+bset_indicate_empty_lines (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (indicate_empty_lines) = val;
+}
+static inline void
+bset_invisibility_spec (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (invisibility_spec) = val;
+}
+static inline void
+bset_left_fringe_width (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (left_fringe_width) = val;
+}
+static inline void
+bset_major_mode (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (major_mode) = val;
+}
+static inline void
+bset_mark (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (mark) = val;
+}
+static inline void
+bset_minor_modes (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (minor_modes) = val;
+}
+static inline void
+bset_mode_line_format (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (mode_line_format) = val;
+}
+static inline void
+bset_mode_name (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (mode_name) = val;
+}
+static inline void
+bset_name (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (name) = val;
+}
+static inline void
+bset_overwrite_mode (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (overwrite_mode) = val;
+}
+static inline void
+bset_pt_marker (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (pt_marker) = val;
+}
+static inline void
+bset_right_fringe_width (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (right_fringe_width) = val;
+}
+static inline void
+bset_save_length (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (save_length) = val;
+}
+static inline void
+bset_scroll_bar_width (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (scroll_bar_width) = val;
+}
+static inline void
+bset_scroll_down_aggressively (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (scroll_down_aggressively) = val;
+}
+static inline void
+bset_scroll_up_aggressively (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (scroll_up_aggressively) = val;
+}
+static inline void
+bset_selective_display (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (selective_display) = val;
+}
+static inline void
+bset_selective_display_ellipses (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (selective_display_ellipses) = val;
+}
+static inline void
+bset_vertical_scroll_bar_type (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (vertical_scroll_bar_type) = val;
+}
+static inline void
+bset_word_wrap (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (word_wrap) = val;
+}
+static inline void
+bset_zv_marker (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (zv_marker) = val;
+}
+
 /* For debugging; temporary.  See set_buffer_internal.  */
 /* Lisp_Object Qlisp_mode, Vcheck_symbol; */
 
@@ -360,7 +582,7 @@ even if it is dead.  The return value is never nil.  */)
   BUF_CHARS_MODIFF (b) = 1;
   BUF_OVERLAY_MODIFF (b) = 1;
   BUF_SAVE_MODIFF (b) = 1;
-  buffer_set_intervals (b, NULL);
+  set_buffer_intervals (b, NULL);
   BUF_UNCHANGED_MODIFIED (b) = 1;
   BUF_OVERLAY_UNCHANGED_MODIFIED (b) = 1;
   BUF_END_UNCHANGED (b) = 0;
@@ -370,7 +592,7 @@ even if it is dead.  The return value is never nil.  */)
 
   b->newline_cache = 0;
   b->width_run_cache = 0;
-  BSET (b, width_table, Qnil);
+  bset_width_table (b, Qnil);
   b->prevent_redisplay_optimizations_p = 1;
 
   /* Put this on the chain of all buffers including killed ones.  */
@@ -379,20 +601,20 @@ even if it is dead.  The return value is never nil.  */)
 
   /* An ordinary buffer normally doesn't need markers
      to handle BEGV and ZV.  */
-  BSET (b, pt_marker, Qnil);
-  BSET (b, begv_marker, Qnil);
-  BSET (b, zv_marker, Qnil);
+  bset_pt_marker (b, Qnil);
+  bset_begv_marker (b, Qnil);
+  bset_zv_marker (b, Qnil);
 
   name = Fcopy_sequence (buffer_or_name);
-  string_set_intervals (name, NULL);
-  BSET (b, name, name);
+  set_string_intervals (name, NULL);
+  bset_name (b, name);
 
-  BSET (b, undo_list, (SREF (name, 0) != ' ') ? Qnil : Qt);
+  bset_undo_list (b, SREF (name, 0) != ' ' ? Qnil : Qt);
 
   reset_buffer (b);
   reset_buffer_local_variables (b, 1);
 
-  BSET (b, mark, Fmake_marker ());
+  bset_mark (b, Fmake_marker ());
   BUF_MARKERS (b) = NULL;
 
   /* Put this in the alist of all live buffers.  */
@@ -439,6 +661,19 @@ copy_overlays (struct buffer *b, struct Lisp_Overlay *list)
   return result;
 }
 
+/* Set an appropriate overlay of B.  */
+
+static inline void
+set_buffer_overlays_before (struct buffer *b, struct Lisp_Overlay *o)
+{
+  b->overlays_before = o;
+}
+
+static inline void
+set_buffer_overlays_after (struct buffer *b, struct Lisp_Overlay *o)
+{
+  b->overlays_after = o;
+}
 
 /* Clone per-buffer values of buffer FROM.
 
@@ -474,12 +709,12 @@ clone_per_buffer_values (struct buffer *from, struct buffer *to)
 
   memcpy (to->local_flags, from->local_flags, sizeof to->local_flags);
 
-  buffer_set_overlays_before (to, copy_overlays (to, from->overlays_before));
-  buffer_set_overlays_after (to, copy_overlays (to, from->overlays_after));
+  set_buffer_overlays_before (to, copy_overlays (to, from->overlays_before));
+  set_buffer_overlays_after (to, copy_overlays (to, from->overlays_after));
 
   /* Get (a copy of) the alist of Lisp-level local variables of FROM
      and install that in TO.  */
-  BSET (to, local_var_alist, buffer_lisp_local_variables (from, 1));
+  bset_local_var_alist (to, buffer_lisp_local_variables (from, 1));
 }
 
 
@@ -582,15 +817,15 @@ CLONE nil means the indirect buffer's state is reset to default values.  */)
 
   b->newline_cache = 0;
   b->width_run_cache = 0;
-  BSET (b, width_table, Qnil);
+  bset_width_table (b, Qnil);
 
   /* Put this on the chain of all buffers including killed ones.  */
   b->header.next.buffer = all_buffers;
   all_buffers = b;
 
   name = Fcopy_sequence (name);
-  string_set_intervals (name, NULL);
-  BSET (b, name, name);
+  set_string_intervals (name, NULL);
+  bset_name (b, name);
 
   reset_buffer (b);
   reset_buffer_local_variables (b, 1);
@@ -599,10 +834,11 @@ CLONE nil means the indirect buffer's state is reset to default values.  */)
   XSETBUFFER (buf, b);
   Vbuffer_alist = nconc2 (Vbuffer_alist, Fcons (Fcons (name, buf), Qnil));
 
-  BSET (b, mark, Fmake_marker ());
+  bset_mark (b, Fmake_marker ());
 
   /* The multibyte status belongs to the base buffer.  */
-  BSET (b, enable_multibyte_characters, BVAR (b->base_buffer, enable_multibyte_characters));
+  bset_enable_multibyte_characters
+    (b, BVAR (b->base_buffer, enable_multibyte_characters));
 
   /* Make sure the base buffer has markers for its narrowing.  */
   if (NILP (BVAR (b->base_buffer, pt_marker)))
@@ -610,14 +846,17 @@ CLONE nil means the indirect buffer's state is reset to default values.  */)
       eassert (NILP (BVAR (b->base_buffer, begv_marker)));
       eassert (NILP (BVAR (b->base_buffer, zv_marker)));
 
-      BSET (b->base_buffer, pt_marker,
-            build_marker (b->base_buffer, b->base_buffer->pt, b->base_buffer->pt_byte));
+      bset_pt_marker (b->base_buffer,
+                      build_marker (b->base_buffer, b->base_buffer->pt,
+                                    b->base_buffer->pt_byte));
 
-      BSET (b->base_buffer, begv_marker,
-            build_marker (b->base_buffer, b->base_buffer->begv, b->base_buffer->begv_byte));
+      bset_begv_marker (b->base_buffer,
+                        build_marker (b->base_buffer, b->base_buffer->begv,
+                                      b->base_buffer->begv_byte));
 
-      BSET (b->base_buffer, zv_marker,
-            build_marker (b->base_buffer, b->base_buffer->zv, b->base_buffer->zv_byte));
+      bset_zv_marker (b->base_buffer,
+                      build_marker (b->base_buffer, b->base_buffer->zv,
+                                    b->base_buffer->zv_byte));
 
       XMARKER (BVAR (b->base_buffer, zv_marker))->insertion_type = 1;
     }
@@ -625,9 +864,9 @@ CLONE nil means the indirect buffer's state is reset to default values.  */)
   if (NILP (clone))
     {
       /* Give the indirect buffer markers for its narrowing.  */
-      BSET (b, pt_marker, build_marker (b, b->pt, b->pt_byte));
-      BSET (b, begv_marker, build_marker (b, b->begv, b->begv_byte));
-      BSET (b, zv_marker, build_marker (b, b->zv, b->zv_byte));
+      bset_pt_marker (b, build_marker (b, b->pt, b->pt_byte));
+      bset_begv_marker (b, build_marker (b, b->begv, b->begv_byte));
+      bset_zv_marker (b, build_marker (b, b->zv, b->zv_byte));
       XMARKER (BVAR (b, zv_marker))->insertion_type = 1;
     }
   else
@@ -635,11 +874,11 @@ CLONE nil means the indirect buffer's state is reset to default values.  */)
       struct buffer *old_b = current_buffer;
 
       clone_per_buffer_values (b->base_buffer, b);
-      BSET (b, filename, Qnil);
-      BSET (b, file_truename, Qnil);
-      BSET (b, display_count, make_number (0));
-      BSET (b, backed_up, Qnil);
-      BSET (b, auto_save_file_name, Qnil);
+      bset_filename (b, Qnil);
+      bset_file_truename (b, Qnil);
+      bset_display_count (b, make_number (0));
+      bset_backed_up (b, Qnil);
+      bset_auto_save_file_name (b, Qnil);
       set_buffer_internal_1 (b);
       Fset (intern ("buffer-save-without-query"), Qnil);
       Fset (intern ("buffer-file-number"), Qnil);
@@ -688,8 +927,8 @@ delete_all_overlays (struct buffer *b)
       ov->next = NULL;
     }
 
-  buffer_set_overlays_before (b, NULL);
-  buffer_set_overlays_after (b, NULL);
+  set_buffer_overlays_before (b, NULL);
+  set_buffer_overlays_after (b, NULL);
 }
 
 /* Reinitialize everything about a buffer except its name and contents
@@ -702,10 +941,9 @@ delete_all_overlays (struct buffer *b)
 void
 reset_buffer (register struct buffer *b)
 {
-  BSET (b, filename, Qnil);
-  BSET (b, file_truename, Qnil);
-  BSET (b, directory,
-        (current_buffer) ? BVAR (current_buffer, directory) : Qnil);
+  bset_filename (b, Qnil);
+  bset_file_truename (b, Qnil);
+  bset_directory (b, current_buffer ? BVAR (current_buffer, directory) : Qnil);
   b->modtime = make_emacs_time (0, UNKNOWN_MODTIME_NSECS);
   b->modtime_size = -1;
   XSETFASTINT (BVAR (b, save_length), 0);
@@ -713,25 +951,25 @@ reset_buffer (register struct buffer *b)
   /* It is more conservative to start out "changed" than "unchanged".  */
   b->clip_changed = 0;
   b->prevent_redisplay_optimizations_p = 1;
-  BSET (b, backed_up, Qnil);
+  bset_backed_up (b, Qnil);
   BUF_AUTOSAVE_MODIFF (b) = 0;
   b->auto_save_failure_time = 0;
-  BSET (b, auto_save_file_name, Qnil);
-  BSET (b, read_only, Qnil);
-  buffer_set_overlays_before (b, NULL);
-  buffer_set_overlays_after (b, NULL);
+  bset_auto_save_file_name (b, Qnil);
+  bset_read_only (b, Qnil);
+  set_buffer_overlays_before (b, NULL);
+  set_buffer_overlays_after (b, NULL);
   b->overlay_center = BEG;
-  BSET (b, mark_active, Qnil);
-  BSET (b, point_before_scroll, Qnil);
-  BSET (b, file_format, Qnil);
-  BSET (b, auto_save_file_format, Qt);
-  BSET (b, last_selected_window, Qnil);
-  BSET (b, display_count, make_number (0));
-  BSET (b, display_time, Qnil);
-  BSET (b, enable_multibyte_characters,
-       BVAR (&buffer_defaults, enable_multibyte_characters));
-  BSET (b, cursor_type, BVAR (&buffer_defaults, cursor_type));
-  BSET (b, extra_line_spacing, BVAR (&buffer_defaults, extra_line_spacing));
+  bset_mark_active (b, Qnil);
+  bset_point_before_scroll (b, Qnil);
+  bset_file_format (b, Qnil);
+  bset_auto_save_file_format (b, Qt);
+  bset_last_selected_window (b, Qnil);
+  bset_display_count (b, make_number (0));
+  bset_display_time (b, Qnil);
+  bset_enable_multibyte_characters
+    (b, BVAR (&buffer_defaults, enable_multibyte_characters));
+  bset_cursor_type (b, BVAR (&buffer_defaults, cursor_type));
+  bset_extra_line_spacing (b, BVAR (&buffer_defaults, extra_line_spacing));
 
   b->display_error_modiff = 0;
 }
@@ -755,10 +993,10 @@ reset_buffer_local_variables (register struct buffer *b, int permanent_too)
      things that depend on the major mode.
      default-major-mode is handled at a higher level.
      We ignore it here.  */
-  BSET (b, major_mode, Qfundamental_mode);
-  BSET (b, keymap, Qnil);
-  BSET (b, mode_name, QSFundamental);
-  BSET (b, minor_modes, Qnil);
+  bset_major_mode (b, Qfundamental_mode);
+  bset_keymap (b, Qnil);
+  bset_mode_name (b, QSFundamental);
+  bset_minor_modes (b, Qnil);
 
   /* If the standard case table has been altered and invalidated,
      fix up its insides first.  */
@@ -767,15 +1005,15 @@ reset_buffer_local_variables (register struct buffer *b, int permanent_too)
          && CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table)->extras[2])))
     Fset_standard_case_table (Vascii_downcase_table);
 
-  BSET (b, downcase_table, Vascii_downcase_table);
-  BSET (b, upcase_table, XCHAR_TABLE (Vascii_downcase_table)->extras[0]);
-  BSET (b, case_canon_table, XCHAR_TABLE (Vascii_downcase_table)->extras[1]);
-  BSET (b, case_eqv_table, XCHAR_TABLE (Vascii_downcase_table)->extras[2]);
-  BSET (b, invisibility_spec, Qt);
+  bset_downcase_table (b, Vascii_downcase_table);
+  bset_upcase_table (b, XCHAR_TABLE (Vascii_downcase_table)->extras[0]);
+  bset_case_canon_table (b, XCHAR_TABLE (Vascii_downcase_table)->extras[1]);
+  bset_case_eqv_table (b, XCHAR_TABLE (Vascii_downcase_table)->extras[2]);
+  bset_invisibility_spec (b, Qt);
 
   /* Reset all (or most) per-buffer variables to their defaults.  */
   if (permanent_too)
-    BSET (b, local_var_alist, Qnil);
+    bset_local_var_alist (b, Qnil);
   else
     {
       Lisp_Object tmp, prop, last = Qnil;
@@ -809,7 +1047,7 @@ reset_buffer_local_variables (register struct buffer *b, int permanent_too)
           }
         /* Delete this local variable.  */
         else if (NILP (last))
-          BSET (b, local_var_alist, XCDR (tmp));
+          bset_local_var_alist (b, XCDR (tmp));
         else
           XSETCDR (last, XCDR (tmp));
     }
@@ -1286,7 +1524,7 @@ This does not change the name of the visited file (if any).  */)
         error ("Buffer name `%s' is in use", SDATA (newname));
     }
 
-  BSET (current_buffer, name, newname);
+  bset_name (current_buffer, newname);
 
   /* Catch redisplay's attention.  Unless we do this, the mode lines for
      any windows displaying current_buffer will stay unchanged.  */
@@ -1431,7 +1669,7 @@ No argument or nil as argument means do this for the current buffer.  */)
     }
 
   if (EQ (BVAR (XBUFFER (real_buffer), undo_list), Qt))
-    BSET (XBUFFER (real_buffer), undo_list, Qnil);
+    bset_undo_list (XBUFFER (real_buffer), Qnil);
 
   return Qnil;
 }
@@ -1691,7 +1929,7 @@ cleaning up all windows currently displaying the buffer to be killed. */)
           m = next;
         }
       BUF_MARKERS (b) = NULL;
-      buffer_set_intervals (b, NULL);
+      set_buffer_intervals (b, NULL);
 
       /* Perhaps we should explicitly free the interval tree here... */
     }
@@ -1703,7 +1941,7 @@ cleaning up all windows currently displaying the buffer to be killed. */)
   swap_out_buffer_local_variables (b);
   reset_buffer_local_variables (b, 1);
 
-  BSET (b, name, Qnil);
+  bset_name (b, Qnil);
 
   BLOCK_INPUT;
   if (b->base_buffer)
@@ -1727,9 +1965,9 @@ cleaning up all windows currently displaying the buffer to be killed. */)
       free_region_cache (b->width_run_cache);
       b->width_run_cache = 0;
     }
-  BSET (b, width_table, Qnil);
+  bset_width_table (b, Qnil);
   UNBLOCK_INPUT;
-  BSET (b, undo_list, Qnil);
+  bset_undo_list (b, Qnil);
 
   /* Run buffer-list-update-hook.  */
   if (!NILP (Vrun_hooks))
@@ -1770,8 +2008,8 @@ record_buffer (Lisp_Object buffer)
   Vinhibit_quit = tem;
 
   /* Update buffer list of selected frame.  */
-  FSET (f, buffer_list, Fcons (buffer, Fdelq (buffer, f->buffer_list)));
-  FSET (f, buried_buffer_list, Fdelq (buffer, f->buried_buffer_list));
+  fset_buffer_list (f, Fcons (buffer, Fdelq (buffer, f->buffer_list)));
+  fset_buried_buffer_list (f, Fdelq (buffer, f->buried_buffer_list));
 
   /* Run buffer-list-update-hook.  */
   if (!NILP (Vrun_hooks))
@@ -1808,9 +2046,9 @@ DEFUN ("bury-buffer-internal", Fbury_buffer_internal, Sbury_buffer_internal,
   Vinhibit_quit = tem;
 
   /* Update buffer lists of selected frame.  */
-  FSET (f, buffer_list, Fdelq (buffer, f->buffer_list));
-  FSET (f, buried_buffer_list,
-        Fcons (buffer, Fdelq (buffer, f->buried_buffer_list)));
+  fset_buffer_list (f, Fdelq (buffer, f->buffer_list));
+  fset_buried_buffer_list
+    (f, Fcons (buffer, Fdelq (buffer, f->buried_buffer_list)));
 
   /* Run buffer-list-update-hook.  */
   if (!NILP (Vrun_hooks))
@@ -1910,7 +2148,7 @@ set_buffer_internal_1 (register struct buffer *b)
       /* Put the undo list back in the base buffer, so that it appears
          that an indirect buffer shares the undo list of its base.  */
       if (old_buf->base_buffer)
-        BSET (old_buf->base_buffer, undo_list, BVAR (old_buf, undo_list));
+        bset_undo_list (old_buf->base_buffer, BVAR (old_buf, undo_list));
 
       /* If the old current buffer has markers to record PT, BEGV and ZV
          when it is not current, update them now.  */
@@ -1920,7 +2158,7 @@ set_buffer_internal_1 (register struct buffer *b)
   /* Get the undo list from the base buffer, so that it appears
      that an indirect buffer shares the undo list of its base.  */
   if (b->base_buffer)
-    BSET (b, undo_list, BVAR (b->base_buffer, undo_list));
+    bset_undo_list (b, BVAR (b->base_buffer, undo_list));
 
   /* If the new current buffer has markers to record PT, BEGV and ZV
      when it is not current, fetch them now.  */
@@ -2118,8 +2356,8 @@ DEFUN ("buffer-swap-text", Fbuffer_swap_text, Sbuffer_swap_text,
 #define swapfield_(field, type) \
   do {                                                  \
     type tmp##field = BVAR (other_buffer, field);               \
-    BSET (other_buffer, field, BVAR (current_buffer, field));   \
-    BSET (current_buffer, field, tmp##field);                   \
+    bset_##field (other_buffer, BVAR (current_buffer, field));  \
+    bset_##field (current_buffer, tmp##field);                  \
   } while (0)
 
   swapfield (own_text, struct buffer_text);
@@ -2159,8 +2397,8 @@ DEFUN ("buffer-swap-text", Fbuffer_swap_text, Sbuffer_swap_text,
   swapfield_ (pt_marker, Lisp_Object);
   swapfield_ (begv_marker, Lisp_Object);
   swapfield_ (zv_marker, Lisp_Object);
-  BSET (current_buffer, point_before_scroll, Qnil);
-  BSET (other_buffer, point_before_scroll, Qnil);
+  bset_point_before_scroll (current_buffer, Qnil);
+  bset_point_before_scroll (other_buffer, Qnil);
 
   current_buffer->text->modiff++;         other_buffer->text->modiff++;
   current_buffer->text->chars_modiff++;   other_buffer->text->chars_modiff++;
@@ -2249,7 +2487,7 @@ current buffer is cleared.  */)
 
   /* Don't record these buffer changes.  We will put a special undo entry
      instead.  */
-  BSET (current_buffer, undo_list, Qt);
+  bset_undo_list (current_buffer, Qt);
 
   /* If the cached position is for this buffer, clear it out.  */
   clear_charpos_cache (current_buffer);
@@ -2271,7 +2509,7 @@ current buffer is cleared.  */)
          to calculate the old correspondences.  */
       set_intervals_multibyte (0);
 
-      BSET (current_buffer, enable_multibyte_characters, Qnil);
+      bset_enable_multibyte_characters (current_buffer, Qnil);
 
       Z = Z_BYTE;
       BEGV = BEGV_BYTE;
@@ -2409,7 +2647,7 @@ current buffer is cleared.  */)
 
       /* Do this first, so that chars_in_text asks the right question.
          set_intervals_multibyte needs it too.  */
-      BSET (current_buffer, enable_multibyte_characters, Qt);
+      bset_enable_multibyte_characters (current_buffer, Qt);
 
       GPT_BYTE = advance_to_char_boundary (GPT_BYTE);
       GPT = chars_in_text (BEG_ADDR, GPT_BYTE - BEG_BYTE) + BEG;
@@ -2467,11 +2705,11 @@ current buffer is cleared.  */)
   if (!EQ (old_undo, Qt))
     {
       /* Represent all the above changes by a special undo entry.  */
-      BSET (current_buffer, undo_list,
-            Fcons (list3 (Qapply,
-                          intern ("set-buffer-multibyte"),
-                          NILP (flag) ? Qt : Qnil),
-                   old_undo));
+      bset_undo_list (current_buffer,
+                      Fcons (list3 (Qapply,
+                                    intern ("set-buffer-multibyte"),
+                                    NILP (flag) ? Qt : Qnil),
+                             old_undo));
     }
 
   UNGCPRO;
@@ -3238,7 +3476,7 @@ recenter_overlay_lists (struct buffer *buf, ptrdiff_t pos)
           if (prev)
             prev->next = next;
           else
-            buffer_set_overlays_before (buf, next);
+            set_buffer_overlays_before (buf, next);
 
           /* Search thru overlays_after for where to put it.  */
           other_prev = NULL;
@@ -3260,7 +3498,7 @@ recenter_overlay_lists (struct buffer *buf, ptrdiff_t pos)
           if (other_prev)
             other_prev->next = tail;
           else
-            buffer_set_overlays_after (buf, tail);
+            set_buffer_overlays_after (buf, tail);
           tail = prev;
         }
       else
@@ -3296,7 +3534,7 @@ recenter_overlay_lists (struct buffer *buf, ptrdiff_t pos)
           if (prev)
             prev->next = next;
           else
-            buffer_set_overlays_after (buf, next);
+            set_buffer_overlays_after (buf, next);
 
           /* Search thru overlays_before for where to put it.  */
           other_prev = NULL;
@@ -3318,7 +3556,7 @@ recenter_overlay_lists (struct buffer *buf, ptrdiff_t pos)
           if (other_prev)
             other_prev->next = tail;
           else
-            buffer_set_overlays_before (buf, tail);
+            set_buffer_overlays_before (buf, tail);
           tail = prev;
         }
     }
@@ -3423,7 +3661,7 @@ fix_start_end_in_overlays (register ptrdiff_t start, register ptrdiff_t end)
               beforep = tail;
             }
           if (!parent)
-            buffer_set_overlays_before (current_buffer, tail->next);
+            set_buffer_overlays_before (current_buffer, tail->next);
           else
             parent->next = tail->next;
           tail = tail->next;
@@ -3469,7 +3707,7 @@ fix_start_end_in_overlays (register ptrdiff_t start, register ptrdiff_t end)
               beforep = tail;
             }
           if (!parent)
-            buffer_set_overlays_after (current_buffer, tail->next);
+            set_buffer_overlays_after (current_buffer, tail->next);
           else
             parent->next = tail->next;
           tail = tail->next;
@@ -3483,14 +3721,14 @@ fix_start_end_in_overlays (register ptrdiff_t start, register ptrdiff_t end)
   if (beforep)
     {
       beforep->next = current_buffer->overlays_before;
-      buffer_set_overlays_before (current_buffer, before_list);
+      set_buffer_overlays_before (current_buffer, before_list);
     }
   recenter_overlay_lists (current_buffer, current_buffer->overlay_center);
 
   if (afterp)
     {
       afterp->next = current_buffer->overlays_after;
-      buffer_set_overlays_after (current_buffer, after_list);
+      set_buffer_overlays_after (current_buffer, after_list);
     }
   recenter_overlay_lists (current_buffer, current_buffer->overlay_center);
 }
@@ -3567,7 +3805,7 @@ fix_overlays_before (struct buffer *bp, ptrdiff_t prev, ptrdiff_t pos)
           if (!right_pair)
             {
               found->next = bp->overlays_before;
-              buffer_set_overlays_before (bp, found);
+              set_buffer_overlays_before (bp, found);
             }
           else
             {
@@ -3645,13 +3883,13 @@ for the rear of the overlay advance when text is inserted there
     {
       if (b->overlays_after)
         XOVERLAY (overlay)->next = b->overlays_after;
-      buffer_set_overlays_after (b, XOVERLAY (overlay));
+      set_buffer_overlays_after (b, XOVERLAY (overlay));
     }
   else
     {
       if (b->overlays_before)
         XOVERLAY (overlay)->next = b->overlays_before;
-      buffer_set_overlays_before (b, XOVERLAY (overlay));
+      set_buffer_overlays_before (b, XOVERLAY (overlay));
     }
 
   /* This puts it in the right list, and in the right order.  */
@@ -3716,8 +3954,8 @@ unchain_both (struct buffer *b, Lisp_Object overlay)
 {
   struct Lisp_Overlay *ov = XOVERLAY (overlay);
 
-  buffer_set_overlays_before (b, unchain_overlay (b->overlays_before, ov));
-  buffer_set_overlays_after (b, unchain_overlay (b->overlays_after, ov));
+  set_buffer_overlays_before (b, unchain_overlay (b->overlays_before, ov));
+  set_buffer_overlays_after (b, unchain_overlay (b->overlays_after, ov));
   eassert (XOVERLAY (overlay)->next == NULL);
 }
 
@@ -3812,12 +4050,12 @@ buffer.  */)
   if (n_end < b->overlay_center)
     {
       XOVERLAY (overlay)->next = b->overlays_after;
-      buffer_set_overlays_after (b, XOVERLAY (overlay));
+      set_buffer_overlays_after (b, XOVERLAY (overlay));
     }
   else
     {
       XOVERLAY (overlay)->next = b->overlays_before;
-      buffer_set_overlays_before (b, XOVERLAY (overlay));
+      set_buffer_overlays_before (b, XOVERLAY (overlay));
     }
 
   /* This puts it in the right list, and in the right order.  */
@@ -4913,8 +5151,8 @@ init_buffer_once (void)
   /* No one will share the text with these buffers, but let's play it safe.  */
   buffer_defaults.indirections = 0;
   buffer_local_symbols.indirections = 0;
-  buffer_set_intervals (&buffer_defaults, NULL);
-  buffer_set_intervals (&buffer_local_symbols, NULL);
+  set_buffer_intervals (&buffer_defaults, NULL);
+  set_buffer_intervals (&buffer_local_symbols, NULL);
   XSETPVECTYPESIZE (&buffer_defaults, PVEC_BUFFER, pvecsize);
   XSETBUFFER (Vbuffer_defaults, &buffer_defaults);
   XSETPVECTYPESIZE (&buffer_local_symbols, PVEC_BUFFER, pvecsize);
@@ -4924,55 +5162,55 @@ init_buffer_once (void)
   /* Must do these before making the first buffer! */
 
   /* real setup is done in bindings.el */
-  BSET (&buffer_defaults, mode_line_format, build_pure_c_string ("%-"));
-  BSET (&buffer_defaults, header_line_format, Qnil);
-  BSET (&buffer_defaults, abbrev_mode, Qnil);
-  BSET (&buffer_defaults, overwrite_mode, Qnil);
-  BSET (&buffer_defaults, case_fold_search, Qt);
-  BSET (&buffer_defaults, auto_fill_function, Qnil);
-  BSET (&buffer_defaults, selective_display, Qnil);
-  BSET (&buffer_defaults, selective_display_ellipses, Qt);
-  BSET (&buffer_defaults, abbrev_table, Qnil);
-  BSET (&buffer_defaults, display_table, Qnil);
-  BSET (&buffer_defaults, undo_list, Qnil);
-  BSET (&buffer_defaults, mark_active, Qnil);
-  BSET (&buffer_defaults, file_format, Qnil);
-  BSET (&buffer_defaults, auto_save_file_format, Qt);
-  buffer_set_overlays_before (&buffer_defaults, NULL);
-  buffer_set_overlays_after (&buffer_defaults, NULL);
+  bset_mode_line_format (&buffer_defaults, build_pure_c_string ("%-"));
+  bset_header_line_format (&buffer_defaults, Qnil);
+  bset_abbrev_mode (&buffer_defaults, Qnil);
+  bset_overwrite_mode (&buffer_defaults, Qnil);
+  bset_case_fold_search (&buffer_defaults, Qt);
+  bset_auto_fill_function (&buffer_defaults, Qnil);
+  bset_selective_display (&buffer_defaults, Qnil);
+  bset_selective_display_ellipses (&buffer_defaults, Qt);
+  bset_abbrev_table (&buffer_defaults, Qnil);
+  bset_display_table (&buffer_defaults, Qnil);
+  bset_undo_list (&buffer_defaults, Qnil);
+  bset_mark_active (&buffer_defaults, Qnil);
+  bset_file_format (&buffer_defaults, Qnil);
+  bset_auto_save_file_format (&buffer_defaults, Qt);
+  set_buffer_overlays_before (&buffer_defaults, NULL);
+  set_buffer_overlays_after (&buffer_defaults, NULL);
   buffer_defaults.overlay_center = BEG;
 
   XSETFASTINT (BVAR (&buffer_defaults, tab_width), 8);
-  BSET (&buffer_defaults, truncate_lines, Qnil);
-  BSET (&buffer_defaults, word_wrap, Qnil);
-  BSET (&buffer_defaults, ctl_arrow, Qt);
-  BSET (&buffer_defaults, bidi_display_reordering, Qt);
-  BSET (&buffer_defaults, bidi_paragraph_direction, Qnil);
-  BSET (&buffer_defaults, cursor_type, Qt);
-  BSET (&buffer_defaults, extra_line_spacing, Qnil);
-  BSET (&buffer_defaults, cursor_in_non_selected_windows, Qt);
-
-  BSET (&buffer_defaults, enable_multibyte_characters, Qt);
-  BSET (&buffer_defaults, buffer_file_coding_system, Qnil);
+  bset_truncate_lines (&buffer_defaults, Qnil);
+  bset_word_wrap (&buffer_defaults, Qnil);
+  bset_ctl_arrow (&buffer_defaults, Qt);
+  bset_bidi_display_reordering (&buffer_defaults, Qt);
+  bset_bidi_paragraph_direction (&buffer_defaults, Qnil);
+  bset_cursor_type (&buffer_defaults, Qt);
+  bset_extra_line_spacing (&buffer_defaults, Qnil);
+  bset_cursor_in_non_selected_windows (&buffer_defaults, Qt);
+
+  bset_enable_multibyte_characters (&buffer_defaults, Qt);
+  bset_buffer_file_coding_system (&buffer_defaults, Qnil);
   XSETFASTINT (BVAR (&buffer_defaults, fill_column), 70);
   XSETFASTINT (BVAR (&buffer_defaults, left_margin), 0);
-  BSET (&buffer_defaults, cache_long_line_scans, Qnil);
-  BSET (&buffer_defaults, file_truename, Qnil);
+  bset_cache_long_line_scans (&buffer_defaults, Qnil);
+  bset_file_truename (&buffer_defaults, Qnil);
   XSETFASTINT (BVAR (&buffer_defaults, display_count), 0);
   XSETFASTINT (BVAR (&buffer_defaults, left_margin_cols), 0);
   XSETFASTINT (BVAR (&buffer_defaults, right_margin_cols), 0);
-  BSET (&buffer_defaults, left_fringe_width, Qnil);
-  BSET (&buffer_defaults, right_fringe_width, Qnil);
-  BSET (&buffer_defaults, fringes_outside_margins, Qnil);
-  BSET (&buffer_defaults, scroll_bar_width, Qnil);
-  BSET (&buffer_defaults, vertical_scroll_bar_type, Qt);
-  BSET (&buffer_defaults, indicate_empty_lines, Qnil);
-  BSET (&buffer_defaults, indicate_buffer_boundaries, Qnil);
-  BSET (&buffer_defaults, fringe_indicator_alist, Qnil);
-  BSET (&buffer_defaults, fringe_cursor_alist, Qnil);
-  BSET (&buffer_defaults, scroll_up_aggressively, Qnil);
-  BSET (&buffer_defaults, scroll_down_aggressively, Qnil);
-  BSET (&buffer_defaults, display_time, Qnil);
+  bset_left_fringe_width (&buffer_defaults, Qnil);
+  bset_right_fringe_width (&buffer_defaults, Qnil);
+  bset_fringes_outside_margins (&buffer_defaults, Qnil);
+  bset_scroll_bar_width (&buffer_defaults, Qnil);
+  bset_vertical_scroll_bar_type (&buffer_defaults, Qt);
+  bset_indicate_empty_lines (&buffer_defaults, Qnil);
+  bset_indicate_buffer_boundaries (&buffer_defaults, Qnil);
+  bset_fringe_indicator_alist (&buffer_defaults, Qnil);
+  bset_fringe_cursor_alist (&buffer_defaults, Qnil);
+  bset_scroll_up_aggressively (&buffer_defaults, Qnil);
+  bset_scroll_down_aggressively (&buffer_defaults, Qnil);
+  bset_display_time (&buffer_defaults, Qnil);
 
   /* Assign the local-flags to the slots that have default values.
      The local flag is a bit that is used in the buffer
@@ -4984,24 +5222,24 @@ init_buffer_once (void)
 
   /* 0 means not a lisp var, -1 means always local, else mask */
   memset (&buffer_local_flags, 0, sizeof buffer_local_flags);
-  BSET (&buffer_local_flags, filename, make_number (-1));
-  BSET (&buffer_local_flags, directory, make_number (-1));
-  BSET (&buffer_local_flags, backed_up, make_number (-1));
-  BSET (&buffer_local_flags, save_length, make_number (-1));
-  BSET (&buffer_local_flags, auto_save_file_name, make_number (-1));
-  BSET (&buffer_local_flags, read_only, make_number (-1));
-  BSET (&buffer_local_flags, major_mode, make_number (-1));
-  BSET (&buffer_local_flags, mode_name, make_number (-1));
-  BSET (&buffer_local_flags, undo_list, make_number (-1));
-  BSET (&buffer_local_flags, mark_active, make_number (-1));
-  BSET (&buffer_local_flags, point_before_scroll, make_number (-1));
-  BSET (&buffer_local_flags, file_truename, make_number (-1));
-  BSET (&buffer_local_flags, invisibility_spec, make_number (-1));
-  BSET (&buffer_local_flags, file_format, make_number (-1));
-  BSET (&buffer_local_flags, auto_save_file_format, make_number (-1));
-  BSET (&buffer_local_flags, display_count, make_number (-1));
-  BSET (&buffer_local_flags, display_time, make_number (-1));
-  BSET (&buffer_local_flags, enable_multibyte_characters, make_number (-1));
+  bset_filename (&buffer_local_flags, make_number (-1));
+  bset_directory (&buffer_local_flags, make_number (-1));
+  bset_backed_up (&buffer_local_flags, make_number (-1));
+  bset_save_length (&buffer_local_flags, make_number (-1));
+  bset_auto_save_file_name (&buffer_local_flags, make_number (-1));
+  bset_read_only (&buffer_local_flags, make_number (-1));
+  bset_major_mode (&buffer_local_flags, make_number (-1));
+  bset_mode_name (&buffer_local_flags, make_number (-1));
+  bset_undo_list (&buffer_local_flags, make_number (-1));
+  bset_mark_active (&buffer_local_flags, make_number (-1));
+  bset_point_before_scroll (&buffer_local_flags, make_number (-1));
+  bset_file_truename (&buffer_local_flags, make_number (-1));
+  bset_invisibility_spec (&buffer_local_flags, make_number (-1));
+  bset_file_format (&buffer_local_flags, make_number (-1));
+  bset_auto_save_file_format (&buffer_local_flags, make_number (-1));
+  bset_display_count (&buffer_local_flags, make_number (-1));
+  bset_display_time (&buffer_local_flags, make_number (-1));
+  bset_enable_multibyte_characters (&buffer_local_flags, make_number (-1));
 
   idx = 1;
   XSETFASTINT (BVAR (&buffer_local_flags, mode_line_format), idx); ++idx;
@@ -5057,7 +5295,7 @@ init_buffer_once (void)
   QSFundamental = build_pure_c_string ("Fundamental");
 
   Qfundamental_mode = intern_c_string ("fundamental-mode");
-  BSET (&buffer_defaults, major_mode, Qfundamental_mode);
+  bset_major_mode (&buffer_defaults, Qfundamental_mode);
 
   Qmode_class = intern_c_string ("mode-class");
 
@@ -5120,13 +5358,13 @@ init_buffer (void)
       len++;
     }
 
-  BSET (current_buffer, directory, make_unibyte_string (pwd, len));
+  bset_directory (current_buffer, make_unibyte_string (pwd, len));
   if (! NILP (BVAR (&buffer_defaults, enable_multibyte_characters)))
     /* At this moment, we still don't know how to decode the
        directory name.  So, we keep the bytes in multibyte form so
        that ENCODE_FILE correctly gets the original bytes.  */
-    BSET (current_buffer, directory,
-         string_to_multibyte (BVAR (current_buffer, directory)));
+    bset_directory
+      (current_buffer, string_to_multibyte (BVAR (current_buffer, directory)));
 
   /* Add /: to the front of the name
      if it would otherwise be treated as magic.  */
@@ -5137,11 +5375,12 @@ init_buffer (void)
          However, it is not necessary to turn / into /:/.
          So avoid doing that.  */
       && strcmp ("/", SSDATA (BVAR (current_buffer, directory))))
-    BSET (current_buffer, directory,
-         concat2 (build_string ("/:"), BVAR (current_buffer, directory)));
+    bset_directory
+      (current_buffer,
+       concat2 (build_string ("/:"), BVAR (current_buffer, directory)));
 
   temp = get_minibuffer (0);
-  BSET (XBUFFER (temp), directory, BVAR (current_buffer, directory));
+  bset_directory (XBUFFER (temp), BVAR (current_buffer, directory));
 
   free (pwd);
 }
diff --git a/src/buffer.h b/src/buffer.h
index 7a6bddee5ec..510a8e55682 100644
--- a/src/buffer.h
+++ b/src/buffer.h
@@ -477,7 +477,6 @@ struct buffer_text
 /* Most code should use this macro to access Lisp fields in struct buffer.  */
 
 #define BVAR(buf, field) ((buf)->INTERNAL_FIELD (field))
-#define BSET(buf, field, value) ((buf)->INTERNAL_FIELD (field) = (value))
 
 /* This is the structure that the buffer Lisp object points to.  */
 
@@ -862,6 +861,104 @@ struct buffer
   Lisp_Object INTERNAL_FIELD (undo_list);
 };
 
+/* Most code should use these functions to set Lisp fields in struct
+   buffer.  */
+BUFFER_INLINE void
+bset_bidi_paragraph_direction (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (bidi_paragraph_direction) = val;
+}
+BUFFER_INLINE void
+bset_case_canon_table (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (case_canon_table) = val;
+}
+BUFFER_INLINE void
+bset_case_eqv_table (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (case_eqv_table) = val;
+}
+BUFFER_INLINE void
+bset_directory (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (directory) = val;
+}
+BUFFER_INLINE void
+bset_display_count (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (display_count) = val;
+}
+BUFFER_INLINE void
+bset_display_time (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (display_time) = val;
+}
+BUFFER_INLINE void
+bset_downcase_table (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (downcase_table) = val;
+}
+BUFFER_INLINE void
+bset_enable_multibyte_characters (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (enable_multibyte_characters) = val;
+}
+BUFFER_INLINE void
+bset_filename (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (filename) = val;
+}
+BUFFER_INLINE void
+bset_keymap (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (keymap) = val;
+}
+BUFFER_INLINE void
+bset_last_selected_window (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (last_selected_window) = val;
+}
+BUFFER_INLINE void
+bset_local_var_alist (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (local_var_alist) = val;
+}
+BUFFER_INLINE void
+bset_mark_active (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (mark_active) = val;
+}
+BUFFER_INLINE void
+bset_point_before_scroll (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (point_before_scroll) = val;
+}
+BUFFER_INLINE void
+bset_read_only (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (read_only) = val;
+}
+BUFFER_INLINE void
+bset_truncate_lines (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (truncate_lines) = val;
+}
+BUFFER_INLINE void
+bset_undo_list (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (undo_list) = val;
+}
+BUFFER_INLINE void
+bset_upcase_table (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (upcase_table) = val;
+}
+BUFFER_INLINE void
+bset_width_table (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (width_table) = val;
+}
+
 
 /* Chain of all buffers, including killed ones.  */
 
@@ -953,7 +1050,7 @@ extern Lisp_Object Qfirst_change_hook;
 /* Get text properties of B.  */
 
 BUFFER_INLINE INTERVAL
-buffer_get_intervals (struct buffer *b)
+buffer_intervals (struct buffer *b)
 {
   eassert (b->text != NULL);
   return b->text->intervals;
@@ -962,26 +1059,12 @@ buffer_get_intervals (struct buffer *b)
 /* Set text properties of B to I.  */
 
 BUFFER_INLINE void
-buffer_set_intervals (struct buffer *b, INTERVAL i)
+set_buffer_intervals (struct buffer *b, INTERVAL i)
 {
   eassert (b->text != NULL);
   b->text->intervals = i;
 }
 
-/* Set an appropriate overlay of B.  */
-
-BUFFER_INLINE void
-buffer_set_overlays_before (struct buffer *b, struct Lisp_Overlay *o)
-{
-  b->overlays_before = o;
-}
-
-BUFFER_INLINE void
-buffer_set_overlays_after (struct buffer *b, struct Lisp_Overlay *o)
-{
-  b->overlays_after = o;
-}
-
 /* Non-zero if current buffer has overlays.  */
 
 BUFFER_INLINE int
diff --git a/src/callint.c b/src/callint.c
index e0133864674..36a59e812f2 100644
--- a/src/callint.c
+++ b/src/callint.c
@@ -372,7 +372,7 @@ invoke it.  If KEYS is omitted or nil, the return value of
       Vthis_command = save_this_command;
       Vthis_original_command = save_this_original_command;
       Vreal_this_command = save_real_this_command;
-      KSET (current_kboard, Vlast_command, save_last_command);
+      kset_last_command (current_kboard, save_last_command);
 
       temporarily_switch_to_single_kboard (NULL);
       return unbind_to (speccount, apply1 (function, specs));
@@ -843,7 +843,7 @@ invoke it.  If KEYS is omitted or nil, the return value of
   Vthis_command = save_this_command;
   Vthis_original_command = save_this_original_command;
   Vreal_this_command = save_real_this_command;
-  KSET (current_kboard, Vlast_command, save_last_command);
+  kset_last_command (current_kboard, save_last_command);
 
   {
     Lisp_Object val;
diff --git a/src/casetab.c b/src/casetab.c
index 4b29c091ca9..a163d5204f8 100644
--- a/src/casetab.c
+++ b/src/casetab.c
@@ -128,13 +128,13 @@ set_case_table (Lisp_Object table, int standard)
       up = Fmake_char_table (Qcase_table, Qnil);
       map_char_table (set_identity, Qnil, table, up);
       map_char_table (shuffle, Qnil, table, up);
-      XCHAR_TABLE (table)->extras[0] = up;
+      set_char_table_extras (table, 0, up);
     }
 
   if (NILP (canon))
     {
       canon = Fmake_char_table (Qcase_table, Qnil);
-      XCHAR_TABLE (table)->extras[1] = canon;
+      set_char_table_extras (table, 1, canon);
       map_char_table (set_canon, Qnil, table, table);
     }
 
@@ -143,11 +143,11 @@ set_case_table (Lisp_Object table, int standard)
       eqv = Fmake_char_table (Qcase_table, Qnil);
       map_char_table (set_identity, Qnil, canon, eqv);
       map_char_table (shuffle, Qnil, canon, eqv);
-      XCHAR_TABLE (table)->extras[2] = eqv;
+      set_char_table_extras (table, 2, eqv);
     }
 
   /* This is so set_image_of_range_1 in regex.c can find the EQV table.  */
-  XCHAR_TABLE (canon)->extras[2] = eqv;
+  set_char_table_extras (canon, 2, eqv);
 
   if (standard)
     {
@@ -158,10 +158,10 @@ set_case_table (Lisp_Object table, int standard)
     }
   else
     {
-      BSET (current_buffer, downcase_table, table);
-      BSET (current_buffer, upcase_table, up);
-      BSET (current_buffer, case_canon_table, canon);
-      BSET (current_buffer, case_eqv_table, eqv);
+      bset_downcase_table (current_buffer, table);
+      bset_upcase_table (current_buffer, up);
+      bset_case_canon_table (current_buffer, canon);
+      bset_case_eqv_table (current_buffer, eqv);
     }
 
   return table;
@@ -260,7 +260,7 @@ init_casetab_once (void)
 
   down = Fmake_char_table (Qcase_table, Qnil);
   Vascii_downcase_table = down;
-  XCHAR_TABLE (down)->purpose = Qcase_table;
+  set_char_table_purpose (down, Qcase_table);
 
   for (i = 0; i < 128; i++)
     {
@@ -268,10 +268,10 @@ init_casetab_once (void)
       CHAR_TABLE_SET (down, i, make_number (c));
     }
 
-  XCHAR_TABLE (down)->extras[1] = Fcopy_sequence (down);
+  set_char_table_extras (down, 1, Fcopy_sequence (down));
 
   up = Fmake_char_table (Qcase_table, Qnil);
-  XCHAR_TABLE (down)->extras[0] = up;
+  set_char_table_extras (down, 0, up);
 
   for (i = 0; i < 128; i++)
     {
@@ -281,7 +281,7 @@ init_casetab_once (void)
       CHAR_TABLE_SET (up, i, make_number (c));
     }
 
-  XCHAR_TABLE (down)->extras[2] = Fcopy_sequence (up);
+  set_char_table_extras (down, 2, Fcopy_sequence (up));
 
   /* Fill in what isn't filled in.  */
   set_case_table (down, 1);
diff --git a/src/category.c b/src/category.c
index 13c6e46d283..a9bbf596abc 100644
--- a/src/category.c
+++ b/src/category.c
@@ -32,7 +32,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #define CATEGORY_INLINE EXTERN_INLINE
 
-#include <ctype.h>
 #include <setjmp.h>
 #include "lisp.h"
 #include "character.h"
@@ -41,6 +40,13 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "category.h"
 #include "keymap.h"
 
+/* This setter is used only in this file, so it can be private.  */
+static inline void
+bset_category_table (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (category_table) = val;
+}
+
 /* The version number of the latest category table.  Each category
    table has a unique version number.  It is assigned a new number
    also when it is modified.  When a regular expression is compiled
@@ -71,11 +77,12 @@ hash_get_category_set (Lisp_Object table, Lisp_Object category_set)
   EMACS_UINT hash;
 
   if (NILP (XCHAR_TABLE (table)->extras[1]))
-    XCHAR_TABLE (table)->extras[1]
-      = make_hash_table (Qequal, make_number (DEFAULT_HASH_SIZE),
-                         make_float (DEFAULT_REHASH_SIZE),
-                         make_float (DEFAULT_REHASH_THRESHOLD),
-                         Qnil, Qnil, Qnil);
+    set_char_table_extras
+      (table, 1,
+       make_hash_table (Qequal, make_number (DEFAULT_HASH_SIZE),
+                        make_float (DEFAULT_REHASH_SIZE),
+                        make_float (DEFAULT_REHASH_THRESHOLD),
+                        Qnil, Qnil, Qnil));
   h = XHASH_TABLE (XCHAR_TABLE (table)->extras[1]);
   i = hash_lookup (h, category_set, &hash);
   if (i >= 0)
@@ -238,10 +245,10 @@ copy_category_table (Lisp_Object table)
   table = copy_char_table (table);
 
   if (! NILP (XCHAR_TABLE (table)->defalt))
-    XCHAR_TABLE (table)->defalt
-      = Fcopy_sequence (XCHAR_TABLE (table)->defalt);
-  XCHAR_TABLE (table)->extras[0]
-    = Fcopy_sequence (XCHAR_TABLE (table)->extras[0]);
+    set_char_table_defalt (table,
+                           Fcopy_sequence (XCHAR_TABLE (table)->defalt));
+  set_char_table_extras
+    (table, 0, Fcopy_sequence (XCHAR_TABLE (table)->extras[0]));
   map_char_table (copy_category_entry, Qnil, table, table);
 
   return table;
@@ -270,9 +277,9 @@ DEFUN ("make-category-table", Fmake_category_table, Smake_category_table,
   int i;
 
   val = Fmake_char_table (Qcategory_table, Qnil);
-  XCHAR_TABLE (val)->defalt = MAKE_CATEGORY_SET;
+  set_char_table_defalt (val, MAKE_CATEGORY_SET);
   for (i = 0; i < (1 << CHARTAB_SIZE_BITS_0); i++)
-    XCHAR_TABLE (val)->contents[i] = MAKE_CATEGORY_SET;
+    set_char_table_contents (val, i, MAKE_CATEGORY_SET);
   Fset_char_table_extra_slot (val, make_number (0),
                               Fmake_vector (make_number (95), Qnil));
   return val;
@@ -285,7 +292,7 @@ Return TABLE.  */)
 {
   int idx;
   table = check_category_table (table);
-  BSET (current_buffer, category_table, table);
+  bset_category_table (current_buffer, table);
   /* Indicate that this buffer now has a specified category table.  */
   idx = PER_BUFFER_VAR_IDX (category_table);
   SET_PER_BUFFER_VALUE_P (current_buffer, idx, 1);
@@ -466,7 +473,7 @@ init_category_once (void)
 
   Vstandard_category_table = Fmake_char_table (Qcategory_table, Qnil);
   /* Set a category set which contains nothing to the default.  */
-  XCHAR_TABLE (Vstandard_category_table)->defalt = MAKE_CATEGORY_SET;
+  set_char_table_defalt (Vstandard_category_table, MAKE_CATEGORY_SET);
   Fset_char_table_extra_slot (Vstandard_category_table, make_number (0),
                               Fmake_vector (make_number (95), Qnil));
 }
diff --git a/src/charset.c b/src/charset.c
index fbbcefc4915..87c16e12008 100644
--- a/src/charset.c
+++ b/src/charset.c
@@ -30,10 +30,10 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include <stdio.h>
 #include <unistd.h>
-#include <ctype.h>
 #include <limits.h>
 #include <sys/types.h>
 #include <setjmp.h>
+#include <c-ctype.h>
 #include "lisp.h"
 #include "character.h"
 #include "charset.h"
@@ -446,7 +446,7 @@ read_hex (FILE *fp, int *eof, int *overflow)
       return 0;
     }
   n = 0;
-  while (isxdigit (c = getc (fp)))
+  while (c_isxdigit (c = getc (fp)))
     {
       if (UINT_MAX >> 4 < n)
         *overflow = 1;
diff --git a/src/chartab.c b/src/chartab.c
index c022bc03e66..711a49ed397 100644
--- a/src/chartab.c
+++ b/src/chartab.c
@@ -115,8 +115,8 @@ the char-table has no extra slot.  */)
   size = VECSIZE (struct Lisp_Char_Table) - 1 + n_extras;
   vector = Fmake_vector (make_number (size), init);
   XSETPVECTYPE (XVECTOR (vector), PVEC_CHAR_TABLE);
-  XCHAR_TABLE (vector)->parent = Qnil;
-  XCHAR_TABLE (vector)->purpose = purpose;
+  set_char_table_parent (vector, Qnil);
+  set_char_table_purpose (vector, purpose);
   XSETCHAR_TABLE (vector, XCHAR_TABLE (vector));
   return vector;
 }
@@ -155,21 +155,17 @@ char_table_ascii (Lisp_Object table)
 static Lisp_Object
 copy_sub_char_table (Lisp_Object table)
 {
-  Lisp_Object copy;
   int depth = XINT (XSUB_CHAR_TABLE (table)->depth);
   int min_char = XINT (XSUB_CHAR_TABLE (table)->min_char);
-  Lisp_Object val;
+  Lisp_Object copy = make_sub_char_table (depth, min_char, Qnil);
   int i;
 
-  copy = make_sub_char_table (depth, min_char, Qnil);
   /* Recursively copy any sub char-tables.  */
   for (i = 0; i < chartab_size[depth]; i++)
     {
-      val = XSUB_CHAR_TABLE (table)->contents[i];
-      if (SUB_CHAR_TABLE_P (val))
-        XSUB_CHAR_TABLE (copy)->contents[i] = copy_sub_char_table (val);
-      else
-        XSUB_CHAR_TABLE (copy)->contents[i] = val;
+      Lisp_Object val = XSUB_CHAR_TABLE (table)->contents[i];
+      set_sub_char_table_contents
+        (copy, i, SUB_CHAR_TABLE_P (val) ? copy_sub_char_table (val) : val);
     }
 
   return copy;
@@ -185,18 +181,19 @@ copy_char_table (Lisp_Object table)
 
   copy = Fmake_vector (make_number (size), Qnil);
   XSETPVECTYPE (XVECTOR (copy), PVEC_CHAR_TABLE);
-  XCHAR_TABLE (copy)->defalt = XCHAR_TABLE (table)->defalt;
-  XCHAR_TABLE (copy)->parent = XCHAR_TABLE (table)->parent;
-  XCHAR_TABLE (copy)->purpose = XCHAR_TABLE (table)->purpose;
+  set_char_table_defalt (copy, XCHAR_TABLE (table)->defalt);
+  set_char_table_parent (copy, XCHAR_TABLE (table)->parent);
+  set_char_table_purpose (copy, XCHAR_TABLE (table)->purpose);
   for (i = 0; i < chartab_size[0]; i++)
-    XCHAR_TABLE (copy)->contents[i]
-      = (SUB_CHAR_TABLE_P (XCHAR_TABLE (table)->contents[i])
-         ? copy_sub_char_table (XCHAR_TABLE (table)->contents[i])
-         : XCHAR_TABLE (table)->contents[i]);
-  XCHAR_TABLE (copy)->ascii = char_table_ascii (copy);
+    set_char_table_contents
+      (copy, i,
+       (SUB_CHAR_TABLE_P (XCHAR_TABLE (table)->contents[i])
+        ? copy_sub_char_table (XCHAR_TABLE (table)->contents[i])
+        : XCHAR_TABLE (table)->contents[i]));
+  set_char_table_ascii (copy, char_table_ascii (copy));
   size -= VECSIZE (struct Lisp_Char_Table) - 1;
   for (i = 0; i < size; i++)
-    XCHAR_TABLE (copy)->extras[i] = XCHAR_TABLE (table)->extras[i];
+    set_char_table_extras (copy, i, XCHAR_TABLE (table)->extras[i]);
 
   XSETCHAR_TABLE (copy, XCHAR_TABLE (copy));
   return copy;
@@ -394,7 +391,7 @@ sub_char_table_set (Lisp_Object table, int c, Lisp_Object val, int is_uniprop)
   Lisp_Object sub;
 
   if (depth == 3)
-    tbl->contents[i] = val;
+    set_sub_char_table_contents (table, i, val);
   else
     {
       sub = tbl->contents[i];
@@ -407,23 +404,21 @@ sub_char_table_set (Lisp_Object table, int c, Lisp_Object val, int is_uniprop)
               sub = make_sub_char_table (depth + 1,
                                          min_char + i * chartab_chars[depth],
                                          sub);
-              tbl->contents[i] = sub;
+              set_sub_char_table_contents (table, i, sub);
             }
         }
       sub_char_table_set (sub, c, val, is_uniprop);
     }
 }
 
-Lisp_Object
+void
 char_table_set (Lisp_Object table, int c, Lisp_Object val)
 {
   struct Lisp_Char_Table *tbl = XCHAR_TABLE (table);
 
   if (ASCII_CHAR_P (c)
       && SUB_CHAR_TABLE_P (tbl->ascii))
-    {
-      XSUB_CHAR_TABLE (tbl->ascii)->contents[c] = val;
-    }
+    set_sub_char_table_contents (tbl->ascii, c, val);
   else
     {
       int i = CHARTAB_IDX (c, 0, 0);
@@ -433,13 +428,12 @@ char_table_set (Lisp_Object table, int c, Lisp_Object val)
       if (! SUB_CHAR_TABLE_P (sub))
         {
           sub = make_sub_char_table (1, i * chartab_chars[0], sub);
-          tbl->contents[i] = sub;
+          set_char_table_contents (table, i, sub);
         }
       sub_char_table_set (sub, c, val, UNIPROP_TABLE_P (table));
       if (ASCII_CHAR_P (c))
-        tbl->ascii = char_table_ascii (table);
+        set_char_table_ascii (table, char_table_ascii (table));
     }
-  return val;
 }
 
 static void
@@ -461,7 +455,7 @@ sub_char_table_set_range (Lisp_Object table, int from, int to, Lisp_Object val,
       if (c > to)
         break;
       if (from <= c && c + chars_in_block - 1 <= to)
-        tbl->contents[i] = val;
+        set_sub_char_table_contents (table, i, val);
       else
         {
           Lisp_Object sub = tbl->contents[i];
@@ -472,7 +466,7 @@ sub_char_table_set_range (Lisp_Object table, int from, int to, Lisp_Object val,
               else
                 {
                   sub = make_sub_char_table (depth + 1, c, sub);
-                  tbl->contents[i] = sub;
+                  set_sub_char_table_contents (table, i, sub);
                 }
             }
           sub_char_table_set_range (sub, from, to, val, is_uniprop);
@@ -481,7 +475,7 @@ sub_char_table_set_range (Lisp_Object table, int from, int to, Lisp_Object val,
 }
 
 
-Lisp_Object
+void
 char_table_set_range (Lisp_Object table, int from, int to, Lisp_Object val)
 {
   struct Lisp_Char_Table *tbl = XCHAR_TABLE (table);
@@ -500,22 +494,21 @@ char_table_set_range (Lisp_Object table, int from, int to, Lisp_Object val)
           if (c > to)
             break;
           if (from <= c && c + chartab_chars[0] - 1 <= to)
-            tbl->contents[i] = val;
+            set_char_table_contents (table, i, val);
           else
             {
               Lisp_Object sub = tbl->contents[i];
               if (! SUB_CHAR_TABLE_P (sub))
                 {
                   sub = make_sub_char_table (1, i * chartab_chars[0], sub);
-                  tbl->contents[i] = sub;
+                  set_char_table_contents (table, i, sub);
                 }
               sub_char_table_set_range (sub, from, to, val, is_uniprop);
             }
         }
       if (ASCII_CHAR_P (from))
-        tbl->ascii = char_table_ascii (table);
+        set_char_table_ascii (table, char_table_ascii (table));
     }
-  return val;
 }
 
 
@@ -563,7 +556,7 @@ Return PARENT.  PARENT must be either nil or another char-table.  */)
           error ("Attempt to make a chartable be its own parent");
     }
 
-  XCHAR_TABLE (char_table)->parent = parent;
+  set_char_table_parent (char_table, parent);
 
   return parent;
 }
@@ -594,7 +587,8 @@ DEFUN ("set-char-table-extra-slot", Fset_char_table_extra_slot,
       || XINT (n) >= CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (char_table)))
     args_out_of_range (char_table, n);
 
-  return XCHAR_TABLE (char_table)->extras[XINT (n)] = value;
+  set_char_table_extras (char_table, XINT (n), value);
+  return value;
 }
 
 DEFUN ("char-table-range", Fchar_table_range, Schar_table_range,
@@ -640,12 +634,12 @@ or a character code.  Return VALUE.  */)
     {
       int i;
 
-      XCHAR_TABLE (char_table)->ascii = value;
+      set_char_table_ascii (char_table, value);
       for (i = 0; i < chartab_size[0]; i++)
-        XCHAR_TABLE (char_table)->contents[i] = value;
+        set_char_table_contents (char_table, i, value);
     }
   else if (EQ (range, Qnil))
-    XCHAR_TABLE (char_table)->defalt = value;
+    set_char_table_defalt (char_table, value);
   else if (CHARACTERP (range))
     char_table_set (char_table, XINT (range), value);
   else if (CONSP (range))
@@ -693,15 +687,19 @@ optimize_sub_char_table (Lisp_Object table, Lisp_Object test)
 
   elt = XSUB_CHAR_TABLE (table)->contents[0];
   if (SUB_CHAR_TABLE_P (elt))
-    elt = XSUB_CHAR_TABLE (table)->contents[0]
-      = optimize_sub_char_table (elt, test);
+    {
+      elt = optimize_sub_char_table (elt, test);
+      set_sub_char_table_contents (table, 0, elt);
+    }
   optimizable = SUB_CHAR_TABLE_P (elt) ? 0 : 1;
   for (i = 1; i < chartab_size[depth]; i++)
     {
       this = XSUB_CHAR_TABLE (table)->contents[i];
       if (SUB_CHAR_TABLE_P (this))
-        this = XSUB_CHAR_TABLE (table)->contents[i]
-          = optimize_sub_char_table (this, test);
+        {
+          this = optimize_sub_char_table (this, test);
+          set_sub_char_table_contents (table, i, this);
+        }
       if (optimizable
           && (NILP (test) ? NILP (Fequal (this, elt)) /* defaults to `equal'. */
               : EQ (test, Qeq) ? !EQ (this, elt)      /* Optimize `eq' case.  */
@@ -728,11 +726,11 @@ equivalent and can be merged.  It defaults to `equal'.  */)
     {
       elt = XCHAR_TABLE (char_table)->contents[i];
       if (SUB_CHAR_TABLE_P (elt))
-        XCHAR_TABLE (char_table)->contents[i]
-          = optimize_sub_char_table (elt, test);
+        set_char_table_contents
+          (char_table, i, optimize_sub_char_table (elt, test));
     }
   /* Reset the `ascii' cache, in case it got optimized away.  */
-  XCHAR_TABLE (char_table)->ascii = char_table_ascii (char_table);
+  set_char_table_ascii (char_table, char_table_ascii (char_table));
 
   return Qnil;
 }
@@ -824,9 +822,9 @@ map_sub_char_table (void (*c_function) (Lisp_Object, Lisp_Object, Lisp_Object),
 
                       /* This is to get a value of FROM in PARENT
                          without checking the parent of PARENT.  */
-                      XCHAR_TABLE (parent)->parent = Qnil;
+                      set_char_table_parent (parent, Qnil);
                       val = CHAR_TABLE_REF (parent, from);
-                      XCHAR_TABLE (parent)->parent = temp;
+                      set_char_table_parent (parent, temp);
                       XSETCDR (range, make_number (c - 1));
                       val = map_sub_char_table (c_function, function,
                                                 parent, arg, val, range,
@@ -906,9 +904,9 @@ map_char_table (void (*c_function) (Lisp_Object, Lisp_Object, Lisp_Object),
       temp = XCHAR_TABLE (parent)->parent;
       /* This is to get a value of FROM in PARENT without checking the
          parent of PARENT.  */
-      XCHAR_TABLE (parent)->parent = Qnil;
+      set_char_table_parent (parent, Qnil);
       val = CHAR_TABLE_REF (parent, from);
-      XCHAR_TABLE (parent)->parent = temp;
+      set_char_table_parent (parent, temp);
       val = map_sub_char_table (c_function, function, parent, arg, val, range,
                                 parent);
       table = parent;
@@ -1143,10 +1141,9 @@ uniprop_table_uncompress (Lisp_Object table, int idx)
   int min_char = (XINT (XSUB_CHAR_TABLE (table)->min_char)
                   + chartab_chars[2] * idx);
   Lisp_Object sub = make_sub_char_table (3, min_char, Qnil);
-  struct Lisp_Sub_Char_Table *subtbl = XSUB_CHAR_TABLE (sub);
   const unsigned char *p, *pend;
 
-  XSUB_CHAR_TABLE (table)->contents[idx] = sub;
+  set_sub_char_table_contents (table, idx, sub);
   p = SDATA (val), pend = p + SBYTES (val);
   if (*p == 1)
     {
@@ -1156,7 +1153,8 @@ uniprop_table_uncompress (Lisp_Object table, int idx)
       while (p < pend && idx < chartab_chars[2])
         {
           int v = STRING_CHAR_ADVANCE (p);
-          subtbl->contents[idx++] = v > 0 ? make_number (v) : Qnil;
+          set_sub_char_table_contents
+            (sub, idx++, v > 0 ? make_number (v) : Qnil);
         }
     }
   else if (*p == 2)
@@ -1181,7 +1179,7 @@ uniprop_table_uncompress (Lisp_Object table, int idx)
                 }
             }
           while (count-- > 0)
-            subtbl->contents[idx++] = make_number (v);
+            set_sub_char_table_contents (sub, idx++, make_number (v));
         }
     }
 /* It seems that we don't need this function because C code won't need
@@ -1284,7 +1282,7 @@ uniprop_encode_value_numeric (Lisp_Object table, Lisp_Object value)
 
       args[0] = XCHAR_TABLE (table)->extras[4];
       args[1] = Fmake_vector (make_number (1), value);
-      XCHAR_TABLE (table)->extras[4] = Fvconcat (2, args);
+      set_char_table_extras (table, 4, Fvconcat (2, args));
     }
   return make_number (i);
 }
@@ -1346,7 +1344,7 @@ uniprop_table (Lisp_Object prop)
       : ! NILP (val))
     return Qnil;
   /* Prepare ASCII values in advance for CHAR_TABLE_REF.  */
-  XCHAR_TABLE (table)->ascii = char_table_ascii (table);
+  set_char_table_ascii (table, char_table_ascii (table));
   return table;
 }
 
diff --git a/src/cmds.c b/src/cmds.c
index 24778fae6e3..b416135ee9e 100644
--- a/src/cmds.c
+++ b/src/cmds.c
@@ -301,7 +301,7 @@ At the end, it runs `post-self-insert-hook'.  */)
          added be explicit calls to undo-boundary.  */
       && EQ (BVAR (current_buffer, undo_list), last_undo_boundary))
     /* Remove the undo_boundary that was just pushed.  */
-    BSET (current_buffer, undo_list, XCDR (BVAR (current_buffer, undo_list)));
+    bset_undo_list (current_buffer, XCDR (BVAR (current_buffer, undo_list)));
 
   /* Barf if the key that invoked this was not a character.  */
   if (!CHARACTERP (last_command_event))
diff --git a/src/coding.c b/src/coding.c
index c601a18b26e..971686dc180 100644
--- a/src/coding.c
+++ b/src/coding.c
@@ -7112,7 +7112,7 @@ decode_coding (struct coding_system *coding)
         record_first_change ();
 
       undo_list = BVAR (current_buffer, undo_list);
-      BSET (current_buffer, undo_list, Qt);
+      bset_undo_list (current_buffer, Qt);
     }
 
   coding->consumed = coding->consumed_char = 0;
@@ -7209,7 +7209,7 @@ decode_coding (struct coding_system *coding)
     decode_eol (coding);
   if (BUFFERP (coding->dst_object))
     {
-      BSET (current_buffer, undo_list, undo_list);
+      bset_undo_list (current_buffer, undo_list);
       record_insert (coding->dst_pos, coding->produced_char);
     }
   return coding->result;
@@ -7577,8 +7577,8 @@ make_conversion_work_buffer (int multibyte)
      doesn't compile new regexps.  */
   Fset (Fmake_local_variable (Qinhibit_modification_hooks), Qt);
   Ferase_buffer ();
-  BSET (current_buffer, undo_list, Qt);
-  BSET (current_buffer, enable_multibyte_characters, multibyte ? Qt : Qnil);
+  bset_undo_list (current_buffer, Qt);
+  bset_enable_multibyte_characters (current_buffer, multibyte ? Qt : Qnil);
   set_buffer_internal (current);
   return workbuf;
 }
@@ -9302,10 +9302,10 @@ DEFUN ("set-terminal-coding-system-internal", Fset_terminal_coding_system_intern
   terminal_coding->common_flags &= ~CODING_ANNOTATE_COMPOSITION_MASK;
   terminal_coding->src_multibyte = 1;
   terminal_coding->dst_multibyte = 0;
-  if (terminal_coding->common_flags & CODING_REQUIRE_ENCODING_MASK)
-    TSET (term, charset_list, coding_charset_list (terminal_coding));
-  else
-    TSET (term, charset_list, Fcons (make_number (charset_ascii), Qnil));
+  tset_charset_list
+    (term, (terminal_coding->common_flags & CODING_REQUIRE_ENCODING_MASK
+            ? coding_charset_list (terminal_coding)
+            : Fcons (make_number (charset_ascii), Qnil)));
   return Qnil;
 }
 
diff --git a/src/data.c b/src/data.c
index d0ef5734abc..ea511824e6d 100644
--- a/src/data.c
+++ b/src/data.c
@@ -543,7 +543,7 @@ DEFUN ("boundp", Fboundp, Sboundp, 1, 1, 0,
         else
           {
             swap_in_symval_forwarding (sym, blv);
-            valcontents = BLV_VALUE (blv);
+            valcontents = blv_value (blv);
           }
         break;
       }
@@ -964,16 +964,16 @@ swap_in_global_binding (struct Lisp_Symbol *symbol)
 
   /* Unload the previously loaded binding.  */
   if (blv->fwd)
-    SET_BLV_VALUE (blv, do_symval_forwarding (blv->fwd));
+    set_blv_value (blv, do_symval_forwarding (blv->fwd));
 
   /* Select the global binding in the symbol.  */
-  blv->valcell = blv->defcell;
+  set_blv_valcell (blv, blv->defcell);
   if (blv->fwd)
     store_symval_forwarding (blv->fwd, XCDR (blv->defcell), NULL);
 
   /* Indicate that the global binding is set up now.  */
-  blv->where = Qnil;
-  SET_BLV_FOUND (blv, 0);
+  set_blv_where (blv, Qnil);
+  set_blv_found (blv, 0);
 }
 
 /* Set up the buffer-local symbol SYMBOL for validity in the current buffer.
@@ -1001,7 +1001,7 @@ swap_in_symval_forwarding (struct Lisp_Symbol *symbol, struct Lisp_Buffer_Local_
       /* Unload the previously loaded binding.  */
       tem1 = blv->valcell;
       if (blv->fwd)
-        SET_BLV_VALUE (blv, do_symval_forwarding (blv->fwd));
+        set_blv_value (blv, do_symval_forwarding (blv->fwd));
       /* Choose the new binding.  */
       {
         Lisp_Object var;
@@ -1009,7 +1009,7 @@ swap_in_symval_forwarding (struct Lisp_Symbol *symbol, struct Lisp_Buffer_Local_
         if (blv->frame_local)
           {
             tem1 = assq_no_quit (var, XFRAME (selected_frame)->param_alist);
-            blv->where = selected_frame;
+            set_blv_where (blv, selected_frame);
           }
         else
           {
@@ -1021,9 +1021,9 @@ swap_in_symval_forwarding (struct Lisp_Symbol *symbol, struct Lisp_Buffer_Local_
         tem1 = blv->defcell;
 
       /* Load the new binding.  */
-      blv->valcell = tem1;
+      set_blv_valcell (blv, tem1);
       if (blv->fwd)
-        store_symval_forwarding (blv->fwd, BLV_VALUE (blv), NULL);
+        store_symval_forwarding (blv->fwd, blv_value (blv), NULL);
     }
 }
 
@@ -1050,7 +1050,7 @@ find_symbol_value (Lisp_Object symbol)
       {
         struct Lisp_Buffer_Local_Value *blv = SYMBOL_BLV (sym);
         swap_in_symval_forwarding (sym, blv);
-        return blv->fwd ? do_symval_forwarding (blv->fwd) : BLV_VALUE (blv);
+        return blv->fwd ? do_symval_forwarding (blv->fwd) : blv_value (blv);
       }
       /* FALLTHROUGH */
     case SYMBOL_FORWARDED:
@@ -1175,7 +1175,7 @@ set_internal (register Lisp_Object symbol, register Lisp_Object newval, register
 
             /* Write out `realvalue' to the old loaded binding.  */
             if (blv->fwd)
-              SET_BLV_VALUE (blv, do_symval_forwarding (blv->fwd));
+              set_blv_value (blv, do_symval_forwarding (blv->fwd));
 
             /* Find the new binding.  */
             XSETSYMBOL (symbol, sym); /* May have changed via aliasing.  */
@@ -1183,8 +1183,8 @@ set_internal (register Lisp_Object symbol, register Lisp_Object newval, register
                           (blv->frame_local
                            ? XFRAME (where)->param_alist
                            : BVAR (XBUFFER (where), local_var_alist)));
-            blv->where = where;
-            blv->found = 1;
+            set_blv_where (blv, where);
+            set_blv_found (blv, 1);
 
             if (NILP (tem1))
               {
@@ -1199,7 +1199,7 @@ set_internal (register Lisp_Object symbol, register Lisp_Object newval, register
                 if (bindflag || !blv->local_if_set
                     || let_shadows_buffer_binding_p (sym))
                   {
-                    blv->found = 0;
+                    set_blv_found (blv, 0);
                     tem1 = blv->defcell;
                   }
                 /* If it's a local_if_set, being set not bound,
@@ -1213,17 +1213,18 @@ set_internal (register Lisp_Object symbol, register Lisp_Object newval, register
                        bindings, not for frame-local bindings.  */
                     eassert (!blv->frame_local);
                     tem1 = Fcons (symbol, XCDR (blv->defcell));
-                    BSET (XBUFFER (where), local_var_alist,
-                          Fcons (tem1, BVAR (XBUFFER (where), local_var_alist)));
+                    bset_local_var_alist
+                      (XBUFFER (where),
+                       Fcons (tem1, BVAR (XBUFFER (where), local_var_alist)));
                   }
               }
 
             /* Record which binding is now loaded.  */
-            blv->valcell = tem1;
+            set_blv_valcell (blv, tem1);
           }
 
         /* Store the new value in the cons cell.  */
-        SET_BLV_VALUE (blv, newval);
+        set_blv_value (blv, newval);
 
         if (blv->fwd)
           {
@@ -1479,12 +1480,12 @@ make_blv (struct Lisp_Symbol *sym, int forwarded, union Lisp_Val_Fwd valcontents
   eassert (!(forwarded && BUFFER_OBJFWDP (valcontents.fwd)));
   eassert (!(forwarded && KBOARD_OBJFWDP (valcontents.fwd)));
   blv->fwd = forwarded ? valcontents.fwd : NULL;
-  blv->where = Qnil;
+  set_blv_where (blv, Qnil);
   blv->frame_local = 0;
   blv->local_if_set = 0;
-  blv->defcell = tem;
-  blv->valcell = tem;
-  SET_BLV_FOUND (blv, 0);
+  set_blv_defcell (blv, tem);
+  set_blv_valcell (blv, tem);
+  set_blv_found (blv, 0);
   return blv;
 }
 
@@ -1653,17 +1654,16 @@ Instead, use `add-hook' and specify t for the LOCAL argument.  */)
          default value.  */
       find_symbol_value (variable);
 
-      BSET (current_buffer, local_var_alist,
-            Fcons (Fcons (variable, XCDR (blv->defcell)),
-                   BVAR (current_buffer, local_var_alist)));
+      bset_local_var_alist
+        (current_buffer,
+         Fcons (Fcons (variable, XCDR (blv->defcell)),
+                BVAR (current_buffer, local_var_alist)));
 
       /* Make sure symbol does not think it is set up for this buffer;
          force it to look once again for this buffer's value.  */
       if (current_buffer == XBUFFER (blv->where))
-        blv->where = Qnil;
-      /* blv->valcell = blv->defcell;
-       * SET_BLV_FOUND (blv, 0); */
-      blv->found = 0;
+        set_blv_where (blv, Qnil);
+      set_blv_found (blv, 0);
     }
 
   /* If the symbol forwards into a C variable, then load the binding
@@ -1723,8 +1723,9 @@ From now on the default value will apply in this buffer.  Return VARIABLE.  */)
   XSETSYMBOL (variable, sym);   /* Propagate variable indirection.  */
   tem = Fassq (variable, BVAR (current_buffer, local_var_alist));
   if (!NILP (tem))
-    BSET (current_buffer, local_var_alist,
-          Fdelq (tem, BVAR (current_buffer, local_var_alist)));
+    bset_local_var_alist
+      (current_buffer,
+       Fdelq (tem, BVAR (current_buffer, local_var_alist)));
 
   /* If the symbol is set up with the current buffer's binding
      loaded, recompute its value.  We have to do it now, or else
@@ -1733,10 +1734,8 @@ From now on the default value will apply in this buffer.  Return VARIABLE.  */)
     Lisp_Object buf; XSETBUFFER (buf, current_buffer);
     if (EQ (buf, blv->where))
       {
-        blv->where = Qnil;
-        /* blv->valcell = blv->defcell;
-         * SET_BLV_FOUND (blv, 0); */
-        blv->found = 0;
+        set_blv_where (blv, Qnil);
+        set_blv_found (blv, 0);
         find_symbol_value (variable);
       }
   }
@@ -1857,11 +1856,11 @@ BUFFER defaults to the current buffer.  */)
             if (EQ (variable, XCAR (elt)))
               {
                 eassert (!blv->frame_local);
-                eassert (BLV_FOUND (blv) || !EQ (blv->where, tmp));
+                eassert (blv_found (blv) || !EQ (blv->where, tmp));
                 return Qt;
               }
           }
-        eassert (!BLV_FOUND (blv) || !EQ (blv->where, tmp));
+        eassert (!blv_found (blv) || !EQ (blv->where, tmp));
         return Qnil;
       }
     case SYMBOL_FORWARDED:
@@ -1951,7 +1950,7 @@ If the current binding is global (the default), the value is nil.  */)
       if (!NILP (Flocal_variable_p (variable, Qnil)))
         return Fcurrent_buffer ();
       else if (sym->redirect == SYMBOL_LOCALIZED
-               && BLV_FOUND (SYMBOL_BLV (sym)))
+               && blv_found (SYMBOL_BLV (sym)))
         return SYMBOL_BLV (sym)->where;
       else
         return Qnil;
diff --git a/src/dispnew.c b/src/dispnew.c
index 506e174850e..1078ebcb0b0 100644
--- a/src/dispnew.c
+++ b/src/dispnew.c
@@ -22,7 +22,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include <signal.h>
 #include <stdio.h>
-#include <ctype.h>
 #include <setjmp.h>
 #include <unistd.h>
 
@@ -626,7 +625,7 @@ adjust_glyph_matrix (struct window *w, struct glyph_matrix *matrix, int x, int y
                  are invalidated below.  */
               if (INTEGERP (w->window_end_vpos)
                   && XFASTINT (w->window_end_vpos) >= i)
-                WSET (w, window_end_valid, Qnil);
+                wset_window_end_valid (w, Qnil);
 
               while (i < matrix->nrows)
                 matrix->rows[i++].enabled_p = 0;
@@ -883,7 +882,7 @@ clear_window_matrices (struct window *w, int desired_p)
           else
             {
               clear_glyph_matrix (w->current_matrix);
-              WSET (w, window_end_valid, Qnil);
+              wset_window_end_valid (w, Qnil);
             }
         }
 
@@ -1892,14 +1891,14 @@ adjust_frame_glyphs_initially (void)
   int top_margin = FRAME_TOP_MARGIN (sf);
 
   /* Do it for the root window.  */
-  WSET (root, top_line, make_number (top_margin));
-  WSET (root, total_lines, make_number (frame_lines - 1 - top_margin));
-  WSET (root, total_cols, make_number (frame_cols));
+  wset_top_line (root, make_number (top_margin));
+  wset_total_lines (root, make_number (frame_lines - 1 - top_margin));
+  wset_total_cols (root, make_number (frame_cols));
 
   /* Do it for the mini-buffer window.  */
-  WSET (mini, top_line, make_number (frame_lines - 1));
-  WSET (mini, total_lines, make_number (1));
-  WSET (mini, total_cols, make_number (frame_cols));
+  wset_top_line (mini, make_number (frame_lines - 1));
+  wset_total_lines (mini, make_number (1));
+  wset_total_cols (mini, make_number (frame_cols));
 
   adjust_frame_glyphs (sf);
   glyphs_initialized_initially_p = 1;
@@ -2171,10 +2170,10 @@ adjust_frame_glyphs_for_window_redisplay (struct frame *f)
     if (NILP (f->menu_bar_window))
       {
         Lisp_Object frame;
-        FSET (f, menu_bar_window, make_window ());
+        fset_menu_bar_window (f, make_window ());
         w = XWINDOW (f->menu_bar_window);
         XSETFRAME (frame, f);
-        WSET (w, frame, frame);
+        wset_frame (w, frame);
         w->pseudo_window_p = 1;
       }
     else
@@ -2182,10 +2181,10 @@ adjust_frame_glyphs_for_window_redisplay (struct frame *f)
 
     /* Set window dimensions to frame dimensions and allocate or
        adjust glyph matrices of W.  */
-    WSET (w, top_line, make_number (0));
-    WSET (w, left_col, make_number (0));
-    WSET (w, total_lines, make_number (FRAME_MENU_BAR_LINES (f)));
-    WSET (w, total_cols, make_number (FRAME_TOTAL_COLS (f)));
+    wset_top_line (w, make_number (0));
+    wset_left_col (w, make_number (0));
+    wset_total_lines (w, make_number (FRAME_MENU_BAR_LINES (f)));
+    wset_total_cols (w, make_number (FRAME_TOTAL_COLS (f)));
     allocate_matrices_for_window_redisplay (w);
   }
 #endif /* not USE_X_TOOLKIT && not USE_GTK */
@@ -2199,19 +2198,19 @@ adjust_frame_glyphs_for_window_redisplay (struct frame *f)
     if (NILP (f->tool_bar_window))
       {
         Lisp_Object frame;
-        FSET (f, tool_bar_window, make_window ());
+        fset_tool_bar_window (f, make_window ());
         w = XWINDOW (f->tool_bar_window);
         XSETFRAME (frame, f);
-        WSET (w, frame, frame);
+        wset_frame (w, frame);
         w->pseudo_window_p = 1;
       }
     else
       w = XWINDOW (f->tool_bar_window);
 
-    WSET (w, top_line, make_number (FRAME_MENU_BAR_LINES (f)));
-    WSET (w, left_col, make_number (0));
-    WSET (w, total_lines, make_number (FRAME_TOOL_BAR_LINES (f)));
-    WSET (w, total_cols, make_number (FRAME_TOTAL_COLS (f)));
+    wset_top_line (w, make_number (FRAME_MENU_BAR_LINES (f)));
+    wset_left_col (w, make_number (0));
+    wset_total_lines (w, make_number (FRAME_TOOL_BAR_LINES (f)));
+    wset_total_cols (w, make_number (FRAME_TOTAL_COLS (f)));
     allocate_matrices_for_window_redisplay (w);
   }
 #endif
@@ -2277,7 +2276,7 @@ free_glyphs (struct frame *f)
           free_glyph_matrix (w->desired_matrix);
           free_glyph_matrix (w->current_matrix);
           w->desired_matrix = w->current_matrix = NULL;
-          FSET (f, menu_bar_window, Qnil);
+          fset_menu_bar_window (f, Qnil);
         }
 
       /* Free the tool bar window and its glyph matrices.  */
@@ -2287,7 +2286,7 @@ free_glyphs (struct frame *f)
           free_glyph_matrix (w->desired_matrix);
           free_glyph_matrix (w->current_matrix);
           w->desired_matrix = w->current_matrix = NULL;
-          FSET (f, tool_bar_window, Qnil);
+          fset_tool_bar_window (f, Qnil);
         }
 
       /* Release frame glyph matrices.  Reset fields to zero in
@@ -3225,8 +3224,8 @@ update_frame (struct frame *f, int force_p, int inhibit_hairy_id_p)
               /* Swap tool-bar strings.  We swap because we want to
                  reuse strings.  */
               tem = f->current_tool_bar_string;
-              FSET (f, current_tool_bar_string, f->desired_tool_bar_string);
-              FSET (f, desired_tool_bar_string, tem);
+              fset_current_tool_bar_string (f, f->desired_tool_bar_string);
+              fset_desired_tool_bar_string (f, tem);
             }
         }
 
@@ -5758,7 +5757,7 @@ change_frame_size_1 (register struct frame *f, int newheight, int newwidth, int
         FrameCols (FRAME_TTY (f)) = newwidth;
 
       if (WINDOWP (f->tool_bar_window))
-        WSET (XWINDOW (f->tool_bar_window), total_cols, make_number (newwidth));
+        wset_total_cols (XWINDOW (f->tool_bar_window), make_number (newwidth));
     }
 
   FRAME_LINES (f) = newheight;
diff --git a/src/doc.c b/src/doc.c
index d17e90f11c0..ed311d918d7 100644
--- a/src/doc.c
+++ b/src/doc.c
@@ -22,11 +22,12 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include <sys/types.h>
 #include <sys/file.h>   /* Must be after sys/types.h for USG*/
-#include <ctype.h>
 #include <setjmp.h>
 #include <fcntl.h>
 #include <unistd.h>
 
+#include <c-ctype.h>
+
 #include "lisp.h"
 #include "character.h"
 #include "buffer.h"
@@ -597,9 +598,9 @@ the same file name is found in the `doc-directory'.  */)
       {
         ptrdiff_t len;
 
-        while (*beg && isspace (*beg)) ++beg;
+        while (*beg && c_isspace (*beg)) ++beg;
 
-        for (end = beg; *end && ! isspace (*end); ++end)
+        for (end = beg; *end && ! c_isspace (*end); ++end)
           if (*end == '/') beg = end+1;  /* skip directory part  */
 
         len = end - beg;
diff --git a/src/doprnt.c b/src/doprnt.c
index 63f05cb74e2..b36e946005d 100644
--- a/src/doprnt.c
+++ b/src/doprnt.c
@@ -102,7 +102,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include <config.h>
 #include <stdio.h>
-#include <ctype.h>
 #include <setjmp.h>
 #include <float.h>
 #include <unistd.h>
diff --git a/src/dosfns.c b/src/dosfns.c
index e3adf25d79f..21676f4b4f5 100644
--- a/src/dosfns.c
+++ b/src/dosfns.c
@@ -473,7 +473,7 @@ x_set_title (struct frame *f, Lisp_Object name)
 
   update_mode_lines = 1;
 
-  FSET (f, title, name);
+  fset_title (f, name);
 
   if (NILP (name))
     name = f->name;
diff --git a/src/editfns.c b/src/editfns.c
index 5ac012c8378..c4725aa0ff3 100644
--- a/src/editfns.c
+++ b/src/editfns.c
@@ -44,7 +44,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <sys/resource.h>
 #endif
 
-#include <ctype.h>
 #include <float.h>
 #include <limits.h>
 #include <intprops.h>
@@ -882,7 +881,7 @@ save_excursion_restore (Lisp_Object info)
   info = XCDR (info);
   tem = XCAR (info);
   tem1 = BVAR (current_buffer, mark_active);
-  BSET (current_buffer, mark_active, tem);
+  bset_mark_active (current_buffer, tem);
 
   /* If mark is active now, and either was not active
      or was at a different place, run the activate hook.  */
@@ -2816,13 +2815,15 @@ determines whether case is significant or ignored.  */)
 static Lisp_Object
 subst_char_in_region_unwind (Lisp_Object arg)
 {
-  return BSET (current_buffer, undo_list, arg);
+  bset_undo_list (current_buffer, arg);
+  return arg;
 }
 
 static Lisp_Object
 subst_char_in_region_unwind_1 (Lisp_Object arg)
 {
-  return BSET (current_buffer, filename, arg);
+  bset_filename (current_buffer, arg);
+  return arg;
 }
 
 DEFUN ("subst-char-in-region", Fsubst_char_in_region,
@@ -2896,11 +2897,11 @@ Both characters must have the same length of multi-byte form.  */)
     {
       record_unwind_protect (subst_char_in_region_unwind,
                              BVAR (current_buffer, undo_list));
-      BSET (current_buffer, undo_list, Qt);
+      bset_undo_list (current_buffer, Qt);
       /* Don't do file-locking.  */
       record_unwind_protect (subst_char_in_region_unwind_1,
                              BVAR (current_buffer, filename));
-      BSET (current_buffer, filename, Qnil);
+      bset_filename (current_buffer, Qnil);
     }
 
   if (pos_byte < GPT_BYTE)
@@ -2982,7 +2983,7 @@ Both characters must have the same length of multi-byte form.  */)
                 INC_POS (pos_byte_next);
 
               if (! NILP (noundo))
-                BSET (current_buffer, undo_list, tem);
+                bset_undo_list (current_buffer, tem);
 
               UNGCPRO;
             }
@@ -3937,7 +3938,7 @@ usage: (format STRING &rest OBJECTS)  */)
 
                   /* If this argument has text properties, record where
                      in the result string it appears.  */
-                  if (string_get_intervals (args[n]))
+                  if (string_intervals (args[n]))
                     info[n].intervals = arg_intervals = 1;
 
                   continue;
@@ -4281,7 +4282,7 @@ usage: (format STRING &rest OBJECTS)  */)
      arguments has text properties, set up text properties of the
      result string.  */
 
-  if (string_get_intervals (args[0]) || arg_intervals)
+  if (string_intervals (args[0]) || arg_intervals)
     {
       Lisp_Object len, new_len, props;
       struct gcpro gcpro1;
@@ -4531,7 +4532,7 @@ Transposing beyond buffer boundaries is an error.  */)
   Lisp_Object buf;
 
   XSETBUFFER (buf, current_buffer);
-  cur_intv = buffer_get_intervals (current_buffer);
+  cur_intv = buffer_intervals (current_buffer);
 
   validate_region (&startr1, &endr1);
   validate_region (&startr2, &endr2);
diff --git a/src/eval.c b/src/eval.c
index b531f790cc5..771cd7b160a 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -2217,7 +2217,19 @@ eval_sub (Lisp_Object form)
           goto retry;
         }
       if (EQ (funcar, Qmacro))
-        val = eval_sub (apply1 (Fcdr (fun), original_args));
+        {
+          ptrdiff_t count = SPECPDL_INDEX ();
+          extern Lisp_Object Qlexical_binding;
+          Lisp_Object exp;
+          /* Bind lexical-binding during expansion of the macro, so the
+             macro can know reliably if the code it outputs will be
+             interpreted using lexical-binding or not.  */
+          specbind (Qlexical_binding,
+                    NILP (Vinternal_interpreter_environment) ? Qnil : Qt);
+          exp = apply1 (Fcdr (fun), original_args);
+          unbind_to (count, Qnil);
+          val = eval_sub (exp);
+        }
       else if (EQ (funcar, Qlambda)
                || EQ (funcar, Qclosure))
         val = apply_lambda (fun, original_args);
@@ -3157,12 +3169,12 @@ specbind (Lisp_Object symbol, Lisp_Object value)
             if (!NILP (Flocal_variable_p (symbol, Qnil)))
               {
                 eassert (sym->redirect != SYMBOL_LOCALIZED
-                         || (BLV_FOUND (SYMBOL_BLV (sym))
+                         || (blv_found (SYMBOL_BLV (sym))
                              && EQ (cur_buf, SYMBOL_BLV (sym)->where)));
                 where = cur_buf;
               }
             else if (sym->redirect == SYMBOL_LOCALIZED
-                     && BLV_FOUND (SYMBOL_BLV (sym)))
+                     && blv_found (SYMBOL_BLV (sym)))
               where = SYMBOL_BLV (sym)->where;
             else
               where = Qnil;
diff --git a/src/fileio.c b/src/fileio.c
index eba157ea042..2f4a2ad2314 100644
--- a/src/fileio.c
+++ b/src/fileio.c
@@ -30,7 +30,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <pwd.h>
 #endif
 
-#include <ctype.h>
 #include <errno.h>
 
 #ifdef HAVE_LIBSELINUX
@@ -38,6 +37,8 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <selinux/context.h>
 #endif
 
+#include <c-ctype.h>
+
 #include "lisp.h"
 #include "intervals.h"
 #include "character.h"
@@ -67,12 +68,12 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #define IS_DRIVE(x) ((x) >= 'A' && (x) <= 'z')
 #endif
 #ifdef WINDOWSNT
-#define IS_DRIVE(x) isalpha ((unsigned char) (x))
+#define IS_DRIVE(x) c_isalpha (x)
 #endif
 /* Need to lower-case the drive letter, or else expanded
    filenames will sometimes compare unequal, because
    `expand-file-name' doesn't always down-case the drive letter.  */
-#define DRIVE_LETTER(x) (tolower ((unsigned char) (x)))
+#define DRIVE_LETTER(x) c_tolower (x)
 #endif
 
 #include "systime.h"
@@ -364,7 +365,7 @@ Given a Unix syntax file name, returns a string ending in slash.  */)
           r += 2;
         }
 
-      if (getdefdir (toupper ((unsigned char) *beg) - 'A' + 1, r))
+      if (getdefdir (c_toupper (*beg) - 'A' + 1, r))
         {
           if (!IS_DIRECTORY_SEP (res[strlen (res) - 1]))
             strcat (res, "/");
@@ -1053,7 +1054,7 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
       if (!IS_DIRECTORY_SEP (nm[0]))
         {
           adir = alloca (MAXPATHLEN + 1);
-          if (!getdefdir (toupper (drive) - 'A' + 1, adir))
+          if (!getdefdir (c_toupper (drive) - 'A' + 1, adir))
             adir = NULL;
         }
       if (!adir)
@@ -1129,7 +1130,7 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
           adir = alloca (MAXPATHLEN + 1);
           if (drive)
             {
-              if (!getdefdir (toupper (drive) - 'A' + 1, adir))
+              if (!getdefdir (c_toupper (drive) - 'A' + 1, adir))
                 newdir = "/";
             }
           else
@@ -1635,7 +1636,7 @@ those `/' is discarded.  */)
         else
           {
             o = p;
-            while (p != endp && (isalnum (*p) || *p == '_')) p++;
+            while (p != endp && (c_isalnum (*p) || *p == '_')) p++;
             s = p;
           }
 
@@ -1698,7 +1699,7 @@ those `/' is discarded.  */)
         else
           {
             o = p;
-            while (p != endp && (isalnum (*p) || *p == '_')) p++;
+            while (p != endp && (c_isalnum (*p) || *p == '_')) p++;
             s = p;
           }
 
@@ -3145,12 +3146,12 @@ decide_coding_unwind (Lisp_Object unwind_data)
     set_buffer_internal (XBUFFER (buffer));
   adjust_markers_for_delete (BEG, BEG_BYTE, Z, Z_BYTE);
   adjust_overlays_for_delete (BEG, Z - BEG);
-  buffer_set_intervals (current_buffer, NULL);
+  set_buffer_intervals (current_buffer, NULL);
   TEMP_SET_PT_BOTH (BEG, BEG_BYTE);
 
   /* Now we are safe to change the buffer's multibyteness directly.  */
-  BSET (current_buffer, enable_multibyte_characters, multibyte);
-  BSET (current_buffer, undo_list, undo_list);
+  bset_enable_multibyte_characters (current_buffer, multibyte);
+  bset_undo_list (current_buffer, undo_list);
 
   return Qnil;
 }
@@ -3486,16 +3487,16 @@ variable `last-coding-system-used' to the coding system actually used.  */)
                   buf = XBUFFER (workbuf);
 
                   delete_all_overlays (buf);
-                  BSET (buf, directory, BVAR (current_buffer, directory));
-                  BSET (buf, read_only, Qnil);
-                  BSET (buf, filename, Qnil);
-                  BSET (buf, undo_list, Qt);
+                  bset_directory (buf, BVAR (current_buffer, directory));
+                  bset_read_only (buf, Qnil);
+                  bset_filename (buf, Qnil);
+                  bset_undo_list (buf, Qt);
                   eassert (buf->overlays_before == NULL);
                   eassert (buf->overlays_after == NULL);
 
                   set_buffer_internal (buf);
                   Ferase_buffer ();
-                  BSET (buf, enable_multibyte_characters, Qnil);
+                  bset_enable_multibyte_characters (buf, Qnil);
 
                   insert_1_both ((char *) read_buf, nread, nread, 0, 0, 0);
                   TEMP_SET_PT_BOTH (BEG, BEG_BYTE);
@@ -4104,8 +4105,8 @@ variable `last-coding-system-used' to the coding system actually used.  */)
           unwind_data = Fcons (BVAR (current_buffer, enable_multibyte_characters),
                                Fcons (BVAR (current_buffer, undo_list),
                                       Fcurrent_buffer ()));
-          BSET (current_buffer, enable_multibyte_characters, Qnil);
-          BSET (current_buffer, undo_list, Qt);
+          bset_enable_multibyte_characters (current_buffer, Qnil);
+          bset_undo_list (current_buffer, Qt);
           record_unwind_protect (decide_coding_unwind, unwind_data);
 
           if (inserted > 0 && ! NILP (Vset_auto_coding_function))
@@ -4153,7 +4154,7 @@ variable `last-coding-system-used' to the coding system actually used.  */)
           && NILP (replace))
         /* Visiting a file with these coding system makes the buffer
            unibyte. */
-        BSET (current_buffer, enable_multibyte_characters, Qnil);
+        bset_enable_multibyte_characters (current_buffer, Qnil);
     }
 
   coding.dst_multibyte = ! NILP (BVAR (current_buffer, enable_multibyte_characters));
@@ -4196,13 +4197,13 @@ variable `last-coding-system-used' to the coding system actually used.  */)
   if (!NILP (visit))
     {
       if (!EQ (BVAR (current_buffer, undo_list), Qt) && !nochange)
-        BSET (current_buffer, undo_list, Qnil);
+        bset_undo_list (current_buffer, Qnil);
 
       if (NILP (handler))
         {
           current_buffer->modtime = mtime;
           current_buffer->modtime_size = st.st_size;
-          BSET (current_buffer, filename, orig_filename);
+          bset_filename (current_buffer, orig_filename);
         }
 
       SAVE_MODIFF = MODIFF;
@@ -4247,7 +4248,7 @@ variable `last-coding-system-used' to the coding system actually used.  */)
 
       /* Save old undo list and don't record undo for decoding.  */
       old_undo = BVAR (current_buffer, undo_list);
-      BSET (current_buffer, undo_list, Qt);
+      bset_undo_list (current_buffer, Qt);
 
       if (NILP (replace))
         {
@@ -4339,7 +4340,7 @@ variable `last-coding-system-used' to the coding system actually used.  */)
 
       if (NILP (visit))
         {
-          BSET (current_buffer, undo_list, old_undo);
+          bset_undo_list (current_buffer, old_undo);
           if (CONSP (old_undo) && inserted != old_inserted)
             {
               /* Adjust the last undo record for the size change during
@@ -4354,7 +4355,7 @@ variable `last-coding-system-used' to the coding system actually used.  */)
       else
         /* If undo_list was Qt before, keep it that way.
            Otherwise start with an empty undo_list.  */
-        BSET (current_buffer, undo_list, EQ (old_undo, Qt) ? Qt : Qnil);
+        bset_undo_list (current_buffer, EQ (old_undo, Qt) ? Qt : Qnil);
 
       unbind_to (count1, Qnil);
     }
@@ -4594,7 +4595,7 @@ This calls `write-region-annotate-functions' at the start, and
         {
           SAVE_MODIFF = MODIFF;
           XSETFASTINT (BVAR (current_buffer, save_length), Z - BEG);
-          BSET (current_buffer, filename, visit_file);
+          bset_filename (current_buffer, visit_file);
         }
       UNGCPRO;
       return val;
@@ -4810,7 +4811,7 @@ This calls `write-region-annotate-functions' at the start, and
     {
       SAVE_MODIFF = MODIFF;
       XSETFASTINT (BVAR (current_buffer, save_length), Z - BEG);
-      BSET (current_buffer, filename, visit_file);
+      bset_filename (current_buffer, visit_file);
       update_mode_lines++;
     }
   else if (quietly)
diff --git a/src/fns.c b/src/fns.c
index 12dca917e62..443e98b2f04 100644
--- a/src/fns.c
+++ b/src/fns.c
@@ -628,7 +628,7 @@ concat (ptrdiff_t nargs, Lisp_Object *args,
           ptrdiff_t thislen_byte = SBYTES (this);
 
           memcpy (SDATA (val) + toindex_byte, SDATA (this), SBYTES (this));
-          if (string_get_intervals (this))
+          if (string_intervals (this))
             {
               textprops[num_textprops].argnum = argnum;
               textprops[num_textprops].from = 0;
@@ -640,7 +640,7 @@ concat (ptrdiff_t nargs, Lisp_Object *args,
       /* Copy a single-byte string to a multibyte string.  */
       else if (STRINGP (this) && STRINGP (val))
         {
-          if (string_get_intervals (this))
+          if (string_intervals (this))
             {
               textprops[num_textprops].argnum = argnum;
               textprops[num_textprops].from = 0;
@@ -1060,7 +1060,7 @@ If you're not sure, whether to use `string-as-multibyte' or
         str_as_multibyte (SDATA (new_string), nbytes,
                           SBYTES (string), NULL);
       string = new_string;
-      string_set_intervals (string, NULL);
+      set_string_intervals (string, NULL);
     }
   return string;
 }
@@ -2150,8 +2150,8 @@ ARRAY is a vector, string, char-table, or bool-vector.  */)
       int i;
 
       for (i = 0; i < (1 << CHARTAB_SIZE_BITS_0); i++)
-        XCHAR_TABLE (array)->contents[i] = item;
-      XCHAR_TABLE (array)->defalt = item;
+        set_char_table_contents (array, i, item);
+      set_char_table_defalt (array, item);
     }
   else if (STRINGP (array))
     {
diff --git a/src/font.c b/src/font.c
index c3040b8aa3f..5b9e4f1cfcf 100644
--- a/src/font.c
+++ b/src/font.c
@@ -23,9 +23,10 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <config.h>
 #include <float.h>
 #include <stdio.h>
-#include <ctype.h>
 #include <setjmp.h>
 
+#include <c-ctype.h>
+
 #include "lisp.h"
 #include "character.h"
 #include "buffer.h"
@@ -1079,7 +1080,7 @@ font_parse_xlfd (char *name, ptrdiff_t len, Lisp_Object font)
               p = f[XLFD_POINT_INDEX];
               if (*p == '[')
                 point_size = parse_matrix (p);
-              else if (isdigit (*p))
+              else if (c_isdigit (*p))
                 point_size = atoi (p), point_size /= 10;
               if (point_size >= 0)
                 ASET (font, FONT_SIZE_INDEX, make_float (point_size));
@@ -1346,7 +1347,7 @@ font_parse_fcname (char *name, ptrdiff_t len, Lisp_Object font)
         {
           int decimal = 0, size_found = 1;
           for (q = p + 1; *q && *q != ':'; q++)
-            if (! isdigit (*q))
+            if (! c_isdigit (*q))
               {
                 if (*q != '.' || decimal)
                   {
@@ -1474,7 +1475,7 @@ font_parse_fcname (char *name, ptrdiff_t len, Lisp_Object font)
 
       /* Scan backwards from the end, looking for a size.  */
       for (p = name + len - 1; p >= name; p--)
-        if (!isdigit (*p))
+        if (!c_isdigit (*p))
           break;
 
       if ((p < name + len - 1) && ((p + 1 == name) || *p == ' '))
diff --git a/src/font.h b/src/font.h
index 3e9af6df235..6e9387f7632 100644
--- a/src/font.h
+++ b/src/font.h
@@ -284,8 +284,11 @@ struct font
 
   /* Beyond here, there should be no more Lisp_Object components.  */
 
-  /* Maximum bound width over all existing characters of the font.  On
-     X window, this is same as (font->max_bounds.width).  */
+  /* Minimum and maximum glyph widths, in pixels.  Some font backends,
+     such as xft, lack the information to easily compute minimum and
+     maximum widths over all characters; in that case, these values
+     are approximate.  */
+  int min_width;
   int max_width;
 
   /* By which pixel size the font is opened.  */
@@ -301,13 +304,10 @@ struct font
 
   /* Average width of glyphs in the font.  If the font itself doesn't
      have that information but has glyphs of ASCII characters, the
-     value is the average with of those glyphs.  Otherwise, the value
+     value is the average width of those glyphs.  Otherwise, the value
      is 0.  */
   int average_width;
 
-  /* Minimum glyph width (in pixels).  */
-  int min_width;
-
   /* Ascent and descent of the font (in pixels).  */
   int ascent, descent;
 
diff --git a/src/fontset.c b/src/fontset.c
index 3c7e931d121..c39d68a8ecf 100644
--- a/src/fontset.c
+++ b/src/fontset.c
@@ -1916,7 +1916,7 @@ format is the same as above.  */)
   if (!EQ (fontset, Vdefault_fontset))
     {
       tables[1] = Fmake_char_table (Qnil, Qnil);
-      XCHAR_TABLE (tables[0])->extras[0] = tables[1];
+      set_char_table_extras (tables[0], 0, tables[1]);
       fontsets[1] = Vdefault_fontset;
     }
 
@@ -1979,7 +1979,7 @@ format is the same as above.  */)
               if (c <= MAX_5_BYTE_CHAR)
                 char_table_set_range (tables[k], c, to, alist);
               else
-                XCHAR_TABLE (tables[k])->defalt = alist;
+                set_char_table_defalt (tables[k], alist);
 
               /* At last, change each elements to font names.  */
               for (; CONSP (alist); alist = XCDR (alist))
diff --git a/src/frame.c b/src/frame.c
index ea682835a87..a00f44a1e5a 100644
--- a/src/frame.c
+++ b/src/frame.c
@@ -19,11 +19,15 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include <config.h>
 
+#define FRAME_INLINE EXTERN_INLINE
+
 #include <stdio.h>
-#include <ctype.h>
 #include <errno.h>
 #include <limits.h>
 #include <setjmp.h>
+
+#include <c-ctype.h>
+
 #include "lisp.h"
 #include "character.h"
 #ifdef HAVE_X_WINDOWS
@@ -125,6 +129,18 @@ static Lisp_Object Qdelete_frame_functions;
 static void x_report_frame_params (struct frame *, Lisp_Object *);
 #endif
 
+/* These setters are used only in this file, so they can be private.  */
+static inline void
+fset_buffer_predicate (struct frame *f, Lisp_Object val)
+{
+  f->buffer_predicate = val;
+}
+static inline void
+fset_minibuffer_window (struct frame *f, Lisp_Object val)
+{
+  f->minibuffer_window = val;
+}
+
 
 static void
 set_menu_bar_lines_1 (Lisp_Object window, int n)
@@ -132,8 +148,8 @@ set_menu_bar_lines_1 (Lisp_Object window, int n)
   struct window *w = XWINDOW (window);
 
   w->last_modified = 0;
-  WSET (w, top_line, make_number (XFASTINT (w->top_line) + n));
-  WSET (w, total_lines, make_number (XFASTINT (w->total_lines) - n));
+  wset_top_line (w, make_number (XFASTINT (w->top_line) + n));
+  wset_total_lines (w, make_number (XFASTINT (w->total_lines) - n));
 
   /* Handle just the top child in a vertical split.  */
   if (!NILP (w->vchild))
@@ -269,7 +285,7 @@ make_frame (int mini_p)
 
   /* Initialize Lisp data.  Note that allocate_frame initializes all
      Lisp data to nil, so do it only for slots which should not be nil.  */
-  FSET (f, tool_bar_position, Qtop);
+  fset_tool_bar_position (f, Qtop);
 
   /* Initialize non-Lisp data.  Note that allocate_frame zeroes out all
      non-Lisp data, so do it only for slots which should not be zero.
@@ -289,20 +305,20 @@ make_frame (int mini_p)
   if (mini_p)
     {
       mini_window = make_window ();
-      WSET (XWINDOW (root_window), next, mini_window);
-      WSET (XWINDOW (mini_window), prev, root_window);
+      wset_next (XWINDOW (root_window), mini_window);
+      wset_prev (XWINDOW (mini_window), root_window);
       XWINDOW (mini_window)->mini = 1;
-      WSET (XWINDOW (mini_window), frame, frame);
-      FSET (f, minibuffer_window, mini_window);
+      wset_frame (XWINDOW (mini_window), frame);
+      fset_minibuffer_window (f, mini_window);
     }
   else
     {
       mini_window = Qnil;
-      WSET (XWINDOW (root_window), next, Qnil);
-      FSET (f, minibuffer_window, Qnil);
+      wset_next (XWINDOW (root_window), Qnil);
+      fset_minibuffer_window (f, Qnil);
     }
 
-  WSET (XWINDOW (root_window), frame, frame);
+  wset_frame (XWINDOW (root_window), frame);
 
   /* 10 is arbitrary,
      just so that there is "something there."
@@ -311,21 +327,21 @@ make_frame (int mini_p)
   SET_FRAME_COLS (f, 10);
   FRAME_LINES (f) = 10;
 
-  WSET (XWINDOW (root_window), total_cols, make_number (10));
-  WSET (XWINDOW (root_window), total_lines, make_number (mini_p ? 9 : 10));
+  wset_total_cols (XWINDOW (root_window), make_number (10));
+  wset_total_lines (XWINDOW (root_window), make_number (mini_p ? 9 : 10));
 
   if (mini_p)
     {
-      WSET (XWINDOW (mini_window), total_cols, make_number (10));
-      WSET (XWINDOW (mini_window), top_line, make_number (9));
-      WSET (XWINDOW (mini_window), total_lines, make_number (1));
+      wset_total_cols (XWINDOW (mini_window), make_number (10));
+      wset_top_line (XWINDOW (mini_window), make_number (9));
+      wset_total_lines (XWINDOW (mini_window), make_number (1));
     }
 
   /* Choose a buffer for the frame's root window.  */
   {
     Lisp_Object buf;
 
-    WSET (XWINDOW (root_window), buffer, Qt);
+    wset_buffer (XWINDOW (root_window), Qt);
     buf = Fcurrent_buffer ();
     /* If buf is a 'hidden' buffer (i.e. one whose name starts with
        a space), try to find another one.  */
@@ -339,12 +355,12 @@ make_frame (int mini_p)
        etc.  Running Lisp functions at this point surely ends in a
        SEGV.  */
     set_window_buffer (root_window, buf, 0, 0);
-    FSET (f, buffer_list, Fcons (buf, Qnil));
+    fset_buffer_list (f, Fcons (buf, Qnil));
   }
 
   if (mini_p)
     {
-      WSET (XWINDOW (mini_window), buffer, Qt);
+      wset_buffer (XWINDOW (mini_window), Qt);
       set_window_buffer (mini_window,
                          (NILP (Vminibuffer_list)
                           ? get_minibuffer (0)
@@ -352,8 +368,8 @@ make_frame (int mini_p)
                          0, 0);
     }
 
-  FSET (f, root_window, root_window);
-  FSET (f, selected_window, root_window);
+  fset_root_window (f, root_window);
+  fset_selected_window (f, root_window);
   /* Make sure this window seems more recently used than
      a newly-created, never-selected window.  */
   XWINDOW (f->selected_window)->use_time = ++window_select_count;
@@ -393,8 +409,8 @@ make_frame_without_minibuffer (register Lisp_Object mini_window, KBOARD *kb, Lis
           XSETFRAME (frame_dummy, f);
           GCPRO1 (frame_dummy);
           /* If there's no minibuffer frame to use, create one.  */
-          KSET (kb, Vdefault_minibuffer_frame,
-                call1 (intern ("make-initial-minibuffer-frame"), display));
+          kset_default_minibuffer_frame
+            (kb, call1 (intern ("make-initial-minibuffer-frame"), display));
           UNGCPRO;
         }
 
@@ -402,7 +418,7 @@ make_frame_without_minibuffer (register Lisp_Object mini_window, KBOARD *kb, Lis
         = XFRAME (KVAR (kb, Vdefault_minibuffer_frame))->minibuffer_window;
     }
 
-  FSET (f, minibuffer_window, mini_window);
+  fset_minibuffer_window (f, mini_window);
 
   /* Make the chosen minibuffer window display the proper minibuffer,
      unless it is already showing a minibuffer.  */
@@ -439,11 +455,12 @@ make_minibuffer_frame (void)
      Avoid infinite looping on the window chain by marking next pointer
      as nil. */
 
-  mini_window = FSET (f, minibuffer_window, f->root_window);
+  mini_window = f->root_window;
+  fset_minibuffer_window (f, mini_window);
   XWINDOW (mini_window)->mini = 1;
-  WSET (XWINDOW (mini_window), next, Qnil);
-  WSET (XWINDOW (mini_window), prev, Qnil);
-  WSET (XWINDOW (mini_window), frame, frame);
+  wset_next (XWINDOW (mini_window), Qnil);
+  wset_prev (XWINDOW (mini_window), Qnil);
+  wset_frame (XWINDOW (mini_window), frame);
 
   /* Put the proper buffer in that window.  */
 
@@ -482,7 +499,7 @@ make_initial_frame (void)
   Vframe_list = Fcons (frame, Vframe_list);
 
   tty_frame_count = 1;
-  FSET (f, name, build_pure_c_string ("F1"));
+  fset_name (f, build_pure_c_string ("F1"));
 
   f->visible = 1;
   f->async_visible = 1;
@@ -523,7 +540,7 @@ make_terminal_frame (struct terminal *terminal)
   XSETFRAME (frame, f);
   Vframe_list = Fcons (frame, Vframe_list);
 
-  FSET (f, name, make_formatted_string (name, "F%"pMd, ++tty_frame_count));
+  fset_name (f, make_formatted_string (name, "F%"pMd, ++tty_frame_count));
 
   f->visible = 1;               /* FRAME_SET_VISIBLE wd set frame_garbaged. */
   f->async_visible = 1;         /* Don't let visible be cleared later. */
@@ -693,7 +710,7 @@ affects all frames on the same terminal device.  */)
 
   /* Make the frame face alist be frame-specific, so that each
      frame could change its face definitions independently.  */
-  FSET (f, face_alist, Fcopy_alist (sf->face_alist));
+  fset_face_alist (f, Fcopy_alist (sf->face_alist));
   /* Simple Fcopy_alist isn't enough, because we need the contents of
      the vectors which are the CDRs of associations in face_alist to
      be copied as well.  */
@@ -847,7 +864,7 @@ to that frame.  */)
   (Lisp_Object event)
 {
   /* Preserve prefix arg that the command loop just cleared.  */
-  KSET (current_kboard, Vprefix_arg, Vcurrent_prefix_arg);
+  kset_prefix_arg (current_kboard, Vcurrent_prefix_arg);
   Frun_hooks (1, &Qmouse_leave_buffer_hook);
   return do_switch_frame (event, 0, 0, Qnil);
 }
@@ -1280,7 +1297,7 @@ delete_frame (Lisp_Object frame, Lisp_Object force)
   /* Mark all the windows that used to be on FRAME as deleted, and then
      remove the reference to them.  */
   delete_all_child_windows (f->root_window);
-  FSET (f, root_window, Qnil);
+  fset_root_window (f, Qnil);
 
   Vframe_list = Fdelq (frame, Vframe_list);
   FRAME_SET_VISIBLE (f, 0);
@@ -1289,7 +1306,7 @@ delete_frame (Lisp_Object frame, Lisp_Object force)
      garbage collection.  The frame object itself may not be garbage
      collected until much later, because recent_keys and other data
      structures can still refer to it.  */
-  FSET (f, menu_bar_vector, Qnil);
+  fset_menu_bar_vector (f, Qnil);
 
   free_font_driver_list (f);
   xfree (f->namebuf);
@@ -1441,11 +1458,11 @@ delete_frame (Lisp_Object frame, Lisp_Object force)
           if (NILP (frame_with_minibuf))
             abort ();
 
-          KSET (kb, Vdefault_minibuffer_frame, frame_with_minibuf);
+          kset_default_minibuffer_frame (kb, frame_with_minibuf);
         }
       else
         /* No frames left on this kboard--say no minibuffer either.  */
-        KSET (kb, Vdefault_minibuffer_frame, Qnil);
+        kset_default_minibuffer_frame (kb, Qnil);
     }
 
   /* Cause frame titles to update--necessary if we now have just one frame.  */
@@ -1683,7 +1700,7 @@ make_frame_visible_1 (Lisp_Object window)
       w = XWINDOW (window);
 
       if (!NILP (w->buffer))
-        BSET (XBUFFER (w->buffer), display_time, Fcurrent_time ());
+        bset_display_time (XBUFFER (w->buffer), Fcurrent_time ());
 
       if (!NILP (w->vchild))
         make_frame_visible_1 (w->vchild);
@@ -1917,7 +1934,7 @@ The redirection lasts until `redirect-frame-focus' is called to change it.  */)
 
   f = XFRAME (frame);
 
-  FSET (f, focus_frame, focus_frame);
+  fset_focus_frame (f, focus_frame);
 
   if (FRAME_TERMINAL (f)->frame_rehighlight_hook)
     (*FRAME_TERMINAL (f)->frame_rehighlight_hook) (f);
@@ -1982,10 +1999,10 @@ frames_discard_buffer (Lisp_Object buffer)
 
   FOR_EACH_FRAME (tail, frame)
     {
-      FSET (XFRAME (frame), buffer_list,
-            Fdelq (buffer, XFRAME (frame)->buffer_list));
-      FSET (XFRAME (frame), buried_buffer_list,
-            Fdelq (buffer, XFRAME (frame)->buried_buffer_list));
+      fset_buffer_list
+        (XFRAME (frame), Fdelq (buffer, XFRAME (frame)->buffer_list));
+      fset_buried_buffer_list
+        (XFRAME (frame), Fdelq (buffer, XFRAME (frame)->buried_buffer_list));
     }
 }
 
@@ -2052,7 +2069,7 @@ set_term_frame_name (struct frame *f, Lisp_Object name)
         error ("Frame names of the form F<num> are usurped by Emacs");
     }
 
-  FSET (f, name, name);
+  fset_name (f, name);
   update_mode_lines = 1;
 }
 
@@ -2069,7 +2086,7 @@ store_frame_param (struct frame *f, Lisp_Object prop, Lisp_Object val)
       for (; CONSP (val); val = XCDR (val))
         if (!NILP (Fbuffer_live_p (XCAR (val))))
           list = Fcons (XCAR (val), list);
-      FSET (f, buffer_list, Fnreverse (list));
+      fset_buffer_list (f, Fnreverse (list));
       return;
     }
   if (EQ (prop, Qburied_buffer_list))
@@ -2078,7 +2095,7 @@ store_frame_param (struct frame *f, Lisp_Object prop, Lisp_Object val)
       for (; CONSP (val); val = XCDR (val))
         if (!NILP (Fbuffer_live_p (XCAR (val))))
           list = Fcons (XCAR (val), list);
-      FSET (f, buried_buffer_list, Fnreverse (list));
+      fset_buried_buffer_list (f, Fnreverse (list));
       return;
     }
 
@@ -2096,7 +2113,7 @@ store_frame_param (struct frame *f, Lisp_Object prop, Lisp_Object val)
         case SYMBOL_PLAINVAL: case SYMBOL_FORWARDED: break;
         case SYMBOL_LOCALIZED:
           { struct Lisp_Buffer_Local_Value *blv = sym->val.blv;
-            if (blv->frame_local && BLV_FOUND (blv) && XFRAME (blv->where) == f)
+            if (blv->frame_local && blv_found (blv) && XFRAME (blv->where) == f)
               swap_in_global_binding (sym);
             break;
           }
@@ -2115,7 +2132,7 @@ store_frame_param (struct frame *f, Lisp_Object prop, Lisp_Object val)
   /* Update the frame parameter alist.  */
   old_alist_elt = Fassq (prop, f->param_alist);
   if (EQ (old_alist_elt, Qnil))
-    FSET (f, param_alist, Fcons (Fcons (prop, val), f->param_alist));
+    fset_param_alist (f, Fcons (Fcons (prop, val), f->param_alist));
   else
     Fsetcdr (old_alist_elt, val);
 
@@ -2123,7 +2140,7 @@ store_frame_param (struct frame *f, Lisp_Object prop, Lisp_Object val)
      in addition to the alist.  */
 
   if (EQ (prop, Qbuffer_predicate))
-    FSET (f, buffer_predicate, val);
+    fset_buffer_predicate (f, val);
 
   if (! FRAME_WINDOW_P (f))
     {
@@ -2143,7 +2160,7 @@ store_frame_param (struct frame *f, Lisp_Object prop, Lisp_Object val)
         error ("Can't change the surrogate minibuffer of a frame with its own minibuffer");
 
       /* Install the chosen minibuffer window, with proper buffer.  */
-      FSET (f, minibuffer_window, val);
+      fset_minibuffer_window (f, val);
     }
 }
 
@@ -3271,7 +3288,7 @@ x_set_font_backend (struct frame *f, Lisp_Object new_value, Lisp_Object old_valu
       new_value = Qnil;
       while (*p0)
         {
-          while (*p1 && ! isspace (*p1) && *p1 != ',') p1++;
+          while (*p1 && ! c_isspace (*p1) && *p1 != ',') p1++;
           if (p0 < p1)
             new_value = Fcons (Fintern (make_string (p0, p1 - p0), Qnil),
                                new_value);
@@ -3279,7 +3296,7 @@ x_set_font_backend (struct frame *f, Lisp_Object new_value, Lisp_Object old_valu
             {
               int c;
 
-              while ((c = *++p1) && isspace (c));
+              while ((c = *++p1) && c_isspace (c));
             }
           p0 = p1;
         }
diff --git a/src/frame.h b/src/frame.h
index e07974fb4d2..92fbda42c70 100644
--- a/src/frame.h
+++ b/src/frame.h
@@ -25,6 +25,11 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "dispextern.h"
 
+INLINE_HEADER_BEGIN
+#ifndef FRAME_INLINE
+# define FRAME_INLINE INLINE
+#endif
+
 
 /* Miscellanea.  */
 
@@ -80,10 +85,6 @@ struct terminal;
 
 struct font_driver_list;
 
-/* Most code should use this macro to set Lisp field in struct frame.  */
-
-#define FSET(f, field, value) ((f)->field = (value))
-
 struct frame
 {
   struct vectorlike_header header;
@@ -499,6 +500,109 @@ struct frame
   unsigned long foreground_pixel;
 };
 
+/* Most code should use these functions to set Lisp fields in struct frame.  */
+
+FRAME_INLINE void
+fset_buffer_list (struct frame *f, Lisp_Object val)
+{
+  f->buffer_list = val;
+}
+FRAME_INLINE void
+fset_buried_buffer_list (struct frame *f, Lisp_Object val)
+{
+  f->buried_buffer_list = val;
+}
+FRAME_INLINE void
+fset_condemned_scroll_bars (struct frame *f, Lisp_Object val)
+{
+  f->condemned_scroll_bars = val;
+}
+FRAME_INLINE void
+fset_current_tool_bar_string (struct frame *f, Lisp_Object val)
+{
+  f->current_tool_bar_string = val;
+}
+FRAME_INLINE void
+fset_desired_tool_bar_string (struct frame *f, Lisp_Object val)
+{
+  f->desired_tool_bar_string = val;
+}
+FRAME_INLINE void
+fset_face_alist (struct frame *f, Lisp_Object val)
+{
+  f->face_alist = val;
+}
+FRAME_INLINE void
+fset_focus_frame (struct frame *f, Lisp_Object val)
+{
+  f->focus_frame = val;
+}
+FRAME_INLINE void
+fset_icon_name (struct frame *f, Lisp_Object val)
+{
+  f->icon_name = val;
+}
+FRAME_INLINE void
+fset_menu_bar_items (struct frame *f, Lisp_Object val)
+{
+  f->menu_bar_items = val;
+}
+FRAME_INLINE void
+fset_menu_bar_vector (struct frame *f, Lisp_Object val)
+{
+  f->menu_bar_vector = val;
+}
+FRAME_INLINE void
+fset_menu_bar_window (struct frame *f, Lisp_Object val)
+{
+  f->menu_bar_window = val;
+}
+FRAME_INLINE void
+fset_name (struct frame *f, Lisp_Object val)
+{
+  f->name = val;
+}
+FRAME_INLINE void
+fset_param_alist (struct frame *f, Lisp_Object val)
+{
+  f->param_alist = val;
+}
+FRAME_INLINE void
+fset_root_window (struct frame *f, Lisp_Object val)
+{
+  f->root_window = val;
+}
+FRAME_INLINE void
+fset_scroll_bars (struct frame *f, Lisp_Object val)
+{
+  f->scroll_bars = val;
+}
+FRAME_INLINE void
+fset_selected_window (struct frame *f, Lisp_Object val)
+{
+  f->selected_window = val;
+}
+FRAME_INLINE void
+fset_title (struct frame *f, Lisp_Object val)
+{
+  f->title = val;
+}
+FRAME_INLINE void
+fset_tool_bar_items (struct frame *f, Lisp_Object val)
+{
+  f->tool_bar_items = val;
+}
+FRAME_INLINE void
+fset_tool_bar_position (struct frame *f, Lisp_Object val)
+{
+  f->tool_bar_position = val;
+}
+FRAME_INLINE void
+fset_tool_bar_window (struct frame *f, Lisp_Object val)
+{
+  f->tool_bar_window = val;
+}
+
 #define FRAME_KBOARD(f) ((f)->terminal->kboard)
 
 /* Return a pointer to the image cache of frame F.  */
@@ -1146,4 +1250,6 @@ extern void set_frame_menubar (FRAME_PTR, int, int);
 
 #endif /* HAVE_WINDOW_SYSTEM */
 
+INLINE_HEADER_END
+
 #endif /* not EMACS_FRAME_H */
diff --git a/src/gnutls.c b/src/gnutls.c
index 5189f2098cf..a2573f6bd99 100644
--- a/src/gnutls.c
+++ b/src/gnutls.c
@@ -830,7 +830,7 @@ one trustfile (usually a CA bundle).  */)
   XPROCESS (proc)->gnutls_state = NULL;
   XPROCESS (proc)->gnutls_x509_cred = NULL;
   XPROCESS (proc)->gnutls_anon_cred = NULL;
-  PSET (XPROCESS (proc), gnutls_cred_type, type);
+  pset_gnutls_cred_type (XPROCESS (proc), type);
   GNUTLS_INITSTAGE (proc) = GNUTLS_STAGE_EMPTY;
 
   GNUTLS_LOG (1, max_log_level, "allocating credentials");
diff --git a/src/gtkutil.c b/src/gtkutil.c
index 6638f375a2c..2941605d448 100644
--- a/src/gtkutil.c
+++ b/src/gtkutil.c
@@ -24,7 +24,9 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <signal.h>
 #include <stdio.h>
 #include <setjmp.h>
-#include <ctype.h>
+
+#include <c-ctype.h>
+
 #include "lisp.h"
 #include "xterm.h"
 #include "blockinput.h"
@@ -2016,7 +2018,7 @@ xg_get_file_name (FRAME_PTR f,
 
 #if USE_NEW_GTK_FONT_CHOOSER
 
-extern Lisp_Object Qnormal;
+extern Lisp_Object Qxft, Qnormal;
 extern Lisp_Object Qextra_light, Qlight, Qsemi_light, Qsemi_bold;
 extern Lisp_Object Qbold, Qextra_bold, Qultra_bold;
 extern Lisp_Object Qoblique, Qitalic;
@@ -2072,7 +2074,7 @@ xg_get_font (FRAME_PTR f, const char *default_name)
       if (p)
         {
           char *ep = p+1;
-          while (isdigit (*ep))
+          while (c_isdigit (*ep))
             ++ep;
           if (*ep == '\0') *p = ' ';
         }
@@ -2099,7 +2101,7 @@ xg_get_font (FRAME_PTR f, const char *default_name)
 
       if (desc)
         {
-          Lisp_Object args[8];
+          Lisp_Object args[10];
           const char *name   = pango_font_description_get_family (desc);
           gint        size   = pango_font_description_get_size (desc);
           PangoWeight weight = pango_font_description_get_weight (desc);
@@ -2117,6 +2119,9 @@ xg_get_font (FRAME_PTR f, const char *default_name)
           args[6] = QCslant;
           args[7] = XG_STYLE_TO_SYMBOL (style);
 
+          args[8] = QCtype;
+          args[9] = Qxft;
+
           font = Ffont_spec (8, args);
 
           pango_font_description_free (desc);
diff --git a/src/image.c b/src/image.c
index 8a318c2f6ec..f2778165ece 100644
--- a/src/image.c
+++ b/src/image.c
@@ -20,7 +20,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <config.h>
 #include <stdio.h>
 #include <math.h>
-#include <ctype.h>
 #include <unistd.h>
 
 #ifdef HAVE_PNG
@@ -33,6 +32,8 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include <setjmp.h>
 
+#include <c-ctype.h>
+
 /* This makes the fields of a Display accessible, in Xlib header files.  */
 
 #define XLIB_ILLEGAL_ACCESS
@@ -2405,12 +2406,12 @@ xbm_scan (unsigned char **s, unsigned char *end, char *sval, int *ival)
  loop:
 
   /* Skip white space.  */
-  while (*s < end && (c = *(*s)++, isspace (c)))
+  while (*s < end && (c = *(*s)++, c_isspace (c)))
     ;
 
   if (*s >= end)
     c = 0;
-  else if (isdigit (c))
+  else if (c_isdigit (c))
     {
       int value = 0, digit;
 
@@ -2422,7 +2423,7 @@ xbm_scan (unsigned char **s, unsigned char *end, char *sval, int *ival)
               while (*s < end)
                 {
                   c = *(*s)++;
-                  if (isdigit (c))
+                  if (c_isdigit (c))
                     digit = c - '0';
                   else if (c >= 'a' && c <= 'f')
                     digit = c - 'a' + 10;
@@ -2433,11 +2434,11 @@ xbm_scan (unsigned char **s, unsigned char *end, char *sval, int *ival)
                   value = 16 * value + digit;
                 }
             }
-          else if (isdigit (c))
+          else if (c_isdigit (c))
             {
               value = c - '0';
               while (*s < end
-                     && (c = *(*s)++, isdigit (c)))
+                     && (c = *(*s)++, c_isdigit (c)))
                 value = 8 * value + c - '0';
             }
         }
@@ -2445,7 +2446,7 @@ xbm_scan (unsigned char **s, unsigned char *end, char *sval, int *ival)
         {
           value = c - '0';
           while (*s < end
-                 && (c = *(*s)++, isdigit (c)))
+                 && (c = *(*s)++, c_isdigit (c)))
             value = 10 * value + c - '0';
         }
 
@@ -2454,11 +2455,11 @@ xbm_scan (unsigned char **s, unsigned char *end, char *sval, int *ival)
       *ival = value;
       c = XBM_TK_NUMBER;
     }
-  else if (isalpha (c) || c == '_')
+  else if (c_isalpha (c) || c == '_')
     {
       *sval++ = c;
       while (*s < end
-             && (c = *(*s)++, (isalnum (c) || c == '_')))
+             && (c = *(*s)++, (c_isalnum (c) || c == '_')))
         *sval++ = c;
       *sval = 0;
       if (*s < end)
@@ -3661,16 +3662,17 @@ xpm_scan (const unsigned char **s,
   while (*s < end)
     {
       /* Skip white-space.  */
-      while (*s < end && (c = *(*s)++, isspace (c)))
+      while (*s < end && (c = *(*s)++, c_isspace (c)))
         ;
 
       /* gnus-pointer.xpm uses '-' in its identifier.
          sb-dir-plus.xpm uses '+' in its identifier.  */
-      if (isalpha (c) || c == '_' || c == '-' || c == '+')
+      if (c_isalpha (c) || c == '_' || c == '-' || c == '+')
         {
           *beg = *s - 1;
           while (*s < end
-                 && (c = **s, isalnum (c) || c == '_' || c == '-' || c == '+'))
+                 && (c = **s, c_isalnum (c)
+                     || c == '_' || c == '-' || c == '+'))
               ++*s;
           *len = *s - *beg;
           return XPM_TK_IDENT;
@@ -5014,7 +5016,7 @@ pbm_scan_number (unsigned char **s, unsigned char *end)
   while (*s < end)
     {
       /* Skip white-space.  */
-      while (*s < end && (c = *(*s)++, isspace (c)))
+      while (*s < end && (c = *(*s)++, c_isspace (c)))
         ;
 
       if (c == '#')
@@ -5023,11 +5025,11 @@ pbm_scan_number (unsigned char **s, unsigned char *end)
           while (*s < end && (c = *(*s)++, c != '\n'))
             ;
         }
-      else if (isdigit (c))
+      else if (c_isdigit (c))
         {
           /* Read decimal number.  */
           val = c - '0';
-          while (*s < end && (c = *(*s)++, isdigit (c)))
+          while (*s < end && (c = *(*s)++, c_isdigit (c)))
             val = 10 * val + c - '0';
           break;
         }
@@ -8554,7 +8556,7 @@ gs_load (struct frame *f, struct image *img)
      don't either.  Let the Lisp loader use `unwind-protect' instead.  */
   printnum1 = FRAME_X_WINDOW (f);
   printnum2 = img->pixmap;
-  window_and_pixmap_id 
+  window_and_pixmap_id
     = make_formatted_string (buffer, "%"pMu" %"pMu, printnum1, printnum2);
 
   printnum1 = FRAME_FOREGROUND_PIXEL (f);
diff --git a/src/indent.c b/src/indent.c
index 881e5d7ddaf..160b8c7479e 100644
--- a/src/indent.c
+++ b/src/indent.c
@@ -141,7 +141,7 @@ recompute_width_table (struct buffer *buf, struct Lisp_Char_Table *disptab)
   struct Lisp_Vector *widthtab;
 
   if (!VECTORP (BVAR (buf, width_table)))
-    BSET (buf, width_table, Fmake_vector (make_number (256), make_number (0)));
+    bset_width_table (buf, Fmake_vector (make_number (256), make_number (0)));
   widthtab = XVECTOR (BVAR (buf, width_table));
   if (widthtab->header.size != 256)
     abort ();
@@ -166,7 +166,7 @@ width_run_cache_on_off (void)
         {
           free_region_cache (current_buffer->width_run_cache);
           current_buffer->width_run_cache = 0;
-          BSET (current_buffer, width_table, Qnil);
+          bset_width_table (current_buffer, Qnil);
         }
     }
   else
@@ -336,7 +336,7 @@ current_column (void)
 
   /* If the buffer has overlays, text properties,
      or multibyte characters, use a more general algorithm.  */
-  if (buffer_get_intervals (current_buffer)
+  if (buffer_intervals (current_buffer)
       || buffer_has_overlays ()
       || Z != Z_BYTE)
     return current_column_1 ();
@@ -2003,7 +2003,7 @@ whether or not it is currently displayed in some window.  */)
       old_buffer = w->buffer;
       old_charpos = XMARKER (w->pointm)->charpos;
       old_bytepos = XMARKER (w->pointm)->bytepos;
-      WSET (w, buffer, Fcurrent_buffer ());
+      wset_buffer (w, Fcurrent_buffer ());
       set_marker_both (w->pointm, w->buffer,
                        BUF_PT (current_buffer), BUF_PT_BYTE (current_buffer));
     }
@@ -2146,7 +2146,7 @@ whether or not it is currently displayed in some window.  */)
 
   if (BUFFERP (old_buffer))
     {
-      WSET (w, buffer, old_buffer);
+      wset_buffer (w, old_buffer);
       set_marker_both (w->pointm, w->buffer,
                        old_charpos, old_bytepos);
     }
diff --git a/src/insdel.c b/src/insdel.c
index 14d2dab084d..1dceb67bffa 100644
--- a/src/insdel.c
+++ b/src/insdel.c
@@ -844,10 +844,10 @@ insert_1_both (const char *string,
                              PT + nchars, PT_BYTE + nbytes,
                              before_markers);
 
-  if (buffer_get_intervals (current_buffer))
+  if (buffer_intervals (current_buffer))
     offset_intervals (current_buffer, PT, nchars);
 
-  if (!inherit && buffer_get_intervals (current_buffer))
+  if (!inherit && buffer_intervals (current_buffer))
     set_text_properties (make_number (PT), make_number (PT + nchars),
                          Qnil, Qnil, Qnil);
 
@@ -976,7 +976,7 @@ insert_from_string_1 (Lisp_Object string, ptrdiff_t pos, ptrdiff_t pos_byte,
 
   offset_intervals (current_buffer, PT, nchars);
 
-  intervals = string_get_intervals (string);
+  intervals = string_intervals (string);
   /* Get the intervals for the part of the string we are inserting.  */
   if (nbytes < SBYTES (string))
     intervals = copy_intervals (intervals, pos, nchars);
@@ -1017,7 +1017,7 @@ insert_from_gap (ptrdiff_t nchars, ptrdiff_t nbytes)
   adjust_markers_for_insert (GPT - nchars, GPT_BYTE - nbytes,
                              GPT, GPT_BYTE, 0);
 
-  if (buffer_get_intervals (current_buffer))
+  if (buffer_intervals (current_buffer))
     {
       offset_intervals (current_buffer, GPT - nchars, nchars);
       graft_intervals_into_buffer (NULL, GPT - nchars, nchars,
@@ -1157,11 +1157,11 @@ insert_from_buffer_1 (struct buffer *buf,
                              PT_BYTE + outgoing_nbytes,
                              0);
 
-  if (buffer_get_intervals (current_buffer))
+  if (buffer_intervals (current_buffer))
     offset_intervals (current_buffer, PT, nchars);
 
   /* Get the intervals for the part of the string we are inserting.  */
-  intervals = buffer_get_intervals (buf);
+  intervals = buffer_intervals (buf);
   if (nchars < BUF_Z (buf) - BUF_BEG (buf))
     {
       if (buf == current_buffer && PT <= from)
@@ -1226,7 +1226,7 @@ adjust_after_replace (ptrdiff_t from, ptrdiff_t from_byte,
   else if (len < nchars_del)
     adjust_overlays_for_delete (from, nchars_del - len);
 
-  if (buffer_get_intervals (current_buffer))
+  if (buffer_intervals (current_buffer))
     offset_intervals (current_buffer, from, len - nchars_del);
 
   if (from < PT)
@@ -1412,7 +1412,7 @@ replace_range (ptrdiff_t from, ptrdiff_t to, Lisp_Object new,
 
   /* Get the intervals for the part of the string we are inserting--
      not including the combined-before bytes.  */
-  intervals = string_get_intervals (new);
+  intervals = string_intervals (new);
   /* Insert those intervals.  */
   graft_intervals_into_buffer (intervals, from, inschars,
                                current_buffer, inherit);
@@ -1792,7 +1792,7 @@ modify_region (struct buffer *buffer, ptrdiff_t start, ptrdiff_t end,
   if (! preserve_chars_modiff)
     CHARS_MODIFF = MODIFF;
 
-  BSET (buffer, point_before_scroll, Qnil);
+  bset_point_before_scroll (buffer, Qnil);
 
   if (buffer != old_buffer)
     set_buffer_internal (old_buffer);
@@ -1822,7 +1822,7 @@ prepare_to_modify_buffer (ptrdiff_t start, ptrdiff_t end,
   if (XBUFFER (XWINDOW (selected_window)->buffer) != current_buffer)
     ++windows_or_buffers_changed;
 
-  if (buffer_get_intervals (current_buffer))
+  if (buffer_intervals (current_buffer))
     {
       if (preserve_ptr)
         {
diff --git a/src/intervals.c b/src/intervals.c
index 09949bbbd45..0a85e20e5d9 100644
--- a/src/intervals.c
+++ b/src/intervals.c
@@ -59,10 +59,41 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 static Lisp_Object merge_properties_sticky (Lisp_Object, Lisp_Object);
 static INTERVAL merge_interval_right (INTERVAL);
 static INTERVAL reproduce_tree (INTERVAL, INTERVAL);
-static INTERVAL reproduce_tree_obj (INTERVAL, Lisp_Object);
 
 /* Utility functions for intervals.  */
 
+/* Use these functions to set Lisp_Object
+   or pointer slots of struct interval.  */
+
+static inline void
+set_interval_object (INTERVAL i, Lisp_Object obj)
+{
+  eassert (BUFFERP (obj) || STRINGP (obj));
+  i->up_obj = 1;
+  i->up.obj = obj;
+}
+
+static inline void
+set_interval_left (INTERVAL i, INTERVAL left)
+{
+  i->left = left;
+}
+
+static inline void
+set_interval_right (INTERVAL i, INTERVAL right)
+{
+  i->right = right;
+}
+
+/* Make the parent of D be whatever the parent of S is, regardless
+   of the type.  This is used when balancing an interval tree.  */
+
+static inline void
+copy_interval_parent (INTERVAL d, INTERVAL s)
+{
+  d->up = s->up;
+  d->up_obj = s->up_obj;
+}
 
 /* Create the root interval of some object, a buffer or string.  */
 
@@ -80,18 +111,18 @@ create_root_interval (Lisp_Object parent)
       new->total_length = (BUF_Z (XBUFFER (parent))
                            - BUF_BEG (XBUFFER (parent)));
       eassert (0 <= TOTAL_LENGTH (new));
-      buffer_set_intervals (XBUFFER (parent), new);
+      set_buffer_intervals (XBUFFER (parent), new);
       new->position = BEG;
     }
   else if (STRINGP (parent))
     {
       new->total_length = SCHARS (parent);
       eassert (0 <= TOTAL_LENGTH (new));
-      string_set_intervals (parent, new);
+      set_string_intervals (parent, new);
       new->position = 0;
     }
 
-  interval_set_object (new, parent);
+  set_interval_object (new, parent);
 
   return new;
 }
@@ -105,7 +136,7 @@ copy_properties (register INTERVAL source, register INTERVAL target)
     return;
 
   COPY_INTERVAL_CACHE (source, target);
-  interval_set_plist (target, Fcopy_sequence (source->plist));
+  set_interval_plist (target, Fcopy_sequence (source->plist));
 }
 
 /* Merge the properties of interval SOURCE into the properties
@@ -141,7 +172,7 @@ merge_properties (register INTERVAL source, register INTERVAL target)
       if (NILP (val))
         {
           val = XCAR (o);
-          interval_set_plist (target, Fcons (sym, Fcons (val, target->plist)));
+          set_interval_plist (target, Fcons (sym, Fcons (val, target->plist)));
         }
       o = XCDR (o);
     }
@@ -323,21 +354,21 @@ rotate_right (INTERVAL interval)
   if (! ROOT_INTERVAL_P (interval))
     {
       if (AM_LEFT_CHILD (interval))
-        interval_set_left (INTERVAL_PARENT (interval), B);
+        set_interval_left (INTERVAL_PARENT (interval), B);
       else
-        interval_set_right (INTERVAL_PARENT (interval), B);
+        set_interval_right (INTERVAL_PARENT (interval), B);
     }
-  interval_copy_parent (B, interval);
+  copy_interval_parent (B, interval);
 
   /* Make B the parent of A */
   i = B->right;
-  interval_set_right (B, interval);
-  interval_set_parent (interval, B);
+  set_interval_right (B, interval);
+  set_interval_parent (interval, B);
 
   /* Make A point to c */
-  interval_set_left (interval, i);
+  set_interval_left (interval, i);
   if (i)
-    interval_set_parent (i, interval);
+    set_interval_parent (i, interval);
 
   /* A's total length is decreased by the length of B and its left child.  */
   interval->total_length -= B->total_length - LEFT_TOTAL_LENGTH (interval);
@@ -370,21 +401,21 @@ rotate_left (INTERVAL interval)
   if (! ROOT_INTERVAL_P (interval))
     {
       if (AM_LEFT_CHILD (interval))
-        interval_set_left (INTERVAL_PARENT (interval), B);
+        set_interval_left (INTERVAL_PARENT (interval), B);
       else
-        interval_set_right (INTERVAL_PARENT (interval), B);
+        set_interval_right (INTERVAL_PARENT (interval), B);
     }
-  interval_copy_parent (B, interval);
+  copy_interval_parent (B, interval);
 
   /* Make B the parent of A */
   i = B->left;
-  interval_set_left (B, interval);
-  interval_set_parent (interval, B);
+  set_interval_left (B, interval);
+  set_interval_parent (interval, B);
 
   /* Make A point to c */
-  interval_set_right (interval, i);
+  set_interval_right (interval, i);
   if (i)
-    interval_set_parent (i, interval);
+    set_interval_parent (i, interval);
 
   /* A's total length is decreased by the length of B and its right child.  */
   interval->total_length -= B->total_length - RIGHT_TOTAL_LENGTH (interval);
@@ -456,9 +487,9 @@ balance_possible_root_interval (register INTERVAL interval)
   if (have_parent)
     {
       if (BUFFERP (parent))
-        buffer_set_intervals (XBUFFER (parent), interval);
+        set_buffer_intervals (XBUFFER (parent), interval);
       else if (STRINGP (parent))
-        string_set_intervals (parent, interval);
+        set_string_intervals (parent, interval);
     }
 
   return interval;
@@ -494,9 +525,9 @@ buffer_balance_intervals (struct buffer *b)
   INTERVAL i;
 
   eassert (b != NULL);
-  i = buffer_get_intervals (b);
+  i = buffer_intervals (b);
   if (i)
-    buffer_set_intervals (b, balance_an_interval (i));
+    set_buffer_intervals (b, balance_an_interval (i));
 }
 
 /* Split INTERVAL into two pieces, starting the second piece at
@@ -520,20 +551,20 @@ split_interval_right (INTERVAL interval, ptrdiff_t offset)
   ptrdiff_t new_length = LENGTH (interval) - offset;
 
   new->position = position + offset;
-  interval_set_parent (new, interval);
+  set_interval_parent (new, interval);
 
   if (NULL_RIGHT_CHILD (interval))
     {
-      interval_set_right (interval, new);
+      set_interval_right (interval, new);
       new->total_length = new_length;
       eassert (0 <= TOTAL_LENGTH (new));
     }
   else
     {
       /* Insert the new node between INTERVAL and its right child.  */
-      interval_set_right (new, interval->right);
-      interval_set_parent (interval->right, new);
-      interval_set_right (interval, new);
+      set_interval_right (new, interval->right);
+      set_interval_parent (interval->right, new);
+      set_interval_right (interval, new);
       new->total_length = new_length + new->right->total_length;
       eassert (0 <= TOTAL_LENGTH (new));
       balance_an_interval (new);
@@ -565,20 +596,20 @@ split_interval_left (INTERVAL interval, ptrdiff_t offset)
 
   new->position = interval->position;
   interval->position = interval->position + offset;
-  interval_set_parent (new, interval);
+  set_interval_parent (new, interval);
 
   if (NULL_LEFT_CHILD (interval))
     {
-      interval_set_left (interval, new);
+      set_interval_left (interval, new);
       new->total_length = new_length;
       eassert (0 <= TOTAL_LENGTH (new));
     }
   else
     {
       /* Insert the new node between INTERVAL and its left child.  */
-      interval_set_left (new, interval->left);
-      interval_set_parent (new->left, new);
-      interval_set_left (interval, new);
+      set_interval_left (new, interval->left);
+      set_interval_parent (new->left, new);
+      set_interval_left (interval, new);
       new->total_length = new_length + new->left->total_length;
       eassert (0 <= TOTAL_LENGTH (new));
       balance_an_interval (new);
@@ -953,20 +984,20 @@ adjust_intervals_for_insertion (INTERVAL tree,
           RESET_INTERVAL (&newi);
           pleft = prev ? prev->plist : Qnil;
           pright = i ? i->plist : Qnil;
-          interval_set_plist (&newi, merge_properties_sticky (pleft, pright));
+          set_interval_plist (&newi, merge_properties_sticky (pleft, pright));
 
           if (! prev) /* i.e. position == BEG */
             {
               if (! intervals_equal (i, &newi))
                 {
                   i = split_interval_left (i, length);
-                  interval_set_plist (i, newi.plist);
+                  set_interval_plist (i, newi.plist);
                 }
             }
           else if (! intervals_equal (prev, &newi))
             {
               prev = split_interval_right (prev, position - prev->position);
-              interval_set_plist (prev, newi.plist);
+              set_interval_plist (prev, newi.plist);
               if (i && intervals_equal (prev, i))
                 merge_interval_right (prev);
             }
@@ -1191,8 +1222,8 @@ delete_node (register INTERVAL i)
       this->total_length += migrate_amt;
     }
   eassert (0 <= TOTAL_LENGTH (this));
-  interval_set_left (this, migrate);
-  interval_set_parent (migrate, this);
+  set_interval_left (this, migrate);
+  set_interval_parent (migrate, this);
 
   return i->right;
 }
@@ -1217,12 +1248,12 @@ delete_interval (register INTERVAL i)
       GET_INTERVAL_OBJECT (owner, i);
       parent = delete_node (i);
       if (parent)
-        interval_set_object (parent, owner);
+        set_interval_object (parent, owner);
 
       if (BUFFERP (owner))
-        buffer_set_intervals (XBUFFER (owner), parent);
+        set_buffer_intervals (XBUFFER (owner), parent);
       else if (STRINGP (owner))
-        string_set_intervals (owner, parent);
+        set_string_intervals (owner, parent);
       else
         abort ();
 
@@ -1232,15 +1263,15 @@ delete_interval (register INTERVAL i)
   parent = INTERVAL_PARENT (i);
   if (AM_LEFT_CHILD (i))
     {
-      interval_set_left (parent, delete_node (i));
+      set_interval_left (parent, delete_node (i));
       if (parent->left)
-        interval_set_parent (parent->left, parent);
+        set_interval_parent (parent->left, parent);
     }
   else
     {
-      interval_set_right (parent, delete_node (i));
+      set_interval_right (parent, delete_node (i));
       if (parent->right)
-        interval_set_parent (parent->right, parent);
+        set_interval_parent (parent->right, parent);
     }
 }
 
@@ -1321,8 +1352,8 @@ static void
 adjust_intervals_for_deletion (struct buffer *buffer,
                                ptrdiff_t start, ptrdiff_t length)
 {
-  register ptrdiff_t left_to_delete = length;
-  register INTERVAL tree = buffer_get_intervals (buffer);
+  ptrdiff_t left_to_delete = length;
+  INTERVAL tree = buffer_intervals (buffer);
   Lisp_Object parent;
   ptrdiff_t offset;
 
@@ -1337,7 +1368,7 @@ adjust_intervals_for_deletion (struct buffer *buffer,
 
   if (length == TOTAL_LENGTH (tree))
     {
-      buffer_set_intervals (buffer, NULL);
+      set_buffer_intervals (buffer, NULL);
       return;
     }
 
@@ -1354,10 +1385,10 @@ adjust_intervals_for_deletion (struct buffer *buffer,
     {
       left_to_delete -= interval_deletion_adjustment (tree, start - offset,
                                                       left_to_delete);
-      tree = buffer_get_intervals (buffer);
+      tree = buffer_intervals (buffer);
       if (left_to_delete == tree->total_length)
         {
-          buffer_set_intervals (buffer, NULL);
+          set_buffer_intervals (buffer, NULL);
           return;
         }
     }
@@ -1371,11 +1402,11 @@ adjust_intervals_for_deletion (struct buffer *buffer,
 void
 offset_intervals (struct buffer *buffer, ptrdiff_t start, ptrdiff_t length)
 {
-  if (!buffer_get_intervals (buffer) || length == 0)
+  if (!buffer_intervals (buffer) || length == 0)
     return;
 
   if (length > 0)
-    adjust_intervals_for_insertion (buffer_get_intervals (buffer),
+    adjust_intervals_for_insertion (buffer_intervals (buffer),
                                     start, length);
   else
     {
@@ -1498,6 +1529,26 @@ merge_interval_left (register INTERVAL i)
   abort ();
 }
 
+/* Create a copy of SOURCE but with the default value of UP.  */
+
+static INTERVAL
+reproduce_interval (INTERVAL source)
+{
+  register INTERVAL target = make_interval ();
+
+  target->total_length = source->total_length;
+  target->position = source->position;
+
+  copy_properties (source, target);
+
+  if (! NULL_LEFT_CHILD (source))
+    set_interval_left (target, reproduce_tree (source->left, target));
+  if (! NULL_RIGHT_CHILD (source))
+    set_interval_right (target, reproduce_tree (source->right, target));
+
+  return target;
+}
+
 /* Make an exact copy of interval tree SOURCE which descends from
    PARENT.  This is done by recursing through SOURCE, copying
    the current interval and its properties, and then adjusting
@@ -1506,33 +1557,17 @@ merge_interval_left (register INTERVAL i)
 static INTERVAL
 reproduce_tree (INTERVAL source, INTERVAL parent)
 {
-  register INTERVAL t = make_interval ();
-
-  memcpy (t, source, sizeof *t);
-  copy_properties (source, t);
-  interval_set_parent (t, parent);
-  if (! NULL_LEFT_CHILD (source))
-    interval_set_left (t, reproduce_tree (source->left, t));
-  if (! NULL_RIGHT_CHILD (source))
-    interval_set_right (t, reproduce_tree (source->right, t));
-
-  return t;
+  INTERVAL target = reproduce_interval (source);
+  set_interval_parent (target, parent);
+  return target;
 }
 
 static INTERVAL
 reproduce_tree_obj (INTERVAL source, Lisp_Object parent)
 {
-  register INTERVAL t = make_interval ();
-
-  memcpy (t, source, sizeof *t);
-  copy_properties (source, t);
-  interval_set_object (t, parent);
-  if (! NULL_LEFT_CHILD (source))
-    interval_set_left (t, reproduce_tree (source->left, t));
-  if (! NULL_RIGHT_CHILD (source))
-    interval_set_right (t, reproduce_tree (source->right, t));
-
-  return t;
+  INTERVAL target = reproduce_interval (source);
+  set_interval_object (target, parent);
+  return target;
 }
 
 /* Insert the intervals of SOURCE into BUFFER at POSITION.
@@ -1577,12 +1612,10 @@ graft_intervals_into_buffer (INTERVAL source, ptrdiff_t position,
                              ptrdiff_t length, struct buffer *buffer,
                              int inherit)
 {
-  register INTERVAL under, over, this;
-  register INTERVAL tree;
+  INTERVAL tree = buffer_intervals (buffer);
+  INTERVAL under, over, this;
   ptrdiff_t over_used;
 
-  tree = buffer_get_intervals (buffer);
-
   /* If the new text has no properties, then with inheritance it
      becomes part of whatever interval it was inserted into.
      To prevent inheritance, we must clear out the properties
@@ -1611,9 +1644,9 @@ graft_intervals_into_buffer (INTERVAL source, ptrdiff_t position,
       Lisp_Object buf;
 
       XSETBUFFER (buf, buffer);
-      buffer_set_intervals (buffer, reproduce_tree_obj (source, buf));
-      buffer_get_intervals (buffer)->position = BUF_BEG (buffer);
-      eassert (buffer_get_intervals (buffer)->up_obj == 1);
+      set_buffer_intervals (buffer, reproduce_tree_obj (source, buf));
+      buffer_intervals (buffer)->position = BUF_BEG (buffer);
+      eassert (buffer_intervals (buffer)->up_obj == 1);
       return;
     }
   else if (!tree)
@@ -1854,7 +1887,7 @@ set_point_both (ptrdiff_t charpos, ptrdiff_t bytepos)
   int have_overlays;
   ptrdiff_t original_position;
 
-  BSET (current_buffer, point_before_scroll, Qnil);
+  bset_point_before_scroll (current_buffer, Qnil);
 
   if (charpos == PT)
     return;
@@ -1871,7 +1904,7 @@ set_point_both (ptrdiff_t charpos, ptrdiff_t bytepos)
 
   /* If we have no text properties and overlays,
      then we can do it quickly.  */
-  if (!buffer_get_intervals (current_buffer) && ! have_overlays)
+  if (!buffer_intervals (current_buffer) && ! have_overlays)
     {
       temp_set_point_both (current_buffer, charpos, bytepos);
       return;
@@ -1880,7 +1913,7 @@ set_point_both (ptrdiff_t charpos, ptrdiff_t bytepos)
   /* Set TO to the interval containing the char after CHARPOS,
      and TOPREV to the interval containing the char before CHARPOS.
      Either one may be null.  They may be equal.  */
-  to = find_interval (buffer_get_intervals (current_buffer), charpos);
+  to = find_interval (buffer_intervals (current_buffer), charpos);
   if (charpos == BEGV)
     toprev = 0;
   else if (to && to->position == charpos)
@@ -1894,7 +1927,7 @@ set_point_both (ptrdiff_t charpos, ptrdiff_t bytepos)
      and FROMPREV to the interval containing the char before PT.
      Either one may be null.  They may be equal.  */
   /* We could cache this and save time.  */
-  from = find_interval (buffer_get_intervals (current_buffer), buffer_point);
+  from = find_interval (buffer_intervals (current_buffer), buffer_point);
   if (buffer_point == BEGV)
     fromprev = 0;
   else if (from && from->position == PT)
@@ -2000,7 +2033,7 @@ set_point_both (ptrdiff_t charpos, ptrdiff_t bytepos)
       /* Set TO to the interval containing the char after CHARPOS,
          and TOPREV to the interval containing the char before CHARPOS.
          Either one may be null.  They may be equal.  */
-      to = find_interval (buffer_get_intervals (current_buffer), charpos);
+      to = find_interval (buffer_intervals (current_buffer), charpos);
       if (charpos == BEGV)
         toprev = 0;
       else if (to && to->position == charpos)
@@ -2133,11 +2166,11 @@ get_property_and_range (ptrdiff_t pos, Lisp_Object prop, Lisp_Object *val,
   INTERVAL i, prev, next;
 
   if (NILP (object))
-    i = find_interval (buffer_get_intervals (current_buffer), pos);
+    i = find_interval (buffer_intervals (current_buffer), pos);
   else if (BUFFERP (object))
-    i = find_interval (buffer_get_intervals (XBUFFER (object)), pos);
+    i = find_interval (buffer_intervals (XBUFFER (object)), pos);
   else if (STRINGP (object))
-    i = find_interval (string_get_intervals (object), pos);
+    i = find_interval (string_intervals (object), pos);
   else
     abort ();
 
@@ -2264,13 +2297,13 @@ void
 copy_intervals_to_string (Lisp_Object string, struct buffer *buffer,
                           ptrdiff_t position, ptrdiff_t length)
 {
-  INTERVAL interval_copy = copy_intervals (buffer_get_intervals (buffer),
+  INTERVAL interval_copy = copy_intervals (buffer_intervals (buffer),
                                            position, length);
   if (!interval_copy)
     return;
 
-  interval_set_object (interval_copy, string);
-  string_set_intervals (string, interval_copy);
+  set_interval_object (interval_copy, string);
+  set_string_intervals (string, interval_copy);
 }
 
 /* Return 1 if strings S1 and S2 have identical properties; 0 otherwise.
@@ -2283,8 +2316,8 @@ compare_string_intervals (Lisp_Object s1, Lisp_Object s2)
   ptrdiff_t pos = 0;
   ptrdiff_t end = SCHARS (s1);
 
-  i1 = find_interval (string_get_intervals (s1), 0);
-  i2 = find_interval (string_get_intervals (s2), 0);
+  i1 = find_interval (string_intervals (s1), 0);
+  i2 = find_interval (string_intervals (s2), 0);
 
   while (pos < end)
     {
@@ -2409,13 +2442,13 @@ set_intervals_multibyte_1 (INTERVAL i, int multi_flag,
     {
       if ((i)->left)
         {
-          interval_set_plist (i, i->left->plist);
+          set_interval_plist (i, i->left->plist);
           (i)->left->total_length = 0;
           delete_interval ((i)->left);
         }
       else
         {
-          interval_set_plist (i, i->right->plist);
+          set_interval_plist (i, i->right->plist);
           (i)->right->total_length = 0;
           delete_interval ((i)->right);
         }
@@ -2429,7 +2462,7 @@ set_intervals_multibyte_1 (INTERVAL i, int multi_flag,
 void
 set_intervals_multibyte (int multi_flag)
 {
-  INTERVAL i = buffer_get_intervals (current_buffer);
+  INTERVAL i = buffer_intervals (current_buffer);
 
   if (i)
     set_intervals_multibyte_1 (i, multi_flag, BEG, BEG_BYTE, Z, Z_BYTE);
diff --git a/src/intervals.h b/src/intervals.h
index a5166c6376f..01e72d7c9db 100644
--- a/src/intervals.h
+++ b/src/intervals.h
@@ -137,47 +137,16 @@ struct interval
    or pointer slots of struct interval.  */
 
 INTERVALS_INLINE void
-interval_set_parent (INTERVAL i, INTERVAL parent)
+set_interval_parent (INTERVAL i, INTERVAL parent)
 {
   i->up_obj = 0;
   i->up.interval = parent;
 }
 
 INTERVALS_INLINE void
-interval_set_object (INTERVAL i, Lisp_Object obj)
-{
-  eassert (BUFFERP (obj) || STRINGP (obj));
-  i->up_obj = 1;
-  i->up.obj = obj;
-}
-
-INTERVALS_INLINE void
-interval_set_left (INTERVAL i, INTERVAL left)
-{
-  i->left = left;
-}
-
-INTERVALS_INLINE void
-interval_set_right (INTERVAL i, INTERVAL right)
-{
-  i->right = right;
-}
-
-INTERVALS_INLINE Lisp_Object
-interval_set_plist (INTERVAL i, Lisp_Object plist)
+set_interval_plist (INTERVAL i, Lisp_Object plist)
 {
   i->plist = plist;
-  return plist;
-}
-
-/* Make the parent of D be whatever the parent of S is, regardless
-   of the type.  This is used when balancing an interval tree.  */
-
-INTERVALS_INLINE void
-interval_copy_parent (INTERVAL d, INTERVAL s)
-{
-  d->up = s->up;
-  d->up_obj = s->up_obj;
 }
 
 /* Get the parent interval, if any, otherwise a null pointer.  Useful
@@ -191,11 +160,11 @@ interval_copy_parent (INTERVAL d, INTERVAL s)
 {                                             \
   (i)->total_length = (i)->position = 0;      \
   (i)->left = (i)->right = NULL;              \
-  interval_set_parent (i, NULL);              \
+  set_interval_parent (i, NULL);              \
   (i)->write_protect = 0;                     \
   (i)->visible = 0;                           \
   (i)->front_sticky = (i)->rear_sticky = 0;   \
-  interval_set_plist (i, Qnil);               \
+  set_interval_plist (i, Qnil);               \
 }
 
 /* Copy the cached property values of interval FROM to interval TO.  */
diff --git a/src/keyboard.c b/src/keyboard.c
index 0b3c48ab713..7b9be358caa 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -18,6 +18,9 @@ You should have received a copy of the GNU General Public License
 along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include <config.h>
+
+#define KEYBOARD_INLINE EXTERN_INLINE
+
 #include <signal.h>
 #include <stdio.h>
 #include <setjmp.h>
@@ -472,6 +475,53 @@ static void handle_user_signal (int);
 static char *find_user_signal_name (int);
 static int store_user_signal_events (void);
 
+/* These setters are used only in this file, so they can be private.  */
+static inline void
+kset_echo_string (struct kboard *kb, Lisp_Object val)
+{
+  kb->INTERNAL_FIELD (echo_string) = val;
+}
+static inline void
+kset_kbd_queue (struct kboard *kb, Lisp_Object val)
+{
+  kb->INTERNAL_FIELD (kbd_queue) = val;
+}
+static inline void
+kset_keyboard_translate_table (struct kboard *kb, Lisp_Object val)
+{
+  kb->INTERNAL_FIELD (Vkeyboard_translate_table) = val;
+}
+static inline void
+kset_last_prefix_arg (struct kboard *kb, Lisp_Object val)
+{
+  kb->INTERNAL_FIELD (Vlast_prefix_arg) = val;
+}
+static inline void
+kset_last_repeatable_command (struct kboard *kb, Lisp_Object val)
+{
+  kb->INTERNAL_FIELD (Vlast_repeatable_command) = val;
+}
+static inline void
+kset_local_function_key_map (struct kboard *kb, Lisp_Object val)
+{
+  kb->INTERNAL_FIELD (Vlocal_function_key_map) = val;
+}
+static inline void
+kset_overriding_terminal_local_map (struct kboard *kb, Lisp_Object val)
+{
+  kb->INTERNAL_FIELD (Voverriding_terminal_local_map) = val;
+}
+static inline void
+kset_real_last_command (struct kboard *kb, Lisp_Object val)
+{
+  kb->INTERNAL_FIELD (Vreal_last_command) = val;
+}
+static inline void
+kset_system_key_syms (struct kboard *kb, Lisp_Object val)
+{
+  kb->INTERNAL_FIELD (system_key_syms) = val;
+}
+
 
 /* Add C to the echo string, if echoing is going on.
    C can be a character, which is printed prettily ("M-C-x" and all that
@@ -554,8 +604,9 @@ echo_char (Lisp_Object c)
       else if (STRINGP (echo_string))
         echo_string = concat2 (echo_string, build_string (" "));
 
-      KSET (current_kboard, echo_string,
-            concat2 (echo_string, make_string (buffer, ptr - buffer)));
+      kset_echo_string
+        (current_kboard,
+         concat2 (echo_string, make_string (buffer, ptr - buffer)));
 
       echo_now ();
     }
@@ -600,8 +651,9 @@ echo_dash (void)
 
   /* Put a dash at the end of the buffer temporarily,
      but make it go away when the next character is added.  */
-  KSET (current_kboard, echo_string,
-        concat2 (KVAR (current_kboard, echo_string), build_string ("-")));
+  kset_echo_string
+    (current_kboard,
+     concat2 (KVAR (current_kboard, echo_string), build_string ("-")));
   echo_now ();
 }
 
@@ -663,7 +715,7 @@ cancel_echoing (void)
 {
   current_kboard->immediate_echo = 0;
   current_kboard->echo_after_prompt = -1;
-  KSET (current_kboard, echo_string, Qnil);
+  kset_echo_string (current_kboard, Qnil);
   ok_to_echo_at_next_pause = NULL;
   echo_kboard = NULL;
   echo_message_buffer = Qnil;
@@ -687,9 +739,9 @@ static void
 echo_truncate (ptrdiff_t nchars)
 {
   if (STRINGP (KVAR (current_kboard, echo_string)))
-    KSET (current_kboard, echo_string,
-          Fsubstring (KVAR (current_kboard, echo_string),
-                      make_number (0), make_number (nchars)));
+    kset_echo_string (current_kboard,
+                      Fsubstring (KVAR (current_kboard, echo_string),
+                                  make_number (0), make_number (nchars)));
   truncate_echo_area (nchars);
 }
 
@@ -1019,8 +1071,8 @@ cmd_error (Lisp_Object data)
   Vstandard_input = Qt;
   Vexecuting_kbd_macro = Qnil;
   executing_kbd_macro = Qnil;
-  KSET (current_kboard, Vprefix_arg, Qnil);
-  KSET (current_kboard, Vlast_prefix_arg, Qnil);
+  kset_prefix_arg (current_kboard, Qnil);
+  kset_last_prefix_arg (current_kboard, Qnil);
   cancel_echoing ();
 
   /* Avoid unquittable loop if data contains a circular list.  */
@@ -1341,8 +1393,8 @@ command_loop_1 (void)
 #endif
   int already_adjusted = 0;
 
-  KSET (current_kboard, Vprefix_arg, Qnil);
-  KSET (current_kboard, Vlast_prefix_arg, Qnil);
+  kset_prefix_arg (current_kboard, Qnil);
+  kset_last_prefix_arg (current_kboard, Qnil);
   Vdeactivate_mark = Qnil;
   waiting_for_input = 0;
   cancel_echoing ();
@@ -1374,10 +1426,10 @@ command_loop_1 (void)
     }
 
   /* Do this after running Vpost_command_hook, for consistency.  */
-  KSET (current_kboard, Vlast_command, Vthis_command);
-  KSET (current_kboard, Vreal_last_command, Vreal_this_command);
+  kset_last_command (current_kboard, Vthis_command);
+  kset_real_last_command (current_kboard, Vreal_this_command);
   if (!CONSP (last_command_event))
-    KSET (current_kboard, Vlast_repeatable_command, Vreal_this_command);
+    kset_last_repeatable_command (current_kboard, Vreal_this_command);
 
   while (1)
     {
@@ -1549,7 +1601,7 @@ command_loop_1 (void)
           keys = Fkey_description (keys, Qnil);
           bitch_at_user ();
           message_with_string ("%s is undefined", keys, 0);
-          KSET (current_kboard, defining_kbd_macro, Qnil);
+          kset_defining_kbd_macro (current_kboard, Qnil);
           update_mode_lines = 1;
           /* If this is a down-mouse event, don't reset prefix-arg;
              pass it to the command run by the up event.  */
@@ -1559,10 +1611,10 @@ command_loop_1 (void)
                 = parse_modifiers (EVENT_HEAD (last_command_event));
               int modifiers = XINT (XCAR (XCDR (breakdown)));
               if (!(modifiers & down_modifier))
-                KSET (current_kboard, Vprefix_arg, Qnil);
+                kset_prefix_arg (current_kboard, Qnil);
             }
           else
-            KSET (current_kboard, Vprefix_arg, Qnil);
+            kset_prefix_arg (current_kboard, Qnil);
         }
       else
         {
@@ -1599,7 +1651,7 @@ command_loop_1 (void)
             unbind_to (scount, Qnil);
 #endif
           }
-      KSET (current_kboard, Vlast_prefix_arg, Vcurrent_prefix_arg);
+      kset_last_prefix_arg (current_kboard, Vcurrent_prefix_arg);
 
       safe_run_hooks (Qpost_command_hook);
 
@@ -1630,10 +1682,10 @@ command_loop_1 (void)
       if (NILP (KVAR (current_kboard, Vprefix_arg))
           || CONSP (last_command_event))
         {
-          KSET (current_kboard, Vlast_command, Vthis_command);
-          KSET (current_kboard, Vreal_last_command, Vreal_this_command);
+          kset_last_command (current_kboard, Vthis_command);
+          kset_real_last_command (current_kboard, Vreal_this_command);
           if (!CONSP (last_command_event))
-            KSET (current_kboard, Vlast_repeatable_command, Vreal_this_command);
+            kset_last_repeatable_command (current_kboard, Vreal_this_command);
           cancel_echoing ();
           this_command_key_count = 0;
           this_command_key_count_reset = 0;
@@ -2576,7 +2628,7 @@ read_char (int commandflag, ptrdiff_t nmaps, Lisp_Object *maps,
                   abort ();
               }
             if (!CONSP (last))
-              KSET (kb, kbd_queue, Fcons (c, Qnil));
+              kset_kbd_queue (kb, Fcons (c, Qnil));
             else
               XSETCDR (last, Fcons (c, Qnil));
             kb->kbd_queue_has_data = 1;
@@ -2748,8 +2800,8 @@ read_char (int commandflag, ptrdiff_t nmaps, Lisp_Object *maps,
           if (!CONSP (KVAR (current_kboard, kbd_queue)))
             abort ();
           c = XCAR (KVAR (current_kboard, kbd_queue));
-          KSET (current_kboard, kbd_queue,
-                XCDR (KVAR (current_kboard, kbd_queue)));
+          kset_kbd_queue (current_kboard,
+                          XCDR (KVAR (current_kboard, kbd_queue)));
           if (NILP (KVAR (current_kboard, kbd_queue)))
             current_kboard->kbd_queue_has_data = 0;
           input_pending = readable_events (0);
@@ -2816,7 +2868,7 @@ read_char (int commandflag, ptrdiff_t nmaps, Lisp_Object *maps,
                 abort ();
             }
           if (!CONSP (last))
-            KSET (kb, kbd_queue, Fcons (c, Qnil));
+            kset_kbd_queue (kb, Fcons (c, Qnil));
           else
             XSETCDR (last, Fcons (c, Qnil));
           kb->kbd_queue_has_data = 1;
@@ -3074,7 +3126,7 @@ read_char (int commandflag, ptrdiff_t nmaps, Lisp_Object *maps,
 
       cancel_echoing ();
       ok_to_echo_at_next_pause = saved_ok_to_echo;
-      KSET (current_kboard, echo_string, saved_echo_string);
+      kset_echo_string (current_kboard, saved_echo_string);
       current_kboard->echo_after_prompt = saved_echo_after_prompt;
       if (saved_immediate_echo)
         echo_now ();
@@ -3545,9 +3597,9 @@ kbd_buffer_store_event_hold (register struct input_event *event,
 
           if (single_kboard && kb != current_kboard)
             {
-              KSET (kb, kbd_queue,
-                    Fcons (make_lispy_switch_frame (event->frame_or_window),
-                           Fcons (make_number (c), Qnil)));
+              kset_kbd_queue
+                (kb, Fcons (make_lispy_switch_frame (event->frame_or_window),
+                            Fcons (make_number (c), Qnil)));
               kb->kbd_queue_has_data = 1;
               for (sp = kbd_fetch_ptr; sp != kbd_store_ptr; sp++)
                 {
@@ -5426,7 +5478,7 @@ make_lispy_event (struct input_event *event)
           /* We need to use an alist rather than a vector as the cache
              since we can't make a vector long enough.  */
           if (NILP (KVAR (current_kboard, system_key_syms)))
-            KSET (current_kboard, system_key_syms, Fcons (Qnil, Qnil));
+            kset_system_key_syms (current_kboard, Fcons (Qnil, Qnil));
           return modify_event_symbol (event->code,
                                       event->modifiers,
                                       Qfunction_key,
@@ -8755,11 +8807,11 @@ read_char_minibuf_menu_prompt (int commandflag,
          is not used on replay.
          */
       orig_defn_macro = KVAR (current_kboard, defining_kbd_macro);
-      KSET (current_kboard, defining_kbd_macro, Qnil);
+      kset_defining_kbd_macro (current_kboard, Qnil);
       do
         obj = read_char (commandflag, 0, 0, Qt, 0, NULL);
       while (BUFFERP (obj));
-      KSET (current_kboard, defining_kbd_macro, orig_defn_macro);
+      kset_defining_kbd_macro (current_kboard, orig_defn_macro);
 
       if (!INTEGERP (obj))
         return obj;
@@ -9115,7 +9167,7 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
           /* Install the string STR as the beginning of the string of
              echoing, so that it serves as a prompt for the next
              character.  */
-          KSET (current_kboard, echo_string, prompt);
+          kset_echo_string (current_kboard, prompt);
           current_kboard->echo_after_prompt = SCHARS (prompt);
           echo_now ();
         }
@@ -9361,15 +9413,17 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
 
                 if (!NILP (delayed_switch_frame))
                   {
-                    KSET (interrupted_kboard, kbd_queue,
-                          Fcons (delayed_switch_frame,
-                                 KVAR (interrupted_kboard, kbd_queue)));
+                    kset_kbd_queue
+                      (interrupted_kboard,
+                       Fcons (delayed_switch_frame,
+                              KVAR (interrupted_kboard, kbd_queue)));
                     delayed_switch_frame = Qnil;
                   }
 
                 while (t > 0)
-                  KSET (interrupted_kboard, kbd_queue,
-                        Fcons (keybuf[--t], KVAR (interrupted_kboard, kbd_queue)));
+                  kset_kbd_queue
+                    (interrupted_kboard,
+                     Fcons (keybuf[--t], KVAR (interrupted_kboard, kbd_queue)));
 
                 /* If the side queue is non-empty, ensure it begins with a
                    switch-frame, so we'll replay it in the right context.  */
@@ -9381,9 +9435,10 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
                   {
                     Lisp_Object frame;
                     XSETFRAME (frame, interrupted_frame);
-                    KSET (interrupted_kboard, kbd_queue,
-                          Fcons (make_lispy_switch_frame (frame),
-                                 KVAR (interrupted_kboard, kbd_queue)));
+                    kset_kbd_queue
+                      (interrupted_kboard,
+                       Fcons (make_lispy_switch_frame (frame),
+                              KVAR (interrupted_kboard, kbd_queue)));
                   }
                 mock_input = 0;
                 orig_local_map = get_local_map (PT, current_buffer, Qlocal_map);
@@ -10277,7 +10332,7 @@ a special event, so ignore the prefix argument and don't clear it.  */)
     {
       prefixarg = KVAR (current_kboard, Vprefix_arg);
       Vcurrent_prefix_arg = prefixarg;
-      KSET (current_kboard, Vprefix_arg, Qnil);
+      kset_prefix_arg (current_kboard, Qnil);
     }
   else
     prefixarg = Qnil;
@@ -11216,11 +11271,8 @@ The `posn-' functions access elements of such lists.  */)
 
   if (WINDOWP (frame_or_window))
     {
-      struct window *w;
-
-      CHECK_LIVE_WINDOW (frame_or_window);
+      struct window *w = decode_valid_window (frame_or_window);
 
-      w = XWINDOW (frame_or_window);
       XSETINT (x, (XINT (x)
                    + WINDOW_LEFT_EDGE_X (w)
                    + (NILP (whole)
@@ -11275,30 +11327,30 @@ The `posn-' functions access elements of such lists.  */)
 void
 init_kboard (KBOARD *kb)
 {
-  KSET (kb, Voverriding_terminal_local_map, Qnil);
-  KSET (kb, Vlast_command, Qnil);
-  KSET (kb, Vreal_last_command, Qnil);
-  KSET (kb, Vkeyboard_translate_table, Qnil);
-  KSET (kb, Vlast_repeatable_command, Qnil);
-  KSET (kb, Vprefix_arg, Qnil);
-  KSET (kb, Vlast_prefix_arg, Qnil);
-  KSET (kb, kbd_queue, Qnil);
+  kset_overriding_terminal_local_map (kb, Qnil);
+  kset_last_command (kb, Qnil);
+  kset_real_last_command (kb, Qnil);
+  kset_keyboard_translate_table (kb, Qnil);
+  kset_last_repeatable_command (kb, Qnil);
+  kset_prefix_arg (kb, Qnil);
+  kset_last_prefix_arg (kb, Qnil);
+  kset_kbd_queue (kb, Qnil);
   kb->kbd_queue_has_data = 0;
   kb->immediate_echo = 0;
-  KSET (kb, echo_string, Qnil);
+  kset_echo_string (kb, Qnil);
   kb->echo_after_prompt = -1;
   kb->kbd_macro_buffer = 0;
   kb->kbd_macro_bufsize = 0;
-  KSET (kb, defining_kbd_macro, Qnil);
-  KSET (kb, Vlast_kbd_macro, Qnil);
+  kset_defining_kbd_macro (kb, Qnil);
+  kset_last_kbd_macro (kb, Qnil);
   kb->reference_count = 0;
-  KSET (kb, Vsystem_key_alist, Qnil);
-  KSET (kb, system_key_syms, Qnil);
-  KSET (kb, Vwindow_system, Qt);        /* Unset.  */
-  KSET (kb, Vinput_decode_map, Fmake_sparse_keymap (Qnil));
-  KSET (kb, Vlocal_function_key_map, Fmake_sparse_keymap (Qnil));
+  kset_system_key_alist (kb, Qnil);
+  kset_system_key_syms (kb, Qnil);
+  kset_window_system (kb, Qt);  /* Unset.  */
+  kset_input_decode_map (kb, Fmake_sparse_keymap (Qnil));
+  kset_local_function_key_map (kb, Fmake_sparse_keymap (Qnil));
   Fset_keymap_parent (KVAR (kb, Vlocal_function_key_map), Vfunction_key_map);
-  KSET (kb, Vdefault_minibuffer_frame, Qnil);
+  kset_default_minibuffer_frame (kb, Qnil);
 }
 
 /*
@@ -11374,7 +11426,7 @@ init_keyboard (void)
   init_kboard (current_kboard);
   /* A value of nil for Vwindow_system normally means a tty, but we also use
      it for the initial terminal since there is no window system there.  */
-  KSET (current_kboard, Vwindow_system, Qnil);
+  kset_window_system (current_kboard, Qnil);
 
   if (!noninteractive)
     {
diff --git a/src/keyboard.h b/src/keyboard.h
index f83643d6f6e..91484b3649b 100644
--- a/src/keyboard.h
+++ b/src/keyboard.h
@@ -19,10 +19,14 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "systime.h"            /* for EMACS_TIME, Time */
 #include "coding.h"             /* for ENCODE_UTF_8 and ENCODE_SYSTEM */
 
+INLINE_HEADER_BEGIN
+#ifndef KEYBOARD_INLINE
+# define KEYBOARD_INLINE INLINE
+#endif
+
 /* Most code should use this macro to access Lisp fields in struct kboard.  */
 
 #define KVAR(kboard, field) ((kboard)->INTERNAL_FIELD (field))
-#define KSET(kboard, field, value) ((kboard)->INTERNAL_FIELD (field) = (value))
 
 /* Each KBOARD represents one logical input stream from which Emacs
    gets input.  If we are using ordinary terminals, it has one KBOARD
@@ -173,6 +177,47 @@ struct kboard
     char echo_after_prompt;
   };
 
+KEYBOARD_INLINE void
+kset_default_minibuffer_frame (struct kboard *kb, Lisp_Object val)
+{
+  kb->INTERNAL_FIELD (Vdefault_minibuffer_frame) = val;
+}
+KEYBOARD_INLINE void
+kset_defining_kbd_macro (struct kboard *kb, Lisp_Object val)
+{
+  kb->INTERNAL_FIELD (defining_kbd_macro) = val;
+}
+KEYBOARD_INLINE void
+kset_input_decode_map (struct kboard *kb, Lisp_Object val)
+{
+  kb->INTERNAL_FIELD (Vinput_decode_map) = val;
+}
+KEYBOARD_INLINE void
+kset_last_command (struct kboard *kb, Lisp_Object val)
+{
+  kb->INTERNAL_FIELD (Vlast_command) = val;
+}
+KEYBOARD_INLINE void
+kset_last_kbd_macro (struct kboard *kb, Lisp_Object val)
+{
+  kb->INTERNAL_FIELD (Vlast_kbd_macro) = val;
+}
+KEYBOARD_INLINE void
+kset_prefix_arg (struct kboard *kb, Lisp_Object val)
+{
+  kb->INTERNAL_FIELD (Vprefix_arg) = val;
+}
+KEYBOARD_INLINE void
+kset_system_key_alist (struct kboard *kb, Lisp_Object val)
+{
+  kb->INTERNAL_FIELD (Vsystem_key_alist) = val;
+}
+KEYBOARD_INLINE void
+kset_window_system (struct kboard *kb, Lisp_Object val)
+{
+  kb->INTERNAL_FIELD (Vwindow_system) = val;
+}
+
 /* Temporarily used before a frame has been opened. */
 extern KBOARD *initial_kboard;
 
@@ -510,3 +555,5 @@ extern void mark_kboards (void);
 #ifdef WINDOWSNT
 extern const char *const lispy_function_keys[];
 #endif
+
+INLINE_HEADER_END
diff --git a/src/keymap.c b/src/keymap.c
index c550b37c1d6..21f7dcb5d37 100644
--- a/src/keymap.c
+++ b/src/keymap.c
@@ -1854,7 +1854,7 @@ If KEYMAP is nil, that means no local keymap.  */)
   if (!NILP (keymap))
     keymap = get_keymap (keymap, 1, 1);
 
-  BSET (current_buffer, keymap, keymap);
+  bset_keymap (current_buffer, keymap);
 
   return Qnil;
 }
diff --git a/src/lisp.h b/src/lisp.h
index 90705f51ddb..fea5ac0c768 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -928,7 +928,7 @@ enum
    8-bit European characters.  Do not check validity of CT.  */
 #define CHAR_TABLE_SET(CT, IDX, VAL)                                    \
   (ASCII_CHAR_P (IDX) && SUB_CHAR_TABLE_P (XCHAR_TABLE (CT)->ascii)     \
-   ? XSUB_CHAR_TABLE (XCHAR_TABLE (CT)->ascii)->contents[IDX] = VAL     \
+   ? set_sub_char_table_contents (XCHAR_TABLE (CT)->ascii, IDX, VAL)    \
    : char_table_set (CT, IDX, VAL))
 
 enum CHARTAB_SIZE_BITS
@@ -941,8 +941,6 @@ enum CHARTAB_SIZE_BITS
 
 extern const int chartab_size[4];
 
-struct Lisp_Sub_Char_Table;
-
 struct Lisp_Char_Table
   {
     /* HEADER.SIZE is the vector's size field, which also holds the
@@ -991,6 +989,7 @@ struct Lisp_Sub_Char_Table
     /* Minimum character covered by the sub char-table.  */
     Lisp_Object min_char;
 
+    /* Use set_sub_char_table_contents to set this.  */
     Lisp_Object contents[1];
   };
 
@@ -1472,14 +1471,6 @@ struct Lisp_Buffer_Local_Value
     Lisp_Object valcell;
   };
 
-#define BLV_FOUND(blv) \
-  (eassert ((blv)->found == !EQ ((blv)->defcell, (blv)->valcell)), (blv)->found)
-#define SET_BLV_FOUND(blv, v) \
-  (eassert ((v) == !EQ ((blv)->defcell, (blv)->valcell)), (blv)->found = (v))
-
-#define BLV_VALUE(blv) (XCDR ((blv)->valcell))
-#define SET_BLV_VALUE(blv, v) (XSETCDR ((blv)->valcell, v))
-
 /* Like Lisp_Objfwd except that value lives in a slot in the
    current kboard.  */
 struct Lisp_Kboard_Objfwd
@@ -1758,15 +1749,18 @@ typedef struct {
 #define CHECK_WINDOW_CONFIGURATION(x) \
   CHECK_TYPE (WINDOW_CONFIGURATIONP (x), Qwindow_configuration_p, x)
 
-/* This macro rejects windows on the interior of the window tree as
-   "dead", which is what we want; this is an argument-checking macro, and
-   the user should never get access to interior windows.
-
-   A window of any sort, leaf or interior, is dead if the buffer,
-   vchild, and hchild members are all nil.  */
-
-#define CHECK_LIVE_WINDOW(x) \
-  CHECK_TYPE (WINDOWP (x) && !NILP (XWINDOW (x)->buffer), \
+/* A window of any sort, leaf or interior, is "valid" if one of its
+   buffer, vchild, or hchild members is non-nil.  */
+#define CHECK_VALID_WINDOW(x)                           \
+  CHECK_TYPE (WINDOWP (x)                               \
+              && (!NILP (XWINDOW (x)->buffer)           \
+                  || !NILP (XWINDOW (x)->vchild)        \
+                  || !NILP (XWINDOW (x)->hchild)),      \
+              Qwindow_valid_p, x)
+
+/* A window is "live" if and only if it shows a buffer.  */
+#define CHECK_LIVE_WINDOW(x)                                            \
+  CHECK_TYPE (WINDOWP (x) && !NILP (XWINDOW (x)->buffer),               \
               Qwindow_live_p, x)
 
 #define CHECK_PROCESS(x) \
@@ -2412,6 +2406,52 @@ set_symbol_next (Lisp_Object sym, struct Lisp_Symbol *next)
   XSYMBOL (sym)->next = next;
 }
 
+/* Buffer-local (also frame-local) variable access functions.  */
+
+LISP_INLINE int
+blv_found (struct Lisp_Buffer_Local_Value *blv)
+{
+  eassert (blv->found == !EQ (blv->defcell, blv->valcell));
+  return blv->found;
+}
+
+LISP_INLINE void
+set_blv_found (struct Lisp_Buffer_Local_Value *blv, int found)
+{
+  eassert (found == !EQ (blv->defcell, blv->valcell));
+  blv->found = found;
+}
+
+LISP_INLINE Lisp_Object
+blv_value (struct Lisp_Buffer_Local_Value *blv)
+{
+  return XCDR (blv->valcell);
+}
+
+LISP_INLINE void
+set_blv_value (struct Lisp_Buffer_Local_Value *blv, Lisp_Object val)
+{
+  XSETCDR (blv->valcell, val);
+}
+
+LISP_INLINE void
+set_blv_where (struct Lisp_Buffer_Local_Value *blv, Lisp_Object val)
+{
+  blv->where = val;
+}
+
+LISP_INLINE void
+set_blv_defcell (struct Lisp_Buffer_Local_Value *blv, Lisp_Object val)
+{
+  blv->defcell = val;
+}
+
+LISP_INLINE void
+set_blv_valcell (struct Lisp_Buffer_Local_Value *blv, Lisp_Object val)
+{
+  blv->valcell = val;
+}
+
 /* Set overlay's property list.  */
 
 LISP_INLINE void
@@ -2423,7 +2463,7 @@ set_overlay_plist (Lisp_Object overlay, Lisp_Object plist)
 /* Get text properties of S.  */
 
 LISP_INLINE INTERVAL
-string_get_intervals (Lisp_Object s)
+string_intervals (Lisp_Object s)
 {
   return XSTRING (s)->intervals;
 }
@@ -2431,11 +2471,57 @@ string_get_intervals (Lisp_Object s)
 /* Set text properties of S to I.  */
 
 LISP_INLINE void
-string_set_intervals (Lisp_Object s, INTERVAL i)
+set_string_intervals (Lisp_Object s, INTERVAL i)
 {
   XSTRING (s)->intervals = i;
 }
 
+/* Set a Lisp slot in TABLE to VAL.  Most code should use this instead
+   of setting slots directly.  */
+
+LISP_INLINE void
+set_char_table_ascii (Lisp_Object table, Lisp_Object val)
+{
+  XCHAR_TABLE (table)->ascii = val;
+}
+LISP_INLINE void
+set_char_table_defalt (Lisp_Object table, Lisp_Object val)
+{
+  XCHAR_TABLE (table)->defalt = val;
+}
+LISP_INLINE void
+set_char_table_parent (Lisp_Object table, Lisp_Object val)
+{
+  XCHAR_TABLE (table)->parent = val;
+}
+LISP_INLINE void
+set_char_table_purpose (Lisp_Object table, Lisp_Object val)
+{
+  XCHAR_TABLE (table)->purpose = val;
+}
+
+/* Set different slots in (sub)character tables.  */
+
+LISP_INLINE void
+set_char_table_extras (Lisp_Object table, ptrdiff_t idx, Lisp_Object val)
+{
+  eassert (0 <= idx && idx < CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (table)));
+  XCHAR_TABLE (table)->extras[idx] = val;
+}
+
+LISP_INLINE void
+set_char_table_contents (Lisp_Object table, ptrdiff_t idx, Lisp_Object val)
+{
+  eassert (0 <= idx && idx < (1 << CHARTAB_SIZE_BITS_0));
+  XCHAR_TABLE (table)->contents[idx] = val;
+}
+
+LISP_INLINE void
+set_sub_char_table_contents (Lisp_Object table, ptrdiff_t idx, Lisp_Object val)
+{
+  XSUB_CHAR_TABLE (table)->contents[idx] = val;
+}
+
 /* Defined in data.c.  */
 extern Lisp_Object Qnil, Qt, Qquote, Qlambda, Qunbound;
 extern Lisp_Object Qerror_conditions, Qerror_message, Qtop_level;
@@ -2657,7 +2743,6 @@ _Noreturn void __executable_start (void);
 #endif
 extern Lisp_Object selected_frame;
 extern Lisp_Object Vwindow_system;
-void duration_to_sec_usec (double, int *, int *);
 extern Lisp_Object sit_for (Lisp_Object, int, int);
 extern void init_display (void);
 extern void syms_of_display (void);
@@ -2835,9 +2920,8 @@ extern Lisp_Object copy_char_table (Lisp_Object);
 extern Lisp_Object char_table_ref (Lisp_Object, int);
 extern Lisp_Object char_table_ref_and_range (Lisp_Object, int,
                                              int *, int *);
-extern Lisp_Object char_table_set (Lisp_Object, int, Lisp_Object);
-extern Lisp_Object char_table_set_range (Lisp_Object, int, int,
-                                         Lisp_Object);
+extern void char_table_set (Lisp_Object, int, Lisp_Object);
+extern void char_table_set_range (Lisp_Object, int, int, Lisp_Object);
 extern int char_table_translate (Lisp_Object, int);
 extern void map_char_table (void (*) (Lisp_Object, Lisp_Object,
                             Lisp_Object),
diff --git a/src/lread.c b/src/lread.c
index 72991e92bae..e2ad03b349f 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -80,7 +80,7 @@ static Lisp_Object Qascii_character, Qload, Qload_file_name;
 Lisp_Object Qbackquote, Qcomma, Qcomma_at, Qcomma_dot, Qfunction;
 static Lisp_Object Qinhibit_file_name_operation;
 static Lisp_Object Qeval_buffer_list;
-static Lisp_Object Qlexical_binding;
+Lisp_Object Qlexical_binding;
 static Lisp_Object Qfile_truename, Qdo_after_load_evaluation; /* ACM 2006/5/16 */
 
 /* Used instead of Qget_file_char while loading *.elc files compiled
@@ -3189,8 +3189,8 @@ substitute_object_recurse (Lisp_Object object, Lisp_Object placeholder, Lisp_Obj
         /* Check for text properties in each interval.
            substitute_in_interval contains part of the logic.  */
 
-        INTERVAL    root_interval = string_get_intervals (subtree);
-        Lisp_Object arg           = Fcons (object, placeholder);
+        INTERVAL root_interval = string_intervals (subtree);
+        Lisp_Object arg = Fcons (object, placeholder);
 
         traverse_intervals_noorder (root_interval,
                                     &substitute_in_interval, arg);
@@ -3211,7 +3211,7 @@ substitute_in_interval (INTERVAL interval, Lisp_Object arg)
   Lisp_Object object      = Fcar (arg);
   Lisp_Object placeholder = Fcdr (arg);
 
-  SUBSTITUTE (interval->plist, interval_set_plist (interval, true_value));
+  SUBSTITUTE (interval->plist, set_interval_plist (interval, true_value));
 }
 
 
diff --git a/src/macros.c b/src/macros.c
index d74d12e6158..e81068181b9 100644
--- a/src/macros.c
+++ b/src/macros.c
@@ -127,7 +127,7 @@ macro before appending to it. */)
 
       message ("Appending to kbd macro...");
     }
-  KSET (current_kboard, defining_kbd_macro, Qt);
+  kset_defining_kbd_macro (current_kboard, Qt);
 
   return Qnil;
 }
@@ -137,12 +137,13 @@ macro before appending to it. */)
 void
 end_kbd_macro (void)
 {
-  KSET (current_kboard, defining_kbd_macro, Qnil);
+  kset_defining_kbd_macro (current_kboard, Qnil);
   update_mode_lines++;
-  KSET (current_kboard, Vlast_kbd_macro,
-        make_event_array ((current_kboard->kbd_macro_end 
-                           - current_kboard->kbd_macro_buffer),
-                          current_kboard->kbd_macro_buffer));
+  kset_last_kbd_macro
+    (current_kboard,
+     make_event_array ((current_kboard->kbd_macro_end
+                        - current_kboard->kbd_macro_buffer),
+                       current_kboard->kbd_macro_buffer));
 }
 
 DEFUN ("end-kbd-macro", Fend_kbd_macro, Send_kbd_macro, 0, 2, "p",
@@ -330,7 +331,7 @@ each iteration of the macro.  Iteration stops if LOOPFUNC returns nil.  */)
       executing_kbd_macro = final;
       executing_kbd_macro_index = 0;
 
-      KSET (current_kboard, Vprefix_arg, Qnil);
+      kset_prefix_arg (current_kboard, Qnil);
 
       if (!NILP (loopfunc))
         {
diff --git a/src/makefile.w32-in b/src/makefile.w32-in
index 31dc94f7964..9c13f561a04 100644
--- a/src/makefile.w32-in
+++ b/src/makefile.w32-in
@@ -395,6 +395,8 @@ BLOCKINPUT_H   = $(SRC)/blockinput.h \
                  $(ATIMER_H)
 BUFFER_H       = $(SRC)/buffer.h \
                  $(SYSTIME_H)
+C_CTYPE_H      = $(GNU_LIB)/c-ctype.h \
+                 $(NT_INC)/stdbool.h
 CAREADLINKAT_H = $(GNU_LIB)/careadlinkat.h \
                  $(NT_INC)/unistd.h
 CHARACTER_H    = $(SRC)/character.h \
@@ -441,7 +443,8 @@ LISP_H         = $(SRC)/lisp.h \
                  $(SRC)/globals.h \
                  $(GNU_LIB)/intprops.h \
                  $(INTTYPES_H) \
-                 $(NT_INC)/stdalign.h
+                 $(NT_INC)/stdalign.h \
+                 $(NT_INC)/stdbool.h
 MD5_H          = $(GNU_LIB)/md5.h \
                  $(NT_INC)/stdint.h
 MENU_H         = $(SRC)/menu.h \
@@ -626,6 +629,7 @@ $(BLD)/charset.$(O) : \
         $(CHARSET_H) \
         $(CODING_H) \
         $(CONFIG_H) \
+        $(C_CTYPE_H) \
         $(LISP_H)
 
 $(BLD)/chartab.$(O) : \
@@ -747,6 +751,7 @@ $(BLD)/doc.$(O) : \
         $(BUFFER_H) \
         $(CHARACTER_H) \
         $(CONFIG_H) \
+        $(C_CTYPE_H) \
         $(KEYBOARD_H) \
         $(LISP_H)
 
@@ -820,6 +825,7 @@ $(BLD)/fileio.$(O) : \
         $(CHARACTER_H) \
         $(CODING_H) \
         $(CONFIG_H) \
+        $(C_CTYPE_H) \
         $(DISPEXTERN_H) \
         $(FRAME_H) \
         $(INTERVALS_H) \
@@ -881,6 +887,7 @@ $(BLD)/font.$(O) : \
         $(CHARACTER_H) \
         $(CHARSET_H) \
         $(CONFIG_H) \
+        $(C_CTYPE_H) \
         $(DISPEXTERN_H) \
         $(FONT_H) \
         $(FRAME_H) \
@@ -916,6 +923,7 @@ $(BLD)/frame.$(O) : \
         $(BUFFER_H) \
         $(CHARACTER_H) \
         $(CONFIG_H) \
+        $(C_CTYPE_H) \
         $(DISPEXTERN_H) \
         $(FONT_H) \
         $(FRAME_H) \
@@ -967,6 +975,7 @@ $(BLD)/image.$(O) : \
         $(CHARACTER_H) \
         $(CODING_H) \
         $(CONFIG_H) \
+        $(C_CTYPE_H) \
         $(DISPEXTERN_H) \
         $(FONT_H) \
         $(FRAME_H) \
@@ -1354,6 +1363,7 @@ $(BLD)/sysdep.$(O) : \
         $(BLOCKINPUT_H) \
         $(CAREADLINKAT_H) \
         $(CONFIG_H) \
+        $(C_CTYPE_H) \
         $(DISPEXTERN_H) \
         $(FRAME_H) \
         $(GRP_H) \
@@ -1499,6 +1509,7 @@ $(BLD)/xfaces.$(O) : \
         $(CHARACTER_H) \
         $(CHARSET_H) \
         $(CONFIG_H) \
+        $(C_CTYPE_H) \
         $(DISPEXTERN_H) \
         $(FONT_H) \
         $(FRAME_H) \
diff --git a/src/minibuf.c b/src/minibuf.c
index 06ea415db62..2154d1654df 100644
--- a/src/minibuf.c
+++ b/src/minibuf.c
@@ -565,11 +565,11 @@ read_minibuf (Lisp_Object map, Lisp_Object initial, Lisp_Object prompt,
 
   /* Defeat (setq-default truncate-lines t), since truncated lines do
      not work correctly in minibuffers.  (Bug#5715, etc)  */
-  BSET (current_buffer, truncate_lines, Qnil);
+  bset_truncate_lines (current_buffer, Qnil);
 
   /* If appropriate, copy enable-multibyte-characters into the minibuffer.  */
   if (inherit_input_method)
-    BSET (current_buffer, enable_multibyte_characters, enable_multibyte);
+    bset_enable_multibyte_characters (current_buffer, enable_multibyte);
 
   /* The current buffer's default directory is usually the right thing
      for our minibuffer here.  However, if you're typing a command at
@@ -580,7 +580,7 @@ read_minibuf (Lisp_Object map, Lisp_Object initial, Lisp_Object prompt,
      you think of something better to do?  Find another buffer with a
      better directory, and use that one instead.  */
   if (STRINGP (ambient_dir))
-    BSET (current_buffer, directory, ambient_dir);
+    bset_directory (current_buffer, ambient_dir);
   else
     {
       Lisp_Object buf_list;
@@ -594,8 +594,8 @@ read_minibuf (Lisp_Object map, Lisp_Object initial, Lisp_Object prompt,
           other_buf = XCDR (XCAR (buf_list));
           if (STRINGP (BVAR (XBUFFER (other_buf), directory)))
             {
-              BSET (current_buffer, directory,
-                   BVAR (XBUFFER (other_buf), directory));
+              bset_directory (current_buffer,
+                              BVAR (XBUFFER (other_buf), directory));
               break;
             }
         }
@@ -672,7 +672,7 @@ read_minibuf (Lisp_Object map, Lisp_Object initial, Lisp_Object prompt,
     }
 
   clear_message (1, 1);
-  BSET (current_buffer, keymap, map);
+  bset_keymap (current_buffer, map);
 
   /* Turn on an input method stored in INPUT_METHOD if any.  */
   if (STRINGP (input_method) && !NILP (Ffboundp (Qactivate_input_method)))
@@ -681,7 +681,7 @@ read_minibuf (Lisp_Object map, Lisp_Object initial, Lisp_Object prompt,
   Frun_hooks (1, &Qminibuffer_setup_hook);
 
   /* Don't allow the user to undo past this point.  */
-  BSET (current_buffer, undo_list, Qnil);
+  bset_undo_list (current_buffer, Qnil);
 
   recursive_edit_1 ();
 
diff --git a/src/msdos.c b/src/msdos.c
index bcb7fbe75e0..30435820d9e 100644
--- a/src/msdos.c
+++ b/src/msdos.c
@@ -520,8 +520,8 @@ dos_set_window_size (int *rows, int *cols)
 
   /* If the user specified a special video mode for these dimensions,
      use that mode.  */
-  video_mode 
-    = Fsymbol_value (Fintern_soft (make_formatted_string 
+  video_mode
+    = Fsymbol_value (Fintern_soft (make_formatted_string
                                    (video_name, "screen-dimensions-%dx%d",
                                     *rows, *cols), Qnil));
 
@@ -1801,7 +1801,7 @@ internal_terminal_init (void)
     }
 
   tty = FRAME_TTY (sf);
-  KSET (current_kboard, Vwindow_system, Qpc);
+  kset_window_system (current_kboard, Qpc);
   sf->output_method = output_msdos_raw;
   if (init_needed)
     {
diff --git a/src/nsfns.m b/src/nsfns.m
index 1b39f0257a5..e8b5d22077a 100644
--- a/src/nsfns.m
+++ b/src/nsfns.m
@@ -447,7 +447,7 @@ x_set_icon_name (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
   else if (!STRINGP (oldval) && EQ (oldval, Qnil) == EQ (arg, Qnil))
     return;
 
-  FSET (f, icon_name, arg);
+  fset_icon_name (f, arg);
 
   if (NILP (arg))
     {
@@ -539,7 +539,7 @@ ns_set_name (struct frame *f, Lisp_Object name, int explicit)
   if (! NILP (Fstring_equal (name, f->name)))
     return;
 
-  FSET (f, name, name);
+  fset_name (f, name);
 
   /* title overrides explicit name */
   if (! NILP (f->title))
@@ -590,7 +590,7 @@ x_set_title (struct frame *f, Lisp_Object name, Lisp_Object old_name)
 
   update_mode_lines = 1;
 
-  FSET (f, title, name);
+  fset_title (f, name);
 
   if (NILP (name))
     name = f->name;
@@ -676,7 +676,7 @@ ns_set_name_as_filename (struct frame *f)
 
       [[view window] setRepresentedFilename: fstr];
       [[view window] setTitle: str];
-      FSET (f, name, name);
+      fset_name (f, name);
     }
 
   [pool release];
@@ -1204,11 +1204,11 @@ This function is an internal primitive--use `make-frame' instead.  */)
 
   FRAME_FONTSET (f) = -1;
 
-  FSET (f, icon_name, x_get_arg (dpyinfo, parms, Qicon_name,
-                                 "iconName", "Title",
-                                 RES_TYPE_STRING));
+  fset_icon_name (f, x_get_arg (dpyinfo, parms, Qicon_name,
+                                "iconName", "Title",
+                                RES_TYPE_STRING));
   if (! STRINGP (f->icon_name))
-    FSET (f, icon_name, Qnil);
+    fset_icon_name (f, Qnil);
 
   FRAME_NS_DISPLAY_INFO (f) = dpyinfo;
 
@@ -1231,12 +1231,12 @@ This function is an internal primitive--use `make-frame' instead.  */)
      be set.  */
   if (EQ (name, Qunbound) || NILP (name) || ! STRINGP (name))
     {
-      FSET (f, name, build_string ([ns_app_name UTF8String]));
+      fset_name (f, build_string ([ns_app_name UTF8String]));
       f->explicit_name = 0;
     }
   else
     {
-      FSET (f, name, name);
+      fset_name (f, name);
       f->explicit_name = 1;
       specbind (Qx_resource_name, name);
     }
@@ -1391,13 +1391,13 @@ This function is an internal primitive--use `make-frame' instead.  */)
   if (FRAME_HAS_MINIBUF_P (f)
       && (!FRAMEP (KVAR (kb, Vdefault_minibuffer_frame))
           || !FRAME_LIVE_P (XFRAME (KVAR (kb, Vdefault_minibuffer_frame)))))
-    KSET (kb, Vdefault_minibuffer_frame, frame);
+    kset_default_minibuffer_frame (kb, frame);
 
   /* All remaining specified parameters, which have not been "used"
      by x_get_arg and friends, now go in the misc. alist of the frame.  */
   for (tem = parms; CONSP (tem); tem = XCDR (tem))
     if (CONSP (XCAR (tem)) && !NILP (XCAR (XCAR (tem))))
-      FSET (f, param_alist, Fcons (XCAR (tem), f->param_alist));
+      fset_param_alist (f, Fcons (XCAR (tem), f->param_alist));
 
   UNGCPRO;
 
diff --git a/src/nsfont.m b/src/nsfont.m
index 6f9294e082a..1f8d28cd238 100644
--- a/src/nsfont.m
+++ b/src/nsfont.m
@@ -236,27 +236,62 @@ ns_fallback_entity (void)
 }
 
 
-/* Utility: get width of a char c in screen font sfont */
+/* Utility: get width of a char c in screen font SFONT */
 static float
 ns_char_width (NSFont *sfont, int c)
 {
-    float w;
-    NSString *cstr = [NSString stringWithFormat: @"%c", c];
+  float w = -1.0;
+  NSString *cstr = [NSString stringWithFormat: @"%c", c];
+
 #ifdef NS_IMPL_COCOA
-    NSGlyph glyph = [sfont glyphWithName: cstr];
-    if (glyph)
-      {
-        float w = [sfont advancementForGlyph: glyph].width;
-        if (w >= 1.5)
-            return w;
-      }
+  NSGlyph glyph = [sfont glyphWithName: cstr];
+  if (glyph)
+    w = [sfont advancementForGlyph: glyph].width;
 #endif
+
+  if (w < 0.0)
     {
       NSDictionary *attrsDictionary =
         [NSDictionary dictionaryWithObject: sfont forKey: NSFontAttributeName];
       w = [cstr sizeWithAttributes: attrsDictionary].width;
     }
-    return max (w, 2.0);
+
+  return max (w, 1.0);
+}
+
+/* Return average width over ASCII printable characters for SFONT.  */
+
+static NSString *ascii_printable;
+
+static int
+ns_ascii_average_width (NSFont *sfont)
+{
+  float w = -1.0;
+
+  if (!ascii_printable)
+    {
+      char chars[95];
+      int ch;
+      for (ch = 0; ch < 95; ch++)
+        chars[ch] = ' ' + ch;
+
+      ascii_printable = [[NSString alloc] initWithFormat: @"%s", chars];
+    }
+
+#ifdef NS_IMPL_COCOA
+  NSGlyph glyph = [sfont glyphWithName: ascii_printable];
+  if (glyph)
+    w = [sfont advancementForGlyph: glyph].width;
+#endif
+
+  if (w < 0.0)
+    {
+      NSDictionary *attrsDictionary =
+        [NSDictionary dictionaryWithObject: sfont forKey: NSFontAttributeName];
+      w = [ascii_printable sizeWithAttributes: attrsDictionary].width;
+    }
+
+  return lrint (w / 95.0);
 }
 
 
@@ -885,10 +920,11 @@ nsfont_open (FRAME_PTR f, Lisp_Object font_entity, int pixel_size)
     /* set up metrics portion of font struct */
     font->ascent = lrint([sfont ascender]);
     font->descent = -lrint(floor(adjusted_descender));
-    font->min_width = ns_char_width(sfont, '|');
     font->space_width = lrint (ns_char_width (sfont, ' '));
-    font->average_width = lrint (font_info->width);
     font->max_width = lrint (font_info->max_bounds.width);
+    font->min_width = font->space_width;  /* Approximate.  */
+    font->average_width = ns_ascii_average_width (sfont);
+
     font->height = lrint (font_info->height);
     font->underline_position = lrint (font_info->underpos);
     font->underline_thickness = lrint (font_info->underwidth);
@@ -1492,4 +1528,6 @@ syms_of_nsfont (void)
   DEFSYM (Qmedium, "medium");
   DEFVAR_LISP ("ns-reg-to-script", Vns_reg_to_script,
                doc: /* Internal use: maps font registry to Unicode script. */);
+
+  ascii_printable = NULL;
 }
diff --git a/src/nsimage.m b/src/nsimage.m
index 1479294948b..8a8a3ddaae4 100644
--- a/src/nsimage.m
+++ b/src/nsimage.m
@@ -302,7 +302,7 @@ static EmacsImage *ImageList = nil;
                   [bmRep release];
                   return nil;
                 }
-#define hexchar(x) (isdigit (x) ? x - '0' : x - 'a' + 10)
+#define hexchar(x) ('0' <= (x) && (x) <= '9' ? (x) - '0' : (x) - 'a' + 10)
               s1 = *s++;
               s2 = *s++;
               c = hexchar (s1) * 0x10 + hexchar (s2);
@@ -501,4 +501,3 @@ static EmacsImage *ImageList = nil;
 }
 
 @end
-
diff --git a/src/nsmenu.m b/src/nsmenu.m
index 657b9306942..e8a0b43a01b 100644
--- a/src/nsmenu.m
+++ b/src/nsmenu.m
@@ -214,7 +214,7 @@ ns_update_menubar (struct frame *f, int deep_p, EmacsMenu *submenu)
       if (! NILP (Vlucid_menu_bar_dirty_flag))
         call0 (Qrecompute_lucid_menubar);
       safe_run_hooks (Qmenu_bar_update_hook);
-      FSET (f, menu_bar_items, menu_bar_items (FRAME_MENU_BAR_ITEMS (f)));
+      fset_menu_bar_items (f, menu_bar_items (FRAME_MENU_BAR_ITEMS (f)));
 
       /* Now ready to go */
       items = FRAME_MENU_BAR_ITEMS (f);
@@ -340,7 +340,7 @@ ns_update_menubar (struct frame *f, int deep_p, EmacsMenu *submenu)
         }
       /* The menu items are different, so store them in the frame */
       /* FIXME: this is not correct for single-submenu case */
-      FSET (f, menu_bar_vector, menu_items);
+      fset_menu_bar_vector (f, menu_items);
       f->menu_bar_items_used = menu_items_used;
 
       /* Calls restore_menu_items, etc., as they were outside */
diff --git a/src/nsterm.h b/src/nsterm.h
index 94984b3d35e..54f4a4ec89e 100644
--- a/src/nsterm.h
+++ b/src/nsterm.h
@@ -450,7 +450,10 @@ struct nsfont_info
   struct font font;
 
   char *name;  /* PostScript name, uniquely identifies on NS systems */
-  float width;  /* this and following metrics stored as float rather than int */
+
+  /* The following metrics are stored as float rather than int. */
+
+  float width;  /* Maximum advance for the font.  */
   float height;
   float underpos;
   float underwidth;
diff --git a/src/nsterm.m b/src/nsterm.m
index 76e6ee8fb40..3ab9358467a 100644
--- a/src/nsterm.m
+++ b/src/nsterm.m
@@ -36,6 +36,8 @@ GNUstep port and post-20 update by Adrian Robert (arobert@cogsci.ucsd.edu)
 #include <signal.h>
 #include <unistd.h>
 #include <setjmp.h>
+
+#include <c-ctype.h>
 #include <c-strcase.h>
 #include <ftoastr.h>
 
@@ -1030,7 +1032,7 @@ ns_frame_rehighlight (struct frame *frame)
            : dpyinfo->x_focus_frame);
       if (!FRAME_LIVE_P (dpyinfo->x_highlight_frame))
         {
-          FSET (dpyinfo->x_focus_frame, focus_frame, Qnil);
+          fset_focus_frame (dpyinfo->x_focus_frame, Qnil);
           dpyinfo->x_highlight_frame = dpyinfo->x_focus_frame;
         }
     }
@@ -3696,7 +3698,7 @@ ns_set_vertical_scroll_bar (struct window *window,
         {
           bar = XNS_SCROLL_BAR (window->vertical_scroll_bar);
           [bar removeFromSuperview];
-          WSET (window, vertical_scroll_bar, Qnil);
+          wset_vertical_scroll_bar (window, Qnil);
         }
       ns_clear_frame_area (f, sb_left, top, width, height);
       UNBLOCK_INPUT;
@@ -3707,7 +3709,7 @@ ns_set_vertical_scroll_bar (struct window *window,
     {
       ns_clear_frame_area (f, sb_left, top, width, height);
       bar = [[EmacsScroller alloc] initFrame: r window: win];
-      WSET (window, vertical_scroll_bar, make_save_value (bar, 0));
+      wset_vertical_scroll_bar (window, make_save_value (bar, 0));
     }
   else
     {
@@ -4091,7 +4093,7 @@ ns_term_init (Lisp_Object display_name)
 
   terminal->kboard = xmalloc (sizeof *terminal->kboard);
   init_kboard (terminal->kboard);
-  KSET (terminal->kboard, Vwindow_system, Qns);
+  kset_window_system (terminal->kboard, Qns);
   terminal->kboard->next_kboard = all_kboards;
   all_kboards = terminal->kboard;
   /* Don't let the initial kboard remain current longer than necessary.
@@ -6386,7 +6388,7 @@ not_in_argv (NSString *arg)
 {
   NSTRACE (EmacsScroller_dealloc);
   if (!NILP (win))
-    WSET (XWINDOW (win), vertical_scroll_bar, Qnil);
+    wset_vertical_scroll_bar (XWINDOW (win), Qnil);
   [super dealloc];
 }
 
@@ -6785,20 +6787,20 @@ ns_xlfd_to_fontname (const char *xlfd)
 
   /* undo hack in ns_fontname_to_xlfd, converting '$' to '-', '_' to ' '
      also uppercase after '-' or ' ' */
-  name[0] = toupper (name[0]);
+  name[0] = c_toupper (name[0]);
   for (len =strlen (name), i =0; i<len; i++)
     {
       if (name[i] == '$')
         {
           name[i] = '-';
           if (i+1<len)
-            name[i+1] = toupper (name[i+1]);
+            name[i+1] = c_toupper (name[i+1]);
         }
       else if (name[i] == '_')
         {
           name[i] = ' ';
           if (i+1<len)
-            name[i+1] = toupper (name[i+1]);
+            name[i+1] = c_toupper (name[i+1]);
         }
     }
 /*fprintf (stderr, "converted '%s' to '%s'\n",xlfd,name);  */
diff --git a/src/print.c b/src/print.c
index 1546ab3e229..e7da5a25643 100644
--- a/src/print.c
+++ b/src/print.c
@@ -496,14 +496,14 @@ temp_output_buffer_setup (const char *bufname)
 
   Fkill_all_local_variables ();
   delete_all_overlays (current_buffer);
-  BSET (current_buffer, directory, BVAR (old, directory));
-  BSET (current_buffer, read_only, Qnil);
-  BSET (current_buffer, filename, Qnil);
-  BSET (current_buffer, undo_list, Qt);
+  bset_directory (current_buffer, BVAR (old, directory));
+  bset_read_only (current_buffer, Qnil);
+  bset_filename (current_buffer, Qnil);
+  bset_undo_list (current_buffer, Qt);
   eassert (current_buffer->overlays_before == NULL);
   eassert (current_buffer->overlays_after == NULL);
-  BSET (current_buffer, enable_multibyte_characters,
-        BVAR (&buffer_defaults, enable_multibyte_characters));
+  bset_enable_multibyte_characters
+    (current_buffer, BVAR (&buffer_defaults, enable_multibyte_characters));
   specbind (Qinhibit_read_only, Qt);
   specbind (Qinhibit_modification_hooks, Qt);
   Ferase_buffer ();
@@ -1196,7 +1196,7 @@ print_preprocess (Lisp_Object obj)
         {
         case Lisp_String:
           /* A string may have text properties, which can be circular.  */
-          traverse_intervals_noorder (string_get_intervals (obj),
+          traverse_intervals_noorder (string_intervals (obj),
                                       print_preprocess_string, Qnil);
           break;
 
@@ -1299,7 +1299,7 @@ static Lisp_Object
 print_prune_string_charset (Lisp_Object string)
 {
   print_check_string_result = 0;
-  traverse_intervals (string_get_intervals (string), 0,
+  traverse_intervals (string_intervals (string), 0,
                       print_check_string_charset_prop, string);
   if (! (print_check_string_result & PRINT_STRING_UNSAFE_CHARSET_FOUND))
     {
@@ -1410,7 +1410,7 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
           if (! EQ (Vprint_charset_text_property, Qt))
             obj = print_prune_string_charset (obj);
 
-          if (string_get_intervals (obj))
+          if (string_intervals (obj))
             {
               PRINTCHAR ('#');
               PRINTCHAR ('(');
@@ -1501,9 +1501,9 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
             }
           PRINTCHAR ('\"');
 
-          if (string_get_intervals (obj))
+          if (string_intervals (obj))
             {
-              traverse_intervals (string_get_intervals (obj),
+              traverse_intervals (string_intervals (obj),
                                   0, print_interval, printcharfun);
               PRINTCHAR (')');
             }
diff --git a/src/process.c b/src/process.c
index a43655e4da8..ea463cd9187 100644
--- a/src/process.c
+++ b/src/process.c
@@ -20,6 +20,9 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 
 #include <config.h>
+
+#define PROCESS_INLINE EXTERN_INLINE
+
 #include <signal.h>
 #include <stdio.h>
 #include <errno.h>
@@ -334,6 +337,88 @@ static struct sockaddr_and_len {
 /* Maximum number of bytes to send to a pty without an eof.  */
 static int pty_max_bytes;
 
+/* These setters are used only in this file, so they can be private.  */
+static inline void
+pset_buffer (struct Lisp_Process *p, Lisp_Object val)
+{
+  p->buffer = val;
+}
+static inline void
+pset_command (struct Lisp_Process *p, Lisp_Object val)
+{
+  p->command = val;
+}
+static inline void
+pset_decode_coding_system (struct Lisp_Process *p, Lisp_Object val)
+{
+  p->decode_coding_system = val;
+}
+static inline void
+pset_decoding_buf (struct Lisp_Process *p, Lisp_Object val)
+{
+  p->decoding_buf = val;
+}
+static inline void
+pset_encode_coding_system (struct Lisp_Process *p, Lisp_Object val)
+{
+  p->encode_coding_system = val;
+}
+static inline void
+pset_encoding_buf (struct Lisp_Process *p, Lisp_Object val)
+{
+  p->encoding_buf = val;
+}
+static inline void
+pset_filter (struct Lisp_Process *p, Lisp_Object val)
+{
+  p->filter = val;
+}
+static inline void
+pset_log (struct Lisp_Process *p, Lisp_Object val)
+{
+  p->log = val;
+}
+static inline void
+pset_mark (struct Lisp_Process *p, Lisp_Object val)
+{
+  p->mark = val;
+}
+static inline void
+pset_name (struct Lisp_Process *p, Lisp_Object val)
+{
+  p->name = val;
+}
+static inline void
+pset_plist (struct Lisp_Process *p, Lisp_Object val)
+{
+  p->plist = val;
+}
+static inline void
+pset_sentinel (struct Lisp_Process *p, Lisp_Object val)
+{
+  p->sentinel = val;
+}
+static inline void
+pset_status (struct Lisp_Process *p, Lisp_Object val)
+{
+  p->status = val;
+}
+static inline void
+pset_tty_name (struct Lisp_Process *p, Lisp_Object val)
+{
+  p->tty_name = val;
+}
+static inline void
+pset_type (struct Lisp_Process *p, Lisp_Object val)
+{
+  p->type = val;
+}
+static inline void
+pset_write_queue (struct Lisp_Process *p, Lisp_Object val)
+{
+  p->write_queue = val;
+}
+
 
 
 static struct fd_callback_data
@@ -428,7 +513,7 @@ static void
 update_status (struct Lisp_Process *p)
 {
   eassert (p->raw_status_new);
-  PSET (p, status, status_convert (p->raw_status));
+  pset_status (p, status_convert (p->raw_status));
   p->raw_status_new = 0;
 }
 
@@ -626,8 +711,8 @@ make_process (Lisp_Object name)
   p = allocate_process ();
   /* Initialize Lisp data.  Note that allocate_process initializes all
      Lisp data to nil, so do it only for slots which should not be nil.  */
-  PSET (p, status, Qrun);
-  PSET (p, mark, Fmake_marker ());
+  pset_status (p, Qrun);
+  pset_mark (p, Fmake_marker ());
 
   /* Initialize non-Lisp data.  Note that allocate_process zeroes out all
      non-Lisp data, so do it only for slots which should not be zero.  */
@@ -648,7 +733,7 @@ make_process (Lisp_Object name)
       name1 = concat2 (name, make_formatted_string (suffix, "<%"pMd">", i));
     }
   name = name1;
-  PSET (p, name, name);
+  pset_name (p, name);
   XSETPROCESS (val, p);
   Vprocess_alist = Fcons (Fcons (name, val), Vprocess_alist);
   return val;
@@ -745,7 +830,7 @@ nil, indicating the current buffer's process.  */)
   p->raw_status_new = 0;
   if (NETCONN1_P (p) || SERIALCONN1_P (p))
     {
-      PSET (p, status, Fcons (Qexit, Fcons (make_number (0), Qnil)));
+      pset_status (p, Fcons (Qexit, Fcons (make_number (0), Qnil)));
       p->tick = ++process_tick;
       status_notify (p);
       redisplay_preserve_echo_area (13);
@@ -774,7 +859,7 @@ nil, indicating the current buffer's process.  */)
         {
           Fkill_process (process, Qnil);
           /* Do this now, since remove_process will make sigchld_handler do nothing.  */
-          PSET (p, status, Fcons (Qsignal, Fcons (make_number (SIGKILL), Qnil)));
+          pset_status (p, Fcons (Qsignal, Fcons (make_number (SIGKILL), Qnil)));
           p->tick = ++process_tick;
           status_notify (p);
           redisplay_preserve_echo_area (13);
@@ -901,9 +986,9 @@ Return BUFFER.  */)
   if (!NILP (buffer))
     CHECK_BUFFER (buffer);
   p = XPROCESS (process);
-  PSET (p, buffer, buffer);
+  pset_buffer (p, buffer);
   if (NETCONN1_P (p) || SERIALCONN1_P (p))
-    PSET (p, childp, Fplist_put (p->childp, QCbuffer, buffer));
+    pset_childp (p, Fplist_put (p->childp, QCbuffer, buffer));
   setup_process_coding_systems (process);
   return buffer;
 }
@@ -974,9 +1059,9 @@ The string argument is normally a multibyte string, except:
         }
     }
 
-  PSET (p, filter, filter);
+  pset_filter (p, filter);
   if (NETCONN1_P (p) || SERIALCONN1_P (p))
-    PSET (p, childp, Fplist_put (p->childp, QCfilter, filter));
+    pset_childp (p, Fplist_put (p->childp, QCfilter, filter));
   setup_process_coding_systems (process);
   return filter;
 }
@@ -1003,9 +1088,9 @@ It gets two arguments: the process, and a string describing the change.  */)
   CHECK_PROCESS (process);
   p = XPROCESS (process);
 
-  PSET (p, sentinel, sentinel);
+  pset_sentinel (p, sentinel);
   if (NETCONN1_P (p) || SERIALCONN1_P (p))
-    PSET (p, childp, Fplist_put (p->childp, QCsentinel, sentinel));
+    pset_childp (p, Fplist_put (p->childp, QCsentinel, sentinel));
   return sentinel;
 }
 
@@ -1138,7 +1223,7 @@ DEFUN ("set-process-plist", Fset_process_plist, Sset_process_plist,
   CHECK_PROCESS (process);
   CHECK_LIST (plist);
 
-  PSET (XPROCESS (process), plist, plist);
+  pset_plist (XPROCESS (process), plist);
   return plist;
 }
 
@@ -1324,18 +1409,18 @@ usage: (start-process NAME BUFFER PROGRAM &rest PROGRAM-ARGS)  */)
      itself; it's all taken care of here.  */
   record_unwind_protect (start_process_unwind, proc);
 
-  PSET (XPROCESS (proc), childp, Qt);
-  PSET (XPROCESS (proc), plist, Qnil);
-  PSET (XPROCESS (proc), type, Qreal);
-  PSET (XPROCESS (proc), buffer, buffer);
-  PSET (XPROCESS (proc), sentinel, Qnil);
-  PSET (XPROCESS (proc), filter, Qnil);
-  PSET (XPROCESS (proc), command, Flist (nargs - 2, args + 2));
+  pset_childp (XPROCESS (proc), Qt);
+  pset_plist (XPROCESS (proc), Qnil);
+  pset_type (XPROCESS (proc), Qreal);
+  pset_buffer (XPROCESS (proc), buffer);
+  pset_sentinel (XPROCESS (proc), Qnil);
+  pset_filter (XPROCESS (proc), Qnil);
+  pset_command (XPROCESS (proc), Flist (nargs - 2, args + 2));
 
 #ifdef HAVE_GNUTLS
   /* AKA GNUTLS_INITSTAGE(proc).  */
   XPROCESS (proc)->gnutls_initstage = GNUTLS_STAGE_EMPTY;
-  PSET (XPROCESS (proc), gnutls_cred_type, Qnil);
+  pset_gnutls_cred_type (XPROCESS (proc), Qnil);
 #endif
 
 #ifdef ADAPTIVE_READ_BUFFERING
@@ -1375,7 +1460,7 @@ usage: (start-process NAME BUFFER PROGRAM &rest PROGRAM-ARGS)  */)
         else if (CONSP (Vdefault_process_coding_system))
           val = XCAR (Vdefault_process_coding_system);
       }
-    PSET (XPROCESS (proc), decode_coding_system, val);
+    pset_decode_coding_system (XPROCESS (proc), val);
 
     val = Vcoding_system_for_write;
     if (NILP (val))
@@ -1395,7 +1480,7 @@ usage: (start-process NAME BUFFER PROGRAM &rest PROGRAM-ARGS)  */)
         else if (CONSP (Vdefault_process_coding_system))
           val = XCDR (Vdefault_process_coding_system);
       }
-    PSET (XPROCESS (proc), encode_coding_system, val);
+    pset_encode_coding_system (XPROCESS (proc), val);
     /* Note: At this moment, the above coding system may leave
        text-conversion or eol-conversion unspecified.  They will be
        decided after we read output from the process and decode it by
@@ -1404,9 +1489,9 @@ usage: (start-process NAME BUFFER PROGRAM &rest PROGRAM-ARGS)  */)
   }
 
 
-  PSET (XPROCESS (proc), decoding_buf, empty_unibyte_string);
+  pset_decoding_buf (XPROCESS (proc), empty_unibyte_string);
   XPROCESS (proc)->decoding_carryover = 0;
-  PSET (XPROCESS (proc), encoding_buf, empty_unibyte_string);
+  pset_encoding_buf (XPROCESS (proc), empty_unibyte_string);
 
   XPROCESS (proc)->inherit_coding_system_flag
     = !(NILP (buffer) || !inherit_process_coding_system);
@@ -1628,7 +1713,7 @@ create_process (Lisp_Object process, char **new_argv, Lisp_Object current_dir)
      more portable (see USG_SUBTTY_WORKS above).  */
 
   XPROCESS (process)->pty_flag = pty_flag;
-  PSET (XPROCESS (process), status, Qrun);
+  pset_status (XPROCESS (process), Qrun);
 
   /* Delay interrupts until we have a chance to store
      the new fork's pid in its process structure */
@@ -1867,10 +1952,10 @@ create_process (Lisp_Object process, char **new_argv, Lisp_Object current_dir)
 
 #ifdef HAVE_PTYS
       if (pty_flag)
-        PSET (XPROCESS (process), tty_name, build_string (pty_name));
+        pset_tty_name (XPROCESS (process), build_string (pty_name));
       else
 #endif
-        PSET (XPROCESS (process), tty_name, Qnil);
+        pset_tty_name (XPROCESS (process), Qnil);
 
 #if !defined (WINDOWSNT) && defined (FD_CLOEXEC)
       /* Wait for child_setup to complete in case that vfork is
@@ -1965,7 +2050,7 @@ create_pty (Lisp_Object process)
      more portable (see USG_SUBTTY_WORKS above).  */
 
   XPROCESS (process)->pty_flag = pty_flag;
-  PSET (XPROCESS (process), status, Qrun);
+  pset_status (XPROCESS (process), Qrun);
   setup_process_coding_systems (process);
 
   FD_SET (inchannel, &input_wait_mask);
@@ -1976,10 +2061,10 @@ create_pty (Lisp_Object process)
   XPROCESS (process)->pid = -2;
 #ifdef HAVE_PTYS
   if (pty_flag)
-    PSET (XPROCESS (process), tty_name, build_string (pty_name));
+    pset_tty_name (XPROCESS (process), build_string (pty_name));
   else
 #endif
-    PSET (XPROCESS (process), tty_name, Qnil);
+    pset_tty_name (XPROCESS (process), Qnil);
 }
 
 
@@ -2368,7 +2453,7 @@ OPTION is not a supported option, return nil instead; otherwise return t.  */)
 
   if (set_socket_option (s, option, value))
     {
-      PSET (p, childp, Fplist_put (p->childp, option, value));
+      pset_childp (p, Fplist_put (p->childp, option, value));
       return Qt;
     }
 
@@ -2601,18 +2686,18 @@ usage:  (make-serial-process &rest ARGS)  */)
   if (NILP (buffer))
     buffer = name;
   buffer = Fget_buffer_create (buffer);
-  PSET (p, buffer, buffer);
-
-  PSET (p, childp, contact);
-  PSET (p, plist, Fcopy_sequence (Fplist_get (contact, QCplist)));
-  PSET (p, type, Qserial);
-  PSET (p, sentinel, Fplist_get (contact, QCsentinel));
-  PSET (p, filter, Fplist_get (contact, QCfilter));
-  PSET (p, log, Qnil);
+  pset_buffer (p, buffer);
+
+  pset_childp (p, contact);
+  pset_plist (p, Fcopy_sequence (Fplist_get (contact, QCplist)));
+  pset_type (p, Qserial);
+  pset_sentinel (p, Fplist_get (contact, QCsentinel));
+  pset_filter (p, Fplist_get (contact, QCfilter));
+  pset_log (p, Qnil);
   if (tem = Fplist_get (contact, QCnoquery), !NILP (tem))
     p->kill_without_query = 1;
   if (tem = Fplist_get (contact, QCstop), !NILP (tem))
-    PSET (p, command, Qt);
+    pset_command (p, Qt);
   p->pty_flag = 0;
 
   if (!EQ (p->command, Qt))
@@ -2644,7 +2729,7 @@ usage:  (make-serial-process &rest ARGS)  */)
   else if ((!NILP (buffer) && NILP (BVAR (XBUFFER (buffer), enable_multibyte_characters)))
            || (NILP (buffer) && NILP (BVAR (&buffer_defaults, enable_multibyte_characters))))
     val = Qnil;
-  PSET (p, decode_coding_system, val);
+  pset_decode_coding_system (p, val);
 
   val = Qnil;
   if (!NILP (tem))
@@ -2658,12 +2743,12 @@ usage:  (make-serial-process &rest ARGS)  */)
   else if ((!NILP (buffer) && NILP (BVAR (XBUFFER (buffer), enable_multibyte_characters)))
            || (NILP (buffer) && NILP (BVAR (&buffer_defaults, enable_multibyte_characters))))
     val = Qnil;
-  PSET (p, encode_coding_system, val);
+  pset_encode_coding_system (p, val);
 
   setup_process_coding_systems (proc);
-  PSET (p, decoding_buf, empty_unibyte_string);
+  pset_decoding_buf (p, empty_unibyte_string);
   p->decoding_carryover = 0;
-  PSET (p, encoding_buf, empty_unibyte_string);
+  pset_encoding_buf (p, empty_unibyte_string);
   p->inherit_coding_system_flag
     = !(!NILP (tem) || NILP (buffer) || !inherit_process_coding_system);
 
@@ -3400,23 +3485,23 @@ usage: (make-network-process &rest ARGS)  */)
 
   p = XPROCESS (proc);
 
-  PSET (p, childp, contact);
-  PSET (p, plist, Fcopy_sequence (Fplist_get (contact, QCplist)));
-  PSET (p, type, Qnetwork);
+  pset_childp (p, contact);
+  pset_plist (p, Fcopy_sequence (Fplist_get (contact, QCplist)));
+  pset_type (p, Qnetwork);
 
-  PSET (p, buffer, buffer);
-  PSET (p, sentinel, sentinel);
-  PSET (p, filter, filter);
-  PSET (p, log, Fplist_get (contact, QClog));
+  pset_buffer (p, buffer);
+  pset_sentinel (p, sentinel);
+  pset_filter (p, filter);
+  pset_log (p, Fplist_get (contact, QClog));
   if (tem = Fplist_get (contact, QCnoquery), !NILP (tem))
     p->kill_without_query = 1;
   if ((tem = Fplist_get (contact, QCstop), !NILP (tem)))
-    PSET (p, command, Qt);
+    pset_command (p, Qt);
   p->pid = 0;
   p->infd  = inch;
   p->outfd = outch;
   if (is_server && socktype != SOCK_DGRAM)
-    PSET (p, status, Qlisten);
+    pset_status (p, Qlisten);
 
   /* Make the process marker point into the process buffer (if any).  */
   if (BUFFERP (buffer))
@@ -3430,7 +3515,7 @@ usage: (make-network-process &rest ARGS)  */)
       /* We may get here if connect did succeed immediately.  However,
          in that case, we still need to signal this like a non-blocking
          connection.  */
-      PSET (p, status, Qconnect);
+      pset_status (p, Qconnect);
       if (!FD_ISSET (inch, &connect_wait_mask))
         {
           FD_SET (inch, &connect_wait_mask);
@@ -3497,7 +3582,7 @@ usage: (make-network-process &rest ARGS)  */)
         else
           val = Qnil;
       }
-    PSET (p, decode_coding_system, val);
+    pset_decode_coding_system (p, val);
 
     if (!NILP (tem))
       {
@@ -3531,13 +3616,13 @@ usage: (make-network-process &rest ARGS)  */)
         else
           val = Qnil;
       }
-    PSET (p, encode_coding_system, val);
+    pset_encode_coding_system (p, val);
   }
   setup_process_coding_systems (proc);
 
-  PSET (p, decoding_buf, empty_unibyte_string);
+  pset_decoding_buf (p, empty_unibyte_string);
   p->decoding_carryover = 0;
-  PSET (p, encoding_buf, empty_unibyte_string);
+  pset_encoding_buf (p, empty_unibyte_string);
 
   p->inherit_coding_system_flag
     = !(!NILP (tem) || NILP (buffer) || !inherit_process_coding_system);
@@ -4150,18 +4235,18 @@ server_accept_connection (Lisp_Object server, int channel)
                           conv_sockaddr_to_lisp (&saddr.sa, len));
 #endif
 
-  PSET (p, childp, contact);
-  PSET (p, plist, Fcopy_sequence (ps->plist));
-  PSET (p, type, Qnetwork);
+  pset_childp (p, contact);
+  pset_plist (p, Fcopy_sequence (ps->plist));
+  pset_type (p, Qnetwork);
 
-  PSET (p, buffer, buffer);
-  PSET (p, sentinel, ps->sentinel);
-  PSET (p, filter, ps->filter);
-  PSET (p, command, Qnil);
+  pset_buffer (p, buffer);
+  pset_sentinel (p, ps->sentinel);
+  pset_filter (p, ps->filter);
+  pset_command (p, Qnil);
   p->pid = 0;
   p->infd  = s;
   p->outfd = s;
-  PSET (p, status, Qrun);
+  pset_status (p, Qrun);
 
   /* Client processes for accepted connections are not stopped initially.  */
   if (!EQ (p->filter, Qt))
@@ -4178,13 +4263,13 @@ server_accept_connection (Lisp_Object server, int channel)
      of the new process should reflect the settings at the time the
      server socket was opened; not the current settings. */
 
-  PSET (p, decode_coding_system, ps->decode_coding_system);
-  PSET (p, encode_coding_system, ps->encode_coding_system);
+  pset_decode_coding_system (p, ps->decode_coding_system);
+  pset_encode_coding_system (p, ps->encode_coding_system);
   setup_process_coding_systems (proc);
 
-  PSET (p, decoding_buf, empty_unibyte_string);
+  pset_decoding_buf (p, empty_unibyte_string);
   p->decoding_carryover = 0;
-  PSET (p, encoding_buf, empty_unibyte_string);
+  pset_encoding_buf (p, empty_unibyte_string);
 
   p->inherit_coding_system_flag
     = (NILP (buffer) ? 0 : ps->inherit_coding_system_flag);
@@ -4889,7 +4974,7 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
                          waitpid() will not find the process object to
                          delete.  Do it here.  */
                       p->tick = ++process_tick;
-                      PSET (p, status, Qfailed);
+                      pset_status (p, Qfailed);
                     }
                   else
                     kill (getpid (), SIGCHLD);
@@ -4909,8 +4994,8 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
                   if (XPROCESS (proc)->raw_status_new)
                     update_status (XPROCESS (proc));
                   if (EQ (XPROCESS (proc)->status, Qrun))
-                    PSET (XPROCESS (proc), status,
-                          Fcons (Qexit, Fcons (make_number (256), Qnil)));
+                    pset_status (XPROCESS (proc),
+                                 list2 (Qexit, make_number (256)));
                 }
             }
 #ifdef NON_BLOCKING_CONNECT
@@ -4958,13 +5043,12 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
               if (xerrno)
                 {
                   p->tick = ++process_tick;
-                  PSET (p, status,
-                        Fcons (Qfailed, Fcons (make_number (xerrno), Qnil)));
+                  pset_status (p, list2 (Qfailed, make_number (xerrno)));
                   deactivate_process (proc);
                 }
               else
                 {
-                  PSET (p, status, Qrun);
+                  pset_status (p, Qrun);
                   /* Execute the sentinel here.  If we had relied on
                      status_notify to do it later, it will read input
                      from the process before calling the sentinel.  */
@@ -5164,7 +5248,7 @@ read_process_output (Lisp_Object proc, register int channel)
       /* A new coding system might be found.  */
       if (!EQ (p->decode_coding_system, Vlast_coding_system_used))
         {
-          PSET (p, decode_coding_system, Vlast_coding_system_used);
+          pset_decode_coding_system (p, Vlast_coding_system_used);
 
           /* Don't call setup_coding_system for
              proc_decode_coding_system[channel] here.  It is done in
@@ -5180,8 +5264,8 @@ read_process_output (Lisp_Object proc, register int channel)
           if (NILP (p->encode_coding_system)
               && proc_encode_coding_system[p->outfd])
             {
-              PSET (p, encode_coding_system,
-                    coding_inherit_eol_type (Vlast_coding_system_used, Qnil));
+              pset_encode_coding_system
+                (p, coding_inherit_eol_type (Vlast_coding_system_used, Qnil));
               setup_coding_system (p->encode_coding_system,
                                    proc_encode_coding_system[p->outfd]);
             }
@@ -5190,7 +5274,7 @@ read_process_output (Lisp_Object proc, register int channel)
       if (coding->carryover_bytes > 0)
         {
           if (SCHARS (p->decoding_buf) < coding->carryover_bytes)
-            PSET (p, decoding_buf, make_uninit_string (coding->carryover_bytes));
+            pset_decoding_buf (p, make_uninit_string (coding->carryover_bytes));
           memcpy (SDATA (p->decoding_buf), coding->carryover,
                   coding->carryover_bytes);
           p->decoding_carryover = coding->carryover_bytes;
@@ -5246,7 +5330,7 @@ read_process_output (Lisp_Object proc, register int channel)
       old_begv_byte = BEGV_BYTE;
       old_zv_byte = ZV_BYTE;
 
-      BSET (current_buffer, read_only, Qnil);
+      bset_read_only (current_buffer, Qnil);
 
       /* Insert new output into buffer
          at the current end-of-output marker,
@@ -5274,12 +5358,12 @@ read_process_output (Lisp_Object proc, register int channel)
          similar code in the previous `if' block.  */
       if (!EQ (p->decode_coding_system, Vlast_coding_system_used))
         {
-          PSET (p, decode_coding_system, Vlast_coding_system_used);
+          pset_decode_coding_system (p, Vlast_coding_system_used);
           if (NILP (p->encode_coding_system)
               && proc_encode_coding_system[p->outfd])
             {
-              PSET (p, encode_coding_system,
-                    coding_inherit_eol_type (Vlast_coding_system_used, Qnil));
+              pset_encode_coding_system
+                (p, coding_inherit_eol_type (Vlast_coding_system_used, Qnil));
               setup_coding_system (p->encode_coding_system,
                                    proc_encode_coding_system[p->outfd]);
             }
@@ -5287,7 +5371,7 @@ read_process_output (Lisp_Object proc, register int channel)
       if (coding->carryover_bytes > 0)
         {
           if (SCHARS (p->decoding_buf) < coding->carryover_bytes)
-            PSET (p, decoding_buf, make_uninit_string (coding->carryover_bytes));
+            pset_decoding_buf (p, make_uninit_string (coding->carryover_bytes));
           memcpy (SDATA (p->decoding_buf), coding->carryover,
                   coding->carryover_bytes);
           p->decoding_carryover = coding->carryover_bytes;
@@ -5337,7 +5421,7 @@ read_process_output (Lisp_Object proc, register int channel)
         Fnarrow_to_region (make_number (old_begv), make_number (old_zv));
 
 
-      BSET (current_buffer, read_only, old_read_only);
+      bset_read_only (current_buffer, old_read_only);
       SET_PT_BOTH (opoint, opoint_byte);
     }
   /* Handling the process output should not deactivate the mark.  */
@@ -5404,9 +5488,9 @@ write_queue_push (struct Lisp_Process *p, Lisp_Object input_obj,
   entry = Fcons (obj, Fcons (make_number (offset), make_number (len)));
 
   if (front)
-    PSET (p, write_queue, Fcons (entry, p->write_queue));
+    pset_write_queue (p, Fcons (entry, p->write_queue));
   else
-    PSET (p, write_queue, nconc2 (p->write_queue, Fcons (entry, Qnil)));
+    pset_write_queue (p, nconc2 (p->write_queue, Fcons (entry, Qnil)));
 }
 
 /* Remove the first element in the write_queue of process P, put its
@@ -5424,7 +5508,7 @@ write_queue_pop (struct Lisp_Process *p, Lisp_Object *obj,
     return 0;
 
   entry = XCAR (p->write_queue);
-  PSET (p, write_queue, XCDR (p->write_queue));
+  pset_write_queue (p, XCDR (p->write_queue));
 
   *obj = XCAR (entry);
   offset_length = XCDR (entry);
@@ -5471,8 +5555,8 @@ send_process (volatile Lisp_Object proc, const char *volatile buf,
           && !NILP (BVAR (XBUFFER (object), enable_multibyte_characters)))
       || EQ (object, Qt))
     {
-      PSET (p, encode_coding_system,
-            complement_process_encoding_system (p->encode_coding_system));
+      pset_encode_coding_system
+        (p, complement_process_encoding_system (p->encode_coding_system));
       if (!EQ (Vlast_coding_system_used, p->encode_coding_system))
         {
           /* The coding system for encoding was changed to raw-text
@@ -5693,7 +5777,7 @@ send_process (volatile Lisp_Object proc, const char *volatile buf,
       proc = process_sent_to;
       p = XPROCESS (proc);
       p->raw_status_new = 0;
-      PSET (p, status, Fcons (Qexit, Fcons (make_number (256), Qnil)));
+      pset_status (p, Fcons (Qexit, Fcons (make_number (256), Qnil)));
       p->tick = ++process_tick;
       deactivate_process (proc);
       error ("SIGPIPE raised on process %s; closed it", SDATA (p->name));
@@ -5922,7 +6006,7 @@ process_send_signal (Lisp_Object process, int signo, Lisp_Object current_group,
 #ifdef SIGCONT
     case SIGCONT:
       p->raw_status_new = 0;
-      PSET (p, status, Qrun);
+      pset_status (p, Qrun);
       p->tick = ++process_tick;
       if (!nomsg)
         {
@@ -6018,7 +6102,7 @@ traffic.  */)
           FD_CLR (p->infd, &input_wait_mask);
           FD_CLR (p->infd, &non_keyboard_wait_mask);
         }
-      PSET (p, command, Qt);
+      pset_command (p, Qt);
       return process;
     }
 #ifndef SIGTSTP
@@ -6054,7 +6138,7 @@ traffic.  */)
           tcflush (p->infd, TCIFLUSH);
 #endif /* not WINDOWSNT */
         }
-      PSET (p, command, Qnil);
+      pset_command (p, Qnil);
       return process;
     }
 #ifdef SIGCONT
@@ -6470,7 +6554,7 @@ sigchld_handler (int signo)
 static Lisp_Object
 exec_sentinel_unwind (Lisp_Object data)
 {
-  PSET (XPROCESS (XCAR (data)), sentinel, XCDR (data));
+  pset_sentinel (XPROCESS (XCAR (data)), XCDR (data));
   return Qnil;
 }
 
@@ -6516,7 +6600,7 @@ exec_sentinel (Lisp_Object proc, Lisp_Object reason)
 
   /* Zilch the sentinel while it's running, to avoid recursive invocations;
      assure that it gets restored no matter how the sentinel exits.  */
-  PSET (p, sentinel, Qnil);
+  pset_sentinel (p, Qnil);
   record_unwind_protect (exec_sentinel_unwind, Fcons (proc, sentinel));
   /* Inhibit quit so that random quits don't screw up a running filter.  */
   specbind (Qinhibit_quit, Qt);
@@ -6671,13 +6755,13 @@ status_notify (struct Lisp_Process *deleting_process)
               before_byte = PT_BYTE;
 
               tem = BVAR (current_buffer, read_only);
-              BSET (current_buffer, read_only, Qnil);
+              bset_read_only (current_buffer, Qnil);
               insert_string ("\nProcess ");
               { /* FIXME: temporary kludge */
                 Lisp_Object tem2 = p->name; Finsert (1, &tem2); }
               insert_string (" ");
               Finsert (1, &msg);
-              BSET (current_buffer, read_only, tem);
+              bset_read_only (current_buffer, tem);
               set_marker_both (p->mark, p->buffer, PT, PT_BYTE);
 
               if (opoint >= before)
@@ -6714,8 +6798,8 @@ encode subprocess input.  */)
   Fcheck_coding_system (decoding);
   Fcheck_coding_system (encoding);
   encoding = coding_inherit_eol_type (encoding, Qnil);
-  PSET (p, decode_coding_system, decoding);
-  PSET (p, encode_coding_system, encoding);
+  pset_decode_coding_system (p, decoding);
+  pset_encode_coding_system (p, encoding);
   setup_process_coding_systems (process);
 
   return Qnil;
@@ -6745,8 +6829,8 @@ suppressed.  */)
   CHECK_PROCESS (process);
   p = XPROCESS (process);
   if (NILP (flag))
-    PSET (p, decode_coding_system,
-          raw_text_coding_system (p->decode_coding_system));
+    pset_decode_coding_system
+      (p, raw_text_coding_system (p->decode_coding_system));
   setup_process_coding_systems (process);
 
   return Qnil;
diff --git a/src/process.h b/src/process.h
index 43cc7ea33c0..55a572117c6 100644
--- a/src/process.h
+++ b/src/process.h
@@ -26,10 +26,10 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "gnutls.h"
 #endif
 
-/* Most code should use these macros to set
-   Lisp fields in struct Lisp_Process.  */
-
-#define PSET(p, field, value) ((p)->field = (value))
+INLINE_HEADER_BEGIN
+#ifndef PROCESS_INLINE
+# define PROCESS_INLINE INLINE
+#endif
 
 /* This structure records information about a subprocess
    or network connection.  */
@@ -165,6 +165,23 @@ struct Lisp_Process
 
 #define ChannelMask(n) (1 << (n))
 
+/* Most code should use these functions to set Lisp fields in struct
+   process.  */
+
+PROCESS_INLINE void
+pset_childp (struct Lisp_Process *p, Lisp_Object val)
+{
+  p->childp = val;
+}
+
+#ifdef HAVE_GNUTLS
+PROCESS_INLINE void
+pset_gnutls_cred_type (struct Lisp_Process *p, Lisp_Object val)
+{
+  p->gnutls_cred_type = val;
+}
+#endif
+
 /* True if we are about to fork off a synchronous process or if we
    are waiting for it.  */
 extern int synch_process_alive;
@@ -208,3 +225,5 @@ extern void add_read_fd (int fd, fd_callback func, void *data);
 extern void delete_read_fd (int fd);
 extern void add_write_fd (int fd, fd_callback func, void *data);
 extern void delete_write_fd (int fd);
+
+INLINE_HEADER_END
diff --git a/src/search.c b/src/search.c
index 004e599be9c..0b4f635066c 100644
--- a/src/search.c
+++ b/src/search.c
@@ -278,8 +278,8 @@ looking_at_1 (Lisp_Object string, int posix)
     save_search_regs ();
 
   /* This is so set_image_of_range_1 in regex.c can find the EQV table.  */
-  XCHAR_TABLE (BVAR (current_buffer, case_canon_table))->extras[2]
-    = BVAR (current_buffer, case_eqv_table);
+  set_char_table_extras (BVAR (current_buffer, case_canon_table), 2,
+                         BVAR (current_buffer, case_eqv_table));
 
   CHECK_STRING (string);
   bufp = compile_pattern (string,
@@ -393,8 +393,8 @@ string_match_1 (Lisp_Object regexp, Lisp_Object string, Lisp_Object start, int p
     }
 
   /* This is so set_image_of_range_1 in regex.c can find the EQV table.  */
-  XCHAR_TABLE (BVAR (current_buffer, case_canon_table))->extras[2]
-    = BVAR (current_buffer, case_eqv_table);
+  set_char_table_extras (BVAR (current_buffer, case_canon_table), 2,
+                         BVAR (current_buffer, case_eqv_table));
 
   bufp = compile_pattern (regexp,
                           (NILP (Vinhibit_changing_match_data)
@@ -990,8 +990,8 @@ search_command (Lisp_Object string, Lisp_Object bound, Lisp_Object noerror,
     }
 
   /* This is so set_image_of_range_1 in regex.c can find the EQV table.  */
-  XCHAR_TABLE (BVAR (current_buffer, case_canon_table))->extras[2]
-    = BVAR (current_buffer, case_eqv_table);
+  set_char_table_extras (BVAR (current_buffer, case_canon_table), 2,
+                         BVAR (current_buffer, case_eqv_table));
 
   np = search_buffer (string, PT, PT_BYTE, lim, lim_byte, n, RE,
                       (!NILP (BVAR (current_buffer, case_fold_search))
diff --git a/src/syntax.c b/src/syntax.c
index 08a63e033b2..f995b8f2cac 100644
--- a/src/syntax.c
+++ b/src/syntax.c
@@ -20,7 +20,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include <config.h>
 
-#include <ctype.h>
 #include <sys/types.h>
 #include <setjmp.h>
 #include "lisp.h"
@@ -150,6 +149,13 @@ static void scan_sexps_forward (struct lisp_parse_state *,
                                 ptrdiff_t, ptrdiff_t, ptrdiff_t, EMACS_INT,
                                 int, Lisp_Object, int);
 static int in_classes (int, Lisp_Object);
+
+/* This setter is used only in this file, so it can be private.  */
+static inline void
+bset_syntax_table (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (syntax_table) = val;
+}
 
 /* Whether the syntax of the character C has the prefix flag set.  */
 int syntax_prefix_flag_p (int c)
@@ -819,7 +825,7 @@ It is a copy of the TABLE, which defaults to the standard syntax table.  */)
 
   /* Only the standard syntax table should have a default element.
      Other syntax tables should inherit from parents instead.  */
-  XCHAR_TABLE (copy)->defalt = Qnil;
+  set_char_table_defalt (copy, Qnil);
 
   /* Copied syntax tables should all have parents.
      If we copied one with no parent, such as the standard syntax table,
@@ -836,7 +842,7 @@ One argument, a syntax table.  */)
 {
   int idx;
   check_syntax_table (table);
-  BSET (current_buffer, syntax_table, table);
+  bset_syntax_table (current_buffer, table);
   /* Indicate that this buffer now has a specified syntax table.  */
   idx = PER_BUFFER_VAR_IDX (syntax_table);
   SET_PER_BUFFER_VALUE_P (current_buffer, idx, 1);
diff --git a/src/sysdep.c b/src/sysdep.c
index 01ca905a987..183ee005227 100644
--- a/src/sysdep.c
+++ b/src/sysdep.c
@@ -21,7 +21,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #define SYSTIME_INLINE EXTERN_INLINE
 
-#include <ctype.h>
 #include <signal.h>
 #include <stdio.h>
 #include <setjmp.h>
@@ -33,6 +32,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <unistd.h>
 
 #include <allocator.h>
+#include <c-ctype.h>
 #include <careadlinkat.h>
 #include <ignore-value.h>
 #include <utimens.h>
@@ -2307,8 +2307,7 @@ serial_configure (struct Lisp_Process *p,
     error ("tcsetattr() failed: %s", emacs_strerror (errno));
 
   childp2 = Fplist_put (childp2, QCsummary, build_string (summary));
-  PSET (p, childp, childp2);
-
+  pset_childp (p, childp2);
 }
 #endif /* not DOS_NT  */
 
@@ -2733,7 +2732,7 @@ system_process_attributes (Lisp_Object pid)
           if (emacs_read (fd, &ch, 1) != 1)
             break;
           c = ch;
-          if (isspace (c) || c == '\\')
+          if (c_isspace (c) || c == '\\')
             cmdline_size++;     /* for later quoting, see below */
         }
       if (cmdline_size)
@@ -2757,7 +2756,7 @@ system_process_attributes (Lisp_Object pid)
           for (p = cmdline; p < cmdline + nread; p++)
             {
               /* Escape-quote whitespace and backslashes.  */
-              if (isspace (*p) || *p == '\\')
+              if (c_isspace (*p) || *p == '\\')
                 {
                   memmove (p + 1, p, nread - (p - cmdline));
                   nread++;
diff --git a/src/term.c b/src/term.c
index 514c7ad11ec..23e074287c1 100644
--- a/src/term.c
+++ b/src/term.c
@@ -21,7 +21,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include <config.h>
 #include <stdio.h>
-#include <ctype.h>
 #include <errno.h>
 #include <sys/file.h>
 #include <sys/time.h>
@@ -1333,7 +1332,7 @@ term_get_fkeys_1 (void)
 
   /* This can happen if CANNOT_DUMP or with strange options.  */
   if (!KEYMAPP (KVAR (kboard, Vinput_decode_map)))
-    KSET (kboard, Vinput_decode_map, Fmake_sparse_keymap (Qnil));
+    kset_input_decode_map (kboard, Fmake_sparse_keymap (Qnil));
 
   for (i = 0; i < (sizeof (keys)/sizeof (keys[0])); i++)
     {
@@ -3281,7 +3280,7 @@ use the Bourne shell command `TERM=... export TERM' (C-shell:\n\
 
   terminal->kboard = xmalloc (sizeof *terminal->kboard);
   init_kboard (terminal->kboard);
-  KSET (terminal->kboard, Vwindow_system, Qnil);
+  kset_window_system (terminal->kboard, Qnil);
   terminal->kboard->next_kboard = all_kboards;
   all_kboards = terminal->kboard;
   terminal->kboard->reference_count++;
diff --git a/src/termhooks.h b/src/termhooks.h
index 51815886c78..a1164be85cc 100644
--- a/src/termhooks.h
+++ b/src/termhooks.h
@@ -22,6 +22,11 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "systime.h" /* for Time */
 
+INLINE_HEADER_BEGIN
+#ifndef TERMHOOKS_INLINE
+# define TERMHOOKS_INLINE INLINE
+#endif
+
 struct glyph;
 struct frame;
 
@@ -324,10 +329,6 @@ struct ns_display_info;
 struct x_display_info;
 struct w32_display_info;
 
-/* Most code should use this macro to set Lisp field in struct terminal.  */
-
-#define TSET(f, field, value) ((f)->field = (value))
-
 /* Terminal-local parameters. */
 struct terminal
 {
@@ -634,6 +635,18 @@ struct terminal
   void (*delete_terminal_hook) (struct terminal *);
 };
 
+/* Most code should use these functions to set Lisp fields in struct
+   terminal.  */
+TERMHOOKS_INLINE void
+tset_charset_list (struct terminal *t, Lisp_Object val)
+{
+  t->charset_list = val;
+}
+TERMHOOKS_INLINE void
+tset_selection_alist (struct terminal *t, Lisp_Object val)
+{
+  t->Vselection_alist = val;
+}
 
 /* Chain of all terminal devices currently in use. */
 extern struct terminal *terminal_list;
@@ -672,3 +685,5 @@ extern unsigned char *encode_terminal_code (struct glyph *, int,
 #ifdef HAVE_GPM
 extern void close_gpm (int gpm_fd);
 #endif
+
+INLINE_HEADER_END
diff --git a/src/terminal.c b/src/terminal.c
index 53610d9736f..d94164a4e40 100644
--- a/src/terminal.c
+++ b/src/terminal.c
@@ -17,6 +17,9 @@ You should have received a copy of the GNU General Public License
 along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include <config.h>
+
+#define TERMHOOKS_INLINE EXTERN_INLINE
+
 #include <stdio.h>
 #include <setjmp.h>
 
@@ -39,6 +42,13 @@ struct terminal *initial_terminal;
 
 static void delete_initial_terminal (struct terminal *);
 
+/* This setter is used only in this file, so it can be private.  */
+static inline void
+tset_param_alist (struct terminal *t, Lisp_Object val)
+{
+  t->param_alist = val;
+}
+
 
 
 void
@@ -446,7 +456,7 @@ store_terminal_param (struct terminal *t, Lisp_Object parameter, Lisp_Object val
   Lisp_Object old_alist_elt = Fassq (parameter, t->param_alist);
   if (EQ (old_alist_elt, Qnil))
     {
-      TSET (t, param_alist, Fcons (Fcons (parameter, value), t->param_alist));
+      tset_param_alist (t, Fcons (Fcons (parameter, value), t->param_alist));
       return Qnil;
     }
   else
diff --git a/src/textprop.c b/src/textprop.c
index ac1980fde78..20d98b0e6f3 100644
--- a/src/textprop.c
+++ b/src/textprop.c
@@ -143,7 +143,7 @@ validate_interval_range (Lisp_Object object, Lisp_Object *begin, Lisp_Object *en
       if (!(BUF_BEGV (b) <= XINT (*begin) && XINT (*begin) <= XINT (*end)
             && XINT (*end) <= BUF_ZV (b)))
         args_out_of_range (*begin, *end);
-      i = buffer_get_intervals (b);
+      i = buffer_intervals (b);
 
       /* If there's no text, there are no properties.  */
       if (BUF_BEGV (b) == BUF_ZV (b))
@@ -161,7 +161,7 @@ validate_interval_range (Lisp_Object object, Lisp_Object *begin, Lisp_Object *en
       XSETFASTINT (*begin, XFASTINT (*begin));
       if (begin != end)
         XSETFASTINT (*end, XFASTINT (*end));
-      i = string_get_intervals (object);
+      i = string_intervals (object);
 
       if (len == 0)
         return NULL;
@@ -338,7 +338,7 @@ set_properties (Lisp_Object properties, INTERVAL interval, Lisp_Object object)
     }
 
   /* Store new properties.  */
-  interval_set_plist (interval, Fcopy_sequence (properties));
+  set_interval_plist (interval, Fcopy_sequence (properties));
 }
 
 /* Add the properties of PLIST to the interval I, or set
@@ -411,7 +411,7 @@ add_properties (Lisp_Object plist, INTERVAL i, Lisp_Object object)
               record_property_change (i->position, LENGTH (i),
                                       sym1, Qnil, object);
             }
-          interval_set_plist (i, Fcons (sym1, Fcons (val1, i->plist)));
+          set_interval_plist (i, Fcons (sym1, Fcons (val1, i->plist)));
           changed++;
         }
     }
@@ -484,7 +484,7 @@ remove_properties (Lisp_Object plist, Lisp_Object list, INTERVAL i, Lisp_Object
     }
 
   if (changed)
-    interval_set_plist (i, current_plist);
+    set_interval_plist (i, current_plist);
   return changed;
 }
 
@@ -510,13 +510,13 @@ interval_of (ptrdiff_t position, Lisp_Object object)
 
       beg = BUF_BEGV (b);
       end = BUF_ZV (b);
-      i = buffer_get_intervals (b);
+      i = buffer_intervals (b);
     }
   else
     {
       beg = 0;
       end = SCHARS (object);
-      i = string_get_intervals (object);
+      i = string_intervals (object);
     }
 
   if (!(beg <= position && position <= end))
@@ -1274,10 +1274,10 @@ set_text_properties (Lisp_Object start, Lisp_Object end, Lisp_Object properties,
       && XFASTINT (start) == 0
       && XFASTINT (end) == SCHARS (object))
     {
-      if (!string_get_intervals (object))
+      if (!string_intervals (object))
         return Qnil;
 
-      string_set_intervals (object, NULL);
+      set_string_intervals (object, NULL);
       return Qt;
     }
 
@@ -1339,7 +1339,7 @@ set_text_properties_1 (Lisp_Object start, Lisp_Object end, Lisp_Object propertie
     return;
 
   if (i == NULL)
-    i = find_interval (buffer_get_intervals (XBUFFER (buffer)), s);
+    i = find_interval (buffer_intervals (XBUFFER (buffer)), s);
 
   if (i->position != s)
     {
@@ -1993,10 +1993,10 @@ void
 verify_interval_modification (struct buffer *buf,
                               ptrdiff_t start, ptrdiff_t end)
 {
-  register INTERVAL intervals = buffer_get_intervals (buf);
-  register INTERVAL i;
+  INTERVAL intervals = buffer_intervals (buf);
+  INTERVAL i;
   Lisp_Object hooks;
-  register Lisp_Object prev_mod_hooks;
+  Lisp_Object prev_mod_hooks;
   Lisp_Object mod_hooks;
   struct gcpro gcpro1;
 
diff --git a/src/undo.c b/src/undo.c
index cfb67ba5bc8..777e3291806 100644
--- a/src/undo.c
+++ b/src/undo.c
@@ -104,9 +104,9 @@ record_point (ptrdiff_t pt)
   if (at_boundary
       && current_buffer == last_boundary_buffer
       && last_boundary_position != pt)
-    BSET (current_buffer, undo_list,
-          Fcons (make_number (last_boundary_position),
-                 BVAR (current_buffer, undo_list)));
+    bset_undo_list (current_buffer,
+                    Fcons (make_number (last_boundary_position),
+                           BVAR (current_buffer, undo_list)));
 }
 
 /* Record an insertion that just happened or is about to happen,
@@ -142,8 +142,8 @@ record_insert (ptrdiff_t beg, ptrdiff_t length)
 
   XSETFASTINT (lbeg, beg);
   XSETINT (lend, beg + length);
-  BSET (current_buffer, undo_list,
-        Fcons (Fcons (lbeg, lend), BVAR (current_buffer, undo_list)));
+  bset_undo_list (current_buffer,
+                  Fcons (Fcons (lbeg, lend), BVAR (current_buffer, undo_list)));
 }
 
 /* Record that a deletion is about to take place,
@@ -168,8 +168,9 @@ record_delete (ptrdiff_t beg, Lisp_Object string)
       record_point (beg);
     }
 
-  BSET (current_buffer, undo_list,
-       Fcons (Fcons (string, sbeg), BVAR (current_buffer, undo_list)));
+  bset_undo_list
+    (current_buffer,
+     Fcons (Fcons (string, sbeg), BVAR (current_buffer, undo_list)));
 }
 
 /* Record the fact that MARKER is about to be adjusted by ADJUSTMENT.
@@ -191,9 +192,10 @@ record_marker_adjustment (Lisp_Object marker, ptrdiff_t adjustment)
     Fundo_boundary ();
   last_undo_buffer = current_buffer;
 
-  BSET (current_buffer, undo_list,
-        Fcons (Fcons (marker, make_number (adjustment)),
-               BVAR (current_buffer, undo_list)));
+  bset_undo_list
+    (current_buffer,
+     Fcons (Fcons (marker, make_number (adjustment)),
+            BVAR (current_buffer, undo_list)));
 }
 
 /* Record that a replacement is about to take place,
@@ -226,9 +228,10 @@ record_first_change (void)
   if (base_buffer->base_buffer)
     base_buffer = base_buffer->base_buffer;
 
-  BSET (current_buffer, undo_list,
-        Fcons (Fcons (Qt, make_lisp_time (base_buffer->modtime)),
-               BVAR (current_buffer, undo_list)));
+  bset_undo_list
+    (current_buffer,
+     Fcons (Fcons (Qt, make_lisp_time (base_buffer->modtime)),
+            BVAR (current_buffer, undo_list)));
 }
 
 /* Record a change in property PROP (whose old value was VAL)
@@ -266,8 +269,8 @@ record_property_change (ptrdiff_t beg, ptrdiff_t length,
   XSETINT (lbeg, beg);
   XSETINT (lend, beg + length);
   entry = Fcons (Qnil, Fcons (prop, Fcons (value, Fcons (lbeg, lend))));
-  BSET (current_buffer, undo_list,
-        Fcons (entry, BVAR (current_buffer, undo_list)));
+  bset_undo_list (current_buffer,
+                  Fcons (entry, BVAR (current_buffer, undo_list)));
 
   current_buffer = obuf;
 }
@@ -290,11 +293,12 @@ but another undo command will undo to the previous boundary.  */)
           /* If we have preallocated the cons cell to use here,
              use that one.  */
           XSETCDR (pending_boundary, BVAR (current_buffer, undo_list));
-          BSET (current_buffer, undo_list, pending_boundary);
+          bset_undo_list (current_buffer, pending_boundary);
           pending_boundary = Qnil;
         }
       else
-        BSET (current_buffer, undo_list, Fcons (Qnil, BVAR (current_buffer, undo_list)));
+        bset_undo_list (current_buffer,
+                        Fcons (Qnil, BVAR (current_buffer, undo_list)));
     }
   last_boundary_position = PT;
   last_boundary_buffer = current_buffer;
@@ -435,7 +439,7 @@ truncate_undo_list (struct buffer *b)
     XSETCDR (last_boundary, Qnil);
   /* There's nothing we decided to keep, so clear it out.  */
   else
-    BSET (b, undo_list, Qnil);
+    bset_undo_list (b, Qnil);
 
   unbind_to (count, Qnil);
 }
@@ -650,8 +654,9 @@ Return what remains of the list.  */)
      will work right.  */
   if (did_apply
       && EQ (oldlist, BVAR (current_buffer, undo_list)))
-    BSET (current_buffer, undo_list,
-          Fcons (list3 (Qapply, Qcdr, Qnil), BVAR (current_buffer, undo_list)));
+    bset_undo_list
+      (current_buffer,
+       Fcons (list3 (Qapply, Qcdr, Qnil), BVAR (current_buffer, undo_list)));
 
   UNGCPRO;
   return unbind_to (count, list);
diff --git a/src/w32.c b/src/w32.c
index 61de234cf70..b460660cb8c 100644
--- a/src/w32.c
+++ b/src/w32.c
@@ -7023,7 +7023,7 @@ serial_configure (struct Lisp_Process *p, Lisp_Object contact)
     error ("SetCommState() failed");
 
   childp2 = Fplist_put (childp2, QCsummary, build_string (summary));
-  PSET (p, childp, childp2);
+  pset_childp (p, childp2);
 }
 
 #ifdef HAVE_GNUTLS
diff --git a/src/w32fns.c b/src/w32fns.c
index 7779f032104..9c5231f9d93 100644
--- a/src/w32fns.c
+++ b/src/w32fns.c
@@ -1490,7 +1490,7 @@ x_set_icon_name (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
   else if (!NILP (arg) || NILP (oldval))
     return;
 
-  FSET (f, icon_name, arg);
+  fset_icon_name (f, arg);
 
 #if 0
   if (f->output_data.w32->icon_bitmap != 0)
@@ -1686,7 +1686,7 @@ x_set_name (struct frame *f, Lisp_Object name, int explicit)
   if (! NILP (Fstring_equal (name, f->name)))
     return;
 
-  FSET (f, name, name);
+  fset_name (f, name);
 
   /* For setting the frame title, the title parameter should override
      the name parameter.  */
@@ -1734,7 +1734,7 @@ x_set_title (struct frame *f, Lisp_Object name, Lisp_Object old_name)
 
   update_mode_lines = 1;
 
-  FSET (f, title, name);
+  fset_title (f, name);
 
   if (NILP (name))
     name = f->name;
@@ -3925,7 +3925,7 @@ w32_window (struct frame *f, long window_prompting, int minibuffer_only)
 
     f->explicit_name = 0;
     name = f->name;
-    FSET (f, name, Qnil);
+    fset_name (f, Qnil);
     x_set_name (f, name, explicit);
   }
 
@@ -4174,11 +4174,11 @@ This function is an internal primitive--use `make-frame' instead.  */)
   f->output_data.w32 = xzalloc (sizeof (struct w32_output));
   FRAME_FONTSET (f) = -1;
 
-  FSET (f, icon_name,
-        x_get_arg (dpyinfo, parameters, Qicon_name, "iconName", "Title",
+  fset_icon_name
+    (f, x_get_arg (dpyinfo, parameters, Qicon_name, "iconName", "Title",
                    RES_TYPE_STRING));
   if (! STRINGP (f->icon_name))
-    FSET (f, icon_name, Qnil);
+    fset_icon_name (f, Qnil);
 
 /*  FRAME_W32_DISPLAY_INFO (f) = dpyinfo; */
 
@@ -4207,12 +4207,12 @@ This function is an internal primitive--use `make-frame' instead.  */)
      be set.  */
   if (EQ (name, Qunbound) || NILP (name))
     {
-      FSET (f, name, build_string (dpyinfo->w32_id_name));
+      fset_name (f, build_string (dpyinfo->w32_id_name));
       f->explicit_name = 0;
     }
   else
     {
-      FSET (f, name, name);
+      fset_name (f, name);
       f->explicit_name = 1;
       /* use the frame's title when getting resources for this frame.  */
       specbind (Qx_resource_name, name);
@@ -4381,13 +4381,13 @@ This function is an internal primitive--use `make-frame' instead.  */)
   if (FRAME_HAS_MINIBUF_P (f)
       && (!FRAMEP (KVAR (kb, Vdefault_minibuffer_frame))
           || !FRAME_LIVE_P (XFRAME (KVAR (kb, Vdefault_minibuffer_frame)))))
-    KSET (kb, Vdefault_minibuffer_frame, frame);
+    kset_default_minibuffer_frame (kb, frame);
 
   /* All remaining specified parameters, which have not been "used"
      by x_get_arg and friends, now go in the misc. alist of the frame.  */
   for (tem = parameters; CONSP (tem); tem = XCDR (tem))
     if (CONSP (XCAR (tem)) && !NILP (XCAR (XCAR (tem))))
-      FSET (f, param_alist, Fcons (XCAR (tem), f->param_alist));
+      fset_param_alist (f, Fcons (XCAR (tem), f->param_alist));
 
   UNGCPRO;
 
@@ -5242,7 +5242,7 @@ x_create_tip_frame (struct w32_display_info *dpyinfo,
   set_window_buffer (FRAME_ROOT_WINDOW (f), buffer, 0, 0);
   old_buffer = current_buffer;
   set_buffer_internal_1 (XBUFFER (buffer));
-  BSET (current_buffer, truncate_lines, Qnil);
+  bset_truncate_lines (current_buffer, Qnil);
   specbind (Qinhibit_read_only, Qt);
   specbind (Qinhibit_modification_hooks, Qt);
   Ferase_buffer ();
@@ -5261,7 +5261,7 @@ x_create_tip_frame (struct w32_display_info *dpyinfo,
   f->output_data.w32 = xzalloc (sizeof (struct w32_output));
 
   FRAME_FONTSET (f)  = -1;
-  FSET (f, icon_name, Qnil);
+  fset_icon_name (f, Qnil);
 
 #ifdef GLYPH_DEBUG
   image_cache_refcount =
@@ -5276,12 +5276,12 @@ x_create_tip_frame (struct w32_display_info *dpyinfo,
      be set.  */
   if (EQ (name, Qunbound) || NILP (name))
     {
-      FSET (f, name, build_string (dpyinfo->w32_id_name));
+      fset_name (f, build_string (dpyinfo->w32_id_name));
       f->explicit_name = 0;
     }
   else
     {
-      FSET (f, name, name);
+      fset_name (f, name);
       f->explicit_name = 1;
       /* use the frame's title when getting resources for this frame.  */
       specbind (Qx_resource_name, name);
@@ -5647,8 +5647,8 @@ Text larger than the specified size is clipped.  */)
 
   /* Set up the frame's root window.  */
   w = XWINDOW (FRAME_ROOT_WINDOW (f));
-  WSET (w, left_col, make_number (0));
-  WSET (w, top_line, make_number (0));
+  wset_left_col (w, make_number (0));
+  wset_top_line (w, make_number (0));
 
   if (CONSP (Vx_max_tooltip_size)
       && INTEGERP (XCAR (Vx_max_tooltip_size))
@@ -5656,13 +5656,13 @@ Text larger than the specified size is clipped.  */)
       && INTEGERP (XCDR (Vx_max_tooltip_size))
       && XINT (XCDR (Vx_max_tooltip_size)) > 0)
     {
-      WSET (w, total_cols, XCAR (Vx_max_tooltip_size));
-      WSET (w, total_lines, XCDR (Vx_max_tooltip_size));
+      wset_total_cols (w, XCAR (Vx_max_tooltip_size));
+      wset_total_lines (w, XCDR (Vx_max_tooltip_size));
     }
   else
     {
-      WSET (w, total_cols, make_number (80));
-      WSET (w, total_lines, make_number (40));
+      wset_total_cols (w, make_number (80));
+      wset_total_lines (w, make_number (40));
     }
 
   FRAME_TOTAL_COLS (f) = XINT (w->total_cols);
@@ -5672,7 +5672,7 @@ Text larger than the specified size is clipped.  */)
   /* Display the tooltip text in a temporary buffer.  */
   old_buffer = current_buffer;
   set_buffer_internal_1 (XBUFFER (XWINDOW (FRAME_ROOT_WINDOW (f))->buffer));
-  BSET (current_buffer, truncate_lines, Qnil);
+  bset_truncate_lines (current_buffer, Qnil);
   clear_glyph_matrix (w->desired_matrix);
   clear_glyph_matrix (w->current_matrix);
   SET_TEXT_POS (pos, BEGV, BEGV_BYTE);
@@ -5733,7 +5733,7 @@ Text larger than the specified size is clipped.  */)
       /* w->total_cols and FRAME_TOTAL_COLS want the width in columns,
          not in pixels.  */
       width /= WINDOW_FRAME_COLUMN_WIDTH (w);
-      WSET (w, total_cols, make_number (width));
+      wset_total_cols (w, make_number (width));
       FRAME_TOTAL_COLS (f) = width;
       adjust_glyphs (f);
       w->pseudo_window_p = 1;
diff --git a/src/w32menu.c b/src/w32menu.c
index 02302c2d594..3aa4c8bc96d 100644
--- a/src/w32menu.c
+++ b/src/w32menu.c
@@ -413,7 +413,7 @@ set_frame_menubar (FRAME_PTR f, int first_time, int deep_p)
       /* Run the hooks.  */
       safe_run_hooks (Qactivate_menubar_hook);
       safe_run_hooks (Qmenu_bar_update_hook);
-      FSET (f, menu_bar_items, menu_bar_items (FRAME_MENU_BAR_ITEMS (f)));
+      fset_menu_bar_items (f, menu_bar_items (FRAME_MENU_BAR_ITEMS (f)));
 
       items = FRAME_MENU_BAR_ITEMS (f);
 
@@ -500,7 +500,7 @@ set_frame_menubar (FRAME_PTR f, int first_time, int deep_p)
           return;
         }
 
-      FSET (f, menu_bar_vector, menu_items);
+      fset_menu_bar_vector (f, menu_items);
       f->menu_bar_items_used = menu_items_used;
 
       /* This undoes save_menu_items.  */
@@ -615,7 +615,7 @@ initialize_frame_menubar (FRAME_PTR f)
 {
   /* This function is called before the first chance to redisplay
      the frame.  It has to be, so the frame will have the right size.  */
-  FSET (f, menu_bar_items, menu_bar_items (FRAME_MENU_BAR_ITEMS (f)));
+  fset_menu_bar_items (f, menu_bar_items (FRAME_MENU_BAR_ITEMS (f)));
   set_frame_menubar (f, 1, 1);
 }
 
diff --git a/src/w32term.c b/src/w32term.c
index 7da9433d3f1..6948a98998e 100644
--- a/src/w32term.c
+++ b/src/w32term.c
@@ -2972,7 +2972,7 @@ x_frame_rehighlight (struct w32_display_info *dpyinfo)
            : dpyinfo->w32_focus_frame);
       if (! FRAME_LIVE_P (dpyinfo->x_highlight_frame))
         {
-          FSET (dpyinfo->w32_focus_frame, focus_frame, Qnil);
+          fset_focus_frame (dpyinfo->w32_focus_frame, Qnil);
           dpyinfo->x_highlight_frame = dpyinfo->w32_focus_frame;
         }
     }
@@ -3646,7 +3646,7 @@ x_scroll_bar_create (struct window *w, int top, int left, int width, int height)
   bar->next = FRAME_SCROLL_BARS (f);
   bar->prev = Qnil;
   XSETVECTOR (barobj, bar);
-  FSET (f, scroll_bars, barobj);
+  fset_scroll_bars (f, barobj);
   if (! NILP (bar->next))
     XSETVECTOR (XSCROLL_BAR (bar->next)->prev, bar);
 
@@ -3670,7 +3670,7 @@ x_scroll_bar_remove (struct scroll_bar *bar)
   my_destroy_window (f, SCROLL_BAR_W32_WINDOW (bar));
 
   /* Dissociate this scroll bar from its window.  */
-  WSET (XWINDOW (bar->window), vertical_scroll_bar, Qnil);
+  wset_vertical_scroll_bar (XWINDOW (bar->window), Qnil);
 
   UNBLOCK_INPUT;
 }
@@ -3808,7 +3808,7 @@ w32_set_vertical_scroll_bar (struct window *w,
 
   w32_set_scroll_bar_thumb (bar, portion, position, whole);
   XSETVECTOR (barobj, bar);
-  WSET (w, vertical_scroll_bar, barobj);
+  wset_vertical_scroll_bar (w, barobj);
 }
 
 
@@ -3832,12 +3832,12 @@ w32_condemn_scroll_bars (FRAME_PTR frame)
     {
       Lisp_Object bar;
       bar = FRAME_SCROLL_BARS (frame);
-      FSET (frame, scroll_bars, XSCROLL_BAR (bar)->next);
+      fset_scroll_bars (frame, XSCROLL_BAR (bar)->next);
       XSCROLL_BAR (bar)->next = FRAME_CONDEMNED_SCROLL_BARS (frame);
       XSCROLL_BAR (bar)->prev = Qnil;
       if (! NILP (FRAME_CONDEMNED_SCROLL_BARS (frame)))
         XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame))->prev = bar;
-      FSET (frame, condemned_scroll_bars, bar);
+      fset_condemned_scroll_bars (frame, bar);
     }
 }
 
@@ -3869,7 +3869,7 @@ w32_redeem_scroll_bar (struct window *window)
         return;
       else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f),
                    window->vertical_scroll_bar))
-        FSET (f, condemned_scroll_bars, bar->next);
+        fset_condemned_scroll_bars (f, bar->next);
       else
         /* If its prev pointer is nil, it must be at the front of
            one or the other!  */
@@ -3884,7 +3884,7 @@ w32_redeem_scroll_bar (struct window *window)
   bar->next = FRAME_SCROLL_BARS (f);
   bar->prev = Qnil;
   XSETVECTOR (barobj, bar);
-  FSET (f, scroll_bars, barobj);
+  fset_scroll_bars (f, barobj);
   if (! NILP (bar->next))
     XSETVECTOR (XSCROLL_BAR (bar->next)->prev, bar);
 }
@@ -3901,7 +3901,7 @@ w32_judge_scroll_bars (FRAME_PTR f)
 
   /* Clear out the condemned list now so we won't try to process any
      more events on the hapless scroll bars.  */
-  FSET (f, condemned_scroll_bars, Qnil);
+  fset_condemned_scroll_bars (f, Qnil);
 
   for (; ! NILP (bar); bar = next)
     {
@@ -6232,7 +6232,7 @@ w32_create_terminal (struct w32_display_info *dpyinfo)
      terminal like X does.  */
   terminal->kboard = xmalloc (sizeof (KBOARD));
   init_kboard (terminal->kboard);
-  KSET (terminal->kboard, Vwindow_system, intern ("w32"));
+  kset_window_system (terminal->kboard, intern ("w32"));
   terminal->kboard->next_kboard = all_kboards;
   all_kboards = terminal->kboard;
   /* Don't let the initial kboard remain current longer than necessary.
diff --git a/src/window.c b/src/window.c
index 31711718a38..d8e09162228 100644
--- a/src/window.c
+++ b/src/window.c
@@ -19,6 +19,9 @@ You should have received a copy of the GNU General Public License
 along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include <config.h>
+
+#define WINDOW_INLINE EXTERN_INLINE
+
 #include <stdio.h>
 #include <setjmp.h>
 
@@ -53,7 +56,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #ifdef HAVE_XWIDGETS
 #include "xwidget.h"
 #endif
-Lisp_Object Qwindowp, Qwindow_live_p;
+Lisp_Object Qwindowp, Qwindow_live_p, Qwindow_valid_p;
 static Lisp_Object Qwindow_configuration_p, Qrecord_window_buffer;
 static Lisp_Object Qwindow_deletable_p, Qdelete_window, Qdisplay_buffer;
 static Lisp_Object Qreplace_buffer_in_windows, Qget_mru_window;
@@ -63,7 +66,6 @@ static Lisp_Object Qsafe, Qabove, Qbelow;
 static Lisp_Object Qauto_buffer_name, Qclone_of;
 
 static int displayed_window_lines (struct window *);
-static struct window *decode_window (Lisp_Object);
 static int count_windows (struct window *);
 static int get_leaf_windows (struct window *, struct window **, int);
 static void window_scroll (Lisp_Object, EMACS_INT, int, int);
@@ -133,8 +135,120 @@ static int window_scroll_pixel_based_preserve_y;
 static EMACS_INT window_scroll_preserve_hpos;
 static EMACS_INT window_scroll_preserve_vpos;
 
-static struct window *
-decode_window (register Lisp_Object window)
+/* These setters are used only in this file, so they can be private.  */
+static inline void
+wset_combination_limit (struct window *w, Lisp_Object val)
+{
+  w->combination_limit = val;
+}
+static inline void
+wset_dedicated (struct window *w, Lisp_Object val)
+{
+  w->dedicated = val;
+}
+static inline void
+wset_display_table (struct window *w, Lisp_Object val)
+{
+  w->display_table = val;
+}
+static inline void
+wset_hchild (struct window *w, Lisp_Object val)
+{
+  w->hchild = val;
+}
+static inline void
+wset_left_fringe_width (struct window *w, Lisp_Object val)
+{
+  w->left_fringe_width = val;
+}
+static inline void
+wset_left_margin_cols (struct window *w, Lisp_Object val)
+{
+  w->left_margin_cols = val;
+}
+static inline void
+wset_new_normal (struct window *w, Lisp_Object val)
+{
+  w->new_normal = val;
+}
+static inline void
+wset_new_total (struct window *w, Lisp_Object val)
+{
+  w->new_total = val;
+}
+static inline void
+wset_next_buffers (struct window *w, Lisp_Object val)
+{
+  w->next_buffers = val;
+}
+static inline void
+wset_normal_cols (struct window *w, Lisp_Object val)
+{
+  w->normal_cols = val;
+}
+static inline void
+wset_normal_lines (struct window *w, Lisp_Object val)
+{
+  w->normal_lines = val;
+}
+static inline void
+wset_parent (struct window *w, Lisp_Object val)
+{
+  w->parent = val;
+}
+static inline void
+wset_pointm (struct window *w, Lisp_Object val)
+{
+  w->pointm = val;
+}
+static inline void
+wset_prev_buffers (struct window *w, Lisp_Object val)
+{
+  w->prev_buffers = val;
+}
+static inline void
+wset_right_fringe_width (struct window *w, Lisp_Object val)
+{
+  w->right_fringe_width = val;
+}
+static inline void
+wset_right_margin_cols (struct window *w, Lisp_Object val)
+{
+  w->right_margin_cols = val;
+}
+static inline void
+wset_scroll_bar_width (struct window *w, Lisp_Object val)
+{
+  w->scroll_bar_width = val;
+}
+static inline void
+wset_start (struct window *w, Lisp_Object val)
+{
+  w->start = val;
+}
+static inline void
+wset_temslot (struct window *w, Lisp_Object val)
+{
+  w->temslot = val;
+}
+static inline void
+wset_vchild (struct window *w, Lisp_Object val)
+{
+  w->vchild = val;
+}
+static inline void
+wset_vertical_scroll_bar_type (struct window *w, Lisp_Object val)
+{
+  w->vertical_scroll_bar_type = val;
+}
+static inline void
+wset_window_parameters (struct window *w, Lisp_Object val)
+{
+  w->window_parameters = val;
+}
+
+struct window *
+decode_live_window (register Lisp_Object window)
 {
   if (NILP (window))
     return XWINDOW (selected_window);
@@ -156,6 +270,19 @@ decode_any_window (register Lisp_Object window)
   return w;
 }
 
+struct window *
+decode_valid_window (register Lisp_Object window)
+{
+  struct window *w;
+
+  if (NILP (window))
+    return XWINDOW (selected_window);
+
+  CHECK_VALID_WINDOW (window);
+  w = XWINDOW (window);
+  return w;
+}
+
 DEFUN ("windowp", Fwindowp, Swindowp, 1, 1, 0,
        doc: /* Return t if OBJECT is a window and nil otherwise.  */)
   (Lisp_Object object)
@@ -163,6 +290,15 @@ DEFUN ("windowp", Fwindowp, Swindowp, 1, 1, 0,
   return WINDOWP (object) ? Qt : Qnil;
 }
 
+DEFUN ("window-valid-p", Fwindow_valid_p, Swindow_valid_p, 1, 1, 0,
+       doc: /* Return t if OBJECT is a valid window and nil otherwise.
+A valid window is either a window that displays a buffer or an internal
+window.  Deleted windows are not live.  */)
+  (Lisp_Object object)
+{
+  return WINDOW_VALID_P (object) ? Qt : Qnil;
+}
+
 DEFUN ("window-live-p", Fwindow_live_p, Swindow_live_p, 1, 1, 0,
        doc: /* Return t if OBJECT is a live window and nil otherwise.
 A live window is a window that displays a buffer.
@@ -175,10 +311,10 @@ Internal windows and deleted windows are not live.  */)
 /* Frames and windows.  */
 DEFUN ("window-frame", Fwindow_frame, Swindow_frame, 1, 1, 0,
        doc: /* Return the frame that window WINDOW is on.
-If WINDOW is omitted or nil, it defaults to the selected window.  */)
+WINDOW must be a valid window and defaults to the selected one.  */)
   (Lisp_Object window)
 {
-  return decode_any_window (window)->frame;
+  return decode_valid_window (window)->frame;
 }
 
 DEFUN ("frame-root-window", Fframe_root_window, Sframe_root_window, 0, 1, 0,
@@ -192,8 +328,8 @@ With a window argument, return the root window of that window's frame.  */)
 
   if (NILP (frame_or_window))
     window = SELECTED_FRAME ()->root_window;
-  else if (WINDOWP (frame_or_window))
-    window = XFRAME (WINDOW_FRAME (XWINDOW (frame_or_window)))->root_window;
+  else if (WINDOW_VALID_P (frame_or_window))
+      window = XFRAME (XWINDOW (frame_or_window)->frame)->root_window;
   else
     {
       CHECK_LIVE_FRAME (frame_or_window);
@@ -217,18 +353,18 @@ If FRAME is omitted or nil, it defaults to the selected frame.  */)
 DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p,
        Swindow_minibuffer_p, 0, 1, 0,
        doc: /* Return non-nil if WINDOW is a minibuffer window.
-If WINDOW is omitted or nil, it defaults to the selected window.  */)
+WINDOW must be a valid window and defaults to the selected one.  */)
   (Lisp_Object window)
 {
-  return MINI_WINDOW_P (decode_any_window (window)) ? Qt : Qnil;
+  return MINI_WINDOW_P (decode_valid_window (window)) ? Qt : Qnil;
 }
 
 /* Don't move this to window.el - this must be a safe routine.  */
 DEFUN ("frame-first-window", Fframe_first_window, Sframe_first_window, 0, 1, 0,
        doc: /* Return the topmost, leftmost live window on FRAME-OR-WINDOW.
 If omitted, FRAME-OR-WINDOW defaults to the currently selected frame.
-Else if FRAME-OR-WINDOW denotes any window, return the first window of
-that window's frame.  If FRAME-OR-WINDOW denotes a live frame, return
+Else if FRAME-OR-WINDOW denotes a valid window, return the first window
+of that window's frame.  If FRAME-OR-WINDOW denotes a live frame, return
 the first window of that frame.  */)
   (Lisp_Object frame_or_window)
 {
@@ -236,7 +372,7 @@ the first window of that frame.  */)
 
   if (NILP (frame_or_window))
     window = SELECTED_FRAME ()->root_window;
-  else if (WINDOWP (frame_or_window))
+  else if (WINDOW_VALID_P (frame_or_window))
     window = XFRAME (WINDOW_FRAME (XWINDOW (frame_or_window)))->root_window;
   else
     {
@@ -261,16 +397,16 @@ DEFUN ("frame-selected-window", Fframe_selected_window,
        Sframe_selected_window, 0, 1, 0,
        doc: /* Return the selected window of FRAME-OR-WINDOW.
 If omitted, FRAME-OR-WINDOW defaults to the currently selected frame.
-Else if FRAME-OR-WINDOW denotes any window, return the selected window
-of that window's frame.  If FRAME-OR-WINDOW denotes a live frame, return
-the selected window of that frame.  */)
+Else if FRAME-OR-WINDOW denotes a valid window, return the selected
+window of that window's frame.  If FRAME-OR-WINDOW denotes a live frame,
+return the selected window of that frame.  */)
   (Lisp_Object frame_or_window)
 {
   Lisp_Object window;
 
   if (NILP (frame_or_window))
     window = SELECTED_FRAME ()->selected_window;
-  else if (WINDOWP (frame_or_window))
+  else if (WINDOW_VALID_P (frame_or_window))
     window = XFRAME (WINDOW_FRAME (XWINDOW (frame_or_window)))->selected_window;
   else
     {
@@ -303,7 +439,10 @@ Return WINDOW.  */)
   if (EQ (frame, selected_frame))
     return Fselect_window (window, norecord);
   else
-    return FSET (XFRAME (frame), selected_window, window);
+    {
+      fset_selected_window (XFRAME (frame), window);
+      return window;
+    }
 }
 
 DEFUN ("selected-window", Fselected_window, Sselected_window, 0, 0, 0,
@@ -346,7 +485,7 @@ select_window (Lisp_Object window, Lisp_Object norecord, int inhibit_point_swap)
   sf = SELECTED_FRAME ();
   if (XFRAME (WINDOW_FRAME (w)) != sf)
     {
-      FSET (XFRAME (WINDOW_FRAME (w)), selected_window, window);
+      fset_selected_window (XFRAME (WINDOW_FRAME (w)), window);
       /* Use this rather than Fhandle_switch_frame
          so that FRAME_FOCUS_FRAME is moved appropriately as we
          move around in the state where a minibuffer in a separate
@@ -357,7 +496,7 @@ select_window (Lisp_Object window, Lisp_Object norecord, int inhibit_point_swap)
       return window;
     }
   else
-    FSET (sf, selected_window, window);
+    fset_selected_window (sf, window);
 
   /* Store the current buffer's actual point into the
      old selected window.  It belongs to that window,
@@ -375,7 +514,7 @@ select_window (Lisp_Object window, Lisp_Object norecord, int inhibit_point_swap)
 
   Fset_buffer (w->buffer);
 
-  BSET (XBUFFER (w->buffer), last_selected_window, window);
+  bset_last_selected_window (XBUFFER (w->buffer), window);
 
   /* Go to the point recorded in the window.
      This is important when the buffer is in more
@@ -423,88 +562,93 @@ Return nil for an internal window or a deleted window.  */)
 
 DEFUN ("window-parent", Fwindow_parent, Swindow_parent, 0, 1, 0,
        doc: /* Return the parent window of window WINDOW.
-If WINDOW is omitted or nil, it defaults to the selected window.
+WINDOW must be a valid window and defaults to the selected one.
 Return nil for a window with no parent (e.g. a root window).  */)
   (Lisp_Object window)
 {
-  return decode_any_window (window)->parent;
+  return decode_valid_window (window)->parent;
 }
 
 DEFUN ("window-top-child", Fwindow_top_child, Swindow_top_child, 1, 1, 0,
        doc: /* Return the topmost child window of window WINDOW.
+WINDOW must be a valid window and defaults to the selected one.
 Return nil if WINDOW is a live window (live windows have no children).
 Return nil if WINDOW is an internal window whose children form a
 horizontal combination.  */)
   (Lisp_Object window)
 {
   CHECK_WINDOW (window);
-  return decode_any_window (window)->vchild;
+  return decode_valid_window (window)->vchild;
 }
 
 DEFUN ("window-left-child", Fwindow_left_child, Swindow_left_child, 1, 1, 0,
        doc: /* Return the leftmost child window of window WINDOW.
+WINDOW must be a valid window and defaults to the selected one.
 Return nil if WINDOW is a live window (live windows have no children).
 Return nil if WINDOW is an internal window whose children form a
 vertical combination.  */)
   (Lisp_Object window)
 {
   CHECK_WINDOW (window);
-  return decode_any_window (window)->hchild;
+  return decode_valid_window (window)->hchild;
 }
 
 DEFUN ("window-next-sibling", Fwindow_next_sibling, Swindow_next_sibling, 0, 1, 0,
        doc: /* Return the next sibling window of window WINDOW.
-If WINDOW is omitted or nil, it defaults to the selected window.
+WINDOW must be a valid window and defaults to the selected one.
 Return nil if WINDOW has no next sibling.  */)
   (Lisp_Object window)
 {
-  return decode_any_window (window)->next;
+  return decode_valid_window (window)->next;
 }
 
 DEFUN ("window-prev-sibling", Fwindow_prev_sibling, Swindow_prev_sibling, 0, 1, 0,
        doc: /* Return the previous sibling window of window WINDOW.
-If WINDOW is omitted or nil, it defaults to the selected window.
+WINDOW must be a valid window and defaults to the selected one.
 Return nil if WINDOW has no previous sibling.  */)
   (Lisp_Object window)
 {
-  return decode_any_window (window)->prev;
+  return decode_valid_window (window)->prev;
 }
 
 DEFUN ("window-combination-limit", Fwindow_combination_limit, Swindow_combination_limit, 1, 1, 0,
        doc: /* Return combination limit of window WINDOW.
+WINDOW must be a valid window and defaults to the selected one.
 If the return value is nil, child windows of WINDOW can be recombined with
 WINDOW's siblings.  A return value of t means that child windows of
 WINDOW are never \(re-)combined with WINDOW's siblings.  */)
   (Lisp_Object window)
 {
-  return decode_any_window (window)->combination_limit;
+  return decode_valid_window (window)->combination_limit;
 }
 
 DEFUN ("set-window-combination-limit", Fset_window_combination_limit, Sset_window_combination_limit, 2, 2, 0,
        doc: /* Set combination limit of window WINDOW to LIMIT; return LIMIT.
+WINDOW must be a valid window and defaults to the selected one.
 If LIMIT is nil, child windows of WINDOW can be recombined with
 WINDOW's siblings.  LIMIT t means that child windows of WINDOW are
 never \(re-)combined with WINDOW's siblings.  Other values are reserved
 for future use.  */)
   (Lisp_Object window, Lisp_Object limit)
 {
-  return WSET (decode_any_window (window), combination_limit, limit);
+  wset_combination_limit (decode_valid_window (window), limit);
+  return limit;
 }
 
 DEFUN ("window-use-time", Fwindow_use_time, Swindow_use_time, 0, 1, 0,
        doc: /* Return the use time of window WINDOW.
-If WINDOW is omitted or nil, it defaults to the selected window.
+WINDOW must be a live window and defaults to the selected one.
 The window with the highest use time is the most recently selected
 one.  The window with the lowest use time is the least recently
 selected one.  */)
   (Lisp_Object window)
 {
-  return make_number (decode_window (window)->use_time);
+  return make_number (decode_live_window (window)->use_time);
 }
 
 DEFUN ("window-total-height", Fwindow_total_height, Swindow_total_height, 0, 1, 0,
        doc: /* Return the total height, in lines, of window WINDOW.
-If WINDOW is omitted or nil, it defaults to the selected window.
+WINDOW must be a valid window and defaults to the selected one.
 
 The return value includes the mode line and header line, if any.
 If WINDOW is an internal window, the total height is the height
@@ -514,12 +658,12 @@ On a graphical display, this total height is reported as an
 integer multiple of the default character height.  */)
   (Lisp_Object window)
 {
-  return decode_any_window (window)->total_lines;
+  return decode_valid_window (window)->total_lines;
 }
 
 DEFUN ("window-total-width", Fwindow_total_width, Swindow_total_width, 0, 1, 0,
        doc: /* Return the total width, in columns, of window WINDOW.
-If WINDOW is omitted or nil, it defaults to the selected window.
+WINDOW must be a valid window and defaults to the selected one.
 
 The return value includes any vertical dividers or scroll bars
 belonging to WINDOW.  If WINDOW is an internal window, the total width
@@ -529,34 +673,34 @@ On a graphical display, this total width is reported as an
 integer multiple of the default character width.  */)
   (Lisp_Object window)
 {
-  return decode_any_window (window)->total_cols;
+  return decode_valid_window (window)->total_cols;
 }
 
 DEFUN ("window-new-total", Fwindow_new_total, Swindow_new_total, 0, 1, 0,
        doc: /* Return the new total size of window WINDOW.
-If WINDOW is omitted or nil, it defaults to the selected window.   */)
+WINDOW must be a valid window and defaults to the selected one.  */)
   (Lisp_Object window)
 {
-  return decode_any_window (window)->new_total;
+  return decode_valid_window (window)->new_total;
 }
 
 DEFUN ("window-normal-size", Fwindow_normal_size, Swindow_normal_size, 0, 2, 0,
        doc: /* Return the normal height of window WINDOW.
-If WINDOW is omitted or nil, it defaults to the selected window.
+WINDOW must be a valid window and defaults to the selected one.
 If HORIZONTAL is non-nil, return the normal width of WINDOW.  */)
   (Lisp_Object window, Lisp_Object horizontal)
 {
-  struct window *w = decode_any_window (window);
+  struct window *w = decode_valid_window (window);
 
   return NILP (horizontal) ? w->normal_lines : w->normal_cols;
 }
 
 DEFUN ("window-new-normal", Fwindow_new_normal, Swindow_new_normal, 0, 1, 0,
        doc: /* Return new normal size of window WINDOW.
-If WINDOW is omitted or nil, it defaults to the selected window.  */)
+WINDOW must be a valid window and defaults to the selected one.  */)
   (Lisp_Object window)
 {
-  return decode_any_window (window)->new_normal;
+  return decode_valid_window (window)->new_normal;
 }
 
 DEFUN ("window-left-column", Fwindow_left_column, Swindow_left_column, 0, 1, 0,
@@ -565,10 +709,10 @@ This is the distance, in columns, between the left edge of WINDOW and
 the left edge of the frame's window area.  For instance, the return
 value is 0 if there is no window to the left of WINDOW.
 
-If WINDOW is omitted or nil, it defaults to the selected window.  */)
+WINDOW must be a valid window and defaults to the selected one.  */)
   (Lisp_Object window)
 {
-  return decode_any_window (window)->left_col;
+  return decode_valid_window (window)->left_col;
 }
 
 DEFUN ("window-top-line", Fwindow_top_line, Swindow_top_line, 0, 1, 0,
@@ -577,10 +721,10 @@ This is the distance, in lines, between the top of WINDOW and the top
 of the frame's window area.  For instance, the return value is 0 if
 there is no window above WINDOW.
 
-If WINDOW is omitted or nil, it defaults to the selected window.  */)
+WINDOW must be a valid window and defaults to the selected one.  */)
   (Lisp_Object window)
 {
-  return decode_any_window (window)->top_line;
+  return decode_valid_window (window)->top_line;
 }
 
 /* Return the number of lines of W's body.  Don't count any mode or
@@ -634,8 +778,7 @@ window_body_cols (struct window *w)
 
 DEFUN ("window-body-height", Fwindow_body_height, Swindow_body_height, 0, 1, 0,
        doc: /* Return the height, in lines, of WINDOW's text area.
-If WINDOW is omitted or nil, it defaults to the selected window.
-Signal an error if the window is not live.
+WINDOW must be a live window and defaults to the selected one.
 
 The returned height does not include the mode line or header line.
 On a graphical display, the height is expressed as an integer multiple
@@ -644,21 +787,20 @@ area is only partially visible, that counts as a whole line; to
 exclude partially-visible lines, use `window-text-height'.  */)
   (Lisp_Object window)
 {
-  struct window *w = decode_window (window);
+  struct window *w = decode_live_window (window);
   return make_number (window_body_lines (w));
 }
 
 DEFUN ("window-body-width", Fwindow_body_width, Swindow_body_width, 0, 1, 0,
        doc: /* Return the width, in columns, of WINDOW's text area.
-If WINDOW is omitted or nil, it defaults to the selected window.
-Signal an error if the window is not live.
+WINDOW must be a live window and defaults to the selected one.
 
 The return value does not include any vertical dividers, fringe or
 marginal areas, or scroll bars.  On a graphical display, the width is
 expressed as an integer multiple of the default character width.  */)
   (Lisp_Object window)
 {
-  struct window *w = decode_window (window);
+  struct window *w = decode_live_window (window);
   return make_number (window_body_cols (w));
 }
 
@@ -667,7 +809,7 @@ DEFUN ("window-hscroll", Fwindow_hscroll, Swindow_hscroll, 0, 1, 0,
 WINDOW must be a live window and defaults to the selected one.  */)
   (Lisp_Object window)
 {
-  return make_number (decode_window (window)->hscroll);
+  return make_number (decode_live_window (window)->hscroll);
 }
 
 /* Set W's horizontal scroll amount to HSCROLL clipped to a reasonable
@@ -694,7 +836,7 @@ set_window_hscroll (struct window *w, EMACS_INT hscroll)
 
 DEFUN ("set-window-hscroll", Fset_window_hscroll, Sset_window_hscroll, 2, 2, 0,
        doc: /* Set number of columns WINDOW is scrolled from left margin to NCOL.
-If WINDOW is nil, the selected window is used.
+WINDOW must be a live window and defaults to the selected one.
 Clip the number to a reasonable value if out of range.
 Return the new number.  NCOL should be zero or positive.
 
@@ -702,7 +844,7 @@ Note that if `automatic-hscrolling' is non-nil, you cannot scroll the
 window so that the location of point moves off-window.  */)
   (Lisp_Object window, Lisp_Object ncol)
 {
-  struct window *w = decode_window (window);
+  struct window *w = decode_live_window (window);
 
   CHECK_NUMBER (ncol);
   return set_window_hscroll (w, XINT (ncol));
@@ -711,41 +853,44 @@ window so that the location of point moves off-window.  */)
 DEFUN ("window-redisplay-end-trigger", Fwindow_redisplay_end_trigger,
        Swindow_redisplay_end_trigger, 0, 1, 0,
        doc: /* Return WINDOW's redisplay end trigger value.
-WINDOW defaults to the selected window.
+WINDOW must be a live window and defaults to the selected one.
 See `set-window-redisplay-end-trigger' for more information.  */)
   (Lisp_Object window)
 {
-  return decode_window (window)->redisplay_end_trigger;
+  return decode_live_window (window)->redisplay_end_trigger;
 }
 
 DEFUN ("set-window-redisplay-end-trigger", Fset_window_redisplay_end_trigger,
        Sset_window_redisplay_end_trigger, 2, 2, 0,
        doc: /* Set WINDOW's redisplay end trigger value to VALUE.
-VALUE should be a buffer position (typically a marker) or nil.
-If it is a buffer position, then if redisplay in WINDOW reaches a position
-beyond VALUE, the functions in `redisplay-end-trigger-functions' are called
-with two arguments: WINDOW, and the end trigger value.
-Afterwards the end-trigger value is reset to nil.  */)
+WINDOW must be a live window and defaults to the selected one.  VALUE
+should be a buffer position (typically a marker) or nil.  If it is a
+buffer position, then if redisplay in WINDOW reaches a position beyond
+VALUE, the functions in `redisplay-end-trigger-functions' are called
+with two arguments: WINDOW, and the end trigger value.  Afterwards the
+end-trigger value is reset to nil.  */)
   (register Lisp_Object window, Lisp_Object value)
 {
-  return WSET (decode_window (window), redisplay_end_trigger, value);
+  wset_redisplay_end_trigger (decode_live_window (window), value);
+  return value;
 }
 
 DEFUN ("window-edges", Fwindow_edges, Swindow_edges, 0, 1, 0,
        doc: /* Return a list of the edge coordinates of WINDOW.
-The list has the form (LEFT TOP RIGHT BOTTOM).
-TOP and BOTTOM count by lines, and LEFT and RIGHT count by columns,
-all relative to 0, 0 at top left corner of frame.
-
-RIGHT is one more than the rightmost column occupied by WINDOW.
-BOTTOM is one more than the bottommost row occupied by WINDOW.
-The edges include the space used by WINDOW's scroll bar, display
-margins, fringes, header line, and/or mode line.  For the edges of
-just the text area, use `window-inside-edges'.  */)
+WINDOW must be a valid window and defaults to the selected one.
+
+The returned list has the form (LEFT TOP RIGHT BOTTOM).  TOP and BOTTOM
+count by lines, and LEFT and RIGHT count by columns, all relative to 0,
+0 at top left corner of frame.
+
+RIGHT is one more than the rightmost column occupied by WINDOW.  BOTTOM
+is one more than the bottommost row occupied by WINDOW.  The edges
+include the space used by WINDOW's scroll bar, display margins, fringes,
+header line, and/or mode line.  For the edges of just the text area, use
+`window-inside-edges'.  */)
   (Lisp_Object window)
 {
-  register struct window *w = decode_any_window (window);
-  CHECK_LIVE_FRAME (w->frame);
+  register struct window *w = decode_valid_window (window);
 
   return Fcons (make_number (WINDOW_LEFT_EDGE_COL (w)),
          Fcons (make_number (WINDOW_TOP_EDGE_LINE (w)),
@@ -756,8 +901,10 @@ just the text area, use `window-inside-edges'.  */)
 
 DEFUN ("window-pixel-edges", Fwindow_pixel_edges, Swindow_pixel_edges, 0, 1, 0,
        doc: /* Return a list of the edge pixel coordinates of WINDOW.
-The list has the form (LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at
-the top left corner of the frame.
+WINDOW must be a valid window and defaults to the selected one.
+
+The returned list has the form (LEFT TOP RIGHT BOTTOM), all relative to
+0, 0 at the top left corner of the frame.
 
 RIGHT is one more than the rightmost x position occupied by WINDOW.
 BOTTOM is one more than the bottommost y position occupied by WINDOW.
@@ -766,8 +913,7 @@ margins, fringes, header line, and/or mode line.  For the pixel edges
 of just the text area, use `window-inside-pixel-edges'.  */)
   (Lisp_Object window)
 {
-  register struct window *w = decode_any_window (window);
-  CHECK_LIVE_FRAME (w->frame);
+  register struct window *w = decode_valid_window (window);
 
   return Fcons (make_number (WINDOW_LEFT_EDGE_X (w)),
          Fcons (make_number (WINDOW_TOP_EDGE_Y (w)),
@@ -801,8 +947,10 @@ calc_absolute_offset (struct window *w, int *add_x, int *add_y)
 DEFUN ("window-absolute-pixel-edges", Fwindow_absolute_pixel_edges,
        Swindow_absolute_pixel_edges, 0, 1, 0,
        doc: /* Return a list of the edge pixel coordinates of WINDOW.
-The list has the form (LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at
-the top left corner of the display.
+WINDOW must be a valid window and defaults to the selected one.
+
+The returned list has the form (LEFT TOP RIGHT BOTTOM), all relative to
+0, 0 at the top left corner of the display.
 
 RIGHT is one more than the rightmost x position occupied by WINDOW.
 BOTTOM is one more than the bottommost y position occupied by WINDOW.
@@ -811,10 +959,8 @@ margins, fringes, header line, and/or mode line.  For the pixel edges
 of just the text area, use `window-inside-absolute-pixel-edges'.  */)
   (Lisp_Object window)
 {
-  register struct window *w = decode_any_window (window);
+  register struct window *w = decode_valid_window (window);
   int add_x, add_y;
-
-  CHECK_LIVE_FRAME (w->frame);
   calc_absolute_offset (w, &add_x, &add_y);
 
   return Fcons (make_number (WINDOW_LEFT_EDGE_X (w) + add_x),
@@ -826,17 +972,19 @@ of just the text area, use `window-inside-absolute-pixel-edges'.  */)
 
 DEFUN ("window-inside-edges", Fwindow_inside_edges, Swindow_inside_edges, 0, 1, 0,
        doc: /* Return a list of the edge coordinates of WINDOW.
-The list has the form (LEFT TOP RIGHT BOTTOM).
-TOP and BOTTOM count by lines, and LEFT and RIGHT count by columns,
-all relative to 0, 0 at top left corner of frame.
+WINDOW must be a live window and defaults to the selected one.
+
+The returned list has the form (LEFT TOP RIGHT BOTTOM).  TOP and BOTTOM
+count by lines, and LEFT and RIGHT count by columns, all relative to 0,
+0 at top left corner of frame.
 
 RIGHT is one more than the rightmost column of WINDOW's text area.
-BOTTOM is one more than the bottommost row of WINDOW's text area.
-The inside edges do not include the space used by the WINDOW's scroll
-bar, display margins, fringes, header line, and/or mode line.  */)
+BOTTOM is one more than the bottommost row of WINDOW's text area.  The
+inside edges do not include the space used by the WINDOW's scroll bar,
+display margins, fringes, header line, and/or mode line.  */)
   (Lisp_Object window)
 {
-  register struct window *w = decode_window (window);
+  register struct window *w = decode_live_window (window);
 
   return list4 (make_number (WINDOW_BOX_LEFT_EDGE_COL (w)
                              + WINDOW_LEFT_MARGIN_COLS (w)
@@ -852,8 +1000,10 @@ bar, display margins, fringes, header line, and/or mode line.  */)
 
 DEFUN ("window-inside-pixel-edges", Fwindow_inside_pixel_edges, Swindow_inside_pixel_edges, 0, 1, 0,
        doc: /* Return a list of the edge pixel coordinates of WINDOW's text area.
-The list has the form (LEFT TOP RIGHT BOTTOM), all relative to (0,0)
-at the top left corner of the frame's window area.
+WINDOW must be a live window and defaults to the selected one.
+
+The returned list has the form (LEFT TOP RIGHT BOTTOM), all relative to
+(0,0) at the top left corner of the frame's window area.
 
 RIGHT is one more than the rightmost x position of WINDOW's text area.
 BOTTOM is one more than the bottommost y position of WINDOW's text area.
@@ -861,7 +1011,7 @@ The inside edges do not include the space used by WINDOW's scroll bar,
 display margins, fringes, header line, and/or mode line.  */)
   (Lisp_Object window)
 {
-  register struct window *w = decode_window (window);
+  register struct window *w = decode_live_window (window);
 
   return list4 (make_number (WINDOW_BOX_LEFT_EDGE_X (w)
                              + WINDOW_LEFT_MARGIN_WIDTH (w)
@@ -879,8 +1029,10 @@ DEFUN ("window-inside-absolute-pixel-edges",
        Fwindow_inside_absolute_pixel_edges,
        Swindow_inside_absolute_pixel_edges, 0, 1, 0,
        doc: /* Return a list of the edge pixel coordinates of WINDOW's text area.
-The list has the form (LEFT TOP RIGHT BOTTOM), all relative to (0,0)
-at the top left corner of the frame's window area.
+WINDOW must be a live window and defaults to the selected one.
+
+The returned list has the form (LEFT TOP RIGHT BOTTOM), all relative to
+(0,0) at the top left corner of the frame's window area.
 
 RIGHT is one more than the rightmost x position of WINDOW's text area.
 BOTTOM is one more than the bottommost y position of WINDOW's text area.
@@ -888,7 +1040,7 @@ The inside edges do not include the space used by WINDOW's scroll bar,
 display margins, fringes, header line, and/or mode line.  */)
   (Lisp_Object window)
 {
-  register struct window *w = decode_window (window);
+  register struct window *w = decode_live_window (window);
   int add_x, add_y;
   calc_absolute_offset (w, &add_x, &add_y);
 
@@ -1067,7 +1219,7 @@ window_relative_x_coord (struct window *w, enum window_part part, int x)
 DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p,
        Scoordinates_in_window_p, 2, 2, 0,
        doc: /* Return non-nil if COORDINATES are in WINDOW.
-WINDOW must be a live window.
+WINDOW must be a live window and defaults to the selected one.
 COORDINATES is a cons of the form (X . Y), X and Y being distances
 measured in characters from the upper-left corner of the frame.
 \(0 . 0) denotes the character in the upper left corner of the
@@ -1089,8 +1241,7 @@ If they are in the windows's left or right marginal areas, `left-margin'\n\
   int x, y;
   Lisp_Object lx, ly;
 
-  CHECK_LIVE_WINDOW (window);
-  w = XWINDOW (window);
+  w = decode_live_window (window);
   f = XFRAME (w->frame);
   CHECK_CONS (coordinates);
   lx = Fcar (coordinates);
@@ -1268,7 +1419,7 @@ of point, outside of any save-excursion forms.
 But that is hard to define.  */)
   (Lisp_Object window)
 {
-  register struct window *w = decode_window (window);
+  register struct window *w = decode_live_window (window);
 
   if (w == XWINDOW (selected_window)
       && current_buffer == XBUFFER (w->buffer))
@@ -1282,7 +1433,7 @@ WINDOW must be a live window and defaults to the selected one.
 This is updated by redisplay or by calling `set-window-start'.  */)
   (Lisp_Object window)
 {
-  return Fmarker_position (decode_window (window)->start);
+  return Fmarker_position (decode_live_window (window)->start);
 }
 
 /* This is text temporarily removed from the doc string below.
@@ -1309,7 +1460,7 @@ if it isn't already recorded.  */)
   (Lisp_Object window, Lisp_Object update)
 {
   Lisp_Object value;
-  struct window *w = decode_window (window);
+  struct window *w = decode_live_window (window);
   Lisp_Object buf;
   struct buffer *b;
 
@@ -1376,10 +1527,11 @@ if it isn't already recorded.  */)
 
 DEFUN ("set-window-point", Fset_window_point, Sset_window_point, 2, 2, 0,
        doc: /* Make point value in WINDOW be at position POS in WINDOW's buffer.
+WINDOW must be a live window and defaults to the selected one.
 Return POS.  */)
   (Lisp_Object window, Lisp_Object pos)
 {
-  register struct window *w = decode_window (window);
+  register struct window *w = decode_live_window (window);
 
   CHECK_NUMBER_COERCE_MARKER (pos);
   if (w == XWINDOW (selected_window)
@@ -1398,12 +1550,12 @@ Return POS.  */)
 
 DEFUN ("set-window-start", Fset_window_start, Sset_window_start, 2, 3, 0,
        doc: /* Make display in WINDOW start at position POS in WINDOW's buffer.
-If WINDOW is nil, the selected window is used.  Return POS.
-Optional third arg NOFORCE non-nil inhibits next redisplay from
+WINDOW must be a live window and defaults to the selected one.  Return
+POS.  Optional third arg NOFORCE non-nil inhibits next redisplay from
 overriding motion of point in order to display at this exact start.  */)
   (Lisp_Object window, Lisp_Object pos, Lisp_Object noforce)
 {
-  register struct window *w = decode_window (window);
+  register struct window *w = decode_live_window (window);
 
   CHECK_NUMBER_COERCE_MARKER (pos);
   set_marker_restricted (w->start, pos, w->buffer);
@@ -1423,12 +1575,14 @@ overriding motion of point in order to display at this exact start.  */)
 DEFUN ("pos-visible-in-window-p", Fpos_visible_in_window_p,
        Spos_visible_in_window_p, 0, 3, 0,
        doc: /* Return non-nil if position POS is currently on the frame in WINDOW.
-Return nil if that position is scrolled vertically out of view.
-If a character is only partially visible, nil is returned, unless the
-optional argument PARTIALLY is non-nil.
-If POS is only out of view because of horizontal scrolling, return non-nil.
-If POS is t, it specifies the position of the last visible glyph in WINDOW.
-POS defaults to point in WINDOW; WINDOW defaults to the selected window.
+WINDOW must be a live window and defaults to the selected one.
+
+Return nil if that position is scrolled vertically out of view.  If a
+character is only partially visible, nil is returned, unless the
+optional argument PARTIALLY is non-nil.  If POS is only out of view
+because of horizontal scrolling, return non-nil.  If POS is t, it
+specifies the position of the last visible glyph in WINDOW.  POS
+defaults to point in WINDOW; WINDOW defaults to the selected window.
 
 If POS is visible, return t if PARTIALLY is nil; if PARTIALLY is non-nil,
 return value is a list of 2 or 6 elements (X Y [RTOP RBOT ROWH VPOS]),
@@ -1447,7 +1601,7 @@ display row, and VPOS is the row number (0-based) containing POS.  */)
   int rtop, rbot, rowh, vpos, fully_p = 1;
   int x, y;
 
-  w = decode_window (window);
+  w = decode_live_window (window);
   buf = XBUFFER (w->buffer);
   SET_TEXT_POS_FROM_MARKER (top, w->start);
 
@@ -1489,7 +1643,7 @@ display row, and VPOS is the row number (0-based) containing POS.  */)
 DEFUN ("window-line-height", Fwindow_line_height,
        Swindow_line_height, 0, 2, 0,
        doc: /* Return height in pixels of text line LINE in window WINDOW.
-WINDOW defaults to the selected window.
+WINDOW must be a live window and defaults to the selected one.
 
 Return height of current line if LINE is omitted or nil.  Return height of
 header or mode line if LINE is `header-line' or `mode-line'.
@@ -1513,7 +1667,7 @@ Return nil if window display is not up-to-date.  In that case, use
   int max_y, crop, i;
   EMACS_INT n;
 
-  w = decode_window (window);
+  w = decode_live_window (window);
 
   if (noninteractive || w->pseudo_window_p)
     return Qnil;
@@ -1601,8 +1755,8 @@ DEFUN ("window-dedicated-p", Fwindow_dedicated_p, Swindow_dedicated_p,
 More precisely, return the value assigned by the last call of
 `set-window-dedicated-p' for WINDOW.  Return nil if that function was
 never called with WINDOW as its argument, or the value set by that
-function was internally reset since its last call.  WINDOW defaults to
-the selected window.
+function was internally reset since its last call.  WINDOW must be a
+live window and defaults to the selected one.
 
 When a window is dedicated to its buffer, `display-buffer' will refrain
 from displaying another buffer in it.  `get-lru-window' and
@@ -1615,7 +1769,7 @@ window, unless that window is "strongly" dedicated to its buffer, that
 is the value returned by `window-dedicated-p' is t.  */)
   (Lisp_Object window)
 {
-  return decode_window (window)->dedicated;
+  return decode_live_window (window)->dedicated;
 }
 
 DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p,
@@ -1639,7 +1793,8 @@ buffer.  If and when `set-window-buffer' displays another buffer in a
 window, it also makes sure that the window is no more dedicated.  */)
   (Lisp_Object window, Lisp_Object flag)
 {
-  return WSET (decode_window (window), dedicated, flag);
+  wset_dedicated (decode_live_window (window), flag);
+  return flag;
 }
 
 DEFUN ("window-prev-buffers", Fwindow_prev_buffers, Swindow_prev_buffers,
@@ -1652,7 +1807,7 @@ where BUFFER is a buffer, WINDOW-START is the start position of the
 window for that buffer, and POS is a window-specific point value.  */)
   (Lisp_Object window)
 {
-  return decode_window (window)->prev_buffers;
+  return decode_live_window (window)->prev_buffers;
 }
 
 DEFUN ("set-window-prev-buffers", Fset_window_prev_buffers,
@@ -1665,7 +1820,8 @@ where BUFFER is a buffer, WINDOW-START is the start position of the
 window for that buffer, and POS is a window-specific point value.  */)
      (Lisp_Object window, Lisp_Object prev_buffers)
 {
-  return WSET (decode_window (window), prev_buffers, prev_buffers);
+  wset_prev_buffers (decode_live_window (window), prev_buffers);
+  return prev_buffers;
 }
 
 DEFUN ("window-next-buffers", Fwindow_next_buffers, Swindow_next_buffers,
@@ -1674,7 +1830,7 @@ DEFUN ("window-next-buffers", Fwindow_next_buffers, Swindow_next_buffers,
 WINDOW must be a live window and defaults to the selected one.  */)
      (Lisp_Object window)
 {
-  return decode_window (window)->next_buffers;
+  return decode_live_window (window)->next_buffers;
 }
 
 DEFUN ("set-window-next-buffers", Fset_window_next_buffers,
@@ -1684,44 +1840,46 @@ WINDOW must be a live window and defaults to the selected one.
 NEXT-BUFFERS should be a list of buffers.  */)
      (Lisp_Object window, Lisp_Object next_buffers)
 {
-  return WSET (decode_window (window), next_buffers, next_buffers);
+  wset_next_buffers (decode_live_window (window), next_buffers);
+  return next_buffers;
 }
 
 DEFUN ("window-parameters", Fwindow_parameters, Swindow_parameters,
        0, 1, 0,
        doc: /* Return the parameters of WINDOW and their values.
-WINDOW defaults to the selected window.  The return value is a list of
-elements of the form (PARAMETER . VALUE).  */)
+WINDOW must be a valid window and defaults to the selected one.  The
+return value is a list of elements of the form (PARAMETER . VALUE).  */)
   (Lisp_Object window)
 {
-  return Fcopy_alist (decode_any_window (window)->window_parameters);
+  return Fcopy_alist (decode_valid_window (window)->window_parameters);
 }
 
 DEFUN ("window-parameter", Fwindow_parameter, Swindow_parameter,
        2, 2, 0,
        doc:  /* Return WINDOW's value for PARAMETER.
-WINDOW defaults to the selected window.  */)
+WINDOW must be a valid window and defaults to the selected one.  */)
   (Lisp_Object window, Lisp_Object parameter)
 {
   Lisp_Object result;
 
-  result = Fassq (parameter, decode_any_window (window)->window_parameters);
+  result = Fassq (parameter, decode_valid_window (window)->window_parameters);
   return CDR_SAFE (result);
 }
 
 DEFUN ("set-window-parameter", Fset_window_parameter,
        Sset_window_parameter, 3, 3, 0,
        doc: /* Set WINDOW's value of PARAMETER to VALUE.
-WINDOW defaults to the selected window.  Return VALUE.  */)
+WINDOW must be a valid window and defaults to the selected one.
+Return VALUE.  */)
   (Lisp_Object window, Lisp_Object parameter, Lisp_Object value)
 {
-  register struct window *w = decode_any_window (window);
+  register struct window *w = decode_valid_window (window);
   Lisp_Object old_alist_elt;
 
   old_alist_elt = Fassq (parameter, w->window_parameters);
   if (NILP (old_alist_elt))
-    WSET (w, window_parameters,
-          Fcons (Fcons (parameter, value), w->window_parameters));
+    wset_window_parameters
+      (w, Fcons (Fcons (parameter, value), w->window_parameters));
   else
     Fsetcdr (old_alist_elt, value);
   return value;
@@ -1730,10 +1888,10 @@ WINDOW defaults to the selected window.  Return VALUE.  */)
 DEFUN ("window-display-table", Fwindow_display_table, Swindow_display_table,
        0, 1, 0,
        doc: /* Return the display-table that WINDOW is using.
-WINDOW defaults to the selected window.  */)
+WINDOW must be a live window and defaults to the selected one.  */)
   (Lisp_Object window)
 {
-  return decode_window (window)->display_table;
+  return decode_live_window (window)->display_table;
 }
 
 /* Get the display table for use on window W.  This is either W's
@@ -1762,10 +1920,12 @@ window_display_table (struct window *w)
 }
 
 DEFUN ("set-window-display-table", Fset_window_display_table, Sset_window_display_table, 2, 2, 0,
-       doc: /* Set WINDOW's display-table to TABLE.  */)
+       doc: /* Set WINDOW's display-table to TABLE.
+WINDOW must be a live window and defaults to the selected one.  */)
   (register Lisp_Object window, Lisp_Object table)
 {
-  return WSET (decode_window (window), display_table, table);
+  wset_display_table (decode_live_window (window), table);
+  return table;
 }
 
 /* Record info on buffer window W is displaying
@@ -1814,7 +1974,7 @@ unshow_buffer (register struct window *w)
 
   if (WINDOWP (BVAR (b, last_selected_window))
       && w == XWINDOW (BVAR (b, last_selected_window)))
-    BSET (b, last_selected_window, Qnil);
+    bset_last_selected_window (b, Qnil);
 }
 
 /* Put NEW into the window structure in place of OLD.  SETFLAG zero
@@ -1829,18 +1989,18 @@ replace_window (Lisp_Object old, Lisp_Object new, int setflag)
   /* If OLD is its frame's root window, then NEW is the new
      root window for that frame.  */
   if (EQ (old, FRAME_ROOT_WINDOW (XFRAME (o->frame))))
-    FSET (XFRAME (o->frame), root_window, new);
+    fset_root_window (XFRAME (o->frame), new);
 
    if (setflag)
      {
-      WSET (n, left_col, o->left_col);
-      WSET (n, top_line, o->top_line);
-      WSET (n, total_cols, o->total_cols);
-      WSET (n, total_lines, o->total_lines);
-      WSET (n, normal_cols, o->normal_cols);
-      WSET (o, normal_cols, make_float (1.0));
-      WSET (n, normal_lines, o->normal_lines);
-      WSET (o, normal_lines, make_float (1.0));
+      wset_left_col (n, o->left_col);
+      wset_top_line (n, o->top_line);
+      wset_total_cols (n, o->total_cols);
+      wset_total_lines (n, o->total_lines);
+      wset_normal_cols (n, o->normal_cols);
+      wset_normal_cols (o, make_float (1.0));
+      wset_normal_lines (n, o->normal_lines);
+      wset_normal_lines (o, make_float (1.0));
       n->desired_matrix = n->current_matrix = 0;
       n->vscroll = 0;
       memset (&n->cursor, 0, sizeof (n->cursor));
@@ -1850,30 +2010,30 @@ replace_window (Lisp_Object old, Lisp_Object new, int setflag)
       n->phys_cursor_width = -1;
       n->must_be_updated_p = 0;
       n->pseudo_window_p = 0;
-      WSET (n, window_end_vpos, make_number (0));
-      WSET (n, window_end_pos, make_number (0));
-      WSET (n, window_end_valid, Qnil);
+      wset_window_end_vpos (n, make_number (0));
+      wset_window_end_pos (n, make_number (0));
+      wset_window_end_valid (n, Qnil);
       n->frozen_window_start_p = 0;
     }
 
   tem = o->next;
-  WSET (n, next, tem);
+  wset_next (n, tem);
   if (!NILP (tem))
-    WSET (XWINDOW (tem), prev, new);
+    wset_prev (XWINDOW (tem), new);
 
   tem = o->prev;
-  WSET (n, prev, tem);
+  wset_prev (n, tem);
   if (!NILP (tem))
-    WSET (XWINDOW (tem), next, new);
+    wset_next (XWINDOW (tem), new);
 
   tem = o->parent;
-  WSET (n, parent, tem);
+  wset_parent (n, tem);
   if (!NILP (tem))
     {
       if (EQ (XWINDOW (tem)->vchild, old))
-        WSET (XWINDOW (tem), vchild, new);
+        wset_vchild (XWINDOW (tem), new);
       if (EQ (XWINDOW (tem)->hchild, old))
-        WSET (XWINDOW (tem), hchild, new);
+        wset_hchild (XWINDOW (tem), new);
     }
 }
 
@@ -1906,34 +2066,34 @@ recombine_windows (Lisp_Object window)
              assign new normal sizes.  */
           if (NILP (w->prev))
             if (horflag)
-              WSET (p, hchild, child);
+              wset_hchild (p, child);
             else
-              WSET (p, vchild, child);
+              wset_vchild (p, child);
           else
             {
-              WSET (c, prev, w->prev);
-              WSET (XWINDOW (w->prev), next, child);
+              wset_prev (c, w->prev);
+              wset_next (XWINDOW (w->prev), child);
             }
 
           while (c)
             {
-              WSET (c, parent, parent);
+              wset_parent (c, parent);
 
               if (horflag)
-                WSET (c, normal_cols,
-                      make_float (XFLOATINT (c->total_cols)
-                                  / XFLOATINT (p->total_cols)));
+                wset_normal_cols (c,
+                                  make_float (XFLOATINT (c->total_cols)
+                                              / XFLOATINT (p->total_cols)));
               else
-                WSET (c, normal_lines,
-                      make_float (XFLOATINT (c->total_lines)
-                                  / XFLOATINT (p->total_lines)));
+                wset_normal_lines (c,
+                                   make_float (XFLOATINT (c->total_lines)
+                                               / XFLOATINT (p->total_lines)));
 
               if (NILP (c->next))
                 {
                   if (!NILP (w->next))
                     {
-                      WSET (c, next, w->next);
-                      WSET (XWINDOW (c->next), prev, child);
+                      wset_next (c, w->next);
+                      wset_prev (XWINDOW (c->next), child);
                     }
 
                   c = 0;
@@ -1946,8 +2106,8 @@ recombine_windows (Lisp_Object window)
             }
 
           /* WINDOW can be deleted now.  */
-          WSET (w, vchild, Qnil);
-          WSET (w, hchild, Qnil);
+          wset_vchild (w, Qnil);
+          wset_hchild (w, Qnil);
         }
     }
 }
@@ -2112,7 +2272,7 @@ decode_next_window_args (Lisp_Object *window, Lisp_Object *minibuf, Lisp_Object
 
   /* ALL_FRAMES nil doesn't specify which frames to include.  */
   if (NILP (*all_frames))
-    *all_frames 
+    *all_frames
       = (!EQ (*minibuf, Qlambda)
          ? FRAME_MINIBUF_WINDOW (XFRAME (XWINDOW (*window)->frame))
          : Qnil);
@@ -2468,7 +2628,7 @@ window_loop (enum window_loop type, Lisp_Object obj, int mini, Lisp_Object frame
             if (EQ (w->buffer, obj))
               {
                 /* Undedicate WINDOW.  */
-                WSET (w, dedicated, Qnil);
+                wset_dedicated (w, Qnil);
                 /* Make WINDOW show the buffer returned by
                    other_buffer_safely, don't run any hooks.  */
                 set_window_buffer
@@ -2561,8 +2721,8 @@ resize_root_window (Lisp_Object window, Lisp_Object delta, Lisp_Object horizonta
 DEFUN ("delete-other-windows-internal", Fdelete_other_windows_internal,
        Sdelete_other_windows_internal, 0, 2, "",
        doc: /* Make WINDOW fill its frame.
-Only the frame WINDOW is on is affected.  WINDOW may be any window and
-defaults to the selected one.
+Only the frame WINDOW is on is affected.  WINDOW must be a valid window
+and defaults to the selected one.
 
 Optional argument ROOT, if non-nil, must specify an internal window such
 that WINDOW is in its window subtree.  If this is the case, replace ROOT
@@ -2581,8 +2741,7 @@ window-start value is reasonable when this function is called.  */)
   ptrdiff_t startpos IF_LINT (= 0);
   int top IF_LINT (= 0), new_top, resize_failed;
 
-  w = decode_any_window (window);
-  CHECK_LIVE_FRAME (w->frame);
+  w = decode_valid_window (window);
   XSETWINDOW (window, w);
   f = XFRAME (w->frame);
 
@@ -2595,8 +2754,7 @@ window-start value is reasonable when this function is called.  */)
   else
     /* ROOT must be an ancestor of WINDOW.  */
     {
-      r = decode_any_window (root);
-      CHECK_LIVE_FRAME (r->frame);
+      r = decode_valid_window (root);
       pwindow = XWINDOW (window)->parent;
       while (!NILP (pwindow))
         if (EQ (pwindow, root))
@@ -2627,7 +2785,7 @@ window-start value is reasonable when this function is called.  */)
           if (EQ (selected_frame, w->frame))
             Fselect_window (window, Qnil);
           else
-            FSET (f, selected_window, window);
+            fset_selected_window (f, window);
         }
     }
   else
@@ -2657,7 +2815,7 @@ window-start value is reasonable when this function is called.  */)
           if (EQ (selected_frame, w->frame))
             Fselect_window (swindow, Qnil);
           else
-            FSET (f, selected_window, swindow);
+            fset_selected_window (f, swindow);
         }
     }
 
@@ -2692,7 +2850,7 @@ window-start value is reasonable when this function is called.  */)
       /* Resize child windows vertically.  */
       XSETINT (delta, XINT (r->total_lines)
                - XINT (w->total_lines));
-      WSET (w, top_line, r->top_line);
+      wset_top_line (w, r->top_line);
       resize_root_window (window, delta, Qnil, Qnil);
       if (window_resize_check (w, 0))
         window_resize_apply (w, 0);
@@ -2708,10 +2866,10 @@ window-start value is reasonable when this function is called.  */)
       /* Resize child windows horizontally.  */
       if (!resize_failed)
         {
-          WSET (w, left_col, r->left_col);
-          XSETINT (delta, XINT (r->total_cols) 
-                   - XINT (w->total_cols));
-          WSET (w, left_col, r->left_col);
+          wset_left_col (w, r->left_col);
+          XSETINT (delta,
+                   XINT (r->total_cols) - XINT (w->total_cols));
+          wset_left_col (w, r->left_col);
           resize_root_window (window, delta, Qt, Qnil);
           if (window_resize_check (w, 1))
             window_resize_apply (w, 1);
@@ -2739,32 +2897,32 @@ window-start value is reasonable when this function is called.  */)
     {
       sibling = w->prev;
       s = XWINDOW (sibling);
-      WSET (s, next, w->next);
+      wset_next (s, w->next);
       if (!NILP (s->next))
-        WSET (XWINDOW (s->next), prev, sibling);
+        wset_prev (XWINDOW (s->next), sibling);
     }
   else
     /* Get SIBLING below (on the right of) WINDOW.  */
     {
       sibling = w->next;
       s = XWINDOW (sibling);
-      WSET (s, prev, Qnil);
+      wset_prev (s, Qnil);
       if (!NILP (XWINDOW (w->parent)->vchild))
-        WSET (XWINDOW (w->parent), vchild, sibling);
+        wset_vchild (XWINDOW (w->parent), sibling);
       else
-        WSET (XWINDOW (w->parent), hchild, sibling);
+        wset_hchild (XWINDOW (w->parent), sibling);
     }
 
   /* Delete ROOT and all child windows of ROOT.  */
   if (!NILP (r->vchild))
     {
       delete_all_child_windows (r->vchild);
-      WSET (r, vchild, Qnil);
+      wset_vchild (r, Qnil);
     }
   else if (!NILP (r->hchild))
     {
       delete_all_child_windows (r->hchild);
-      WSET (r, hchild, Qnil);
+      wset_hchild (r, Qnil);
     }
 
   replace_window (root, window, 1);
@@ -2791,7 +2949,7 @@ window-start value is reasonable when this function is called.  */)
           pos = *vmotion (startpos, -top, w);
 
           set_marker_both (w->start, w->buffer, pos.bufpos, pos.bytepos);
-          WSET (w, window_end_valid, Qnil);
+          wset_window_end_valid (w, Qnil);
           w->start_at_line_beg = (pos.bytepos == BEGV_BYTE
                                     || FETCH_BYTE (pos.bytepos - 1) == '\n');
           /* We need to do this, so that the window-scroll-functions
@@ -2882,14 +3040,14 @@ adjust_window_margins (struct window *w)
     {
       if (WINDOW_LEFT_MARGIN_COLS (w) > 0)
         {
-          WSET (w, left_margin_cols, make_number (margin_cols / 2));
-          WSET (w, right_margin_cols, make_number (margin_cols / 2));   
+          wset_left_margin_cols (w, make_number (margin_cols / 2));
+          wset_right_margin_cols (w, make_number (margin_cols / 2));
         }
       else
-        WSET (w, right_margin_cols, make_number (margin_cols));
+        wset_right_margin_cols (w, make_number (margin_cols));
     }
   else
-    WSET (w, left_margin_cols, make_number (margin_cols));
+    wset_left_margin_cols (w, make_number (margin_cols));
   return 1;
 }
 
@@ -2989,23 +3147,23 @@ set_window_buffer (Lisp_Object window, Lisp_Object buffer, int run_hooks_p, int
   ptrdiff_t count = SPECPDL_INDEX ();
   int samebuf = EQ (buffer, w->buffer);
 
-  WSET (w, buffer, buffer);
+  wset_buffer (w, buffer);
 
   if (EQ (window, selected_window))
-    BSET (b, last_selected_window, window);
+    bset_last_selected_window (b, window);
 
   /* Let redisplay errors through.  */
   b->display_error_modiff = 0;
 
   /* Update time stamps of buffer display.  */
   if (INTEGERP (BVAR (b, display_count)))
-    BSET (b, display_count, make_number (XINT (BVAR (b, display_count)) + 1));
-  BSET (b, display_time, Fcurrent_time ());
+    bset_display_count (b, make_number (XINT (BVAR (b, display_count)) + 1));
+  bset_display_time (b, Fcurrent_time ());
 
-  WSET (w, window_end_pos, make_number (0));
-  WSET (w, window_end_vpos, make_number (0));
+  wset_window_end_pos (w, make_number (0));
+  wset_window_end_vpos (w, make_number (0));
   memset (&w->last_cursor, 0, sizeof w->last_cursor);
-  WSET (w, window_end_valid, Qnil);
+  wset_window_end_valid (w, Qnil);
   if (!(keep_margins_p && samebuf))
     { /* If we're not actually changing the buffer, don't reset hscroll and
          vscroll.  This case happens for example when called from
@@ -3050,8 +3208,8 @@ set_window_buffer (Lisp_Object window, Lisp_Object buffer, int run_hooks_p, int
       Lisp_Object save_left = w->left_margin_cols;
       Lisp_Object save_right = w->right_margin_cols;
 
-      WSET (w, left_margin_cols, Qnil);
-      WSET (w, right_margin_cols, Qnil);
+      wset_left_margin_cols (w, Qnil);
+      wset_right_margin_cols (w, Qnil);
 
       Fset_window_fringes (window,
                            BVAR (b, left_fringe_width), BVAR (b, right_fringe_width),
@@ -3061,8 +3219,8 @@ set_window_buffer (Lisp_Object window, Lisp_Object buffer, int run_hooks_p, int
                                BVAR (b, scroll_bar_width),
                                BVAR (b, vertical_scroll_bar_type), Qnil);
 
-      WSET (w, left_margin_cols, save_left);
-      WSET (w, right_margin_cols, save_right);
+      wset_left_margin_cols (w, save_left);
+      wset_right_margin_cols (w, save_right);
 
       Fset_window_margins (window,
                            BVAR (b, left_margin_cols), BVAR (b, right_margin_cols));
@@ -3081,7 +3239,7 @@ set_window_buffer (Lisp_Object window, Lisp_Object buffer, int run_hooks_p, int
 
 DEFUN ("set-window-buffer", Fset_window_buffer, Sset_window_buffer, 2, 3, 0,
        doc: /* Make WINDOW display BUFFER-OR-NAME as its contents.
-WINDOW has to be a live window and defaults to the selected one.
+WINDOW must be a live window and defaults to the selected one.
 BUFFER-OR-NAME must be a buffer or the name of an existing buffer.
 
 Optional third argument KEEP-MARGINS non-nil means that WINDOW's current
@@ -3098,7 +3256,7 @@ This function runs `window-scroll-functions' before running
   (register Lisp_Object window, Lisp_Object buffer_or_name, Lisp_Object keep_margins)
 {
   register Lisp_Object tem, buffer;
-  register struct window *w = decode_window (window);
+  register struct window *w = decode_live_window (window);
 
   XSETWINDOW (window, w);
   buffer = Fget_buffer (buffer_or_name);
@@ -3121,7 +3279,7 @@ This function runs `window-scroll-functions' before running
           else
             /* WINDOW is weakly dedicated to its buffer, reset
                dedication.  */
-            WSET (w, dedicated, Qnil);
+            wset_dedicated (w, Qnil);
 
           call1 (Qrecord_window_buffer, window);
         }
@@ -3191,7 +3349,7 @@ temp_output_buffer_show (register Lisp_Object buf)
   register Lisp_Object window;
   register struct window *w;
 
-  BSET (XBUFFER (buf), directory, BVAR (current_buffer, directory));
+  bset_directory (XBUFFER (buf), BVAR (current_buffer, directory));
 
   Fset_buffer (buf);
   BUF_SAVE_MODIFF (XBUFFER (buf)) = MODIFF;
@@ -3267,17 +3425,17 @@ make_parent_window (Lisp_Object window, int horflag)
 
   replace_window (window, parent, 1);
 
-  WSET (o, next, Qnil);
-  WSET (o, prev, Qnil);
-  WSET (o, parent, parent);
+  wset_next (o, Qnil);
+  wset_prev (o, Qnil);
+  wset_parent (o, parent);
 
-  WSET (p, hchild, horflag ? window : Qnil);
-  WSET (p, vchild, horflag ? Qnil : window);
-  WSET (p, start, Qnil);
-  WSET (p, pointm, Qnil);
-  WSET (p, buffer, Qnil);
-  WSET (p, combination_limit, Qnil);
-  WSET (p, window_parameters, Qnil);
+  wset_hchild (p, horflag ? window : Qnil);
+  wset_vchild (p, horflag ? Qnil : window);
+  wset_start (p, Qnil);
+  wset_pointm (p, Qnil);
+  wset_buffer (p, Qnil);
+  wset_combination_limit (p, Qnil);
+  wset_window_parameters (p, Qnil);
 }
 
 /* Make new window from scratch.  */
@@ -3290,19 +3448,19 @@ make_window (void)
   w = allocate_window ();
   /* Initialize Lisp data.  Note that allocate_window initializes all
      Lisp data to nil, so do it only for slots which should not be nil.  */
-  WSET (w, left_col, make_number (0));
-  WSET (w, top_line, make_number (0));
-  WSET (w, total_lines, make_number (0));
-  WSET (w, total_cols, make_number (0));
-  WSET (w, normal_lines, make_float (1.0));
-  WSET (w, normal_cols, make_float (1.0));
-  WSET (w, new_total, make_number (0));
-  WSET (w, new_normal, make_number (0));
-  WSET (w, start, Fmake_marker ());
-  WSET (w, pointm, Fmake_marker ());
-  WSET (w, vertical_scroll_bar_type, Qt);
-  WSET (w, window_end_pos, make_number (0));
-  WSET (w, window_end_vpos, make_number (0));
+  wset_left_col (w, make_number (0));
+  wset_top_line (w, make_number (0));
+  wset_total_lines (w, make_number (0));
+  wset_total_cols (w, make_number (0));
+  wset_normal_lines (w, make_float (1.0));
+  wset_normal_cols (w, make_float (1.0));
+  wset_new_total (w, make_number (0));
+  wset_new_normal (w, make_number (0));
+  wset_start (w, Fmake_marker ());
+  wset_pointm (w, Fmake_marker ());
+  wset_vertical_scroll_bar_type (w, Qt);
+  wset_window_end_pos (w, make_number (0));
+  wset_window_end_vpos (w, make_number (0));
 
   /* Initialize non-Lisp data.  Note that allocate_window zeroes out all
      non-Lisp data, so do it only for slots which should not be zero.  */
@@ -3320,6 +3478,7 @@ make_window (void)
 
 DEFUN ("set-window-new-total", Fset_window_new_total, Sset_window_new_total, 2, 3, 0,
        doc: /* Set new total size of WINDOW to SIZE.
+WINDOW must be a valid window and defaults to the selected one.
 Return SIZE.
 
 Optional argument ADD non-nil means add SIZE to the new total size of
@@ -3328,25 +3487,27 @@ WINDOW and return the sum.
 Note: This function does not operate on any child windows of WINDOW.  */)
      (Lisp_Object window, Lisp_Object size, Lisp_Object add)
 {
-  struct window *w = decode_any_window (window);
+  struct window *w = decode_valid_window (window);
 
   CHECK_NUMBER (size);
   if (NILP (add))
-    WSET (w, new_total, size);
+    wset_new_total (w, size);
   else
-    WSET (w, new_total, make_number (XINT (w->new_total) + XINT (size)));
+    wset_new_total (w, make_number (XINT (w->new_total) + XINT (size)));
 
   return w->new_total;
 }
 
 DEFUN ("set-window-new-normal", Fset_window_new_normal, Sset_window_new_normal, 1, 2, 0,
        doc: /* Set new normal size of WINDOW to SIZE.
+WINDOW must be a valid window and defaults to the selected one.
 Return SIZE.
 
 Note: This function does not operate on any child windows of WINDOW.  */)
      (Lisp_Object window, Lisp_Object size)
 {
-  return WSET (decode_any_window (window), new_normal, size);
+  wset_new_normal (decode_valid_window (window), size);
+  return size;
 }
 
 /* Return 1 if setting w->total_lines (w->total_cols if HORFLAG is
@@ -3447,17 +3608,17 @@ window_resize_apply (struct window *w, int horflag)
      parent window has been set *before*.  */
   if (horflag)
     {
-      WSET (w, total_cols, w->new_total);
+      wset_total_cols (w, w->new_total);
       if (NUMBERP (w->new_normal))
-        WSET (w, normal_cols, w->new_normal);
+        wset_normal_cols (w, w->new_normal);
 
       pos = XINT (w->left_col);
     }
   else
     {
-      WSET (w, total_lines, w->new_total);
+      wset_total_lines (w, w->new_total);
       if (NUMBERP (w->new_normal))
-        WSET (w, normal_lines, w->new_normal);
+        wset_normal_lines (w, w->new_normal);
 
       pos = XINT (w->top_line);
     }
@@ -3469,9 +3630,9 @@ window_resize_apply (struct window *w, int horflag)
       while (c)
         {
           if (horflag)
-            WSET (c, left_col, make_number (pos));
+            wset_left_col (c, make_number (pos));
           else
-            WSET (c, top_line, make_number (pos));
+            wset_top_line (c, make_number (pos));
           window_resize_apply (c, horflag);
           if (!horflag)
             pos = pos + XINT (c->total_lines);
@@ -3485,9 +3646,9 @@ window_resize_apply (struct window *w, int horflag)
       while (c)
         {
           if (horflag)
-            WSET (c, left_col, make_number (pos));
+            wset_left_col (c, make_number (pos));
           else
-            WSET (c, top_line, make_number (pos));
+            wset_top_line (c, make_number (pos));
           window_resize_apply (c, horflag);
           if (horflag)
             pos = pos + XINT (c->total_cols);
@@ -3568,17 +3729,17 @@ resize_frame_windows (struct frame *f, int size, int horflag)
                      - ((FRAME_HAS_MINIBUF_P (f) && !FRAME_MINIBUF_ONLY_P (f))
                         ? 1 : 0)));
 
-  WSET (r, top_line, make_number (FRAME_TOP_MARGIN (f)));
+  wset_top_line (r, make_number (FRAME_TOP_MARGIN (f)));
   if (NILP (r->vchild) && NILP (r->hchild))
     /* For a leaf root window just set the size.  */
     if (horflag)
-      WSET (r, total_cols, make_number (new_size));
+      wset_total_cols (r, make_number (new_size));
     else
-      WSET (r, total_lines, make_number (new_size));
+      wset_total_lines (r, make_number (new_size));
   else
     {
       /* old_size is the old size of the frame's root window.  */
-      int old_size = XFASTINT (horflag ? r->total_cols 
+      int old_size = XFASTINT (horflag ? r->total_cols
                                : r->total_lines);
       Lisp_Object delta;
 
@@ -3609,9 +3770,9 @@ resize_frame_windows (struct frame *f, int size, int horflag)
                   root = f->selected_window;
                   Fdelete_other_windows_internal (root, Qnil);
                   if (horflag)
-                    WSET (XWINDOW (root), total_cols, make_number (new_size));
+                    wset_total_cols (XWINDOW (root), make_number (new_size));
                   else
-                    WSET (XWINDOW (root), total_lines, make_number (new_size));
+                    wset_total_lines (XWINDOW (root), make_number (new_size));
                 }
             }
         }
@@ -3621,13 +3782,13 @@ resize_frame_windows (struct frame *f, int size, int horflag)
     {
       m = XWINDOW (mini);
       if (horflag)
-        WSET (m, total_cols, make_number (size));
+        wset_total_cols (m, make_number (size));
       else
         {
           /* Are we sure we always want 1 line here?  */
-          WSET (m, total_lines, make_number (1));
-          WSET (m, top_line,
-                make_number (XINT (r->top_line) + XINT (r->total_lines)));
+          wset_total_lines (m, make_number (1));
+          wset_top_line
+            (m, make_number (XINT (r->top_line) + XINT (r->total_lines)));
         }
     }
 }
@@ -3708,15 +3869,14 @@ set correctly.  See the code of `split-window' for how this is done.  */)
     {
       p = XWINDOW (o->parent);
       /* Temporarily pretend we split the parent window.  */
-      WSET (p, new_total,
-            make_number (XINT (horflag ? p->total_cols : p->total_lines)
+      wset_new_total
+        (p, make_number (XINT (horflag ? p->total_cols : p->total_lines)
                          - XINT (total_size)));
       if (!window_resize_check (p, horflag))
         error ("Window sizes don't fit");
       else
         /* Undo the temporary pretension.  */
-        WSET (p, new_total,
-              horflag ? p->total_cols : p->total_lines);
+        wset_new_total (p, horflag ? p->total_cols : p->total_lines);
     }
   else
     {
@@ -3740,10 +3900,10 @@ set correctly.  See the code of `split-window' for how this is done.  */)
       p = XWINDOW (o->parent);
       /* Store value of `window-combination-limit' in new parent's
          combination_limit slot.  */
-      WSET (p, combination_limit, Vwindow_combination_limit);
+      wset_combination_limit (p, Vwindow_combination_limit);
       /* These get applied below.  */
-      WSET (p, new_total, horflag ? o->total_cols : o->total_lines);
-      WSET (p, new_normal, new_normal);
+      wset_new_total (p, horflag ? o->total_cols : o->total_lines);
+      wset_new_normal (p, new_normal);
     }
   else
     p = XWINDOW (o->parent);
@@ -3752,62 +3912,62 @@ set correctly.  See the code of `split-window' for how this is done.  */)
   FRAME_WINDOW_SIZES_CHANGED (f) = 1;
   new = make_window ();
   n = XWINDOW (new);
-  WSET (n, frame, frame);
-  WSET (n, parent, o->parent);
-  WSET (n, vchild, Qnil);
-  WSET (n, hchild, Qnil);
+  wset_frame (n, frame);
+  wset_parent (n, o->parent);
+  wset_vchild (n, Qnil);
+  wset_hchild (n, Qnil);
 
   if (EQ (side, Qabove) || EQ (side, Qleft))
     {
-      WSET (n, prev, o->prev);
+      wset_prev (n, o->prev);
       if (NILP (n->prev))
         if (horflag)
-          WSET (p, hchild, new);
+          wset_hchild (p, new);
         else
-          WSET (p, vchild, new);
+          wset_vchild (p, new);
       else
-        WSET (XWINDOW (n->prev), next, new);
-      WSET (n, next, old);
-      WSET (o, prev, new);
+        wset_next (XWINDOW (n->prev), new);
+      wset_next (n, old);
+      wset_prev (o, new);
     }
   else
     {
-      WSET (n, next, o->next);
+      wset_next (n, o->next);
       if (!NILP (n->next))
-        WSET (XWINDOW (n->next), prev, new);
-      WSET (n, prev, old);
-      WSET (o, next, new);
+        wset_prev (XWINDOW (n->next), new);
+      wset_prev (n, old);
+      wset_next (o, new);
     }
 
-  WSET (n, buffer, Qt);
-  WSET (n, window_end_valid, Qnil);
+  wset_buffer (n, Qt);
+  wset_window_end_valid (n, Qnil);
   memset (&n->last_cursor, 0, sizeof n->last_cursor);
 
   /* Get special geometry settings from reference window.  */
-  WSET (n, left_margin_cols, r->left_margin_cols);
-  WSET (n, right_margin_cols, r->right_margin_cols);
-  WSET (n, left_fringe_width, r->left_fringe_width);
-  WSET (n, right_fringe_width, r->right_fringe_width);
+  wset_left_margin_cols (n, r->left_margin_cols);
+  wset_right_margin_cols (n, r->right_margin_cols);
+  wset_left_fringe_width (n, r->left_fringe_width);
+  wset_right_fringe_width (n, r->right_fringe_width);
   n->fringes_outside_margins = r->fringes_outside_margins;
-  WSET (n, scroll_bar_width, r->scroll_bar_width);
-  WSET (n, vertical_scroll_bar_type, r->vertical_scroll_bar_type);
+  wset_scroll_bar_width (n, r->scroll_bar_width);
+  wset_vertical_scroll_bar_type (n, r->vertical_scroll_bar_type);
 
   /* Directly assign orthogonal coordinates and sizes.  */
   if (horflag)
     {
-      WSET (n, top_line, o->top_line);
-      WSET (n, total_lines, o->total_lines);
+      wset_top_line (n, o->top_line);
+      wset_total_lines (n, o->total_lines);
     }
   else
     {
-      WSET (n, left_col, o->left_col);
-      WSET (n, total_cols, o->total_cols);
+      wset_left_col (n, o->left_col);
+      wset_total_cols (n, o->total_cols);
     }
 
   /* Iso-coordinates and sizes are assigned by window_resize_apply,
      get them ready here.  */
-  WSET (n, new_total, total_size);
-  WSET (n, new_normal, normal_size);
+  wset_new_total (n, total_size);
+  wset_new_normal (n, normal_size);
 
   BLOCK_INPUT;
   window_resize_apply (p, horflag);
@@ -3840,8 +4000,6 @@ Signal an error when WINDOW is the only window on its frame.  */)
   int before_sibling = 0;
 
   w = decode_any_window (window);
-  CHECK_LIVE_FRAME (w->frame);
-
   XSETWINDOW (window, w);
   if (NILP (w->buffer)
       && NILP (w->hchild) && NILP (w->vchild))
@@ -3875,20 +4033,20 @@ Signal an error when WINDOW is the only window on its frame.  */)
       before_sibling = 1;
       sibling = w->next;
       s = XWINDOW (sibling);
-      WSET (s, prev, Qnil);
+      wset_prev (s, Qnil);
       if (horflag)
-        WSET (p, hchild, sibling);
+        wset_hchild (p, sibling);
       else
-        WSET (p, vchild, sibling);
+        wset_vchild (p, sibling);
     }
   else
     /* Get SIBLING above (on the left of) WINDOW.  */
     {
       sibling = w->prev;
       s = XWINDOW (sibling);
-      WSET (s, next, w->next);
+      wset_next (s, w->next);
       if (!NILP (s->next))
-        WSET (XWINDOW (s->next), prev, sibling);
+        wset_prev (XWINDOW (s->next), sibling);
     }
 
   if (window_resize_check (r, horflag)
@@ -3918,25 +4076,25 @@ Signal an error when WINDOW is the only window on its frame.  */)
       Vwindow_list = Qnil;
       FRAME_WINDOW_SIZES_CHANGED (f) = 1;
 
-      WSET (w, next, Qnil);  /* Don't delete w->next too.  */
+      wset_next (w, Qnil);  /* Don't delete w->next too.  */
       free_window_matrices (w);
 
       if (!NILP (w->vchild))
         {
           delete_all_child_windows (w->vchild);
-          WSET (w, vchild, Qnil);
+          wset_vchild (w, Qnil);
         }
       else if (!NILP (w->hchild))
         {
           delete_all_child_windows (w->hchild);
-          WSET (w, hchild, Qnil);
+          wset_hchild (w, Qnil);
         }
       else if (!NILP (w->buffer))
         {
           unshow_buffer (w);
           unchain_marker (XMARKER (w->pointm));
           unchain_marker (XMARKER (w->start));
-          WSET (w, buffer, Qnil);
+          wset_buffer (w, Qnil);
         }
 
       if (NILP (s->prev) && NILP (s->next))
@@ -3947,11 +4105,11 @@ Signal an error when WINDOW is the only window on its frame.  */)
           replace_window (parent, sibling, 0);
           /* Have SIBLING inherit the following three slot values from
              PARENT (the combination_limit slot is not inherited).  */
-          WSET (s, normal_cols, p->normal_cols);
-          WSET (s, normal_lines, p->normal_lines);
+          wset_normal_cols (s, p->normal_cols);
+          wset_normal_lines (s, p->normal_lines);
           /* Mark PARENT as deleted.  */
-          WSET (p, vchild, Qnil);
-          WSET (p, hchild, Qnil);
+          wset_vchild (p, Qnil);
+          wset_hchild (p, Qnil);
           /* Try to merge SIBLING into its new parent.  */
           recombine_windows (sibling);
         }
@@ -3971,7 +4129,7 @@ Signal an error when WINDOW is the only window on its frame.  */)
           if (EQ (FRAME_SELECTED_WINDOW (f), selected_window))
             Fselect_window (new_selected_window, Qt);
           else
-            FSET (f, selected_window, new_selected_window);
+            fset_selected_window (f, new_selected_window);
 
           UNBLOCK_INPUT;
 
@@ -3985,7 +4143,7 @@ Signal an error when WINDOW is the only window on its frame.  */)
           if (EQ (FRAME_SELECTED_WINDOW (f), selected_window))
             Fselect_window (new_selected_window, Qnil);
           else
-            FSET (f, selected_window, new_selected_window);
+            fset_selected_window (f, new_selected_window);
         }
       else
         UNBLOCK_INPUT;
@@ -3998,17 +4156,17 @@ Signal an error when WINDOW is the only window on its frame.  */)
     {
       if (before_sibling)
         {
-          WSET (s, prev, window);
+          wset_prev (s, window);
           if (horflag)
-            WSET (p, hchild, window);
+            wset_hchild (p, window);
           else
-            WSET (p, vchild, window);
+            wset_vchild (p, window);
         }
       else
         {
-          WSET (s, next, window);
+          wset_next (s, window);
           if (!NILP (w->next))
-            WSET (XWINDOW (w->next), prev, window);
+            wset_prev (XWINDOW (w->next), window);
         }
       error ("Deletion failed");
     }
@@ -4042,10 +4200,10 @@ grow_mini_window (struct window *w, int delta)
       window_resize_apply (r, 0);
 
       /* Grow the mini-window.  */
-      WSET (w, top_line,
-            make_number (XFASTINT (r->top_line) + XFASTINT (r->total_lines)));
-      WSET (w, total_lines,
-            make_number (XFASTINT (w->total_lines) - XINT (value)));
+      wset_top_line
+        (w, make_number (XFASTINT (r->top_line) + XFASTINT (r->total_lines)));
+      wset_total_lines
+        (w, make_number (XFASTINT (w->total_lines) - XINT (value)));
       w->last_modified = 0;
       w->last_overlay_modified = 0;
 
@@ -4079,9 +4237,9 @@ shrink_mini_window (struct window *w)
           window_resize_apply (r, 0);
 
           /* Shrink the mini-window.  */
-          WSET (w, top_line,
-                make_number (XFASTINT (r->top_line) + XFASTINT (r->total_lines)));
-          WSET (w, total_lines, make_number (1));
+          wset_top_line (w, make_number (XFASTINT (r->top_line)
+                                         + XFASTINT (r->total_lines)));
+          wset_total_lines (w, make_number (1));
 
           w->last_modified = 0;
           w->last_overlay_modified = 0;
@@ -4122,9 +4280,9 @@ DEFUN ("resize-mini-window-internal", Fresize_mini_window_internal, Sresize_mini
       BLOCK_INPUT;
       window_resize_apply (r, 0);
 
-      WSET (w, total_lines, w->new_total);
-      WSET (w, top_line,
-            make_number (XINT (r->top_line) + XINT (r->total_lines)));
+      wset_total_lines (w, w->new_total);
+      wset_top_line (w, make_number (XINT (r->top_line)
+                                     + XINT (r->total_lines)));
 
       windows_or_buffers_changed++;
       FRAME_WINDOW_SIZES_CHANGED (f) = 1;
@@ -5192,7 +5350,7 @@ and redisplay normally--don't erase and redraw the frame.  */)
 
   /* Set the new window start.  */
   set_marker_both (w->start, w->buffer, charpos, bytepos);
-  WSET (w, window_end_valid, Qnil);
+  wset_window_end_valid (w, Qnil);
 
   w->optional_new_start = 1;
 
@@ -5206,13 +5364,13 @@ and redisplay normally--don't erase and redraw the frame.  */)
 DEFUN ("window-text-height", Fwindow_text_height, Swindow_text_height,
        0, 1, 0,
        doc: /* Return the height in lines of the text display area of WINDOW.
-If WINDOW is omitted or nil, it defaults to the selected window.
+WINDOW must be a live window and defaults to the selected one.
 
 The returned height does not include the mode line, any header line,
 nor any partial-height lines at the bottom of the text area.  */)
   (Lisp_Object window)
 {
-  struct window *w = decode_window (window);
+  struct window *w = decode_live_window (window);
   int pixel_height = window_box_height (w);
   int line_height = pixel_height / FRAME_LINE_HEIGHT (XFRAME (w->frame));
   return make_number (line_height);
@@ -5510,34 +5668,34 @@ the return value is nil.  Otherwise the value is t.  */)
           p = SAVED_WINDOW_N (saved_windows, k);
           window = p->window;
           w = XWINDOW (window);
-          WSET (w, next, Qnil);
+          wset_next (w, Qnil);
 
           if (!NILP (p->parent))
-            WSET (w, parent, SAVED_WINDOW_N 
-                  (saved_windows, XFASTINT (p->parent))->window);
+            wset_parent
+              (w, SAVED_WINDOW_N (saved_windows, XFASTINT (p->parent))->window);
           else
-            WSET (w, parent, Qnil);
+            wset_parent (w, Qnil);
 
           if (!NILP (p->prev))
             {
-              WSET (w, prev, SAVED_WINDOW_N
-                    (saved_windows, XFASTINT (p->prev))->window);
-              WSET (XWINDOW (w->prev), next, p->window);
+              wset_prev
+                (w, SAVED_WINDOW_N (saved_windows, XFASTINT (p->prev))->window);
+              wset_next (XWINDOW (w->prev), p->window);
             }
           else
             {
-              WSET (w, prev, Qnil);
+              wset_prev (w, Qnil);
               if (!NILP (w->parent))
                 {
                   if (EQ (p->total_cols, XWINDOW (w->parent)->total_cols))
                     {
-                      WSET (XWINDOW (w->parent), vchild, p->window);
-                      WSET (XWINDOW (w->parent), hchild, Qnil);
+                      wset_vchild (XWINDOW (w->parent), p->window);
+                      wset_hchild (XWINDOW (w->parent), Qnil);
                     }
                   else
                     {
-                      WSET (XWINDOW (w->parent), hchild, p->window);
-                      WSET (XWINDOW (w->parent), vchild, Qnil);
+                      wset_hchild (XWINDOW (w->parent), p->window);
+                      wset_vchild (XWINDOW (w->parent), Qnil);
                     }
                 }
             }
@@ -5545,25 +5703,25 @@ the return value is nil.  Otherwise the value is t.  */)
           /* If we squirreled away the buffer in the window's height,
              restore it now.  */
           if (BUFFERP (w->total_lines))
-            WSET (w, buffer, w->total_lines);
-          WSET (w, left_col, p->left_col);
-          WSET (w, top_line, p->top_line);
-          WSET (w, total_cols, p->total_cols);
-          WSET (w, total_lines, p->total_lines);
-          WSET (w, normal_cols, p->normal_cols);
-          WSET (w, normal_lines, p->normal_lines);
+            wset_buffer (w, w->total_lines);
+          wset_left_col (w, p->left_col);
+          wset_top_line (w, p->top_line);
+          wset_total_cols (w, p->total_cols);
+          wset_total_lines (w, p->total_lines);
+          wset_normal_cols (w, p->normal_cols);
+          wset_normal_lines (w, p->normal_lines);
           w->hscroll = XFASTINT (p->hscroll);
           w->min_hscroll = XFASTINT (p->min_hscroll);
-          WSET (w, display_table, p->display_table);
-          WSET (w, left_margin_cols, p->left_margin_cols);
-          WSET (w, right_margin_cols, p->right_margin_cols);
-          WSET (w, left_fringe_width, p->left_fringe_width);
-          WSET (w, right_fringe_width, p->right_fringe_width);
+          wset_display_table (w, p->display_table);
+          wset_left_margin_cols (w, p->left_margin_cols);
+          wset_right_margin_cols (w, p->right_margin_cols);
+          wset_left_fringe_width (w, p->left_fringe_width);
+          wset_right_fringe_width (w, p->right_fringe_width);
           w->fringes_outside_margins = !NILP (p->fringes_outside_margins);
-          WSET (w, scroll_bar_width, p->scroll_bar_width);
-          WSET (w, vertical_scroll_bar_type, p->vertical_scroll_bar_type);
-          WSET (w, dedicated, p->dedicated);
-          WSET (w, combination_limit, p->combination_limit);
+          wset_scroll_bar_width (w, p->scroll_bar_width);
+          wset_vertical_scroll_bar_type (w, p->vertical_scroll_bar_type);
+          wset_dedicated (w, p->dedicated);
+          wset_combination_limit (w, p->combination_limit);
           /* Restore any window parameters that have been saved.
              Parameters that have not been saved are left alone.  */
           for (tem = p->window_parameters; CONSP (tem); tem = XCDR (tem))
@@ -5592,24 +5750,24 @@ the return value is nil.  Otherwise the value is t.  */)
           /* Reinstall the saved buffer and pointers into it.  */
           if (NILP (p->buffer))
             /* An internal window.  */
-            WSET (w, buffer, p->buffer);
+            wset_buffer (w, p->buffer);
           else if (!NILP (BVAR (XBUFFER (p->buffer), name)))
             /* If saved buffer is alive, install it.  */
             {
-              WSET (w, buffer, p->buffer);
-               w->start_at_line_beg = !NILP (p->start_at_line_beg);
-               set_marker_restricted (w->start, p->start, w->buffer);
-               set_marker_restricted (w->pointm, p->pointm,
-                                      w->buffer);
-               Fset_marker (BVAR (XBUFFER (w->buffer), mark),
-                            p->mark, w->buffer);
-
-               /* As documented in Fcurrent_window_configuration, don't
-                  restore the location of point in the buffer which was
-                  current when the window configuration was recorded.  */
-               if (!EQ (p->buffer, new_current_buffer)
-                   && XBUFFER (p->buffer) == current_buffer)
-                 Fgoto_char (w->pointm);
+              wset_buffer (w, p->buffer);
+              w->start_at_line_beg = !NILP (p->start_at_line_beg);
+              set_marker_restricted (w->start, p->start, w->buffer);
+              set_marker_restricted (w->pointm, p->pointm,
+                                     w->buffer);
+              Fset_marker (BVAR (XBUFFER (w->buffer), mark),
+                           p->mark, w->buffer);
+
+              /* As documented in Fcurrent_window_configuration, don't
+                 restore the location of point in the buffer which was
+                 current when the window configuration was recorded.  */
+              if (!EQ (p->buffer, new_current_buffer)
+                  && XBUFFER (p->buffer) == current_buffer)
+                Fgoto_char (w->pointm);
              }
            else if (!NILP (w->buffer)
                     && !NILP (BVAR (XBUFFER (w->buffer), name)))
@@ -5621,7 +5779,7 @@ the return value is nil.  Otherwise the value is t.  */)
                  set_marker_restricted (w->start, make_number (0),
                                         w->buffer);
                if (XMARKER (w->pointm)->buffer == 0)
-                 set_marker_restricted_both 
+                 set_marker_restricted_both
                    (w->pointm, w->buffer,
                     BUF_PT (XBUFFER (w->buffer)),
                     BUF_PT_BYTE (XBUFFER (w->buffer)));
@@ -5630,7 +5788,8 @@ the return value is nil.  Otherwise the value is t.  */)
            else if (STRINGP (auto_buffer_name =
                              Fwindow_parameter (window, Qauto_buffer_name))
                     && SCHARS (auto_buffer_name) != 0
-                    && !NILP (WSET (w, buffer, Fget_buffer_create (auto_buffer_name))))
+                    && (wset_buffer (w, Fget_buffer_create (auto_buffer_name)),
+                        !NILP (w->buffer)))
             {
               set_marker_restricted (w->start,
                                      make_number (0), w->buffer);
@@ -5645,7 +5804,7 @@ the return value is nil.  Otherwise the value is t.  */)
               avoid showing an unimportant buffer and, if necessary, to
               recreate *scratch* in the course (part of Juanma's bs-show
               scenario from March 2011).  */
-              WSET (w, buffer, other_buffer_safely (Fcurrent_buffer ()));
+              wset_buffer (w, other_buffer_safely (Fcurrent_buffer ()));
               /* This will set the markers to beginning of visible
                  range.  */
               set_marker_restricted (w->start,
@@ -5657,11 +5816,11 @@ the return value is nil.  Otherwise the value is t.  */)
                 /* Record this window as dead.  */
                 dead_windows = Fcons (window, dead_windows);
               /* Make sure window is no more dedicated.  */
-              WSET (w, dedicated, Qnil);
+              wset_dedicated (w, Qnil);
             }
         }
 
-      FSET (f, root_window, data->root_window);
+      fset_root_window (f, data->root_window);
       /* Arrange *not* to restore point in the buffer that was
          current when the window configuration was saved.  */
       if (EQ (XWINDOW (data->current_window)->buffer, new_current_buffer))
@@ -5757,24 +5916,25 @@ delete_all_child_windows (Lisp_Object window)
     /* Delete WINDOW's siblings (we traverse postorderly).  */
     delete_all_child_windows (w->next);
 
-  WSET (w, total_lines, w->buffer);       /* See Fset_window_configuration for excuse.  */
+  /* See Fset_window_configuration for excuse.  */
+  wset_total_lines (w, w->buffer);
 
   if (!NILP (w->vchild))
     {
       delete_all_child_windows (w->vchild);
-      WSET (w, vchild, Qnil);
+      wset_vchild (w, Qnil);
     }
   else if (!NILP (w->hchild))
     {
       delete_all_child_windows (w->hchild);
-      WSET (w, hchild, Qnil);
+      wset_hchild (w, Qnil);
     }
   else if (!NILP (w->buffer))
     {
       unshow_buffer (w);
       unchain_marker (XMARKER (w->pointm));
       unchain_marker (XMARKER (w->start));
-      WSET (w, buffer, Qnil);
+      wset_buffer (w, Qnil);
     }
 
   Vwindow_list = Qnil;
@@ -5866,7 +6026,7 @@ save_window_save (Lisp_Object window, struct Lisp_Vector *vector, int i)
       p = SAVED_WINDOW_N (vector, i);
       w = XWINDOW (window);
 
-      WSET (w, temslot, make_number (i)); i++;
+      wset_temslot (w, make_number (i)); i++;
       p->window = window;
       p->buffer = w->buffer;
       p->left_col = w->left_col;
@@ -6039,14 +6199,15 @@ saved by this function.  */)
 DEFUN ("set-window-margins", Fset_window_margins, Sset_window_margins,
        2, 3, 0,
        doc: /* Set width of marginal areas of window WINDOW.
-If WINDOW is nil, set margins of the currently selected window.
+WINDOW must be a live window and defaults to the selected one.
+
 Second arg LEFT-WIDTH specifies the number of character cells to
 reserve for the left marginal area.  Optional third arg RIGHT-WIDTH
 does the same for the right marginal area.  A nil width parameter
 means no margin.  */)
   (Lisp_Object window, Lisp_Object left_width, Lisp_Object right_width)
 {
-  struct window *w = decode_window (window);
+  struct window *w = decode_live_window (window);
 
   /* Translate negative or zero widths to nil.
      Margins that are too wide have to be checked elsewhere.  */
@@ -6068,8 +6229,8 @@ means no margin.  */)
   if (!EQ (w->left_margin_cols, left_width)
       || !EQ (w->right_margin_cols, right_width))
     {
-      WSET (w, left_margin_cols, left_width);
-      WSET (w, right_margin_cols, right_width);
+      wset_left_margin_cols (w, left_width);
+      wset_right_margin_cols (w, right_width);
 
       adjust_window_margins (w);
 
@@ -6084,13 +6245,14 @@ means no margin.  */)
 DEFUN ("window-margins", Fwindow_margins, Swindow_margins,
        0, 1, 0,
        doc: /* Get width of marginal areas of window WINDOW.
-If WINDOW is omitted or nil, it defaults to the selected window.
+WINDOW must be a live window and defaults to the selected one.
+
 Value is a cons of the form (LEFT-WIDTH . RIGHT-WIDTH).
 If a marginal area does not exist, its width will be returned
 as nil.  */)
   (Lisp_Object window)
 {
-  struct window *w = decode_window (window);
+  struct window *w = decode_live_window (window);
   return Fcons (w->left_margin_cols, w->right_margin_cols);
 }
 
@@ -6103,8 +6265,8 @@ as nil.  */)
 DEFUN ("set-window-fringes", Fset_window_fringes, Sset_window_fringes,
        2, 4, 0,
        doc: /* Set the fringe widths of window WINDOW.
-If WINDOW is nil, set the fringe widths of the currently selected
-window.
+WINDOW must be a live window and defaults to the selected one.
+
 Second arg LEFT-WIDTH specifies the number of pixels to reserve for
 the left fringe.  Optional third arg RIGHT-WIDTH specifies the right
 fringe width.  If a fringe width arg is nil, that means to use the
@@ -6115,7 +6277,7 @@ outside of the display margins.  By default, fringes are drawn between
 display marginal areas and the text area.  */)
   (Lisp_Object window, Lisp_Object left_width, Lisp_Object right_width, Lisp_Object outside_margins)
 {
-  struct window *w = decode_window (window);
+  struct window *w = decode_live_window (window);
   int outside = !NILP (outside_margins);
 
   if (!NILP (left_width))
@@ -6129,14 +6291,14 @@ display marginal areas and the text area.  */)
           || !EQ (w->right_fringe_width, right_width)
           || w->fringes_outside_margins != outside))
     {
-      WSET (w, left_fringe_width, left_width);
-      WSET (w, right_fringe_width, right_width);
+      wset_left_fringe_width (w, left_width);
+      wset_right_fringe_width (w, right_width);
       w->fringes_outside_margins = outside;
 
       adjust_window_margins (w);
 
       clear_glyph_matrix (w->current_matrix);
-      WSET (w, window_end_valid, Qnil);
+      wset_window_end_valid (w, Qnil);
 
       ++windows_or_buffers_changed;
       adjust_glyphs (XFRAME (WINDOW_FRAME (w)));
@@ -6149,11 +6311,12 @@ display marginal areas and the text area.  */)
 DEFUN ("window-fringes", Fwindow_fringes, Swindow_fringes,
        0, 1, 0,
        doc: /* Get width of fringes of window WINDOW.
-If WINDOW is omitted or nil, it defaults to the selected window.
+WINDOW must be a live window and defaults to the selected one.
+
 Value is a list of the form (LEFT-WIDTH RIGHT-WIDTH OUTSIDE-MARGINS).  */)
   (Lisp_Object window)
 {
-  struct window *w = decode_window (window);
+  struct window *w = decode_live_window (window);
 
   return Fcons (make_number (WINDOW_LEFT_FRINGE_WIDTH (w)),
                 Fcons (make_number (WINDOW_RIGHT_FRINGE_WIDTH (w)),
@@ -6170,7 +6333,8 @@ Value is a list of the form (LEFT-WIDTH RIGHT-WIDTH OUTSIDE-MARGINS).  */)
 DEFUN ("set-window-scroll-bars", Fset_window_scroll_bars,
        Sset_window_scroll_bars, 2, 4, 0,
        doc: /* Set width and type of scroll bars of window WINDOW.
-If window is nil, set scroll bars of the currently selected window.
+WINDOW must be a live window and defaults to the selected one.
+
 Second parameter WIDTH specifies the pixel width for the scroll bar;
 this is automatically adjusted to a multiple of the frame column width.
 Third parameter VERTICAL-TYPE specifies the type of the vertical scroll
@@ -6180,7 +6344,7 @@ If VERTICAL-TYPE is t, use the frame's scroll-bar type.
 Fourth parameter HORIZONTAL-TYPE is currently unused.  */)
   (Lisp_Object window, Lisp_Object width, Lisp_Object vertical_type, Lisp_Object horizontal_type)
 {
-  struct window *w = decode_window (window);
+  struct window *w = decode_live_window (window);
 
   if (!NILP (width))
     {
@@ -6199,13 +6363,13 @@ Fourth parameter HORIZONTAL-TYPE is currently unused.  */)
   if (!EQ (w->scroll_bar_width, width)
       || !EQ (w->vertical_scroll_bar_type, vertical_type))
     {
-      WSET (w, scroll_bar_width, width);
-      WSET (w, vertical_scroll_bar_type, vertical_type);
+      wset_scroll_bar_width (w, width);
+      wset_vertical_scroll_bar_type (w, vertical_type);
 
       adjust_window_margins (w);
 
       clear_glyph_matrix (w->current_matrix);
-      WSET (w, window_end_valid, Qnil);
+      wset_window_end_valid (w, Qnil);
 
       ++windows_or_buffers_changed;
       adjust_glyphs (XFRAME (WINDOW_FRAME (w)));
@@ -6218,13 +6382,14 @@ Fourth parameter HORIZONTAL-TYPE is currently unused.  */)
 DEFUN ("window-scroll-bars", Fwindow_scroll_bars, Swindow_scroll_bars,
        0, 1, 0,
        doc: /* Get width and type of scroll bars of window WINDOW.
-If WINDOW is omitted or nil, it defaults to the selected window.
+WINDOW must be a live window and defaults to the selected one.
+
 Value is a list of the form (WIDTH COLS VERTICAL-TYPE HORIZONTAL-TYPE).
 If WIDTH is nil or TYPE is t, the window is using the frame's corresponding
 value.  */)
   (Lisp_Object window)
 {
-  struct window *w = decode_window (window);
+  struct window *w = decode_live_window (window);
   return Fcons (make_number ((WINDOW_CONFIG_SCROLL_BAR_WIDTH (w)
                               ? WINDOW_CONFIG_SCROLL_BAR_WIDTH (w)
                               : WINDOW_SCROLL_BAR_AREA_WIDTH (w))),
@@ -6518,6 +6683,7 @@ syms_of_window (void)
   DEFSYM (Qwindowp, "windowp");
   DEFSYM (Qwindow_configuration_p, "window-configuration-p");
   DEFSYM (Qwindow_live_p, "window-live-p");
+  DEFSYM (Qwindow_valid_p, "window-valid-p");
   DEFSYM (Qwindow_deletable_p, "window-deletable-p");
   DEFSYM (Qdelete_window, "delete-window");
   DEFSYM (Qwindow_resize_root_window, "window--resize-root-window");
@@ -6670,6 +6836,7 @@ respectively are not installed by `window-state-put'.  */);
   defsubr (&Sminibuffer_window);
   defsubr (&Swindow_minibuffer_p);
   defsubr (&Swindowp);
+  defsubr (&Swindow_valid_p);
   defsubr (&Swindow_live_p);
   defsubr (&Swindow_frame);
   defsubr (&Sframe_root_window);
diff --git a/src/window.h b/src/window.h
index 3e6f4f82b0a..28b9678b667 100644
--- a/src/window.h
+++ b/src/window.h
@@ -22,6 +22,11 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "dispextern.h"
 
+INLINE_HEADER_BEGIN
+#ifndef WINDOW_INLINE
+# define WINDOW_INLINE INLINE
+#endif
+
 extern Lisp_Object Qleft, Qright;
 
 /* Windows are allocated as if they were vectors, but then the
@@ -86,10 +91,6 @@ struct cursor_pos
   int hpos, vpos;
 };
 
-/* Most code should use this macro to set Lisp fields in struct window.  */
-
-#define WSET(w, field, value) ((w)->field = (value))
-
 struct window
   {
     /* This is for Lisp; the terminal code does not refer to it.  */
@@ -348,6 +349,75 @@ struct window
     ptrdiff_t window_end_bytepos;
 };
 
+/* Most code should use these functions to set Lisp fields in struct
+   window.  */
+WINDOW_INLINE void
+wset_buffer (struct window *w, Lisp_Object val)
+{
+  w->buffer = val;
+}
+WINDOW_INLINE void
+wset_frame (struct window *w, Lisp_Object val)
+{
+  w->frame = val;
+}
+WINDOW_INLINE void
+wset_left_col (struct window *w, Lisp_Object val)
+{
+  w->left_col = val;
+}
+WINDOW_INLINE void
+wset_next (struct window *w, Lisp_Object val)
+{
+  w->next = val;
+}
+WINDOW_INLINE void
+wset_prev (struct window *w, Lisp_Object val)
+{
+  w->prev = val;
+}
+WINDOW_INLINE void
+wset_redisplay_end_trigger (struct window *w, Lisp_Object val)
+{
+  w->redisplay_end_trigger = val;
+}
+WINDOW_INLINE void
+wset_top_line (struct window *w, Lisp_Object val)
+{
+  w->top_line = val;
+}
+WINDOW_INLINE void
+wset_total_cols (struct window *w, Lisp_Object val)
+{
+  w->total_cols = val;
+}
+WINDOW_INLINE void
+wset_total_lines (struct window *w, Lisp_Object val)
+{
+  w->total_lines = val;
+}
+WINDOW_INLINE void
+wset_vertical_scroll_bar (struct window *w, Lisp_Object val)
+{
+  w->vertical_scroll_bar = val;
+}
+WINDOW_INLINE void
+wset_window_end_pos (struct window *w, Lisp_Object val)
+{
+  w->window_end_pos = val;
+}
+WINDOW_INLINE void
+wset_window_end_valid (struct window *w, Lisp_Object val)
+{
+  w->window_end_valid = val;
+}
+WINDOW_INLINE void
+wset_window_end_vpos (struct window *w, Lisp_Object val)
+{
+  w->window_end_vpos = val;
+}
+
+
 /* 1 if W is a minibuffer window.  */
 
 #define MINI_WINDOW_P(W)        ((W)->mini)
@@ -885,8 +955,15 @@ extern void check_frame_size (struct frame *frame, int *rows, int *cols);
 
 struct glyph *get_phys_cursor_glyph (struct window *w);
 
-/* Value is non-zero if WINDOW is a live window.  */
+/* Value is non-zero if WINDOW is a valid window.  */
+#define WINDOW_VALID_P(WINDOW)                          \
+  (WINDOWP (WINDOW)                                     \
+   && (!NILP (XWINDOW (WINDOW)->buffer)                 \
+       || !NILP (XWINDOW (WINDOW)->vchild)              \
+       || !NILP (XWINDOW (WINDOW)->hchild)))
+
 
+/* Value is non-zero if WINDOW is a live window.  */
 #define WINDOW_LIVE_P(WINDOW)                                   \
   (WINDOWP (WINDOW) && !NILP (XWINDOW (WINDOW)->buffer))
 
@@ -895,6 +972,8 @@ struct glyph *get_phys_cursor_glyph (struct window *w);
 extern Lisp_Object Qwindowp, Qwindow_live_p;
 extern Lisp_Object Vwindow_list;
 
+extern struct window *decode_valid_window (Lisp_Object);
+extern struct window *decode_live_window (Lisp_Object);
 extern int compare_window_configurations (Lisp_Object, Lisp_Object, int);
 extern void mark_window_cursors_off (struct window *);
 extern int window_internal_height (struct window *);
@@ -907,4 +986,6 @@ extern void init_window (void);
 extern void syms_of_window (void);
 extern void keys_of_window (void);
 
+INLINE_HEADER_END
+
 #endif /* not WINDOW_H_INCLUDED */
diff --git a/src/xdisp.c b/src/xdisp.c
index 9bb3d92ac39..8260080ccf2 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -367,6 +367,28 @@ Lisp_Object Qcenter;
 static Lisp_Object Qmargin, Qpointer;
 static Lisp_Object Qline_height;
 
+/* These setters are used only in this file, so they can be private.  */
+static inline void
+wset_base_line_number (struct window *w, Lisp_Object val)
+{
+  w->base_line_number = val;
+}
+static inline void
+wset_base_line_pos (struct window *w, Lisp_Object val)
+{
+  w->base_line_pos = val;
+}
+static inline void
+wset_column_number_displayed (struct window *w, Lisp_Object val)
+{
+  w->column_number_displayed = val;
+}
+static inline void
+wset_region_showing (struct window *w, Lisp_Object val)
+{
+  w->region_showing = val;
+}
+
 #ifdef HAVE_WINDOW_SYSTEM
 
 /* Test if overflow newline into fringe.  Called with iterator IT
@@ -4052,38 +4074,56 @@ static enum prop_handled
 handle_invisible_prop (struct it *it)
 {
   enum prop_handled handled = HANDLED_NORMALLY;
+  int invis_p;
+  Lisp_Object prop;
 
   if (STRINGP (it->string))
     {
-      Lisp_Object prop, end_charpos, limit, charpos;
+      Lisp_Object end_charpos, limit, charpos;
 
       /* Get the value of the invisible text property at the
          current position.  Value will be nil if there is no such
          property.  */
       charpos = make_number (IT_STRING_CHARPOS (*it));
       prop = Fget_text_property (charpos, Qinvisible, it->string);
+      invis_p = TEXT_PROP_MEANS_INVISIBLE (prop);
 
-      if (!NILP (prop)
-          && IT_STRING_CHARPOS (*it) < it->end_charpos)
+      if (invis_p && IT_STRING_CHARPOS (*it) < it->end_charpos)
         {
+          /* Record whether we have to display an ellipsis for the
+             invisible text.  */
+          int display_ellipsis_p = (invis_p == 2);
           ptrdiff_t endpos;
 
           handled = HANDLED_RECOMPUTE_PROPS;
 
-          /* Get the position at which the next change of the
-             invisible text property can be found in IT->string.
-             Value will be nil if the property value is the same for
-             all the rest of IT->string.  */
+          /* Get the position at which the next visible text can be
+             found in IT->string, if any.  */
           XSETINT (limit, SCHARS (it->string));
-          end_charpos = Fnext_single_property_change (charpos, Qinvisible,
-                                                      it->string, limit);
+          do
+            {
+              end_charpos = Fnext_single_property_change (charpos, Qinvisible,
+                                                          it->string, limit);
+              if (!NILP (end_charpos))
+                {
+                  prop = Fget_text_property (end_charpos, Qinvisible, it->string);
+                  invis_p = TEXT_PROP_MEANS_INVISIBLE (prop);
+                  if (invis_p == 2)
+                    display_ellipsis_p = 1;
+                }
+            }
+          while (!NILP (end_charpos) && invis_p);
+
+          if (display_ellipsis_p)
+            {
+              it->ellipsis_p = 1;
+              handled = HANDLED_RETURN;
+            }
 
-          /* Text at current position is invisible.  The next
-             change in the property is at position end_charpos.
-             Move IT's current position to that position.  */
           if (INTEGERP (end_charpos)
               && (endpos = XFASTINT (end_charpos)) < XFASTINT (limit))
             {
+              /* Text at END_CHARPOS is visible.  Move IT there.  */
               struct text_pos old;
               ptrdiff_t oldpos;
 
@@ -4136,9 +4176,8 @@ handle_invisible_prop (struct it *it)
     }
   else
     {
-      int invis_p;
       ptrdiff_t newpos, next_stop, start_charpos, tem;
-      Lisp_Object pos, prop, overlay;
+      Lisp_Object pos, overlay;
 
       /* First of all, is there invisible text at this position?  */
       tem = start_charpos = IT_CHARPOS (*it);
@@ -6045,7 +6084,7 @@ back_to_previous_visible_line_start (struct it *it)
       {
         Lisp_Object prop;
         prop = Fget_char_property (make_number (IT_CHARPOS (*it) - 1),
-                                     Qinvisible, it->window);
+                                   Qinvisible, it->window);
         if (TEXT_PROP_MEANS_INVISIBLE (prop))
           continue;
       }
@@ -8035,7 +8074,7 @@ run_redisplay_end_trigger_hook (struct it *it)
 
   /* Since we are *trying* to run these functions, don't try to run
      them again, even if they get an error.  */
-  WSET (it->w, redisplay_end_trigger, Qnil);
+  wset_redisplay_end_trigger (it->w, Qnil);
   Frun_hook_with_args (3, args);
 
   /* Notice if it changed the face of the character we are on.  */
@@ -9372,7 +9411,7 @@ message_dolog (const char *m, ptrdiff_t nbytes, int nlflag, int multibyte)
       old_deactivate_mark = Vdeactivate_mark;
       oldbuf = current_buffer;
       Fset_buffer (Fget_buffer_create (Vmessages_buffer_name));
-      BSET (current_buffer, undo_list, Qt);
+      bset_undo_list (current_buffer, Qt);
 
       oldpoint = message_dolog_marker1;
       set_marker_restricted (oldpoint, make_number (PT), Qnil);
@@ -9934,7 +9973,7 @@ ensure_echo_area_buffers (void)
         old_buffer = echo_buffer[i];
         echo_buffer[i] = Fget_buffer_create
           (make_formatted_string (name, " *Echo Area %d*", i));
-        BSET (XBUFFER (echo_buffer[i]), truncate_lines, Qnil);
+        bset_truncate_lines (XBUFFER (echo_buffer[i]), Qnil);
         /* to force word wrap in echo area -
            it was decided to postpone this*/
         /* XBUFFER (echo_buffer[i])->word_wrap = Qt; */
@@ -10023,12 +10062,12 @@ with_echo_area_buffer (struct window *w, int which,
   set_buffer_internal_1 (XBUFFER (buffer));
   if (w)
     {
-      WSET (w, buffer, buffer);
+      wset_buffer (w, buffer);
       set_marker_both (w->pointm, buffer, BEG, BEG_BYTE);
     }
 
-  BSET (current_buffer, undo_list, Qt);
-  BSET (current_buffer, read_only, Qnil);
+  bset_undo_list (current_buffer, Qt);
+  bset_read_only (current_buffer, Qnil);
   specbind (Qinhibit_read_only, Qt);
   specbind (Qinhibit_modification_hooks, Qt);
 
@@ -10108,7 +10147,7 @@ unwind_with_echo_area_buffer (Lisp_Object vector)
       charpos = AREF (vector, 5);
       bytepos = AREF (vector, 6);
 
-      WSET (w, buffer, buffer);
+      wset_buffer (w, buffer);
       set_marker_both (w->pointm, buffer,
                        XFASTINT (charpos), XFASTINT (bytepos));
     }
@@ -10141,7 +10180,7 @@ setup_echo_area_for_printing (int multibyte_p)
 
       /* Switch to that buffer and clear it.  */
       set_buffer_internal (XBUFFER (echo_area_buffer[0]));
-      BSET (current_buffer, truncate_lines, Qnil);
+      bset_truncate_lines (current_buffer, Qnil);
 
       if (Z > BEG)
         {
@@ -10184,7 +10223,7 @@ setup_echo_area_for_printing (int multibyte_p)
         {
           /* Someone switched buffers between print requests.  */
           set_buffer_internal (XBUFFER (echo_area_buffer[0]));
-          BSET (current_buffer, truncate_lines, Qnil);
+          bset_truncate_lines (current_buffer, Qnil);
         }
     }
 }
@@ -10636,9 +10675,9 @@ set_message_1 (ptrdiff_t a1, Lisp_Object a2, ptrdiff_t nbytes, ptrdiff_t multiby
       != !NILP (BVAR (current_buffer, enable_multibyte_characters)))
     Fset_buffer_multibyte (message_enable_multibyte ? Qt : Qnil);
 
-  BSET (current_buffer, truncate_lines, message_truncate_lines ? Qt : Qnil);
+  bset_truncate_lines (current_buffer, message_truncate_lines ? Qt : Qnil);
   if (!NILP (BVAR (current_buffer, bidi_display_reordering)))
-    BSET (current_buffer, bidi_paragraph_direction, Qleft_to_right);
+    bset_bidi_paragraph_direction (current_buffer, Qleft_to_right);
 
   /* Insert new message at BEG.  */
   TEMP_SET_PT_BOTH (BEG, BEG_BYTE);
@@ -11328,7 +11367,7 @@ update_menu_bar (struct frame *f, int save_match_data, int hooks_run)
             }
 
           XSETFRAME (Vmenu_updating_frame, f);
-          FSET (f, menu_bar_items, menu_bar_items (FRAME_MENU_BAR_ITEMS (f)));
+          fset_menu_bar_items (f, menu_bar_items (FRAME_MENU_BAR_ITEMS (f)));
 
           /* Redisplay the menu bar in case we changed it.  */
 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) \
@@ -11541,7 +11580,7 @@ update_tool_bar (struct frame *f, int save_match_data)
                  may access f->tool_bar_items.  Make sure we update both
                  variables within BLOCK_INPUT so no such event interrupts.  */
               BLOCK_INPUT;
-              FSET (f, tool_bar_items, new_tool_bar);
+              fset_tool_bar_items (f, new_tool_bar);
               f->n_tool_bar_items = new_n_tool_bar;
               w->update_mode_line = 1;
               UNBLOCK_INPUT;
@@ -11583,8 +11622,8 @@ build_desired_tool_bar_string (struct frame *f)
 
   /* Reuse f->desired_tool_bar_string, if possible.  */
   if (size < size_needed || NILP (f->desired_tool_bar_string))
-    FSET (f, desired_tool_bar_string,
-          Fmake_string (make_number (size_needed), make_number (' ')));
+    fset_desired_tool_bar_string
+      (f, Fmake_string (make_number (size_needed), make_number (' ')));
   else
     {
       props = list4 (Qdisplay, Qnil, Qmenu_item, Qnil);
@@ -13320,12 +13359,12 @@ redisplay_internal (void)
               if ((it.glyph_row - 1)->displays_text_p)
                 {
                   if (XFASTINT (w->window_end_vpos) < this_line_vpos)
-                    WSET (w, window_end_vpos, make_number (this_line_vpos));
+                    wset_window_end_vpos (w, make_number (this_line_vpos));
                 }
               else if (XFASTINT (w->window_end_vpos) == this_line_vpos
                        && this_line_vpos > 0)
-                WSET (w, window_end_vpos, make_number (this_line_vpos - 1));
-              WSET (w, window_end_valid, Qnil);
+                wset_window_end_vpos (w, make_number (this_line_vpos - 1));
+              wset_window_end_valid (w, Qnil);
 
               /* Update hint: No need to try to scroll in update_window.  */
               w->desired_matrix->no_scrolling_p = 1;
@@ -13798,7 +13837,7 @@ mark_window_display_accurate_1 (struct window *w, int accurate_p)
 
   if (accurate_p)
     {
-      WSET (w, window_end_valid, w->buffer);
+      wset_window_end_valid (w, w->buffer);
       w->update_mode_line = 0;
     }
 }
@@ -14906,7 +14945,7 @@ try_scrolling (Lisp_Object window, int just_this_one_p,
       if (!just_this_one_p
           || current_buffer->clip_changed
           || BEG_UNCHANGED < CHARPOS (startp))
-        WSET (w, base_line_number, Qnil);
+        wset_base_line_number (w, Qnil);
 
       /* If cursor ends up on a partially visible line,
          treat that as being off the bottom of the screen.  */
@@ -15531,7 +15570,7 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
       if (XMARKER (w->start)->buffer == current_buffer)
         compute_window_start_on_continuation_line (w);
 
-      WSET (w, window_end_valid, Qnil);
+      wset_window_end_valid (w, Qnil);
     }
 
   /* Some sanity checks.  */
@@ -15642,11 +15681,11 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
 
       w->force_start = 0;
       w->vscroll = 0;
-      WSET (w, window_end_valid, Qnil);
+      wset_window_end_valid (w, Qnil);
 
       /* Forget any recorded base line for line number display.  */
       if (!buffer_unchanged_p)
-        WSET (w, base_line_number, Qnil);
+        wset_base_line_number (w, Qnil);
 
       /* Redisplay the mode line.  Select the buffer properly for that.
          Also, run the hook window-scroll-functions
@@ -15860,7 +15899,7 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
               || current_buffer->clip_changed
               || BEG_UNCHANGED < CHARPOS (startp))
             /* Forget any recorded base line for line number display.  */
-            WSET (w, base_line_number, Qnil);
+            wset_base_line_number (w, Qnil);
 
           if (!cursor_row_fully_visible_p (w, 1, 0))
             {
@@ -15931,7 +15970,7 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
 
   /* Forget any previously recorded base line for line number display.  */
   if (!buffer_unchanged_p)
-    WSET (w, base_line_number, Qnil);
+    wset_base_line_number (w, Qnil);
 
   /* Determine the window start relative to point.  */
   init_iterator (&it, w, PT, PT_BYTE, NULL, DEFAULT_FACE_ID);
@@ -16189,8 +16228,8 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
   if (!line_number_displayed
       && !BUFFERP (w->base_line_pos))
     {
-      WSET (w, base_line_pos, Qnil);
-      WSET (w, base_line_number, Qnil);
+      wset_base_line_pos (w, Qnil);
+      wset_base_line_number (w, Qnil);
     }
 
  finish_menu_bars:
@@ -16374,10 +16413,10 @@ try_window (Lisp_Object window, struct text_pos pos, int flags)
       eassert (MATRIX_ROW_DISPLAYS_TEXT_P (last_text_row));
       w->window_end_bytepos
         = Z_BYTE - MATRIX_ROW_END_BYTEPOS (last_text_row);
-      WSET (w, window_end_pos,
-            make_number (Z - MATRIX_ROW_END_CHARPOS (last_text_row)));
-      WSET (w, window_end_vpos,
-            make_number (MATRIX_ROW_VPOS (last_text_row, w->desired_matrix)));
+      wset_window_end_pos
+        (w, make_number (Z - MATRIX_ROW_END_CHARPOS (last_text_row)));
+      wset_window_end_vpos
+        (w, make_number (MATRIX_ROW_VPOS (last_text_row, w->desired_matrix)));
       eassert
         (MATRIX_ROW (w->desired_matrix,
                      XFASTINT (w->window_end_vpos))->displays_text_p);
@@ -16385,12 +16424,12 @@ try_window (Lisp_Object window, struct text_pos pos, int flags)
   else
     {
       w->window_end_bytepos = Z_BYTE - ZV_BYTE;
-      WSET (w, window_end_pos, make_number (Z - ZV));
-      WSET (w, window_end_vpos, make_number (0));
+      wset_window_end_pos (w, make_number (Z - ZV));
+      wset_window_end_vpos (w, make_number (0));
     }
 
   /* But that is not valid info until redisplay finishes.  */
-  WSET (w, window_end_valid, Qnil);
+  wset_window_end_valid (w, Qnil);
   return 1;
 }
 
@@ -16621,28 +16660,31 @@ try_window_reusing_current_matrix (struct window *w)
         {
           w->window_end_bytepos
             = Z_BYTE - MATRIX_ROW_END_BYTEPOS (last_reused_text_row);
-          WSET (w, window_end_pos,
-                make_number (Z - MATRIX_ROW_END_CHARPOS (last_reused_text_row)));
-          WSET (w, window_end_vpos,
-                make_number (MATRIX_ROW_VPOS (last_reused_text_row, w->current_matrix)));
+          wset_window_end_pos
+            (w, make_number (Z
+                             - MATRIX_ROW_END_CHARPOS (last_reused_text_row)));
+          wset_window_end_vpos
+            (w, make_number (MATRIX_ROW_VPOS (last_reused_text_row,
+                                              w->current_matrix)));
         }
       else if (last_text_row)
         {
           w->window_end_bytepos
             = Z_BYTE - MATRIX_ROW_END_BYTEPOS (last_text_row);
-          WSET (w, window_end_pos,
-                make_number (Z - MATRIX_ROW_END_CHARPOS (last_text_row)));
-          WSET (w, window_end_vpos,
-                make_number (MATRIX_ROW_VPOS (last_text_row, w->desired_matrix)));
+          wset_window_end_pos
+            (w, make_number (Z - MATRIX_ROW_END_CHARPOS (last_text_row)));
+          wset_window_end_vpos
+            (w, make_number (MATRIX_ROW_VPOS (last_text_row,
+                                              w->desired_matrix)));
         }
       else
         {
           /* This window must be completely empty.  */
           w->window_end_bytepos = Z_BYTE - ZV_BYTE;
-          WSET (w, window_end_pos, make_number (Z - ZV));
-          WSET (w, window_end_vpos, make_number (0));
+          wset_window_end_pos (w, make_number (Z - ZV));
+          wset_window_end_vpos (w, make_number (0));
         }
-      WSET (w, window_end_valid, Qnil);
+      wset_window_end_valid (w, Qnil);
 
       /* Update hint: don't try scrolling again in update_window.  */
       w->desired_matrix->no_scrolling_p = 1;
@@ -16823,18 +16865,19 @@ try_window_reusing_current_matrix (struct window *w)
         {
           w->window_end_bytepos
             = Z_BYTE - MATRIX_ROW_END_BYTEPOS (last_text_row);
-          WSET (w, window_end_pos,
-                make_number (Z - MATRIX_ROW_END_CHARPOS (last_text_row)));
-          WSET (w, window_end_vpos,
-                make_number (MATRIX_ROW_VPOS (last_text_row, w->desired_matrix)));
+          wset_window_end_pos
+            (w, make_number (Z - MATRIX_ROW_END_CHARPOS (last_text_row)));
+          wset_window_end_vpos
+            (w, make_number (MATRIX_ROW_VPOS (last_text_row,
+                                              w->desired_matrix)));
         }
       else
         {
-          WSET (w, window_end_vpos,
-                make_number (XFASTINT (w->window_end_vpos) - nrows_scrolled));
+          wset_window_end_vpos
+            (w, make_number (XFASTINT (w->window_end_vpos) - nrows_scrolled));
         }
 
-      WSET (w, window_end_valid, Qnil);
+      wset_window_end_valid (w, Qnil);
       w->desired_matrix->no_scrolling_p = 1;
 
 #ifdef GLYPH_DEBUG
@@ -17413,8 +17456,8 @@ try_window_id (struct window *w)
         {
           /* We have to compute the window end anew since text
              could have been added/removed after it.  */
-          WSET (w, window_end_pos,
-               make_number (Z - MATRIX_ROW_END_CHARPOS (row)));
+          wset_window_end_pos
+            (w, make_number (Z - MATRIX_ROW_END_CHARPOS (row)));
           w->window_end_bytepos
             = Z_BYTE - MATRIX_ROW_END_BYTEPOS (row);
 
@@ -17848,21 +17891,22 @@ try_window_id (struct window *w)
                                            first_unchanged_at_end_row);
       eassert (row && MATRIX_ROW_DISPLAYS_TEXT_P (row));
 
-      WSET (w, window_end_pos, make_number (Z - MATRIX_ROW_END_CHARPOS (row)));
+      wset_window_end_pos (w, make_number (Z - MATRIX_ROW_END_CHARPOS (row)));
       w->window_end_bytepos = Z_BYTE - MATRIX_ROW_END_BYTEPOS (row);
-      WSET (w, window_end_vpos,
-            make_number (MATRIX_ROW_VPOS (row, w->current_matrix)));
+      wset_window_end_vpos
+        (w, make_number (MATRIX_ROW_VPOS (row, w->current_matrix)));
       eassert (w->window_end_bytepos >= 0);
       IF_DEBUG (debug_method_add (w, "A"));
     }
   else if (last_text_row_at_end)
     {
-      WSET (w, window_end_pos,
-            make_number (Z - MATRIX_ROW_END_CHARPOS (last_text_row_at_end)));
+      wset_window_end_pos
+        (w, make_number (Z - MATRIX_ROW_END_CHARPOS (last_text_row_at_end)));
       w->window_end_bytepos
         = Z_BYTE - MATRIX_ROW_END_BYTEPOS (last_text_row_at_end);
-      WSET (w, window_end_vpos,
-            make_number (MATRIX_ROW_VPOS (last_text_row_at_end, desired_matrix)));
+      wset_window_end_vpos
+        (w, make_number (MATRIX_ROW_VPOS (last_text_row_at_end,
+                                          desired_matrix)));
       eassert (w->window_end_bytepos >= 0);
       IF_DEBUG (debug_method_add (w, "B"));
     }
@@ -17871,12 +17915,12 @@ try_window_id (struct window *w)
       /* We have displayed either to the end of the window or at the
          end of the window, i.e. the last row with text is to be found
          in the desired matrix.  */
-      WSET (w, window_end_pos,
-            make_number (Z - MATRIX_ROW_END_CHARPOS (last_text_row)));
+      wset_window_end_pos
+        (w, make_number (Z - MATRIX_ROW_END_CHARPOS (last_text_row)));
       w->window_end_bytepos
         = Z_BYTE - MATRIX_ROW_END_BYTEPOS (last_text_row);
-      WSET (w, window_end_vpos,
-            make_number (MATRIX_ROW_VPOS (last_text_row, desired_matrix)));
+      wset_window_end_vpos
+        (w, make_number (MATRIX_ROW_VPOS (last_text_row, desired_matrix)));
       eassert (w->window_end_bytepos >= 0);
     }
   else if (first_unchanged_at_end_row == NULL
@@ -17904,8 +17948,8 @@ try_window_id (struct window *w)
         }
 
       eassert (row != NULL);
-      WSET (w, window_end_vpos, make_number (vpos + 1));
-      WSET (w, window_end_pos, make_number (Z - MATRIX_ROW_END_CHARPOS (row)));
+      wset_window_end_vpos (w, make_number (vpos + 1));
+      wset_window_end_pos (w, make_number (Z - MATRIX_ROW_END_CHARPOS (row)));
       w->window_end_bytepos = Z_BYTE - MATRIX_ROW_END_BYTEPOS (row);
       eassert (w->window_end_bytepos >= 0);
       IF_DEBUG (debug_method_add (w, "C"));
@@ -17917,7 +17961,7 @@ try_window_id (struct window *w)
             debug_end_vpos = XFASTINT (w->window_end_vpos));
 
   /* Record that display has not been completed.  */
-  WSET (w, window_end_valid, Qnil);
+  wset_window_end_valid (w, Qnil);
   w->desired_matrix->no_scrolling_p = 1;
   return 3;
 
@@ -19353,7 +19397,7 @@ display_line (struct it *it)
     }
 
   /* Is IT->w showing the region?  */
-  WSET (it->w, region_showing, it->region_beg_charpos > 0 ? Qt : Qnil);
+  wset_region_showing (it->w, it->region_beg_charpos > 0 ? Qt : Qnil);
 
   /* Clear the result glyph row and enable it.  */
   prepare_desired_row (row);
@@ -20357,7 +20401,7 @@ display_mode_lines (struct window *w)
 
   /* These will be set while the mode line specs are processed.  */
   line_number_displayed = 0;
-  WSET (w, column_number_displayed, Qnil);
+  wset_column_number_displayed (w, Qnil);
 
   if (WINDOW_WANTS_MODELINE_P (w))
     {
@@ -21493,7 +21537,7 @@ decode_mode_spec (struct window *w, register int c, int field_width,
       else
         {
           ptrdiff_t col = current_column ();
-          WSET (w, column_number_displayed, make_number (col));
+          wset_column_number_displayed (w, make_number (col));
           pint2str (decode_mode_spec_buf, field_width, col);
           return decode_mode_spec_buf;
         }
@@ -21556,14 +21600,14 @@ decode_mode_spec (struct window *w, register int c, int field_width,
           goto no_value;
         /* But do forget it, if the window shows a different buffer now.  */
         else if (BUFFERP (w->base_line_pos))
-          WSET (w, base_line_pos, Qnil);
+          wset_base_line_pos (w, Qnil);
 
         /* If the buffer is very big, don't waste time.  */
         if (INTEGERP (Vline_number_display_limit)
             && BUF_ZV (b) - BUF_BEGV (b) > XINT (Vline_number_display_limit))
           {
-            WSET (w, base_line_pos, Qnil);
-            WSET (w, base_line_number, Qnil);
+            wset_base_line_pos (w, Qnil);
+            wset_base_line_number (w, Qnil);
             goto no_value;
           }
 
@@ -21595,8 +21639,8 @@ decode_mode_spec (struct window *w, register int c, int field_width,
            go back past it.  */
         if (startpos == BUF_BEGV (b))
           {
-            WSET (w, base_line_number, make_number (topline));
-            WSET (w, base_line_pos, make_number (BUF_BEGV (b)));
+            wset_base_line_number (w, make_number (topline));
+            wset_base_line_pos (w, make_number (BUF_BEGV (b)));
           }
         else if (nlines < height + 25 || nlines > height * 3 + 50
                  || linepos == BUF_BEGV (b))
@@ -21622,13 +21666,13 @@ decode_mode_spec (struct window *w, register int c, int field_width,
                give up on line numbers for this window.  */
             if (position == limit_byte && limit == startpos - distance)
               {
-                WSET (w, base_line_pos, w->buffer);
-                WSET (w, base_line_number, Qnil);
+                wset_base_line_pos (w, w->buffer);
+                wset_base_line_number (w, Qnil);
                 goto no_value;
               }
 
-            WSET (w, base_line_number, make_number (topline - nlines));
-            WSET (w, base_line_pos, make_number (BYTE_TO_CHAR (position)));
+            wset_base_line_number (w, make_number (topline - nlines));
+            wset_base_line_pos (w, make_number (BYTE_TO_CHAR (position)));
           }
 
         /* Now count lines from the start pos to point.  */
@@ -29540,12 +29584,13 @@ init_xdisp (void)
 
       echo_area_window = minibuf_window;
 
-      WSET (r, top_line, make_number (FRAME_TOP_MARGIN (f)));
-      WSET (r, total_lines, make_number (FRAME_LINES (f) - 1 - FRAME_TOP_MARGIN (f)));
-      WSET (r, total_cols, make_number (FRAME_COLS (f)));
-      WSET (m, top_line, make_number (FRAME_LINES (f) - 1));
-      WSET (m, total_lines, make_number (1));
-      WSET (m, total_cols, make_number (FRAME_COLS (f)));
+      wset_top_line (r, make_number (FRAME_TOP_MARGIN (f)));
+      wset_total_lines
+        (r, make_number (FRAME_LINES (f) - 1 - FRAME_TOP_MARGIN (f)));
+      wset_total_cols (r, make_number (FRAME_COLS (f)));
+      wset_top_line (m, make_number (FRAME_LINES (f) - 1));
+      wset_total_lines (m, make_number (1));
+      wset_total_cols (m, make_number (FRAME_COLS (f)));
 
       scratch_glyph_row.glyphs[TEXT_AREA] = scratch_glyphs;
       scratch_glyph_row.glyphs[TEXT_AREA + 1]
diff --git a/src/xfaces.c b/src/xfaces.c
index ed372c6b419..46121d66606 100644
--- a/src/xfaces.c
+++ b/src/xfaces.c
@@ -279,7 +279,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #endif /* HAVE_X_WINDOWS */
 
-#include <ctype.h>
+#include <c-ctype.h>
 
 /* Number of pt per inch (from the TeXbook).  */
 
@@ -2281,6 +2281,7 @@ merge_face_vectors (struct frame *f, Lisp_Object *from, Lisp_Object *to,
                     struct named_merge_point *named_merge_points)
 {
   int i;
+  Lisp_Object font = Qnil;
 
   /* If FROM inherits from some other faces, merge their attributes into
      TO before merging FROM's direct attributes.  Note that an :inherit
@@ -2291,24 +2292,13 @@ merge_face_vectors (struct frame *f, Lisp_Object *from, Lisp_Object *to,
       && !NILP (from[LFACE_INHERIT_INDEX]))
     merge_face_ref (f, from[LFACE_INHERIT_INDEX], to, 0, named_merge_points);
 
-  i = LFACE_FONT_INDEX;
-  if (!UNSPECIFIEDP (from[i]))
+  if (FONT_SPEC_P (from[LFACE_FONT_INDEX]))
     {
-      if (!UNSPECIFIEDP (to[i]))
-        to[i] = merge_font_spec (from[i], to[i]);
+      if (!UNSPECIFIEDP (to[LFACE_FONT_INDEX]))
+        font = merge_font_spec (from[LFACE_FONT_INDEX], to[LFACE_FONT_INDEX]);
       else
-        to[i] = copy_font_spec (from[i]);
-      if (! NILP (AREF (to[i], FONT_FOUNDRY_INDEX)))
-        to[LFACE_FOUNDRY_INDEX] = SYMBOL_NAME (AREF (to[i], FONT_FOUNDRY_INDEX));
-      if (! NILP (AREF (to[i], FONT_FAMILY_INDEX)))
-        to[LFACE_FAMILY_INDEX] = SYMBOL_NAME (AREF (to[i], FONT_FAMILY_INDEX));
-      if (! NILP (AREF (to[i], FONT_WEIGHT_INDEX)))
-        to[LFACE_WEIGHT_INDEX] = FONT_WEIGHT_FOR_FACE (to[i]);
-      if (! NILP (AREF (to[i], FONT_SLANT_INDEX)))
-        to[LFACE_SLANT_INDEX] = FONT_SLANT_FOR_FACE (to[i]);
-      if (! NILP (AREF (to[i], FONT_WIDTH_INDEX)))
-        to[LFACE_SWIDTH_INDEX] = FONT_WIDTH_FOR_FACE (to[i]);
-      ASET (to[i], FONT_SIZE_INDEX, Qnil);
+        font = copy_font_spec (from[LFACE_FONT_INDEX]);
+      to[LFACE_FONT_INDEX] = font;
     }
 
   for (i = 1; i < LFACE_VECTOR_SIZE; ++i)
@@ -2319,8 +2309,7 @@ merge_face_vectors (struct frame *f, Lisp_Object *from, Lisp_Object *to,
             to[i] = merge_face_heights (from[i], to[i], to[i]);
             font_clear_prop (to, FONT_SIZE_INDEX);
           }
-        else if (i != LFACE_FONT_INDEX
-                 && ! EQ (to[i], from[i]))
+        else if (i != LFACE_FONT_INDEX && ! EQ (to[i], from[i]))
           {
             to[i] = from[i];
             if (i >= LFACE_FAMILY_INDEX && i <=LFACE_SLANT_INDEX)
@@ -2334,6 +2323,25 @@ merge_face_vectors (struct frame *f, Lisp_Object *from, Lisp_Object *to,
           }
       }
 
+  /* If FROM specifies a font spec, make its contents take precedence
+     over :family and other attributes.  This is needed for face
+     remapping using :font to work.  */
+
+  if (!NILP (font))
+    {
+      if (! NILP (AREF (font, FONT_FOUNDRY_INDEX)))
+        to[LFACE_FOUNDRY_INDEX] = SYMBOL_NAME (AREF (font, FONT_FOUNDRY_INDEX));
+      if (! NILP (AREF (font, FONT_FAMILY_INDEX)))
+        to[LFACE_FAMILY_INDEX] = SYMBOL_NAME (AREF (font, FONT_FAMILY_INDEX));
+      if (! NILP (AREF (font, FONT_WEIGHT_INDEX)))
+        to[LFACE_WEIGHT_INDEX] = FONT_WEIGHT_FOR_FACE (font);
+      if (! NILP (AREF (font, FONT_SLANT_INDEX)))
+        to[LFACE_SLANT_INDEX] = FONT_SLANT_FOR_FACE (font);
+      if (! NILP (AREF (font, FONT_WIDTH_INDEX)))
+        to[LFACE_SWIDTH_INDEX] = FONT_WIDTH_FOR_FACE (font);
+      ASET (font, FONT_SIZE_INDEX, Qnil);
+    }
+
   /* TO is always an absolute face, which should inherit from nothing.
      We blindly copy the :inherit attribute above and fix it up here.  */
   to[LFACE_INHERIT_INDEX] = Qnil;
@@ -2575,6 +2583,13 @@ merge_face_ref (struct frame *f, Lisp_Object face_ref, Lisp_Object *to,
                   else
                     err = 1;
                 }
+              else if (EQ (keyword, QCfont))
+                {
+                  if (FONTP (value))
+                    to[LFACE_FONT_INDEX] = value;
+                  else
+                    err = 1;
+                }
               else if (EQ (keyword, QCinherit))
                 {
                   /* This is not really very useful; it's just like a
@@ -2680,7 +2695,7 @@ Value is a vector of face attributes.  */)
           lface = Fmake_vector (make_number (LFACE_VECTOR_SIZE),
                                 Qunspecified);
           ASET (lface, 0, Qface);
-          FSET (f, face_alist, Fcons (Fcons (face, lface), f->face_alist));
+          fset_face_alist (f, Fcons (Fcons (face, lface), f->face_alist));
         }
       else
         for (i = 1; i < LFACE_VECTOR_SIZE; ++i)
@@ -4059,7 +4074,7 @@ hash_string_case_insensitive (Lisp_Object string)
   unsigned hash = 0;
   eassert (STRINGP (string));
   for (s = SDATA (string); *s; ++s)
-    hash = (hash << 1) ^ tolower (*s);
+    hash = (hash << 1) ^ c_tolower (*s);
   return hash;
 }
 
diff --git a/src/xfns.c b/src/xfns.c
index 2e7334b7d71..90b54d12345 100644
--- a/src/xfns.c
+++ b/src/xfns.c
@@ -49,7 +49,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #ifdef HAVE_X_WINDOWS
 
-#include <ctype.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 
@@ -659,7 +658,7 @@ x_set_tool_bar_position (struct frame *f,
 
 #ifdef USE_GTK
   if (xg_change_toolbar_position (f, new_value))
-    FSET (f, tool_bar_position, new_value);
+    fset_tool_bar_position (f, new_value);
 #endif
 }
 
@@ -1146,7 +1145,7 @@ x_set_icon_name (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
   else if (!NILP (arg) || NILP (oldval))
     return;
 
-  FSET (f, icon_name, arg);
+  fset_icon_name (f, arg);
 
   if (f->output_data.x->icon_bitmap != 0)
     return;
@@ -1637,7 +1636,7 @@ x_set_name (struct frame *f, Lisp_Object name, int explicit)
   if (! NILP (Fstring_equal (name, f->name)))
     return;
 
-  FSET (f, name, name);
+  fset_name (f, name);
 
   /* For setting the frame title, the title parameter should override
      the name parameter.  */
@@ -1677,7 +1676,7 @@ x_set_title (struct frame *f, Lisp_Object name, Lisp_Object old_name)
 
   update_mode_lines = 1;
 
-  FSET (f, title, name);
+  fset_title (f, name);
 
   if (NILP (name))
     name = f->name;
@@ -2566,7 +2565,7 @@ x_window (struct frame *f, long window_prompting, int minibuffer_only)
 
     f->explicit_name = 0;
     name = f->name;
-    FSET (f, name, Qnil);
+    fset_name (f, Qnil);
     x_set_name (f, name, explicit);
   }
 
@@ -2709,7 +2708,7 @@ x_window (struct frame *f)
 
     f->explicit_name = 0;
     name = f->name;
-    FSET (f, name, Qnil);
+    fset_name (f, Qnil);
     x_set_name (f, name, explicit);
   }
 
@@ -3129,11 +3128,11 @@ This function is an internal primitive--use `make-frame' instead.  */)
   f->output_data.x->scroll_bar_bottom_shadow_pixel = -1;
 #endif /* USE_TOOLKIT_SCROLL_BARS */
 
-  FSET (f, icon_name,
-        x_get_arg (dpyinfo, parms, Qicon_name, "iconName", "Title",
-                   RES_TYPE_STRING));
+  fset_icon_name (f,
+                  x_get_arg (dpyinfo, parms, Qicon_name, "iconName", "Title",
+                             RES_TYPE_STRING));
   if (! STRINGP (f->icon_name))
-    FSET (f, icon_name, Qnil);
+    fset_icon_name (f, Qnil);
 
   FRAME_X_DISPLAY_INFO (f) = dpyinfo;
 
@@ -3190,12 +3189,12 @@ This function is an internal primitive--use `make-frame' instead.  */)
      be set.  */
   if (EQ (name, Qunbound) || NILP (name))
     {
-      FSET (f, name, build_string (dpyinfo->x_id_name));
+      fset_name (f, build_string (dpyinfo->x_id_name));
       f->explicit_name = 0;
     }
   else
     {
-      FSET (f, name, name);
+      fset_name (f, name);
       f->explicit_name = 1;
       /* use the frame's title when getting resources for this frame.  */
       specbind (Qx_resource_name, name);
@@ -3456,13 +3455,13 @@ This function is an internal primitive--use `make-frame' instead.  */)
   if (FRAME_HAS_MINIBUF_P (f)
       && (!FRAMEP (KVAR (kb, Vdefault_minibuffer_frame))
           || !FRAME_LIVE_P (XFRAME (KVAR (kb, Vdefault_minibuffer_frame)))))
-    KSET (kb, Vdefault_minibuffer_frame, frame);
+    kset_default_minibuffer_frame (kb, frame);
 
   /* All remaining specified parameters, which have not been "used"
      by x_get_arg and friends, now go in the misc. alist of the frame.  */
   for (tem = parms; CONSP (tem); tem = XCDR (tem))
     if (CONSP (XCAR (tem)) && !NILP (XCAR (XCAR (tem))))
-      FSET (f, param_alist, Fcons (XCAR (tem), f->param_alist));
+      fset_param_alist (f, Fcons (XCAR (tem), f->param_alist));
 
   UNGCPRO;
 
@@ -4591,7 +4590,7 @@ x_create_tip_frame (struct x_display_info *dpyinfo,
   set_window_buffer (FRAME_ROOT_WINDOW (f), buffer, 0, 0);
   old_buffer = current_buffer;
   set_buffer_internal_1 (XBUFFER (buffer));
-  BSET (current_buffer, truncate_lines, Qnil);
+  bset_truncate_lines (current_buffer, Qnil);
   specbind (Qinhibit_read_only, Qt);
   specbind (Qinhibit_modification_hooks, Qt);
   Ferase_buffer ();
@@ -4617,7 +4616,7 @@ x_create_tip_frame (struct x_display_info *dpyinfo,
   f->output_data.x->scroll_bar_top_shadow_pixel = -1;
   f->output_data.x->scroll_bar_bottom_shadow_pixel = -1;
 #endif /* USE_TOOLKIT_SCROLL_BARS */
-  FSET (f, icon_name, Qnil);
+  fset_icon_name (f, Qnil);
   FRAME_X_DISPLAY_INFO (f) = dpyinfo;
   f->output_data.x->parent_desc = FRAME_X_DISPLAY_INFO (f)->root_window;
   f->output_data.x->explicit_parent = 0;
@@ -4659,12 +4658,12 @@ x_create_tip_frame (struct x_display_info *dpyinfo,
      be set.  */
   if (EQ (name, Qunbound) || NILP (name))
     {
-      FSET (f, name, build_string (dpyinfo->x_id_name));
+      fset_name (f, build_string (dpyinfo->x_id_name));
       f->explicit_name = 0;
     }
   else
     {
-      FSET (f, name, name);
+      fset_name (f, name);
       f->explicit_name = 1;
       /* use the frame's title when getting resources for this frame.  */
       specbind (Qx_resource_name, name);
@@ -5065,20 +5064,20 @@ Text larger than the specified size is clipped.  */)
 
   /* Set up the frame's root window.  */
   w = XWINDOW (FRAME_ROOT_WINDOW (f));
-  WSET (w, left_col, make_number (0));
-  WSET (w, top_line, make_number (0));
+  wset_left_col (w, make_number (0));
+  wset_top_line (w, make_number (0));
 
   if (CONSP (Vx_max_tooltip_size)
       && RANGED_INTEGERP (1, XCAR (Vx_max_tooltip_size), INT_MAX)
       && RANGED_INTEGERP (1, XCDR (Vx_max_tooltip_size), INT_MAX))
     {
-      WSET (w, total_cols, XCAR (Vx_max_tooltip_size));
-      WSET (w, total_lines, XCDR (Vx_max_tooltip_size));
+      wset_total_cols (w, XCAR (Vx_max_tooltip_size));
+      wset_total_lines (w, XCDR (Vx_max_tooltip_size));
     }
   else
     {
-      WSET (w, total_cols, make_number (80));
-      WSET (w, total_lines, make_number (40));
+      wset_total_cols (w, make_number (80));
+      wset_total_lines (w, make_number (40));
     }
 
   FRAME_TOTAL_COLS (f) = XINT (w->total_cols);
@@ -5088,7 +5087,7 @@ Text larger than the specified size is clipped.  */)
   /* Display the tooltip text in a temporary buffer.  */
   old_buffer = current_buffer;
   set_buffer_internal_1 (XBUFFER (XWINDOW (FRAME_ROOT_WINDOW (f))->buffer));
-  BSET (current_buffer, truncate_lines, Qnil);
+  bset_truncate_lines (current_buffer, Qnil);
   clear_glyph_matrix (w->desired_matrix);
   clear_glyph_matrix (w->current_matrix);
   SET_TEXT_POS (pos, BEGV, BEGV_BYTE);
@@ -5148,7 +5147,7 @@ Text larger than the specified size is clipped.  */)
       /* w->total_cols and FRAME_TOTAL_COLS want the width in columns,
          not in pixels.  */
       width /= WINDOW_FRAME_COLUMN_WIDTH (w);
-      WSET (w, total_cols, make_number (width));
+      wset_total_cols (w, make_number (width));
       FRAME_TOTAL_COLS (f) = width;
       adjust_glyphs (f);
       clear_glyph_matrix (w->desired_matrix);
diff --git a/src/xfont.c b/src/xfont.c
index 9e929eed678..072bce7bb0a 100644
--- a/src/xfont.c
+++ b/src/xfont.c
@@ -823,6 +823,7 @@ xfont_open (FRAME_PTR f, Lisp_Object entity, int pixel_size)
   font->descent = xfont->descent;
   font->height = font->ascent + font->descent;
   font->min_width = xfont->min_bounds.width;
+  font->max_width = xfont->max_bounds.width;
   if (xfont->min_bounds.width == xfont->max_bounds.width)
     {
       /* Fixed width font.  */
diff --git a/src/xftfont.c b/src/xftfont.c
index 2f8125393bc..5e60ab0c4d3 100644
--- a/src/xftfont.c
+++ b/src/xftfont.c
@@ -39,7 +39,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 /* Xft font driver.  */
 
-static Lisp_Object Qxft;
+Lisp_Object Qxft;
 static Lisp_Object QChinting, QCautohint, QChintstyle, QCrgba, QCembolden,
   QClcdfilter;
 
@@ -414,20 +414,25 @@ xftfont_open (FRAME_PTR f, Lisp_Object entity, int pixel_size)
         ascii_printable[ch] = ' ' + ch;
     }
   BLOCK_INPUT;
+
+  /* Unfortunately Xft doesn't provide a way to get minimum char
+     width.  So, we set min_width to space_width.  */
+
   if (spacing != FC_PROPORTIONAL
 #ifdef FC_DUAL
       && spacing != FC_DUAL
 #endif  /* FC_DUAL */
       )
     {
-      font->min_width = font->average_width = font->space_width
-        = xftfont->max_advance_width;
+      font->min_width = font->max_width = font->average_width
+        = font->space_width = xftfont->max_advance_width;
       XftTextExtents8 (display, xftfont, ascii_printable + 1, 94, &extents);
     }
   else
     {
       XftTextExtents8 (display, xftfont, ascii_printable, 1, &extents);
-      font->space_width = extents.xOff;
+      font->min_width = font->max_width = font->space_width
+        = extents.xOff;
       if (font->space_width <= 0)
         /* dirty workaround */
         font->space_width = pixel_size;
@@ -470,10 +475,6 @@ xftfont_open (FRAME_PTR f, Lisp_Object entity, int pixel_size)
 #endif  /* HAVE_LIBOTF */
   xftfont_info->ft_size = ft_face->size;
 
-  /* Unfortunately Xft doesn't provide a way to get minimum char
-     width.  So, we use space_width instead.  */
-  font->min_width = font->space_width;
-
   font->baseline_offset = 0;
   font->relative_compose = 0;
   font->default_ascent = 0;
@@ -764,6 +765,8 @@ syms_of_xftfont (void)
   DEFSYM (QCembolden, ":embolden");
   DEFSYM (QClcdfilter, ":lcdfilter");
 
+  ascii_printable[0] = 0;
+
   xftfont_driver = ftfont_driver;
   xftfont_driver.type = Qxft;
   xftfont_driver.get_cache = xfont_driver.get_cache;
diff --git a/src/xmenu.c b/src/xmenu.c
index ab790094f85..54a7849218a 100644
--- a/src/xmenu.c
+++ b/src/xmenu.c
@@ -1008,7 +1008,7 @@ set_frame_menubar (FRAME_PTR f, int first_time, int deep_p)
       if (! NILP (Vlucid_menu_bar_dirty_flag))
         call0 (Qrecompute_lucid_menubar);
       safe_run_hooks (Qmenu_bar_update_hook);
-      FSET (f, menu_bar_items, menu_bar_items (FRAME_MENU_BAR_ITEMS (f)));
+      fset_menu_bar_items (f, menu_bar_items (FRAME_MENU_BAR_ITEMS (f)));
 
       items = FRAME_MENU_BAR_ITEMS (f);
 
@@ -1100,7 +1100,7 @@ set_frame_menubar (FRAME_PTR f, int first_time, int deep_p)
         }
 
       /* The menu items are different, so store them in the frame.  */
-      FSET (f, menu_bar_vector, menu_items);
+      fset_menu_bar_vector (f, menu_items);
       f->menu_bar_items_used = menu_items_used;
 
       /* This undoes save_menu_items.  */
@@ -1283,7 +1283,7 @@ initialize_frame_menubar (FRAME_PTR f)
 {
   /* This function is called before the first chance to redisplay
      the frame.  It has to be, so the frame will have the right size.  */
-  FSET (f, menu_bar_items, menu_bar_items (FRAME_MENU_BAR_ITEMS (f)));
+  fset_menu_bar_items (f, menu_bar_items (FRAME_MENU_BAR_ITEMS (f)));
   set_frame_menubar (f, 1, 1);
 }
 
diff --git a/src/xselect.c b/src/xselect.c
index 664b5f92a15..463bd6e37b0 100644
--- a/src/xselect.c
+++ b/src/xselect.c
@@ -353,8 +353,9 @@ x_own_selection (Lisp_Object selection_name, Lisp_Object selection_value,
                             INTEGER_TO_CONS (timestamp), frame);
     prev_value = LOCAL_SELECTION (selection_name, dpyinfo);
 
-    TSET (dpyinfo->terminal, Vselection_alist,
-          Fcons (selection_data, dpyinfo->terminal->Vselection_alist));
+    tset_selection_alist
+      (dpyinfo->terminal,
+       Fcons (selection_data, dpyinfo->terminal->Vselection_alist));
 
     /* If we already owned the selection, remove the old selection
        data.  Don't use Fdelq as that may QUIT.  */
@@ -989,7 +990,7 @@ x_handle_selection_clear (struct input_event *event)
             break;
           }
     }
-  TSET (dpyinfo->terminal, Vselection_alist, Vselection_alist);
+  tset_selection_alist (dpyinfo->terminal, Vselection_alist);
 
   /* Run the `x-lost-selection-functions' abnormal hook.  */
   {
@@ -1039,7 +1040,7 @@ x_clear_frame_selections (FRAME_PTR f)
       args[1] = Fcar (Fcar (t->Vselection_alist));
       Frun_hook_with_args (2, args);
 
-      TSET (t, Vselection_alist, XCDR (t->Vselection_alist));
+      tset_selection_alist (t, XCDR (t->Vselection_alist));
     }
 
   /* Delete elements after the beginning of Vselection_alist.  */
diff --git a/src/xterm.c b/src/xterm.c
index 2e71ccd94a0..c5a916d9d2e 100644
--- a/src/xterm.c
+++ b/src/xterm.c
@@ -50,7 +50,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "systime.h"
 
 #include <fcntl.h>
-#include <ctype.h>
 #include <errno.h>
 #include <setjmp.h>
 #include <sys/stat.h>
@@ -3594,7 +3593,7 @@ x_frame_rehighlight (struct x_display_info *dpyinfo)
            : dpyinfo->x_focus_frame);
       if (! FRAME_LIVE_P (dpyinfo->x_highlight_frame))
         {
-          FSET (dpyinfo->x_focus_frame, focus_frame, Qnil);
+          fset_focus_frame (dpyinfo->x_focus_frame, Qnil);
           dpyinfo->x_highlight_frame = dpyinfo->x_focus_frame;
         }
     }
@@ -5028,7 +5027,7 @@ x_scroll_bar_create (struct window *w, int top, int left, int width, int height)
   bar->next = FRAME_SCROLL_BARS (f);
   bar->prev = Qnil;
   XSETVECTOR (barobj, bar);
-  FSET (f, scroll_bars, barobj);
+  fset_scroll_bars (f, barobj);
   if (!NILP (bar->next))
     XSETVECTOR (XSCROLL_BAR (bar->next)->prev, bar);
 
@@ -5191,7 +5190,7 @@ x_scroll_bar_remove (struct scroll_bar *bar)
 #endif
 
   /* Dissociate this scroll bar from its window.  */
-  WSET (XWINDOW (bar->window), vertical_scroll_bar, Qnil);
+  wset_vertical_scroll_bar (XWINDOW (bar->window), Qnil);
 
   UNBLOCK_INPUT;
 }
@@ -5405,7 +5404,7 @@ XTset_vertical_scroll_bar (struct window *w, int portion, int whole, int positio
 #endif /* not USE_TOOLKIT_SCROLL_BARS */
 
   XSETVECTOR (barobj, bar);
-  WSET (w, vertical_scroll_bar, barobj);
+  wset_vertical_scroll_bar (w, barobj);
 }
 
 
@@ -5429,12 +5428,12 @@ XTcondemn_scroll_bars (FRAME_PTR frame)
     {
       Lisp_Object bar;
       bar = FRAME_SCROLL_BARS (frame);
-      FSET (frame, scroll_bars, XSCROLL_BAR (bar)->next);
+      fset_scroll_bars (frame, XSCROLL_BAR (bar)->next);
       XSCROLL_BAR (bar)->next = FRAME_CONDEMNED_SCROLL_BARS (frame);
       XSCROLL_BAR (bar)->prev = Qnil;
       if (! NILP (FRAME_CONDEMNED_SCROLL_BARS (frame)))
         XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame))->prev = bar;
-      FSET (frame, condemned_scroll_bars, bar);
+      fset_condemned_scroll_bars (frame, bar);
     }
 }
 
@@ -5466,7 +5465,7 @@ XTredeem_scroll_bar (struct window *window)
         return;
       else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f),
                    window->vertical_scroll_bar))
-        FSET (f, condemned_scroll_bars, bar->next);
+        fset_condemned_scroll_bars (f, bar->next);
       else
         /* If its prev pointer is nil, it must be at the front of
            one or the other!  */
@@ -5481,7 +5480,7 @@ XTredeem_scroll_bar (struct window *window)
   bar->next = FRAME_SCROLL_BARS (f);
   bar->prev = Qnil;
   XSETVECTOR (barobj, bar);
-  FSET (f, scroll_bars, barobj);
+  fset_scroll_bars (f, barobj);
   if (! NILP (bar->next))
     XSETVECTOR (XSCROLL_BAR (bar->next)->prev, bar);
 }
@@ -5498,7 +5497,7 @@ XTjudge_scroll_bars (FRAME_PTR f)
 
   /* Clear out the condemned list now so we won't try to process any
      more events on the hapless scroll bars.  */
-  FSET (f, condemned_scroll_bars, Qnil);
+  fset_condemned_scroll_bars (f, Qnil);
 
   for (; ! NILP (bar); bar = next)
     {
@@ -7849,7 +7848,7 @@ x_connection_closed (Display *dpy, const char *error_message)
       {
         /* Set this to t so that delete_frame won't get confused
            trying to find a replacement.  */
-        KSET (FRAME_KBOARD (XFRAME (frame)), Vdefault_minibuffer_frame, Qt);
+        kset_default_minibuffer_frame (FRAME_KBOARD (XFRAME (frame)), Qt);
         delete_frame (frame, Qnoelisp);
       }
 
@@ -10133,7 +10132,7 @@ x_term_init (Lisp_Object display_name, char *xrm_option, char *resource_name)
       {
         terminal->kboard = xmalloc (sizeof *terminal->kboard);
         init_kboard (terminal->kboard);
-        KSET (terminal->kboard, Vwindow_system, Qx);
+        kset_window_system (terminal->kboard, Qx);
 
         /* Add the keyboard to the list before running Lisp code (via
            Qvendor_specific_keysyms below), since these are not traced
@@ -10155,9 +10154,10 @@ x_term_init (Lisp_Object display_name, char *xrm_option, char *resource_name)
             /* Temporarily hide the partially initialized terminal.  */
             terminal_list = terminal->next_terminal;
             UNBLOCK_INPUT;
-            KSET (terminal->kboard, Vsystem_key_alist,
-                  call1 (Qvendor_specific_keysyms,
-                         vendor ? build_string (vendor) : empty_unibyte_string));
+            kset_system_key_alist
+              (terminal->kboard,
+               call1 (Qvendor_specific_keysyms,
+                      vendor ? build_string (vendor) : empty_unibyte_string));
             BLOCK_INPUT;
             terminal->next_terminal = terminal_list;
             terminal_list = terminal;