lisp/calc/calc-yank.el

   1 ;;; calc-yank.el --- kill-ring functionality for Calc
   2
   3 ;; Copyright (C) 1990, 1991, 1992, 1993, 2001, 2002, 2003, 2004,
   4 ;;   2005, 2006, 2007, 2008 Free Software Foundation, Inc.
   5
   6 ;; Author: David Gillespie <daveg@synaptics.com>
   7 ;; Maintainer: Jay Belanger <jay.p.belanger@gmail.com>
   8
   9 ;; This file is part of GNU Emacs.
  10
  11 ;; GNU Emacs is free software: you can redistribute it and/or modify
  12 ;; it under the terms of the GNU General Public License as published by
  13 ;; the Free Software Foundation, either version 3 of the License, or
  14 ;; (at your option) any later version.
  15
  16 ;; GNU Emacs is distributed in the hope that it will be useful,
  17 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19 ;; GNU General Public License for more details.
  20
  21 ;; You should have received a copy of the GNU General Public License
  22 ;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
  23
  24 ;;; Commentary:
  25
  26 ;;; Code:
  27
  28 ;; This file is autoloaded from calc-ext.el.
  29
  30 (require 'calc-ext)
  31 (require 'calc-macs)
  32
  33 ;;; Kill ring commands.
  34
  35 (defun calc-kill (nn &optional no-delete)
  36   (interactive "P")
  37   (if (eq major-mode 'calc-mode)
  38       (calc-wrapper
  39        (calc-force-refresh)
  40        (calc-set-command-flag 'no-align)
  41        (let ((num (max (calc-locate-cursor-element (point)) 1))
  42              (n (prefix-numeric-value nn)))
  43          (if (< n 0)
  44              (progn
  45                (if (eobp)
  46                    (setq num (1- num)))
  47                (setq num (- num n)
  48                      n (- n))))
  49          (calc-check-stack num)
  50          (let ((stuff (calc-top-list n (- num n -1))))
  51            (calc-cursor-stack-index num)
  52            (let ((first (point)))
  53              (calc-cursor-stack-index (- num n))
  54              (if (null nn)
  55                  (backward-char 1))   ; don't include newline for raw C-k
  56              (copy-region-as-kill first (point))
  57              (if (not no-delete)
  58                  (calc-pop-stack n (- num n -1))))
  59            (setq calc-last-kill (cons (car kill-ring) stuff)))))
  60     (kill-line nn)))
  61
  62 (defun calc-force-refresh ()
  63   (if (or calc-executing-macro calc-display-dirty)
  64       (let ((calc-executing-macro nil))
  65         (calc-refresh))))
  66
  67 (defun calc-locate-cursor-element (pt)
  68   (save-excursion
  69     (goto-char (point-max))
  70     (calc-locate-cursor-scan (- calc-stack-top) calc-stack pt)))
  71
  72 (defun calc-locate-cursor-scan (n stack pt)
  73   (if (or (<= (point) pt)
  74           (null stack))
  75       n
  76     (forward-line (- (nth 1 (car stack))))
  77     (calc-locate-cursor-scan (1+ n) (cdr stack) pt)))
  78
  79 (defun calc-kill-region (top bot &optional no-delete)
  80   (interactive "r")
  81   (if (eq major-mode 'calc-mode)
  82       (calc-wrapper
  83        (calc-force-refresh)
  84        (calc-set-command-flag 'no-align)
  85        (let* ((top-num (calc-locate-cursor-element top))
  86               (top-pos (save-excursion
  87                          (calc-cursor-stack-index top-num)
  88                          (point)))
  89               (bot-num (calc-locate-cursor-element (1- bot)))
  90               (bot-pos (save-excursion
  91                          (calc-cursor-stack-index (max 0 (1- bot-num)))
  92                          (point)))
  93               (num (- top-num bot-num -1)))
  94          (copy-region-as-kill top-pos bot-pos)
  95          (setq calc-last-kill (cons (car kill-ring)
  96                                     (calc-top-list num bot-num)))
  97          (if (not no-delete)
  98              (calc-pop-stack num bot-num))))
  99     (if no-delete
 100         (copy-region-as-kill top bot)
 101       (kill-region top bot))))
 102
 103 (defun calc-copy-as-kill (n)
 104   (interactive "P")
 105   (calc-kill n t))
 106
 107 (defun calc-copy-region-as-kill (top bot)
 108   (interactive "r")
 109   (calc-kill-region top bot t))
 110
 111 ;; This function uses calc-last-kill if possible to get an exact result,
 112 ;; otherwise it just parses the yanked string.
 113 ;; Modified to use Emacs 19 extended concept of kill-ring. -- daveg 12/15/96
 114 ;;;###autoload
 115 (defun calc-yank ()
 116   (interactive)
 117   (calc-wrapper
 118    (calc-pop-push-record-list
 119     0 "yank"
 120     (let ((thing (if (fboundp 'current-kill)
 121                      (current-kill 0 t)
 122                    (car kill-ring-yank-pointer))))
 123       (if (eq (car-safe calc-last-kill) thing)
 124           (cdr calc-last-kill)
 125         (if (stringp thing)
 126             (let ((val (math-read-exprs (calc-clean-newlines thing))))
 127               (if (eq (car-safe val) 'error)
 128                   (progn
 129                     (setq val (math-read-exprs thing))
 130                     (if (eq (car-safe val) 'error)
 131                         (error "Bad format in yanked data")
 132                       val))
 133                 val))))))))
 134
 135 ;;; The Calc set- and get-register commands are modified versions of functions
 136 ;;; in register.el
 137
 138 (defvar calc-register-alist nil
 139   "Alist of elements (NAME . (TEXT . CALCVAL)).
 140 NAME is a character (a number).
 141 TEXT and CALCVAL are the TEXT and internal structure of stack entries.")
 142
 143 (defun calc-set-register (register text calcval)
 144   "Set the contents of the Calc register REGISTER to (TEXT . CALCVAL),
 145 as well as set the contents of the Emacs register REGISTER to TEXT."
 146   (set-register register text)
 147   (let ((aelt (assq register calc-register-alist)))
 148     (if aelt
 149         (setcdr aelt (cons text calcval))
 150       (push (cons register (cons text calcval)) calc-register-alist))))
 151
 152 (defun calc-get-register (reg)
 153   "Return the CALCVAL portion of the contents of the Calc register REG,
 154 unless the TEXT portion doesn't match the contents of the Emacs register REG,
 155 in which case either return the contents of the Emacs register (if it is
 156 text) or `nil'."
 157   (let ((cval (cdr (assq reg calc-register-alist)))
 158         (val (cdr (assq reg register-alist))))
 159     (if (stringp val)
 160         (if (and (stringp (car cval))
 161                  (string= (car cval) val))
 162             (cdr cval)
 163           val))))
 164
 165 (defun calc-copy-to-register (register start end &optional delete-flag)
 166   "Copy the lines in the region into register REGISTER.
 167 With prefix arg, delete as well."
 168   (interactive "cCopy to register: \nr\nP")
 169   (if (eq major-mode 'calc-mode)
 170       (let* ((top-num (calc-locate-cursor-element start))
 171              (top-pos (save-excursion
 172                         (calc-cursor-stack-index top-num)
 173                         (point)))
 174              (bot-num (calc-locate-cursor-element (1- end)))
 175              (bot-pos (save-excursion
 176                         (calc-cursor-stack-index (max 0 (1- bot-num)))
 177                         (point)))
 178              (num (- top-num bot-num -1))
 179              (str (buffer-substring top-pos bot-pos)))
 180         (calc-set-register register str (calc-top-list num bot-num))
 181         (if delete-flag
 182             (calc-wrapper
 183              (calc-pop-stack num bot-num))))
 184     (copy-to-register register start end delete-flag)))
 185
 186 (defun calc-insert-register (register)
 187   "Insert the contents of register REGISTER."
 188   (interactive "cInsert register: ")
 189   (if (eq major-mode 'calc-mode)
 190       (let ((val (calc-get-register register)))
 191         (calc-wrapper
 192          (calc-pop-push-record-list
 193           0 "insr"
 194           (if (not val)
 195               (error "Bad format in register data")
 196             (if (consp val)
 197                 val
 198               (let ((nval (math-read-exprs (calc-clean-newlines val))))
 199                 (if (eq (car-safe nval) 'error)
 200                     (progn
 201                       (setq nval (math-read-exprs val))
 202                       (if (eq (car-safe nval) 'error)
 203                           (error "Bad format in register data")
 204                         nval))
 205                   nval)))))))
 206     (insert-register register)))
 207
 208 (defun calc-add-to-register (register start end prepend delete-flag)
 209   "Add the lines in the region to register REGISTER.
 210 If PREPEND is non-nil, add them to the beginning of the register,
 211 otherwise the end.  If DELETE-FLAG is non-nil, also delete the region."
 212   (let* ((top-num (calc-locate-cursor-element start))
 213          (top-pos (save-excursion
 214                     (calc-cursor-stack-index top-num)
 215                     (point)))
 216          (bot-num (calc-locate-cursor-element (1- end)))
 217          (bot-pos (save-excursion
 218                     (calc-cursor-stack-index (max 0 (1- bot-num)))
 219                     (point)))
 220          (num (- top-num bot-num -1))
 221          (str (buffer-substring top-pos bot-pos))
 222          (calcval (calc-top-list num bot-num))
 223          (cval (cdr (assq register calc-register-alist))))
 224     (if (not cval)
 225         (calc-set-register register str calcval)
 226       (if prepend
 227           (calc-set-register
 228            register
 229            (concat str (car cval))
 230            (append calcval (cdr cval)))
 231         (calc-set-register
 232          register
 233          (concat (car cval) str)
 234          (append (cdr cval) calcval))))
 235     (if delete-flag
 236         (calc-wrapper
 237          (calc-pop-stack num bot-num)))))
 238
 239 (defun calc-append-to-register (register start end &optional delete-flag)
 240   "Copy the lines in the region to the end of register REGISTER.
 241 With prefix arg, also delete the region."
 242   (interactive "cAppend to register: \nr\nP")
 243   (if (eq major-mode 'calc-mode)
 244       (calc-add-to-register register start end nil delete-flag)
 245     (append-to-register register start end delete-flag)))
 246
 247 (defun calc-prepend-to-register (register start end &optional delete-flag)
 248   "Copy the lines in the region to the beginning of register REGISTER.
 249 With prefix arg, also delete the region."
 250   (interactive "cPrepend to register: \nr\nP")
 251   (if (eq major-mode 'calc-mode)
 252       (calc-add-to-register register start end t delete-flag)
 253     (prepend-to-register register start end delete-flag)))
 254
 255
 256
 257 (defun calc-clean-newlines (s)
 258   (cond
 259
 260    ;; Omit leading/trailing whitespace
 261    ((or (string-match "\\`[ \n\r]+\\([^\001]*\\)\\'" s)
 262         (string-match "\\`\\([^\001]*\\)[ \n\r]+\\'" s))
 263     (calc-clean-newlines (math-match-substring s 1)))
 264
 265    ;; Convert newlines to commas
 266    ((string-match "\\`\\(.*\\)[\n\r]+\\([^\001]*\\)\\'" s)
 267     (calc-clean-newlines (concat (math-match-substring s 1) ","
 268                                  (math-match-substring s 2))))
 269
 270    (t s)))
 271
 272
 273 (defun calc-do-grab-region (top bot arg)
 274   (when (memq major-mode '(calc-mode calc-trail-mode))
 275     (error "This command works only in a regular text buffer"))
 276   (let* ((from-buffer (current-buffer))
 277          (calc-was-started (get-buffer-window "*Calculator*"))
 278          (single nil)
 279          data vals pos)
 280     (if arg
 281         (if (consp arg)
 282             (setq single t)
 283           (setq arg (prefix-numeric-value arg))
 284           (if (= arg 0)
 285               (save-excursion
 286                 (beginning-of-line)
 287                 (setq top (point))
 288                 (end-of-line)
 289                 (setq bot (point)))
 290             (save-excursion
 291               (setq top (point))
 292               (forward-line arg)
 293               (if (> arg 0)
 294                   (setq bot (point))
 295                 (setq bot top
 296                       top (point)))))))
 297     (setq data (buffer-substring top bot))
 298     (calc)
 299     (if single
 300         (setq vals (math-read-expr data))
 301       (setq vals (math-read-expr (concat "[" data "]")))
 302       (and (eq (car-safe vals) 'vec)
 303            (= (length vals) 2)
 304            (eq (car-safe (nth 1 vals)) 'vec)
 305            (setq vals (nth 1 vals))))
 306     (if (eq (car-safe vals) 'error)
 307         (progn
 308           (if calc-was-started
 309               (pop-to-buffer from-buffer)
 310             (calc-quit t)
 311             (switch-to-buffer from-buffer))
 312           (goto-char top)
 313           (forward-char (+ (nth 1 vals) (if single 0 1)))
 314           (error (nth 2 vals))))
 315     (calc-slow-wrapper
 316      (calc-enter-result 0 "grab" vals))))
 317
 318
 319 (defun calc-do-grab-rectangle (top bot arg &optional reduce)
 320   (and (memq major-mode '(calc-mode calc-trail-mode))
 321        (error "This command works only in a regular text buffer"))
 322   (let* ((col1 (save-excursion (goto-char top) (current-column)))
 323          (col2 (save-excursion (goto-char bot) (current-column)))
 324          (from-buffer (current-buffer))
 325          (calc-was-started (get-buffer-window "*Calculator*"))
 326          data mat vals lnum pt pos)
 327     (if (= col1 col2)
 328         (save-excursion
 329           (unless (= col1 0)
 330             (error "Point and mark must be at beginning of line, or define a rectangle"))
 331           (goto-char top)
 332           (while (< (point) bot)
 333             (setq pt (point))
 334             (forward-line 1)
 335             (setq data (cons (buffer-substring pt (1- (point))) data)))
 336           (setq data (nreverse data)))
 337       (setq data (extract-rectangle top bot)))
 338     (calc)
 339     (setq mat (list 'vec)
 340           lnum 0)
 341     (when arg
 342       (setq arg (if (consp arg) 0 (prefix-numeric-value arg))))
 343     (while data
 344       (if (natnump arg)
 345           (progn
 346             (if (= arg 0)
 347                 (setq arg 1000000))
 348             (setq pos 0
 349                   vals (list 'vec))
 350             (let ((w (length (car data)))
 351                   j v)
 352               (while (< pos w)
 353                 (setq j (+ pos arg)
 354                       v (if (>= j w)
 355                             (math-read-expr (substring (car data) pos))
 356                           (math-read-expr (substring (car data) pos j))))
 357                 (if (eq (car-safe v) 'error)
 358                     (setq vals v w 0)
 359                   (setq vals (nconc vals (list v))
 360                         pos j)))))
 361         (if (string-match "\\` *-?[0-9][0-9]?[0-9]?[0-9]?[0-9]?[0-9]? *\\'"
 362                           (car data))
 363             (setq vals (list 'vec (string-to-number (car data))))
 364           (if (and (null arg)
 365                    (string-match "[[{][^][{}]*[]}]" (car data)))
 366               (setq pos (match-beginning 0)
 367                     vals (math-read-expr (math-match-substring (car data) 0)))
 368             (let ((s (if (string-match
 369                           "\\`\\([0-9]+:[ \t]\\)?\\(.*[^, \t]\\)[, \t]*\\'"
 370                           (car data))
 371                          (math-match-substring (car data) 2)
 372                        (car data))))
 373               (setq pos -1
 374                     vals (math-read-expr (concat "[" s "]")))
 375               (if (eq (car-safe vals) 'error)
 376                   (let ((v2 (math-read-expr s)))
 377                     (unless (eq (car-safe v2) 'error)
 378                       (setq vals (list 'vec v2)))))))))
 379       (if (eq (car-safe vals) 'error)
 380           (progn
 381             (if calc-was-started
 382                 (pop-to-buffer from-buffer)
 383               (calc-quit t)
 384               (switch-to-buffer from-buffer))
 385             (goto-char top)
 386             (forward-line lnum)
 387             (forward-char (+ (nth 1 vals) (min col1 col2) pos))
 388             (error (nth 2 vals))))
 389       (unless (equal vals '(vec))
 390         (setq mat (cons vals mat)))
 391       (setq data (cdr data)
 392             lnum (1+ lnum)))
 393     (calc-slow-wrapper
 394      (if reduce
 395          (calc-enter-result 0 "grb+" (list reduce '(var add var-add)
 396                                            (nreverse mat)))
 397        (calc-enter-result 0 "grab" (nreverse mat))))))
 398
 399
 400 (defun calc-copy-to-buffer (nn)
 401   "Copy the top of stack into an editing buffer."
 402   (interactive "P")
 403   (let ((thebuf (and (not (memq major-mode '(calc-mode calc-trail-mode)))
 404                      (current-buffer)))
 405         (movept nil)
 406         oldbuf newbuf)
 407     (calc-wrapper
 408      (save-excursion
 409        (calc-force-refresh)
 410        (let ((n (prefix-numeric-value nn))
 411              (eat-lnums calc-line-numbering)
 412              (big-offset (if (eq calc-language 'big) 1 0))
 413              top bot)
 414          (setq oldbuf (current-buffer)
 415                newbuf (or thebuf
 416                           (calc-find-writable-buffer (buffer-list) 0)
 417                           (calc-find-writable-buffer (buffer-list) 1)
 418                           (error "No other buffer")))
 419          (cond ((and (or (null nn)
 420                          (consp nn))
 421                      (= (calc-substack-height 0)
 422                         (- (1- (calc-substack-height 1)) big-offset)))
 423                 (calc-cursor-stack-index 1)
 424                 (if (looking-at
 425                      (if calc-line-numbering "[0-9]+: *[^ \n]" " *[^ \n]"))
 426                     (goto-char (1- (match-end 0))))
 427                 (setq eat-lnums nil
 428                       top (point))
 429                 (calc-cursor-stack-index 0)
 430                 (setq bot (- (1- (point)) big-offset)))
 431                ((> n 0)
 432                 (calc-cursor-stack-index n)
 433                 (setq top (point))
 434                 (calc-cursor-stack-index 0)
 435                 (setq bot (- (point) big-offset)))
 436                ((< n 0)
 437                 (calc-cursor-stack-index (- n))
 438                 (setq top (point))
 439                 (calc-cursor-stack-index (1- (- n)))
 440                 (setq bot (point)))
 441                (t
 442                 (goto-char (point-min))
 443                 (forward-line 1)
 444                 (setq top (point))
 445                 (calc-cursor-stack-index 0)
 446                 (setq bot (point))))
 447          (save-excursion
 448            (set-buffer newbuf)
 449            (if (consp nn)
 450                (kill-region (region-beginning) (region-end)))
 451            (push-mark (point) t)
 452            (if (and overwrite-mode (not (consp nn)))
 453                (calc-overwrite-string (save-excursion
 454                                         (set-buffer oldbuf)
 455                                         (buffer-substring top bot))
 456                                       eat-lnums)
 457              (or (bolp) (setq eat-lnums nil))
 458              (insert-buffer-substring oldbuf top bot)
 459              (and eat-lnums
 460                   (let ((n 1))
 461                     (while (and (> (point) (mark))
 462                                 (progn
 463                                   (forward-line -1)
 464                                   (>= (point) (mark))))
 465                       (delete-char 4)
 466                       (setq n (1+ n)))
 467                     (forward-line n))))
 468            (when thebuf
 469              (setq movept (point)))
 470            (when (get-buffer-window (current-buffer))
 471              (set-window-point (get-buffer-window (current-buffer))
 472                                (point)))))))
 473     (when movept
 474       (goto-char movept))
 475     (when (and (consp nn)
 476                (not thebuf))
 477       (calc-quit t)
 478       (switch-to-buffer newbuf))))
 479
 480 (defun calc-overwrite-string (str eat-lnums)
 481   (when (string-match "\n\\'" str)
 482     (setq str (substring str 0 -1)))
 483   (when eat-lnums
 484     (setq str (substring str 4)))
 485   (if (and (string-match "\\`[-+]?[0-9.]+\\(e-?[0-9]+\\)?\\'" str)
 486            (looking-at "[-+]?[0-9.]+\\(e-?[0-9]+\\)?"))
 487       (progn
 488         (delete-region (point) (match-end 0))
 489         (insert str))
 490     (let ((i 0))
 491       (while (< i (length str))
 492         (if (= (setq last-command-char (aref str i)) ?\n)
 493             (or (= i (1- (length str)))
 494                 (let ((pt (point)))
 495                   (end-of-line)
 496                   (delete-region pt (point))
 497                   (if (eobp)
 498                       (insert "\n")
 499                     (forward-char 1))
 500                   (if eat-lnums (setq i (+ i 4)))))
 501           (self-insert-command 1))
 502         (setq i (1+ i))))))
 503
 504 ;; First, require that buffer is visible and does not begin with "*"
 505 ;; Second, require only that it not begin with "*Calc"
 506 (defun calc-find-writable-buffer (buf mode)
 507   (and buf
 508        (if (or (string-match "\\`\\( .*\\|\\*Calc.*\\)"
 509                              (buffer-name (car buf)))
 510                (and (= mode 0)
 511                     (or (string-match "\\`\\*.*" (buffer-name (car buf)))
 512                         (not (get-buffer-window (car buf))))))
 513            (calc-find-writable-buffer (cdr buf) mode)
 514          (car buf))))
 515
 516
 517 (defun calc-edit (n)
 518   (interactive "p")
 519   (calc-slow-wrapper
 520    (when (eq n 0)
 521      (setq n (calc-stack-size)))
 522    (let* ((flag nil)
 523           (allow-ret (> n 1))
 524           (list (math-showing-full-precision
 525                  (mapcar (if (> n 1)
 526                              (function (lambda (x)
 527                                          (math-format-flat-expr x 0)))
 528                            (function
 529                             (lambda (x)
 530                               (if (math-vectorp x) (setq allow-ret t))
 531                               (math-format-nice-expr x (frame-width)))))
 532                          (if (> n 0)
 533                              (calc-top-list n)
 534                            (calc-top-list 1 (- n)))))))
 535      (calc-edit-mode (list 'calc-finish-stack-edit (or flag n)) allow-ret)
 536      (while list
 537        (insert (car list) "\n")
 538        (setq list (cdr list)))))
 539   (calc-show-edit-buffer))
 540
 541 (defun calc-alg-edit (str)
 542   (calc-edit-mode '(calc-finish-stack-edit 0))
 543   (calc-show-edit-buffer)
 544   (insert str "\n")
 545   (backward-char 1)
 546   (calc-set-command-flag 'do-edit))
 547
 548 (defvar calc-edit-mode-map
 549   (let ((map (make-sparse-keymap)))
 550     (define-key map "\n" 'calc-edit-finish)
 551     (define-key map "\r" 'calc-edit-return)
 552     (define-key map "\C-c\C-c" 'calc-edit-finish)
 553     map)
 554   "Keymap for use by the calc-edit command.")
 555
 556 (defvar calc-original-buffer)
 557 (defvar calc-return-buffer)
 558 (defvar calc-one-window)
 559 (defvar calc-edit-handler)
 560 (defvar calc-restore-trail)
 561 (defvar calc-allow-ret)
 562 (defvar calc-edit-top)
 563
 564 (defun calc-edit-mode (&optional handler allow-ret title)
 565   "Calculator editing mode.  Press RET, LFD, or C-c C-c to finish.
 566 To cancel the edit, simply kill the *Calc Edit* buffer."
 567   (interactive)
 568   (unless handler
 569     (error "This command can be used only indirectly through calc-edit"))
 570   (let ((oldbuf (current-buffer))
 571         (buf (get-buffer-create "*Calc Edit*")))
 572     (set-buffer buf)
 573     (kill-all-local-variables)
 574     (use-local-map calc-edit-mode-map)
 575     (setq buffer-read-only nil)
 576     (setq truncate-lines nil)
 577     (setq major-mode 'calc-edit-mode)
 578     (setq mode-name "Calc Edit")
 579     (run-mode-hooks 'calc-edit-mode-hook)
 580     (make-local-variable 'calc-original-buffer)
 581     (setq calc-original-buffer oldbuf)
 582     (make-local-variable 'calc-return-buffer)
 583     (setq calc-return-buffer oldbuf)
 584     (make-local-variable 'calc-one-window)
 585     (setq calc-one-window (and (one-window-p t) pop-up-windows))
 586     (make-local-variable 'calc-edit-handler)
 587     (setq calc-edit-handler handler)
 588     (make-local-variable 'calc-restore-trail)
 589     (setq calc-restore-trail (get-buffer-window (calc-trail-buffer)))
 590     (make-local-variable 'calc-allow-ret)
 591     (setq calc-allow-ret allow-ret)
 592     (let ((inhibit-read-only t))
 593       (erase-buffer))
 594     (add-hook 'kill-buffer-hook (lambda ()
 595                                   (let ((calc-edit-handler nil))
 596                                     (calc-edit-finish t))
 597                                   (message "(Cancelled)")) t t)
 598     (insert (propertize
 599              (concat
 600               (or title title "Calc Edit Mode. ")
 601               "Press `C-c C-c'"
 602               (if allow-ret "" " or RET")
 603               " to finish, `C-x k RET' to cancel.\n\n")
 604              'font-lock-face 'italic 'read-only t 'rear-nonsticky t 'front-sticky t))
 605     (make-local-variable 'calc-edit-top)
 606     (setq calc-edit-top (point))))
 607 (put 'calc-edit-mode 'mode-class 'special)
 608
 609 (defun calc-show-edit-buffer ()
 610   (let ((buf (current-buffer)))
 611     (if (and (one-window-p t) pop-up-windows)
 612         (pop-to-buffer (get-buffer-create "*Calc Edit*"))
 613       (and calc-embedded-info (get-buffer-window (aref calc-embedded-info 1))
 614            (select-window (get-buffer-window (aref calc-embedded-info 1))))
 615       (switch-to-buffer (get-buffer-create "*Calc Edit*")))
 616     (setq calc-return-buffer buf)
 617     (if (and (< (window-width) (frame-width))
 618              calc-display-trail)
 619         (let ((win (get-buffer-window (calc-trail-buffer))))
 620           (if win
 621               (delete-window win))))
 622     (set-buffer-modified-p nil)
 623     (goto-char calc-edit-top)))
 624
 625 (defun calc-edit-return ()
 626   (interactive)
 627   (if (and (boundp 'calc-allow-ret) calc-allow-ret)
 628       (newline)
 629     (calc-edit-finish)))
 630
 631 ;; The variable calc-edit-disp-trail is local to calc-edit finish, but
 632 ;; is used by calc-finish-selection-edit and calc-finish-stack-edit.
 633 (defvar calc-edit-disp-trail)
 634
 635 (defun calc-edit-finish (&optional keep)
 636   "Finish calc-edit mode.  Parse buffer contents and push them on the stack."
 637   (interactive "P")
 638   (message "Working...")
 639   (or (and (boundp 'calc-original-buffer)
 640            (boundp 'calc-return-buffer)
 641            (boundp 'calc-one-window)
 642            (boundp 'calc-edit-handler)
 643            (boundp 'calc-restore-trail)
 644            (eq major-mode 'calc-edit-mode))
 645       (error "This command is valid only in buffers created by calc-edit"))
 646   (let ((buf (current-buffer))
 647         (original calc-original-buffer)
 648         (return calc-return-buffer)
 649         (one-window calc-one-window)
 650         (calc-edit-disp-trail calc-restore-trail))
 651     (save-excursion
 652       (when (or (null (buffer-name original))
 653                 (progn
 654                   (set-buffer original)
 655                   (not (eq major-mode 'calc-mode))))
 656         (error "Original calculator buffer has been corrupted")))
 657     (goto-char calc-edit-top)
 658     (if (buffer-modified-p)
 659         (eval calc-edit-handler))
 660     (if (and one-window (not (one-window-p t)))
 661         (delete-window))
 662     (if (get-buffer-window return)
 663         (select-window (get-buffer-window return))
 664       (switch-to-buffer return))
 665     (if keep
 666         (bury-buffer buf)
 667       (kill-buffer buf))
 668     (if calc-edit-disp-trail
 669         (calc-wrapper
 670          (calc-trail-display 1 t)))
 671     (message "")))
 672
 673 (defun calc-edit-cancel ()
 674   "Cancel calc-edit mode.  Ignore the Calc Edit buffer and don't change stack."
 675   (interactive)
 676   (let ((calc-edit-handler nil))
 677     (calc-edit-finish))
 678   (message "(Cancelled)"))
 679
 680 (defun calc-finish-stack-edit (num)
 681   (let ((buf (current-buffer))
 682         (str (buffer-substring calc-edit-top (point-max)))
 683         (start (point))
 684         pos)
 685     (if (and (integerp num) (> num 1))
 686         (while (setq pos (string-match "\n." str))
 687           (aset str pos ?\,)))
 688     (switch-to-buffer calc-original-buffer)
 689     (let ((vals (let ((calc-language nil)
 690                       (math-expr-opers (math-standard-ops)))
 691                   (and (string-match "[^\n\t ]" str)
 692                        (math-read-exprs str)))))
 693       (when (eq (car-safe vals) 'error)
 694         (switch-to-buffer buf)
 695         (goto-char (+ start (nth 1 vals)))
 696         (error (nth 2 vals)))
 697       (calc-wrapper
 698        (if (symbolp num)
 699            (progn
 700              (set num (car vals))
 701              (calc-refresh-evaltos num))
 702          (if calc-edit-disp-trail
 703              (calc-trail-display 1 t))
 704          (and vals
 705               (let ((calc-simplify-mode (if (eq last-command-char ?\C-j)
 706                                             'none
 707                                           calc-simplify-mode)))
 708                 (if (>= num 0)
 709                     (calc-enter-result num "edit" vals)
 710                   (calc-enter-result 1 "edit" vals (- num))))))))))
 711
 712 (provide 'calc-yank)
 713
 714 ;; Local variables:
 715 ;; generated-autoload-file: "calc-loaddefs.el"
 716 ;; End:
 717
 718 ;; arch-tag: ca61019e-caca-4daa-b32c-b6afe372d5b5
 719 ;;; calc-yank.el ends here