root/trunk/lisp/calc/calc-embed.el

;;; calc-embed.el --- embed Calc in a buffer

;; Copyright (C) 1990, 1991, 1992, 1993, 2001, 2002, 2003, 2004,
;;   2005, 2006, 2007, 2008 Free Software Foundation, Inc.

;; Author: David Gillespie <daveg@synaptics.com>
;; Maintainer: Jay Belanger <jay.p.belanger@gmail.com>

;; This file is part of GNU Emacs.

;; GNU Emacs is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation; either version 3, or (at your option)
;; any later version.

;; GNU Emacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;; GNU General Public License for more details.

;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs; see the file COPYING.  If not, write to the
;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
;; Boston, MA 02110-1301, USA.

;;; Commentary:

;;; Code:

;; This file is autoloaded from calc-ext.el.

(require 'calc-ext)
(require 'calc-macs)

(defun calc-show-plain (n)
  (interactive "P")
  (calc-wrapper
   (calc-set-command-flag 'renum-stack)
   (message (if (calc-change-mode 'calc-show-plain n nil t)
                "Including \"plain\" formulas in Calc Embedded mode"
              "Omitting \"plain\" formulas in Calc Embedded mode"))))


(defvar calc-embedded-modes nil)
(defvar calc-embedded-globals nil)
(defvar calc-embedded-active nil)
(defvar calc-embedded-all-active nil)
(make-variable-buffer-local 'calc-embedded-all-active)
(defvar calc-embedded-some-active nil)
(make-variable-buffer-local 'calc-embedded-some-active)

;; The following variables are customizable and defined in calc.el.
(defvar calc-embedded-announce-formula)
(defvar calc-embedded-open-formula)
(defvar calc-embedded-close-formula)
(defvar calc-embedded-open-word)
(defvar calc-embedded-close-word)
(defvar calc-embedded-open-plain)
(defvar calc-embedded-close-plain)
(defvar calc-embedded-open-new-formula)
(defvar calc-embedded-close-new-formula)
(defvar calc-embedded-open-mode)
(defvar calc-embedded-close-mode)

(defconst calc-embedded-mode-vars '(("precision" . calc-internal-prec)
                                    ("word-size" . calc-word-size)
                                    ("angles" . calc-angle-mode)
                                    ("symbolic" . calc-symbolic-mode)
                                    ("matrix" . calc-matrix-mode)
                                    ("fractions" . calc-prefer-frac)
                                    ("complex" . calc-complex-mode)
                                    ("simplify" . calc-simplify-mode)
                                    ("language" . the-language)
                                    ("plain" . calc-show-plain)
                                    ("break" . calc-line-breaking)
                                    ("justify" . the-display-just)
                                    ("left-label" . calc-left-label)
                                    ("right-label" . calc-right-label)
                                    ("radix" . calc-number-radix)
                                    ("leading-zeros" . calc-leading-zeros)
                                    ("grouping" . calc-group-digits)
                                    ("group-char" . calc-group-char)
                                    ("point-char" . calc-point-char)
                                    ("frac-format" . calc-frac-format)
                                    ("float-format" . calc-float-format)
                                    ("complex-format" . calc-complex-format)
                                    ("hms-format" . calc-hms-format)
                                    ("date-format" . calc-date-format)
                                    ("matrix-justify" . calc-matrix-just)
                                    ("full-vectors" . calc-full-vectors)
                                    ("break-vectors" . calc-break-vectors)
                                    ("vector-commas" . calc-vector-commas)
                                    ("vector-brackets" . calc-vector-brackets)
                                    ("matrix-brackets" . calc-matrix-brackets)
                                    ("strings" . calc-display-strings)
))


;;; Format of calc-embedded-info vector:
;;;    0   Editing buffer.
;;;    1   Calculator buffer.
;;;    2   Top of current formula (marker).
;;;    3   Bottom of current formula (marker).
;;;    4   Top of current formula's delimiters (marker).
;;;    5   Bottom of current formula's delimiters (marker).
;;;    6   String representation of current formula.
;;;    7   Non-nil if formula is embedded within a single line.
;;;    8   Internal representation of current formula.
;;;    9   Variable assigned by this formula, or nil.
;;;   10   List of variables upon which this formula depends.
;;;   11   Evaluated value of the formula, or nil.
;;;   12   Mode settings for current formula.
;;;   13   Local mode settings for current formula.
;;;   14   Permanent mode settings for current formula.
;;;   15   Global mode settings for editing buffer.


;;; calc-embedded-active is an a-list keyed on buffers; each cdr is a
;;; sorted list of calc-embedded-infos in that buffer.  We do this
;;; rather than using buffer-local variables because the latter are
;;; thrown away when a buffer changes major modes.

(defvar calc-embedded-original-modes nil
  "The mode settings for Calc buffer when put in embedded mode.")

(defun calc-embedded-save-original-modes ()
  "Save the current Calc modes when entereding embedded mode."
  (let ((calcbuf (save-excursion
                   (calc-create-buffer)
                   (current-buffer)))
        lang modes)
    (if calcbuf
        (with-current-buffer calcbuf
          (setq lang
                (cons calc-language calc-language-option))
          (setq modes
                (list (cons 'calc-display-just
                            calc-display-just)
                      (cons 'calc-display-origin
                            calc-display-origin)))
          (let ((v calc-embedded-mode-vars))
            (while v
              (let ((var (cdr (car v))))
                (unless (memq var '(the-language the-display-just))
                  (setq modes
                        (cons (cons var (symbol-value var)) 
                              modes))))
              (setq v (cdr v))))
          (setq calc-embedded-original-modes (cons lang modes)))
      (setq calc-embedded-original-modes nil))))

(defun calc-embedded-preserve-modes ()
  "Preserve the current modes when leaving embedded mode."
  (interactive)
  (if calc-embedded-info
      (progn
        (calc-embedded-save-original-modes)
        (message "Current modes will be preserved when leaving embedded mode."))
    (message "Not in embedded mode.")))

(defun calc-embedded-restore-original-modes ()
  "Restore the original Calc modes when leaving embedded mode."
  (let ((calcbuf (get-buffer "*Calculator*"))
        (changed nil)
        (lang (car calc-embedded-original-modes))
        (modes (cdr calc-embedded-original-modes)))
    (if (and calcbuf calc-embedded-original-modes)
        (with-current-buffer calcbuf
          (unless (and
                   (equal calc-language (car lang))
                   (equal calc-language-option (cdr lang)))
            (calc-set-language (car lang) (cdr lang))
            (setq changed t))
          (while modes
            (let ((mode (car modes)))
              (unless (equal (symbol-value (car mode)) (cdr mode))
                (set (car mode) (cdr mode))
                (setq changed t)))
            (setq modes (cdr modes)))
          (when changed
            (calc-refresh)
            (calc-set-mode-line))))
    (setq calc-embedded-original-modes nil)))

;; The variables calc-embed-outer-top, calc-embed-outer-bot, 
;; calc-embed-top and calc-embed-bot are
;; local to calc-do-embedded, calc-embedded-mark-formula,
;; calc-embedded-duplicate, calc-embedded-new-formula and
;; calc-embedded-make-info, but are used by calc-embedded-find-bounds,
;; which is called (directly or indirectly) by the above functions.
(defvar calc-embed-outer-top)
(defvar calc-embed-outer-bot)
(defvar calc-embed-top)
(defvar calc-embed-bot)

;; The variable calc-embed-arg is local to calc-do-embedded,
;; calc-embedded-update-formula, calc-embedded-edit and
;; calc-do-embedded-activate, but is used by 
;; calc-embedded-make-info, which is called by the above
;; functions.
(defvar calc-embed-arg)

(defvar calc-embedded-quiet nil)

(defvar calc-embedded-firsttime)
(defvar calc-embedded-firsttime-buf)
(defvar calc-embedded-firsttime-formula)

;; The following is to take care of any minor modes which override
;; a Calc command.
(defvar calc-override-minor-modes-map 
  (make-sparse-keymap)
  "A list of keybindings that might be overwritten by minor modes.")

;; Add any keys that might be overwritten here.
(define-key calc-override-minor-modes-map "`" 'calc-edit)

(defvar calc-override-minor-modes 
  (cons t calc-override-minor-modes-map))

(defun calc-do-embedded (calc-embed-arg end obeg oend)
  (if calc-embedded-info

      ;; Turn embedded mode off or switch to a new buffer.
      (cond ((eq (current-buffer) (aref calc-embedded-info 1))
             (let ((calcbuf (current-buffer))
                   (buf (aref calc-embedded-info 0)))
               (calc-embedded-original-buffer t)
               (calc-embedded nil)
               (switch-to-buffer calcbuf)))

            ((eq (current-buffer) (aref calc-embedded-info 0))
             (let* ((info calc-embedded-info)
                    (mode calc-embedded-modes))
               (save-excursion
                 (set-buffer (aref info 1))
                 (if (and (> (calc-stack-size) 0)
                          (equal (calc-top 1 'full) (aref info 8)))
                     (let ((calc-no-refresh-evaltos t))
                       (if (calc-top 1 'sel)
                           (calc-unselect 1))
                       (calc-embedded-set-modes
                        (aref info 15) (aref info 12) (aref info 14))
                       (let ((calc-embedded-info nil))
                         (calc-wrapper (calc-pop-stack))))
                   (calc-set-mode-line)))
               (setq calc-embedded-info nil
                     mode-line-buffer-identification (car mode)
                     truncate-lines (nth 2 mode)
                     buffer-read-only nil)
               (use-local-map (nth 1 mode))
               (setq minor-mode-overriding-map-alist
                     (remq calc-override-minor-modes minor-mode-overriding-map-alist))
               (set-buffer-modified-p (buffer-modified-p))
               (calc-embedded-restore-original-modes)
               (or calc-embedded-quiet
                   (message "Back to %s mode" mode-name))))

            (t
             (if (buffer-name (aref calc-embedded-info 0))
                 (save-excursion
                   (set-buffer (aref calc-embedded-info 0))
                   (or (y-or-n-p (format "Cancel Calc Embedded mode in buffer %s? "
                                         (buffer-name)))
                       (keyboard-quit))
                   (calc-embedded nil)))
             (calc-embedded calc-embed-arg end obeg oend)))

    ;; Turn embedded mode on.
    (calc-plain-buffer-only)
    (let ((modes (list mode-line-buffer-identification
                       (current-local-map)
                       truncate-lines))
          (calc-embedded-firsttime (not calc-embedded-active))
          (calc-embedded-firsttime-buf nil)
          (calc-embedded-firsttime-formula nil)
          calc-embed-top calc-embed-bot calc-embed-outer-top calc-embed-outer-bot
          info chg ident)
      (barf-if-buffer-read-only)
      (calc-embedded-save-original-modes)
      (or calc-embedded-globals
          (calc-find-globals))
      (setq info 
            (calc-embedded-make-info (point) nil t calc-embed-arg end obeg oend))
      (if (eq (car-safe (aref info 8)) 'error)
          (progn
            (setq calc-embedded-original-modes nil)
            (goto-char (nth 1 (aref info 8)))
            (error (nth 2 (aref info 8)))))
      (let ((mode-line-buffer-identification mode-line-buffer-identification)
            (calc-embedded-info info)
            (calc-embedded-no-reselect t))
        (calc-wrapper
         (let* ((okay nil)
                (calc-no-refresh-evaltos t))
           (if (aref info 8)
               (progn
                 (calc-push (calc-normalize (aref info 8)))
                 (setq chg (calc-embedded-set-modes
                            (aref info 15) (aref info 12) (aref info 13))))
             (setq chg (calc-embedded-set-modes
                        (aref info 15) (aref info 12) (aref info 13)))
             (calc-alg-entry)))
         (setq calc-undo-list nil
               calc-redo-list nil
               ident mode-line-buffer-identification)))
      (setq calc-embedded-info info
            calc-embedded-modes modes
            mode-line-buffer-identification ident
            truncate-lines t
            buffer-read-only t)
      (set-buffer-modified-p (buffer-modified-p))
      (use-local-map calc-mode-map)
      (setq minor-mode-overriding-map-alist
            (cons calc-override-minor-modes
                  minor-mode-overriding-map-alist))
      (setq calc-no-refresh-evaltos nil)
      (and chg calc-any-evaltos (calc-wrapper (calc-refresh-evaltos)))
      (let (str)
        (save-excursion
          (calc-select-buffer)
          (setq str mode-line-buffer-identification))
        (unless (equal str mode-line-buffer-identification)
          (setq mode-line-buffer-identification str)
          (set-buffer-modified-p (buffer-modified-p))))
      (if calc-embedded-firsttime
          (run-hooks 'calc-embedded-mode-hook))
      (if calc-embedded-firsttime-buf
          (run-hooks 'calc-embedded-new-buffer-hook))
      (if calc-embedded-firsttime-formula
          (run-hooks 'calc-embedded-new-formula-hook))
      (or (eq calc-embedded-quiet t)
          (message "Embedded Calc mode enabled; %s to return to normal"
                   (if calc-embedded-quiet
                       "Type `C-x * x'"
                     "Give this command again")))))
  (scroll-down 0))    ; fix a bug which occurs when truncate-lines is changed.


(defun calc-embedded-select (arg)
  (interactive "P")
  (calc-embedded arg)
  (and calc-embedded-info
       (eq (car-safe (aref calc-embedded-info 8)) 'calcFunc-evalto)
       (calc-select-part 1))
  (and calc-embedded-info
       (or (eq (car-safe (aref calc-embedded-info 8)) 'calcFunc-assign)
           (and (eq (car-safe (aref calc-embedded-info 8)) 'calcFunc-evalto)
                (eq (car-safe (nth 1 (aref calc-embedded-info 8)))
                    'calcFunc-assign)))
       (calc-select-part 2)))


(defun calc-embedded-update-formula (calc-embed-arg)
  (interactive "P")
  (if calc-embed-arg
      (let ((entry (assq (current-buffer) calc-embedded-active)))
        (while (setq entry (cdr entry))
          (and (eq (car-safe (aref (car entry) 8)) 'calcFunc-evalto)
               (or (not (consp calc-embed-arg))
                   (and (<= (aref (car entry) 2) (region-beginning))
                        (>= (aref (car entry) 3) (region-end))))
               (save-excursion
                 (calc-embedded-update (car entry) 14 t t)))))
    (if (and calc-embedded-info
             (eq (current-buffer) (aref calc-embedded-info 0))
             (>= (point) (aref calc-embedded-info 4))
             (<= (point) (aref calc-embedded-info 5)))
        (calc-evaluate 1)
      (let* ((opt (point))
             (info (calc-embedded-make-info (point) nil t))
             (pt (- opt (aref info 4))))
        (or (eq (car-safe (aref info 8)) 'error)
            (progn
              (save-excursion
                (calc-embedded-update info 14 'eval t))
              (goto-char (+ (aref info 4) pt))))))))


(defun calc-embedded-edit (calc-embed-arg)
  (interactive "P")
  (let ((info (calc-embedded-make-info (point) nil t calc-embed-arg))
        str)
    (if (eq (car-safe (aref info 8)) 'error)
        (progn
          (goto-char (nth 1 (aref info 8)))
          (error (nth 2 (aref info 8)))))
    (calc-wrapper
     (setq str (math-showing-full-precision
                (math-format-nice-expr (aref info 8) (frame-width))))
     (calc-edit-mode (list 'calc-embedded-finish-edit info))
     (insert str "\n")))
  (calc-show-edit-buffer))

(defvar calc-original-buffer)
(defvar calc-edit-top)
(defun calc-embedded-finish-edit (info)
  (let ((buf (current-buffer))
        (str (buffer-substring calc-edit-top (point-max)))
        (start (point))
        pos)
    (switch-to-buffer calc-original-buffer)
    (let ((val (save-excursion
                 (set-buffer (aref info 1))
                 (let ((calc-language nil)
                       (math-expr-opers math-standard-opers))
                   (math-read-expr str)))))
      (if (eq (car-safe val) 'error)
          (progn
            (switch-to-buffer buf)
            (goto-char (+ start (nth 1 val)))
            (error (nth 2 val))))
      (calc-embedded-original-buffer t info)
      (aset info 8 val)
      (calc-embedded-update info 14 t t))))

(defun calc-do-embedded-activate (calc-embed-arg cbuf)
  (calc-plain-buffer-only)
  (if calc-embed-arg
      (calc-embedded-forget))
  (calc-find-globals)
  (if (< (prefix-numeric-value calc-embed-arg) 0)
      (message "Deactivating %s for Calc Embedded mode" (buffer-name))
    (message "Activating %s for Calc Embedded mode..." (buffer-name))
    (save-excursion
      (let* ((active (assq (current-buffer) calc-embedded-active))
             (info active)
             (pat " := \\| \\\\gets \\| => \\| \\\\evalto "))
        (if calc-embedded-announce-formula
            (setq pat (format "%s\\|\\(%s\\)"
                              pat calc-embedded-announce-formula)))
        (while (setq info (cdr info))
          (or (equal (buffer-substring (aref (car info) 2) (aref (car info) 3))
                     (aref (car info) 6))
              (setcdr active (delq (car info) (cdr active)))))
        (goto-char (point-min))
        (while (re-search-forward pat nil t)
;;;       (if (looking-at calc-embedded-open-formula)
;;;           (goto-char (match-end 1)))
          (setq info (calc-embedded-make-info (point) cbuf nil))
          (or (eq (car-safe (aref info 8)) 'error)
              (goto-char (aref info 5))))))
    (message "Activating %s for Calc Embedded mode...done" (buffer-name)))
  (calc-embedded-active-state t))

(defun calc-plain-buffer-only ()
  (if (memq major-mode '(calc-mode calc-trail-mode calc-edit-mode))
      (error "This command should be used in a normal editing buffer")))

(defun calc-embedded-active-state (state)
  (or (assq 'calc-embedded-all-active minor-mode-alist)
      (setq minor-mode-alist
            (cons '(calc-embedded-all-active " Active")
                  (cons '(calc-embedded-some-active " ~Active")
                        minor-mode-alist))))
  (let ((active (assq (current-buffer) calc-embedded-active)))
    (or (cdr active)
        (setq state nil)))
  (and (eq state 'more) calc-embedded-all-active (setq state t))
  (setq calc-embedded-all-active (eq state t)
        calc-embedded-some-active (not (memq state '(nil t))))
  (set-buffer-modified-p (buffer-modified-p)))


(defun calc-embedded-original-buffer (switch &optional info)
  (or info (setq info calc-embedded-info))
  (or (buffer-name (aref info 0))
      (progn
        (error "Calc embedded mode: Original buffer has been killed")))
  (if switch
      (set-buffer (aref info 0))))

(defun calc-embedded-word ()
  (interactive)
  (calc-embedded '(t)))

(defun calc-embedded-mark-formula (&optional body-only)
  "Put point at the beginning of this Calc formula, mark at the end.
This normally marks the whole formula, including surrounding delimiters.
With any prefix argument, marks only the formula itself."
  (interactive "P")
  (and (eq major-mode 'calc-mode)
       (error "This command should be used in a normal editing buffer"))
  (let (calc-embed-top calc-embed-bot calc-embed-outer-top calc-embed-outer-bot)
    (save-excursion
      (calc-embedded-find-bounds body-only))
    (push-mark (if body-only calc-embed-bot calc-embed-outer-bot) t)
    (goto-char (if body-only calc-embed-top calc-embed-outer-top))))

(defun calc-embedded-find-bounds (&optional plain)
  ;; (while (and (bolp) (eq (following-char) ?\n))
  ;;  (forward-char 1))
  (and (eolp) (bolp) (not (eq (char-after (- (point) 2)) ?\n))
       (forward-char -1))
  (let ((home (point)))
    (or (and (looking-at calc-embedded-open-formula)
             (not (looking-at calc-embedded-close-formula)))
        (re-search-backward calc-embedded-open-formula nil t)
        (error "Can't find start of formula"))
    (and (eq (preceding-char) ?\$)  ; backward search for \$\$? won't back
         (eq (following-char) ?\$)  ; up over a second $, so do it by hand.
         (forward-char -1))
    (setq calc-embed-outer-top (point))
    (goto-char (match-end 0))
    (if (looking-at "[ \t]*$")
        (end-of-line))
    (if (eq (following-char) ?\n)
        (forward-char 1))
    (or (bolp)
        (while (eq (following-char) ?\ )
          (forward-char 1)))
    (or (eq plain 'plain)
        (if (looking-at (regexp-quote calc-embedded-open-plain))
            (progn
              (goto-char (match-end 0))
              (search-forward calc-embedded-close-plain))))
    (setq calc-embed-top (point))
    (or (re-search-forward calc-embedded-close-formula nil t)
        (error "Can't find end of formula"))
    (if (< (point) home)
        (error "Not inside a formula"))
    (and (eq (following-char) ?\n) (not (bolp))
         (forward-char 1))
    (setq calc-embed-outer-bot (point))
    (goto-char (match-beginning 0))
    (if (eq (preceding-char) ?\n)
        (backward-char 1))
    (or (eolp)
        (while (eq (preceding-char) ?\ )
          (backward-char 1)))
    (setq calc-embed-bot (point))))

(defun calc-embedded-kill-formula ()
  "Kill the formula surrounding point.
If Calc Embedded mode was active, this deactivates it.
The formula (including its surrounding delimiters) is saved in the kill ring.
The command \\[yank] can retrieve it from there."
  (interactive)
  (and calc-embedded-info
       (calc-embedded nil))
  (calc-embedded-mark-formula)
  (kill-region (point) (mark))
  (pop-mark))

(defun calc-embedded-copy-formula-as-kill ()
  "Save the formula surrounding point as if killed, but don't kill it."
  (interactive)
  (save-excursion
    (calc-embedded-mark-formula)
    (copy-region-as-kill (point) (mark))
    (pop-mark)))

(defun calc-embedded-duplicate ()
  (interactive)
  (let ((already calc-embedded-info)
        calc-embed-top calc-embed-bot calc-embed-outer-top calc-embed-outer-bot new-top)
    (if calc-embedded-info
        (progn
          (setq calc-embed-top (+ (aref calc-embedded-info 2))
                calc-embed-bot (+ (aref calc-embedded-info 3))
                calc-embed-outer-top (+ (aref calc-embedded-info 4))
                calc-embed-outer-bot (+ (aref calc-embedded-info 5)))
          (calc-embedded nil))
      (calc-embedded-find-bounds))
    (goto-char calc-embed-outer-bot)
    (insert "\n")
    (setq new-top (point))
    (insert-buffer-substring (current-buffer) 
                             calc-embed-outer-top calc-embed-outer-bot)
    (goto-char (+ new-top (- calc-embed-top calc-embed-outer-top)))
    (let ((calc-embedded-quiet (if already t 'x)))
      (calc-embedded (+ new-top (- calc-embed-top calc-embed-outer-top))
                     (+ new-top (- calc-embed-bot calc-embed-outer-top))
                     new-top
                     (+ new-top (- calc-embed-outer-bot calc-embed-outer-top))))))

(defun calc-embedded-next (arg)
  (interactive "P")
  (setq arg (prefix-numeric-value arg))
  (let* ((active (cdr (assq (current-buffer) calc-embedded-active)))
         (p active)
         (num (length active)))
    (or active
        (error "No active formulas in buffer"))
    (cond ((= arg 0))
          ((= arg -1)
           (if (<= (point) (aref (car active) 3))
               (goto-char (aref (nth (1- num) active) 2))
             (while (and (cdr p)
                         (> (point) (aref (nth 1 p) 3)))
               (setq p (cdr p)))
             (goto-char (aref (car p) 2))))
          ((< arg -1)
           (calc-embedded-next -1)
           (calc-embedded-next (+ (* num 1000) arg 1)))
          (t
           (setq arg (1+ (% (1- arg) num)))
           (while (and p (>= (point) (aref (car p) 2)))
             (setq p (cdr p)))
           (while (> (setq arg (1- arg)) 0)
             (setq p (if p (cdr p) (cdr active))))
           (goto-char (aref (car (or p active)) 2))))))

(defun calc-embedded-previous (arg)
  (interactive "p")
  (calc-embedded-next (- (prefix-numeric-value arg))))

(defun calc-embedded-new-formula ()
  (interactive)
  (and (eq major-mode 'calc-mode)
       (error "This command should be used in a normal editing buffer"))
  (if calc-embedded-info
      (calc-embedded nil))
  (let (calc-embed-top calc-embed-bot calc-embed-outer-top calc-embed-outer-bot)
    (if (and (eq (preceding-char) ?\n)
             (string-match "\\`\n" calc-embedded-open-new-formula))
        (progn
          (setq calc-embed-outer-top (1- (point)))
          (forward-char -1)
          (insert (substring calc-embedded-open-new-formula 1)))
      (setq calc-embed-outer-top (point))
      (insert calc-embedded-open-new-formula))
    (setq calc-embed-top (point))
    (insert " ")
    (setq calc-embed-bot (point))
    (insert calc-embedded-close-new-formula)
    (if (and (eq (following-char) ?\n)
             (string-match "\n\\'" calc-embedded-close-new-formula))
        (delete-char 1))
    (setq calc-embed-outer-bot (point))
    (goto-char calc-embed-top)
    (let ((calc-embedded-quiet 'x))
      (calc-embedded calc-embed-top calc-embed-bot calc-embed-outer-top calc-embed-outer-bot))))

(defun calc-embedded-forget ()
  (interactive)
  (setq calc-embedded-active (delq (assq (current-buffer) calc-embedded-active)
                                   calc-embedded-active))
  (calc-embedded-active-state nil))

;; The variables calc-embed-prev-modes is local to calc-embedded-update,
;; but is used by calc-embedded-set-modes.
(defvar calc-embed-prev-modes)

(defun calc-embedded-set-modes (gmodes modes local-modes &optional temp)
  (let ((the-language (calc-embedded-language))
        (the-display-just (calc-embedded-justify))
        (v gmodes)
        (changed nil)
        found value)
    (while v
      (or (symbolp (car v))
          (and (setq found (assq (car (car v)) modes))
               (not (eq (cdr found) 'default)))
          (and (setq found (assq (car (car v)) local-modes))
               (not (eq (cdr found) 'default)))
          (progn
            (if (eq (setq value (cdr (car v))) 'default)
                (setq value (list (nth 1 (assq (car (car v)) calc-mode-var-list)))))
            (equal (symbol-value (car (car v))) value))
          (progn
            (setq changed t)
            (if temp (setq calc-embed-prev-modes 
                           (cons (cons (car (car v))
                                       (symbol-value (car (car v))))
                                 calc-embed-prev-modes)))
            (set (car (car v)) value)))
      (setq v (cdr v)))
    (setq v modes)
    (while v
      (or (and (setq found (assq (car (car v)) local-modes))
               (not (eq (cdr found) 'default)))
          (eq (setq value (cdr (car v))) 'default)
          (equal (symbol-value (car (car v))) value)
          (progn
            (setq changed t)
            (if temp (setq calc-embed-prev-modes (cons (cons (car (car v))
                                                  (symbol-value (car (car v))))
                                            calc-embed-prev-modes)))
            (set (car (car v)) value)))
      (setq v (cdr v)))
    (setq v local-modes)
    (while v
      (or (eq (setq value (cdr (car v))) 'default)
          (equal (symbol-value (car (car v))) value)
          (progn
            (setq changed t)
            (if temp (setq calc-embed-prev-modes (cons (cons (car (car v))
                                                  (symbol-value (car (car v))))
                                            calc-embed-prev-modes)))
            (set (car (car v)) value)))
      (setq v (cdr v)))
    (and changed (not (eq temp t))
         (progn
           (calc-embedded-set-justify the-display-just)
           (calc-embedded-set-language the-language)))
    (and changed (not temp)
         (progn
           (setq calc-full-float-format (list (if (eq (car calc-float-format)
                                                      'fix)
                                                  'float
                                                (car calc-float-format))
                                              0))
           (calc-refresh)))
    changed))

(defun calc-embedded-language ()
  (if calc-language-option
      (list calc-language calc-language-option)
    calc-language))

(defun calc-embedded-set-language (lang)
  (let ((option nil))
    (if (consp lang)
        (setq option (nth 1 lang)
              lang (car lang)))
    (or (and (eq lang calc-language)
             (equal option calc-language-option))
        (calc-set-language lang option t))))

(defun calc-embedded-justify ()
  (if calc-display-origin
      (list calc-display-just calc-display-origin)
    calc-display-just))

(defun calc-embedded-set-justify (just)
  (if (consp just)
      (setq calc-display-origin (nth 1 just)
            calc-display-just (car just))
    (setq calc-display-just just
          calc-display-origin nil)))


(defun calc-find-globals ()
  (interactive)
  (and (eq major-mode 'calc-mode)
       (error "This command should be used in a normal editing buffer"))
  (make-local-variable 'calc-embedded-globals)
  (let ((case-fold-search nil)
        (modes nil)
        (save-pt (point))
        found value)
    (goto-char (point-min))
    (while (re-search-forward "\\[calc-global-mode: *\\([-a-z]+\\): *\\(\"\\([^\"\n\\]\\|\\\\.\\)*\"\\|[- ()a-zA-Z0-9]+\\)\\]" nil t)
      (and (setq found (assoc (buffer-substring (match-beginning 1)
                                                (match-end 1))
                              calc-embedded-mode-vars))
           (or (assq (cdr found) modes)
               (setq modes (cons (cons (cdr found)
                                       (car (read-from-string
                                             (buffer-substring
                                              (match-beginning 2)
                                              (match-end 2)))))
                                 modes)))))
    (setq calc-embedded-globals (cons t modes))
    (goto-char save-pt)))

(defun calc-embedded-find-modes ()
  (let ((case-fold-search nil)
        (save-pt (point))
        (no-defaults t)
        (modes nil)
        (emodes nil)
        (pmodes nil)
        found value)
    (while (and no-defaults (search-backward "[calc-" nil t))
      (forward-char 6)
      (or (and (looking-at "mode: *\\([-a-z]+\\): *\\(\"\\([^\"\n\\]\\|\\\\.\\)*\"\\|[- ()a-zA-Z0-9]+\\)]")
               (setq found (assoc (buffer-substring (match-beginning 1)
                                                    (match-end 1))
                                  calc-embedded-mode-vars))
               (or (assq (cdr found) modes)
                   (setq modes (cons (cons (cdr found)
                                           (car (read-from-string
                                                 (buffer-substring
                                                  (match-beginning 2)
                                                  (match-end 2)))))
                                     modes))))
          (and (looking-at "perm-mode: *\\([-a-z]+\\): *\\(\"\\([^\"\n\\]\\|\\\\.\\)*\"\\|[- ()a-zA-Z0-9]+\\)]")
               (setq found (assoc (buffer-substring (match-beginning 1)
                                                    (match-end 1))
                                  calc-embedded-mode-vars))
               (or (assq (cdr found) pmodes)
                   (setq pmodes (cons (cons (cdr found)
                                            (car (read-from-string
                                                  (buffer-substring
                                                   (match-beginning 2)
                                                   (match-end 2)))))
                                      pmodes))))
          (and (looking-at "edit-mode: *\\([-a-z]+\\): *\\(\"\\([^\"\n\\]\\|\\\\.\\)*\"\\|[- ()a-zA-Z0-9]+\\)]")
               (setq found (assoc (buffer-substring (match-beginning 1)
                                                    (match-end 1))
                                  calc-embedded-mode-vars))
               (or (assq (cdr found) emodes)
                   (setq emodes (cons (cons (cdr found)
                                            (car (read-from-string
                                                  (buffer-substring
                                                   (match-beginning 2)
                                                   (match-end 2)))))
                                      emodes))))
          (and (looking-at "defaults]")
               (setq no-defaults nil)))
      (backward-char 6))
    (goto-char save-pt)
    (unless (assq 'the-language modes)
      (let ((lang (assoc major-mode calc-language-alist)))
        (if lang
            (setq modes (cons (cons 'the-language (cdr lang))
                              modes)))))
    (list modes emodes pmodes)))

;; The variable calc-embed-vars-used is local to calc-embedded-make-info,
;; calc-embedded-evaluate-expr and calc-embedded-update, but is 
;; used by calc-embedded-find-vars, which is called by the above functions.
(defvar calc-embed-vars-us