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