HOME

Mini Shell 1.0
DIR:/proc/self/root/usr/share/emacs/26.1/lisp/emacs-lisp/
Current File : //proc/self/root/usr/share/emacs/26.1/lisp/emacs-lisp/ring.elc
;ELC
;;; Compiled
;;; in Emacs version 26.1
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.

;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


#@49 Return t if X is a ring; nil otherwise.

(fn X)
(defalias 'ring-p #[257 "\211:\205\211@\250\205\211A:\205\211A@\250\205\300AA!\207" [vectorp] 3 (#$ . 408)])
#@56 Make a ring that can contain SIZE elements.

(fn SIZE)
(defalias 'make-ring #[257 "\300\211\301\302\"BB\207" [0 make-vector nil] 6 (#$ . 580)])
#@78 Add to RING the item ITEM, at the front, as the oldest item.

(fn RING ITEM)
(defalias 'ring-insert-at-beginning #[514 "AA\211G@A@T^\262\300\"\262I\210\240\210A\240\207" [ring-minus1] 9 (#$ . 731)])
#@53 Return INDEX+1, with wraparound.

(fn INDEX VECLEN)
(defalias 'ring-plus1 #[514 "T\211U\203\f\300\202
\211\207" [0] 5 (#$ . 953)])
#@53 Return INDEX-1, with wraparound.

(fn INDEX VECLEN)
(defalias 'ring-minus1 #[514 "\300U\203\n\211\202S\207" [0] 4 (#$ . 1094)])
#@55 Return the number of elements in the RING.

(fn RING)
(defalias 'ring-length #[257 "\211A@\207" [] 2 (#$ . 1233)])
#@314 Convert nominal ring index INDEX to an internal index.
The internal index refers to the items ordered from newest to oldest.
HEAD is the index of the oldest element in the ring.
RINGLEN is the number of elements currently in the ring.
VECLEN is the size of the vector in the ring.

(fn INDEX HEAD RINGLEN VECLEN)
(defalias 'ring-index #[1028 "\300\"\262\300Z\\S\"\207" [mod] 8 (#$ . 1355)])
#@54 Return t if RING is empty; nil otherwise.

(fn RING)
(defalias 'ring-empty-p #[257 "\211A@\300U\207" [0] 3 (#$ . 1760)])
#@84 Return the size of RING, the maximum number of elements it can contain.

(fn RING)
(defalias 'ring-size #[257 "\211AAG\207" [] 2 (#$ . 1887)])
#@35 Return a copy of RING.

(fn RING)
(defalias 'ring-copy #[257 "\211AA@A@\300!BB\207" [copy-sequence] 8 (#$ . 2036)])
#@137 Insert onto ring RING the item ITEM, as the newest (last) item.
If the ring is full, dump the oldest item to make room.

(fn RING ITEM)
(defalias 'ring-insert #[514 "AA\211G@A@\300\\\"IU\203&\301\"\240\210\202-AT\240\210\207" [mod ring-plus1] 11 (#$ . 2164)])
#@180 Remove an item from the RING.  Return the removed item.
If optional INDEX is nil, remove the oldest item.  If it's
numeric, remove the element indexed.

(fn RING &optional INDEX)
(defalias 'ring-remove #[513 "\300!\203\n\301\302!\207@A@AA\211G\303\\S\"\304\204%S\262\305$\262H\262U\204U\306\n\"HI\210\306\"\262\2027\304I\210AS\240\210\207" [ring-empty-p error "Ring empty" mod nil ring-index ring-plus1] 14 (#$ . 2452)])
#@223 Return RING's INDEX element.
INDEX = 0 is the most recently inserted; higher indices
correspond to older elements.
INDEX need not be <= the ring length; the appropriate modulo operation
will be performed.

(fn RING INDEX)
(defalias 'ring-ref #[514 "\300!\203\n\301\302!\207@A@AA\211\303G$H\207" [ring-empty-p error "Accessing an empty ring" ring-index] 11 (#$ . 2927)])
#@75 Return a list of the elements of RING, in order, newest first.

(fn RING)
(defalias 'ring-elements #[257 "\211@\300!AA\301A@\302\211W\203*\211\303\\\"HB\262\210\211T\262\202
\266\207" [ring-size nil 0 mod] 12 (#$ . 3312)])
#@115 Return index of ITEM if on RING, else nil.
Comparison is done via `equal'.  The index is 0-based.

(fn RING ITEM)
(defalias 'ring-member #[514 "\3002)\301!\302\211W\205&\211\303\"\232\203\304\300\"\210\210\211T\262\202\266\2020\207" [found ring-length 0 ring-ref throw] 9 (#$ . 3558)])
#@103 Return the next item in the RING, after ITEM.
Raise error if ITEM is not in the RING.

(fn RING ITEM)
(defalias 'ring-next #[514 "\300\"\211\204
\301\302\"\210\303\304\305!\"\"\207" [ring-member error "Item is not in the ring: `%s'" ring-ref ring-plus1 ring-length] 9 (#$ . 3865)])
#@108 Return the previous item in the RING, before ITEM.
Raise error if ITEM is not in the RING.

(fn RING ITEM)
(defalias 'ring-previous #[514 "\300\"\211\204
\301\302\"\210\303\304\305!\"\"\207" [ring-member error "Item is not in the ring: `%s'" ring-ref ring-minus1 ring-length] 9 (#$ . 4162)])
#@46 Increase the size of RING by X.

(fn RING X)
(defalias 'ring-extend #[514 "\211\250\205L\211\300V\205L@\301!\302!AA\303\\\304\"B\241\210\300\211W\203D\211\305\\\n\"HI\266\211T\262\202&\266\300\240\266\205\207" [0 ring-length ring-size make-vector nil mod] 16 (#$ . 4468)])
#@349 Like `ring-insert', but if GROW-P is non-nil, then enlarge ring.
Insert onto ring RING the item ITEM, as the newest (last) item.
If the ring is full, behavior depends on GROW-P:
  If GROW-P is non-nil, enlarge the ring to accommodate the new item.
  If GROW-P is nil, dump the oldest item to make room for the new.

(fn RING ITEM &optional GROW-P)
(defalias 'ring-insert+extend #[770 "\211\203\300!\301!U\203\302\303\"\210\304\"\207" [ring-length ring-size ring-extend 1 ring-insert] 6 (#$ . 4778)])
#@331 `ring-remove' ITEM from RING, then `ring-insert+extend' it.
This ensures that there is only one ITEM on RING.

If the RING is full, behavior depends on GROW-P:
  If GROW-P is non-nil, enlarge the ring to accommodate the new ITEM.
  If GROW-P is nil, dump the oldest item to make room for the new.

(fn RING ITEM &optional GROW-P)
(defalias 'ring-remove+insert+extend #[770 "\300\301\"\211\262\203\302\"\210\202\210\303#\207" [nil ring-member ring-remove ring-insert+extend] 7 (#$ . 5294)])
#@98 Convert sequence SEQ to a ring.  Return the ring.
If SEQ is already a ring, return it.

(fn SEQ)
(defalias 'ring-convert-sequence-to-ring #[257 "\300!\203\207\211G\301!\302\211W\2037\211\303!\204'\304\302\"\234\232\204/\305\234\"\210\210\211T\262\202\266\207" [ring-p make-ring 0 ring-empty-p ring-ref ring-insert-at-beginning] 10 (#$ . 5802)])
(provide 'ring)