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