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