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