upstream

26 files changed, 1669 insertions, 495 deletions

diff --git a/src/.gdbinit b/src/.gdbinit
new file mode 100644
index 00000000000..e1ee81e66b5
--- /dev/null
+++ b/src/.gdbinit
@@ -0,0 +1,1273 @@
+# Copyright (C) 1992-1998, 2000-2012  Free Software Foundation, Inc.
+#
+# This file is part of GNU Emacs.
+#
+# GNU Emacs is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3, or (at your option)
+# any later version.
+#
+# GNU Emacs is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with GNU Emacs; see the file COPYING.  If not, write to the
+# Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+# Boston, MA 02110-1301, USA.
+
+# Force loading of symbols, enough to give us VALBITS etc.
+set $dummy = main + 8
+# With some compilers, we need this to give us struct Lisp_Symbol etc.:
+set $dummy = Fmake_symbol + 8
+
+# Find lwlib source files too.
+dir ../lwlib
+#dir /gd/gnu/lesstif-0.89.9/lib/Xm
+
+# Don't enter GDB when user types C-g to quit.
+# This has one unfortunate effect: you can't type C-c
+# at the GDB to stop Emacs, when using X.
+# However, C-z works just as well in that case.
+handle 2 noprint pass
+
+# Make it work like SIGINT normally does.
+handle SIGTSTP nopass
+
+# Pass on user signals
+handle SIGUSR1 noprint pass
+handle SIGUSR2 noprint pass
+
+# Don't pass SIGALRM to Emacs.  This makes problems when
+# debugging.
+handle SIGALRM ignore
+
+# Use $bugfix so that the value isn't a constant.
+# Using a constant runs into GDB bugs sometimes.
+define xgetptr
+  if (CHECK_LISP_OBJECT_TYPE)
+    set $bugfix = $arg0.i
+  else
+    set $bugfix = $arg0
+  end
+  set $ptr = ($bugfix & VALMASK) | DATA_SEG_BITS
+end
+
+define xgetint
+  if (CHECK_LISP_OBJECT_TYPE)
+    set $bugfix = $arg0.i
+  else
+    set $bugfix = $arg0
+  end
+  set $int = $bugfix << (USE_LSB_TAG ? 0 : INTTYPEBITS) >> INTTYPEBITS
+end
+
+define xgettype
+  if (CHECK_LISP_OBJECT_TYPE)
+    set $bugfix = $arg0.i
+  else
+    set $bugfix = $arg0
+  end
+  set $type = (enum Lisp_Type) (USE_LSB_TAG ? $bugfix & (1 << GCTYPEBITS) - 1 : $bugfix >> VALBITS)
+end
+
+# Set up something to print out s-expressions.
+# We save and restore print_output_debug_flag to prevent the w32 port
+# from calling OutputDebugString, which causes GDB to display each
+# character twice (yuk!).
+define pr
+  pp $
+end
+document pr
+Print the emacs s-expression which is $.
+Works only when an inferior emacs is executing.
+end
+
+# Print out s-expressions
+define pp
+  set $tmp = $arg0
+  set $output_debug = print_output_debug_flag
+  set print_output_debug_flag = 0
+  call safe_debug_print ($tmp)
+  set print_output_debug_flag = $output_debug
+end
+document pp
+Print the argument as an emacs s-expression
+Works only when an inferior emacs is executing.
+end
+
+# Print value of lisp variable
+define pv
+  set $tmp = "$arg0"
+  set $output_debug = print_output_debug_flag
+  set print_output_debug_flag = 0
+  call safe_debug_print (find_symbol_value (intern ($tmp)))
+  set print_output_debug_flag = $output_debug
+end
+document pv
+Print the value of the lisp variable given as argument.
+Works only when an inferior emacs is executing.
+end
+
+# Print out current buffer point and boundaries
+define ppt
+  set $b = current_buffer
+  set $t = $b->text
+  printf "BUF PT: %d", $b->pt
+  if ($b->pt != $b->pt_byte)
+    printf "[%d]", $b->pt_byte
+  end
+  printf " of 1..%d", $t->z
+  if ($t->z != $t->z_byte)
+    printf "[%d]", $t->z_byte
+  end
+  if ($b->begv != 1 || $b->zv != $t->z)
+    printf " NARROW=%d..%d", $b->begv, $b->zv
+    if ($b->begv != $b->begv_byte || $b->zv != $b->zv_byte)
+      printf " [%d..%d]", $b->begv_byte, $b->zv_byte
+    end
+  end
+  printf " GAP: %d", $t->gpt
+  if ($t->gpt != $t->gpt_byte)
+    printf "[%d]", $t->gpt_byte
+  end
+  printf " SZ=%d\n", $t->gap_size
+end
+document ppt
+Print current buffer's point and boundaries.
+Prints values of point, beg, end, narrow, and gap for current buffer.
+end
+
+define pitmethod
+  set $itmethod = $arg0
+  # output $itmethod
+  if ($itmethod == 0)
+    printf "GET_FROM_BUFFER"
+  end
+  if ($itmethod == 1)
+    printf "GET_FROM_DISPLAY_VECTOR"
+  end
+  if ($itmethod == 2)
+    printf "GET_FROM_STRING"
+  end
+  if ($itmethod == 3)
+    printf "GET_FROM_C_STRING"
+  end
+  if ($itmethod == 4)
+    printf "GET_FROM_IMAGE"
+  end
+  if ($itmethod == 5)
+    printf "GET_FROM_STRETCH"
+  end
+  if ($itmethod < 0 || $itmethod > 5)
+    output $itmethod
+  end
+end
+document pitmethod
+Pretty print it->method given as first arg
+end
+
+# Print out iterator given as first arg
+define pitx
+  set $it = $arg0
+  printf "cur=%d", $it->current.pos.charpos
+  if ($it->current.pos.charpos != $it->current.pos.bytepos)
+    printf "[%d]", $it->current.pos.bytepos
+  end
+  printf " pos=%d", $it->position.charpos
+  if ($it->position.charpos != $it->position.bytepos)
+    printf "[%d]", $it->position.bytepos
+  end
+  printf " start=%d", $it->start.pos.charpos
+  if ($it->start.pos.charpos != $it->start.pos.bytepos)
+    printf "[%d]", $it->start.pos.bytepos
+  end
+  printf " end=%d", $it->end_charpos
+  printf " stop=%d", $it->stop_charpos
+  printf " face=%d", $it->face_id
+  if ($it->multibyte_p)
+    printf " MB"
+  end
+  if ($it->header_line_p)
+    printf " HL"
+  end
+  if ($it->n_overlay_strings > 0)
+    printf " nov=%d", $it->n_overlay_strings
+  end
+  if ($it->sp != 0)
+    printf " sp=%d", $it->sp
+  end
+  # IT_CHARACTER
+  if ($it->what == 0)
+    if ($it->len == 1 && $it->c >= ' ' && it->c < 255)
+      printf " ch='%c'", $it->c
+    else
+      printf " ch=[%d,%d]", $it->c, $it->len
+    end
+  else
+    printf " "
+    # output $it->what
+    if ($it->what == 0)
+      printf "IT_CHARACTER"
+    end
+    if ($it->what == 1)
+      printf "IT_COMPOSITION"
+    end
+    if ($it->what == 2)
+      printf "IT_IMAGE"
+    end
+    if ($it->what == 3)
+      printf "IT_STRETCH"
+    end
+    if ($it->what == 4)
+      printf "IT_EOB"
+    end
+    if ($it->what == 5)
+      printf "IT_TRUNCATION"
+    end
+    if ($it->what == 6)
+      printf "IT_CONTINUATION"
+    end
+    if ($it->what < 0 || $it->what > 6)
+      output $it->what
+    end
+  end
+  if ($it->method != 0)
+    # !GET_FROM_BUFFER
+    printf " next="
+    pitmethod $it->method
+    if ($it->method == 2)
+      # GET_FROM_STRING
+      printf "[%d]", $it->current.string_pos.charpos
+    end
+    if ($it->method == 4)
+      # GET_FROM_IMAGE
+      printf "[%d]", $it->image_id
+    end
+  end
+  printf "\n"
+  if ($it->bidi_p)
+    printf "BIDI: base_stop=%d prev_stop=%d level=%d\n", $it->base_level_stop, $it->prev_stop, $it->bidi_it.resolved_level
+  end
+  if ($it->region_beg_charpos >= 0)
+    printf "reg=%d-%d ", $it->region_beg_charpos, $it->region_end_charpos
+  end
+  printf "vpos=%d hpos=%d", $it->vpos, $it->hpos,
+  printf " y=%d lvy=%d", $it->current_y, $it->last_visible_y
+  printf " x=%d vx=%d-%d", $it->current_x, $it->first_visible_x, $it->last_visible_x
+  printf " w=%d", $it->pixel_width
+  printf " a+d=%d+%d=%d", $it->ascent, $it->descent, $it->ascent+$it->descent
+  printf " max=%d+%d=%d", $it->max_ascent, $it->max_descent, $it->max_ascent+$it->max_descent
+  printf "\n"
+  set $i = 0
+  while ($i < $it->sp && $i < 4)
+    set $e = $it->stack[$i]
+    printf "stack[%d]: ", $i
+    pitmethod $e.method
+    printf "[%d]", $e.position.charpos
+    printf "\n"
+    set $i = $i + 1
+  end
+end
+document pitx
+Pretty print a display iterator.
+Take one arg, an iterator object or pointer.
+end
+
+define pit
+  pitx it
+end
+document pit
+Pretty print the display iterator it.
+end
+
+define prowx
+  set $row = $arg0
+  printf "y=%d x=%d pwid=%d", $row->y, $row->x, $row->pixel_width
+  printf " a+d=%d+%d=%d", $row->ascent, $row->height-$row->ascent, $row->height
+  printf " phys=%d+%d=%d", $row->phys_ascent, $row->phys_height-$row->phys_ascent, $row->phys_height
+  printf " vis=%d\n", $row->visible_height
+  printf "used=(LMargin=%d,Text=%d,RMargin=%d) Hash=%d\n", $row->used[0], $row->used[1], $row->used[2], $row->hash
+  printf "start=%d end=%d", $row->start.pos.charpos, $row->end.pos.charpos
+  if ($row->enabled_p)
+    printf " ENA"
+  end
+  if ($row->displays_text_p)
+    printf " DISP"
+  end
+  if ($row->mode_line_p)
+    printf " MODEL"
+  end
+  if ($row->continued_p)
+    printf " CONT"
+  end
+  if ($row-> truncated_on_left_p)
+    printf " TRUNC:L"
+  end
+  if ($row-> truncated_on_right_p)
+    printf " TRUNC:R"
+  end
+  if ($row->starts_in_middle_of_char_p)
+    printf " STARTMID"
+  end
+  if ($row->ends_in_middle_of_char_p)
+    printf " ENDMID"
+  end
+  if ($row->ends_in_newline_from_string_p)
+    printf " ENDNLFS"
+  end
+  if ($row->ends_at_zv_p)
+    printf " ENDZV"
+  end
+  if ($row->overlapped_p)
+    printf " OLAPD"
+  end
+  if ($row->overlapping_p)
+    printf " OLAPNG"
+  end
+  printf "\n"
+end
+document prowx
+Pretty print information about glyph_row.
+Takes one argument, a row object or pointer.
+end
+
+define prow
+  prowx row
+end
+document prow
+Pretty print information about glyph_row in row.
+end
+
+
+define pcursorx
+  set $cp = $arg0
+  printf "y=%d x=%d vpos=%d hpos=%d", $cp->y, $cp->x, $cp->vpos, $cp->hpos
+end
+document pcursorx
+Pretty print a window cursor.
+end
+
+define pcursor
+  printf "output: "
+  pcursorx output_cursor
+  printf "\n"
+end
+document pcursor
+Pretty print the output_cursor.
+end
+
+define pwinx
+  set $w = $arg0
+  xgetint $w->sequence_number
+  if ($w->mini_p != Qnil)
+    printf "Mini "
+  end
+  printf "Window %d ", $int
+  xgetptr $w->buffer
+  set $tem = (struct buffer *) $ptr
+  xgetptr $tem->name_
+  printf "%s", ((struct Lisp_String *) $ptr)->data
+  printf "\n"
+  xgetptr $w->start
+  set $tem = (struct Lisp_Marker *) $ptr
+  printf "start=%d end:", $tem->charpos
+  if ($w->window_end_valid != Qnil)
+    xgetint $w->window_end_pos
+    printf "pos=%d", $int
+    xgetint $w->window_end_vpos
+    printf " vpos=%d", $int
+  else
+    printf "invalid"
+  end
+  printf " vscroll=%d", $w->vscroll
+  if ($w->force_start != Qnil)
+    printf " FORCE_START"
+  end
+  if ($w->must_be_updated_p)
+    printf " MUST_UPD"
+  end
+  printf "\n"
+  printf "cursor: "
+  pcursorx $w->cursor
+  printf "  phys: "
+  pcursorx $w->phys_cursor
+  if ($w->phys_cursor_on_p)
+    printf " ON"
+  else
+    printf " OFF"
+  end
+  printf " blk="
+  if ($w->last_cursor_off_p != $w->cursor_off_p)
+    if ($w->last_cursor_off_p)
+      printf "ON->"
+    else
+      printf "OFF->"
+    end
+  end
+  if ($w->cursor_off_p)
+    printf "ON"
+  else
+    printf "OFF"
+  end
+  printf "\n"
+end
+document pwinx
+Pretty print a window structure.
+Takes one argument, a pointer to a window structure.
+end
+
+define pwin
+  pwinx w
+end
+document pwin
+Pretty print window structure w.
+end
+
+define pbiditype
+  if ($arg0 == 0)
+    printf "UNDEF"
+  end
+  if ($arg0 == 1)
+    printf "L"
+  end
+  if ($arg0 == 2)
+    printf "R"
+  end
+  if ($arg0 == 3)
+    printf "EN"
+  end
+  if ($arg0 == 4)
+    printf "AN"
+  end
+  if ($arg0 == 5)
+    printf "BN"
+  end
+  if ($arg0 == 6)
+    printf "B"
+  end
+  if ($arg0 < 0 || $arg0 > 6)
+    printf "%d??", $arg0
+  end
+end
+document pbiditype
+Print textual description of bidi type given as first argument.
+end
+
+define pgx
+  set $g = $arg0
+  # CHAR_GLYPH
+  if ($g.type == 0)
+    if ($g.u.ch >= ' ' && $g.u.ch < 127)
+      printf "CHAR[%c]", $g.u.ch
+    else
+      printf "CHAR[0x%x]", $g.u.ch
+    end
+  end
+  # COMPOSITE_GLYPH
+  if ($g.type == 1)
+    printf "COMP[%d (%d..%d)]", $g.u.cmp.id, $g.slice.cmp.from, $g.slice.cmp.to
+  end
+  # GLYPHLESS_GLYPH
+  if ($g.type == 2)
+    printf "GLYPHLESS["
+    if ($g.u.glyphless.method == 0)
+      printf "THIN]"
+    end
+    if ($g.u.glyphless.method == 1)
+      printf "EMPTY]"
+    end
+    if ($g.u.glyphless.method == 2)
+      printf "ACRO]"
+    end
+    if ($g.u.glyphless.method == 3)
+      printf "HEX]"
+    end
+  end
+  # IMAGE_GLYPH
+  if ($g.type == 3)
+    printf "IMAGE[%d]", $g.u.img_id
+  end
+  # STRETCH_GLYPH
+  if ($g.type == 4)
+    printf "STRETCH[%d+%d]", $g.u.stretch.height, $g.u.stretch.ascent
+  end
+  xgettype ($g.object)
+  if ($type == Lisp_String)
+    xgetptr $g.object
+    printf " str=0x%x[%d]", ((struct Lisp_String *)$ptr)->data, $g.charpos
+  else
+    printf " pos=%d", $g.charpos
+  end
+  # For characters, print their resolved level and bidi type
+  if ($g.type == 0)
+    printf " blev=%d,btyp=", $g.resolved_level
+    pbiditype $g.bidi_type
+  end
+  printf " w=%d a+d=%d+%d", $g.pixel_width, $g.ascent, $g.descent
+  # If not DEFAULT_FACE_ID
+  if ($g.face_id != 0)
+    printf " face=%d", $g.face_id
+  end
+  if ($g.voffset)
+    printf " vof=%d", $g.voffset
+  end
+  if ($g.multibyte_p)
+    printf " MB"
+  end
+  if ($g.padding_p)
+    printf " PAD"
+  end
+  if ($g.glyph_not_available_p)
+    printf " N/A"
+  end
+  if ($g.overlaps_vertically_p)
+    printf " OVL"
+  end
+  if ($g.avoid_cursor_p)
+    printf " AVOID"
+  end
+  if ($g.left_box_line_p)
+    printf " ["
+  end
+  if ($g.right_box_line_p)
+    printf " ]"
+  end
+  if ($g.slice.img.x || $g.slice.img.y || $g.slice.img.width || $g.slice.img.height)
+    printf " slice=%d,%d,%d,%d" ,$g.slice.img.x, $g.slice.img.y, $g.slice.img.width, $g.slice.img.height
+  end
+  printf "\n"
+end
+document pgx
+Pretty print a glyph structure.
+Takes one argument, a pointer to a glyph structure.
+end
+
+define pg
+  set $pgidx = 0
+  pgx glyph
+end
+document pg
+Pretty print glyph structure glyph.
+end
+
+define pgi
+  set $pgidx = $arg0
+  pgx (&glyph[$pgidx])
+end
+document pgi
+Pretty print glyph structure glyph[I].
+Takes one argument, a integer I.
+end
+
+define pgn
+  set $pgidx = $pgidx + 1
+  pgx (&glyph[$pgidx])
+end
+document pgn
+Pretty print next glyph structure.
+end
+
+define pgrowx
+  set $row = $arg0
+  set $area = 0
+  set $xofs = $row->x
+  while ($area < 3)
+    set $used = $row->used[$area]
+    if ($used > 0)
+      set $gl0 = $row->glyphs[$area]
+      set $pgidx = 0
+      printf "%s: %d glyphs\n", ($area == 0 ? "LEFT" : $area == 2 ? "RIGHT" : "TEXT"), $used
+      while ($pgidx < $used)
+        printf "%3d %4d: ", $pgidx, $xofs
+        pgx $gl0[$pgidx]
+        set $xofs = $xofs + $gl0[$pgidx]->pixel_width
+        set $pgidx = $pgidx + 1
+      end
+    end
+    set $area = $area + 1
+  end
+end
+document pgrowx
+Pretty print all glyphs in a row structure.
+Takes one argument, a pointer to a row structure.
+end
+
+define pgrow
+  pgrowx row
+end
+document pgrow
+Pretty print all glyphs in row structure row.
+end
+
+define pgrowit
+  pgrowx it->glyph_row
+end
+document pgrowit
+Pretty print all glyphs in it->glyph_row.
+end
+
+define prowlims
+  printf "edges=(%d,%d),r2l=%d,cont=%d,trunc=(%d,%d),at_zv=%d\n", $arg0->minpos.charpos, $arg0->maxpos.charpos, $arg0->reversed_p, $arg0->continued_p, $arg0->truncated_on_left_p, $arg0->truncated_on_right_p, $arg0->ends_at_zv_p
+end
+document prowlims
+Print important attributes of a glyph_row structure.
+Takes one argument, a pointer to a glyph_row structure.
+end
+
+define pmtxrows
+  set $mtx = $arg0
+  set $gl = $mtx->rows
+  set $glend = $mtx->rows + $mtx->nrows - 1
+  set $i = 0
+  while ($gl < $glend)
+    printf "%d: ", $i
+    prowlims $gl
+    set $gl = $gl + 1
+    set $i = $i + 1
+  end
+end
+document pmtxrows
+Print data about glyph rows in a glyph matrix.
+Takes one argument, a pointer to a glyph_matrix structure.
+end
+
+define xtype
+  xgettype $
+  output $type
+  echo \n
+  if $type == Lisp_Misc
+    xmisctype
+  else
+    if $type == Lisp_Vectorlike
+      xvectype
+    end
+  end
+end
+document xtype
+Print the type of $, assuming it is an Emacs Lisp value.
+If the first type printed is Lisp_Vector or Lisp_Misc,
+a second line gives the more precise type.
+end
+
+define pvectype
+  set $size = ((struct Lisp_Vector *) $arg0)->header.size
+  if ($size & PSEUDOVECTOR_FLAG)
+    output (enum pvec_type) (($size & PVEC_TYPE_MASK) >> PSEUDOVECTOR_AREA_BITS)
+  else
+    output PVEC_NORMAL_VECTOR
+  end
+  echo \n
+end
+document pvectype
+Print the subtype of vectorlike object.
+Takes one argument, a pointer to an object.
+end
+
+define xvectype
+  xgetptr $
+  pvectype $ptr
+end
+document xvectype
+Print the subtype of vectorlike object.
+This command assumes that $ is a Lisp_Object.
+end
+
+define pvecsize
+  set $size = ((struct Lisp_Vector *) $arg0)->header.size
+  if ($size & PSEUDOVECTOR_FLAG)
+    output ($size & PSEUDOVECTOR_SIZE_MASK)
+    echo \n
+    output (($size & PSEUDOVECTOR_REST_MASK) >> PSEUDOVECTOR_SIZE_BITS)
+  else
+    output ($size & ~ARRAY_MARK_FLAG)
+  end
+  echo \n
+end
+document pvecsize
+Print the size of vectorlike object.
+Takes one argument, a pointer to an object.
+end
+
+define xvecsize
+  xgetptr $
+  pvecsize $ptr
+end
+document xvecsize
+Print the size of $
+This command assumes that $ is a Lisp_Object.
+end
+
+define xmisctype
+  xgetptr $
+  output (enum Lisp_Misc_Type) (((struct Lisp_Free *) $ptr)->type)
+  echo \n
+end
+document xmisctype
+Assume that $ is some misc type and print its specific type.
+end
+
+define xint
+  xgetint $
+  print $int
+end
+document xint
+Print $ as an Emacs Lisp integer.  This gets the sign right.
+end
+
+define xptr
+  xgetptr $
+  print (void *) $ptr
+end
+document xptr
+Print the pointer portion of an Emacs Lisp value in $.
+end
+
+define xmarker
+  xgetptr $
+  print (struct Lisp_Marker *) $ptr
+end
+document xmarker
+Print $ as a marker pointer.
+This command assumes that $ is an Emacs Lisp marker value.
+end
+
+define xoverlay
+  xgetptr $
+  print (struct Lisp_Overlay *) $ptr
+end
+document xoverlay
+Print $ as a overlay pointer.
+This command assumes that $ is an Emacs Lisp overlay value.
+end
+
+define xmiscfree
+  xgetptr $
+  print (struct Lisp_Free *) $ptr
+end
+document xmiscfree
+Print $ as a misc free-cell pointer.
+This command assumes that $ is an Emacs Lisp Misc value.
+end
+
+define xsymbol
+  set $sym = $
+  xgetptr $sym
+  print (struct Lisp_Symbol *) $ptr
+  xprintsym $sym
+  echo \n
+end
+document xsymbol
+Print the name and address of the symbol $.
+This command assumes that $ is an Emacs Lisp symbol value.
+end
+
+define xstring
+  xgetptr $
+  print (struct Lisp_String *) $ptr
+  xprintstr $
+  echo \n
+end
+document xstring
+Print the contents and address of the string $.
+This command assumes that $ is an Emacs Lisp string value.
+end
+
+define xvector
+  xgetptr $
+  print (struct Lisp_Vector *) $ptr
+  output ($->header.size > 50) ? 0 : ($->contents[0])@($->header.size & ~ARRAY_MARK_FLAG)
+echo \n
+end
+document xvector
+Print the contents and address of the vector $.
+This command assumes that $ is an Emacs Lisp vector value.
+end
+
+define xprocess
+  xgetptr $
+  print (struct Lisp_Process *) $ptr
+  output *$
+  echo \n
+end
+document xprocess
+Print the address of the struct Lisp_process to which $ points.
+This command assumes that $ is a Lisp_Object.
+end
+
+define xframe
+  xgetptr $
+  print (struct frame *) $ptr
+  xgetptr $->name
+  set $ptr = (struct Lisp_String *) $ptr
+  xprintstr $ptr
+  echo \n
+end
+document xframe
+Print $ as a frame pointer.
+This command assumes $ is an Emacs Lisp frame value.
+end
+
+define xcompiled
+  xgetptr $
+  print (struct Lisp_Vector *) $ptr
+  output ($->contents[0])@($->header.size & 0xff)
+end
+document xcompiled
+Print $ as a compiled function pointer.
+This command assumes that $ is an Emacs Lisp compiled value.
+end
+
+define xwindow
+  xgetptr $
+  print (struct window *) $ptr
+  set $window = (struct window *) $ptr
+  xgetint $window->total_cols
+  set $width=$int
+  xgetint $window->total_lines
+  set $height=$int
+  xgetint $window->left_col
+  set $left=$int
+  xgetint $window->top_line
+  set $top=$int
+  printf "%dx%d+%d+%d\n", $width, $height, $left, $top
+end
+document xwindow
+Print $ as a window pointer, assuming it is an Emacs Lisp window value.
+Print the window's position as "WIDTHxHEIGHT+LEFT+TOP".
+end
+
+define xwinconfig
+  xgetptr $
+  print (struct save_window_data *) $ptr
+end
+document xwinconfig
+Print $ as a window configuration pointer.
+This command assumes that $ is an Emacs Lisp window configuration value.
+end
+
+define xsubr
+  xgetptr $
+  print (struct Lisp_Subr *) $ptr
+  output *$
+  echo \n
+end
+document xsubr
+Print the address of the subr which the Lisp_Object $ points to.
+end
+
+define xchartable
+  xgetptr $
+  print (struct Lisp_Char_Table *) $ptr
+  printf "Purpose: "
+  xprintsym $->purpose
+  printf "  %d extra slots", ($->header.size & 0x1ff) - 68
+  echo \n
+end
+document xchartable
+Print the address of the char-table $, and its purpose.
+This command assumes that $ is an Emacs Lisp char-table value.
+end
+
+define xsubchartable
+  xgetptr $
+  print (struct Lisp_Sub_Char_Table *) $ptr
+  xgetint $->depth
+  set $depth = $int
+  xgetint $->min_char
+  printf "Depth: %d, Min char: %d (0x%x)\n", $depth, $int, $int
+end
+document xsubchartable
+Print the address of the sub-char-table $, its depth and min-char.
+This command assumes that $ is an Emacs Lisp sub-char-table value.
+end
+
+define xboolvector
+  xgetptr $
+  print (struct Lisp_Bool_Vector *) $ptr
+  output ($->size > 256) ? 0 : ($->data[0])@(($->size + BOOL_VECTOR_BITS_PER_CHAR - 1)/ BOOL_VECTOR_BITS_PER_CHAR)
+  echo \n
+end
+document xboolvector
+Print the contents and address of the bool-vector $.
+This command assumes that $ is an Emacs Lisp bool-vector value.
+end
+
+define xbuffer
+  xgetptr $
+  print (struct buffer *) $ptr
+  xgetptr $->name_
+  output ((struct Lisp_String *) $ptr)->data
+  echo \n
+end
+document xbuffer
+Set $ as a buffer pointer and the name of the buffer.
+This command assumes $ is an Emacs Lisp buffer value.
+end
+
+define xhashtable
+  xgetptr $
+  print (struct Lisp_Hash_Table *) $ptr
+end
+document xhashtable
+Set $ as a hash table pointer.
+This command assumes that $ is an Emacs Lisp hash table value.
+end
+
+define xcons
+  xgetptr $
+  print (struct Lisp_Cons *) $ptr
+  output/x *$
+  echo \n
+end
+document xcons
+Print the contents of $ as an Emacs Lisp cons.
+end
+
+define nextcons
+  p $.u.cdr
+  xcons
+end
+document nextcons
+Print the contents of the next cell in a list.
+This command assumes that the last thing you printed was a cons cell contents
+(type struct Lisp_Cons) or a pointer to one.
+end
+define xcar
+  xgetptr $
+  xgettype $
+  print/x ($type == Lisp_Cons ? ((struct Lisp_Cons *) $ptr)->car : 0)
+end
+document xcar
+Assume that $ is an Emacs Lisp pair and print its car.
+end
+
+define xcdr
+  xgetptr $
+  xgettype $
+  print/x ($type == Lisp_Cons ? ((struct Lisp_Cons *) $ptr)->u.cdr : 0)
+end
+document xcdr
+Assume that $ is an Emacs Lisp pair and print its cdr.
+end
+
+define xlist
+  xgetptr $
+  set $cons = (struct Lisp_Cons *) $ptr
+  xgetptr Qnil
+  set $nil = $ptr
+  set $i = 0
+  while $cons != $nil && $i < 10
+    p/x $cons->car
+    xpr
+    xgetptr $cons->u.cdr
+    set $cons = (struct Lisp_Cons *) $ptr
+    set $i = $i + 1
+    printf "---\n"
+  end
+  if $cons == $nil
+    printf "nil\n"
+  else
+    printf "...\n"
+    p $ptr
+  end
+end
+document xlist
+Print $ assuming it is a list.
+end
+
+define xfloat
+  xgetptr $
+  print ((struct Lisp_Float *) $ptr)->u.data
+end
+document xfloat
+Print $ assuming it is a lisp floating-point number.
+end
+
+define xscrollbar
+  xgetptr $
+  print (struct scrollbar *) $ptr
+output *$
+echo \n
+end
+document xscrollbar
+Print $ as a scrollbar pointer.
+end
+
+define xpr
+  xtype
+  if $type == Lisp_Int0 || $type == Lisp_Int1
+    xint
+  end
+  if $type == Lisp_Symbol
+    xsymbol
+  end
+  if $type == Lisp_String
+    xstring
+  end
+  if $type == Lisp_Cons
+    xcons
+  end
+  if $type == Lisp_Float
+    xfloat
+  end
+  if $type == Lisp_Misc
+    set $misc = (enum Lisp_Misc_Type) (((struct Lisp_Free *) $ptr)->type)
+    if $misc == Lisp_Misc_Free
+      xmiscfree
+    end
+    if $misc == Lisp_Misc_Marker
+      xmarker
+    end
+    if $misc == Lisp_Misc_Overlay
+      xoverlay
+    end
+#    if $misc == Lisp_Misc_Save_Value
+#      xsavevalue
+#    end
+  end
+  if $type == Lisp_Vectorlike
+    set $size = ((struct Lisp_Vector *) $ptr)->header.size
+    if ($size & PSEUDOVECTOR_FLAG)
+      set $vec = (enum pvec_type) (($size & PVEC_TYPE_MASK) >> PSEUDOVECTOR_AREA_BITS)
+      if $vec == PVEC_NORMAL_VECTOR
+        xvector
+      end
+      if $vec == PVEC_PROCESS
+        xprocess
+      end
+      if $vec == PVEC_FRAME
+        xframe
+      end
+      if $vec == PVEC_COMPILED
+        xcompiled
+      end
+      if $vec == PVEC_WINDOW
+        xwindow
+      end
+      if $vec == PVEC_WINDOW_CONFIGURATION
+        xwinconfig
+      end
+      if $vec == PVEC_SUBR
+        xsubr
+      end
+      if $vec == PVEC_CHAR_TABLE
+        xchartable
+      end
+      if $vec == PVEC_BOOL_VECTOR
+        xboolvector
+      end
+      if $vec == PVEC_BUFFER
+        xbuffer
+      end
+      if $vec == PVEC_HASH_TABLE
+        xhashtable
+      end
+    else
+      xvector
+    end
+  end
+end
+document xpr
+Print $ as a lisp object of any type.
+end
+
+define xprintstr
+  set $data = (char *) $arg0->data
+  output ($arg0->size > 1000) ? 0 : ($data[0])@($arg0->size_byte < 0 ? $arg0->size & ~ARRAY_MARK_FLAG : $arg0->size_byte)
+end
+
+define xprintsym
+  xgetptr $arg0
+  set $sym = (struct Lisp_Symbol *) $ptr
+  xgetptr $sym->name
+  set $sym_name = (struct Lisp_String *) $ptr
+  xprintstr $sym_name
+end
+document xprintsym
+  Print argument as a symbol.
+end
+
+define xcoding
+  set $tmp = (struct Lisp_Hash_Table *) ((Vcoding_system_hash_table & VALMASK) | DATA_SEG_BITS)
+  set $tmp = (struct Lisp_Vector *) (($tmp->key_and_value & VALMASK) | DATA_SEG_BITS)
+  set $name = $tmp->contents[$arg0 * 2]
+  print $name
+  pr
+  print $tmp->contents[$arg0 * 2 + 1]
+  pr
+end
+document xcoding
+  Print the name and attributes of coding system that has ID (argument).
+end
+
+define xcharset
+  set $tmp = (struct Lisp_Hash_Table *) ((Vcharset_hash_table & VALMASK) | DATA_SEG_BITS)
+  set $tmp = (struct Lisp_Vector *) (($tmp->key_and_value & VALMASK) | DATA_SEG_BITS)
+  p $tmp->contents[charset_table[$arg0].hash_index * 2]
+  pr
+end
+document xcharset
+  Print the name of charset that has ID (argument).
+end
+
+define xfontset
+  xgetptr $
+  set $tbl = (struct Lisp_Char_Table *) $ptr
+  print $tbl
+  xgetint $tbl->extras[0]
+  printf " ID:%d", $int
+  xgettype $tbl->extras[1]
+  xgetptr $tbl->extras[1]
+  if $type == Lisp_String
+    set $ptr = (struct Lisp_String *) $ptr
+    printf " Name:"
+    xprintstr $ptr
+  else
+    xgetptr $tbl->extras[2]
+    set $ptr = (struct Lisp_Char_Table *) $ptr
+    xgetptr $ptr->extras[1]
+    set $ptr = (struct Lisp_String *) $ptr
+    printf " Realized from:"
+    xprintstr $ptr
+  end
+  echo \n
+end
+
+define xfont
+  xgetptr $
+  set $size = (((struct Lisp_Vector *) $ptr)->header.size & 0x1FF)
+  if $size == FONT_SPEC_MAX
+    print (struct font_spec *) $ptr
+  else
+    if $size == FONT_ENTITY_MAX
+      print (struct font_entity *) $ptr
+    else
+      print (struct font *) $ptr
+    end
+  end
+end
+document xfont
+Print $ assuming it is a list font (font-spec, font-entity, or font-object).
+end
+
+define xbacktrace
+  set $bt = backtrace_list
+  while $bt
+    xgettype ($bt->function)
+    if $type == Lisp_Symbol
+      xprintsym ($bt->function)
+      printf " (0x%x)\n", $bt->args
+    else
+      xgetptr $bt->function
+      printf "0x%x ", $ptr
+      if $type == Lisp_Vectorlike
+        xgetptr ($bt->function)
+        set $size = ((struct Lisp_Vector *) $ptr)->header.size
+        if ($size & PSEUDOVECTOR_FLAG)
+          output (enum pvec_type) (($size & PVEC_TYPE_MASK) >> PSEUDOVECTOR_AREA_BITS)
+        else
+          output $size & ~ARRAY_MARK_FLAG
+        end
+      else
+        printf "Lisp type %d", $type
+      end
+      echo \n
+    end
+    set $bt = $bt->next
+  end
+end
+document xbacktrace
+  Print a backtrace of Lisp function calls from backtrace_list.
+  Set a breakpoint at Fsignal and call this to see from where
+  an error was signaled.
+end
+
+define xprintbytestr
+  set $data = (char *) $arg0->data
+  printf "Bytecode: "
+  output/u ($arg0->size > 1000) ? 0 : ($data[0])@($arg0->size_byte < 0 ? $arg0->size & ~ARRAY_MARK_FLAG : $arg0->size_byte)
+end
+document xprintbytestr
+  Print a string of byte code.
+end
+
+define xwhichsymbols
+  set $output_debug = print_output_debug_flag
+  set print_output_debug_flag = 0
+  call safe_debug_print (which_symbols ($arg0, $arg1))
+  set print_output_debug_flag = $output_debug
+end
+document xwhichsymbols
+  Print symbols which references a given lisp object
+  either as its symbol value or symbol function.
+  Call with two arguments: the lisp object and the
+  maximum number of symbols referencing it to produce.
+end
+
+define xbytecode
+  set $bt = byte_stack_list
+  while $bt
+    xgetptr $bt->byte_string
+    set $ptr = (struct Lisp_String *) $ptr
+    xprintbytestr $ptr
+    printf "\n0x%x => ", $bt->byte_string
+    xwhichsymbols $bt->byte_string 5
+    set $bt = $bt->next
+  end
+end
+document xbytecode
+  Print a backtrace of the byte code stack.
+end
+
+# Show Lisp backtrace after normal backtrace.
+define hookpost-backtrace
+  set $bt = backtrace_list
+  if $bt
+    echo \n
+    echo Lisp Backtrace:\n
+    xbacktrace
+  end
+end
+
+# Flush display (X only)
+define ff
+  set x_flush (0)
+end
+document ff
+Flush pending X window display updates to screen.
+Works only when an inferior emacs is executing.
+end
+
+
+set print pretty on
+set print sevenbit-strings
+
+show environment DISPLAY
+show environment TERM
+
+# When debugging, it is handy to be able to "return" from
+# terminate_due_to_signal when an assertion failure is non-fatal.
+break terminate_due_to_signal
+
+# x_error_quitter is defined only on X.  But window-system is set up
+# only at run time, during Emacs startup, so we need to defer setting
+# the breakpoint.  init_sys_modes is the first function called on
+# every platform after init_display, where window-system is set.
+tbreak init_sys_modes
+commands
+  silent
+  xgetptr globals.f_Vinitial_window_system
+  set $tem = (struct Lisp_Symbol *) $ptr
+  xgetptr $tem->name
+  set $tem = (struct Lisp_String *) $ptr
+  set $tem = (char *) $tem->data
+  # If we are running in synchronous mode, we want a chance to look
+  # around before Emacs exits.  Perhaps we should put the break
+  # somewhere else instead...
+  if $tem[0] == 'x' && $tem[1] == '\0'
+    break x_error_quitter
+  end
+  continue
+end
diff --git a/src/ChangeLog b/src/ChangeLog
index 332656fcf00..c612c4dd365 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,135 @@
+2012-11-25  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * sysdep.c (sys_subshell): Don't assume pid_t fits in int.
+
+2012-11-24  Ken Brown  <kbrown@cornell.edu>
+
+        * keyboard.c (HAVE_MOUSE):
+        * frame.c (HAVE_MOUSE): Remove, and rewrite code as if HAVE_MOUSE
+        were always defined.
+
+2012-11-24  Eli Zaretskii  <eliz@gnu.org>
+
+        * xdisp.c (set_cursor_from_row): Skip step 2 only if point is not
+        between bpos_covered and bpos_max.  This fixes cursor display when
+        several display strings follow each other.
+
+        * .gdbinit (pgx): If the glyph's object is a string, display the
+        pointer to string data, rather than the value of the string object
+        itself (which barfs under CHECK_LISP_OBJECT_TYPE).
+
+        * indent.c (Fvertical_motion): If the starting position is covered
+        by a display string, return to one position before that, to avoid
+        overshooting it inside move_it_to.  (Bug#12930)
+
+2012-11-23  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * frame.h (struct frame): Remove display_preempted member
+        since all users are dead long ago.
+        * nsterm.h (struct x_output): Use the only dummy member.
+        * w32menu.c (pending_menu_activation): Remove since not
+        really used.
+        (set_frame_menubar): Adjust user.
+        * w32term.h (struct x_output): Drop outdated #if 0 code.
+        (struct w32_output): Use bitfields for explicit_parent,
+        asked_for_visible and menubar_active members.  Drop
+        unused pending_menu_activation member.
+        * xterm.h (struct x_output): Drop outdated #if 0 code.
+        Use bitfields for explicit_parent, asked_for_visible,
+        has_been_visible and net_wm_state_hidden_seen members.
+
+2012-11-23  Eli Zaretskii  <eliz@gnu.org>
+
+        * makefile.w32-in (globals.h, gl-stamp): Use $(SWITCHCHAR) instead
+        of a literal "/".  (Bug#12955)
+        (gl-stamp): Invoke fc.exe directly, not through cmd.
+
+2012-11-23  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Assume POSIX 1003.1-1988 or later for dirent.h (Bug#12958).
+        * dired.c: Assume HAVE_DIRENT_H.
+        (NAMLEN): Remove, replacing with ...
+        (dirent_namelen): New function.  All uses changed.  Use the GNU macro
+        _D_EXACT_NAMELEN if available, as it's faster than strlen.
+        (DIRENTRY): Remove, replacing all uses with 'struct dirent'.
+        (DIRENTRY_NONEMPTY): Remove.  All callers now assume it's nonzero.
+        * makefile.w32-in (DIR_H): Remove.  All uses replaced with
+        $(NT_INC)/dirent.h.
+        ($(BLD)/w32.$(O)): Do not depend on $(SRC)/ndir.h.
+        * ndir.h: Rename to ../nt/inc/dirent.h.
+        * sysdep.h (closedir) [!HAVE_CLOSEDIR]: Remove.
+        Do not include <dirent.h>; no longer needed.
+        * w32.c: Include <dirent.h> rather than "ndir.h".
+
+2012-11-23  Chong Yidong  <cyd@gnu.org>
+
+        * xftfont.c (xftfont_open): Remove duplicate assignment.
+
+2012-11-22  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * alloc.c (Fgarbage_collect): Unblock input after clearing
+        gc_in_progress to avoid note_mouse_highlight glitch with GC.
+        * frame.h (FRAME_MOUSE_UPDATE): New macro.
+        * msdos.c (IT_frame_up_to_date): Use it here...
+        * w32term.c (w32_frame_up_to_date): ...here...
+        * xterm.c (XTframe_up_to_date): ...and here...
+        * nsterm.m (ns_frame_up_to_date): ...but not here.
+        * lisp.h (Mouse_HLInfo): Remove mouse_face_deferred_gc member.
+        Adjust users.
+        * xdisp.c (message2_nolog, message3_nolog, note_mouse_highlight):
+        Do not check whether GC is in progress.
+
+2012-11-22  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * xdisp.c (window_buffer_changed): New function.
+        (update_menu_bar, update_tool_bar): Use it to
+        simplify large 'if' statements.
+        (redisplay_internal): Generalize commonly used
+        'tail' and 'frame' local variables.
+
+2012-11-22  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32.c (getcwd): Fix the 2nd argument type, to prevent conflicts
+        with Windows system header.
+
+2012-11-21  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Assume POSIX 1003.1-1988 or later for unistd.h (Bug#12945).
+        * alloc.c: Assume unistd.h exists.
+        * fileio.c (Fexpand_file_name) [DOS_NT]: Use getcwd, not getwd.
+        * sysdep.c (get_current_dir_name): Assume getcwd exists.
+        (getwd) [USG]: Remove; no longer needed.
+        (sys_subshell) [DOS_NT]: Use getcwd, not getwd.
+        * w32.c (getcwd): Rename from getwd, and switch to getcwd's API.
+        * w32.h (getcwd): Remove decl.
+
+2012-11-21  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * xdisp.c (fast_set_selected_frame): Rename from update_tool_bar_unwind.
+        Make it set selected_window as well.
+        (update_tool_bar): Use it.
+
+2012-11-21  Ken Brown  <kbrown@cornell.edu>
+
+        * emacs.c (main): Set the G_SLICE environment variable for all
+        Cygwin builds, not just GTK builds.  See
+        https://lists.gnu.org/archive/html/emacs-devel/2012-11/msg00368.html.
+
+2012-11-21  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32.c (FILE_DEVICE_FILE_SYSTEM, METHOD_BUFFERED)
+        (FILE_ANY_ACCESS, CTL_CODE, FSCTL_GET_REPARSE_POINT) [_MSC_VER]:
+        Define for the MSVC compiler.
+
+        * w32term.h (EnumSystemLocalesW) [_MSC_VER]: Add a missing semi-colon.
+
+        * fileio.c (Fsubstitute_in_file_name, Ffile_name_directory)
+        (Fexpand_file_name) [DOS_NT]: Pass encoded file name to
+        dostounix_filename.  Prevents crashes down the road, because
+        dostounix_filename assumes it gets a unibyte string.  Reported by
+        Michel de Ruiter <michel@sentient.nl>, see
+        http://lists.gnu.org/archive/html/help-emacs-windows/2012-11/msg00017.html
+
 2012-11-20  Stefan Monnier  <monnier@iro.umontreal.ca>
 
         Conflate Qnil and Qunbound for `symbol-function'.
diff --git a/src/alloc.c b/src/alloc.c
index 22e3db3cc77..28c9b51dab4 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -63,10 +63,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #endif
 
 #include <unistd.h>
-#ifndef HAVE_UNISTD_H
-extern void *sbrk ();
-#endif
-
 #include <fcntl.h>
 
 #ifdef USE_GTK
@@ -5335,12 +5331,12 @@ See Info node `(elisp)Garbage Collection'.  */)
   dump_zombies ();
 #endif
 
-  unblock_input ();
-
   check_cons_list ();
 
   gc_in_progress = 0;
 
+  unblock_input ();
+
   consing_since_gc = 0;
   if (gc_cons_threshold < GC_DEFAULT_THRESHOLD / 10)
     gc_cons_threshold = GC_DEFAULT_THRESHOLD / 10;
diff --git a/src/dired.c b/src/dired.c
index 4986f845101..3530b74ecb4 100644
--- a/src/dired.c
+++ b/src/dired.c
@@ -31,44 +31,10 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <errno.h>
 #include <unistd.h>
 
-/* The d_nameln member of a struct dirent includes the '\0' character
-   on some systems, but not on others.  What's worse, you can't tell
-   at compile-time which one it will be, since it really depends on
-   the sort of system providing the filesystem you're reading from,
-   not the system you are running on.  Paul Eggert
-   <eggert@bi.twinsun.com> says this occurs when Emacs is running on a
-   SunOS 4.1.2 host, reading a directory that is remote-mounted from a
-   Solaris 2.1 host and is in a native Solaris 2.1 filesystem.
-
-   Since applying strlen to the name always works, we'll just do that.  */
-#define NAMLEN(p) strlen (p->d_name)
-
-#ifdef HAVE_DIRENT_H
-
 #include <dirent.h>
-#define DIRENTRY struct dirent
-
-#else /* not HAVE_DIRENT_H */
-
-#include <sys/dir.h>
-#include <sys/stat.h>
-
-#define DIRENTRY struct direct
-
-extern DIR *opendir (char *);
-extern struct direct *readdir (DIR *);
-
-#endif /* HAVE_DIRENT_H */
-
 #include <filemode.h>
 #include <stat-time.h>
 
-#ifdef MSDOS
-#define DIRENTRY_NONEMPTY(p) ((p)->d_name[0] != 0)
-#else
-#define DIRENTRY_NONEMPTY(p) ((p)->d_ino)
-#endif
-
 #include "lisp.h"
 #include "systime.h"
 #include "character.h"
@@ -88,6 +54,17 @@ static Lisp_Object Qfile_attributes_lessp;
 
 static ptrdiff_t scmp (const char *, const char *, ptrdiff_t);
 
+/* Return the number of bytes in DP's name.  */
+static ptrdiff_t
+dirent_namelen (struct dirent *dp)
+{
+#ifdef _D_EXACT_NAMLEN
+  return _D_EXACT_NAMLEN (dp);
+#else
+  return strlen (dp->d_name);
+#endif
+}
+
 #ifdef WINDOWSNT
 Lisp_Object
 directory_files_internal_w32_unwind (Lisp_Object arg)
@@ -124,7 +101,7 @@ directory_files_internal (Lisp_Object directory, Lisp_Object full,
   bool needsep = 0;
   ptrdiff_t count = SPECPDL_INDEX ();
   struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
-  DIRENTRY *dp;
+  struct dirent *dp;
 #ifdef WINDOWSNT
   Lisp_Object w32_save = Qnil;
 #endif
@@ -209,6 +186,11 @@ directory_files_internal (Lisp_Object directory, Lisp_Object full,
   /* Loop reading blocks until EOF or error.  */
   for (;;)
     {
+      ptrdiff_t len;
+      bool wanted = 0;
+      Lisp_Object name, finalname;
+      struct gcpro gcpro1, gcpro2;
+
       errno = 0;
       dp = readdir (d);
 
@@ -225,89 +207,81 @@ directory_files_internal (Lisp_Object directory, Lisp_Object full,
       if (dp == NULL)
         break;
 
-      if (DIRENTRY_NONEMPTY (dp))
+      len = dirent_namelen (dp);
+      name = finalname = make_unibyte_string (dp->d_name, len);
+      GCPRO2 (finalname, name);
+
+      /* Note: DECODE_FILE can GC; it should protect its argument,
+         though.  */
+      name = DECODE_FILE (name);
+      len = SBYTES (name);
+
+      /* Now that we have unwind_protect in place, we might as well
+         allow matching to be interrupted.  */
+      immediate_quit = 1;
+      QUIT;
+
+      if (NILP (match)
+          || (0 <= re_search (bufp, SSDATA (name), len, 0, len, 0)))
+        wanted = 1;
+
+      immediate_quit = 0;
+
+      if (wanted)
         {
-          ptrdiff_t len;
-          bool wanted = 0;
-          Lisp_Object name, finalname;
-          struct gcpro gcpro1, gcpro2;
+          if (!NILP (full))
+            {
+              Lisp_Object fullname;
+              ptrdiff_t nbytes = len + directory_nbytes + needsep;
+              ptrdiff_t nchars;
 
-          len = NAMLEN (dp);
-          name = finalname = make_unibyte_string (dp->d_name, len);
-          GCPRO2 (finalname, name);
+              fullname = make_uninit_multibyte_string (nbytes, nbytes);
+              memcpy (SDATA (fullname), SDATA (directory),
+                      directory_nbytes);
 
-          /* Note: DECODE_FILE can GC; it should protect its argument,
-             though.  */
-          name = DECODE_FILE (name);
-          len = SBYTES (name);
+              if (needsep)
+                SSET (fullname, directory_nbytes, DIRECTORY_SEP);
 
-          /* Now that we have unwind_protect in place, we might as well
-             allow matching to be interrupted.  */
-          immediate_quit = 1;
-          QUIT;
+              memcpy (SDATA (fullname) + directory_nbytes + needsep,
+                      SDATA (name), len);
 
-          if (NILP (match)
-              || (0 <= re_search (bufp, SSDATA (name), len, 0, len, 0)))
-            wanted = 1;
+              nchars = chars_in_text (SDATA (fullname), nbytes);
 
-          immediate_quit = 0;
+              /* Some bug somewhere.  */
+              if (nchars > nbytes)
+                emacs_abort ();
 
-          if (wanted)
-            {
-              if (!NILP (full))
-                {
-                  Lisp_Object fullname;
-                  ptrdiff_t nbytes = len + directory_nbytes + needsep;
-                  ptrdiff_t nchars;
-
-                  fullname = make_uninit_multibyte_string (nbytes, nbytes);
-                  memcpy (SDATA (fullname), SDATA (directory),
-                          directory_nbytes);
-
-                  if (needsep)
-                    SSET (fullname, directory_nbytes, DIRECTORY_SEP);
-
-                  memcpy (SDATA (fullname) + directory_nbytes + needsep,
-                          SDATA (name), len);
-
-                  nchars = chars_in_text (SDATA (fullname), nbytes);
-
-                  /* Some bug somewhere.  */
-                  if (nchars > nbytes)
-                    emacs_abort ();
-
-                  STRING_SET_CHARS (fullname, nchars);
-                  if (nchars == nbytes)
-                    STRING_SET_UNIBYTE (fullname);
-
-                  finalname = fullname;
-                }
-              else
-                finalname = name;
-
-              if (attrs)
-                {
-                  /* Construct an expanded filename for the directory entry.
-                     Use the decoded names for input to Ffile_attributes.  */
-                  Lisp_Object decoded_fullname, fileattrs;
-                  struct gcpro gcpro1, gcpro2;
-
-                  decoded_fullname = fileattrs = Qnil;
-                  GCPRO2 (decoded_fullname, fileattrs);
-
-                  /* Both Fexpand_file_name and Ffile_attributes can GC.  */
-                  decoded_fullname = Fexpand_file_name (name, directory);
-                  fileattrs = Ffile_attributes (decoded_fullname, id_format);
-
-                  list = Fcons (Fcons (finalname, fileattrs), list);
-                  UNGCPRO;
-                }
-              else
-                list = Fcons (finalname, list);
+              STRING_SET_CHARS (fullname, nchars);
+              if (nchars == nbytes)
+                STRING_SET_UNIBYTE (fullname);
+
+              finalname = fullname;
             }
+          else
+            finalname = name;
 
-          UNGCPRO;
+          if (attrs)
+            {
+              /* Construct an expanded filename for the directory entry.
+                 Use the decoded names for input to Ffile_attributes.  */
+              Lisp_Object decoded_fullname, fileattrs;
+              struct gcpro gcpro1, gcpro2;
+
+              decoded_fullname = fileattrs = Qnil;
+              GCPRO2 (decoded_fullname, fileattrs);
+
+              /* Both Fexpand_file_name and Ffile_attributes can GC.  */
+              decoded_fullname = Fexpand_file_name (name, directory);
+              fileattrs = Ffile_attributes (decoded_fullname, id_format);
+
+              list = Fcons (Fcons (finalname, fileattrs), list);
+              UNGCPRO;
+            }
+          else
+            list = Fcons (finalname, list);
         }
+
+      UNGCPRO;
     }
 
   block_input ();
@@ -442,7 +416,8 @@ These are all file names in directory DIRECTORY which begin with FILE.  */)
   return file_name_completion (file, directory, 1, Qnil);
 }
 
-static int file_name_completion_stat (Lisp_Object dirname, DIRENTRY *dp, struct stat *st_addr);
+static int file_name_completion_stat (Lisp_Object dirname, struct dirent *dp,
+                                      struct stat *st_addr);
 static Lisp_Object Qdefault_directory;
 
 static Lisp_Object
@@ -499,7 +474,7 @@ file_name_completion (Lisp_Object file, Lisp_Object dirname, bool all_flag,
   /* (att3b compiler bug requires do a null comparison this way) */
   while (1)
     {
-      DIRENTRY *dp;
+      struct dirent *dp;
       ptrdiff_t len;
       bool canexclude = 0;
 
@@ -517,11 +492,10 @@ file_name_completion (Lisp_Object file, Lisp_Object dirname, bool all_flag,
 
       if (!dp) break;
 
-      len = NAMLEN (dp);
+      len = dirent_namelen (dp);
 
       QUIT;
-      if (! DIRENTRY_NONEMPTY (dp)
-          || len < SCHARS (encoded_file)
+      if (len < SCHARS (encoded_file)
           || 0 <= scmp (dp->d_name, SSDATA (encoded_file),
                         SCHARS (encoded_file)))
         continue;
@@ -806,9 +780,10 @@ scmp (const char *s1, const char *s2, ptrdiff_t len)
 }
 
 static int
-file_name_completion_stat (Lisp_Object dirname, DIRENTRY *dp, struct stat *st_addr)
+file_name_completion_stat (Lisp_Object dirname, struct dirent *dp,
+                           struct stat *st_addr)
 {
-  ptrdiff_t len = NAMLEN (dp);
+  ptrdiff_t len = dirent_namelen (dp);
   ptrdiff_t pos = SCHARS (dirname);
   int value;
   USE_SAFE_ALLOCA;
diff --git a/src/emacs.c b/src/emacs.c
index 079304b6c8e..7f1610ce5ef 100644
--- a/src/emacs.c
+++ b/src/emacs.c
@@ -718,7 +718,7 @@ main (int argc, char **argv)
   stack_base = &dummy;
 #endif
 
-#if defined (USE_GTK) && defined (G_SLICE_ALWAYS_MALLOC)
+#ifdef G_SLICE_ALWAYS_MALLOC
   /* This is used by the Cygwin build.  */
   setenv ("G_SLICE", "always-malloc", 1);
 #endif
diff --git a/src/fileio.c b/src/fileio.c
index 572f6d8ef83..442c66550d3 100644
--- a/src/fileio.c
+++ b/src/fileio.c
@@ -315,6 +315,7 @@ Given a Unix syntax file name, returns a string ending in slash.  */)
   register const char *beg;
 #else
   register char *beg;
+  Lisp_Object tem_fn;
 #endif
   register const char *p;
   Lisp_Object handler;
@@ -374,10 +375,13 @@ Given a Unix syntax file name, returns a string ending in slash.  */)
           p = beg + strlen (beg);
         }
     }
-  dostounix_filename (beg);
-#endif /* DOS_NT */
-
+  tem_fn = ENCODE_FILE (make_specified_string (beg, -1, p - beg,
+                                               STRING_MULTIBYTE (filename)));
+  dostounix_filename (SSDATA (tem_fn));
+  return DECODE_FILE (tem_fn);
+#else  /* DOS_NT */
   return make_specified_string (beg, -1, p - beg, STRING_MULTIBYTE (filename));
+#endif  /* DOS_NT */
 }
 
 DEFUN ("file-name-nondirectory", Ffile_name_nondirectory,
@@ -951,7 +955,18 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
 #ifdef DOS_NT
           /* Make sure directories are all separated with /, but
              avoid allocation of a new string when not required. */
-          dostounix_filename (nm);
+          if (multibyte)
+            {
+              Lisp_Object tem_name = make_specified_string (nm, -1, strlen (nm),
+                                                            multibyte);
+
+              tem_name = ENCODE_FILE (tem_name);
+              dostounix_filename (SSDATA (tem_name));
+              tem_name = DECODE_FILE (tem_name);
+              memcpy (nm, SSDATA (tem_name), SBYTES (tem_name) + 1);
+            }
+          else
+            dostounix_filename (nm);
 #ifdef WINDOWSNT
           if (IS_DIRECTORY_SEP (nm[1]))
             {
@@ -1133,7 +1148,7 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
                 newdir = "/";
             }
           else
-            getwd (adir);
+            getcwd (adir, MAXPATHLEN + 1);
           newdir = adir;
         }
 
@@ -1305,10 +1320,13 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
         target[0] = '/';
         target[1] = ':';
       }
-    dostounix_filename (target);
-#endif /* DOS_NT */
-
     result = make_specified_string (target, -1, o - target, multibyte);
+    result = ENCODE_FILE (result);
+    dostounix_filename (SSDATA (result));
+    result = DECODE_FILE (result);
+#else  /* !DOS_NT */
+    result = make_specified_string (target, -1, o - target, multibyte);
+#endif /* !DOS_NT */
   }
 
   /* Again look to see if the file name has special constructs in it
@@ -1587,8 +1605,18 @@ those `/' is discarded.  */)
   memcpy (nm, SDATA (filename), SBYTES (filename) + 1);
 
 #ifdef DOS_NT
-  dostounix_filename (nm);
-  substituted = (strcmp (nm, SDATA (filename)) != 0);
+  {
+    Lisp_Object encoded_filename = ENCODE_FILE (filename);
+    Lisp_Object tem_fn;
+
+    dostounix_filename (SDATA (encoded_filename));
+    tem_fn = DECODE_FILE (encoded_filename);
+    nm = alloca (SBYTES (tem_fn) + 1);
+    memcpy (nm, SDATA (tem_fn), SBYTES (tem_fn) + 1);
+    substituted = (memcmp (nm, SDATA (filename), SBYTES (filename)) != 0);
+    if (substituted)
+      filename = tem_fn;
+  }
 #endif
   endp = nm + SBYTES (filename);
 
diff --git a/src/frame.c b/src/frame.c
index d580bf7f148..3501fc36675 100644
--- a/src/frame.c
+++ b/src/frame.c
@@ -1467,7 +1467,6 @@ and returns whatever that function returns.  */)
   f = SELECTED_FRAME ();
   x = y = Qnil;
 
-#if defined (HAVE_MOUSE) || defined (HAVE_GPM)
   /* It's okay for the hook to refrain from storing anything.  */
   if (FRAME_TERMINAL (f)->mouse_position_hook)
     {
@@ -1487,7 +1486,6 @@ and returns whatever that function returns.  */)
       XSETINT (x, col);
       XSETINT (y, row);
     }
-#endif
   XSETFRAME (lispy_dummy, f);
   retval = Fcons (lispy_dummy, Fcons (x, y));
   GCPRO1 (retval);
@@ -1514,7 +1512,6 @@ and nil for X and Y.  */)
   f = SELECTED_FRAME ();
   x = y = Qnil;
 
-#if defined (HAVE_MOUSE) || defined (HAVE_GPM)
   /* It's okay for the hook to refrain from storing anything.  */
   if (FRAME_TERMINAL (f)->mouse_position_hook)
     {
@@ -1526,7 +1523,6 @@ and nil for X and Y.  */)
                                                   &time_dummy);
     }
 
-#endif
   XSETFRAME (lispy_dummy, f);
   return Fcons (lispy_dummy, Fcons (x, y));
 }
@@ -1557,7 +1553,7 @@ before calling this function on it, like this.
     /* Warping the mouse will cause enternotify and focus events.  */
     x_set_mouse_position (XFRAME (frame), XINT (x), XINT (y));
 #else
-#if defined (MSDOS) && defined (HAVE_MOUSE)
+#if defined (MSDOS)
   if (FRAME_MSDOS_P (XFRAME (frame)))
     {
       Fselect_frame (frame, Qnil);
@@ -1598,7 +1594,7 @@ before calling this function on it, like this.
     /* Warping the mouse will cause enternotify and focus events.  */
     x_set_mouse_pixel_position (XFRAME (frame), XINT (x), XINT (y));
 #else
-#if defined (MSDOS) && defined (HAVE_MOUSE)
+#if defined (MSDOS)
   if (FRAME_MSDOS_P (XFRAME (frame)))
     {
       Fselect_frame (frame, Qnil);
diff --git a/src/frame.h b/src/frame.h
index 35cbc44becc..5ebfc2f7ec3 100644
--- a/src/frame.h
+++ b/src/frame.h
@@ -357,9 +357,6 @@ struct frame
   unsigned int external_menu_bar : 1;
 #endif
 
-  /* Nonzero if last attempt at redisplay on this frame was preempted.  */
-  unsigned display_preempted : 1;
-
   /* visible is nonzero if the frame is currently displayed; we check
      it to see if we should bother updating the frame's contents.
      DON'T SET IT DIRECTLY; instead, use FRAME_SET_VISIBLE.
@@ -933,6 +930,21 @@ typedef struct frame *FRAME_PTR;
         && (frame_var = XCAR (list_var), 1));   \
        list_var = XCDR (list_var))
 
+/* Reflect mouse movement when a complete frame update is performed.  */
+
+#define FRAME_MOUSE_UPDATE(frame)                               \
+  do {                                                          \
+    Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (frame);               \
+    if (frame == hlinfo->mouse_face_mouse_frame)                \
+      {                                                         \
+        block_input ();                                         \
+        if (hlinfo->mouse_face_mouse_frame)                     \
+          note_mouse_highlight (hlinfo->mouse_face_mouse_frame, \
+                                hlinfo->mouse_face_mouse_x,     \
+                                hlinfo->mouse_face_mouse_y);    \
+        unblock_input ();                                       \
+      }                                                         \
+  } while (0)
 
 extern Lisp_Object Qframep, Qframe_live_p;
 extern Lisp_Object Qtty, Qtty_type;
diff --git a/src/indent.c b/src/indent.c
index eee96061e25..a3abf88feeb 100644
--- a/src/indent.c
+++ b/src/indent.c
@@ -2048,7 +2048,13 @@ whether or not it is currently displayed in some window.  */)
            comment said this is "so we don't move too far" (2005-01-19
            checkin by kfs).  But this does nothing useful that I can
            tell, and it causes Bug#2694 .  -- cyd */
-        move_it_to (&it, PT, -1, -1, -1, MOVE_TO_POS);
+        /* When the position we started from is covered by a display
+           string, move_it_to will overshoot it, while vertical-motion
+           wants to put the cursor _before_ the display string.  So in
+           that case, we move to buffer position before the display
+           string, and avoid overshooting.  */
+        move_it_to (&it, disp_string_at_start_p ? PT - 1 : PT,
+                    -1, -1, -1, MOVE_TO_POS);
 
       /* IT may move too far if truncate-lines is on and PT lies
          beyond the right margin.  IT may also move too far if the
diff --git a/src/keyboard.c b/src/keyboard.c
index bf441efef90..5980ae89522 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -306,9 +306,7 @@ static Lisp_Object Qmake_frame_visible;
 static Lisp_Object Qselect_window;
 Lisp_Object Qhelp_echo;
 
-#if defined (HAVE_MOUSE) || defined (HAVE_GPM)
 static Lisp_Object Qmouse_fixup_help_message;
-#endif
 
 /* Symbols to denote kinds of events.  */
 static Lisp_Object Qfunction_key;
@@ -420,12 +418,10 @@ static Lisp_Object read_char_x_menu_prompt (ptrdiff_t, Lisp_Object *,
 static Lisp_Object read_char_minibuf_menu_prompt (int, ptrdiff_t,
                                                   Lisp_Object *);
 static Lisp_Object make_lispy_event (struct input_event *);
-#if defined (HAVE_MOUSE) || defined (HAVE_GPM)
 static Lisp_Object make_lispy_movement (struct frame *, Lisp_Object,
                                         enum scroll_bar_part,
                                         Lisp_Object, Lisp_Object,
                                         Time);
-#endif
 static Lisp_Object modify_event_symbol (ptrdiff_t, int, Lisp_Object,
                                         Lisp_Object, const char *const *,
                                         Lisp_Object *, ptrdiff_t);
@@ -1237,8 +1233,6 @@ DEFUN ("abort-recursive-edit", Fabort_recursive_edit, Sabort_recursive_edit, 0,
   user_error ("No recursive edit is in progress");
 }
 
-#if defined (HAVE_MOUSE) || defined (HAVE_GPM)
-
 /* Restore mouse tracking enablement.  See Ftrack_mouse for the only use
    of this function.  */
 
@@ -1313,7 +1307,6 @@ some_mouse_moved (void)
   return 0;
 }
 
-#endif  /* HAVE_MOUSE || HAVE_GPM */
 
 /* This is the actual command reading loop,
    sans error-handling encapsulation.  */
@@ -1405,14 +1398,11 @@ command_loop_1 (void)
 
       Vdeactivate_mark = Qnil;
 
-#if defined (HAVE_MOUSE) || defined (HAVE_GPM)
-
       /* Don't ignore mouse movements for more than a single command
          loop.  (This flag is set in xdisp.c whenever the tool bar is
          resized, because the resize moves text up or down, and would
          generate false mouse drag events if we don't ignore them.)  */
       ignore_mouse_drag_p = 0;
-#endif
 
       /* If minibuffer on and echo area in use,
          wait a short time and redraw minibuffer.  */
@@ -2185,7 +2175,6 @@ show_help_echo (Lisp_Object help, Lisp_Object window, Lisp_Object object,
         return;
     }
 
-#if defined (HAVE_MOUSE) || defined (HAVE_GPM)
   if (!noninteractive && STRINGP (help))
     {
       /* The mouse-fixup-help-message Lisp function can call
@@ -2198,7 +2187,6 @@ show_help_echo (Lisp_Object help, Lisp_Object window, Lisp_Object object,
       if (f)
         f->mouse_moved = 1;
     }
-#endif
 
   if (STRINGP (help) || NILP (help))
     {
@@ -3393,11 +3381,9 @@ readable_events (int flags)
         return 1;
     }
 
-#if defined (HAVE_MOUSE) || defined (HAVE_GPM)
   if (!(flags & READABLE_EVENTS_IGNORE_SQUEEZABLES)
       && !NILP (do_mouse_tracking) && some_mouse_moved ())
     return 1;
-#endif
   if (single_kboard)
     {
       if (current_kboard->kbd_queue_has_data)
@@ -3765,10 +3751,8 @@ kbd_buffer_get_event (KBOARD **kbp,
 
       if (kbd_fetch_ptr != kbd_store_ptr)
         break;
-#if defined (HAVE_MOUSE) || defined (HAVE_GPM)
       if (!NILP (do_mouse_tracking) && some_mouse_moved ())
         break;
-#endif
 
       /* If the quit flag is set, then read_char will return
          quit_char, so that counts as "available input."  */
@@ -3783,10 +3767,8 @@ kbd_buffer_get_event (KBOARD **kbp,
 #endif
       if (kbd_fetch_ptr != kbd_store_ptr)
         break;
-#if defined (HAVE_MOUSE) || defined (HAVE_GPM)
       if (!NILP (do_mouse_tracking) && some_mouse_moved ())
         break;
-#endif
       if (end_time)
         {
           EMACS_TIME now = current_emacs_time ();
@@ -4050,7 +4032,6 @@ kbd_buffer_get_event (KBOARD **kbp,
             }
         }
     }
-#if defined (HAVE_MOUSE) || defined (HAVE_GPM)
   /* Try generating a mouse motion event.  */
   else if (!NILP (do_mouse_tracking) && some_mouse_moved ())
     {
@@ -4095,7 +4076,6 @@ kbd_buffer_get_event (KBOARD **kbp,
       if (!NILP (x) && NILP (obj))
         obj = make_lispy_movement (f, bar_window, part, x, y, t);
     }
-#endif  /* HAVE_MOUSE || HAVE GPM */
   else
     /* We were promised by the above while loop that there was
        something for us to read!  */
@@ -5407,7 +5387,6 @@ make_lispy_event (struct input_event *event)
       return Qnil;
 #endif
 
-#ifdef HAVE_MOUSE
       /* A mouse click.  Figure out where it is, decide whether it's
          a press, click or drag, and build the appropriate structure.  */
     case MOUSE_CLICK_EVENT:
@@ -5859,7 +5838,6 @@ make_lispy_event (struct input_event *event)
                              Fcons (files,
                                     Qnil)));
       }
-#endif /* HAVE_MOUSE */
 
 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) \
     || defined (HAVE_NS) || defined (USE_GTK)
@@ -5984,8 +5962,6 @@ make_lispy_event (struct input_event *event)
     }
 }
 
-#if defined (HAVE_MOUSE) || defined (HAVE_GPM)
-
 static Lisp_Object
 make_lispy_movement (FRAME_PTR frame, Lisp_Object bar_window, enum scroll_bar_part part,
                      Lisp_Object x, Lisp_Object y, Time t)
@@ -6013,8 +5989,6 @@ make_lispy_movement (FRAME_PTR frame, Lisp_Object bar_window, enum scroll_bar_pa
     }
 }
 
-#endif /* HAVE_MOUSE || HAVE GPM */
-
 /* Construct a switch frame event.  */
 static Lisp_Object
 make_lispy_switch_frame (Lisp_Object frame)
@@ -11249,9 +11223,7 @@ init_keyboard (void)
   recent_keys_index = 0;
   kbd_fetch_ptr = kbd_buffer;
   kbd_store_ptr = kbd_buffer;
-#if defined (HAVE_MOUSE) || defined (HAVE_GPM)
   do_mouse_tracking = Qnil;
-#endif
   input_pending = 0;
   interrupt_input_blocked = 0;
   pending_signals = 0;
@@ -11406,9 +11378,7 @@ syms_of_keyboard (void)
   DEFSYM (Qvertical_scroll_bar, "vertical-scroll-bar");
   DEFSYM (Qmenu_bar, "menu-bar");
 
-#if defined (HAVE_MOUSE) || defined (HAVE_GPM)
   DEFSYM (Qmouse_fixup_help_message, "mouse-fixup-help-message");
-#endif
 
   DEFSYM (Qabove_handle, "above-handle");
   DEFSYM (Qhandle, "handle");
@@ -11528,9 +11498,7 @@ syms_of_keyboard (void)
   defsubr (&Sread_key_sequence);
   defsubr (&Sread_key_sequence_vector);
   defsubr (&Srecursive_edit);
-#if defined (HAVE_MOUSE) || defined (HAVE_GPM)
   defsubr (&Strack_mouse);
-#endif
   defsubr (&Sinput_pending_p);
   defsubr (&Scommand_execute);
   defsubr (&Srecent_keys);
diff --git a/src/lisp.h b/src/lisp.h
index ae532eed5a2..a5c4f862d37 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -1654,10 +1654,6 @@ typedef struct {
   int mouse_face_face_id;
   Lisp_Object mouse_face_overlay;
 
-  /* 1 if a mouse motion event came and we didn't handle it right away because
-     gc was in progress.  */
-  int mouse_face_deferred_gc;
-
   /* FRAME and X, Y position of mouse when last checked for
      highlighting.  X and Y can be negative or out of range for the frame.  */
   struct frame *mouse_face_mouse_frame;
diff --git a/src/makefile.w32-in b/src/makefile.w32-in
index 9778e955677..a296f6eb393 100644
--- a/src/makefile.w32-in
+++ b/src/makefile.w32-in
@@ -229,12 +229,12 @@ SOME_MACHINE_OBJECTS = dosfns.o msdos.o \
 obj = $(GLOBAL_SOURCES:.c=.o)
 
 globals.h: gl-stamp
-        @cmd /c rem true
+        @cmd $(SWITCHCHAR)c rem true
 
 gl-stamp: ../lib-src/$(BLD)/make-docfile.exe $(GLOBAL_SOURCES)
         - $(DEL) gl-tmp
         "$(THISDIR)/../lib-src/$(BLD)/make-docfile" -d . -g $(SOME_MACHINE_OBJECTS) $(obj) > gl-tmp
-        cmd /c "fc /b gl-tmp globals.h >nul 2>&1 || $(CP) gl-tmp globals.h"
+        fc.exe $(SWITCHCHAR)b gl-tmp globals.h >nul 2>&1 || $(CP) gl-tmp globals.h
         - $(DEL) gl-tmp
         echo timestamp > $@
 
@@ -413,8 +413,6 @@ CONF_POST_H    = $(SRC)/conf_post.h \
                  $(MS_W32_H)
 CONFIG_H       = $(SRC)/config.h \
                  $(CONF_POST_H)
-DIR_H          = $(NT_INC)/sys/dir.h \
-                 $(SRC)/ndir.h
 W32GUI_H       = $(SRC)/w32gui.h \
                  $(SYSTIME_H)
 DISPEXTERN_H   = $(SRC)/dispextern.h \
@@ -714,6 +712,7 @@ $(BLD)/dired.$(O) : \
         $(SRC)/blockinput.h \
         $(SRC)/commands.h \
         $(SRC)/regex.h \
+        $(NT_INC)/dirent.h \
         $(NT_INC)/pwd.h \
         $(NT_INC)/sys/stat.h \
         $(NT_INC)/unistd.h \
@@ -722,7 +721,6 @@ $(BLD)/dired.$(O) : \
         $(CHARSET_H) \
         $(CODING_H) \
         $(CONFIG_H) \
-        $(DIR_H) \
         $(FILEMODE_H) \
         $(GRP_H) \
         $(LISP_H) \
@@ -1175,11 +1173,11 @@ $(BLD)/minibuf.$(O) : \
 
 $(BLD)/w32.$(O) : \
         $(SRC)/w32.c \
-        $(SRC)/ndir.h \
         $(SRC)/w32.h \
         $(SRC)/w32common.h \
         $(SRC)/w32heap.h \
         $(SRC)/w32select.h \
+        $(NT_INC)/dirent.h \
         $(NT_INC)/pwd.h \
         $(NT_INC)/sys/file.h \
         $(NT_INC)/sys/time.h \
diff --git a/src/msdos.c b/src/msdos.c
index dd05a8b2c5d..433bf1074d8 100644
--- a/src/msdos.c
+++ b/src/msdos.c
@@ -1275,7 +1275,6 @@ IT_update_begin (struct frame *f)
       hlinfo->mouse_face_beg_row = hlinfo->mouse_face_beg_col = -1;
       hlinfo->mouse_face_end_row = hlinfo->mouse_face_end_col = -1;
       hlinfo->mouse_face_window = Qnil;
-      hlinfo->mouse_face_deferred_gc = 0;
       hlinfo->mouse_face_mouse_frame = NULL;
     }
 
@@ -1295,21 +1294,10 @@ IT_update_end (struct frame *f)
 static void
 IT_frame_up_to_date (struct frame *f)
 {
-  Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
   Lisp_Object new_cursor, frame_desired_cursor;
   struct window *sw;
 
-  if (hlinfo->mouse_face_deferred_gc
-      || (f && f == hlinfo->mouse_face_mouse_frame))
-    {
-      block_input ();
-      if (hlinfo->mouse_face_mouse_frame)
-        note_mouse_highlight (hlinfo->mouse_face_mouse_frame,
-                              hlinfo->mouse_face_mouse_x,
-                              hlinfo->mouse_face_mouse_y);
-      hlinfo->mouse_face_deferred_gc = 0;
-      unblock_input ();
-    }
+  FRAME_MOUSE_UPDATE (f);
 
   /* Set the cursor type to whatever they wanted.  In a minibuffer
      window, we want the cursor to appear only if we are reading input
@@ -1849,7 +1837,6 @@ internal_terminal_init (void)
             FRAME_BACKGROUND_PIXEL (SELECTED_FRAME ()) = colors[1];
         }
       the_only_display_info.mouse_highlight.mouse_face_mouse_frame = NULL;
-      the_only_display_info.mouse_highlight.mouse_face_deferred_gc = 0;
       the_only_display_info.mouse_highlight.mouse_face_beg_row =
         the_only_display_info.mouse_highlight.mouse_face_beg_col = -1;
       the_only_display_info.mouse_highlight.mouse_face_end_row =
diff --git a/src/ndir.h b/src/ndir.h
deleted file mode 100644
index cd7cdbe55f5..00000000000
--- a/src/ndir.h
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
-        <dir.h> -- definitions for 4.2BSD-compatible directory access
-
-        last edit:      09-Jul-1983     D A Gwyn
-
- * The code here is forced by the interface, and is not subject to
- * copyright, constituting the only possible expression of the
- * algorithm in this format.
- */
-
-#define DIRBLKSIZ       512             /* size of directory block */
-#ifdef WINDOWSNT
-#define MAXNAMLEN       255
-#else  /* not WINDOWSNT */
-#define MAXNAMLEN       15              /* maximum filename length */
-#endif /* not WINDOWSNT */
-        /* NOTE:  MAXNAMLEN must be one less than a multiple of 4 */
-
-struct direct                           /* data from readdir() */
-        {
-        long            d_ino;          /* inode number of entry */
-        unsigned short  d_reclen;       /* length of this record */
-        unsigned short  d_namlen;       /* length of string in d_name */
-        char            d_name[MAXNAMLEN+1];    /* name of file */
-        };
-
-typedef struct
-        {
-        int     dd_fd;                  /* file descriptor */
-        int     dd_loc;                 /* offset in block */
-        int     dd_size;                /* amount of valid data */
-        char    dd_buf[DIRBLKSIZ];      /* directory block */
-        }       DIR;                    /* stream data from opendir() */
-
-extern DIR              *opendir (char *);
-extern struct direct    *readdir (DIR *);
-extern void             seekdir (DIR *, long);
-extern void             closedir (DIR *);
-
-#define rewinddir( dirp )       seekdir( dirp, 0L )
-
diff --git a/src/nsterm.h b/src/nsterm.h
index 2e868b86caf..005701ed415 100644
--- a/src/nsterm.h
+++ b/src/nsterm.h
@@ -630,8 +630,7 @@ struct ns_output
 /* this dummy decl needed to support TTYs */
 struct x_output
 {
-  unsigned long background_pixel;
-  unsigned long foreground_pixel;
+  int unused;
 };
 
 
diff --git a/src/nsterm.m b/src/nsterm.m
index 57d32ee0528..25eb7ebc495 100644
--- a/src/nsterm.m
+++ b/src/nsterm.m
@@ -1186,7 +1186,6 @@ x_free_frame_resources (struct frame *f)
       hlinfo->mouse_face_beg_row = hlinfo->mouse_face_beg_col = -1;
       hlinfo->mouse_face_end_row = hlinfo->mouse_face_end_col = -1;
       hlinfo->mouse_face_window = Qnil;
-      hlinfo->mouse_face_deferred_gc = 0;
       hlinfo->mouse_face_mouse_frame = 0;
     }
 
@@ -1887,8 +1886,7 @@ static void
 ns_frame_up_to_date (struct frame *f)
 /* --------------------------------------------------------------------------
     External (hook): Fix up mouse highlighting right after a full update.
-    Some highlighting was deferred if GC was happening during
-    note_mouse_highlight (), while other highlighting was deferred for update.
+    Can't use FRAME_MOUSE_UPDATE due to ns_frame_begin and ns_frame_end calls.
    -------------------------------------------------------------------------- */
 {
   NSTRACE (ns_frame_up_to_date);
@@ -1896,19 +1894,17 @@ ns_frame_up_to_date (struct frame *f)
   if (FRAME_NS_P (f))
     {
       Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
-      if ((hlinfo->mouse_face_deferred_gc || f ==hlinfo->mouse_face_mouse_frame)
-      /*&& hlinfo->mouse_face_mouse_frame*/)
-        {
-          block_input ();
+      if (f == hlinfo->mouse_face_mouse_frame)
+        {
+          block_input ();
           ns_update_begin(f);
-          if (hlinfo->mouse_face_mouse_frame)
-            note_mouse_highlight (hlinfo->mouse_face_mouse_frame,
-                                  hlinfo->mouse_face_mouse_x,
-                                  hlinfo->mouse_face_mouse_y);
-          hlinfo->mouse_face_deferred_gc = 0;
+          if (hlinfo->mouse_face_mouse_frame)
+            note_mouse_highlight (hlinfo->mouse_face_mouse_frame,
+                                  hlinfo->mouse_face_mouse_x,
+                                  hlinfo->mouse_face_mouse_y);
           ns_update_end(f);
-          unblock_input ();
-        }
+          unblock_input ();
+        }
     }
 }
 
@@ -3869,7 +3865,6 @@ ns_initialize_display_info (struct ns_display_info *dpyinfo)
     dpyinfo->root_window = 42; /* a placeholder.. */
 
     hlinfo->mouse_face_mouse_frame = NULL;
-    hlinfo->mouse_face_deferred_gc = 0;
     hlinfo->mouse_face_beg_row = hlinfo->mouse_face_beg_col = -1;
     hlinfo->mouse_face_end_row = hlinfo->mouse_face_end_col = -1;
     hlinfo->mouse_face_face_id = DEFAULT_FACE_ID;
diff --git a/src/sysdep.c b/src/sysdep.c
index 7c5c144fa8c..1a3834f0379 100644
--- a/src/sysdep.c
+++ b/src/sysdep.c
@@ -101,7 +101,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #define _P_WAIT 0
 int _cdecl _spawnlp (int, const char *, const char *, ...);
 int _cdecl _getpid (void);
-extern char *getwd (char *);
 #endif
 
 #include "syssignal.h"
@@ -134,12 +133,12 @@ char*
 get_current_dir_name (void)
 {
   char *buf;
-  char *pwd;
+  char *pwd = getenv ("PWD");
   struct stat dotstat, pwdstat;
-  /* If PWD is accurate, use it instead of calling getwd.  PWD is
+  /* If PWD is accurate, use it instead of calling getcwd.  PWD is
      sometimes a nicer name, and using it may avoid a fatal error if a
      parent directory is searchable but not readable.  */
-    if ((pwd = getenv ("PWD")) != 0
+  if (pwd
       && (IS_DIRECTORY_SEP (*pwd) || (*pwd && IS_DEVICE_SEP (pwd[1])))
       && stat (pwd, &pwdstat) == 0
       && stat (".", &dotstat) == 0
@@ -155,7 +154,6 @@ get_current_dir_name (void)
         return NULL;
       strcpy (buf, pwd);
     }
-#ifdef HAVE_GETCWD
   else
     {
       size_t buf_size = 1024;
@@ -179,22 +177,6 @@ get_current_dir_name (void)
             return NULL;
         }
     }
-#else
-  else
-    {
-      /* We need MAXPATHLEN here.  */
-      buf = malloc (MAXPATHLEN + 1);
-      if (!buf)
-        return NULL;
-      if (getwd (buf) == NULL)
-        {
-          int tmp_errno = errno;
-          free (buf);
-          errno = tmp_errno;
-          return NULL;
-        }
-    }
-#endif
   return buf;
 }
 #endif
@@ -471,7 +453,7 @@ sys_subshell (void)
   int st;
   char oldwd[MAXPATHLEN+1]; /* Fixed length is safe on MSDOS.  */
 #endif
-  int pid;
+  pid_t pid;
   struct save_signal saved_handlers[5];
   Lisp_Object dir;
   unsigned char *volatile str_volatile = 0;
@@ -521,7 +503,7 @@ sys_subshell (void)
       const char *sh = 0;
 
 #ifdef DOS_NT    /* MW, Aug 1993 */
-      getwd (oldwd);
+      getcwd (oldwd, sizeof oldwd);
       if (sh == 0)
         sh = (char *) egetenv ("SUSPEND");      /* KFS, 1994-12-14 */
 #endif
@@ -2238,82 +2220,6 @@ emacs_readlink (char const *filename, char initial_buf[READLINK_BUFSIZE])
                        &emacs_norealloc_allocator, careadlinkatcwd);
 }
 
-#ifdef USG
-/*
- *      All of the following are for USG.
- *
- *      On USG systems the system calls are INTERRUPTIBLE by signals
- *      that the user program has elected to catch.  Thus the system call
- *      must be retried in these cases.  To handle this without massive
- *      changes in the source code, we remap the standard system call names
- *      to names for our own functions in sysdep.c that do the system call
- *      with retries.  Actually, for portability reasons, it is good
- *      programming practice, as this example shows, to limit all actual
- *      system calls to a single occurrence in the source.  Sure, this
- *      adds an extra level of function call overhead but it is almost
- *      always negligible.   Fred Fish, Unisoft Systems Inc.
- */
-
-/*
- *      Warning, this function may not duplicate 4.2 action properly
- *      under error conditions.
- */
-
-#if !defined (HAVE_GETWD) || defined (BROKEN_GETWD)
-
-#ifndef MAXPATHLEN
-/* In 4.1, param.h fails to define this.  */
-#define MAXPATHLEN 1024
-#endif
-
-char *
-getwd (char *pathname)
-{
-  char *npath, *spath;
-  extern char *getcwd (char *, size_t);
-
-  block_input ();                       /* getcwd uses malloc */
-  spath = npath = getcwd ((char *) 0, MAXPATHLEN);
-  if (spath == 0)
-    {
-      unblock_input ();
-      return spath;
-    }
-  /* On Altos 3068, getcwd can return @hostname/dir, so discard
-     up to first slash.  Should be harmless on other systems.  */
-  while (*npath && *npath != '/')
-    npath++;
-  strcpy (pathname, npath);
-  free (spath);                 /* getcwd uses malloc */
-  unblock_input ();
-  return pathname;
-}
-
-#endif /* !defined (HAVE_GETWD) || defined (BROKEN_GETWD) */
-#endif /* USG */
-
-/* Directory routines for systems that don't have them. */
-
-#ifdef HAVE_DIRENT_H
-
-#include <dirent.h>
-
-#if !defined (HAVE_CLOSEDIR)
-
-int
-closedir (DIR *dirp /* stream from opendir */)
-{
-  int rtnval;
-
-  rtnval = emacs_close (dirp->dd_fd);
-  xfree (dirp);
-
-  return rtnval;
-}
-#endif /* not HAVE_CLOSEDIR */
-#endif /* HAVE_DIRENT_H */
-
-
 /* Return a struct timeval that is roughly equivalent to T.
    Use the least timeval not less than T.
    Return an extremal value if the result would overflow.  */
diff --git a/src/w32.c b/src/w32.c
index 94cf472a4ae..c8e16dfaa94 100644
--- a/src/w32.c
+++ b/src/w32.c
@@ -119,9 +119,10 @@ typedef struct _PROCESS_MEMORY_COUNTERS_EX {
 #include <aclapi.h>
 
 #ifdef _MSC_VER
-/* MSVC doesn't provide the definition of REPARSE_DATA_BUFFER, except
-   on ntifs.h, which cannot be included because it triggers conflicts
-   with other Windows API headers.  So we define it here by hand.  */
+/* MSVC doesn't provide the definition of REPARSE_DATA_BUFFER and the
+   associated macros, except on ntifs.h, which cannot be included
+   because it triggers conflicts with other Windows API headers.  So
+   we define it here by hand.  */
 
 typedef struct _REPARSE_DATA_BUFFER {
     ULONG  ReparseTag;
@@ -149,6 +150,12 @@ typedef struct _REPARSE_DATA_BUFFER {
     } DUMMYUNIONNAME;
 } REPARSE_DATA_BUFFER, *PREPARSE_DATA_BUFFER;
 
+#define FILE_DEVICE_FILE_SYSTEM 9
+#define METHOD_BUFFERED         0
+#define FILE_ANY_ACCESS         0x00000000
+#define CTL_CODE(t,f,m,a)       (((t)<<16)|((a)<<14)|((f)<<2)|(m))
+#define FSCTL_GET_REPARSE_POINT \
+  CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 42, METHOD_BUFFERED, FILE_ANY_ACCESS)
 #endif
 
 /* TCP connection support.  */
@@ -172,7 +179,7 @@ typedef struct _REPARSE_DATA_BUFFER {
 #undef sendto
 
 #include "w32.h"
-#include "ndir.h"
+#include <dirent.h>
 #include "w32common.h"
 #include "w32heap.h"
 #include "w32select.h"
@@ -901,8 +908,18 @@ static char startup_dir[MAXPATHLEN];
 
 /* Get the current working directory.  */
 char *
-getwd (char *dir)
+getcwd (char *dir, int dirsize)
 {
+  if (!dirsize)
+    {
+      errno = EINVAL;
+      return NULL;
+    }
+  if (dirsize <= strlen (startup_dir))
+    {
+      errno = ERANGE;
+      return NULL;
+    }
 #if 0
   if (GetCurrentDirectory (MAXPATHLEN, dir) > 0)
     return dir;
@@ -1818,7 +1835,7 @@ init_environment (char ** argv)
         memcpy (*envp, "COMSPEC=", 8);
   }
 
-  /* Remember the initial working directory for getwd.  */
+  /* Remember the initial working directory for getcwd.  */
   /* FIXME: Do we need to resolve possible symlinks in startup_dir?
      Does it matter anywhere in Emacs?  */
   if (!GetCurrentDirectory (MAXPATHLEN, startup_dir))
@@ -2431,7 +2448,7 @@ is_exec (const char * name)
    and readdir.  We can't use the procedures supplied in sysdep.c,
    so we provide them here.  */
 
-struct direct dir_static;       /* simulated directory contents */
+struct dirent dir_static;       /* simulated directory contents */
 static HANDLE dir_find_handle = INVALID_HANDLE_VALUE;
 static int    dir_is_fat;
 static char   dir_pathname[MAXPATHLEN+1];
@@ -2501,7 +2518,7 @@ closedir (DIR *dirp)
   xfree ((char *) dirp);
 }
 
-struct direct *
+struct dirent *
 readdir (DIR *dirp)
 {
   int downcase = !NILP (Vw32_downcase_file_names);
@@ -2555,7 +2572,7 @@ readdir (DIR *dirp)
       downcase = 1;     /* 8+3 aliases are returned in all caps */
     }
   dir_static.d_namlen = strlen (dir_static.d_name);
-  dir_static.d_reclen = sizeof (struct direct) - MAXNAMLEN + 3 +
+  dir_static.d_reclen = sizeof (struct dirent) - MAXNAMLEN + 3 +
     dir_static.d_namlen - dir_static.d_namlen % 4;
 
   /* If the file name in cFileName[] includes `?' characters, it means
diff --git a/src/w32.h b/src/w32.h
index 8309a3cc23d..23eda830268 100644
--- a/src/w32.h
+++ b/src/w32.h
@@ -163,7 +163,6 @@ extern int sys_spawnve (int, char *, char **, char **);
 extern void register_child (int, int);
 
 extern void sys_sleep (int);
-extern char *getwd (char *);
 extern int sys_link (const char *, const char *);
 
 
@@ -181,4 +180,3 @@ extern ssize_t emacs_gnutls_push (gnutls_transport_ptr_t p,
 #endif /* HAVE_GNUTLS */
 
 #endif /* EMACS_W32_H */
-
diff --git a/src/w32menu.c b/src/w32menu.c
index 36bf9574fdc..84fb1bdc71e 100644
--- a/src/w32menu.c
+++ b/src/w32menu.c
@@ -114,17 +114,6 @@ static int fill_in_menu (HMENU, widget_value *);
 
 void w32_free_menu_strings (HWND);
 
-
-
-/* This is set nonzero after the user activates the menu bar, and set
-   to zero again after the menu bars are redisplayed by prepare_menu_bar.
-   While it is nonzero, all calls to set_frame_menubar go deep.
-
-   I don't understand why this is needed, but it does seem to be
-   needed on Motif, according to Marcus Daniels <marcus@sysc.pdx.edu>.  */
-
-int pending_menu_activation;
-
 #ifdef HAVE_MENUS
 
 DEFUN ("x-popup-dialog", Fx_popup_dialog, Sx_popup_dialog, 2, 3, 0,
@@ -389,8 +378,6 @@ set_frame_menubar (FRAME_PTR f, bool first_time, bool deep_p)
 
   if (! menubar_widget)
     deep_p = 1;
-  else if (pending_menu_activation && !deep_p)
-    deep_p = 1;
 
   if (deep_p)
     {
diff --git a/src/w32term.c b/src/w32term.c
index 032912c27f4..ab6afd32c75 100644
--- a/src/w32term.c
+++ b/src/w32term.c
@@ -723,21 +723,7 @@ static void
 w32_frame_up_to_date (struct frame *f)
 {
   if (FRAME_W32_P (f))
-    {
-      Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
-
-      if (hlinfo->mouse_face_deferred_gc
-          || f == hlinfo->mouse_face_mouse_frame)
-        {
-          block_input ();
-          if (hlinfo->mouse_face_mouse_frame)
-            note_mouse_highlight (hlinfo->mouse_face_mouse_frame,
-                                  hlinfo->mouse_face_mouse_x,
-                                  hlinfo->mouse_face_mouse_y);
-          hlinfo->mouse_face_deferred_gc = 0;
-          unblock_input ();
-        }
-    }
+    FRAME_MOUSE_UPDATE (f);
 }
 
 
@@ -5979,7 +5965,6 @@ x_free_frame_resources (struct frame *f)
       hlinfo->mouse_face_end_row
         = hlinfo->mouse_face_end_col = -1;
       hlinfo->mouse_face_window = Qnil;
-      hlinfo->mouse_face_deferred_gc = 0;
       hlinfo->mouse_face_mouse_frame = 0;
     }
 
diff --git a/src/w32term.h b/src/w32term.h
index 83535b8faa3..28d4ca6c490 100644
--- a/src/w32term.h
+++ b/src/w32term.h
@@ -251,16 +251,10 @@ extern Lisp_Object x_get_focus_frame (struct frame *);
    diffs between X and w32 code.  */
 struct x_output
 {
-#if 0 /* These are also defined in struct frame.  Use that instead.  */
-  PIX_TYPE background_pixel;
-  PIX_TYPE foreground_pixel;
-#endif
-
   /* Keep track of focus.  May be EXPLICIT if we received a FocusIn for this
      frame, or IMPLICIT if we received an EnterNotify.
      FocusOut and LeaveNotify clears EXPLICIT/IMPLICIT. */
   int focus_state;
-
 };
 
 enum
@@ -347,17 +341,13 @@ struct w32_output
 
   /* Nonzero means our parent is another application's window
      and was explicitly specified.  */
-  char explicit_parent;
+  unsigned explicit_parent : 1;
 
   /* Nonzero means tried already to make this frame visible.  */
-  char asked_for_visible;
+  unsigned asked_for_visible : 1;
 
   /* Nonzero means menubar is currently active.  */
-  char menubar_active;
-
-  /* Nonzero means menubar is about to become active, but should be
-     brought up to date first.  */
-  volatile char pending_menu_activation;
+  unsigned menubar_active : 1;
 
   /* Relief GCs, colors etc.  */
   struct relief
@@ -751,7 +741,7 @@ extern int w32_system_caret_y;
 typedef BOOL (CALLBACK *LOCALE_ENUMPROCA)(LPSTR);
 typedef BOOL (CALLBACK *LOCALE_ENUMPROCW)(LPWSTR);
 BOOL WINAPI EnumSystemLocalesA(LOCALE_ENUMPROCA,DWORD);
-BOOL WINAPI EnumSystemLocalesW(LOCALE_ENUMPROCW,DWORD)
+BOOL WINAPI EnumSystemLocalesW(LOCALE_ENUMPROCW,DWORD);
 #ifdef UNICODE
 #define EnumSystemLocales EnumSystemLocalesW
 #else
diff --git a/src/xdisp.c b/src/xdisp.c
index a14c54dfc23..f212c39607f 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -9696,7 +9696,7 @@ message2_nolog (const char *m, ptrdiff_t nbytes, int multibyte)
       do_pending_window_change (0);
       echo_area_display (1);
       do_pending_window_change (0);
-      if (FRAME_TERMINAL (f)->frame_up_to_date_hook != 0 && ! gc_in_progress)
+      if (FRAME_TERMINAL (f)->frame_up_to_date_hook)
         (*FRAME_TERMINAL (f)->frame_up_to_date_hook) (f);
     }
 }
@@ -9793,7 +9793,7 @@ message3_nolog (Lisp_Object m, ptrdiff_t nbytes, int multibyte)
       do_pending_window_change (0);
       echo_area_display (1);
       do_pending_window_change (0);
-      if (FRAME_TERMINAL (f)->frame_up_to_date_hook != 0 && ! gc_in_progress)
+      if (FRAME_TERMINAL (f)->frame_up_to_date_hook)
         (*FRAME_TERMINAL (f)->frame_up_to_date_hook) (f);
     }
 }
@@ -10962,6 +10962,21 @@ window_outdated (struct window *w)
           || w->last_overlay_modified < OVERLAY_MODIFF);
 }
 
+/* Nonzero if W's buffer was changed but not saved or Transient Mark mode
+   is enabled and mark of W's buffer was changed since last W's update.  */
+
+static int
+window_buffer_changed (struct window *w)
+{
+  struct buffer *b = XBUFFER (w->buffer);
+
+  eassert (BUFFER_LIVE_P (b));
+
+  return (((BUF_SAVE_MODIFF (b) < BUF_MODIFF (b)) != w->last_had_star)
+          || ((!NILP (Vtransient_mark_mode) && !NILP (BVAR (b, mark_active)))
+              != !NILP (w->region_showing)));
+}
+
 /***********************************************************************
                      Mode Lines and Frame Titles
  ***********************************************************************/
@@ -11381,12 +11396,7 @@ update_menu_bar (struct frame *f, int save_match_data, int hooks_run)
           /* This used to test w->update_mode_line, but we believe
              there is no need to recompute the menu in that case.  */
           || update_mode_lines
-          || ((BUF_SAVE_MODIFF (XBUFFER (w->buffer))
-               < BUF_MODIFF (XBUFFER (w->buffer)))
-              != w->last_had_star)
-          || ((!NILP (Vtransient_mark_mode)
-               && !NILP (BVAR (XBUFFER (w->buffer), mark_active)))
-              != !NILP (w->region_showing)))
+          || window_buffer_changed (w))
         {
           struct buffer *prev = current_buffer;
           ptrdiff_t count = SPECPDL_INDEX ();
@@ -11538,11 +11548,18 @@ FRAME_PTR last_mouse_frame;
 
 int last_tool_bar_item;
 
-
+/* Select `frame' temporarily without running all the code in
+   do_switch_frame.
+   FIXME: Maybe do_switch_frame should be trimmed down similarly
+   when `norecord' is set.  */
 static Lisp_Object
-update_tool_bar_unwind (Lisp_Object frame)
+fast_set_selected_frame (Lisp_Object frame)
 {
-  selected_frame = frame;
+  if (!EQ (selected_frame, frame))
+    {
+      selected_frame = frame;
+      selected_window = XFRAME (frame)->selected_window;
+    }
   return Qnil;
 }
 
@@ -11579,12 +11596,7 @@ update_tool_bar (struct frame *f, int save_match_data)
       if (windows_or_buffers_changed
           || w->update_mode_line
           || update_mode_lines
-          || ((BUF_SAVE_MODIFF (XBUFFER (w->buffer))
-               < BUF_MODIFF (XBUFFER (w->buffer)))
-              != w->last_had_star)
-          || ((!NILP (Vtransient_mark_mode)
-               && !NILP (BVAR (XBUFFER (w->buffer), mark_active)))
-              != !NILP (w->region_showing)))
+          || window_buffer_changed (w))
         {
           struct buffer *prev = current_buffer;
           ptrdiff_t count = SPECPDL_INDEX ();
@@ -11614,9 +11626,13 @@ update_tool_bar (struct frame *f, int save_match_data)
              before calling tool_bar_items, because the calculation of
              the tool-bar keymap uses the selected frame (see
              `tool-bar-make-keymap' in tool-bar.el).  */
-          record_unwind_protect (update_tool_bar_unwind, selected_frame);
+          eassert (EQ (selected_window,
+                       /* Since we only explicitly preserve selected_frame,
+                          check that selected_window would be redundant.  */
+                       XFRAME (selected_frame)->selected_window));
+          record_unwind_protect (fast_set_selected_frame, selected_frame);
           XSETFRAME (frame, f);
-          selected_frame = frame;
+          fast_set_selected_frame (frame);
 
           /* Build desired tool-bar items from keymaps.  */
           new_tool_bar
@@ -13031,7 +13047,7 @@ redisplay_internal (void)
   ptrdiff_t count, count1;
   struct frame *sf;
   int polling_stopped_here = 0;
-  Lisp_Object old_frame = selected_frame;
+  Lisp_Object tail, frame, old_frame = selected_frame;
   struct backtrace backtrace;
 
   /* Non-zero means redisplay has to consider all windows on all
@@ -13083,15 +13099,8 @@ redisplay_internal (void)
   backtrace.debug_on_exit = 0;
   backtrace_list = &backtrace;
 
-  {
-    Lisp_Object tail, frame;
-
-    FOR_EACH_FRAME (tail, frame)
-      {
-        struct frame *f = XFRAME (frame);
-        f->already_hscrolled_p = 0;
-      }
-  }
+  FOR_EACH_FRAME (tail, frame)
+    XFRAME (frame)->already_hscrolled_p = 0;
 
  retry:
   /* Remember the currently selected window.  */
@@ -13141,25 +13150,20 @@ redisplay_internal (void)
       FRAME_TTY (sf)->previous_frame = sf;
     }
 
-  /* Set the visible flags for all frames.  Do this before checking
-     for resized or garbaged frames; they want to know if their frames
-     are visible.  See the comment in frame.h for
-     FRAME_SAMPLE_VISIBILITY.  */
-  {
-    Lisp_Object tail, frame;
-
-    number_of_visible_frames = 0;
+  /* Set the visible flags for all frames.  Do this before checking for
+     resized or garbaged frames; they want to know if their frames are
+     visible.  See the comment in frame.h for FRAME_SAMPLE_VISIBILITY.  */
+  number_of_visible_frames = 0;
 
-    FOR_EACH_FRAME (tail, frame)
-      {
-        struct frame *f = XFRAME (frame);
+  FOR_EACH_FRAME (tail, frame)
+    {
+      struct frame *f = XFRAME (frame);
 
-        FRAME_SAMPLE_VISIBILITY (f);
-        if (FRAME_VISIBLE_P (f))
-          ++number_of_visible_frames;
-        clear_desired_matrices (f);
-      }
-  }
+      FRAME_SAMPLE_VISIBILITY (f);
+      if (FRAME_VISIBLE_P (f))
+        ++number_of_visible_frames;
+      clear_desired_matrices (f);
+    }
 
   /* Notice any pending interrupt request to change frame size.  */
   do_pending_window_change (1);
@@ -13517,8 +13521,6 @@ redisplay_internal (void)
 
   if (consider_all_windows_p)
     {
-      Lisp_Object tail, frame;
-
       FOR_EACH_FRAME (tail, frame)
         XFRAME (frame)->updated_p = 0;
 
@@ -13728,7 +13730,6 @@ redisplay_internal (void)
      frames here explicitly.  */
   if (!pending)
     {
-      Lisp_Object tail, frame;
       int new_count = 0;
 
       FOR_EACH_FRAME (tail, frame)
@@ -14293,7 +14294,7 @@ set_cursor_from_row (struct window *w, struct glyph_row *row,
      GLYPH_BEFORE and GLYPH_AFTER.  */
   if (!((row->reversed_p ? glyph > glyphs_end : glyph < glyphs_end)
         && BUFFERP (glyph->object) && glyph->charpos == pt_old)
-      && bpos_covered < pt_old)
+      && !(bpos_max < pt_old && pt_old <= bpos_covered))
     {
       /* An empty line has a single glyph whose OBJECT is zero and
          whose CHARPOS is the position of a newline on that line.
@@ -27936,12 +27937,6 @@ note_mouse_highlight (struct frame *f, int x, int y)
   if (hlinfo->mouse_face_defer)
     return;
 
-  if (gc_in_progress)
-    {
-      hlinfo->mouse_face_deferred_gc = 1;
-      return;
-    }
-
   /* Which window is that in?  */
   window = window_from_coordinates (f, x, y, &part, 1);
 
diff --git a/src/xftfont.c b/src/xftfont.c
index 372ed87705f..181a1da9b38 100644
--- a/src/xftfont.c
+++ b/src/xftfont.c
@@ -369,7 +369,7 @@ xftfont_open (FRAME_PTR f, Lisp_Object entity, int pixel_size)
   ASET (font_object, FONT_FORMAT_INDEX,
         ftfont_font_format (xftfont->pattern, filename));
   font = XFONT_OBJECT (font_object);
-  font->pixel_size = pixel_size;
+  font->pixel_size = size;
   font->driver = &xftfont_driver;
   font->encoding_charset = font->repertory_charset = -1;
 
@@ -387,8 +387,6 @@ xftfont_open (FRAME_PTR f, Lisp_Object entity, int pixel_size)
       xftfont_info->matrix.xy = 0x10000L * matrix->xy;
       xftfont_info->matrix.yx = 0x10000L * matrix->yx;
     }
-  font->pixel_size = size;
-  font->driver = &xftfont_driver;
   if (INTEGERP (AREF (entity, FONT_SPACING_INDEX)))
     spacing = XINT (AREF (entity, FONT_SPACING_INDEX));
   else
diff --git a/src/xterm.c b/src/xterm.c
index ef0b2267dcd..b5b8f03da48 100644
--- a/src/xterm.c
+++ b/src/xterm.c
@@ -672,21 +672,7 @@ static void
 XTframe_up_to_date (struct frame *f)
 {
   if (FRAME_X_P (f))
-    {
-      Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
-
-      if (hlinfo->mouse_face_deferred_gc
-          || f == hlinfo->mouse_face_mouse_frame)
-        {
-          block_input ();
-          if (hlinfo->mouse_face_mouse_frame)
-            note_mouse_highlight (hlinfo->mouse_face_mouse_frame,
-                                  hlinfo->mouse_face_mouse_x,
-                                  hlinfo->mouse_face_mouse_y);
-          hlinfo->mouse_face_deferred_gc = 0;
-          unblock_input ();
-        }
-    }
+    FRAME_MOUSE_UPDATE (f);
 }
 
 
@@ -9516,7 +9502,6 @@ x_free_frame_resources (struct frame *f)
       hlinfo->mouse_face_end_row
         = hlinfo->mouse_face_end_col = -1;
       hlinfo->mouse_face_window = Qnil;
-      hlinfo->mouse_face_deferred_gc = 0;
       hlinfo->mouse_face_mouse_frame = 0;
     }
 
@@ -10171,7 +10156,6 @@ x_term_init (Lisp_Object display_name, char *xrm_option, char *resource_name)
   dpyinfo->bitmaps_last = 0;
   dpyinfo->scratch_cursor_gc = 0;
   hlinfo->mouse_face_mouse_frame = 0;
-  hlinfo->mouse_face_deferred_gc = 0;
   hlinfo->mouse_face_beg_row = hlinfo->mouse_face_beg_col = -1;
   hlinfo->mouse_face_end_row = hlinfo->mouse_face_end_col = -1;
   hlinfo->mouse_face_face_id = DEFAULT_FACE_ID;
diff --git a/src/xterm.h b/src/xterm.h
index 6ef3d11fe48..d63ed1c4583 100644
--- a/src/xterm.h
+++ b/src/xterm.h
@@ -506,12 +506,6 @@ struct x_output
      value contains an ID of the fontset, else -1.  */
   int fontset;
 
-  /* Pixel values used for various purposes.
-     border_pixel may be -1 meaning use a gray tile.  */
-#if 0 /* These are also defined in struct frame.  Use that instead.  */
-  unsigned long background_pixel;
-  unsigned long foreground_pixel;
-#endif
   unsigned long cursor_pixel;
   unsigned long border_pixel;
   unsigned long mouse_pixel;
@@ -574,13 +568,13 @@ struct x_output
 
   /* Nonzero means our parent is another application's window
      and was explicitly specified.  */
-  char explicit_parent;
+  unsigned explicit_parent : 1;
 
   /* Nonzero means tried already to make this frame visible.  */
-  char asked_for_visible;
+  unsigned asked_for_visible : 1;
 
   /* Nonzero if this frame was ever previously visible.  */
-  char has_been_visible;
+  unsigned has_been_visible : 1;
 
 #ifdef HAVE_X_I18N
   /* Input context (currently, this means Compose key handler setup).  */
@@ -634,7 +628,7 @@ struct x_output
   int top_before_move;
 
   /* Non-zero if _NET_WM_STATE_HIDDEN is set for this frame.  */
-  int net_wm_state_hidden_seen;
+  unsigned net_wm_state_hidden_seen : 1;
 };
 
 #define No_Cursor (None)