Add record objects with user-defined types.

* src/alloc.c (allocate_record): New function.
(Fmake_record, Frecord, Fcopy_record): New functions.
(syms_of_alloc): defsubr them.
(purecopy): Work with records.

* src/data.c (Ftype_of): Return slot 0 for record objects, or type
name if record's type holds class.
(Frecordp): New function.
(syms_of_data): defsubr it.  Define `Qrecordp'.
(Faref, Faset): Work with records.

* src/fns.c (Flength): Work with records.

* src/lisp.h (prec_type): Add PVEC_RECORD.
(RECORDP, CHECK_RECORD, CHECK_RECORD_TYPE): New functions.

* src/lread.c (read1): Add syntax for records.

* src/print.c (PRINT_CIRCLE_CANDIDATE_P): Add RECORDP.
(print_object): Add syntax for records.

* test/lisp/emacs-lisp/cl-print-tests.el (cl-print-tests-2):
New test.

* test/src/alloc-tests.el (record-1, record-2, record-3):
New tests.

* doc/lispref/elisp.texi, doc/lispref/objects.texi,
doc/lispref/records.texi: Add documentation for records.

3 files changed, 126 insertions, 3 deletions

diff --git a/doc/lispref/elisp.texi b/doc/lispref/elisp.texi
index e0bd337e53b..0f7efb6f187 100644
--- a/doc/lispref/elisp.texi
+++ b/doc/lispref/elisp.texi
@@ -180,6 +180,7 @@ To view this manual in other formats, click
 * Sequences Arrays Vectors::  Lists, strings and vectors are called sequences.
                                 Certain functions act on any kind of sequence.
                                 The description of vectors is here as well.
+* Records::                 Compound objects with programmer-defined types.
 * Hash Tables::             Very fast lookup-tables.
 * Symbols::                 Symbols represent names, uniquely.
 
@@ -314,6 +315,7 @@ Programming Types
                           expression, more fundamental but less pretty.
 * Primitive Function Type::     A function written in C, callable from Lisp.
 * Byte-Code Type::      A function written in Lisp, then compiled.
+* Record Type::         Compound objects with programmer-defined types.
 * Autoload Type::       A type used for automatically loading seldom-used
                           functions.
 * Finalizer Type::      Runs code when no longer reachable.
@@ -418,6 +420,10 @@ Sequences, Arrays, and Vectors
 * Bool-Vectors::            How to work with bool-vectors.
 * Rings::                   Managing a fixed-size ring of objects.
 
+Records
+
+* Record Functions::        Functions for records.
+
 Hash Tables
 
 * Creating Hash::           Functions to create hash tables.
@@ -1594,6 +1600,7 @@ Object Internals
 
 @include lists.texi
 @include sequences.texi
+@include records.texi
 @include hash.texi
 @include symbols.texi
 @include eval.texi
diff --git a/doc/lispref/objects.texi b/doc/lispref/objects.texi
index 56049af60a1..90cafbef642 100644
--- a/doc/lispref/objects.texi
+++ b/doc/lispref/objects.texi
@@ -25,9 +25,10 @@ but not for @emph{the} type of an object.
 which all other types are constructed, are called @dfn{primitive types}.
 Each object belongs to one and only one primitive type.  These types
 include @dfn{integer}, @dfn{float}, @dfn{cons}, @dfn{symbol},
-@dfn{string}, @dfn{vector}, @dfn{hash-table}, @dfn{subr}, and
-@dfn{byte-code function}, plus several special types, such as
-@dfn{buffer}, that are related to editing.  (@xref{Editing Types}.)
+@dfn{string}, @dfn{vector}, @dfn{hash-table}, @dfn{subr},
+@dfn{byte-code function}, and @dfn{record}, plus several special
+types, such as @dfn{buffer}, that are related to editing.
+(@xref{Editing Types}.)
 
   Each primitive type has a corresponding Lisp function that checks
 whether an object is a member of that type.
@@ -154,6 +155,7 @@ latter are unique to Emacs Lisp.
                           expression, more fundamental but less pretty.
 * Primitive Function Type::     A function written in C, callable from Lisp.
 * Byte-Code Type::      A function written in Lisp, then compiled.
+* Record Type::         Compound objects with programmer-defined types.
 * Autoload Type::       A type used for automatically loading seldom-used
                         functions.
 * Finalizer Type::      Runs code when no longer reachable.
@@ -1347,6 +1349,16 @@ The printed representation and read syntax for a byte-code function
 object is like that for a vector, with an additional @samp{#} before the
 opening @samp{[}.
 
+@node Record Type
+@subsection Record Type
+
+  A @dfn{record} is much like a @code{vector}.  However, the first
+element is used to hold its type as returned by @code{type-of}.  The
+purpose of records is to allow programmers to create objects with new
+types that are not built into Emacs.
+
+  @xref{Records}, for functions that work with records.
+
 @node Autoload Type
 @subsection Autoload Type
 
@@ -1959,6 +1971,9 @@ with references to further information.
 @item processp
 @xref{Processes, processp}.
 
+@item recordp
+@xref{Record Type, recordp}.
+
 @item sequencep
 @xref{Sequence Functions, sequencep}.
 
@@ -2022,6 +2037,7 @@ This function returns a symbol naming the primitive type of
 @code{marker}, @code{mutex}, @code{overlay}, @code{process},
 @code{string}, @code{subr}, @code{symbol}, @code{thread},
 @code{vector}, @code{window}, or @code{window-configuration}.
+However, if @var{object} is a record, its first slot is returned.
 
 @example
 (type-of 1)
@@ -2033,6 +2049,8 @@ This function returns a symbol naming the primitive type of
      @result{} symbol
 (type-of '(x))
      @result{} cons
+(type-of (record 'foo))
+     @result{} foo
 @end group
 @end example
 @end defun
diff --git a/doc/lispref/records.texi b/doc/lispref/records.texi
new file mode 100644
index 00000000000..aeba77a70e7
--- /dev/null
+++ b/doc/lispref/records.texi
@@ -0,0 +1,98 @@
+@c -*-texinfo-*-
+@c This is part of the GNU Emacs Lisp Reference Manual.
+@c Copyright (C) 2017 Free Software
+@c Foundation, Inc.
+@c See the file elisp.texi for copying conditions.
+@node Records
+@chapter Records
+@cindex record
+
+  The purpose of records is to allow programmers to create objects
+with new types that are not built into Emacs.
+
+  Internally, a record object is much like a vector; its slots can be
+accessed using @code{aref}.  However, the first slot is used to hold
+its type as returned by @code{type-of}.  Like arrays, records use
+zero-origin indexing: the first slot has index 0.
+
+  The printed representation of records is @samp{#s} followed by a
+list specifying the contents.  The first list element must be the
+record type.  The following elements are the record slots.
+
+  A record is considered a constant for evaluation: the result of
+evaluating it is the same record.  This does not evaluate or even
+examine the slots.  @xref{Self-Evaluating Forms}.
+
+@menu
+* Record Functions::      Functions for records.
+@end menu
+
+@node Record Functions
+@section Record Functions
+
+@defun recordp object
+This function returns @code{t} if @var{object} is a record.
+
+@example
+@group
+(recordp #s(a))
+     @result{} t
+@end group
+@end example
+@end defun
+
+@defun record type &rest objects
+This function creates and returns a record whose type is @var{type}
+and remaining slots are the rest of the arguments, @var{objects}.
+
+@example
+@group
+(vector 'foo 23 [bar baz] "rats")
+     @result{} #s(foo 23 [bar baz] "rats")
+@end group
+@end example
+@end defun
+
+@defun make-record type length object
+This function returns a new record with type @var{type} and
+@var{length} more slots, each initialized to @var{object}.
+
+@example
+@group
+(setq sleepy (make-record 'foo 9 'Z))
+     @result{} #s(foo Z Z Z Z Z Z Z Z Z)
+@end group
+@end example
+@end defun
+
+@defun copy-record record
+This function returns a shallow copy of @var{record}.  The copy is the
+same type as the original record, and it has the same slots in the
+same order.
+
+  Storing a new slot into the copy does not affect the original
+@var{record}, and vice versa.  However, the slots of the new record
+are not copies; they are identical (@code{eq}) to the slots of the
+original.  Therefore, changes made within these slots, as found via
+the copied record, are also visible in the original record.
+
+@example
+@group
+(setq x (record 'foo 1 2))
+     @result{} #s(foo 1 2)
+@end group
+@group
+(setq y (copy-record x))
+     @result{} #s(foo 1 2)
+@end group
+
+@group
+(eq x y)
+     @result{} nil
+@end group
+@group
+(equal x y)
+     @result{} t
+@end group
+@end example
+@end defun