lisp/calculator.el

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