lisp/calculator.el

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