* dispextern.h (struct glyph_string): New members clip_head and
[bpt/emacs.git] / lisp / calc / calc-store.el
index c087ff3..b2cef49 100644 (file)
@@ -1,6 +1,9 @@
-;; Calculator for GNU Emacs, part II [calc-store.el]
+;;; calc-store.el --- value storage functions for Calc
+
 ;; Copyright (C) 1990, 1991, 1992, 1993, 2001 Free Software Foundation, Inc.
-;; Written by Dave Gillespie, daveg@synaptics.com.
+
+;; Author: David Gillespie <daveg@synaptics.com>
+;; Maintainer: Jay Belanger <belanger@truman.edu>
 
 ;; This file is part of GNU Emacs.
 
 ;; file named COPYING.  Among other things, the copyright notice
 ;; and this notice must be preserved on all copies.
 
+;;; Commentary:
 
+;;; Code:
 
 ;; This file is autoloaded from calc-ext.el.
-(require 'calc-ext)
 
+(require 'calc-ext)
 (require 'calc-macs)
 
-(defun calc-Need-calc-store () nil)
-
-
 ;;; Memory commands.
 
+(defvar calc-store-keep nil)
 (defun calc-store (&optional var)
   (interactive)
   (let ((calc-store-keep t))
     (calc-store-into var)))
-(setq calc-store-keep nil)
+
+(defvar calc-given-value-flag nil)
+(defvar calc-given-value)
 
 (defun calc-store-into (&optional var)
   (interactive)
                             tag (and (not val) 1))
           (message "Stored to variable \"%s\"" (calc-var-name var)))))))
 
+(defvar calc-var-name-map nil "Keymap for reading Calc variable names.")
+(if calc-var-name-map
+    ()
+  (setq calc-var-name-map (copy-keymap minibuffer-local-completion-map))
+  (define-key calc-var-name-map " " 'self-insert-command)
+  (mapcar (function
+          (lambda (x)
+            (define-key calc-var-name-map (char-to-string x)
+              'calcVar-digit)))
+         "0123456789")
+  (mapcar (function
+          (lambda (x)
+            (define-key calc-var-name-map (char-to-string x)
+              'calcVar-oper)))
+         "+-*/^|"))
+
+(defvar calc-store-opers)
+
 (defun calc-read-var-name (prompt &optional calc-store-opers)
   (setq calc-given-value nil
        calc-aborted-prefix nil)
-  (let ((var (let ((minibuffer-completion-table obarray)
-                  (minibuffer-completion-predicate 'boundp)
-                  (minibuffer-completion-confirm t))
-              (read-from-minibuffer prompt "var-" calc-var-name-map nil))))
+  (let ((var (concat 
+              "var-"
+              (let ((minibuffer-completion-table
+                     (mapcar (lambda (x) (substring x 4)) 
+                             (all-completions "var-" obarray)))
+                    (minibuffer-completion-predicate 
+                     (lambda (x) (boundp (intern (concat "var-" x)))))
+                    (minibuffer-completion-confirm t))
+                (read-from-minibuffer prompt nil calc-var-name-map nil)))))
     (setq calc-aborted-prefix "")
-    (and (not (equal var ""))
-        (not (equal var "var-"))
+    (and (not (equal var "var-"))
         (if (string-match "\\`\\([-a-zA-Z0-9]+\\) *:?=" var)
             (if (null calc-given-value-flag)
                 (error "Assignment is not allowed in this command")
                 (setq calc-given-value (math-evaluate-expr calc-given-value))
                 svar))
           (intern var)))))
-(setq calc-given-value-flag nil)
-
-(defvar calc-var-name-map nil "Keymap for reading Calc variable names.")
-(if calc-var-name-map
-    ()
-  (setq calc-var-name-map (copy-keymap minibuffer-local-completion-map))
-  (define-key calc-var-name-map " " 'self-insert-command)
-  (mapcar (function
-          (lambda (x)
-            (define-key calc-var-name-map (char-to-string x)
-              'calcVar-digit)))
-         "0123456789")
-  (mapcar (function
-          (lambda (x)
-            (define-key calc-var-name-map (char-to-string x)
-              'calcVar-oper)))
-         "+-*/^|"))
 
 (defun calcVar-digit ()
   (interactive)
-  (if (calc-minibuffer-contains "var-\\'")
+  (if (calc-minibuffer-contains "\\'")
       (if (eq calc-store-opers 0)
          (beep)
        (insert "q")
 (defun calcVar-oper ()
   (interactive)
   (if (and (eq calc-store-opers t)
-          (calc-minibuffer-contains "var-\\'"))
+          (calc-minibuffer-contains "\\'"))
       (progn
        (erase-buffer)
        (self-insert-and-exit))
    (if var1
        (let ((value (calc-var-value var1)))
         (or value
-            (error "No such variable: \"%s\"" (calc-var-name var)))
+            (error "No such variable: \"%s\"" (calc-var-name var1)))
         (or var2 (setq var2 (calc-read-var-name
-                             (format "Copy variable: %s, to: " var1))))
+                             (format "Copy variable: %s, to: " 
+                                      (calc-var-name var1)))))
         (if var2
             (calc-store-value var2 value ""))))))
 
+(defvar calc-last-edited-variable nil)
 (defun calc-edit-variable (&optional var)
   (interactive)
   (calc-wrapper
         (setq calc-last-edited-variable var)
         (calc-edit-mode (list 'calc-finish-stack-edit (list 'quote var))
                         t
-                        (concat "Editing " (calc-var-name var)))
+                        (concat "Editing variable `" (calc-var-name var) "'. "))
         (and value
              (insert (math-format-nice-expr value (frame-width)) "\n")))))
   (calc-show-edit-buffer))
-(setq calc-last-edited-variable nil)
 
 (defun calc-edit-Decls ()
   (interactive)
                                                 decl)))))))
      (calc-refresh-evaltos 'var-Decls))))
 
+(defvar calc-dont-insert-variables '(var-FitRules var-FactorRules
+                                    var-CommuteRules var-JumpRules
+                                    var-DistribRules var-MergeRules
+                                    var-NegateRules var-InvertRules
+                                    var-IntegAfterRules
+                                    var-TimeZone var-PlotRejects
+                                    var-PlotData1 var-PlotData2
+                                    var-PlotData3 var-PlotData4
+                                    var-PlotData5 var-PlotData6
+                                    var-DUMMY))
+
+;; The variable calc-pv-pos is local to calc-permanent-variable, but
+;; used by calc-insert-permanent-variable, which is called by
+;; calc-permanent-variable.
+(defvar calc-pv-pos)
+
 (defun calc-permanent-variable (&optional var)
   (interactive)
   (calc-wrapper
    (or var (setq var (calc-read-var-name "Save variable (default=all): ")))
-   (let (pos)
+   (let (calc-pv-pos)
      (and var (or (and (boundp var) (symbol-value var))
                  (error "No such variable")))
      (set-buffer (find-file-noselect (substitute-in-file-name
                         (not (eq (car-safe (symbol-value x)) 'special-const))
                         (calc-insert-permanent-variable x))))))
      (save-buffer))))
-(defvar calc-dont-insert-variables '(var-FitRules var-FactorRules
-                                    var-CommuteRules var-JumpRules
-                                    var-DistribRules var-MergeRules
-                                    var-NegateRules var-InvertRules
-                                    var-IntegAfterRules
-                                    var-TimeZone var-PlotRejects
-                                    var-PlotData1 var-PlotData2
-                                    var-PlotData3 var-PlotData4
-                                    var-PlotData5 var-PlotData6
-                                    var-DUMMY
-))
+
+
 
 (defun calc-insert-permanent-variable (var)
   (goto-char (point-min))
   (if (search-forward (concat "(setq " (symbol-name var) " '") nil t)
       (progn
-       (setq pos (point-marker))
+       (setq calc-pv-pos (point-marker))
        (forward-line -1)
        (if (looking-at ";;; Variable .* stored by Calc on ")
            (progn
              (delete-region (match-end 0) (progn (end-of-line) (point)))
              (insert (current-time-string))))
-       (goto-char (- pos 8 (length (symbol-name var))))
+       (goto-char (- calc-pv-pos 8 (length (symbol-name var))))
        (forward-sexp 1)
        (backward-char 1)
-       (delete-region pos (point)))
+       (delete-region calc-pv-pos (point)))
     (goto-char (point-max))
     (insert "\n;;; Variable \""
            (symbol-name var)
   (calc-slow-wrapper
    (calc-binary-op "sub" 'calcFunc-subscr arg)))
 
+(provide 'calc-store)
+
+;;; arch-tag: 2fbfec82-a521-42ca-bcd8-4f254ae6313e
 ;;; calc-store.el ends here