paredit.elc

;ELC
;;; Compiled by nitro@nitro-desktop.domain on Sat Apr 27 15:23:05 2013
;;; from file /home/nitro/.emacs.d/paredit.el
;;; in Emacs version 24.3.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.

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


(defconst paredit-version 23)
(defconst paredit-beta-p nil)
(defalias 'paredit-xemacs-p #[nil "\300\207" [nil] 1])
(defalias 'paredit-gnu-emacs-p #[nil "\300 ?\207" [paredit-xemacs-p] 1])
#@56 Exhaustive COND.
Signal an error if no clause matches.
(defalias 'xcond '(macro . #[(&rest clauses) "\301\302\303\"B\207" [clauses cond append ((t (error "XCOND lost.")))] 4 (#$ . 702)]))
(byte-code "\300\301\302\303!\203\f\303\202
\304\"\207" [defalias paredit-warn fboundp warn message] 4)
(defvar paredit-sexp-error-type (byte-code "\301\302!rq\210\303\216\304c\210\305\306\307\217+\207" [#1=#:temp-buffer generate-new-buffer " *temp*" ((byte-code "\301!\203\n\302!\210\301\207" [#1# buffer-name kill-buffer] 2)) "(" condition (backward-sexp) ((error (byte-code "@\301=\203\302\303\304\305\306\307\310&\210@\207" [condition error paredit-warn "%s%s%s%s%s" "Paredit is unable to discriminate" " S-expression parse errors from" " other errors. " " This may cause obscure problems. " " Please upgrade Emacs."] 7)))] 3))
(defalias 'paredit-handle-sexp-errors '(macro . #[(body &rest handler) "\303\304	\nBF\207" [body paredit-sexp-error-type handler condition-case nil] 5]))
(put 'paredit-handle-sexp-errors 'lisp-indent-function 1)
(defalias 'paredit-ignore-sexp-errors '(macro . #[(&rest body) "\301\302B\303BB\207" [body paredit-handle-sexp-errors progn (nil)] 3]))
(put 'paredit-ignore-sexp-errors 'lisp-indent-function 0)
#@36 Keymap for the paredit minor mode.
(defvar paredit-mode-map (make-sparse-keymap) (#$ . 1949))
#@71 Function to tell whether unbalanced text should inhibit Paredit Mode.
(defvar paredit-override-check-parens-function #[(condition) "\210\301\207" [condition nil] 1] (#$ . 2049))
#@93 Non-nil if Paredit mode is enabled.
Use the command `paredit-mode' to change this variable.
(defvar paredit-mode nil (#$ . 2234))
(make-variable-buffer-local 'paredit-mode)
#@347 Minor mode for pseudo-structurally editing Lisp code.
With a prefix argument, enable Paredit Mode even if there are
  unbalanced parentheses in the buffer.
Paredit behaves badly if parentheses are unbalanced, so exercise
  caution when forcing Paredit Mode to be enabled, and consider
  fixing unbalanced parentheses instead.
\<paredit-mode-map>
(defalias 'paredit-mode #[(&optional arg) "\304 	\305=\203\n?\202\306	!\307V\211\203!\204!\310\311\312\217\210\313\314\n\203+\315\202,\316\"\210\317\320!\203M\304 \203@\304 \232\203M\321\322\n\203J\323\202K\324\"\210)\325 \210\n\207" [#1=#:last-message arg paredit-mode current-prefix-arg current-message toggle prefix-numeric-value 0 condition (check-parens) ((error (byte-code "	!\204\303\304	@	A\"\210\303\207" [paredit-override-check-parens-function condition paredit-mode nil signal] 3))) run-hooks paredit-mode-hook paredit-mode-on-hook paredit-mode-off-hook called-interactively-p any message "Paredit mode %sabled" "en" "dis" force-mode-line-update] 4 (#$ . 2414) (list (or current-prefix-arg 'toggle))])
(byte-code "\301\302\303\304\300!\205\n\305\211%\207" [paredit-mode-map add-minor-mode paredit-mode " Paredit" boundp nil] 6)
(defalias 'paredit-override-check-parens-interactively #[(condition) "\301\302\303\"!\207" [condition y-or-n-p format "Enable Paredit Mode despite condition %S? "] 4])
#@49 Turn on pseudo-structural editing of Lisp code.
(defalias 'enable-paredit-mode #[nil "\300\301!\207" [paredit-mode 1] 2 (#$ . 3797) nil])
#@50 Turn off pseudo-structural editing of Lisp code.
(defalias 'disable-paredit-mode #[nil "\300\301!\207" [paredit-mode -1] 2 (#$ . 3941) nil])
(defvar paredit-backward-delete-key (byte-code "\300 \203\301\207\302 \203\303\207\304\305!\207" [paredit-xemacs-p "BS" paredit-gnu-emacs-p "DEL" error "XCOND lost."] 2))
(defvar paredit-forward-delete-keys (byte-code "\300 \203\301\207\302 \203\303\207\304\305!\207" [paredit-xemacs-p ("DEL") paredit-gnu-emacs-p ("<delete>" "<deletechar>") error "XCOND lost."] 2))
#@56 List of paredit commands with their keys and examples.
(defvar paredit-commands nil (#$ . 4463))
(byte-code "\303\304\305\306\307\310\311\312\313\314\315\316DF\317\320\321\322\323\324\325DE\326\327B\330B	\331B\332\333\334	P\335B\336BBBBBBBBBBBBBBBBBB\313\207" [paredit-forward-delete-keys paredit-backward-delete-key paredit-commands "Basic Insertion Commands" ("(" paredit-open-round ("(a b |c d)" "(a b (|) c d)") ("(foo \"bar |baz\" quux)" "(foo \"bar (|baz\" quux)")) (")" paredit-close-round ("(a b |c   )" "(a b c)|") ("; Hello,| world!" "; Hello,)| world!")) ("M-)" paredit-close-round-and-newline ("(defun f (x|  ))" "(defun f (x)\n  |)") ("; (Foo.|" "; (Foo.)|")) ("[" paredit-open-square ("(a b |c d)" "(a b [|] c d)") ("(foo \"bar |baz\" quux)" "(foo \"bar [|baz\" quux)")) ("]" paredit-close-square ("(define-key keymap [frob|  ] 'frobnicate)" "(define-key keymap [frob]| 'frobnicate)") ("; [Bar.|" "; [Bar.]|")) ("\"" paredit-doublequote ("(frob grovel |full lexical)" "(frob grovel \"|\" full lexical)" "(frob grovel \"\"| full lexical)") ("(foo \"bar |baz\" quux)" "(foo \"bar \\\"|baz\" quux)") ("(frob grovel)   ; full |lexical" "(frob grovel)   ; full \"|lexical")) "M-\"" paredit-meta-doublequote ("(foo \"bar |baz\" quux)" "(foo \"bar baz\"\n     |quux)") "(foo |(bar #\\x \"baz \\\\ quux\") zot)" "(foo \"|(bar #\\\\x \\\"baz \\\\\\\\ quux\\\")\" zot)" ("\\" paredit-backslash ("(string #|)\n  ; Character to escape: x" "(string #\\x|)") ("\"foo|bar\"\n  ; Character to escape: \"" "\"foo\\\"|bar\"")) (";" paredit-semicolon ("|(frob grovel)" ";|(frob grovel)") ("(frob |grovel)" "(frob ;|grovel\n )") ("(frob |grovel (bloit\n               zargh))" "(frob ;|grovel\n (bloit\n  zargh))") ("(frob grovel)          |" "(frob grovel)          ;|")) ("M-;" paredit-comment-dwim ("(foo |bar)   ; baz" "(foo bar)                               ; |baz") ("(frob grovel)|" "(frob grovel)                           ;|") ("(zot (foo bar)\n|\n     (baz quux))" "(zot (foo bar)\n     ;; |\n     (baz quux))") ("(zot (foo bar) |(baz quux))" "(zot (foo bar)\n     ;; |\n     (baz quux))") ("|(defun hello-world ...)" ";;; |\n(defun hello-world ...)")) "C-j" paredit-newline "(let ((n (frobbotz))) |(display (+ n 1)\nport))" "(let ((n (frobbotz)))\n  |(display (+ n 1)\n           port))" "Deleting & Killing" "C-d" (paredit-forward-delete ("(quu|x \"zot\")" "(quu| \"zot\")") ("(quux |\"zot\")" "(quux \"|zot\")" "(quux \"|ot\")") ("(foo (|) bar)" "(foo | bar)") ("|(foo bar)" "(|foo bar)")) (paredit-backward-delete ("(\"zot\" q|uux)" "(\"zot\" |uux)") ("(\"zot\"| quux)" "(\"zot|\" quux)" "(\"zo|\" quux)") ("(foo (|) bar)" "(foo | bar)") ("(foo bar)|" "(foo bar|)")) ("C-k" paredit-kill ("(foo bar)|     ; Useless comment!" "(foo bar)|") ("(|foo bar)     ; Useful comment!" "(|)     ; Useful comment!") ("|(foo bar)     ; Useless line!" "|") ("(foo \"|bar baz\"\n     quux)" "(foo \"|\"\n     quux)")) ("M-d" paredit-forward-kill-word ("|(foo bar)    ; baz" "(| bar)    ; baz" "(|)    ; baz" "()    ;|") (";;;| Frobnicate\n(defun frobnicate ...)" ";;;|\n(defun frobnicate ...)" ";;;\n(| frobnicate ...)")) "M-" (paredit-backward-kill-word ("(foo bar)    ; baz\n(quux)|" "(foo bar)    ; baz\n(|)" "(foo bar)    ; |\n()" "(foo |)    ; \n()" "(|)    ; \n()")) ("Movement & Navigation" ("C-M-f" paredit-forward ("(foo |(bar baz) quux)" "(foo (bar baz)| quux)") ("(foo (bar)|)" "(foo (bar))|")) ("C-M-b" paredit-backward ("(foo (bar baz)| quux)" "(foo |(bar baz) quux)") ("(|(foo) bar)" "|((foo) bar)")) ("C-M-u" paredit-backward-up) ("C-M-d" paredit-forward-down) ("C-M-p" paredit-backward-down) ("C-M-n" paredit-forward-up) "Depth-Changing Commands" ("M-(" paredit-wrap-round ("(foo |bar baz)" "(foo (|bar) baz)")) ("M-s" paredit-splice-sexp ("(foo (bar| baz) quux)" "(foo bar| baz quux)")) (("M-<up>" "ESC <up>") paredit-splice-sexp-killing-backward ("(foo (let ((x 5)) |(sqrt n)) bar)" "(foo |(sqrt n) bar)")) (("M-<down>" "ESC <down>") paredit-splice-sexp-killing-forward ("(a (b c| d e) f)" "(a b c| f)")) ("M-r" paredit-raise-sexp ("(dynamic-wind in (lambda () |body) out)" "(dynamic-wind in |body out)" "|body")) ("M-?" paredit-convolute-sexp ("(let ((x 5) (y 3)) (frob |(zwonk)) (wibblethwop))" "(frob |(let ((x 5) (y 3)) (zwonk) (wibblethwop)))")) "Barfage & Slurpage" (("C-)" "C-<right>") paredit-forward-slurp-sexp ("(foo (bar |baz) quux zot)" "(foo (bar |baz quux) zot)") ("(a b ((c| d)) e f)" "(a b ((c| d) e) f)")) (("C-}" "C-<left>") paredit-forward-barf-sexp ("(foo (bar |baz quux) zot)" "(foo (bar |baz) quux zot)")) (("C-(" "C-M-<left>" "ESC C-<left>") paredit-backward-slurp-sexp ("(foo bar (baz| quux) zot)" "(foo (bar baz| quux) zot)") ("(a b ((c| d)) e f)" "(a (b (c| d)) e f)")) (("C-{" "C-M-<right>" "ESC C-<right>") paredit-backward-barf-sexp ("(foo (bar baz |quux) zot)" "(foo bar (baz |quux) zot)")) "Miscellaneous Commands" ("M-S" paredit-split-sexp ("(hello| world)" "(hello)| (world)") ("\"Hello, |world!\"" "\"Hello, \"| \"world!\"")) ("M-J" paredit-join-sexps ("(hello)| (world)" "(hello| world)") ("\"Hello, \"| \"world!\"" "\"Hello, |world!\"") ("hello-\n|  world" "hello-|world")) ("C-c C-M-l" paredit-recenter-on-sexp) ("M-q" paredit-reindent-defun))] 19)
(defalias 'paredit-do-commands '(macro . #[(vars string-case &rest body) "@A@\3068\3078\310\f\311B\312\313\fD
\314\314\315\316\fDDC\317\320\321\322\323\324\fEDFED\n\325\fDD	\326\fDDEBBFE,\207" [vars examples fn keys spec string-case 2 3 dolist (paredit-commands) if stringp let k car cond ((stringp k) (list k)) ((listp k) k) t error "Invalid paredit command %s." cadr cddr body] 16]))
(put 'paredit-do-commands 'lisp-indent-function 2)
(defalias 'paredit-define-keys #[nil "\306\211\205d\n@\211;\204\\	@\211;\203C\202*<\203&\202*\307\310	\")	\211A@)	\211AA)\211\f\306
\211\203[\n@
\311\312
!#\210\nA\211\204E-\nA\211\204\306*\207" [paredit-commands spec --dolist-tail-- k x examples nil error "Invalid paredit command %s." define-key read-kbd-macro fn keys key paredit-mode-map] 5])
(defalias 'paredit-function-documentation #[(fn) "\303N\304\305\"\211\206\306\303	#\210	*\207" [fn doc original-doc paredit-original-documentation documentation function-documentation put] 5])
(defalias 'paredit-annotate-mode-with-examples #[nil "\306\307!C	\310\211\203|@\211;\203\311\n\312QB\202u\n@\211;\203,\fC\2029\f<\2035\f\2029\313\314\n\")\n\211A@)\n\211AA)\315!\316\317\"\203t\320\321\203n\322\323\324#\202o\325\260B,A\211\204
*\326\307\327\330\331\332!\"#\210)\310\207" [contents paredit-commands spec --dolist-tail-- k x paredit-function-documentation paredit-mode nil "\n\f\n" "\n" error "Invalid paredit command %s." symbol-name string-match "paredit-" "\n\n\\[" "]	" mapconcat #[(example) "\301\302\303\304#\301Q\207" [example "\n" mapconcat identity "\n  --->\n"] 5] "" "\n  (no examples)\n" put function-documentation apply concat reverse examples fn keys name] 9])
(defalias 'paredit-annotate-functions-with-examples #[nil "\306\211\205\\\n@\211;\204T	@\211;\203C\202*<\203&\202*\307\310	\")	\211A@)	\211AA)\311\312\313!\314\315!\316\317\320
\321#\260#\210+\nA\211\204\306*\207" [paredit-commands spec --dolist-tail-- k x examples nil error "Invalid paredit command %s." put function-documentation paredit-function-documentation "\n\n\\<paredit-mode-map>\\[" symbol-name "]\n" mapconcat #[(example) "\301\302\303\304#\301Q\207" [example "\n" mapconcat identity "\n  ->\n"] 5] "" fn keys] 12])
#@50 Insert HTML for a paredit quick reference table.
(defalias 'paredit-insert-html-examples #[nil "\306\307\310\311\f\312\211!\203\245!@\211;\2037\204$\313c\210\202&\312\314
\315Q\316\317\320\321\322\323&\210\202\234
@\211\";\203F\"C\202U\"<\203Q\"\202U\324\325
\")
\211#A@)
\211#AA)$%&\326%!'\327\330'\"\203\233\317\331'\332Q\333\n&!\334Q\335$\203\225\336	$\337#\202\226\340\334Q\323%\210,!A\211!\204.\313c\207" [firstp html-example html-keys insert-lines paredit-commands spec #[(&rest lines) "\301\302\"\207" [lines mapc #[(line) "c\210\301 \207" [line newline] 1]] 3] #[(keys) "\301\302\303#\207" [keys mapconcat paredit-html-quote ", "] 4] #[(example) "\301\302\303\304#\305Q\207" [example "<table><tr><td><pre>" mapconcat paredit-html-quote "</pre></td></tr><tr><td>&nbsp;&nbsp;&nbsp;&nbsp;---&gt;</td></tr><tr><td><pre>" "</pre></td></tr></table>"] 5] t nil "</table>\n" "<h3>" "</h3>" "<table border=\"1\" cellpadding=\"1\">" "  <tr>" "    <th>Command</th>" "    <th>Keys</th>" "    <th>Examples</th>" "  </tr>" error "Invalid paredit command %s." symbol-name string-match "paredit-" "    <td><tt>" "</tt></td>" "    <td align=\"center\">" "</td>" "    <td>" mapconcat "<hr>" "(no examples)" --dolist-tail-- k x examples fn keys name] 10 (#$ . 11997) nil])
(defalias 'paredit-html-quote #[(string) "\305\306!rq\210\307\216	G\310\nW\203V	\n\234\211\311=\203#\312\202L\f\313=\203-\314\202L\f\315=\2037\316\202L\f\317=\203A\320\202L\f\321=\203K\322\202L\f)c\210\nT\211\202*\323 +\207" [#1=#:temp-buffer string i --dotimes-limit-- c generate-new-buffer " *temp*" ((byte-code "\301!\203\n\302!\210\301\207" [#1# buffer-name kill-buffer] 2)) 0 60 "&lt;" 62 "&gt;" 38 "&amp;" 39 "&apos;" 34 "&quot;" buffer-string] 3])
(defalias 'paredit-conc-name #[(&rest strings) "\301\302\303\"!\207" [strings intern apply concat] 4])
(defalias 'define-paredit-pair '(macro . #[(open close name) "\303\304\305\306\"\307\310\311\312\313\314\260	\315\316\317\320	DD\321\322\323	\n\324BBBB\325BBE\257\304\305\326\"\327\330\314Q\331\332\nD\257\304\305\326\333#\327\334\335\336\nD\257\304\305\337\"\340\341\342\343\344	\nF\257\345\346\347\305\337\"DE\257\207" [name open close progn defun paredit-conc-name "paredit-open-" (&optional n) "Insert a balanced " " pair.\nWith a prefix argument N, put the closing " " after N\n  S-expressions forward.\nIf the region is active, `transient-mark-mode' is enabled, and the\n  region's start and end fall in the same parenthesis depth, insert a\n  " " pair around the region.\nIf in a string or a comment, insert a single " ".\nIf in a character literal, do nothing.  This prevents changing what was\n  in the character literal to a meaningful delimiter unintentionally." (interactive "P") cond (or (paredit-in-string-p) (paredit-in-comment-p)) insert (not (paredit-in-char-p)) paredit-insert-pair n ('goto-char) ((save-excursion (backward-up-list) (indent-sexp))) "paredit-close-" nil "Move past one closing delimiter and reindent.\n(Agnostic to the specific closing delimiter.)\nIf in a string or comment, insert a single closing " (interactive) paredit-move-past-close "-and-newline" "Move past one closing delimiter, add a newline, and reindent.\nIf there was a margin comment after the closing delimiter, preserve it\n  on the same line." (interactive) paredit-move-past-close-and-newline "paredit-wrap-" (&optional argument) "Wrap the following S-expression.\nSee `paredit-wrap-sexp' for more details." (interactive "P") paredit-wrap-sexp argument add-to-list 'paredit-wrap-commands quote] 14]))
#@110 List of paredit commands that wrap S-expressions.
Used by `paredit-yank-pop'; for internal paredit use only.
(defvar paredit-wrap-commands '(paredit-wrap-sexp) (#$ . 15616))
#@475 Insert a balanced round pair.
With a prefix argument N, put the closing round after N
  S-expressions forward.
If the region is active, `transient-mark-mode' is enabled, and the
  region's start and end fall in the same parenthesis depth, insert a
  round pair around the region.
If in a string or a comment, insert a single round.
If in a character literal, do nothing.  This prevents changing what was
  in the character literal to a meaningful delimiter unintentionally.
(defalias 'paredit-open-round #[(&optional n) "\301 \204\n\302 \203
\303c\207\304 ?\205!\305\303\306\307$\210\212\310 \210\311 )\207" [n paredit-in-string-p paredit-in-comment-p 40 paredit-in-char-p paredit-insert-pair 41 goto-char backward-up-list indent-sexp] 5 (#$ . 15797) "P"])
#@293 Move past one closing delimiter and reindent.
(Agnostic to the specific closing delimiter.)
If in a string or comment, insert a single closing round.
If in a character literal, do nothing.  This prevents changing what was
  in the character literal to a meaningful delimiter unintentionally.
(defalias 'paredit-close-round #[nil "\300\301!\207" [paredit-move-past-close 41] 2 (#$ . 16565) nil])
#@154 Move past one closing delimiter, add a newline, and reindent.
If there was a margin comment after the closing delimiter, preserve it
  on the same line.
(defalias 'paredit-close-round-and-newline #[nil "\300\301!\207" [paredit-move-past-close-and-newline 41] 2 (#$ . 16967) nil])
#@76 Wrap the following S-expression.
See `paredit-wrap-sexp' for more details.
(defalias 'paredit-wrap-round #[(&optional argument) "\301\302\303#\207" [argument paredit-wrap-sexp 40 41] 4 (#$ . 17253) "P"])
(add-to-list 'paredit-wrap-commands 'paredit-wrap-round)
#@479 Insert a balanced square pair.
With a prefix argument N, put the closing square after N
  S-expressions forward.
If the region is active, `transient-mark-mode' is enabled, and the
  region's start and end fall in the same parenthesis depth, insert a
  square pair around the region.
If in a string or a comment, insert a single square.
If in a character literal, do nothing.  This prevents changing what was
  in the character literal to a meaningful delimiter unintentionally.
(defalias 'paredit-open-square #[(&optional n) "\301 \204\n\302 \203
\303c\207\304 ?\205!\305\303\306\307$\210\212\310 \210\311 )\207" [n paredit-in-string-p paredit-in-comment-p 91 paredit-in-char-p paredit-insert-pair 93 goto-char backward-up-list indent-sexp] 5 (#$ . 17522) "P"])
#@294 Move past one closing delimiter and reindent.
(Agnostic to the specific closing delimiter.)
If in a string or comment, insert a single closing square.
If in a character literal, do nothing.  This prevents changing what was
  in the character literal to a meaningful delimiter unintentionally.
(defalias 'paredit-close-square #[nil "\300\301!\207" [paredit-move-past-close 93] 2 (#$ . 18295) nil])
#@154 Move past one closing delimiter, add a newline, and reindent.
If there was a margin comment after the closing delimiter, preserve it
  on the same line.
(defalias 'paredit-close-square-and-newline #[nil "\300\301!\207" [paredit-move-past-close-and-newline 93] 2 (#$ . 18699) nil])
#@76 Wrap the following S-expression.
See `paredit-wrap-sexp' for more details.
(defalias 'paredit-wrap-square #[(&optional argument) "\301\302\303#\207" [argument paredit-wrap-sexp 91 93] 4 (#$ . 18986) "P"])
(add-to-list 'paredit-wrap-commands 'paredit-wrap-square)
#@475 Insert a balanced curly pair.
With a prefix argument N, put the closing curly after N
  S-expressions forward.
If the region is active, `transient-mark-mode' is enabled, and the
  region's start and end fall in the same parenthesis depth, insert a
  curly pair around the region.
If in a string or a comment, insert a single curly.
If in a character literal, do nothing.  This prevents changing what was
  in the character literal to a meaningful delimiter unintentionally.
(defalias 'paredit-open-curly #[(&optional n) "\301 \204\n\302 \203
\303c\207\304 ?\205!\305\303\306\307$\210\212\310 \210\311 )\207" [n paredit-in-string-p paredit-in-comment-p 123 paredit-in-char-p paredit-insert-pair 125 goto-char backward-up-list indent-sexp] 5 (#$ . 19257) "P"])
#@293 Move past one closing delimiter and reindent.
(Agnostic to the specific closing delimiter.)
If in a string or comment, insert a single closing curly.
If in a character literal, do nothing.  This prevents changing what was
  in the character literal to a meaningful delimiter unintentionally.
(defalias 'paredit-close-curly #[nil "\300\301!\207" [paredit-move-past-close 125] 2 (#$ . 20027) nil])
#@154 Move past one closing delimiter, add a newline, and reindent.
If there was a margin comment after the closing delimiter, preserve it
  on the same line.
(defalias 'paredit-close-curly-and-newline #[nil "\300\301!\207" [paredit-move-past-close-and-newline 125] 2 (#$ . 20430) nil])
#@76 Wrap the following S-expression.
See `paredit-wrap-sexp' for more details.
(defalias 'paredit-wrap-curly #[(&optional argument) "\301\302\303#\207" [argument paredit-wrap-sexp 123 125] 4 (#$ . 20717) "P"])
(add-to-list 'paredit-wrap-commands 'paredit-wrap-curly)
#@479 Insert a balanced angled pair.
With a prefix argument N, put the closing angled after N
  S-expressions forward.
If the region is active, `transient-mark-mode' is enabled, and the
  region's start and end fall in the same parenthesis depth, insert a
  angled pair around the region.
If in a string or a comment, insert a single angled.
If in a character literal, do nothing.  This prevents changing what was
  in the character literal to a meaningful delimiter unintentionally.
(defalias 'paredit-open-angled #[(&optional n) "\301 \204\n\302 \203
\303c\207\304 ?\205!\305\303\306\307$\210\212\310 \210\311 )\207" [n paredit-in-string-p paredit-in-comment-p 60 paredit-in-char-p paredit-insert-pair 62 goto-char backward-up-list indent-sexp] 5 (#$ . 20988) "P"])
#@294 Move past one closing delimiter and reindent.
(Agnostic to the specific closing delimiter.)
If in a string or comment, insert a single closing angled.
If in a character literal, do nothing.  This prevents changing what was
  in the character literal to a meaningful delimiter unintentionally.
(defalias 'paredit-close-angled #[nil "\300\301!\207" [paredit-move-past-close 62] 2 (#$ . 21761) nil])
#@154 Move past one closing delimiter, add a newline, and reindent.
If there was a margin comment after the closing delimiter, preserve it
  on the same line.
(defalias 'paredit-close-angled-and-newline #[nil "\300\301!\207" [paredit-move-past-close-and-newline 62] 2 (#$ . 22165) nil])
#@76 Wrap the following S-expression.
See `paredit-wrap-sexp' for more details.
(defalias 'paredit-wrap-angled #[(&optional argument) "\301\302\303#\207" [argument paredit-wrap-sexp 60 62] 4 (#$ . 22452) "P"])
(byte-code "\300\301\302\"\210\303\304\305\"\210\303\306\307\"\210\303\310\311\"\210\303\312\313\"\210\303\314\315\"\210\303\316\317\"\207" [add-to-list paredit-wrap-commands paredit-wrap-angled defalias paredit-open-parenthesis paredit-open-round paredit-close-parenthesis paredit-close-round paredit-close-parenthesis-and-newline paredit-close-round-and-newline paredit-open-bracket paredit-open-square paredit-close-bracket paredit-close-square paredit-close-bracket-and-newline paredit-close-square-and-newline] 3)
(defalias 'paredit-move-past-close #[(close) "\301\302\"\207" [close paredit-move-past-close-and #[nil "\300\301!\207" [paredit-blink-paren-match nil] 2]] 3])
(defalias 'paredit-move-past-close-and-newline #[(close) "\301\302\"\207" [close paredit-move-past-close-and #[nil "\301 \302 \210\203\212\303y\210\304\210Aj\210@c\210))\305 \210\304\306\307\217\210\310\311!\207" [comment\.point paredit-find-comment-on-line newline -1 nil lisp-indent-line (indent-sexp) ((scan-error)) paredit-blink-paren-match t] 3]] 3])
(defalias 'paredit-move-past-close-and #[(close if-moved) "\302 \204\n\303 \203
c\207\304 \203\305u\210\306!\210	 \207" [close if-moved paredit-in-string-p paredit-in-comment-p paredit-in-char-p nil paredit-move-past-close-and-reindent] 2])
#@385 Find a margin comment on the current line.
Return nil if there is no such comment or if there is anything but
  whitespace until such a comment.
If such a comment exists, delete the comment (including all leading
  whitespace) and return a cons whose car is the comment as a string
  and whose cdr is the point of the comment's initial semicolon,
  relative to the start of the line.
(defalias 'paredit-find-comment-on-line #[nil "\212\302\303\304 \"\210\305f\306=\205>`Tf\306=?\205>\307 \206\310 ?\205>\311u\210`\211\304 {\302\305\312 \"\210`\304 |\210	\312 Z*B)\207" [start comment paredit-skip-whitespace t point-at-eol nil 59 paredit-in-string-p paredit-in-char-p -1 point-at-bol] 4 (#$ . 23955)])
(defalias 'paredit-insert-pair #[(n open close forward) "\306 \205\307 \211\205	?\205\310 \311 b\210\312\313\"\211\203$\314c\210c\210\212	\2038
\315`\316	!\"!\210\202J\203J
\n\f\203F\317\202G\320\\!\210\321 \204W\322 \203W\323 \210c\210\312\324\"\205e\314c,\207" [regionp n end open spacep forward paredit-region-active-p paredit-region-safe-for-insert-p region-end region-beginning paredit-space-for-delimiter-p nil " " paredit-scan-sexps-hack prefix-numeric-value 2 1 paredit-in-string-p paredit-in-comment-p newline t close] 6])
(defalias 'paredit-scan-sexps-hack #[(point n) "\212b\210\305	W\203\306\202\307\310	!\305\311\312\215\210+`)\207" [point n count magnitude direction 0 1 -1 abs exit (byte-code "	W\203\303\304\305\217\211\204\306\307\303\"\210\nb\210)T\211\202
\303\207" [count magnitude p nil (byte-code "\301`\"\207" [direction scan-sexps] 3) ((scan-error)) throw exit] 4)] 3])
(defalias 'paredit-region-safe-for-insert-p #[nil "\212\304 \305 \211b\210\306 \307	\310\211\n%\n@@U\2058\311\n8\3118=\2058\312\n8\3128=\2058\313\n8\3138=-\207" [end beginning beginning-state end-state region-beginning region-end paredit-current-parse-state parse-partial-sexp nil 3 4 5] 7])
#@846 List of predicates for whether to put space by delimiter at point.
Each predicate is a function that is is applied to two arguments, ENDP
  and DELIMITER, and that returns a boolean saying whether to put a
  space next to the delimiter -- before the delimiter if ENDP is false,
  after the delimiter if ENDP is true.
If any predicate returns false, no space is inserted: every predicate
  has veto power.
Each predicate may assume that the point is not at the beginning of the
  buffer, if ENDP is false, or at the end of the buffer, if ENDP is
  true; and that the point is not preceded, if ENDP is false, or
  followed, if ENDP is true, by a word or symbol constituent, a quote,
  or the delimiter matching DELIMITER.
Each predicate should examine only text before the point, if ENDP is
  false, or only text after the point, if ENDP is true.
(defvar paredit-space-for-delimiter-predicates nil (#$ . 25913))
(defalias 'paredit-space-for-delimiter-p #[(endp delimiter) "\203m\202	o?\205>\203\303f\202`Sfz\304\305\306\307	!\211\205'\nz)?\2055	z\306=\2055\310\257>\205>\311\312\215\207" [endp delimiter matching nil 119 95 34 matching-paren 41 exit (byte-code "\305\211\203\n@\211\f\"\204\306\307\305\"\210\nA\211\204*\310\207" [paredit-space-for-delimiter-predicates predicate --dolist-tail-- endp delimiter nil throw exit t] 4)] 8])
(defalias 'paredit-move-past-close-and-reindent #[(close) "\302 \211\203\"	\303!=\203\212\304\305	\"\210	c\210)\202\"\306\307	#\210)\310 \210\311\312\215\205.\313 \207" [open close paredit-missing-close matching-paren message "Missing closing delimiter: %c" error "Mismatched missing closing delimiter: %c ... %c" up-list return (byte-code "\212`S\301 \210`=\204\302\303\304\"\210\2020\212\305y\210\306\210\307 )\203-\310 \210\302\303\306\"\210\2020\311 \210*\202" [before-paren back-to-indentation throw return t -1 nil paredit-in-comment-p lisp-indent-line delete-indentation] 3) paredit-delete-leading-whitespace] 5])
(defalias 'paredit-missing-close #[nil "\212\301\302\303\217\210\301f\301\304\305\217*\207" [open nil (backward-up-list) ((scan-error (error "Not inside a list."))) (byte-code "\300 \210\301\207" [forward-sexp nil] 1) ((scan-error open))] 3])
(defalias 'paredit-delete-leading-whitespace #[nil "\212\301u\210`Sfz\211\302=\204\303=\205\304`S!?)\205%\305\306!\210\202)\207" [syn -1 32 45 paredit-in-char-p backward-delete-char 1] 3])
(defalias 'paredit-blink-paren-match #[(another-line-p) "\205	\203\f\n\205\303\304\305\217\207" [blink-matching-paren show-paren-mode another-line-p nil (byte-code "\212\301 \210\302 \210\303\304 *\207" [show-paren-mode backward-sexp forward-sexp nil blink-matching-open] 1) ((scan-error))] 3])
#@739 Insert a pair of double-quotes.
With a prefix argument N, wrap the following N S-expressions in
  double-quotes, escaping intermediate characters if necessary.
If the region is active, `transient-mark-mode' is enabled, and the
  region's start and end fall in the same parenthesis depth, insert a
  pair of double-quotes around the region, again escaping intermediate
  characters if necessary.
Inside a comment, insert a literal double-quote.
At the end of a string, move past the closing double-quote.
In the middle of a string, insert a backslash-escaped double-quote.
If in a character literal, do nothing.  This prevents accidentally
  changing a what was in the character literal to become a meaningful
  delimiter unintentionally.
(defalias 'paredit-doublequote #[(&optional n) "\301 \203\302 A`=\203\303u\207\304\305\261\207\306 \203\305c\207\307 ?\205)\310\305\211\311$\207" [n paredit-in-string-p paredit-string-start+end-points nil 92 34 paredit-in-comment-p paredit-in-char-p paredit-insert-pair paredit-forward-for-quote] 5 (#$ . 28666) "P"])
#@280 Move to the end of the string, insert a newline, and indent.
If not in a string, act as `paredit-doublequote'; if no prefix argument
  is specified and the region is not active or `transient-mark-mode' is
  disabled, the default is to wrap one S-expression, however, not
  zero.
(defalias 'paredit-meta-doublequote #[(&optional n) "\302 \204\303\206\304 ?\205\305!\207\306 \211ATb\210\307 \210\310 \210\311\312\313\217)\207" [n start+end paredit-in-string-p paredit-doublequote paredit-region-active-p 1 paredit-string-start+end-points newline lisp-indent-line nil (indent-sexp) ((scan-error))] 4 (#$ . 29738) "P"])
(defalias 'paredit-forward-for-quote #[(end) "\303 `	W\205L\304``T\305\211%\306\n!\2035\307 \204\"\n\202H\310c\210\304`\311Z`\305\211%	T\202H\312u\210\310c\210\304`S`T\305\211%	T)\202)\207" [state end new-state paredit-current-parse-state parse-partial-sexp nil paredit-in-string-p paredit-in-string-escape-p 92 2 -1] 6])
#@55 Insert a backslash followed by a character to escape.
(defalias 'paredit-backslash #[nil "\300 \203\301 \207\302 \203\303c\207\304 \203\305u\210\301 \207\301 \207" [paredit-in-string-p paredit-backslash-interactive paredit-in-comment-p 92 paredit-in-char-p nil] 1 (#$ . 30707) nil])
(defalias 'paredit-backslash-interactive #[nil "\302c\210\303\304\216\305\306!\211\307=?\205\310\311	\"\210	c\210\312\211+\207" [delete-p char 92 t ((byte-code "\203\f\301\302!\210\303\304!\210\301\207" [delete-p message "Deleting escape." backward-delete-char 1] 2)) read-char "Character to escape: " 127 message "Character to escape: %c" nil] 4])
#@431 Insert a newline and indent it.
This is like `newline-and-indent', but it not only indents the line
  that the point is on but also the S-expression following the point,
  if there is one.
Move forward one character first if on an escaped character.
If in a string, just insert a literal newline.
If in a comment and if followed by invalid structure, call
  `indent-new-comment-line' to keep the invalid structure in a
  comment.
(defalias 'paredit-newline #[nil "\300 \203\301 \207\302 \203 \303`\304 \"\203\305 \210\306\307\310\217\207\311 \207\312 \203(\306u\210\305 \210\306\313\314\217\207" [paredit-in-string-p newline paredit-in-comment-p paredit-region-ok-p point-at-eol newline-and-indent nil (indent-sexp) ((scan-error)) indent-new-comment-line paredit-in-char-p (indent-sexp) ((scan-error))] 3 (#$ . 31359) nil])
#@164 Reindent the definition that the point is on.
If the point is in a string or a comment, fill the paragraph instead,
  and with a prefix argument, justify as well.
(defalias 'paredit-reindent-defun #[(&optional argument) "\304 \204\n\305 \203\306!\207i\307 \212\310 \210\311 \210\312 \210)\307 \313 \n	W\2041\n	Z\\\202<\nX\203;\202<\n\\b+\207" [argument indentation column indentation* paredit-in-string-p paredit-in-comment-p lisp-fill-paragraph paredit-current-indentation end-of-defun beginning-of-defun indent-sexp point-at-bol] 4 (#$ . 32196) "P"])
#@504 Insert a semicolon.
With a prefix argument N, insert N semicolons.
If in a string, do just that and nothing else.
If in a character literal, move to the beginning of the character
  literal before inserting the semicolon.
If the enclosing list ends on the line after the point, break the line
  after the last S-expression following the point.
If a list begins on the line after the point but ends on a different
  line, break the line after the last S-expression following the point
  before the list.
(defalias 'paredit-semicolon #[(&optional n) "\302 \204\n\303 \203\304\206\305\306\"c\207\307 \203\310u\210\311 \211\203.\312	\206*\305\"\2027\304\2064\305\306\"c)\207" [n line-break-point paredit-in-string-p paredit-in-comment-p make-string 1 59 paredit-in-char-p -2 paredit-semicolon-find-line-break-point paredit-semicolon-with-line-break] 4 (#$ . 32770) "p"])
(defalias 'paredit-semicolon-find-line-break-point #[nil "\302\303 l?\205\212\302\304\305\217)\205	*\207" [eol line-break-point nil point-at-eol (byte-code "`\302 \210	\303 =\203m\203\304 \210	\303 =\205\302 \210m?\207" [line-break-point eol forward-sexp point-at-eol backward-sexp] 2) ((scan-error (byte-code "\212\300\301\302 \"\210l\206\303f\304=)?\207" [paredit-skip-whitespace t point-at-eol nil 59] 3)))] 3])
(defalias 'paredit-semicolon-with-line-break #[(line-break-point n) "\303 \211	\304\223\210\305\306\"\210\307\n\206\310\311\"c\210\212b\210\304\211\223\210\312 \210\313 \210\304\314\315\217\210\316 *\207" [line-break-marker line-break-point n make-marker nil set-marker-insertion-type t make-string 1 59 newline lisp-indent-line (indent-sexp) ((scan-error)) paredit-indent-sexps] 4])
(byte-code "\300\301\302\"\210\300\303\302\"\210\300\304\302\"\210\300\305\302\"\210\300\306\302\"\207" [autoload comment-forward "newcomment" comment-normalize-vars comment-region comment-search-forward uncomment-region] 3)
(defalias 'paredit-initialize-comment-dwim #[nil "\300\301!\210\302\303!\204\304\303\305\"\210\304\306\307\"\210\307 \207" [require newcomment fboundp comment-or-uncomment-region defalias #[(beginning end &optional argument) "\212b\210\303d!\210	`X)\203\304	\n#\207\305	\n#\207" [beginning end argument comment-forward uncomment-region comment-region] 4 nil "*r\nP"] paredit-initialize-comment-dwim comment-normalize-vars] 3])
#@971 Call the Lisp comment command you want (Do What I Mean).
This is like `comment-dwim', but it is specialized for Lisp editing.
If transient mark mode is enabled and the mark is active, comment or
  uncomment the selected region, depending on whether it was entirely
  commented not not already.
If there is already a comment on the current line, with no prefix
  argument, indent to that comment; with a prefix argument, kill that
  comment.
Otherwise, insert a comment appropriate for the context and ensure that
  any code following the comment is moved to the next line.
At the top level, where indentation is calculated to be at column 0,
  insert a triple-semicolon comment; within code, where the indentation
  is calculated to be non-zero, and on the line there is either no code
  at all or code after the point, insert a double-semicolon comment;
  and if the point is after all code on the line, insert a single-
  semicolon margin comment at `comment-column'.
(defalias 'paredit-comment-dwim #[(&optional argument) "\301 \210\302 \203\303\304 \305 #\207\306 \203%\203\"\307\250\205 !\207\310 \207\311 \207" [argument paredit-initialize-comment-dwim paredit-region-active-p comment-or-uncomment-region region-beginning region-end paredit-comment-on-line-p comment-kill comment-indent paredit-insert-comment] 4 (#$ . 35138) "*P"])
#@147 True if there is a comment on the line following point.
This is expected to be called only in `paredit-comment-dwim'; do not
  call it elsewhere.
(defalias 'paredit-comment-on-line-p #[nil "\212\301 \210\302\303\304 \305\"\211\203\"\306 \204\307`S!\203\"\302u\210\202*\207" [comment-p beginning-of-line nil comment-search-forward point-at-eol t paredit-in-string-p paredit-in-char-p] 4 (#$ . 36493)])
(defalias 'paredit-insert-comment #[nil "\212\304\305\306 \"\210l)?\212\304\307\310 \"\210n)?n\203C\311 \211:\203'\n@\202(\n)\211\2051\312\n!)\203C	\203>\212\313 \210)\314c\202s	\204K\204l\203U\315 \210\202X\316 \210\317c\210	\205s\212\313 \210\316 \210\320 )\202s\321\322\"\210\323c*\207" [code-before-p code-after-p indent comment-column paredit-skip-whitespace t point-at-eol nil point-at-bol calculate-lisp-indent zerop newline ";;; " newline-and-indent lisp-indent-line ";; " paredit-indent-sexps indent-to 1 59] 5])
#@449 Delete a character forward or move forward over a delimiter.
If on an opening S-expression delimiter, move forward into the
  S-expression.
If on a closing S-expression delimiter, refuse to delete unless the
  S-expression is empty, in which case delete the whole S-expression.
With a numeric prefix argument N, delete N characters forward.
With a `C-u' prefix argument, simply delete a character forward,
  without regard for delimiter balancing.
(defalias 'paredit-forward-delete #[(&optional argument) ":\204	m\203
\302\303!\207\250\203-\304W\203\305!\207\304V\205,\306 \210S\211\202\207\307 \2035\310 \207\311 \203=\312 \207\313 \203J\314\303!\210\302\303!\207\315f\316=\203U\302\317!\207\315fz\211\320=\206b	\321=)\203z\212\315\322\323\217)\203r\315u\207\324\325!\210\302\303!\207\313`S!\204\234\315fz\326=\203\234`Sf\327\315f!=\203\234\314\303!\210\302\303!\207\315f\330=\203\246\331 \207\315fz\326=?\205\262\302\303!\207" [argument syn delete-char 1 0 paredit-backward-delete paredit-forward-delete paredit-in-string-p paredit-forward-delete-in-string paredit-in-comment-p paredit-forward-delete-in-comment paredit-in-char-p backward-delete-char nil 92 2 40 34 (byte-code "\300 \210\301\207" [forward-sexp t] 1) ((scan-error)) message "Deleting spurious opening delimiter." 41 matching-paren 59 paredit-forward-delete-comment-start] 4 (#$ . 37452) "P"])
(defalias 'paredit-forward-delete-in-string #[nil "\301 `A=\204'\302 \203\303\304!\210\202!\305f\306=\203!\307\304!\210\307\304!\2026`S@=\2056\303\304!\210\307\304!)\207" [start+end paredit-string-start+end-points paredit-in-string-escape-p backward-delete-char 1 nil 92 delete-char] 2])
(defalias 'paredit-forward-delete-in-comment #[nil "l\203\302\303!\304\303!\305	\"\210*\306\307!\207" [next-line-end next-line-start point-at-bol 2 point-at-eol paredit-check-region delete-char 1] 3])
(defalias 'paredit-forward-delete-comment-start #[nil "\300`T\301 \"\210\302\303!\207" [paredit-check-region point-at-eol delete-char 1] 3])
#@454 Delete a character backward or move backward over a delimiter.
If on a closing S-expression delimiter, move backward into the
  S-expression.
If on an opening S-expression delimiter, refuse to delete unless the
  S-expression is empty, in which case delete the whole S-expression.
With a numeric prefix argument N, delete N characters backward.
With a `C-u' prefix argument, simply delete a character backward,
  without regard for delimiter balancing.
(defalias 'paredit-backward-delete #[(&optional argument) ":\204	o\203
\302\303!\207\250\203.\304W\203\305[!\207\304V\205-\306 \210S\211\202\207\307 \2036\310 \207\311 \203>\312 \207\313 \203K\302\303!\210\314\303!\207\313`S!\203V\302\315!\207`Sfz\211\316=\206d	\317=)\203|\212\320\321\322\217)\203t\323u\207\324\325!\210\302\303!\207`Sfz\326=\203\230\320f\327`Sf!=\203\230\302\303!\210\314\303!\207n\203\237\330 \207`Sfz\326=?\205\254\331\303!\207" [argument syn backward-delete-char 1 0 paredit-forward-delete paredit-backward-delete paredit-in-string-p paredit-backward-delete-in-string paredit-in-comment-p paredit-backward-delete-in-comment paredit-in-char-p delete-char 2 41 34 nil (byte-code "\300 \210\301\207" [backward-sexp t] 1) ((scan-error)) -1 message "Deleting spurious closing delimiter." 40 matching-paren paredit-backward-delete-maybe-comment-end backward-delete-char-untabify] 4 (#$ . 39493) "P"])
(defalias 'paredit-backward-delete-in-string #[nil "\301 `S@=\204#\302 \203\303\304!\210\305\304!\210\302 \2051\305\304!\2021`A=\2051\305\304!\210\303\304!)\207" [start+end paredit-string-start+end-points paredit-in-string-escape-p delete-char 1 backward-delete-char] 2])
(defalias 'paredit-backward-delete-in-comment #[nil "\212\300u\210\301 \206\302 )\204\303`\304 \"\210\305\306!\207" [-1 paredit-in-string-p paredit-in-comment-p paredit-check-region point-at-eol backward-delete-char-untabify 1] 3])
(defalias 'paredit-backward-delete-maybe-comment-end #[nil "\212\300u\210\301 ?\205\f\302 )\203\303\304 \305 \"\210\306\307!\207" [-1 paredit-in-string-p paredit-in-comment-p paredit-check-region point-at-eol point-at-bol backward-delete-char 1] 3])
#@463 Kill a line as if with `kill-line', but respecting delimiters.
In a string, act exactly as `kill-line' but do not kill past the
  closing string delimiter.
On a line with no S-expressions on it starting after the point or
  within a comment, act exactly as `kill-line'.
Otherwise, kill all S-expressions that start after the point.
With a `C-u' prefix argument, just do the standard `kill-line'.
With a numeric prefix argument N, do `kill-line' that many times.
(defalias 'paredit-kill #[(&optional argument) "\203\301\250\203\202\302!\207\303 \203\304 \207\305 \203!\306 \207\212\307\310\311 \"\210l\2060\312f\313=)\203?\314 \203<\315u\210\301 \207\316 \207" [argument kill-line 1 paredit-in-string-p paredit-kill-line-in-string paredit-in-comment-p paredit-kill-line-in-comment paredit-skip-whitespace t point-at-eol nil 59 paredit-in-char-p -1 paredit-kill-sexps-on-line] 3 (#$ . 41667) "P"])
(defalias 'paredit-kill-line-in-string #[nil "\212\300\301\302 \"\210l)\203\303 \207\212\304 \203\305u\210\306`\302 \307 A^\")\207" [paredit-skip-whitespace t point-at-eol kill-line paredit-in-string-escape-p -1 kill-region paredit-string-start+end-points] 4])
(defalias 'paredit-kill-line-in-comment #[nil "l\203\300 \207\301 \207" [paredit-forward-delete-in-comment kill-line] 1])
(defalias 'paredit-kill-sexps-on-line #[nil "\304 \203\305u\210`\306 \307	\"\211\203\310 \210\311u\210\203&\312	!\2029\313	\n\2047\306 =\2037\2028`\"+\207" [eol beginning end-of-list-p kill-whole-line paredit-in-char-p -2 point-at-eol paredit-forward-sexps-to-kill up-list -1 paredit-kill-sexps-on-whole-line kill-region] 5])
(defalias 'paredit-forward-sexps-to-kill #[(beginning eol) "\302\303\304\305\215\210	*\207" [firstp end-of-list-p nil t return (byte-code "\203
m\203
\303\304\305\"\210\212\305\306\307\217\210	\204\204m\204-\305\310\311\217\204-\312 \n=\2042\303\304\305\"\210)\313 \210	\203G\204Gm\203G\303\304\305\"\210\305\202" [kill-whole-line firstp eol throw return nil (forward-sexp) ((scan-error (byte-code "\302 \210\303 =\304\305\306\"\207" [eol end-of-list-p up-list point-at-eol throw return nil] 3))) (byte-code "\300 \210\301\207" [backward-sexp nil] 1) ((scan-error t)) point-at-eol forward-sexp] 3)] 2])
(defalias 'paredit-kill-sexps-on-whole-line #[(beginning) "\303\212\304\305!\210\306f\307=?\205`)\206\310 \"\210\212\304\306\311 \"\210n)\203'\312 \207m\203-\306\207`Sfz\306fz\211\313=\203B	\314=\206W\n\315=\203N	\315=\206W\n\316>\205W	\317>*\205]\320c\207" [beginning syn-after syn-before kill-region paredit-skip-whitespace t nil 59 point-at-eol point-at-bol lisp-indent-line 41 40 34 (95 119) (95 119) " "] 5])
#@60 Kill a word forward, skipping over intervening delimiters.
(defalias 'paredit-forward-kill-word #[nil "`\305\306!\210\307 \310	\311\"m\204>\312fz\313=\204>\314u\210\307 \n\310	\311\"\f=\204:\315\f	#\310	\311\"`*\202*b\210\316\314!)\207" [beginning parse-state state old-state new-state skip-syntax-forward " -" paredit-current-parse-state paredit-kill-word-state char-after nil 119 1 paredit-kill-word-hack kill-word] 4 (#$ . 44369) nil])
#@65 Kill a word backward, skipping over any intervening delimiters.
(defalias 'paredit-backward-kill-word #[nil "o\204V`Sfz\303=\204V`\304v\210\305v\210`^b\210\306 \307	\310\"`W\203=\311``T\312\211	%\n\307	\310\"=\204\"\304u\210\n\313=\203U`f\314=\203U`Sf\315=\203U\304u\210+\316\305!\207" [end parse-state state 119 -1 1 paredit-current-parse-state paredit-kill-word-state char-before parse-partial-sexp nil comment 35 124 backward-kill-word] 6 (#$ . 44831) nil])
(defalias 'paredit-kill-word-state #[(parse-state adjacent-char-fn) "\302!\203\303\207\304!\203\305\207	 z\306>\203\307\207\310\207" [parse-state adjacent-char-fn paredit-in-comment-p comment paredit-in-string-p string (40 41) delimiter other] 2])
(defalias 'paredit-kill-word-hack #[(old-state new-state parse-state) "\303=\204&	\303=\204&\304 \204&`Sf\305=\203&\306f\307=\203&\310u\210\311 \207\303=\204A	\303=\203A`Sf\312=\203A\313\306w\210\311 \207\n\207" [old-state new-state parse-state comment paredit-in-string-escape-p 35 nil 124 1 paredit-current-parse-state 59 ";"] 2])
#@66 Save in the kill ring the region that `paredit-kill' would kill.
(defalias 'paredit-copy-as-kill #[nil "\300 \203\301 \207\302 \203\303`\304 \"\207\212\305\306\304 \"\210l\206\"\307f\310=)\2036\212\311 \203/\312u\210\303`\304 \")\207\313 \207" [paredit-in-string-p paredit-copy-as-kill-in-string paredit-in-comment-p copy-region-as-kill point-at-eol paredit-skip-whitespace t nil 59 paredit-in-char-p -1 paredit-copy-sexps-as-kill] 3 (#$ . 45910) nil])
(defalias 'paredit-copy-as-kill-in-string #[nil "\212\300 \203	\301u\210\302`\303 \304 A^\")\207" [paredit-in-string-escape-p -1 copy-region-as-kill point-at-eol paredit-string-start+end-points] 4])
(defalias 'paredit-copy-sexps-as-kill #[nil "\212\304 \203	\305u\210`\306 \307	\"\211\203\310 \210\311u\210\312	\203:\212\313\314!\210\315f\316=?\2051`)\206J\306 \202J\n\204I\306 =\203I\202J`\",\207" [eol beginning end-of-list-p kill-whole-line paredit-in-char-p -2 point-at-eol paredit-forward-sexps-to-kill up-list -1 copy-region-as-kill paredit-skip-whitespace t nil 59] 5])
#@164 Delete the text between point and mark, like `delete-region'.
If that text is unbalanced, signal an error instead.
With a prefix argument, skip the balance check.
(defalias 'paredit-delete-region #[(start end) "\203	\203\n\204\304	\"\210\305	|\207" [start end current-prefix-arg this-command paredit-check-region-for-delete delete-region] 3 (#$ . 46972) "r"])
#@160 Kill the text between point and mark, like `kill-region'.
If that text is unbalanced, signal an error instead.
With a prefix argument, skip the balance check.
(defalias 'paredit-kill-region #[(start end) "\203	\203\n\204\304	\"\210\305\211	\"\207" [start end current-prefix-arg this-command paredit-check-region-for-delete kill-region] 4 (#$ . 47349) "r"])
#@64 Signal an error deleting text between START and END is unsafe.
(defalias 'paredit-check-region-for-delete #[(start end) "\212b\210\304 \305\n\306\211	%\307	\n$\210\310	\n$\210\311	\n$\210\312	\n$+\207" [start start-state end end-state paredit-current-parse-state parse-partial-sexp nil paredit-check-region-for-delete:depth paredit-check-region-for-delete:string paredit-check-region-for-delete:comment paredit-check-region-for-delete:char-quote] 6 (#$ . 47722)])
(defalias 'paredit-check-region-for-delete:depth #[(start start-state end end-state) "@	@\211\nU?\205\304\305\n#*\207" [start-state end-state end-depth start-depth error "Mismatched parenthesis depth: %S at start, %S at end."] 5])
(defalias 'paredit-check-region-for-delete:string #[(start start-state end end-state) "\3048\304	8\211\n=?\205$\305\306\203\307\202\310\n\203\"\307\202#\310#*\207" [start-state end-state end-string-p start-string-p 3 error "Mismatched string state: start %sin string, end %sin string." "" "not "] 5])
(defalias 'paredit-check-region-for-delete:comment #[(start start-state end end-state) "\3058\305	8\211\n=\2060\306=\203\n\307=\204&\307=\2050\n\306=\2050\212\fb\210\310`\311 \")?\205p\312\313\250\203H\n\250\203H\314\315\n#\202o\250\203Q\316\202o\n\250\203Z\317\202o\203b\320\202o\n\203j\321\202o\314\322\n#\"*\207" [start-state end-state end-comment-state start-comment-state end 4 nil t paredit-region-ok-p point-at-eol error "Mismatched comment state: %s" format "depth %S at start, depth %S at end." "start in nested comment, end otherwise." "end in nested comment, start otherwise." "start in comment, end not in comment." "end in comment, start not in comment." "start %S, end %S."] 7])
(defalias 'paredit-check-region-for-delete:char-quote #[(start start-state end end-state) "\3058\305	8\211\n=?\205+\306\307\310\f\203\311\202\312\f\n\203&\311\202'\312\f&)*\207" [start-state end-state end-char-quote start-char-quote phrase 5 "character quotation" error "Mismatched %s: start %sin %s, end %sin %s." "" "not "] 8])
(defalias 'defun-saving-mark '(macro . #[(name bvl doc &rest body) "\304	\n\305 \203
\306\202\307 \203\310\202\311\312!BBBBB\207" [name bvl doc body defun paredit-xemacs-p (interactive "_") paredit-gnu-emacs-p (interactive) error "XCOND lost."] 6]))
#@244 Move forward an S-expression, or up an S-expression forward.
If there are no more S-expressions in this one before the closing
  delimiter, move past that closing delimiter; otherwise, move forward
  past the S-expression following the point.
(defalias 'paredit-forward #[nil "\300\301\302\217\207" [nil (forward-sexp) ((scan-error (byte-code "\300 \203\301u\207\302 \207" [paredit-in-string-p nil up-list] 1)))] 3 (#$ . 50077) nil])
#@261 Move backward an S-expression, or up an S-expression backward.
If there are no more S-expressions in this one before the opening
  delimiter, move past that opening delimiter backward; otherwise, move
  move backward past the S-expression preceding the point.
(defalias 'paredit-backward #[nil "\300\301\302\217\207" [nil (backward-sexp) ((scan-error (byte-code "\300 \203\301u\207\302 \207" [paredit-in-string-p -1 backward-up-list] 1)))] 3 (#$ . 50520) nil])
#@159 Move backward and descend into one level of parentheses.
With ARG, do this that many times.
A negative argument means move forward but still descend a level.
(defalias 'backward-down-list #[(&optional arg) "\301\206\302[!\207" [arg down-list 1] 2 (#$ . 50990) "p"])
(defalias 'paredit-recentre-on-sexp 'paredit-recenter-on-sexp)
#@127 Recenter the screen on the S-expression following the point.
With a prefix argument N, encompass all N S-expressions forward.
(defalias 'paredit-recenter-on-sexp #[(&optional n) "`\306	!\210`\211b\210\307	!\210`\310\211\212\311\n\"\312\245y\210\313 \210\314!\314!)\f\2044\313\315!\202:
\205:b-\207" [p n end-point start-point start-visible p-visible forward-sexp backward-sexp nil count-lines 2 recenter pos-visible-in-window-p 0] 4 (#$ . 51329) "P"])
#@49 Recenter the screen on the definition at point.
(defalias 'paredit-recenter-on-defun #[nil "\212\300 \210\301 )\207" [beginning-of-defun paredit-recenter-on-sexp] 1 (#$ . 51801) nil])
#@54 Moves display to the top of the definition at point.
(defalias 'paredit-focus-on-defun #[nil "\300 \210\301\302!\207" [beginning-of-defun recenter 0] 2 (#$ . 51991) nil])
(defalias 'paredit-up/down #[(n vertical-direction) "\303W\203\n\304\202\305\303U?\205!\306	\n\"b\210	Z\211\202
)\207" [n horizontal-direction vertical-direction 0 1 -1 paredit-next-up/down-point] 4])
(defalias 'paredit-next-up/down-point #[(horizontal-direction vertical-direction) "\306 \307\310	!\203-\311	!\312W\203&\312\fW\203!\nAT\202)\n@\202)\313\314!)\202\200\312W\203> \206\200\315\f!\202\200\312W\203|\316\317\320\217\321\f
\"\211\203k
\203k\312\fW\203d
^\202x
]\202x\206x \206x\315\f!*\202\200\313\322\323\"*\207" [scan-lists state start+end vertical-direction horizontal-direction list-start paredit-current-parse-state #[nil "\302`	#\207" [horizontal-direction vertical-direction scan-lists] 4] paredit-in-string-p paredit-string-start+end-points 0 error "Can't descend further into string." buffer-end nil (funcall scan-lists) ((scan-error)) paredit-find-next-string-start "Vertical direction must be nonzero in `%s'." paredit-up/down string-start] 4])
(defalias 'paredit-find-next-string-start #[(horizontal-direction limit) "\304W\203\n\305\202\306\304W\203\307\202\310\304W\203 \311\202!\312\313\314\315\217+\207" [horizontal-direction pastp next-char buffer-limit-p 0 eobp bobp char-after char-before > < nil (byte-code "\212\300\301\215)\207" [exit (byte-code " \204	\203\n`	\"\203\305\306\307\"\210\310!\210\212\311!\210\f z\312=\203-\305\306`\\\"\210)\202" [buffer-limit-p limit pastp horizontal-direction next-char throw exit nil forward-sexp backward-sexp 34] 4)] 2) ((scan-error))] 4])
#@157 Move forward down into a list.
With a positive argument, move forward down that many levels.
With a negative argument, move backward down that many levels.
(defalias 'paredit-forward-down #[(&optional argument) "\301\206\302\303\"\207" [argument paredit-up/down 1 -1] 3 (#$ . 53753) "p"])
#@218 Move backward up out of the enclosing list.
With a positive argument, move backward up that many levels.
With a negative argument, move forward up that many levels.
If in a string initially, that counts as one level.
(defalias 'paredit-backward-up #[(&optional argument) "\301\206\302[\302\"\207" [argument paredit-up/down 1] 3 (#$ . 54052) "p"])
#@217 Move forward up out of the enclosing list.
With a positive argument, move forward up that many levels.
With a negative argument, move backward up that many levels.
If in a string initially, that counts as one level.
(defalias 'paredit-forward-up #[(&optional argument) "\301\206\302\302\"\207" [argument paredit-up/down 1] 3 (#$ . 54409) "p"])
#@158 Move backward down into a list.
With a positive argument, move backward down that many levels.
With a negative argument, move forward down that many levels.
(defalias 'paredit-backward-down #[(&optional argument) "\301\206\302[\303\"\207" [argument paredit-up/down 1 -1] 3 (#$ . 54763) "p"])
#@549 Wrap the following S-expression.
If a `C-u' prefix argument is given, wrap all S-expressions following
  the point until the end of the buffer or of the enclosing list.
If a numeric prefix argument N is given, wrap N S-expressions.
Automatically indent the newly wrapped S-expression.
As a special case, if the point is at the end of a list, simply insert
  a parenthesis pair, rather than inserting a lone opening delimiter
  and then signalling an error, in the interest of preserving
  structure.
By default OPEN and CLOSE are round delimiters.
(defalias 'paredit-wrap-sexp #[(&optional argument open close) "\302\303!\210\206	\304	\206\305\306\307\310\217\210*\212\311 \210\312 )\207" [open close paredit-lose-if-not-in-sexp paredit-wrap-sexp 40 41 nil (byte-code "\250\203	\202:\203\304 \202\305 \203\306\202\307\310	\n\311$\210)\306\207" [argument n open close paredit-count-sexps-forward paredit-region-active-p nil 1 paredit-insert-pair goto-char] 5) ((scan-error (byte-code "c\210\301u\207" [close -1] 1))) backward-up-list indent-sexp] 3 (#$ . 55065) "P"])
(defalias 'paredit-count-sexps-forward #[nil "\212\302\303\303\304\305\217\210	+\207" [p n 0 nil (byte-code "\302`\303\"\211\203b\210	T\202\302\207" [p n scan-sexps 1] 3) ((scan-error))] 3])
#@468 Replace just-yanked text with the next item in the kill ring.
If this command follows a `yank', just run `yank-pop'.
If this command follows a `paredit-wrap-sexp', or any other paredit
  wrapping command (see `paredit-wrap-commands'), run `yank' and
  reindent the enclosing S-expression.
If this command is repeated, run `yank-pop' and reindent the enclosing
  S-expression.

The argument is passed on to `yank' or `yank-pop'; see their
  documentation for details.
(defalias 'paredit-yank-pop #[(&optional argument) "\304=\203\n\305	!\207\n>\203\304	!\210\306\212\307 \210\310 )\207\306=\2036\304\305	!\210\306\211\212\307 \210\310 )\207\311\312\"\207" [last-command argument paredit-wrap-commands this-command yank yank-pop paredit-yank-pop backward-up-list indent-sexp error "Last command was not a yank or a wrap: %s"] 4 (#$ . 56362) "*p"])
#@700 Splice the list that the point is on by removing its delimiters.
With a prefix argument as in `C-u', kill all S-expressions backward in
  the current list before splicing all S-expressions forward into the
  enclosing list.
With two prefix arguments as in `C-u C-u', kill all S-expressions
  forward in the current list before splicing all S-expressions
  backward into the enclosing list.
With a numerical prefix argument N, kill N S-expressions backward in
  the current list before splicing the remaining S-expressions into the
  enclosing list.  If N is negative, kill forward.
Inside a string, unescape all backslashes, or signal an error if doing
  so would invalidate the buffer's structure.
(defalias 'paredit-splice-sexp #[(&optional argument) "\304 \203	\305!\207\212\306!\210`\307 \210\212\310u\210\311\312	\"\210`)\313\211\212`\314 \210\315\310!\210`)`	|\210\316\n\313#,\207" [argument end indent-end indent-start paredit-in-string-p paredit-splice-string paredit-kill-surrounding-sexps-for-splice backward-up-list 1 paredit-skip-whitespace t nil forward-sexp backward-delete-char indent-region] 4 (#$ . 57227) "P"])
(defalias 'paredit-kill-surrounding-sexps-for-splice #[(argument) "\305 \204\n\306 \203\307\310!\207\203\311=\203\312\207\247\204%\313=\203D\313=\203/\314\2020\315[!\211b\210\312\316\317\217\210\320	`\"*\207:\203o@\211\321U\203a`\312\322\323\217\210\320`\")\202m`\312\324\325\217\210\320\f`\"))\207\307\326\"\207" [argument saved v end beginning paredit-in-string-p paredit-in-comment-p error "Invalid context for splicing S-expressions." 0 nil - -1 paredit-point-at-sexp-boundary (backward-sexp argument) ((scan-error)) paredit-hack-kill-region 4 (byte-code "o\204\n\300 \210\202\300\207" [backward-sexp] 1) ((scan-error)) (byte-code "m\204\n\300 \210\202\300\207" [forward-sexp] 1) ((scan-error)) "Bizarre prefix argument `%s'."] 4])
#@200 Splice the list the point is on by removing its delimiters, and
  also kill all S-expressions before the point in the current list.
With a prefix argument N, kill only the preceding N S-expressions.
(defalias 'paredit-splice-sexp-killing-backward #[(&optional n) "\301\203\302!\202\f\303!\207" [n paredit-splice-sexp prefix-numeric-value (4)] 3 (#$ . 59145) "P"])
#@199 Splice the list the point is on by removing its delimiters, and
  also kill all S-expressions after the point in the current list.
With a prefix argument N, kill only the following N S-expressions.
(defalias 'paredit-splice-sexp-killing-forward #[(&optional n) "\301\203\f\302![\202
\303!\207" [n paredit-splice-sexp prefix-numeric-value (16)] 3 (#$ . 59521) "P"])
#@328 Raise the following S-expression in a tree, deleting its siblings.
With a prefix argument N, raise the following N S-expressions.  If N
  is negative, raise the preceding N S-expressions.
If the point is on an S-expression, such as a string or a symbol, not
  between them, that S-expression is considered to follow the point.
(defalias 'paredit-raise-sexp #[(&optional argument) "\212\306 \203\307 @b\210\202\"\310 \203\311 \210\202\"\312 \203\"\313\314!\210\315!\316`	\"	\317W\2038\n\320 {\202<\321 \n{\322 \210`\316`\323\"|\210`\212c\210`)\324\f
\325#.\207" [argument n bound sexps indent-start indent-end paredit-in-string-p paredit-string-start+end-points paredit-in-char-p backward-sexp paredit-in-comment-p error "No S-expression to raise in comment." prefix-numeric-value scan-sexps 0 paredit-point-at-sexp-end paredit-point-at-sexp-start backward-up-list 1 indent-region nil] 4 (#$ . 59897) "P"])
#@249 Convolute S-expressions.
Save the S-expressions preceding point and delete them.
Splice the S-expressions following point.
Wrap the enclosing list in a new list prefixed by the saved text.
With a prefix argument N, move up N lists before wrapping.
(defalias 'paredit-convolute-sexp #[(&optional n) "\305\306!\210\212\307!\210\307 \210)\310\211`\310\311\312\217\210`{\307 \210\212\313 \210`Sf\314\315!\210)\310f`|\210l\2049\316 \210)\307!\210\317\315\n	\320$\210\fc\210l\204P\316 \210\212\307 \210\310\321\322\217,\207" [n close open end prefix paredit-lose-if-not-in-sexp paredit-convolute-sexp backward-up-list nil (byte-code "o\204\n\300 \210\202\300\207" [backward-sexp] 1) ((scan-error)) forward-sexp backward-delete-char 1 just-one-space paredit-insert-pair goto-char (indent-sexp) ((scan-error))] 5 (#$ . 60827) "p"])
(defalias 'paredit-splice-string #[(argument) "`\306 @A\f:\204T\n{\202(\f@\307U\203$	\n{\202(T	{\310
!\211\2048\311\312!\202V\212b\210\nT|\210c\210)\f:\205O\f@\307U?\205V	Sb.\207" [start+end original-point end start argument escaped-string paredit-string-start+end-points 4 paredit-unescape-string error "Unspliceable string." unescaped-string] 3])
(defalias 'paredit-unescape-string #[(string) "\302\303!rq\210\304\216	c\210eb\210m\204&\305\306\307\310#\203&\311\312!\210\307u\210\202\307\313\314\217+\207" [#1=#:temp-buffer string generate-new-buffer " *temp*" ((byte-code "\301!\203\n\302!\210\301\207" [#1# buffer-name kill-buffer] 2)) search-forward "\\" nil t delete-char -1 (byte-code "\300ed\"\210\301 \207" [scan-sexps buffer-string] 3) ((scan-error))] 4])
#@373 Add the S-expression following the current list into that list
  by moving the closing delimiter.
Automatically reindent the newly slurped S-expression with respect to
  its new enclosing form.
If in a string, move the opening double-quote forward by one
  S-expression and escape any intervening characters as necessary,
  without altering any indentation or formatting.
(defalias 'paredit-forward-slurp-sexp #[nil "\212\300 \204\301 \203\302\303!\202\304 \203\305 \202\306 )\207" [paredit-in-comment-p paredit-in-char-p error "Invalid context for slurping S-expressions." paredit-in-string-p paredit-forward-slurp-into-string paredit-forward-slurp-into-list] 2 (#$ . 62473) nil])
(defalias 'paredit-forward-slurp-into-list #[nil "\302 \210`Sf\303\304!\210`\305\306\215\210c\210\307	`\310#*\207" [close start up-list backward-delete-char 1 return (byte-code "\300\301\302\217\210\202" [nil (byte-code "\300 \210\301\302\303\"\207" [forward-sexp throw return nil] 3) ((scan-error (byte-code "\301 \210`Sf\302\303!\210c\210\301\207" [close up-list backward-delete-char 1] 3)))] 3) indent-region nil] 4])
(defalias 'paredit-forward-slurp-into-string #[nil "\301 ATb\210\212\302 \210)`Sf\303\304!\210\305\212\302 \210`)!\210c)\207" [close paredit-string-start+end-points forward-sexp backward-delete-char 1 paredit-forward-for-quote] 2])
#@195 Remove the last S-expression in the current list from that list
  by moving the closing delimiter.
Automatically reindent the newly barfed S-expression with respect to
  its new enclosing form.
(defalias 'paredit-forward-barf-sexp #[nil "\301\302!\210\212\303 \210`Sf\304\305!\210\306\307\310\217\210\311\306!\210o\203$\312\313!\210\202,\314 \203,\315 \210c\210)\316 )\207" [close paredit-lose-if-not-in-sexp paredit-forward-barf-sexp up-list backward-delete-char 1 nil (backward-sexp) ((scan-error)) paredit-skip-whitespace error "Barfing all subexpressions with no open-paren?" paredit-in-comment-p newline paredit-forward-and-indent] 3 (#$ . 63834) nil])
#@359 Add the S-expression preceding the current list into that list
  by moving the closing delimiter.
Automatically reindent the whole form into which new S-expression was
  slurped.
If in a string, move the opening double-quote backward by one
  S-expression and escape any intervening characters as necessary,
  without altering any indentation or formatting.
(defalias 'paredit-backward-slurp-sexp #[nil "\212\300 \204\301 \203\302\303!\202\304 \203\305 \202\306 )\207" [paredit-in-comment-p paredit-in-char-p error "Invalid context for slurping S-expressions." paredit-in-string-p paredit-backward-slurp-into-string paredit-backward-slurp-into-list] 2 (#$ . 64504) nil])
(defalias 'paredit-backward-slurp-into-list #[nil "\301 \210\302f\303\304!\210\305\306\215\210c\210)\301 \210\307 \210\310 \207" [open backward-up-list nil delete-char 1 return (byte-code "\300\301\302\217\210\202" [nil (byte-code "\300 \210\301\302\303\"\207" [backward-sexp throw return nil] 3) ((scan-error (byte-code "\301 \210\302f\212c\210\303\304!\210)\302\207" [open backward-up-list nil delete-char 1] 3)))] 3) lisp-indent-line indent-sexp] 2])
(defalias 'paredit-backward-slurp-into-string #[nil "\302 @b\210\212\303 \210)\304f`\305\306!\210\303 \210	c\210\307!*\207" [target open paredit-string-start+end-points backward-sexp nil delete-char 1 paredit-forward-for-quote] 2])
#@189 Remove the first S-expression in the current list from that list
  by moving the closing delimiter.
Automatically reindent the barfed S-expression and the form from which
  it was barfed.
(defalias 'paredit-backward-barf-sexp #[nil "\301\302!\210\212\303 \210\304f\305\306!\210\304\307\310\217\210\311\312!\210\304f\313=\203%\306y\210\202m\203-\314\315!\210\316!\210)\303 \210\317 \210\320 )\207" [open paredit-lose-if-not-in-sexp paredit-backward-barf-sexp backward-up-list nil delete-char 1 (paredit-forward-and-indent) ((scan-error)) paredit-skip-whitespace t 59 error "Barfing all subexpressions with no close-paren?" insert-before-markers lisp-indent-line indent-sexp] 3 (#$ . 65887) nil])
#@52 Split the list or string the point is on into two.
(defalias 'paredit-split-sexp #[nil "\302 \203
\303c\210\212\304c)\207\305 \204\306 \203\307\310!\207\212\311 \210\312f)\212\313 \210`Sf)\314 \210c\210\212\315c\210	c\210\316u\210\317 +\207" [close open paredit-in-string-p "\"" " \"" paredit-in-comment-p paredit-in-char-p error "Invalid context for splitting S-expression." backward-up-list nil up-list delete-horizontal-space 32 -1 indent-sexp] 2 (#$ . 66594) nil])
#@131 Join the S-expressions adjacent on either side of the point.
Both must be lists, strings, or atoms; error if there is a mismatch.
(defalias 'paredit-join-sexps #[nil "\212\306 \204\307 \204\310 \203\311\312!\202\254\313 \314 \211Sff\211z\nz	W\2035\311\315!\202\252
\316=\203\201\f\317=\203\201\320\n!=\203\201\n\320!=\203\201b\210\321\322!\210	b\210\323\322!\210	U\203y`Sfz\324=\204y\325fz\324=\204y\324c\210\326 \210\327 \202\252
\330=\203\225\f\330=\203\225	ST|\202\252
\331>\203\247\f\332>\203\247	|\202\252\311\333!.)\207" [right-point left-point right-char left-char right-syntax left-syntax paredit-in-comment-p paredit-in-string-p paredit-in-char-p error "Invalid context for joining S-expressions." paredit-point-at-sexp-end paredit-point-at-sexp-start "Can't join a datum with itself." 41 40 matching-paren delete-char 1 backward-delete-char 32 nil backward-up-list indent-sexp 34 (119 95) (119 95) "Mismatched S-expressions to join."] 4 (#$ . 67078) nil])
#@67 Add the S-expression following point to the list preceding point.
(defalias 'paredit-add-to-previous-list #[nil "\300\301!\210\212\302 \210\303 )\207" [paredit-lose-if-not-in-sexp paredit-add-to-previous-list backward-down-list paredit-forward-slurp-sexp] 2 (#$ . 68088) nil])
#@135 Add the S-expression preceding point to the list following point.
If no S-expression precedes point, move up the tree until one does.
(defalias 'paredit-add-to-next-list #[nil "\300\301!\210\212\302 \210\303 )\207" [paredit-lose-if-not-in-sexp paredit-add-to-next-list down-list paredit-backward-slurp-sexp] 2 (#$ . 68372) nil])
#@69 Join the list the point is on with the previous list in the buffer.
(defalias 'paredit-join-with-previous-list #[nil "\300\301!\210\212\302\303\304\217\204\305 )\207" [paredit-lose-if-not-in-sexp paredit-join-with-previous-list nil (byte-code "\212\300 \210)\301\207" [backward-sexp nil] 1) ((scan-error (backward-up-list) t)) paredit-join-sexps] 3 (#$ . 68707) nil])
#@65 Join the list the point is on with the next list in the buffer.
(defalias 'paredit-join-with-next-list #[nil "\300\301!\210\212\302\303\304\217\204\305 )\207" [paredit-lose-if-not-in-sexp paredit-join-with-next-list nil (byte-code "\212\300 \210)\301\207" [forward-sexp nil] 1) ((scan-error (up-list) t)) paredit-join-sexps] 3 (#$ . 69083) nil])
#@206 True if the point is on a character escape of a string.
This is true only if the character is preceded by an odd number of
  backslashes.
This assumes that `paredit-in-string-p' has already returned true.
(defalias 'paredit-in-string-escape-p #[nil "\301\212`Sf\302=\203?\303u\210\202))\207" [oddp nil 92 -1] 2 (#$ . 69438)])
#@58 True if point is on a character escape outside a string.
(defalias 'paredit-in-char-p #[(&optional position) "\212\206`b\210\301 )\207" [position paredit-in-string-escape-p] 1 (#$ . 69778)])
#@63 If in a list, indent all following S-expressions in the list.
(defalias 'paredit-indent-sexps #[nil "`\302\303\304\217\211\205\305	\302#*\207" [start end nil (byte-code "\300 \210`\207" [up-list] 1) ((scan-error)) indent-region] 5 (#$ . 69978)])
#@66 Move forward an S-expression, indenting it with `indent-region'.
(defalias 'paredit-forward-and-indent #[nil "`\301 \210\302`\303#)\207" [start forward-sexp indent-region nil] 4 (#$ . 70235)])
#@150 Skip past any whitespace, or until the point LIMIT is reached.
If TRAILING-P is nil, skip leading whitespace; otherwise, skip trailing
  whitespace.
(defalias 'paredit-skip-whitespace #[(trailing-p &optional limit) "\203\302\202	\303\304	\"\207" [trailing-p limit skip-chars-forward skip-chars-backward " 	\n\f"] 3 (#$ . 70437)])
(byte-code "\300\301\302 \203\303\202\304 \203\305\202\306\307!\"\207" [defalias paredit-region-active-p paredit-xemacs-p region-active-p paredit-gnu-emacs-p #[nil "\205	\207" [mark-active transient-mark-mode] 1] error "XCOND lost."] 4)
#@125 Kill the region between START and END.
Do not append to any current kill, and
 do not let the next kill append to this one.
(defalias 'paredit-hack-kill-region #[(start end) "\304\211\305\n\"*\207" [last-command this-command start end nil kill-region] 3 (#$ . 71026) "r"])
#@54 Return parse state of point from beginning of defun.
(defalias 'paredit-current-parse-state #[nil "`\301 \210\302`\")\207" [point beginning-of-defun parse-partial-sexp] 3 (#$ . 71308)])
#@159 True if the parse state is within a double-quote-delimited string.
If no parse state is supplied, compute one from the beginning of the
  defun to the point.
(defalias 'paredit-in-string-p #[(&optional state) "\301\206\302 8\205\f\303\207" [state 3 paredit-current-parse-state t] 2 (#$ . 71503)])
#@306 Return a cons of the points of open and close quotes of the string.
The string is determined from the parse state STATE, or the parse state
  from the beginning of the defun to the point.
This assumes that `paredit-in-string-p' has already returned true, i.e.
  that the point is already within a string.
(defalias 'paredit-string-start+end-points #[(&optional state) "\212\302\206\303 8\211b\210\304\305!\210	`S*B\207" [state start 8 paredit-current-parse-state forward-sexp 1] 3 (#$ . 71811)])
#@139 True if parse state STATE is within a comment.
If no parse state is supplied, compute one from the beginning of the
  defun to the point.
(defalias 'paredit-in-comment-p #[(&optional state) "\301\206\302 8\205\f\303\207" [state 4 paredit-current-parse-state t] 2 (#$ . 72318)])
(defalias 'paredit-point-at-sexp-boundary #[(n) "\301W\203	\302 \207\301U\203`\207\301V\205\303 \207" [n 0 paredit-point-at-sexp-start paredit-point-at-sexp-end] 2])
(defalias 'paredit-point-at-sexp-start #[nil "\212\300 \210\301 \210`)\207" [forward-sexp backward-sexp] 1])
(defalias 'paredit-point-at-sexp-end #[nil "\212\300 \210\301 \210`)\207" [backward-sexp forward-sexp] 1])
(defalias 'paredit-lose-if-not-in-sexp #[(command) "\301 \204\302 \204\303 \205\304\305\"\207" [command paredit-in-string-p paredit-in-comment-p paredit-in-char-p error "Invalid context for command `%s'."] 3])
#@66 Signal an error if text between `start' and `end' is unbalanced.
(defalias 'paredit-check-region #[(start end) "\302	\"?\205\214	}\210\303 )\207" [start end paredit-region-ok-p check-parens] 3 (#$ . 73213)])
#@158 Return true iff the region between `start' and `end' is balanced.
This is independent of context -- it doesn't check what state the
  text at `start' is in.
(defalias 'paredit-region-ok-p #[(start end) "\212\300\301\302\217)\207" [nil (byte-code "\214	}\210\302ed\"\210)\303\207" [start end scan-sexps t] 3) ((scan-error))] 3 (#$ . 73432)])
(defalias 'paredit-current-indentation #[nil "\212\300 \210i)\207" [back-to-indentation] 1])
(byte-code "\300 \210\301 \210\302 \210\303\304!\207" [paredit-define-keys paredit-annotate-mode-with-examples paredit-annotate-functions-with-examples provide paredit] 2)