lisp/calc/calc-store.el

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