lisp/calc/calc-store.el

   1 ;;; calc-store.el --- value storage functions for Calc
   2
   3 ;; Copyright (C) 1990, 1991, 1992, 1993, 2001, 2005 Free Software Foundation, Inc.
   4
   5 ;; Author: David Gillespie <daveg@synaptics.com>
   6 ;; Maintainer: Jay Belanger <belanger@truman.edu>
   7
   8 ;; This file is part of GNU Emacs.
   9
  10 ;; GNU Emacs is distributed in the hope that it will be useful,
  11 ;; but WITHOUT ANY WARRANTY.  No author or distributor
  12 ;; accepts responsibility to anyone for the consequences of using it
  13 ;; or for whether it serves any particular purpose or works at all,
  14 ;; unless he says so in writing.  Refer to the GNU Emacs General Public
  15 ;; License for full details.
  16
  17 ;; Everyone is granted permission to copy, modify and redistribute
  18 ;; GNU Emacs, but only under the conditions described in the
  19 ;; GNU Emacs General Public License.   A copy of this license is
  20 ;; supposed to have been given to you along with GNU Emacs so you
  21 ;; can know your rights and responsibilities.  It should be in a
  22 ;; file named COPYING.  Among other things, the copyright notice
  23 ;; and this notice must be preserved on all copies.
  24
  25 ;;; Commentary:
  26
  27 ;;; Code:
  28
  29 ;; This file is autoloaded from calc-ext.el.
  30
  31 (require 'calc-ext)
  32 (require 'calc-macs)
  33
  34 ;;; Memory commands.
  35
  36 (defvar calc-store-keep nil)
  37 (defun calc-store (&optional var)
  38   (interactive)
  39   (let ((calc-store-keep t))
  40     (calc-store-into var)))
  41
  42 (defvar calc-given-value-flag nil)
  43 (defvar calc-given-value)
  44
  45 (defun calc-store-into (&optional var)
  46   (interactive)
  47   (calc-wrapper
  48    (let ((calc-given-value nil)
  49          (calc-given-value-flag 1))
  50      (or var (setq var (calc-read-var-name "Store: " t)))
  51      (if var
  52          (let ((found (assq var '( ( + . calc-store-plus )
  53                                    ( - . calc-store-minus )
  54                                    ( * . calc-store-times )
  55                                    ( / . calc-store-div )
  56                                    ( ^ . calc-store-power )
  57                                    ( | . calc-store-concat ) ))))
  58            (if found
  59                (funcall (cdr found))
  60              (let ((msg
  61                     (calc-store-value var (or calc-given-value (calc-top 1))
  62                                       "" calc-given-value-flag)))
  63                (message (concat "Stored to variable \"%s\"" msg)
  64                         (calc-var-name var)))))
  65        (setq var (calc-is-assignments (calc-top 1)))
  66        (if var
  67            (while var
  68              (let ((msg
  69                     (calc-store-value (car (car var)) (cdr (car var))
  70                                       (if (not (cdr var)) "")
  71                                       (if (not (cdr var)) 1))))
  72                (message (concat "Stored to variable \"%s\"" msg)
  73                         (calc-var-name var)))
  74              (setq var (cdr var))))))))
  75
  76 (defun calc-store-plus (&optional var)
  77   (interactive)
  78   (calc-store-binary var "+" '+))
  79
  80 (defun calc-store-minus (&optional var)
  81   (interactive)
  82   (calc-store-binary var "-" '-))
  83
  84 (defun calc-store-times (&optional var)
  85   (interactive)
  86   (calc-store-binary var "*" '*))
  87
  88 (defun calc-store-div (&optional var)
  89   (interactive)
  90   (calc-store-binary var "/" '/))
  91
  92 (defun calc-store-power (&optional var)
  93   (interactive)
  94   (calc-store-binary var "^" '^))
  95
  96 (defun calc-store-concat (&optional var)
  97   (interactive)
  98   (calc-store-binary var "|" '|))
  99
 100 (defun calc-store-neg (n &optional var)
 101   (interactive "p")
 102   (calc-store-binary var "n" '/ (- n)))
 103
 104 (defun calc-store-inv (n &optional var)
 105   (interactive "p")
 106   (calc-store-binary var "&" '^ (- n)))
 107
 108 (defun calc-store-incr (n &optional var)
 109   (interactive "p")
 110   (calc-store-binary var "n" '- (- n)))
 111
 112 (defun calc-store-decr (n &optional var)
 113   (interactive "p")
 114   (calc-store-binary var "n" '- n))
 115
 116 (defun calc-store-value (var value tag &optional pop)
 117   (let ((msg ""))
 118     (if var
 119         (let ((old (calc-var-value var)))
 120           (set var value)
 121           (if pop (or calc-store-keep (calc-pop-stack pop)))
 122           (calc-record-undo (list 'store (symbol-name var) old))
 123           (if tag
 124               (let ((calc-full-trail-vectors nil))
 125                 (calc-record value (format ">%s%s" tag (calc-var-name var)))))
 126           (cond
 127            ((and (memq var '(var-e var-i var-pi var-phi var-gamma))
 128                  (eq (car-safe old) 'special-const))
 129             (setq msg (format " (Note: Built-in definition of %s has been lost)"
 130                               (calc-var-name var))))
 131            ((and (memq var '(var-inf var-uinf var-nan))
 132                  (null old))
 133             (setq msg (format " (Note: %s has built-in meanings which may interfere)"
 134                               (calc-var-name var)))))
 135           (calc-refresh-evaltos var)))
 136     msg))
 137
 138 (defun calc-var-name (var)
 139   (if (symbolp var) (setq var (symbol-name var)))
 140   (if (string-match "\\`var-." var)
 141       (substring var 4)
 142     var))
 143
 144 (defun calc-store-binary (var tag func &optional val)
 145   (calc-wrapper
 146    (let ((calc-simplify-mode (if (eq calc-simplify-mode 'none)
 147                                  'num calc-simplify-mode))
 148          (value (or val (calc-top 1))))
 149      (or var (setq var (calc-read-var-name (format "Store %s: " tag))))
 150      (if var
 151          (let ((old (calc-var-value var)))
 152            (if (eq (car-safe old) 'special-const)
 153                (error "\"%s\" is a special constant" (calc-var-name var)))
 154            (if (not old)
 155                (if (memq var '(var-inf var-uinf var-nan))
 156                    (error "\"%s\" is a special variable" (calc-var-name var))
 157                  (error "No such variable: \"%s\"" (calc-var-name var))))
 158            (if (stringp old)
 159                (setq old (math-read-expr old)))
 160            (if (eq (car-safe old) 'error)
 161                (error "Bad format in variable contents: %s" (nth 2 old)))
 162            (calc-store-value var
 163                              (calc-normalize (if (calc-is-inverse)
 164                                                  (list func value old)
 165                                                (list func old value)))
 166                              tag (and (not val) 1))
 167            (message "Variable \"%s\" changed" (calc-var-name var)))))))
 168
 169 (defvar calc-var-name-map nil "Keymap for reading Calc variable names.")
 170 (if calc-var-name-map
 171     ()
 172   (setq calc-var-name-map (copy-keymap minibuffer-local-completion-map))
 173   (define-key calc-var-name-map " " 'self-insert-command)
 174   (mapcar (function
 175            (lambda (x)
 176              (define-key calc-var-name-map (char-to-string x)
 177                'calcVar-digit)))
 178           "0123456789")
 179   (mapcar (function
 180            (lambda (x)
 181              (define-key calc-var-name-map (char-to-string x)
 182                'calcVar-oper)))
 183           "+-*/^|"))
 184
 185 (defvar calc-store-opers)
 186
 187 (defun calc-read-var-name (prompt &optional calc-store-opers)
 188   (setq calc-given-value nil
 189         calc-aborted-prefix nil)
 190   (let ((var (concat
 191               "var-"
 192               (let ((minibuffer-completion-table
 193                      (mapcar (lambda (x) (substring x 4))
 194                              (all-completions "var-" obarray)))
 195                     (minibuffer-completion-predicate
 196                      (lambda (x) (boundp (intern (concat "var-" x)))))
 197                     (minibuffer-completion-confirm t))
 198                 (read-from-minibuffer prompt nil calc-var-name-map nil)))))
 199     (setq calc-aborted-prefix "")
 200     (and (not (equal var "var-"))
 201          (if (string-match "\\`\\([-a-zA-Z0-9]+\\) *:?=" var)
 202              (if (null calc-given-value-flag)
 203                  (error "Assignment is not allowed in this command")
 204                (let ((svar (intern (substring var 0 (match-end 1)))))
 205                  (setq calc-given-value-flag 0
 206                        calc-given-value (math-read-expr
 207                                          (substring var (match-end 0))))
 208                  (if (eq (car-safe calc-given-value) 'error)
 209                      (error "Bad format: %s" (nth 2 calc-given-value)))
 210                  (setq calc-given-value (math-evaluate-expr calc-given-value))
 211                  svar))
 212            (intern var)))))
 213
 214 (defun calcVar-digit ()
 215   (interactive)
 216   (if (calc-minibuffer-contains "\\'")
 217       (if (eq calc-store-opers 0)
 218           (beep)
 219         (insert "q")
 220         (self-insert-and-exit))
 221     (self-insert-command 1)))
 222
 223 (defun calcVar-oper ()
 224   (interactive)
 225   (if (and (eq calc-store-opers t)
 226            (calc-minibuffer-contains "\\'"))
 227       (progn
 228         (erase-buffer)
 229         (self-insert-and-exit))
 230     (self-insert-command 1)))
 231
 232 (defun calc-store-map (&optional oper var)
 233   (interactive)
 234   (calc-wrapper
 235    (let* ((sel-mode nil)
 236           (calc-dollar-values (mapcar 'calc-get-stack-element
 237                                       (nthcdr calc-stack-top calc-stack)))
 238           (calc-dollar-used 0)
 239           (oper (or oper (calc-get-operator "Store Mapping")))
 240           (nargs (car oper)))
 241      (or var (setq var (calc-read-var-name (format "Store Mapping %s: "
 242                                                    (nth 2 oper)))))
 243      (if var
 244          (let ((old (calc-var-value var)))
 245            (if (eq (car-safe old) 'special-const)
 246                (error "\"%s\" is a special constant" (calc-var-name var)))
 247            (if (not old)
 248                (if (memq var '(var-inf var-uinf var-nan))
 249                    (error "\"%s\" is a special variable" (calc-var-name var))
 250                  (error "No such variable: \"%s\"" (calc-var-name var))))
 251            (let ((calc-simplify-mode (if (eq calc-simplify-mode 'none)
 252                                          'num calc-simplify-mode))
 253                  (values (and (> nargs 1)
 254                               (calc-top-list (1- nargs) (1+ calc-dollar-used)))))
 255              (message "Working...")
 256              (calc-set-command-flag 'clear-message)
 257              (if (stringp old)
 258                  (setq old (math-read-expr old)))
 259              (if (eq (car-safe old) 'error)
 260                  (error "Bad format in variable contents: %s" (nth 2 old)))
 261              (setq values (if (calc-is-inverse)
 262                               (append values (list old))
 263                             (append (list old) values)))
 264              (calc-store-value var
 265                                (calc-normalize (cons (nth 1 oper) values))
 266                                (nth 2 oper)
 267                                (+ calc-dollar-used (1- nargs)))
 268              (message "Variable \"%s\" changed" (calc-var-name var))))))))
 269
 270
 271 (defun calc-store-exchange (&optional var)
 272   (interactive)
 273   (calc-wrapper
 274    (let ((calc-given-value nil)
 275          (calc-given-value-flag 1)
 276          top)
 277      (or var (setq var (calc-read-var-name "Exchange with: ")))
 278      (if var
 279          (let ((value (calc-var-value var)))
 280            (if (eq (car-safe value) 'special-const)
 281                (error "\"%s\" is a special constant" (calc-var-name var)))
 282            (if (not value)
 283                (if (memq var '(var-inf var-uinf var-nan))
 284                    (error "\"%s\" is a special variable" (calc-var-name var))
 285                  (error "No such variable: \"%s\"" (calc-var-name var))))
 286            (setq top (or calc-given-value (calc-top 1)))
 287            (calc-store-value var top nil)
 288            (calc-pop-push-record calc-given-value-flag
 289                                  (concat "<>" (calc-var-name var)) value))))))
 290
 291 (defun calc-unstore (&optional var)
 292   (interactive)
 293   (calc-wrapper
 294    (or var (setq var (calc-read-var-name "Unstore: ")))
 295    (if var
 296        (progn
 297          (and (memq var '(var-e var-i var-pi var-phi var-gamma))
 298               (eq (car-safe (calc-var-value var)) 'special-const)
 299               (message "(Note: Built-in definition of %s has been lost)" var))
 300          (if (and (boundp var) (symbol-value var))
 301              (message "Unstored variable \"%s\"" (calc-var-name var))
 302            (message "Variable \"%s\" remains unstored" (calc-var-name var)))
 303          (makunbound var)
 304          (calc-refresh-evaltos var)))))
 305
 306 (defun calc-let (&optional var)
 307   (interactive)
 308   (calc-wrapper
 309    (let* ((calc-given-value nil)
 310           (calc-given-value-flag 1)
 311           thing value)
 312      (or var (setq var (calc-read-var-name "Let variable: ")))
 313      (if calc-given-value
 314          (setq value calc-given-value
 315                thing (calc-top 1))
 316        (setq value (calc-top 1)
 317              thing (calc-top 2)))
 318      (setq var (if var
 319                    (list (cons var value))
 320                  (calc-is-assignments value)))
 321      (if var
 322          (calc-pop-push-record
 323           (1+ calc-given-value-flag)
 324           (concat "=" (calc-var-name (car (car var))))
 325           (let ((saved-val (mapcar (function
 326                                     (lambda (v)
 327                                       (and (boundp (car v))
 328                                            (symbol-value (car v)))))
 329                                    var)))
 330             (unwind-protect
 331                 (let ((vv var))
 332                   (while vv
 333                     (set (car (car vv)) (calc-normalize (cdr (car vv))))
 334                     (calc-refresh-evaltos (car (car vv)))
 335                     (setq vv (cdr vv)))
 336                   (math-evaluate-expr thing))
 337               (while saved-val
 338                 (if (car saved-val)
 339                     (set (car (car var)) (car saved-val))
 340                   (makunbound (car (car var))))
 341                 (setq saved-val (cdr saved-val)
 342                       var (cdr var)))
 343               (calc-handle-whys))))))))
 344
 345 (defun calc-is-assignments (value)
 346   (if (memq (car-safe value) '(calcFunc-eq calcFunc-assign))
 347       (and (eq (car-safe (nth 1 value)) 'var)
 348            (list (cons (nth 2 (nth 1 value)) (nth 2 value))))
 349     (if (eq (car-safe value) 'vec)
 350         (let ((vv nil))
 351           (while (and (setq value (cdr value))
 352                       (memq (car-safe (car value))
 353                             '(calcFunc-eq calcFunc-assign))
 354                       (eq (car-safe (nth 1 (car value))) 'var))
 355             (setq vv (cons (cons (nth 2 (nth 1 (car value)))
 356                                  (nth 2 (car value)))
 357                            vv)))
 358           (and (not value)
 359                vv)))))
 360
 361 (defun calc-recall (&optional var)
 362   (interactive)
 363   (calc-wrapper
 364    (or var (setq var (calc-read-var-name "Recall: ")))
 365    (if var
 366        (let ((value (calc-var-value var)))
 367          (or value
 368              (error "No such variable: \"%s\"" (calc-var-name var)))
 369          (if (stringp value)
 370              (setq value (math-read-expr value)))
 371          (if (eq (car-safe value) 'error)
 372              (error "Bad format in variable contents: %s" (nth 2 value)))
 373          (setq value (calc-normalize value))
 374          (let ((calc-full-trail-vectors nil))
 375            (calc-record value (concat "<" (calc-var-name var))))
 376          (calc-push value)))))
 377
 378 (defun calc-store-quick ()
 379   (interactive)
 380   (calc-store (intern (format "var-q%c" last-command-char))))
 381
 382 (defun calc-store-into-quick ()
 383   (interactive)
 384   (calc-store-into (intern (format "var-q%c" last-command-char))))
 385
 386 (defun calc-recall-quick ()
 387   (interactive)
 388   (calc-recall (intern (format "var-q%c" last-command-char))))
 389
 390 (defun calc-copy-special-constant (&optional sconst var)
 391   (interactive)
 392   (let ((sc '(("")
 393               ("e" . (special-const (math-e)))
 394               ("pi" . (special-const (math-pi)))
 395               ("i" . (special-const (math-imaginary 1)))
 396               ("phi" . (special-const (math-phi)))
 397               ("gamma" . (special-const (math-gamma-const))))))
 398   (calc-wrapper
 399    (or sconst (setq sconst (completing-read "Special constant: " sc nil t)))
 400    (unless (string= sconst "")
 401      (let ((value (cdr (assoc sconst sc))))
 402        (or var (setq var (calc-read-var-name
 403                             (format "Copy special constant %s, to: "
 404                                     sconst))))
 405        (if var
 406            (let ((msg (calc-store-value var value "")))
 407              (message (concat "Special constant \"%s\" copied to \"%s\"" msg)
 408                       sconst (calc-var-name var)))))))))
 409
 410 (defun calc-copy-variable (&optional var1 var2)
 411   (interactive)
 412   (calc-wrapper
 413    (or var1 (setq var1 (calc-read-var-name "Copy variable: ")))
 414    (if var1
 415        (let ((value (calc-var-value var1)))
 416          (or value
 417              (error "No such variable: \"%s\"" (calc-var-name var1)))
 418          (or var2 (setq var2 (calc-read-var-name
 419                               (format "Copy variable: %s, to: "
 420                                       (calc-var-name var1)))))
 421          (if var2
 422              (let ((msg (calc-store-value var2 value "")))
 423                (message (concat "Variable \"%s\" copied to \"%s\"" msg)
 424                         (calc-var-name var1) (calc-var-name var2))))))))
 425
 426 (defvar calc-last-edited-variable nil)
 427 (defun calc-edit-variable (&optional var)
 428   (interactive)
 429   (calc-wrapper
 430    (or var (setq var (calc-read-var-name
 431                       (if calc-last-edited-variable
 432                           (format "Edit: (default %s) "
 433                                   (calc-var-name calc-last-edited-variable))
 434                         "Edit: "))))
 435    (or var (setq var calc-last-edited-variable))
 436    (if var
 437        (let* ((value (calc-var-value var)))
 438          (if (eq (car-safe value) 'special-const)
 439              (error "%s is a special constant" var))
 440          (setq calc-last-edited-variable var)
 441          (calc-edit-mode (list 'calc-finish-stack-edit (list 'quote var))
 442                          t
 443                          (concat "Editing variable `" (calc-var-name var) "'. "))
 444          (and value
 445               (insert (math-format-nice-expr value (frame-width)) "\n")))))
 446   (calc-show-edit-buffer))
 447
 448 (defun calc-edit-Decls ()
 449   (interactive)
 450   (calc-edit-variable 'var-Decls))
 451
 452 (defun calc-edit-EvalRules ()
 453   (interactive)
 454   (calc-edit-variable 'var-EvalRules))
 455
 456 (defun calc-edit-FitRules ()
 457   (interactive)
 458   (calc-edit-variable 'var-FitRules))
 459
 460 (defun calc-edit-GenCount ()
 461   (interactive)
 462   (calc-edit-variable 'var-GenCount))
 463
 464 (defun calc-edit-Holidays ()
 465   (interactive)
 466   (calc-edit-variable 'var-Holidays))
 467
 468 (defun calc-edit-IntegLimit ()
 469   (interactive)
 470   (calc-edit-variable 'var-IntegLimit))
 471
 472 (defun calc-edit-LineStyles ()
 473   (interactive)
 474   (calc-edit-variable 'var-LineStyles))
 475
 476 (defun calc-edit-PointStyles ()
 477   (interactive)
 478   (calc-edit-variable 'var-PointStyles))
 479
 480 (defun calc-edit-PlotRejects ()
 481   (interactive)
 482   (calc-edit-variable 'var-PlotRejects))
 483
 484 (defun calc-edit-AlgSimpRules ()
 485   (interactive)
 486   (calc-edit-variable 'var-AlgSimpRules))
 487
 488 (defun calc-edit-TimeZone ()
 489   (interactive)
 490   (calc-edit-variable 'var-TimeZone))
 491
 492 (defun calc-edit-Units ()
 493   (interactive)
 494   (calc-edit-variable 'var-Units))
 495
 496 (defun calc-edit-ExtSimpRules ()
 497   (interactive)
 498   (calc-edit-variable 'var-ExtSimpRules))
 499
 500 (defun calc-declare-variable (&optional var)
 501   (interactive)
 502   (calc-wrapper
 503    (or var (setq var (calc-read-var-name "Declare: " 0)))
 504    (or var (setq var 'var-All))
 505    (let* (dp decl def row rp)
 506      (or (and (calc-var-value 'var-Decls)
 507               (eq (car-safe var-Decls) 'vec))
 508          (setq var-Decls (list 'vec)))
 509      (setq dp var-Decls)
 510      (while (and (setq dp (cdr dp))
 511                  (or (not (eq (car-safe (car dp)) 'vec))
 512                      (/= (length (car dp)) 3)
 513                      (progn
 514                        (setq row (nth 1 (car dp))
 515                              rp row)
 516                        (if (eq (car-safe row) 'vec)
 517                            (progn
 518                              (while
 519                                  (and (setq rp (cdr rp))
 520                                       (or (not (eq (car-safe (car rp)) 'var))
 521                                           (not (eq (nth 2 (car rp)) var)))))
 522                              (setq rp (car rp)))
 523                          (if (or (not (eq (car-safe row) 'var))
 524                                  (not (eq (nth 2 row) var)))
 525                              (setq rp nil)))
 526                        (not rp)))))
 527      (calc-unread-command ?\C-a)
 528      (setq decl (read-string (format "Declare: %s  to be: " (calc-var-name var))
 529                              (and rp
 530                                   (math-format-flat-expr (nth 2 (car dp)) 0))))
 531      (setq decl (and (string-match "[^ \t]" decl)
 532                      (math-read-exprs decl)))
 533      (if (eq (car-safe decl) 'error)
 534          (error "Bad format in declaration: %s" (nth 2 decl)))
 535      (if (cdr decl)
 536          (setq decl (cons 'vec decl))
 537        (setq decl (car decl)))
 538      (and (eq (car-safe decl) 'vec)
 539           (= (length decl) 2)
 540           (setq decl (nth 1 decl)))
 541      (calc-record (append '(vec) (list (math-build-var-name var))
 542                           (and decl (list decl)))
 543                   "decl")
 544      (setq var-Decls (copy-sequence var-Decls))
 545      (if (eq (car-safe row) 'vec)
 546          (progn
 547            (setcdr row (delq rp (cdr row)))
 548            (or (cdr row)
 549                (setq var-Decls (delq (car dp) var-Decls))))
 550        (setq var-Decls (delq (car dp) var-Decls)))
 551      (if decl
 552          (progn
 553            (setq dp (and (not (eq var 'var-All)) var-Decls))
 554            (while (and (setq dp (cdr dp))
 555                        (or (not (eq (car-safe (car dp)) 'vec))
 556                            (/= (length (car dp)) 3)
 557                            (not (equal (nth 2 (car dp)) decl)))))
 558            (if dp
 559                (setcar (cdr (car dp))
 560                        (append (if (eq (car-safe (nth 1 (car dp))) 'vec)
 561                                    (nth 1 (car dp))
 562                                  (list 'vec (nth 1 (car dp))))
 563                                (list (math-build-var-name var))))
 564              (setq var-Decls (append var-Decls
 565                                      (list (list 'vec
 566                                                  (math-build-var-name var)
 567                                                  decl)))))))
 568      (calc-refresh-evaltos 'var-Decls))))
 569
 570 (defvar calc-dont-insert-variables '(var-FitRules var-FactorRules
 571                                      var-CommuteRules var-JumpRules
 572                                      var-DistribRules var-MergeRules
 573                                      var-NegateRules var-InvertRules
 574                                      var-IntegAfterRules
 575                                      var-TimeZone var-PlotRejects
 576                                      var-PlotData1 var-PlotData2
 577                                      var-PlotData3 var-PlotData4
 578                                      var-PlotData5 var-PlotData6
 579                                      var-DUMMY))
 580
 581 ;; The variable calc-pv-pos is local to calc-permanent-variable, but
 582 ;; used by calc-insert-permanent-variable, which is called by
 583 ;; calc-permanent-variable.
 584 (defvar calc-pv-pos)
 585
 586 (defun calc-permanent-variable (&optional var)
 587   (interactive)
 588   (calc-wrapper
 589    (or var (setq var (calc-read-var-name "Save variable (default=all): ")))
 590    (let (calc-pv-pos)
 591      (and var (or (and (boundp var) (symbol-value var))
 592                   (error "No such variable")))
 593      (set-buffer (find-file-noselect (substitute-in-file-name
 594                                       calc-settings-file)))
 595      (if var
 596          (calc-insert-permanent-variable var)
 597        (mapatoms (function
 598                   (lambda (x)
 599                     (and (string-match "\\`var-" (symbol-name x))
 600                          (not (memq x calc-dont-insert-variables))
 601                          (calc-var-value x)
 602                          (not (eq (car-safe (symbol-value x)) 'special-const))
 603                          (calc-insert-permanent-variable x))))))
 604      (save-buffer))))
 605
 606
 607
 608 (defun calc-insert-permanent-variable (var)
 609   (goto-char (point-min))
 610   (if (search-forward (concat "(setq " (symbol-name var) " '") nil t)
 611       (progn
 612         (setq calc-pv-pos (point-marker))
 613         (forward-line -1)
 614         (if (looking-at ";;; Variable .* stored by Calc on ")
 615             (progn
 616               (delete-region (match-end 0) (progn (end-of-line) (point)))
 617               (insert (current-time-string))))
 618         (goto-char (- calc-pv-pos 8 (length (symbol-name var))))
 619         (forward-sexp 1)
 620         (backward-char 1)
 621         (delete-region calc-pv-pos (point)))
 622     (goto-char (point-max))
 623     (insert "\n;;; Variable \""
 624             (symbol-name var)
 625             "\" stored by Calc on "
 626             (current-time-string)
 627             "\n(setq "
 628             (symbol-name var)
 629             " ')\n")
 630     (backward-char 2))
 631   (insert (prin1-to-string (calc-var-value var)))
 632   (forward-line 1))
 633
 634 (defun calc-insert-variables (buf)
 635   (interactive "bBuffer in which to save variable values: ")
 636   (save-excursion
 637     (set-buffer buf)
 638     (mapatoms (function
 639                (lambda (x)
 640                  (and (string-match "\\`var-" (symbol-name x))
 641                       (not (memq x calc-dont-insert-variables))
 642                       (calc-var-value x)
 643                       (not (eq (car-safe (symbol-value x)) 'special-const))
 644                       (or (not (eq x 'var-Decls))
 645                           (not (equal var-Decls '(vec))))
 646                       (or (not (eq x 'var-Holidays))
 647                           (not (equal var-Holidays '(vec (var sat var-sat)
 648                                                          (var sun var-sun)))))
 649                       (insert "(setq "
 650                               (symbol-name x)
 651                               " "
 652                               (prin1-to-string
 653                                (let ((calc-language
 654                                       (if (memq calc-language '(nil big))
 655                                           'flat
 656                                         calc-language)))
 657                                  (math-format-value (symbol-value x) 100000)))
 658                               ")\n")))))))
 659
 660 (defun calc-assign (arg)
 661   (interactive "P")
 662   (calc-slow-wrapper
 663    (calc-binary-op ":=" 'calcFunc-assign arg)))
 664
 665 (defun calc-evalto (arg)
 666   (interactive "P")
 667   (calc-slow-wrapper
 668    (calc-unary-op "=>" 'calcFunc-evalto arg)))
 669
 670 (defun calc-subscript (arg)
 671   (interactive "P")
 672   (calc-slow-wrapper
 673    (calc-binary-op "sub" 'calcFunc-subscr arg)))
 674
 675 (provide 'calc-store)
 676
 677 ;;; arch-tag: 2fbfec82-a521-42ca-bcd8-4f254ae6313e
 678 ;;; calc-store.el ends here