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