lisp/calculator.el

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