]> code.delx.au - gnu-emacs/blob - lisp/calculator.el
delx.au / code / gnu-emacs / blob
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
(calculator-copy-displayer): New user-option.
[gnu-emacs] / lisp / calculator.el
1 ;;; calculator.el --- a [not so] simple calculator for Emacs
2
3 ;; Copyright (C) 1998, 2000, 2001 by Free Software Foundation, Inc.
4
5 ;; Author: Eli Barzilay <eli@barzilay.org>
6 ;; Keywords: tools, convenience
7 ;; Time-stamp: <2001-09-23 02:24:35 eli>
8
9 ;; This file is part of GNU Emacs.
10
11 ;; GNU Emacs is free software; you can redistribute it and/or modify it
12 ;; under the terms of the GNU General Public License as published by the
13 ;; Free Software Foundation; either version 2, or (at your option) any
14 ;; later version.
15
16 ;; GNU Emacs is distributed in the hope that it will be useful, but
17 ;; WITHOUT ANY WARRANTY; without even the implied warranty of
18 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 ;; 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., 59 Temple Place - Suite 330, Boston,
24 ;; MA 02111-1307, USA.
25
26 ;;;=====================================================================
27 ;;; Commentary:
28 ;;
29 ;; A calculator for Emacs.
30 ;; Why should you reach for your mouse to get xcalc (calc.exe, gcalc or
31 ;; whatever), when you have Emacs running already?
32 ;;
33 ;; If this is not part of your Emacs distribution, then simply bind
34 ;; `calculator' to a key and make it an autoloaded function, e.g.:
35 ;; (autoload 'calculator "calculator"
36 ;; "Run the Emacs calculator." t)
37 ;; (global-set-key [(control return)] 'calculator)
38 ;;
39 ;; Written by Eli Barzilay: Maze is Life! eli@barzilay.org
40 ;; http://www.barzilay.org/
41 ;;
42 ;; For latest version, check
43 ;; http://www.barzilay.org/misc/calculator.el
44 ;;
45
46 ;;; History:
47 ;; I hate history.
48
49 (eval-and-compile
50 (if (fboundp 'defgroup) nil
51 (defmacro defgroup (&rest forms) nil)
52 (defmacro defcustom (s v d &rest r) (list 'defvar s v d))))
53
54 ;;;=====================================================================
55 ;;; Customization:
56
57 (defgroup calculator nil
58 "Simple Emacs calculator."
59 :prefix "calculator"
60 :version "21.1"
61 :group 'tools
62 :group 'convenience)
63
64 (defcustom calculator-electric-mode nil
65 "*Run `calculator' electrically, in the echo area.
66 Electric mode saves some place but changes the way you interact with the
67 calculator."
68 :type 'boolean
69 :group 'calculator)
70
71 (defcustom calculator-use-menu t
72 "*Make `calculator' create a menu.
73 Note that this requires easymenu. Must be set before loading."
74 :type 'boolean
75 :group 'calculator)
76
77 (defcustom calculator-bind-escape nil
78 "*If non-nil, set escape to exit the calculator."
79 :type 'boolean
80 :group 'calculator)
81
82 (defcustom calculator-unary-style 'postfix
83 "*Value is either 'prefix or 'postfix.
84 This determines the default behavior of unary operators."
85 :type '(choice (const prefix) (const postfix))
86 :group 'calculator)
87
88 (defcustom calculator-prompt "Calc=%s> "
89 "*The prompt used by the Emacs calculator.
90 It should contain a \"%s\" somewhere that will indicate the i/o radixes,
91 this string will be a two-character string as described in the
92 documentation for `calculator-mode'."
93 :type 'string
94 :group 'calculator)
95
96 (defcustom calculator-number-digits 3
97 "*The calculator's number of digits used for standard display.
98 Used by the `calculator-standard-display' function - it will use the
99 format string \"%.NC\" where this number is N and C is a character given
100 at runtime."
101 :type 'integer
102 :group 'calculator)
103
104 (defcustom calculator-remove-zeros t
105 "*Non-nil value means delete all redundant zero decimal digits.
106 If this value is not t, and not nil, redundant zeros are removed except
107 for one and if it is nil, nothing is removed.
108 Used by the `calculator-remove-zeros' function."
109 :type '(choice (const t) (const leave-decimal) (const nil))
110 :group 'calculator)
111
112 (defcustom calculator-displayer '(std ?n)
113 "*A displayer specification for numerical values.
114 This is the displayer used to show all numbers in an expression. Result
115 values will be displayed according to the first element of
116 `calculator-displayers'.
117
118 The displayer is a symbol, a string or an expression. A symbol should
119 be the name of a one-argument function, a string is used with a single
120 argument and an expression will be evaluated with the variable `num'
121 bound to whatever should be displayed. If it is a function symbol, it
122 should be able to handle special symbol arguments, currently 'left and
123 'right which will be sent by special keys to modify display parameters
124 associated with the displayer function (for example to change the number
125 of digits displayed).
126
127 An exception to the above is the case of the list (std C) where C is a
128 character, in this case the `calculator-standard-displayer' function
129 will be used with this character for a format string.")
130
131 (defcustom calculator-displayers
132 '(((std ?n) "Standard dislpay, decimal point or scientific")
133 (calculator-eng-display "Eng display")
134 ((std ?f) "Standard display, decimal point")
135 ((std ?e) "Standard dislpay, scientific")
136 ("%S" "Emacs printer"))
137 "*A list of displayers.
138 Each element is a list of a displayer and a description string. The
139 first element is the one which is curently used, this is for the display
140 of result values not values in expressions. A displayer specification
141 is the same as the values that can be stored in `calculator-displayer'.
142
143 `calculator-rotate-displayer' rotates this list."
144 :type 'sexp
145 :group 'calculator)
146
147 (defcustom calculator-paste-decimals t
148 "*If non-nil, convert pasted integers so they have a decimal point.
149 This makes it possible to paste big integers since they will be read as
150 floats, otherwise the Emacs reader will fail on them."
151 :type 'boolean
152 :group 'calculator)
153
154 (defcustom calculator-copy-displayer nil
155 "*If non-nil, this is any value that can be used for
156 `calculator-displayer', to format a string before copying it with
157 `calculator-copy'. If nil, then `calculator-displayer's normal value is
158 used.")
159
160 (defcustom calculator-2s-complement nil
161 "*If non-nil, show negative numbers in 2s complement in radix modes.
162 Otherwise show as a negative number."
163 :type 'boolean
164 :group 'calculator)
165
166 (defcustom calculator-mode-hook nil
167 "*List of hook functions for `calculator-mode' to run."
168 :type 'hook
169 :group 'calculator)
170
171 (defcustom calculator-user-registers nil
172 "*An association list of user-defined register bindings.
173 Each element in this list is a list of a character and a number that
174 will be stored in that character's register.
175
176 For example, use this to define the golden ratio number:
177 (setq calculator-user-registers '((?g . 1.61803398875)))
178 before you load calculator."
179 :type '(repeat (cons character number))
180 :set '(lambda (_ val)
181 (and (boundp 'calculator-registers)
182 (setq calculator-registers
183 (append val calculator-registers)))
184 (setq calculator-user-registers val))
185 :group 'calculator)
186
187 (defcustom calculator-user-operators nil
188 "*A list of additional operators.
189 This is a list in the same format as specified in the documentation for
190 `calculator-operators', that you can use to bind additional calculator
191 operators. It is probably not a good idea to modify this value with
192 `customize' since it is too complex...
193
194 Examples:
195
196 * A very simple one, adding a postfix \"x-to-y\" conversion keys, using
197 t as a prefix key:
198
199 (setq calculator-user-operators
200 '((\"tf\" cl-to-fr (+ 32 (/ (* X 9) 5)) 1)
201 (\"tc\" fr-to-cl (/ (* (- X 32) 5) 9) 1)
202 (\"tp\" kg-to-lb (/ X 0.453592) 1)
203 (\"tk\" lb-to-kg (* X 0.453592) 1)
204 (\"tF\" mt-to-ft (/ X 0.3048) 1)
205 (\"tM\" ft-to-mt (* X 0.3048) 1)))
206
207 * Using a function-like form is very simple, X for an argument (Y the
208 second in case of a binary operator), TX is a truncated version of X
209 and F does a recursive call, Here is a [very inefficient] Fibonacci
210 number calculation:
211
212 (add-to-list 'calculator-user-operators
213 '(\"F\" fib (if (<= TX 1)
214 1
215 (+ (F (- TX 1)) (F (- TX 2)))) 0))
216
217 Note that this will be either postfix or prefix, according to
218 `calculator-unary-style'."
219 :type '(repeat (list string symbol sexp integer integer))
220 :group 'calculator)
221
222 ;;;=====================================================================
223 ;;; Code:
224
225 ;;;---------------------------------------------------------------------
226 ;;; Variables
227
228 (defvar calculator-initial-operators
229 '(;; "+"/"-" have keybindings of themselves, not calculator-ops
230 ("=" = identity 1 -1)
231 (nobind "+" + + 2 4)
232 (nobind "-" - - 2 4)
233 (nobind "+" + + -1 9)
234 (nobind "-" - - -1 9)
235 ("(" \( identity -1 -1)
236 (")" \) identity +1 10)
237 ;; normal keys
238 ("|" or (logior TX TY) 2 2)
239 ("#" xor (logxor TX TY) 2 2)
240 ("&" and (logand TX TY) 2 3)
241 ("*" * * 2 5)
242 ("/" / / 2 5)
243 ("\\" div (/ TX TY) 2 5)
244 ("%" rem (% TX TY) 2 5)
245 ("L" log log 2 6)
246 ("S" sin (sin DX) x 6)
247 ("C" cos (cos DX) x 6)
248 ("T" tan (tan DX) x 6)
249 ("IS" asin (D (asin X)) x 6)
250 ("IC" acos (D (acos X)) x 6)
251 ("IT" atan (D (atan X)) x 6)
252 ("Q" sqrt sqrt x 7)
253 ("^" ^ expt 2 7)
254 ("!" ! calculator-fact x 7)
255 (";" 1/ (/ 1 X) 1 7)
256 ("_" - - 1 8)
257 ("~" ~ (lognot TX) x 8)
258 (">" repR calculator-repR 1 8)
259 ("<" repL calculator-repL 1 8)
260 ("v" avg (/ (apply '+ L) (length L)) 0 8)
261 ("l" tot (apply '+ L) 0 8)
262 )
263 "A list of initial operators.
264 This is a list in the same format as `calculator-operators'. Whenever
265 `calculator' starts, it looks at the value of this variable, and if it
266 is not empty, its contents is prepended to `calculator-operators' and
267 the appropriate key bindings are made.
268
269 This variable is then reset to nil. Don't use this if you want to add
270 user-defined operators, use `calculator-user-operators' instead.")
271
272 (defvar calculator-operators nil
273 "The calculator operators, each a list with:
274
275 1. The key that is bound to for this operation (usually a string);
276
277 2. The displayed symbol for this function;
278
279 3. The function symbol, or a form that uses the variables `X' and `Y',
280 (if it is a binary operator), `TX' and `TY' (truncated integer
281 versions), `DX' (converted to radians if degrees mode is on), `D'
282 (function for converting radians to degrees if deg mode is on), `L'
283 (list of saved values), `F' (function for recursive iteration calls)
284 and evaluates to the function value - these variables are capital;
285
286 4. The function's arity, optional, one of: 2 => binary, -1 => prefix
287 unary, +1 => postfix unary, 0 => a 0-arg operator func, non-number =>
288 postfix/prefix as determined by `calculator-unary-style' (the
289 default);
290
291 5. The function's precedence - should be in the range of 1 (lowest) to
292 9 (highest) (optional, defaults to 1);
293
294 It it possible have a unary prefix version of a binary operator if it
295 comes later in this list. If the list begins with the symbol 'nobind,
296 then no key binding will take place - this is only useful for predefined
297 keys.
298
299 Use `calculator-user-operators' to add operators to this list, see its
300 documentation for an example.")
301
302 (defvar calculator-stack nil
303 "Stack contents - operations and operands.")
304
305 (defvar calculator-curnum nil
306 "Current number being entered (as a string).")
307
308 (defvar calculator-stack-display nil
309 "Cons of the stack and its string representation.")
310
311 (defvar calculator-char-radix
312 '((?D . nil) (?B . bin) (?O . oct) (?H . hex) (?X . hex))
313 "A table to convert input characters to corresponding radix symbols.")
314
315 (defvar calculator-output-radix nil
316 "The mode for display, one of: nil (decimal), 'bin, 'oct or 'hex.")
317
318 (defvar calculator-input-radix nil
319 "The mode for input, one of: nil (decimal), 'bin, 'oct or 'hex.")
320
321 (defvar calculator-deg nil
322 "Non-nil if trig functions operate on degrees instead of radians.")
323
324 (defvar calculator-saved-list nil
325 "A list of saved values collected.")
326
327 (defvar calculator-saved-ptr 0
328 "The pointer to the current saved number.")
329
330 (defvar calculator-add-saved nil
331 "Bound to t when a value should be added to the saved-list.")
332
333 (defvar calculator-display-fragile nil
334 "When non-nil, we see something that the next digit should replace.")
335
336 (defvar calculator-buffer nil
337 "The current calculator buffer.")
338
339 (defvar calculator-eng-extra nil
340 "Internal value used by `calculator-eng-display'.")
341
342 (defvar calculator-eng-tmp-show nil
343 "Internal value used by `calculator-eng-display'.")
344
345 (defvar calculator-last-opXY nil
346 "The last binary operation and its arguments.
347 Used for repeating operations in calculator-repR/L.")
348
349 (defvar calculator-registers ; use user-bindings first
350 (append calculator-user-registers (list (cons ?e e) (cons ?p pi)))
351 "The association list of calculator register values.")
352
353 (defvar calculator-saved-global-map nil
354 "Saved global key map.")
355
356 (defvar calculator-restart-other-mode nil
357 "Used to hack restarting with the electric mode changed.")
358
359 ;;;---------------------------------------------------------------------
360 ;;; Key bindings
361
362 (defvar calculator-mode-map nil
363 "The calculator key map.")
364
365 (or calculator-mode-map
366 (let ((map (make-sparse-keymap)))
367 (suppress-keymap map t)
368 (define-key map "i" nil)
369 (define-key map "o" nil)
370 (let ((p
371 '((calculator-open-paren "[")
372 (calculator-close-paren "]")
373 (calculator-op-or-exp "+" "-" [kp-add] [kp-subtract])
374 (calculator-digit "0" "1" "2" "3" "4" "5" "6" "7" "8"
375 "9" "a" "b" "c" "d" "f"
376 [kp-0] [kp-1] [kp-2] [kp-3] [kp-4]
377 [kp-5] [kp-6] [kp-7] [kp-8] [kp-9])
378 (calculator-op [kp-divide] [kp-multiply])
379 (calculator-decimal "." [kp-decimal])
380 (calculator-exp "e")
381 (calculator-dec/deg-mode "D")
382 (calculator-set-register "s")
383 (calculator-get-register "g")
384 (calculator-radix-mode "H" "X" "O" "B")
385 (calculator-radix-input-mode "id" "ih" "ix" "io" "ib"
386 "iD" "iH" "iX" "iO" "iB")
387 (calculator-radix-output-mode "od" "oh" "ox" "oo" "ob"
388 "oD" "oH" "oX" "oO" "oB")
389 (calculator-rotate-displayer "'")
390 (calculator-rotate-displayer-back "\"")
391 (calculator-displayer-pref "{")
392 (calculator-displayer-next "}")
393 (calculator-saved-up [up] [?\C-p])
394 (calculator-saved-down [down] [?\C-n])
395 (calculator-quit "q" [?\C-g])
396 (calculator-enter [enter] [linefeed] [kp-enter]
397 [return] [?\r] [?\n])
398 (calculator-save-on-list " " [space])
399 (calculator-clear-saved [?\C-c] [(control delete)])
400 (calculator-save-and-quit [(control return)]
401 [(control kp-enter)])
402 (calculator-paste [insert] [(shift insert)]
403 [mouse-2])
404 (calculator-clear [delete] [?\C-?] [?\C-d])
405 (calculator-help [?h] [??] [f1] [help])
406 (calculator-copy [(control insert)])
407 (calculator-backspace [backspace])
408 )))
409 (while p
410 ;; reverse the keys so first defs come last - makes the more
411 ;; sensible bindings visible in the menu
412 (let ((func (car (car p))) (keys (reverse (cdr (car p)))))
413 (while keys
414 (define-key map (car keys) func)
415 (setq keys (cdr keys))))
416 (setq p (cdr p))))
417 (if calculator-bind-escape
418 (progn (define-key map [?\e] 'calculator-quit)
419 (define-key map [escape] 'calculator-quit))
420 (define-key map [?\e ?\e ?\e] 'calculator-quit))
421 ;; make C-h work in text-mode
422 (or window-system (define-key map [?\C-h] 'calculator-backspace))
423 ;; set up a menu
424 (if (and calculator-use-menu (not (boundp 'calculator-menu)))
425 (let ((radix-selectors
426 (mapcar (lambda (x)
427 `([,(nth 0 x)
428 (calculator-radix-mode ,(nth 2 x))
429 :style radio
430 :keys ,(nth 2 x)
431 :selected
432 (and
433 (eq calculator-input-radix ',(nth 1 x))
434 (eq calculator-output-radix ',(nth 1 x)))]
435 [,(concat (nth 0 x) " Input")
436 (calculator-radix-input-mode ,(nth 2 x))
437 :keys ,(concat "i" (downcase (nth 2 x)))
438 :style radio
439 :selected
440 (eq calculator-input-radix ',(nth 1 x))]
441 [,(concat (nth 0 x) " Output")
442 (calculator-radix-output-mode ,(nth 2 x))
443 :keys ,(concat "o" (downcase (nth 2 x)))
444 :style radio
445 :selected
446 (eq calculator-output-radix ',(nth 1 x))]))
447 '(("Decimal" nil "D")
448 ("Binary" bin "B")
449 ("Octal" oct "O")
450 ("Hexadecimal" hex "H"))))
451 (op '(lambda (name key)
452 `[,name (calculator-op ,key) :keys ,key])))
453 (easy-menu-define
454 calculator-menu map "Calculator menu."
455 `("Calculator"
456 ["Help"
457 (let ((last-command 'calculator-help)) (calculator-help))
458 :keys "?"]
459 "---"
460 ["Copy" calculator-copy]
461 ["Paste" calculator-paste]
462 "---"
463 ["Electric mode"
464 (progn (calculator-quit)
465 (setq calculator-restart-other-mode t)
466 (run-with-timer 0.1 nil '(lambda () (message nil)))
467 ;; the message from the menu will be visible,
468 ;; couldn't make it go away...
469 (calculator))
470 :active (not calculator-electric-mode)]
471 ["Normal mode"
472 (progn (setq calculator-restart-other-mode t)
473 (calculator-quit))
474 :active calculator-electric-mode]
475 "---"
476 ("Functions"
477 ,(funcall op "Repeat-right" ">")
478 ,(funcall op "Repeat-left" "<")
479 "------General------"
480 ,(funcall op "Reciprocal" ";")
481 ,(funcall op "Log" "L")
482 ,(funcall op "Square-root" "Q")
483 ,(funcall op "Factorial" "!")
484 "------Trigonometric------"
485 ,(funcall op "Sinus" "S")
486 ,(funcall op "Cosine" "C")
487 ,(funcall op "Tangent" "T")
488 ,(funcall op "Inv-Sinus" "IS")
489 ,(funcall op "Inv-Cosine" "IC")
490 ,(funcall op "Inv-Tangent" "IT")
491 "------Bitwise------"
492 ,(funcall op "Or" "|")
493 ,(funcall op "Xor" "#")
494 ,(funcall op "And" "&")
495 ,(funcall op "Not" "~"))
496 ("Saved List"
497 ["Eval+Save" calculator-save-on-list]
498 ["Prev number" calculator-saved-up]
499 ["Next number" calculator-saved-down]
500 ["Delete current" calculator-clear
501 :active (and calculator-display-fragile
502 calculator-saved-list
503 (= (car calculator-stack)
504 (nth calculator-saved-ptr
505 calculator-saved-list)))]
506 ["Delete all" calculator-clear-saved]
507 "---"
508 ,(funcall op "List-total" "l")
509 ,(funcall op "List-average" "v"))
510 ("Registers"
511 ["Get register" calculator-get-register]
512 ["Set register" calculator-set-register])
513 ("Modes"
514 ["Radians"
515 (progn
516 (and (or calculator-input-radix calculator-output-radix)
517 (calculator-radix-mode "D"))
518 (and calculator-deg (calculator-dec/deg-mode)))
519 :keys "D"
520 :style radio
521 :selected (not (or calculator-input-radix
522 calculator-output-radix
523 calculator-deg))]
524 ["Degrees"
525 (progn
526 (and (or calculator-input-radix calculator-output-radix)
527 (calculator-radix-mode "D"))
528 (or calculator-deg (calculator-dec/deg-mode)))
529 :keys "D"
530 :style radio
531 :selected (and calculator-deg
532 (not (or calculator-input-radix
533 calculator-output-radix)))]
534 "---"
535 ,@(mapcar 'car radix-selectors)
536 ("Seperate I/O"
537 ,@(mapcar (lambda (x) (nth 1 x)) radix-selectors)
538 "---"
539 ,@(mapcar (lambda (x) (nth 2 x)) radix-selectors)))
540 ("Decimal Dislpay"
541 ,@(mapcar (lambda (d)
542 (vector (cadr d)
543 ;; Note: inserts actual object here
544 `(calculator-rotate-displayer ',d)))
545 calculator-displayers)
546 "---"
547 ["Change Prev Display" calculator-displayer-prev]
548 ["Change Next Display" calculator-displayer-next])
549 "---"
550 ["Copy+Quit" calculator-save-and-quit]
551 ["Quit" calculator-quit]))))
552 (setq calculator-mode-map map)))
553
554 ;;;---------------------------------------------------------------------
555 ;;; Startup and mode stuff
556
557 (defun calculator-mode ()
558 ;; this help is also used as the major help screen
559 "A [not so] simple calculator for Emacs.
560
561 This calculator is used in the same way as other popular calculators
562 like xcalc or calc.exe - but using an Emacs interface.
563
564 Expressions are entered using normal infix notation, parens are used as
565 normal. Unary functions are usually postfix, but some depends on the
566 value of `calculator-unary-style' (if the style for an operator below is
567 specified, then it is fixed, otherwise it depends on this variable).
568 `+' and `-' can be used as either binary operators or prefix unary
569 operators. Numbers can be entered with exponential notation using `e',
570 except when using a non-decimal radix mode for input (in this case `e'
571 will be the hexadecimal digit).
572
573 Here are the editing keys:
574 * `RET' `=' evaluate the current expression
575 * `C-insert' copy the whole current expression to the `kill-ring'
576 * `C-return' evaluate, save result the `kill-ring' and exit
577 * `insert' paste a number if the one was copied (normally)
578 * `delete' `C-d' clear last argument or whole expression (hit twice)
579 * `backspace' delete a digit or a previous expression element
580 * `h' `?' pop-up a quick reference help
581 * `ESC' `q' exit (`ESC' can be used if `calculator-bind-escape' is
582 non-nil, otherwise use three consecutive `ESC's)
583
584 These operators are pre-defined:
585 * `+' `-' `*' `/' the common binary operators
586 * `\\' `%' integer division and reminder
587 * `_' `;' postfix unary negation and reciprocal
588 * `^' `L' binary operators for x^y and log(x) in base y
589 * `Q' `!' unary square root and factorial
590 * `S' `C' `T' unary trigonometric operators - sin, cos and tan
591 * `|' `#' `&' `~' bitwise operators - or, xor, and, not
592
593 The trigonometric functions can be inverted if prefixed with an `I', see
594 below for the way to use degrees instead of the default radians.
595
596 Two special postfix unary operators are `>' and `<': whenever a binary
597 operator is performed, it is remembered along with its arguments; then
598 `>' (`<') will apply the same operator with the same right (left)
599 argument.
600
601 hex/oct/bin modes can be set for input and for display separately.
602 Another toggle-able mode is for using degrees instead of radians for
603 trigonometric functions.
604 The keys to switch modes are (`X' is shortcut for `H'):
605 * `D' switch to all-decimal mode, or toggle degrees/radians
606 * `B' `O' `H' `X' binary/octal/hexadecimal modes for input & display
607 * `i' `o' followed by one of `D' `B' `O' `H' `X' (case
608 insensitive) sets only the input or display radix mode
609 The prompt indicates the current modes:
610 * \"D=\": degrees mode;
611 * \"?=\": (? is B/O/H) this is the radix for both input and output;
612 * \"=?\": (? is B/O/H) the display radix (when input is decimal);
613 * \"??\": (? is D/B/O/H) 1st char for input radix, 2nd for display.
614
615 Also, the quote character can be used to switch display modes for
616 decimal numbers (double-quote rotates back), and the two brace
617 characters (\"{\" and \"}\" change display parameters that these
618 displayers use (if they handle such).
619
620 Values can be saved for future reference in either a list of saved
621 values, or in registers.
622
623 The list of saved values is useful for statistics operations on some
624 collected data. It is possible to navigate in this list, and if the
625 value shown is the current one on the list, an indication is displayed
626 as \"[N]\" if this is the last number and there are N numbers, or
627 \"[M/N]\" if the M-th value is shown.
628 * `SPC' evaluate the current value as usual, but also adds
629 the result to the list of saved values
630 * `l' `v' computes total / average of saved values
631 * `up' `C-p' browse to the previous value in the list
632 * `down' `C-n' browse to the next value in the list
633 * `delete' `C-d' remove current value from the list (if it is on it)
634 * `C-delete' `C-c' delete the whole list
635
636 Registers are variable-like place-holders for values:
637 * `s' followed by a character attach the current value to that character
638 * `g' followed by a character fetches the attached value
639
640 There are many variables that can be used to customize the calculator.
641 Some interesting customization variables are:
642 * `calculator-electric-mode' use only the echo-area electrically.
643 * `calculator-unary-style' set most unary ops to pre/postfix style.
644 * `calculator-user-registers' to define user-preset registers.
645 * `calculator-user-operators' to add user-defined operators.
646 See the documentation for these variables, and \"calculator.el\" for
647 more information.
648
649 \\{calculator-mode-map}"
650 (interactive)
651 (kill-all-local-variables)
652 (setq major-mode 'calculator-mode)
653 (setq mode-name "Calculator")
654 (use-local-map calculator-mode-map)
655 (run-hooks 'calculator-mode-hook))
656
657 (eval-when-compile (require 'electric) (require 'ehelp))
658
659 ;;;###autoload
660 (defun calculator ()
661 "Run the Emacs calculator.
662 See the documentation for `calculator-mode' for more information."
663 (interactive)
664 (if calculator-restart-other-mode
665 (setq calculator-electric-mode (not calculator-electric-mode)))
666 (if calculator-initial-operators
667 (progn (calculator-add-operators calculator-initial-operators)
668 (setq calculator-initial-operators nil)
669 ;; don't change this since it is a customization variable,
670 ;; its set function will add any new operators
671 (calculator-add-operators calculator-user-operators)))
672 (if calculator-electric-mode
673 (save-window-excursion
674 (progn (require 'electric) (message nil)) ; hide load message
675 (let (old-g-map old-l-map (echo-keystrokes 0)
676 (garbage-collection-messages nil)) ; no gc msg when electric
677 ;; strange behavior in FSF: doesn't always select correct
678 ;; minibuffer. I have no idea how to fix this
679 (setq calculator-buffer (window-buffer (minibuffer-window)))
680 (select-window (minibuffer-window))
681 (calculator-reset)
682 (calculator-update-display)
683 (setq old-l-map (current-local-map))
684 (setq old-g-map (current-global-map))
685 (setq calculator-saved-global-map (current-global-map))
686 (use-local-map nil)
687 (use-global-map calculator-mode-map)
688 (unwind-protect
689 (catch 'calculator-done
690 (Electric-command-loop
691 'calculator-done
692 ;; can't use 'noprompt, bug in electric.el
693 '(lambda () 'noprompt)
694 nil
695 (lambda (x y) (calculator-update-display))))
696 (and calculator-buffer
697 (catch 'calculator-done (calculator-quit)))
698 (use-local-map old-l-map)
699 (use-global-map old-g-map))))
700 (progn
701 (setq calculator-buffer (get-buffer-create "*calculator*"))
702 (cond
703 ((not (get-buffer-window calculator-buffer))
704 (let ((split-window-keep-point nil)
705 (window-min-height 2))
706 ;; maybe leave two lines for our window because of the normal
707 ;; `raised' modeline in Emacs 21
708 (select-window
709 (split-window-vertically
710 (if (and (fboundp 'face-attr-construct)
711 (plist-get (face-attr-construct 'modeline) :box))
712 -3 -2)))
713 (switch-to-buffer calculator-buffer)))
714 ((not (eq (current-buffer) calculator-buffer))
715 (select-window (get-buffer-window calculator-buffer))))
716 (calculator-mode)
717 (setq buffer-read-only t)
718 (calculator-reset)
719 (message "Hit `?' For a quick help screen.")))
720 (if (and calculator-restart-other-mode calculator-electric-mode)
721 (calculator)))
722
723 ;;;---------------------------------------------------------------------
724 ;;; Operatos
725
726 (defun calculator-op-arity (op)
727 "Return OP's arity, 2, +1 or -1."
728 (let ((arity (or (nth 3 op) 'x)))
729 (if (numberp arity)
730 arity
731 (if (eq calculator-unary-style 'postfix) +1 -1))))
732
733 (defun calculator-op-prec (op)
734 "Return OP's precedence for reducing when inserting into the stack.
735 Defaults to 1."
736 (or (nth 4 op) 1))
737
738 (defun calculator-add-operators (more-ops)
739 "This function handles operator addition.
740 Adds MORE-OPS to `calculator-operator', called initially to handle
741 `calculator-initial-operators' and `calculator-user-operators'."
742 (let ((added-ops nil))
743 (while more-ops
744 (or (eq (car (car more-ops)) 'nobind)
745 (let ((i -1) (key (car (car more-ops))))
746 ;; make sure the key is undefined, so it's easy to define
747 ;; prefix keys
748 (while (< (setq i (1+ i)) (length key))
749 (or (keymapp
750 (lookup-key calculator-mode-map
751 (substring key 0 (1+ i))))
752 (progn
753 (define-key
754 calculator-mode-map (substring key 0 (1+ i)) nil)
755 (setq i (length key)))))
756 (define-key calculator-mode-map key 'calculator-op)))
757 (setq added-ops (cons (if (eq (car (car more-ops)) 'nobind)
758 (cdr (car more-ops))
759 (car more-ops))
760 added-ops))
761 (setq more-ops (cdr more-ops)))
762 ;; added-ops come first, but in correct order
763 (setq calculator-operators
764 (append (nreverse added-ops) calculator-operators))))
765
766 ;;;---------------------------------------------------------------------
767 ;;; Display stuff
768
769 (defun calculator-reset ()
770 "Reset calculator variables."
771 (or calculator-restart-other-mode
772 (setq calculator-stack nil
773 calculator-curnum nil
774 calculator-stack-display nil
775 calculator-display-fragile nil))
776 (setq calculator-restart-other-mode nil)
777 (calculator-update-display))
778
779 (defun calculator-get-prompt ()
780 "Return a string to display.
781 The string is set not to exceed the screen width."
782 (let* ((calculator-prompt
783 (format calculator-prompt
784 (cond
785 ((or calculator-output-radix calculator-input-radix)
786 (if (eq calculator-output-radix
787 calculator-input-radix)
788 (concat
789 (char-to-string
790 (car (rassq calculator-output-radix
791 calculator-char-radix)))
792 "=")
793 (concat
794 (if calculator-input-radix
795 (char-to-string
796 (car (rassq calculator-input-radix
797 calculator-char-radix)))
798 "=")
799 (char-to-string
800 (car (rassq calculator-output-radix
801 calculator-char-radix))))))
802 (calculator-deg "D=")
803 (t "=="))))
804 (prompt
805 (concat calculator-prompt
806 (cdr calculator-stack-display)
807 (cond (calculator-curnum
808 ;; number being typed
809 (concat calculator-curnum "_"))
810 ((and (= 1 (length calculator-stack))
811 calculator-display-fragile)
812 ;; only the result is shown, next number will
813 ;; restart
814 nil)
815 (t
816 ;; waiting for a number or an operator
817 "?"))))
818 (trim (- (length prompt) (1- (window-width)))))
819 (if (<= trim 0)
820 prompt
821 (concat calculator-prompt
822 (substring prompt (+ trim (length calculator-prompt)))))))
823
824 (defun calculator-curnum-value ()
825 "Get the numeric value of the displayed number string as a float."
826 (if calculator-input-radix
827 (let ((radix
828 (cdr (assq calculator-input-radix
829 '((bin . 2) (oct . 8) (hex . 16)))))
830 (i -1) (value 0))
831 ;; assume valid input (upcased & characters in range)
832 (while (< (setq i (1+ i)) (length calculator-curnum))
833 (setq value
834 (+ (let ((ch (aref calculator-curnum i)))
835 (- ch (if (<= ch ?9) ?0 (- ?A 10))))
836 (* radix value))))
837 value)
838 (car
839 (read-from-string
840 (cond
841 ((equal "." calculator-curnum)
842 "0.0")
843 ((string-match "[eE][+-]?$" calculator-curnum)
844 (concat calculator-curnum "0"))
845 ((string-match "\\.[0-9]\\|[eE]" calculator-curnum)
846 calculator-curnum)
847 ((string-match "\\." calculator-curnum)
848 ;; do this because Emacs reads "23." as an integer
849 (concat calculator-curnum "0"))
850 ((stringp calculator-curnum)
851 (concat calculator-curnum ".0"))
852 (t "0.0"))))))
853
854 (defun calculator-rotate-displayer (&optional new-disp)
855 "Switch to the next displayer on the `calculator-displayers' list.
856 Can be called with an optional argument NEW-DISP to force rotation to
857 that argument."
858 (interactive)
859 (setq calculator-displayers
860 (if (and new-disp (memq new-disp calculator-displayers))
861 (let ((tmp nil))
862 (while (not (eq (car calculator-displayers) new-disp))
863 (setq tmp (cons (car calculator-displayers) tmp))
864 (setq calculator-displayers (cdr calculator-displayers)))
865 (setq calculator-displayers
866 (nconc calculator-displayers (nreverse tmp))))
867 (nconc (cdr calculator-displayers)
868 (list (car calculator-displayers)))))
869 (message "Using %s." (cadr (car calculator-displayers)))
870 (if calculator-electric-mode
871 (progn (sit-for 1) (message nil)))
872 (calculator-enter))
873
874 (defun calculator-rotate-displayer-back ()
875 "Like `calculator-rotate-displayer', but rotates modes back."
876 (interactive)
877 (calculator-rotate-displayer (car (last calculator-displayers))))
878
879 (defun calculator-displayer-prev ()
880 "Send the current displayer function a 'left argument.
881 This is used to modify display arguments (if the current displayer
882 function supports this)."
883 (interactive)
884 (and (car calculator-displayers)
885 (let ((disp (caar calculator-displayers)))
886 (cond ((symbolp disp) (funcall disp 'left))
887 ((and (consp disp) (eq 'std (car disp)))
888 (calculator-standard-displayer 'left (cadr disp)))))))
889
890 (defun calculator-displayer-next ()
891 "Send the current displayer function a 'right argument.
892 This is used to modify display arguments (if the current displayer
893 function supports this)."
894 (interactive)
895 (and (car calculator-displayers)
896 (let ((disp (caar calculator-displayers)))
897 (cond ((symbolp disp) (funcall disp 'right))
898 ((and (consp disp) (eq 'std (car disp)))
899 (calculator-standard-displayer 'right (cadr disp)))))))
900
901 (defun calculator-remove-zeros (numstr)
902 "Get a number string NUMSTR and remove unnecessary zeroes.
903 the behavior of this function is controlled by
904 `calculator-remove-zeros'."
905 (cond ((and (eq calculator-remove-zeros t)
906 (string-match "\\.0+\\([eE][+-]?[0-9]*\\)?$" numstr))
907 ;; remove all redundant zeros leaving an integer
908 (if (match-beginning 1)
909 (concat (substring numstr 0 (match-beginning 0))
910 (match-string 1 numstr))
911 (substring numstr 0 (match-beginning 0))))
912 ((and calculator-remove-zeros
913 (string-match
914 "\\..\\([0-9]*[1-9]\\)?\\(0+\\)\\([eE][+-]?[0-9]*\\)?$"
915 numstr))
916 ;; remove zeros, except for first after the "."
917 (if (match-beginning 3)
918 (concat (substring numstr 0 (match-beginning 2))
919 (match-string 3 numstr))
920 (substring numstr 0 (match-beginning 2))))
921 (t numstr)))
922
923 (defun calculator-standard-displayer (num char)
924 "Standard display function, used to display NUM.
925 Its behavior is determined by `calculator-number-digits' and the given
926 CHAR argument (both will be used to compose a format string). If the
927 char is \"n\" then this function will choose one between %f or %e, this
928 is a work around %g jumping to exponential notation too fast.
929
930 The special 'left and 'right symbols will make it change the current
931 number of digits displayed (`calculator-number-digits').
932
933 It will also remove redundant zeros from the result."
934 (if (symbolp num)
935 (cond ((eq num 'left)
936 (and (> calculator-number-digits 0)
937 (setq calculator-number-digits
938 (1- calculator-number-digits))
939 (calculator-enter)))
940 ((eq num 'right)
941 (setq calculator-number-digits
942 (1+ calculator-number-digits))
943 (calculator-enter)))
944 (let ((str (if (zerop num)
945 "0"
946 (format
947 (concat "%."
948 (number-to-string calculator-number-digits)
949 (if (eq char ?n)
950 (let ((n (abs num)))
951 (if (or (< n 0.001) (> n 1e8)) "e" "f"))
952 (string char)))
953 num))))
954 (calculator-remove-zeros str))))
955
956 (defun calculator-eng-display (num)
957 "Display NUM in engineering notation.
958 The number of decimal digits used is controlled by
959 `calculator-number-digits', so to change it at runtime you have to use
960 the 'left or 'right when one of the standard modes is used."
961 (if (symbolp num)
962 (cond ((eq num 'left)
963 (setq calculator-eng-extra
964 (if calculator-eng-extra
965 (1+ calculator-eng-extra)
966 1))
967 (let ((calculator-eng-tmp-show t)) (calculator-enter)))
968 ((eq num 'right)
969 (setq calculator-eng-extra
970 (if calculator-eng-extra
971 (1- calculator-eng-extra)
972 -1))
973 (let ((calculator-eng-tmp-show t)) (calculator-enter))))
974 (let ((exp 0))
975 (and (not (= 0 num))
976 (progn
977 (while (< (abs num) 1.0)
978 (setq num (* num 1000.0)) (setq exp (- exp 3)))
979 (while (> (abs num) 999.0)
980 (setq num (/ num 1000.0)) (setq exp (+ exp 3)))
981 (and calculator-eng-tmp-show
982 (not (= 0 calculator-eng-extra))
983 (let ((i calculator-eng-extra))
984 (while (> i 0)
985 (setq num (* num 1000.0)) (setq exp (- exp 3))
986 (setq i (1- i)))
987 (while (< i 0)
988 (setq num (/ num 1000.0)) (setq exp (+ exp 3))
989 (setq i (1+ i)))))))
990 (or calculator-eng-tmp-show (setq calculator-eng-extra nil))
991 (let ((str (format (concat "%." calculator-number-digits "f")
992 num)))
993 (concat (let ((calculator-remove-zeros
994 ;; make sure we don't leave integers
995 (and calculator-remove-zeros 'x)))
996 (calculator-remove-zeros str))
997 "e" (number-to-string exp))))))
998
999 (defun calculator-num-to-string (num)
1000 "Convert NUM to a displayable string."
1001 (cond
1002 ((and (numberp num) calculator-output-radix)
1003 ;; print with radix - for binary I convert the octal number
1004 (let ((str (format (if (eq calculator-output-radix 'hex) "%x" "%o")
1005 (calculator-truncate
1006 (if calculator-2s-complement num (abs num))))))
1007 (if (eq calculator-output-radix 'bin)
1008 (let ((i -1) (s ""))
1009 (while (< (setq i (1+ i)) (length str))
1010 (setq s
1011 (concat s
1012 (cdr (assq (aref str i)
1013 '((?0 . "000") (?1 . "001")
1014 (?2 . "010") (?3 . "011")
1015 (?4 . "100") (?5 . "101")
1016 (?6 . "110") (?7 . "111")))))))
1017 (string-match "^0*\\(.+\\)" s)
1018 (setq str (match-string 1 s))))
1019 (upcase
1020 (if (and (not calculator-2s-complement) (< num 0))
1021 (concat "-" str)
1022 str))))
1023 ((and (numberp num) calculator-displayer)
1024 (cond
1025 ((stringp calculator-displayer)
1026 (format calculator-displayer num))
1027 ((symbolp calculator-displayer)
1028 (funcall calculator-displayer num))
1029 ((and (consp calculator-displayer)
1030 (eq 'std (car calculator-displayer)))
1031 (calculator-standard-displayer num (cadr calculator-displayer)))
1032 ((listp calculator-displayer)
1033 (eval calculator-displayer))
1034 (t (prin1-to-string num t))))
1035 ;; operators are printed here
1036 (t (prin1-to-string (nth 1 num) t))))
1037
1038 (defun calculator-update-display (&optional force)
1039 "Update the display.
1040 If optional argument FORCE is non-nil, don't use the cached string."
1041 (set-buffer calculator-buffer)
1042 ;; update calculator-stack-display
1043 (if (or force
1044 (not (eq (car calculator-stack-display) calculator-stack)))
1045 (setq calculator-stack-display
1046 (cons calculator-stack
1047 (if calculator-stack
1048 (concat
1049 (let ((calculator-displayer
1050 (if (and calculator-displayers
1051 (= 1 (length calculator-stack)))
1052 ;; customizable display for a single value
1053 (caar calculator-displayers)
1054 calculator-displayer)))
1055 (mapconcat 'calculator-num-to-string
1056 (reverse calculator-stack)
1057 " "))
1058 " "
1059 (and calculator-display-fragile
1060 calculator-saved-list
1061 (= (car calculator-stack)
1062 (nth calculator-saved-ptr
1063 calculator-saved-list))
1064 (if (= 0 calculator-saved-ptr)
1065 (format "[%s]" (length calculator-saved-list))
1066 (format "[%s/%s]"
1067 (- (length calculator-saved-list)
1068 calculator-saved-ptr)
1069 (length calculator-saved-list)))))
1070 ""))))
1071 (let ((inhibit-read-only t))
1072 (erase-buffer)
1073 (insert (calculator-get-prompt)))
1074 (set-buffer-modified-p nil)
1075 (if calculator-display-fragile
1076 (goto-char (1+ (length calculator-prompt)))
1077 (goto-char (1- (point)))))
1078
1079 ;;;---------------------------------------------------------------------
1080 ;;; Stack computations
1081
1082 (defun calculator-reduce-stack (prec)
1083 "Reduce the stack using top operator.
1084 PREC is a precedence - reduce everything with higher precedence."
1085 (while
1086 (cond
1087 ((and (cdr (cdr calculator-stack)) ; have three values
1088 (consp (nth 0 calculator-stack)) ; two operators & num
1089 (numberp (nth 1 calculator-stack))
1090 (consp (nth 2 calculator-stack))
1091 (eq '\) (nth 1 (nth 0 calculator-stack)))
1092 (eq '\( (nth 1 (nth 2 calculator-stack))))
1093 ;; reduce "... ( x )" --> "... x"
1094 (setq calculator-stack
1095 (cons (nth 1 calculator-stack)
1096 (nthcdr 3 calculator-stack)))
1097 ;; another iteration
1098 t)
1099 ((and (cdr (cdr calculator-stack)) ; have three values
1100 (numberp (nth 0 calculator-stack)) ; two nums & operator
1101 (consp (nth 1 calculator-stack))
1102 (numberp (nth 2 calculator-stack))
1103 (= 2 (calculator-op-arity ; binary operator
1104 (nth 1 calculator-stack)))
1105 (<= prec ; with higher prec.
1106 (calculator-op-prec (nth 1 calculator-stack))))
1107 ;; reduce "... x op y" --> "... r", r is the result
1108 (setq calculator-stack
1109 (cons (calculator-funcall
1110 (nth 2 (nth 1 calculator-stack))
1111 (nth 2 calculator-stack)
1112 (nth 0 calculator-stack))
1113 (nthcdr 3 calculator-stack)))
1114 ;; another iteration
1115 t)
1116 ((and (>= (length calculator-stack) 2) ; have two values
1117 (numberp (nth 0 calculator-stack)) ; number & operator
1118 (consp (nth 1 calculator-stack))
1119 (= -1 (calculator-op-arity ; prefix-unary op
1120 (nth 1 calculator-stack)))
1121 (<= prec ; with higher prec.
1122 (calculator-op-prec (nth 1 calculator-stack))))
1123 ;; reduce "... op x" --> "... r" for prefix op
1124 (setq calculator-stack
1125 (cons (calculator-funcall
1126 (nth 2 (nth 1 calculator-stack))
1127 (nth 0 calculator-stack))
1128 (nthcdr 2 calculator-stack)))
1129 ;; another iteration
1130 t)
1131 ((and (cdr calculator-stack) ; have two values
1132 (consp (nth 0 calculator-stack)) ; operator & number
1133 (numberp (nth 1 calculator-stack))
1134 (= +1 (calculator-op-arity ; postfix-unary op
1135 (nth 0 calculator-stack)))
1136 (<= prec ; with higher prec.
1137 (calculator-op-prec (nth 0 calculator-stack))))
1138 ;; reduce "... x op" --> "... r" for postfix op
1139 (setq calculator-stack
1140 (cons (calculator-funcall
1141 (nth 2 (nth 0 calculator-stack))
1142 (nth 1 calculator-stack))
1143 (nthcdr 2 calculator-stack)))
1144 ;; another iteration
1145 t)
1146 ((and calculator-stack ; have one value
1147 (consp (nth 0 calculator-stack)) ; an operator
1148 (= 0 (calculator-op-arity ; 0-ary op
1149 (nth 0 calculator-stack))))
1150 ;; reduce "... op" --> "... r" for 0-ary op
1151 (setq calculator-stack
1152 (cons (calculator-funcall
1153 (nth 2 (nth 0 calculator-stack)))
1154 (nthcdr 1 calculator-stack)))
1155 ;; another iteration
1156 t)
1157 ((and (cdr calculator-stack) ; have two values
1158 (numberp (nth 0 calculator-stack)) ; both numbers
1159 (numberp (nth 1 calculator-stack)))
1160 ;; get rid of redundant numbers:
1161 ;; reduce "... y x" --> "... x"
1162 ;; needed for 0-ary ops that puts more values
1163 (setcdr calculator-stack (cdr (cdr calculator-stack))))
1164 (t ;; no more iterations
1165 nil))))
1166
1167 (defun calculator-funcall (f &optional X Y)
1168 "If F is a symbol, evaluate (F X Y).
1169 Otherwise, it should be a list, evaluate it with X, Y bound to the
1170 arguments."
1171 ;; remember binary ops for calculator-repR/L
1172 (if Y (setq calculator-last-opXY (list f X Y)))
1173 (condition-case nil
1174 ;; there used to be code here that returns 0 if the result was
1175 ;; smaller than calculator-epsilon (1e-15). I don't think this is
1176 ;; necessary now.
1177 (if (symbolp f)
1178 (cond ((and X Y) (funcall f X Y))
1179 (X (funcall f X))
1180 (t (funcall f)))
1181 ;; f is an expression
1182 (let* ((__f__ f) ; so we can get this value below...
1183 (TX (calculator-truncate X))
1184 (TY (and Y (calculator-truncate Y)))
1185 (DX (if calculator-deg (/ (* X pi) 180) X))
1186 (L calculator-saved-list)
1187 (Fbound (fboundp 'F))
1188 (Fsave (and Fbound (symbol-function 'F)))
1189 (Dbound (fboundp 'D))
1190 (Dsave (and Dbound (symbol-function 'D))))
1191 ;; a shortened version of flet
1192 (fset 'F (function
1193 (lambda (&optional x y)
1194 (calculator-funcall __f__ x y))))
1195 (fset 'D (function
1196 (lambda (x)
1197 (if calculator-deg (/ (* x 180) pi) x))))
1198 (unwind-protect (eval f)
1199 (if Fbound (fset 'F Fsave) (fmakunbound 'F))
1200 (if Dbound (fset 'D Dsave) (fmakunbound 'D)))))
1201 (error 0)))
1202
1203 (eval-when-compile ; silence the compiler
1204 (or (fboundp 'event-key)
1205 (defun event-key (&rest _) nil))
1206 (or (fboundp 'key-press-event-p)
1207 (defun key-press-event-p (&rest _) nil)))
1208
1209 ;;;---------------------------------------------------------------------
1210 ;;; Input interaction
1211
1212 (defun calculator-last-input (&optional keys)
1213 "Last char (or event or event sequence) that was read.
1214 Optional string argument KEYS will force using it as the keys entered."
1215 (let ((inp (or keys (this-command-keys))))
1216 (if (or (stringp inp) (not (arrayp inp)))
1217 inp
1218 ;; this translates kp-x to x and [tries to] create a string to
1219 ;; lookup operators
1220 (let* ((i -1) (converted-str (make-string (length inp) ? )) k)
1221 ;; converts an array to a string the ops lookup with keypad
1222 ;; input
1223 (while (< (setq i (1+ i)) (length inp))
1224 (setq k (aref inp i))
1225 ;; if Emacs will someday have a event-key, then this would
1226 ;; probably be modified anyway
1227 (and (fboundp 'event-key) (key-press-event-p k)
1228 (event-key k) (setq k (event-key k)))
1229 ;; assume all symbols are translatable with an ascii-character
1230 (and (symbolp k)
1231 (setq k (or (get k 'ascii-character) ? )))
1232 (aset converted-str i k))
1233 converted-str))))
1234
1235 (defun calculator-clear-fragile (&optional op)
1236 "Clear the fragile flag if it was set, then maybe reset all.
1237 OP is the operator (if any) that caused this call."
1238 (if (and calculator-display-fragile
1239 (or (not op)
1240 (= -1 (calculator-op-arity op))
1241 (= 0 (calculator-op-arity op))))
1242 ;; reset if last calc finished, and now get a num or prefix or 0-ary
1243 ;; op
1244 (calculator-reset))
1245 (setq calculator-display-fragile nil))
1246
1247 (defun calculator-digit ()
1248 "Enter a single digit."
1249 (interactive)
1250 (let ((inp (aref (calculator-last-input) 0)))
1251 (if (and (or calculator-display-fragile
1252 (not (numberp (car calculator-stack))))
1253 (cond
1254 ((not calculator-input-radix) (<= inp ?9))
1255 ((eq calculator-input-radix 'bin) (<= inp ?1))
1256 ((eq calculator-input-radix 'oct) (<= inp ?7))
1257 (t t)))
1258 ;; enter digit if starting a new computation or have an op on the
1259 ;; stack
1260 (progn
1261 (calculator-clear-fragile)
1262 (let ((digit (upcase (char-to-string inp))))
1263 (if (equal calculator-curnum "0")
1264 (setq calculator-curnum nil))
1265 (setq calculator-curnum
1266 (concat (or calculator-curnum "") digit)))
1267 (calculator-update-display)))))
1268
1269 (defun calculator-decimal ()
1270 "Enter a decimal period."
1271 (interactive)
1272 (if (and (not calculator-input-radix)
1273 (or calculator-display-fragile
1274 (not (numberp (car calculator-stack))))
1275 (not (and calculator-curnum
1276 (string-match "[.eE]" calculator-curnum))))
1277 ;; enter the period on the same condition as a digit, only if no
1278 ;; period or exponent entered yet
1279 (progn
1280 (calculator-clear-fragile)
1281 (setq calculator-curnum (concat (or calculator-curnum "0") "."))
1282 (calculator-update-display))))
1283
1284 (defun calculator-exp ()
1285 "Enter an `E' exponent character, or a digit in hex input mode."
1286 (interactive)
1287 (if calculator-input-radix
1288 (calculator-digit)
1289 (if (and (or calculator-display-fragile
1290 (not (numberp (car calculator-stack))))
1291 (not (and calculator-curnum
1292 (string-match "[eE]" calculator-curnum))))
1293 ;; same condition as above, also no E so far
1294 (progn
1295 (calculator-clear-fragile)
1296 (setq calculator-curnum (concat (or calculator-curnum "1") "e"))
1297 (calculator-update-display)))))
1298
1299 (defun calculator-op (&optional keys)
1300 "Enter an operator on the stack, doing all necessary reductions.
1301 Optional string argument KEYS will force using it as the keys entered."
1302 (interactive)
1303 (catch 'op-error
1304 (let* ((last-inp (calculator-last-input keys))
1305 (op (assoc last-inp calculator-operators)))
1306 (calculator-clear-fragile op)
1307 (if (and calculator-curnum (/= (calculator-op-arity op) 0))
1308 (setq calculator-stack
1309 (cons (calculator-curnum-value) calculator-stack)))
1310 (setq calculator-curnum nil)
1311 (if (and (= 2 (calculator-op-arity op))
1312 (not (and calculator-stack
1313 (numberp (nth 0 calculator-stack)))))
1314 ;; we have a binary operator but no number - search for a prefix
1315 ;; version
1316 (let ((rest-ops calculator-operators))
1317 (while (not (equal last-inp (car (car rest-ops))))
1318 (setq rest-ops (cdr rest-ops)))
1319 (setq op (assoc last-inp (cdr rest-ops)))
1320 (if (not (and op (= -1 (calculator-op-arity op))))
1321 ;;(error "Binary operator without a first operand")
1322 (progn
1323 (message "Binary operator without a first operand")
1324 (if calculator-electric-mode
1325 (progn (sit-for 1) (message nil)))
1326 (throw 'op-error nil)))))
1327 (calculator-reduce-stack
1328 (cond ((eq (nth 1 op) '\() 10)
1329 ((eq (nth 1 op) '\)) 0)
1330 (t (calculator-op-prec op))))
1331 (if (or (and (= -1 (calculator-op-arity op))
1332 (numberp (car calculator-stack)))
1333 (and (/= (calculator-op-arity op) -1)
1334 (/= (calculator-op-arity op) 0)
1335 (not (numberp (car calculator-stack)))))
1336 ;;(error "Unterminated expression")
1337 (progn
1338 (message "Unterminated expression")
1339 (if calculator-electric-mode
1340 (progn (sit-for 1) (message nil)))
1341 (throw 'op-error nil)))
1342 (setq calculator-stack (cons op calculator-stack))
1343 (calculator-reduce-stack (calculator-op-prec op))
1344 (and (= (length calculator-stack) 1)
1345 (numberp (nth 0 calculator-stack))
1346 ;; the display is fragile if it contains only one number
1347 (setq calculator-display-fragile t)
1348 ;; add number to the saved-list
1349 calculator-add-saved
1350 (if (= 0 calculator-saved-ptr)
1351 (setq calculator-saved-list
1352 (cons (car calculator-stack) calculator-saved-list))
1353 (let ((p (nthcdr (1- calculator-saved-ptr)
1354 calculator-saved-list)))
1355 (setcdr p (cons (car calculator-stack) (cdr p))))))
1356 (calculator-update-display))))
1357
1358 (defun calculator-op-or-exp ()
1359 "Either enter an operator or a digit.
1360 Used with +/- for entering them as digits in numbers like 1e-3 (there is
1361 no need for negative numbers since these are handled by unary
1362 operators)."
1363 (interactive)
1364 (if (and (not calculator-display-fragile)
1365 calculator-curnum
1366 (string-match "[eE]$" calculator-curnum))
1367 (calculator-digit)
1368 (calculator-op)))
1369
1370 ;;;---------------------------------------------------------------------
1371 ;;; Input/output modes (not display)
1372
1373 (defun calculator-dec/deg-mode ()
1374 "Set decimal mode for display & input, if decimal, toggle deg mode."
1375 (interactive)
1376 (if calculator-curnum
1377 (setq calculator-stack
1378 (cons (calculator-curnum-value) calculator-stack)))
1379 (setq calculator-curnum nil)
1380 (if (or calculator-input-radix calculator-output-radix)
1381 (progn (setq calculator-input-radix nil)
1382 (setq calculator-output-radix nil))
1383 ;; already decimal - toggle degrees mode
1384 (setq calculator-deg (not calculator-deg)))
1385 (calculator-update-display t))
1386
1387 (defun calculator-radix-mode (&optional keys)
1388 "Set input and display radix modes.
1389 Optional string argument KEYS will force using it as the keys entered."
1390 (interactive)
1391 (calculator-radix-input-mode keys)
1392 (calculator-radix-output-mode keys))
1393
1394 (defun calculator-radix-input-mode (&optional keys)
1395 "Set input radix modes.
1396 Optional string argument KEYS will force using it as the keys entered."
1397 (interactive)
1398 (if calculator-curnum
1399 (setq calculator-stack
1400 (cons (calculator-curnum-value) calculator-stack)))
1401 (setq calculator-curnum nil)
1402 (setq calculator-input-radix
1403 (let ((inp (calculator-last-input keys)))
1404 (cdr (assq (upcase (aref inp (1- (length inp))))
1405 calculator-char-radix))))
1406 (calculator-update-display))
1407
1408 (defun calculator-radix-output-mode (&optional keys)
1409 "Set display radix modes.
1410 Optional string argument KEYS will force using it as the keys entered."
1411 (interactive)
1412 (if calculator-curnum
1413 (setq calculator-stack
1414 (cons (calculator-curnum-value) calculator-stack)))
1415 (setq calculator-curnum nil)
1416 (setq calculator-output-radix
1417 (let ((inp (calculator-last-input keys)))
1418 (cdr (assq (upcase (aref inp (1- (length inp))))
1419 calculator-char-radix))))
1420 (calculator-update-display t))
1421
1422 ;;;---------------------------------------------------------------------
1423 ;;; Saved values list
1424
1425 (defun calculator-save-on-list ()
1426 "Evaluate current expression, put result on the saved values list."
1427 (interactive)
1428 (let ((calculator-add-saved t)) ; marks the result to be added
1429 (calculator-enter)))
1430
1431 (defun calculator-clear-saved ()
1432 "Clear the list of saved values in `calculator-saved-list'."
1433 (interactive)
1434 (setq calculator-saved-list nil)
1435 (setq calculator-saved-ptr 0)
1436 (calculator-update-display t))
1437
1438 (defun calculator-saved-move (n)
1439 "Go N elements up the list of saved values."
1440 (interactive)
1441 (and calculator-saved-list
1442 (or (null calculator-stack) calculator-display-fragile)
1443 (progn
1444 (setq calculator-saved-ptr
1445 (max (min (+ n calculator-saved-ptr)
1446 (length calculator-saved-list))
1447 0))
1448 (if (nth calculator-saved-ptr calculator-saved-list)
1449 (setq calculator-stack
1450 (list (nth calculator-saved-ptr calculator-saved-list))
1451 calculator-display-fragile t)
1452 (calculator-reset))
1453 (calculator-update-display))))
1454
1455 (defun calculator-saved-up ()
1456 "Go up the list of saved values."
1457 (interactive)
1458 (calculator-saved-move +1))
1459
1460 (defun calculator-saved-down ()
1461 "Go down the list of saved values."
1462 (interactive)
1463 (calculator-saved-move -1))
1464
1465 ;;;---------------------------------------------------------------------
1466 ;;; Misc functions
1467
1468 (defun calculator-open-paren ()
1469 "Equivalents of `(' use this."
1470 (interactive)
1471 (calculator-op "("))
1472
1473 (defun calculator-close-paren ()
1474 "Equivalents of `)' use this."
1475 (interactive)
1476 (calculator-op ")"))
1477
1478 (defun calculator-enter ()
1479 "Evaluate current expression."
1480 (interactive)
1481 (calculator-op "="))
1482
1483 (defun calculator-backspace ()
1484 "Backward delete a single digit or a stack element."
1485 (interactive)
1486 (if calculator-curnum
1487 (setq calculator-curnum
1488 (if (> (length calculator-curnum) 1)
1489 (substring calculator-curnum
1490 0 (1- (length calculator-curnum)))
1491 nil))
1492 (setq calculator-stack (cdr calculator-stack)))
1493 (calculator-update-display))
1494
1495 (defun calculator-clear ()
1496 "Clear current number."
1497 (interactive)
1498 (setq calculator-curnum nil)
1499 (cond
1500 ;; if the current number is from the saved-list - remove it
1501 ((and calculator-display-fragile
1502 calculator-saved-list
1503 (= (car calculator-stack)
1504 (nth calculator-saved-ptr calculator-saved-list)))
1505 (if (= 0 calculator-saved-ptr)
1506 (setq calculator-saved-list (cdr calculator-saved-list))
1507 (let ((p (nthcdr (1- calculator-saved-ptr)
1508 calculator-saved-list)))
1509 (setcdr p (cdr (cdr p)))
1510 (setq calculator-saved-ptr (1- calculator-saved-ptr))))
1511 (if calculator-saved-list
1512 (setq calculator-stack
1513 (list (nth calculator-saved-ptr calculator-saved-list)))
1514 (calculator-reset)))
1515 ;; reset if fragile or double clear
1516 ((or calculator-display-fragile (eq last-command this-command))
1517 (calculator-reset)))
1518 (calculator-update-display))
1519
1520 (defun calculator-copy ()
1521 "Copy current number to the `kill-ring'."
1522 (interactive)
1523 (let ((calculator-displayer
1524 (or calculator-copy-displayer calculator-displayer))
1525 (calculator-displayers
1526 (if calculator-copy-displayer nil calculator-displayers)))
1527 (calculator-enter)
1528 ;; remove trailing spaces and and an index
1529 (let ((s (cdr calculator-stack-display)))
1530 (and s
1531 (if (string-match "^\\([^ ]+\\) *\\(\\[[0-9/]+\\]\\)? *$" s)
1532 (setq s (match-string 1 s)))
1533 (kill-new s)))))
1534
1535 (defun calculator-set-register (reg)
1536 "Set a register value for REG."
1537 (interactive "cRegister to store into: ")
1538 (let* ((as (assq reg calculator-registers))
1539 (val (progn (calculator-enter) (car calculator-stack))))
1540 (if as
1541 (setcdr as val)
1542 (setq calculator-registers
1543 (cons (cons reg val) calculator-registers)))
1544 (message (format "[%c] := %S" reg val))))
1545
1546 (defun calculator-put-value (val)
1547 "Paste VAL as if entered.
1548 Used by `calculator-paste' and `get-register'."
1549 (if (and (numberp val)
1550 ;; (not calculator-curnum)
1551 (or calculator-display-fragile
1552 (not (numberp (car calculator-stack)))))
1553 (progn
1554 (calculator-clear-fragile)
1555 (setq calculator-curnum (let ((calculator-displayer "%S"))
1556 (calculator-num-to-string val)))
1557 (calculator-update-display))))
1558
1559 (defun calculator-paste ()
1560 "Paste a value from the `kill-ring'."
1561 (interactive)
1562 (calculator-put-value
1563 (let ((str (current-kill 0)))
1564 (and calculator-paste-decimals
1565 (string-match "\\([0-9]+\\)\\(\\.[0-9]+\\)?\\(e[0-9]+\\)?"
1566 str)
1567 (or (match-string 1 str)
1568 (match-string 2 str)
1569 (match-string 3 str))
1570 (setq str (concat (match-string 1 str)
1571 (or (match-string 2 str) ".0")
1572 (match-string 3 str))))
1573 (condition-case nil (car (read-from-string str))
1574 (error nil)))))
1575
1576 (defun calculator-get-register (reg)
1577 "Get a value from a register REG."
1578 (interactive "cRegister to get value from: ")
1579 (calculator-put-value (cdr (assq reg calculator-registers))))
1580
1581 (defun calculator-help ()
1582 ;; this is used as the quick reference screen you get with `h'
1583 "Quick reference:
1584 * numbers/operators/parens/./e - enter expressions
1585 + - * / \\(div) %(rem) _(-X,postfix) ;(1/X,postfix) ^(exp) L(og)
1586 Q(sqrt) !(fact) S(in) C(os) T(an) |(or) #(xor) &(and) ~(not)
1587 * >/< repeats last binary operation with its 2nd (1st) arg as postfix op
1588 * I inverses next trig function * '/\"/{} - display/display args
1589 * D - switch to all-decimal, or toggle deg/rad mode
1590 * B/O/H/X - binary/octal/hex mode for i/o (X is a shortcut for H)
1591 * i/o - prefix for d/b/o/x - set only input/output modes
1592 * enter/= - evaluate current expr. * s/g - set/get a register
1593 * space - evaluate & save on list * l/v - list total/average
1594 * up/down/C-p/C-n - browse saved * C-delete - clear all saved
1595 * C-insert - copy whole expr. * C-return - evaluate, copy, exit
1596 * insert - paste a number * backspace- delete backwards
1597 * delete - clear argument or list value or whole expression (twice)
1598 * escape/q - exit."
1599 (interactive)
1600 (if (eq last-command 'calculator-help)
1601 (let ((mode-name "Calculator")
1602 (major-mode 'calculator-mode)
1603 (g-map (current-global-map))
1604 (win (selected-window)))
1605 (require 'ehelp)
1606 (if calculator-electric-mode
1607 (use-global-map calculator-saved-global-map))
1608 (if (or (not calculator-electric-mode)
1609 ;; XEmacs has a problem with electric-describe-mode
1610 (string-match "XEmacs" (emacs-version)))
1611 (describe-mode)
1612 (electric-describe-mode))
1613 (if calculator-electric-mode
1614 (use-global-map g-map))
1615 (select-window win) ; these are for XEmacs (also below)
1616 (message nil))
1617 (let ((one (one-window-p t))
1618 (win (selected-window))
1619 (help-buf (get-buffer-create "*Help*")))
1620 (save-window-excursion
1621 (with-output-to-temp-buffer "*Help*"
1622 (princ (documentation 'calculator-help)))
1623 (if one
1624 (shrink-window-if-larger-than-buffer
1625 (get-buffer-window help-buf)))
1626 (message
1627 "`%s' again for more help, any other key continues normally."
1628 (calculator-last-input))
1629 (select-window win)
1630 (sit-for 360))
1631 (select-window win))))
1632
1633 (defun calculator-quit ()
1634 "Quit calculator."
1635 (interactive)
1636 (set-buffer calculator-buffer)
1637 (let ((inhibit-read-only t)) (erase-buffer))
1638 (if (not calculator-electric-mode)
1639 (progn
1640 (condition-case nil
1641 (while (get-buffer-window calculator-buffer)
1642 (delete-window (get-buffer-window calculator-buffer)))
1643 (error nil))
1644 (kill-buffer calculator-buffer)))
1645 (setq calculator-buffer nil)
1646 (message "Calculator done.")
1647 (if calculator-electric-mode (throw 'calculator-done nil)))
1648
1649 (defun calculator-save-and-quit ()
1650 "Quit the calculator, saving the result on the `kill-ring'."
1651 (interactive)
1652 (calculator-enter)
1653 (calculator-copy)
1654 (calculator-quit))
1655
1656 (defun calculator-repR (x)
1657 "Repeats the last binary operation with its second argument and X.
1658 To use this, apply a binary operator (evaluate it), then call this."
1659 (if calculator-last-opXY
1660 ;; avoid rebinding calculator-last-opXY
1661 (let ((calculator-last-opXY calculator-last-opXY))
1662 (calculator-funcall
1663 (car calculator-last-opXY) x (nth 2 calculator-last-opXY)))
1664 x))
1665
1666 (defun calculator-repL (x)
1667 "Repeats the last binary operation with its first argument and X.
1668 To use this, apply a binary operator (evaluate it), then call this."
1669 (if calculator-last-opXY
1670 ;; avoid rebinding calculator-last-opXY
1671 (let ((calculator-last-opXY calculator-last-opXY))
1672 (calculator-funcall
1673 (car calculator-last-opXY) (nth 1 calculator-last-opXY) x))
1674 x))
1675
1676 (defun calculator-fact (x)
1677 "Simple factorial of X."
1678 (let ((r (if (<= x 10) 1 1.0)))
1679 (while (> x 0)
1680 (setq r (* r (truncate x)))
1681 (setq x (1- x)))
1682 r))
1683
1684 (defun calculator-truncate (n)
1685 "Truncate N, return 0 in case of overflow."
1686 (condition-case nil (truncate n) (error 0)))
1687
1688
1689 (provide 'calculator)
1690
1691 ;;; calculator.el ends here