From a2b3fea957440b8358d3632a4a05e41dee964b5d Mon Sep 17 00:00:00 2001 From: Paul Eggert Date: Fri, 7 Apr 2017 18:54:40 -0700 Subject: [PATCH] Deprecate copy-record in favor of copy-sequence Since copy-sequence seems to be needed anyway for records, have it work on records, and remove copy-record as being superfluous. * doc/lispref/records.texi (Records, Record Functions): * lisp/emacs-lisp/cl-macs.el (cl-defstruct): * lisp/emacs-lisp/eieio.el (make-instance, clone): * test/src/alloc-tests.el (record-3): Use copy-sequence, not copy-record, to copy records. * doc/lispref/sequences.texi (Sequence Functions) (Array Functions): Document that aref and copy-sequence work on records. * etc/NEWS: Omit copy-record. * src/alloc.c (Fcopy_record): Remove. * src/data.c (Faref): Document that arg can be a record. * src/fns.c (Fcopy_sequence): Copy records, too. --- doc/lispref/records.texi | 37 +++---------------------------------- doc/lispref/sequences.texi | 23 +++++++++++------------ etc/NEWS | 6 +++--- lisp/emacs-lisp/cl-macs.el | 3 +-- lisp/emacs-lisp/eieio.el | 6 +++--- src/alloc.c | 14 -------------- src/data.c | 4 ++-- src/fns.c | 12 +++++++++--- test/src/alloc-tests.el | 2 +- 9 files changed, 33 insertions(+), 74 deletions(-) diff --git a/doc/lispref/records.texi b/doc/lispref/records.texi index 2533a8a4ca1..7cc36f14068 100644 --- a/doc/lispref/records.texi +++ b/doc/lispref/records.texi @@ -13,8 +13,9 @@ underlying representation of @code{cl-defstruct} and @code{defclass} instances. 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}. Also, in the current +accessed using @code{aref} and it can be copied using +@code{copy-sequence}. However, the first slot is used to hold its +type as returned by @code{type-of}. Also, in the current implementation records can have at most 4096 slots, whereas vectors can be much larger. Like arrays, records use zero-origin indexing: the first slot has index 0. @@ -74,38 +75,6 @@ This function returns a new record with type @var{type} and @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 - @node Backward Compatibility @section Backward Compatibility diff --git a/doc/lispref/sequences.texi b/doc/lispref/sequences.texi index 2c88ee38cb1..93e8fa8a5fa 100644 --- a/doc/lispref/sequences.texi +++ b/doc/lispref/sequences.texi @@ -151,20 +151,19 @@ This function generalizes @code{aref} (@pxref{Array Functions}) and @code{nth} (@pxref{Definition of nth}). @end defun -@defun copy-sequence sequence +@defun copy-sequence seqr @cindex copying sequences -This function returns a copy of @var{sequence}. The copy is the same -type of object as the original sequence, and it has the same elements -in the same order. +This function returns a copy of @var{seqr}, which should be either a +sequence or a record. The copy is the same type of object as the +original, and it has the same elements in the same order. Storing a new element into the copy does not affect the original -@var{sequence}, and vice versa. However, the elements of the new -sequence are not copies; they are identical (@code{eq}) to the elements +@var{seqr}, and vice versa. However, the elements of the copy +are not copies; they are identical (@code{eq}) to the elements of the original. Therefore, changes made within these elements, as -found via the copied sequence, are also visible in the original -sequence. +found via the copy, are also visible in the original. -If the sequence is a string with text properties, the property list in +If the argument is a string with text properties, the property list in the copy is itself a copy, not shared with the original's property list. However, the actual values of the properties are shared. @xref{Text Properties}. @@ -1148,10 +1147,10 @@ vector, a string, a bool-vector or a char-table). @end example @end defun -@defun aref array index +@defun aref arr index @cindex array elements -This function returns the @var{index}th element of @var{array}. The -first element is at index zero. +This function returns the @var{index}th element of the array or record +@var{arr}. The first element is at index zero. @example @group diff --git a/etc/NEWS b/etc/NEWS index aaca229d5cd..e351abc159f 100644 --- a/etc/NEWS +++ b/etc/NEWS @@ -863,9 +863,9 @@ instead of its first. +++ ** Emacs now supports records for user-defined types, via the new -functions 'copy-record', 'make-record', 'record', and 'recordp'. -Records are now used internally to represent cl-defstruct and defclass -instances, for example. +functions 'make-record', 'record', and 'recordp'. Records are now +used internally to represent cl-defstruct and defclass instances, for +example. +++ ** 'save-some-buffers' now uses 'save-some-buffers-default-predicate' diff --git a/lisp/emacs-lisp/cl-macs.el b/lisp/emacs-lisp/cl-macs.el index 25c9f999920..ecb89fd51d7 100644 --- a/lisp/emacs-lisp/cl-macs.el +++ b/lisp/emacs-lisp/cl-macs.el @@ -2808,8 +2808,7 @@ non-nil value, that slot cannot be set via `setf'. (setq slots (nreverse slots) defaults (nreverse defaults)) (and copier - (push `(defalias ',copier - ,(if (null type) '#'copy-record '#'copy-sequence)) + (push `(defalias ',copier #'copy-sequence) forms)) (if constructor (push (list constructor diff --git a/lisp/emacs-lisp/eieio.el b/lisp/emacs-lisp/eieio.el index 858b2fdaa04..e21d46e5289 100644 --- a/lisp/emacs-lisp/eieio.el +++ b/lisp/emacs-lisp/eieio.el @@ -699,8 +699,8 @@ SLOTS are the initialization slots used by `initialize-instance'. This static method is called when an object is constructed. It allocates the vector used to represent an EIEIO object, and then calls `initialize-instance' on that object." - (let* ((new-object (copy-record (eieio--class-default-object-cache - (eieio--class-object class))))) + (let* ((new-object (copy-sequence (eieio--class-default-object-cache + (eieio--class-object class))))) (if (and slots (let ((x (car slots))) (or (stringp x) (null x)))) @@ -804,7 +804,7 @@ first and modify the returned object.") (cl-defmethod clone ((obj eieio-default-superclass) &rest params) "Make a copy of OBJ, and then apply PARAMS." - (let ((nobj (copy-record obj))) + (let ((nobj (copy-sequence obj))) (if (stringp (car params)) (funcall (if eieio-backward-compatibility #'ignore #'message) "Obsolete name %S passed to clone" (pop params))) diff --git a/src/alloc.c b/src/alloc.c index fad84b8a0b3..88a1a1ed660 100644 --- a/src/alloc.c +++ b/src/alloc.c @@ -3440,19 +3440,6 @@ usage: (record TYPE &rest SLOTS) */) } -DEFUN ("copy-record", Fcopy_record, Scopy_record, 1, 1, 0, - doc: /* Return a new record that is a shallow copy of the argument RECORD. */) - (Lisp_Object record) -{ - CHECK_RECORD (record); - ptrdiff_t size = ASIZE (record) & PSEUDOVECTOR_SIZE_MASK; - struct Lisp_Vector *new = allocate_record (size); - memcpy (new->contents, XVECTOR (record)->contents, - size * sizeof (Lisp_Object)); - return make_lisp_ptr (new, Lisp_Vectorlike); -} - - DEFUN ("make-vector", Fmake_vector, Smake_vector, 2, 2, 0, doc: /* Return a newly created vector of length LENGTH, with each element being INIT. See also the function `vector'. */) @@ -7523,7 +7510,6 @@ The time is in seconds as a floating point value. */); defsubr (&Slist); defsubr (&Svector); defsubr (&Srecord); - defsubr (&Scopy_record); defsubr (&Sbool_vector); defsubr (&Smake_byte_code); defsubr (&Smake_list); diff --git a/src/data.c b/src/data.c index 3ffca54658d..903e809d235 100644 --- a/src/data.c +++ b/src/data.c @@ -2266,8 +2266,8 @@ function chain of symbols. */) /* Extract and set vector and string elements. */ DEFUN ("aref", Faref, Saref, 2, 2, 0, - doc: /* Return the element of ARRAY at index IDX. -ARRAY may be a vector, a string, a char-table, a bool-vector, + doc: /* Return the element of ARG at index IDX. +ARG may be a vector, a string, a char-table, a bool-vector, a record, or a byte-code object. IDX starts at 0. */) (register Lisp_Object array, Lisp_Object idx) { diff --git a/src/fns.c b/src/fns.c index 47da5f8b4bc..2f07c2ccfb7 100644 --- a/src/fns.c +++ b/src/fns.c @@ -475,13 +475,19 @@ usage: (vconcat &rest SEQUENCES) */) DEFUN ("copy-sequence", Fcopy_sequence, Scopy_sequence, 1, 1, 0, - doc: /* Return a copy of a list, vector, string or char-table. -The elements of a list or vector are not copied; they are shared -with the original. */) + doc: /* Return a copy of a list, vector, string, char-table or record. +The elements of a list, vector or record are not copied; they are +shared with the original. */) (Lisp_Object arg) { if (NILP (arg)) return arg; + if (RECORDP (arg)) + { + ptrdiff_t size = ASIZE (arg) & PSEUDOVECTOR_SIZE_MASK; + return Frecord (size, XVECTOR (arg)->contents); + } + if (CHAR_TABLE_P (arg)) { return copy_char_table (arg); diff --git a/test/src/alloc-tests.el b/test/src/alloc-tests.el index 8b4ef8ce7d2..1cf1fc3be5c 100644 --- a/test/src/alloc-tests.el +++ b/test/src/alloc-tests.el @@ -47,7 +47,7 @@ (ert-deftest record-3 () (let* ((x (record 'foo 1 2 3)) - (y (copy-record x))) + (y (copy-sequence x))) (should-not (eq x y)) (dotimes (i 4) (should (eql (aref x i) (aref y i))))))