* frames.texi (Resources): Describe inhibit-x-resources.

(Size Parameters): Copyedit.

* hash.texi (Creating Hash):
* objects.texi (Hash Table Type): Document the new hash table
printed representation.

* minibuf.texi (Basic Completion): 4th arg to all-completions is
obsolete.

* processes.texi (Process Buffers): Document
process-kill-buffer-query-function.

doc/lispref/ChangeLog

+2009-12-25  Chong Yidong  <cyd@stupidchicken.com>
+
+	* frames.texi (Resources): Describe inhibit-x-resources.
+	(Size Parameters): Copyedit.
+
+	* hash.texi (Creating Hash):
+	* objects.texi (Hash Table Type): Document the new hash table
+	printed representation.
+
+	* minibuf.texi (Basic Completion): 4th arg to all-completions is
+	obsolete.
+
+	* processes.texi (Process Buffers): Document
+	process-kill-buffer-query-function.
+
 2009-12-05  Glenn Morris  <rgm@gnu.org>
 
 	* hooks.texi (Standard Hooks): Remove diary-display-hook, replaced by

doc/lispref/frames.texi

@@ -610,15 +610,15 @@ the @code{user-position} parameter (see above) does for the position
 parameters @code{top} and @code{left}.
 
 @item fullscreen
-Specify that width, height or both shall be maximized.
-The value @code{fullwidth} specifies that width shall be as wide as possible.
+Specify that width, height or both shall be maximized.  The value
+@code{fullwidth} specifies that width shall be as wide as possible.
 The value @code{fullheight} specifies that height shall be as tall as
-possible.  The value @code{fullboth} specifies that both the
-width and the height shall be set to the size of the screen.
-The value @code{maximized} specifies that the frame shall be maximized.
-The difference between @code{maximized} and @code{fullboth} is that
-the first does have window manager decorations but the second does not
-and thus really covers the whole screen.
+possible.  The value @code{fullboth} specifies that both the width and
+the height shall be set to the size of the screen.  The value
+@code{maximized} specifies that the frame shall be maximized.  The
+difference between @code{maximized} and @code{fullboth} is that the
+former still has window manager decorations while the latter really
+covers the whole screen.
 @end table
 
 @node Layout Parameters
@@ -2166,6 +2166,11 @@ If the name @var{color} is not defined, the value is @code{nil}.
 @node Resources
 @section X Resources
 
+This section describes some of the functions and variables for
+querying and using X resources, or their equivalent on your operating
+system.  @xref{X Resources,, X Resources, emacs, The GNU Emacs
+Manual}, for more information about X resources.
+
 @defun x-get-resource attribute class &optional component subclass
 The function @code{x-get-resource} retrieves a resource value from the X
 Window defaults database.
@@ -2219,7 +2224,11 @@ or @file{~/.Xresources}).  Then:
 @end group
 @end example
 
-  @xref{X Resources,, X Resources, emacs, The GNU Emacs Manual}.
+@defvar inhibit-x-resources
+If this variable is non-@code{nil}, Emacs does not look up X
+resources, and X resources do not have any effect when creating new
+frames.
+@end defvar
 
 @node Display Feature Testing
 @section Display Feature Testing

doc/lispref/hash.texi

@@ -30,18 +30,13 @@ the way two alists can share a common tail.
 @end itemize
 
   Emacs Lisp provides a general-purpose hash table data type, along
-with a series of functions for operating on them.  Hash tables have no
-read syntax, and print in hash notation, like this:
-
-@example
-(make-hash-table)
-     @result{} #<hash-table 'eql nil 0/65 0x83af980>
-@end example
-
-@noindent
-(The term ``hash notation'' refers to the initial @samp{#}
-character---@pxref{Printed Representation}---and has nothing to do with
-the term ``hash table.'')
+with a series of functions for operating on them.  Hash tables have a
+special printed representation, which consists of @samp{#s} followed
+by a list specifying the hash table properties and contents.
+@xref{Creating Hash}.  (Note that the term ``hash notation'', which
+refers to the initial @samp{#} character used in the printed
+representations of objects with no read representation, has nothing to
+do with the term ``hash table''.  @xref{Printed Representation}.)
 
   Obarrays are also a kind of hash table, but they are a different type
 of object and are used only for recording interned symbols
@@ -164,6 +159,35 @@ of key lookup.
 This function is obsolete. Use @code{make-hash-table} instead.
 @end defun
 
+You can also create a new hash table using the printed representation
+for hash tables.  The Lisp reader can read this printed
+representation, provided each element in the specified hash table has
+a valid read syntax (@pxref{Printed Representation}).  For instance,
+the following specifies a new hash table containing the keys
+@code{key1} and @code{key2} (both symbols) associated with @code{val1}
+(a symbol) and @code{300} (a number) respectively.
+
+@example
+#s(hash-table size 30 data (key1 val1 key2 300))
+@end example
+
+@noindent
+The printed representation for a hash table consists of @samp{#s}
+followed by a list beginning with @samp{hash-table}.  The rest of the
+list should consist of zero or more property-value pairs specifying
+the hash table's properties and initial contents.  The properties and
+values are read literally.  Valid property names are @code{size},
+@code{test}, @code{weakness}, @code{rehash-size},
+@code{rehash-threshold}, and @code{data}.  The @code{data} property
+should be a list of key-value pairs for the initial contents; the
+other properties have the same meanings as the matching
+@code{make-hash-table} keywords (@code{:size}, @code{:test}, etc.),
+described above.
+
+Note that you cannot specify a hash table whose initial contents
+include objects that have no read syntax, such as buffers and frames.
+Such objects may be added to the hash table after it is created.
+
 @node Hash Access
 @section Hash Table Access
 

doc/lispref/minibuf.texi

@@ -769,10 +769,11 @@ This function returns a list of all possible completions of
 @var{string}.  The arguments to this function (aside from
 @var{nospace}) are the same as those of @code{try-completion}.  Also,
 this function uses @code{completion-regexp-list} in the same way that
-@code{try-completion} does.  The optional argument @var{nospace} only
-matters if @var{string} is the empty string.  In that case, if
-@var{nospace} is non-@code{nil}, completions that start with a space
-are ignored.
+@code{try-completion} does.
+
+The optional argument @var{nospace} is obsolete.  If it is
+non-@code{nil}, completions that start with a space are ignored unless
+@var{string} starts with a space.
 
 If @var{collection} is a function, it is called with three arguments:
 @var{string}, @var{predicate} and @code{t}; then @code{all-completions}

doc/lispref/objects.texi

@@ -1219,14 +1219,18 @@ only the first 3 bits are used:
 
     A hash table is a very fast kind of lookup table, somewhat like an
 alist in that it maps keys to corresponding values, but much faster.
-Hash tables have no read syntax, and print using hash notation.
-@xref{Hash Tables}, for functions that operate on hash tables.
+The printed representation of a hash table specifies its properties
+and contents, like this:
 
 @example
 (make-hash-table)
-     @result{} #<hash-table 'eql nil 0/65 0x83af980>
+     @result{} #s(hash-table size 65 test eql rehash-size 1.5
+                             rehash-threshold 0.8 data ())
 @end example
 
+@noindent
+@xref{Hash Tables}, for more information about hash tables.
+
 @node Function Type
 @subsection Function Type
 

doc/lispref/processes.texi

@@ -1161,6 +1161,14 @@ the output is determined by the @code{process-mark}, which is then
 updated to point to the end of the text just inserted.  Usually, but not
 always, the @code{process-mark} is at the end of the buffer.
 
+@findex process-kill-buffer-query-function
+  Killing the associated buffer of a process also kills the process.
+Emacs asks for confirmation first, if the process's
+@code{process-query-on-exit-flag} is non-@code{nil} (@pxref{Query
+Before Exit}).  This confirmation is done by the function
+@code{process-kill-buffer-query-function}, which is run from
+@code{kill-buffer-query-functions} (@pxref{Killing Buffers}).
+
 @defun process-buffer process
 This function returns the associated buffer of the process
 @var{process}.