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