code.delx.au - gnu-emacs/blob - lisp/calc/calc-aent.el

   1 ;;; calc-aent.el --- algebraic entry functions for Calc
   2
   3 ;; Copyright (C) 1990, 1991, 1992, 1993, 2001, 2002, 2003, 2004,
   4 ;;   2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
   5
   6 ;; Author: Dave Gillespie <daveg@synaptics.com>
   7 ;; Maintainer: Jay Belanger <jay.p.belanger@gmail.com>
   8
   9 ;; This file is part of GNU Emacs.
  10
  11 ;; GNU Emacs is free software: you can redistribute it and/or modify
  12 ;; it under the terms of the GNU General Public License as published by
  13 ;; the Free Software Foundation, either version 3 of the License, or
  14 ;; (at your option) any later version.
  15
  16 ;; GNU Emacs is distributed in the hope that it will be useful,
  17 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19 ;; GNU 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.  If not, see <http://www.gnu.org/licenses/>.
  23
  24 ;;; Commentary:
  25
  26 ;;; Code:
  27
  28 ;; This file is autoloaded from calc.el.
  29
  30 (require 'calc)
  31 (require 'calc-macs)
  32
  33 ;; Declare functions which are defined elsewhere.
  34 (declare-function calc-refresh-evaltos "calc-ext" (&optional which-var))
  35 (declare-function calc-execute-kbd-macro "calc-prog" (mac arg &rest prefix))
  36 (declare-function math-is-true "calc-ext" (expr))
  37 (declare-function calc-explain-why "calc-stuff" (why &optional more))
  38 (declare-function calc-alg-edit "calc-yank" (str))
  39 (declare-function math-composite-inequalities "calc-prog" (x op))
  40 (declare-function math-flatten-lands "calc-rewr" (expr))
  41 (declare-function math-multi-subst "calc-map" (expr olds news))
  42 (declare-function calcFunc-vmatches "calc-rewr" (expr pat))
  43 (declare-function math-simplify "calc-alg" (top-expr))
  44 (declare-function math-known-matrixp "calc-arith" (a))
  45 (declare-function math-parse-fortran-subscr "calc-lang" (sym args))
  46 (declare-function math-to-radians-2 "calc-math" (a))
  47 (declare-function math-read-string "calc-ext" ())
  48 (declare-function math-read-brackets "calc-vec" (space-sep math-rb-close))
  49 (declare-function math-read-angle-brackets "calc-forms" ())
  50 (declare-function math-to-percentsigns "calccomp" (x))
  51
  52 (defvar calc-quick-calc-history nil
  53   "The history list for quick-calc.")
  54
  55 ;;;###autoload
  56 (defun calc-do-quick-calc ()
  57   (require 'calc-ext)
  58   (calc-check-defines)
  59   (if (eq major-mode 'calc-mode)
  60       (calc-algebraic-entry t)
  61     (let (buf shortbuf)
  62       (save-excursion
  63         (calc-create-buffer)
  64         (let* ((calc-command-flags nil)
  65                (calc-dollar-values calc-quick-prev-results)
  66                (calc-dollar-used 0)
  67                (enable-recursive-minibuffers t)
  68                (calc-language (if (memq calc-language '(nil big))
  69                                   'flat calc-language))
  70                (entry (calc-do-alg-entry "" "Quick calc: " t 'calc-quick-calc-history))
  71                (alg-exp (mapcar 'math-evaluate-expr entry)))
  72           (when (and (= (length alg-exp) 1)
  73                      (eq (car-safe (car alg-exp)) 'calcFunc-assign)
  74                      (= (length (car alg-exp)) 3)
  75                      (eq (car-safe (nth 1 (car alg-exp))) 'var))
  76             (set (nth 2 (nth 1 (car alg-exp))) (nth 2 (car alg-exp)))
  77             (calc-refresh-evaltos (nth 2 (nth 1 (car alg-exp))))
  78             (setq alg-exp (list (nth 2 (car alg-exp)))))
  79           (setq calc-quick-prev-results alg-exp
  80                 buf (mapconcat (function (lambda (x)
  81                                            (math-format-value x 1000)))
  82                                alg-exp
  83                                " ")
  84                 shortbuf buf)
  85           (if (and (= (length alg-exp) 1)
  86                    (memq (car-safe (car alg-exp)) '(nil bigpos bigneg))
  87                    (< (length buf) 20)
  88                    (= calc-number-radix 10))
  89               (setq buf (concat buf "  ("
  90                                 (let ((calc-number-radix 16))
  91                                   (math-format-value (car alg-exp) 1000))
  92                                 ", "
  93                                 (let ((calc-number-radix 8))
  94                                   (math-format-value (car alg-exp) 1000))
  95                                 ", "
  96                                 (let ((calc-number-radix 2))
  97                                   (math-format-value (car alg-exp) 1000))
  98                                 (if (and (integerp (car alg-exp))
  99                                          (> (car alg-exp) 0)
 100                                          (< (car alg-exp) 127))
 101                                     (format ", \"%c\"" (car alg-exp))
 102                                   "")
 103                                 ")")))
 104           (if (and (< (length buf) (frame-width)) (= (length entry) 1)
 105                    (featurep 'calc-ext))
 106               (let ((long (concat (math-format-value (car entry) 1000)
 107                                   " =>  " buf)))
 108                 (if (<= (length long) (- (frame-width) 8))
 109                     (setq buf long))))
 110           (calc-handle-whys)
 111           (message "Result: %s" buf)))
 112       (if (eq last-command-event 10)
 113           (insert shortbuf)
 114         (kill-new shortbuf)))))
 115
 116 ;;;###autoload
 117 (defun calc-do-calc-eval (str separator args)
 118   (calc-check-defines)
 119   (catch 'calc-error
 120     (save-excursion
 121       (calc-create-buffer)
 122       (cond
 123        ((and (consp str) (not (symbolp (car str))))
 124         (let ((calc-language nil)
 125               (math-expr-opers (math-standard-ops))
 126               (calc-internal-prec 12)
 127               (calc-word-size 32)
 128               (calc-symbolic-mode nil)
 129               (calc-matrix-mode nil)
 130               (calc-angle-mode 'deg)
 131               (calc-number-radix 10)
 132               (calc-twos-complement-mode nil)
 133               (calc-leading-zeros nil)
 134               (calc-group-digits nil)
 135               (calc-point-char ".")
 136               (calc-frac-format '(":" nil))
 137               (calc-prefer-frac nil)
 138               (calc-hms-format "%s@ %s' %s\"")
 139               (calc-date-format '((H ":" mm C SS pp " ")
 140                                   Www " " Mmm " " D ", " YYYY))
 141               (calc-float-format '(float 0))
 142               (calc-full-float-format '(float 0))
 143               (calc-complex-format nil)
 144               (calc-matrix-just nil)
 145               (calc-full-vectors t)
 146               (calc-break-vectors nil)
 147               (calc-vector-commas ",")
 148               (calc-vector-brackets "[]")
 149               (calc-matrix-brackets '(R O))
 150               (calc-complex-mode 'cplx)
 151               (calc-infinite-mode nil)
 152               (calc-display-strings nil)
 153               (calc-simplify-mode nil)
 154               (calc-display-working-message 'lots)
 155               (strp (cdr str)))
 156           (while strp
 157             (set (car strp) (nth 1 strp))
 158             (setq strp (cdr (cdr strp))))
 159           (calc-do-calc-eval (car str) separator args)))
 160        ((eq separator 'eval)
 161         (eval str))
 162        ((eq separator 'macro)
 163         (require 'calc-ext)
 164         (let* ((calc-buffer (current-buffer))
 165                (calc-window (get-buffer-window calc-buffer))
 166                (save-window (selected-window)))
 167           (if calc-window
 168               (unwind-protect
 169                   (progn
 170                     (select-window calc-window)
 171                     (calc-execute-kbd-macro str nil (car args)))
 172                 (and (window-point save-window)
 173                      (select-window save-window)))
 174             (save-window-excursion
 175               (select-window (get-largest-window))
 176               (switch-to-buffer calc-buffer)
 177               (calc-execute-kbd-macro str nil (car args)))))
 178         nil)
 179        ((eq separator 'pop)
 180         (or (not (integerp str))
 181             (= str 0)
 182             (calc-pop (min str (calc-stack-size))))
 183         (calc-stack-size))
 184        ((eq separator 'top)
 185         (and (integerp str)
 186              (> str 0)
 187              (<= str (calc-stack-size))
 188              (math-format-value (calc-top-n str (car args)) 1000)))
 189        ((eq separator 'rawtop)
 190         (and (integerp str)
 191              (> str 0)
 192              (<= str (calc-stack-size))
 193              (calc-top-n str (car args))))
 194        (t
 195         (let* ((calc-command-flags nil)
 196                (calc-next-why nil)
 197                (calc-language (if (memq calc-language '(nil big))
 198                                   'flat calc-language))
 199                (calc-dollar-values (mapcar
 200                                     (function
 201                                      (lambda (x)
 202                                        (if (stringp x)
 203                                            (progn
 204                                              (setq x (math-read-exprs x))
 205                                              (if (eq (car-safe x)
 206                                                      'error)
 207                                                  (throw 'calc-error
 208                                                         (calc-eval-error
 209                                                          (cdr x)))
 210                                                (car x)))
 211                                          x)))
 212                                     args))
 213                (calc-dollar-used 0)
 214                (res (if (stringp str)
 215                         (math-read-exprs str)
 216                       (list str)))
 217                buf)
 218           (if (eq (car res) 'error)
 219               (calc-eval-error (cdr res))
 220             (setq res (mapcar 'calc-normalize res))
 221             (and (memq 'clear-message calc-command-flags)
 222                  (message ""))
 223             (cond ((eq separator 'pred)
 224                    (require 'calc-ext)
 225                    (if (= (length res) 1)
 226                        (math-is-true (car res))
 227                      (calc-eval-error '(0 "Single value expected"))))
 228                   ((eq separator 'raw)
 229                    (if (= (length res) 1)
 230                        (car res)
 231                      (calc-eval-error '(0 "Single value expected"))))
 232                   ((eq separator 'list)
 233                    res)
 234                   ((memq separator '(num rawnum))
 235                    (if (= (length res) 1)
 236                        (if (math-constp (car res))
 237                            (if (eq separator 'num)
 238                                (math-format-value (car res) 1000)
 239                              (car res))
 240                          (calc-eval-error
 241                           (list 0
 242                                 (if calc-next-why
 243                                     (calc-explain-why (car calc-next-why))
 244                                   "Number expected"))))
 245                      (calc-eval-error '(0 "Single value expected"))))
 246                   ((eq separator 'push)
 247                    (calc-push-list res)
 248                    nil)
 249                   (t (while res
 250                        (setq buf (concat buf
 251                                          (and buf (or separator ", "))
 252                                          (math-format-value (car res) 1000))
 253                              res (cdr res)))
 254                      buf)))))))))
 255
 256 (defvar calc-eval-error nil
 257   "Determines how calc handles errors.
 258 If nil, return a list containing the character position of error.
 259 STRING means return error message as string rather than list.
 260 The value t means abort and give an error message.")
 261
 262 (defun calc-eval-error (msg)
 263   (if calc-eval-error
 264       (if (eq calc-eval-error 'string)
 265           (nth 1 msg)
 266         (error "%s" (nth 1 msg)))
 267     msg))
 268
 269
 270 ;;;; Reading an expression in algebraic form.
 271
 272 ;;;###autoload
 273 (defun calc-auto-algebraic-entry (&optional prefix)
 274   (interactive "P")
 275   (calc-algebraic-entry prefix t))
 276
 277 ;;;###autoload
 278 (defun calc-algebraic-entry (&optional prefix auto)
 279   (interactive "P")
 280   (calc-wrapper
 281    (let ((calc-language (if prefix nil calc-language))
 282          (math-expr-opers (if prefix (math-standard-ops) (math-expr-ops))))
 283      (calc-alg-entry (and auto (char-to-string last-command-event))))))
 284
 285 (defvar calc-alg-entry-history nil
 286   "History for algebraic entry.")
 287
 288 ;;;###autoload
 289 (defun calc-alg-entry (&optional initial prompt)
 290   (let* ((sel-mode nil)
 291          (calc-dollar-values (mapcar 'calc-get-stack-element
 292                                      (nthcdr calc-stack-top calc-stack)))
 293          (calc-dollar-used 0)
 294          (calc-plain-entry t)
 295          (alg-exp (calc-do-alg-entry initial prompt t 'calc-alg-entry-history)))
 296     (if (stringp alg-exp)
 297         (progn
 298           (require 'calc-ext)
 299           (calc-alg-edit alg-exp))
 300       (let* ((calc-simplify-mode (if (eq last-command-event ?\C-j)
 301                                      'none
 302                                    calc-simplify-mode))
 303              (nvals (mapcar 'calc-normalize alg-exp)))
 304         (while alg-exp
 305           (calc-record (if (featurep 'calc-ext) (car alg-exp) (car nvals))
 306                        "alg'")
 307           (calc-pop-push-record-list calc-dollar-used
 308                                      (and (not (equal (car alg-exp)
 309                                                       (car nvals)))
 310                                           (featurep 'calc-ext)
 311                                           "")
 312                                      (list (car nvals)))
 313           (setq alg-exp (cdr alg-exp)
 314                 nvals (cdr nvals)
 315                 calc-dollar-used 0)))
 316       (calc-handle-whys))))
 317
 318 (defvar calc-alg-ent-map nil
 319   "The keymap used for algebraic entry.")
 320
 321 (defvar calc-alg-ent-esc-map nil
 322   "The keymap used for escapes in algebraic entry.")
 323
 324 (defvar calc-alg-exp)
 325
 326 ;;;###autoload
 327 (defun calc-do-alg-entry (&optional initial prompt no-normalize history)
 328   (let* ((calc-buffer (current-buffer))
 329          (blink-paren-function 'calcAlg-blink-matching-open)
 330          (calc-alg-exp 'error))
 331     (unless calc-alg-ent-map
 332       (setq calc-alg-ent-map (copy-keymap minibuffer-local-map))
 333       (define-key calc-alg-ent-map "'" 'calcAlg-previous)
 334       (define-key calc-alg-ent-map "`" 'calcAlg-edit)
 335       (define-key calc-alg-ent-map "\C-m" 'calcAlg-enter)
 336       (define-key calc-alg-ent-map "\C-j" 'calcAlg-enter)
 337       (let ((i 33))
 338         (setq calc-alg-ent-esc-map (copy-keymap esc-map))
 339         (while (< i 127)
 340           (aset (nth 1 calc-alg-ent-esc-map) i 'calcAlg-escape)
 341           (setq i (1+ i)))))
 342     (define-key calc-alg-ent-map "\e" nil)
 343     (if (eq calc-algebraic-mode 'total)
 344         (define-key calc-alg-ent-map "\e" calc-alg-ent-esc-map)
 345       (define-key calc-alg-ent-map "\e+" 'calcAlg-plus-minus)
 346       (define-key calc-alg-ent-map "\em" 'calcAlg-mod)
 347       (define-key calc-alg-ent-map "\e=" 'calcAlg-equals)
 348       (define-key calc-alg-ent-map "\e\r" 'calcAlg-equals)
 349       (define-key calc-alg-ent-map "\ep" 'previous-history-element)
 350       (define-key calc-alg-ent-map "\en" 'next-history-element)
 351       (define-key calc-alg-ent-map "\e%" 'self-insert-command))
 352     (setq calc-aborted-prefix nil)
 353     (let ((buf (read-from-minibuffer (or prompt "Algebraic: ")
 354                                      (or initial "")
 355                                      calc-alg-ent-map nil history)))
 356       (when (eq calc-alg-exp 'error)
 357         (when (eq (car-safe (setq calc-alg-exp (math-read-exprs buf))) 'error)
 358           (setq calc-alg-exp nil)))
 359       (setq calc-aborted-prefix "alg'")
 360       (or no-normalize
 361           (and calc-alg-exp (setq calc-alg-exp (mapcar 'calc-normalize calc-alg-exp))))
 362       calc-alg-exp)))
 363
 364 (defun calcAlg-plus-minus ()
 365   (interactive)
 366   (if (calc-minibuffer-contains ".* \\'")
 367       (insert "+/- ")
 368     (insert " +/- ")))
 369
 370 (defun calcAlg-mod ()
 371   (interactive)
 372   (if (not (calc-minibuffer-contains ".* \\'"))
 373       (insert " "))
 374   (if (calc-minibuffer-contains ".* mod +\\'")
 375       (if calc-previous-modulo
 376           (insert (math-format-flat-expr calc-previous-modulo 0))
 377         (beep))
 378     (insert "mod ")))
 379
 380 (defun calcAlg-previous ()
 381   (interactive)
 382   (if (calc-minibuffer-contains "\\'")
 383       (previous-history-element 1)
 384     (insert "'")))
 385
 386 (defun calcAlg-equals ()
 387   (interactive)
 388   (unwind-protect
 389       (calcAlg-enter)
 390     (if (consp calc-alg-exp)
 391         (progn (setq prefix-arg (length calc-alg-exp))
 392                (calc-unread-command ?=)))))
 393
 394 (defun calcAlg-escape ()
 395   (interactive)
 396   (calc-unread-command)
 397   (save-excursion
 398     (calc-select-buffer)
 399     (use-local-map calc-mode-map))
 400   (calcAlg-enter))
 401
 402 (defvar calc-plain-entry nil)
 403 (defun calcAlg-edit ()
 404   (interactive)
 405   (if (or (not calc-plain-entry)
 406           (calc-minibuffer-contains
 407            "\\`\\([^\"]*\"[^\"]*\"\\)*[^\"]*\"[^\"]*\\'"))
 408       (insert "`")
 409     (setq calc-alg-exp (minibuffer-contents))
 410     (exit-minibuffer)))
 411
 412 (defvar calc-buffer)
 413
 414 (defun calcAlg-enter ()
 415   (interactive)
 416   (let* ((str (minibuffer-contents))
 417          (exp (and (> (length str) 0)
 418                    (with-current-buffer calc-buffer
 419                      (math-read-exprs str)))))
 420     (if (eq (car-safe exp) 'error)
 421         (progn
 422           (goto-char (minibuffer-prompt-end))
 423           (forward-char (nth 1 exp))
 424           (beep)
 425           (calc-temp-minibuffer-message
 426            (concat " [" (or (nth 2 exp) "Error") "]"))
 427           (calc-clear-unread-commands))
 428       (setq calc-alg-exp (if (calc-minibuffer-contains "\\` *\\[ *\\'")
 429                         '((incomplete vec))
 430                       exp))
 431       (exit-minibuffer))))
 432
 433 (defun calcAlg-blink-matching-open ()
 434   (let ((rightpt (point))
 435         (leftpt nil)
 436         (rightchar (preceding-char))
 437         leftchar
 438         rightsyntax
 439         leftsyntax)
 440     (save-excursion
 441       (condition-case ()
 442           (setq leftpt (scan-sexps rightpt -1)
 443                 leftchar (char-after leftpt))
 444         (error nil)))
 445     (if (and leftpt
 446              (or (and (= rightchar ?\))
 447                       (= leftchar ?\[))
 448                  (and (= rightchar ?\])
 449                       (= leftchar ?\()))
 450              (save-excursion
 451                (goto-char leftpt)
 452                (looking-at ".+\\(\\.\\.\\|\\\\dots\\|\\\\ldots\\)")))
 453         (let ((leftsaved (aref (syntax-table) leftchar))
 454               (rightsaved (aref (syntax-table) rightchar)))
 455           (unwind-protect
 456               (progn
 457                 (cond ((= leftchar ?\[)
 458                        (aset (syntax-table) leftchar (cons 4 ?\)))
 459                        (aset (syntax-table) rightchar (cons 5 ?\[)))
 460                       (t
 461                        (aset (syntax-table) leftchar (cons 4 ?\]))
 462                        (aset (syntax-table) rightchar (cons 5 ?\())))
 463                 (blink-matching-open))
 464             (aset (syntax-table) leftchar leftsaved)
 465             (aset (syntax-table) rightchar rightsaved)))
 466       (blink-matching-open))))
 467
 468 ;;;###autoload
 469 (defun calc-alg-digit-entry ()
 470   (calc-alg-entry
 471    (cond ((eq last-command-event ?e)
 472           (if (> calc-number-radix 14) (format "%d.^" calc-number-radix) "1e"))
 473          ((eq last-command-event ?#) (format "%d#" calc-number-radix))
 474          ((eq last-command-event ?_) "-")
 475          ((eq last-command-event ?@) "0@ ")
 476          (t (char-to-string last-command-event)))))
 477
 478 ;; The variable calc-digit-value is initially declared in calc.el,
 479 ;; but can be set by calcDigit-algebraic and calcDigit-edit.
 480 (defvar calc-digit-value)
 481
 482 ;;;###autoload
 483 (defun calcDigit-algebraic ()
 484   (interactive)
 485   (if (calc-minibuffer-contains ".*[@oh] *[^'m ]+[^'m]*\\'")
 486       (calcDigit-key)
 487     (setq calc-digit-value (minibuffer-contents))
 488     (exit-minibuffer)))
 489
 490 ;;;###autoload
 491 (defun calcDigit-edit ()
 492   (interactive)
 493   (calc-unread-command)
 494   (setq calc-digit-value (minibuffer-contents))
 495   (exit-minibuffer))
 496
 497
 498 ;;; Algebraic expression parsing.   [Public]
 499
 500 (defvar math-read-replacement-list
 501   '(;; Misc symbols
 502     ("±" "+/-")  ; plus or minus
 503     ("×" "*")    ; multiplication sign
 504     ("÷" ":")    ; division sign
 505     ("−" "-")    ; subtraction sign
 506     ("∕" "/")    ; division sign
 507     ("∗" "*")    ; asterisk multiplication
 508     ("∞" "inf")  ; infinity symbol
 509     ("≤" "<=")
 510     ("≥" ">=")
 511     ("≦" "<=")
 512     ("≧" ">=")
 513     ;; fractions
 514     ("¼" "(1:4)") ; 1/4
 515     ("½" "(1:2)") ; 1/2
 516     ("¾" "(3:4)") ; 3/4
 517     ("⅓" "(1:3)") ; 1/3
 518     ("⅔" "(2:3)") ; 2/3
 519     ("⅕" "(1:5)") ; 1/5
 520     ("⅖" "(2:5)") ; 2/5
 521     ("⅗" "(3:5)") ; 3/5
 522     ("⅘" "(4:5)") ; 4/5
 523     ("⅙" "(1:6)") ; 1/6
 524     ("⅚" "(5:6)") ; 5/6
 525     ("⅛" "(1:8)") ; 1/8
 526     ("⅜" "(3:8)") ; 3/8
 527     ("⅝" "(5:8)") ; 5/8
 528     ("⅞" "(7:8)") ; 7/8
 529     ("⅟" "1:")    ; 1/...
 530     ;; superscripts
 531     ("⁰" "0")  ; 0
 532     ("¹" "1")  ; 1
 533     ("²" "2")  ; 2
 534     ("³" "3")  ; 3
 535     ("⁴" "4")  ; 4
 536     ("⁵" "5")  ; 5
 537     ("⁶" "6")  ; 6
 538     ("⁷" "7")  ; 7
 539     ("⁸" "8")  ; 8
 540     ("⁹" "9")  ; 9
 541     ("⁺" "+")  ; +
 542     ("⁻" "-")  ; -
 543     ("⁽" "(")  ; (
 544     ("⁾" ")")  ; )
 545     ("ⁿ" "n")  ; n
 546     ("ⁱ" "i")  ; i
 547     ;; subscripts
 548     ("₀"  "0")  ; 0
 549     ("₁"  "1")  ; 1
 550     ("₂"  "2")  ; 2
 551     ("₃"  "3")  ; 3
 552     ("₄"  "4")  ; 4
 553     ("₅"  "5")  ; 5
 554     ("₆"  "6")  ; 6
 555     ("₇"  "7")  ; 7
 556     ("₈"  "8")  ; 8
 557     ("₉"  "9")  ; 9
 558     ("₊"  "+")  ; +
 559     ("₋"  "-")  ; -
 560     ("₍"  "(")  ; (
 561     ("₎"  ")"))  ; )
 562   "A list whose elements (old new) indicate replacements to make
 563 in Calc algebraic input.")
 564
 565 (defvar math-read-superscripts
 566   "⁰¹²³⁴⁵⁶⁷⁸⁹⁺⁻⁽⁾ⁿⁱ" ; 0123456789+-()ni
 567   "A string consisting of the superscripts allowed by Calc.")
 568
 569 (defvar math-read-subscripts
 570   "₀₁₂₃₄₅₆₇₈₉₊₋₍₎" ; 0123456789+-()
 571   "A string consisting of the subscripts allowed by Calc.")
 572
 573 ;;;###autoload
 574 (defun math-read-preprocess-string (str)
 575   "Replace some substrings of STR by Calc equivalents."
 576   (setq str
 577         (replace-regexp-in-string (concat "[" math-read-superscripts "]+")
 578                                   "^(\\&)" str))
 579   (setq str
 580         (replace-regexp-in-string (concat "[" math-read-subscripts "]+")
 581                                   "_(\\&)" str))
 582   (let ((rep-list math-read-replacement-list))
 583     (while rep-list
 584       (setq str
 585             (replace-regexp-in-string (nth 0 (car rep-list))
 586                                       (nth 1 (car rep-list)) str))
 587       (setq rep-list (cdr rep-list))))
 588   str)
 589
 590 ;; The next few variables are local to math-read-exprs (and math-read-expr
 591 ;; in calc-ext.el), but are set in functions they call.
 592
 593 (defvar math-exp-pos)
 594 (defvar math-exp-str)
 595 (defvar math-exp-old-pos)
 596 (defvar math-exp-token)
 597 (defvar math-exp-keep-spaces)
 598 (defvar math-expr-data)
 599
 600 ;;;###autoload
 601 (defun math-read-exprs (math-exp-str)
 602   (let ((math-exp-pos 0)
 603         (math-exp-old-pos 0)
 604         (math-exp-keep-spaces nil)
 605         math-exp-token math-expr-data)
 606     (setq math-exp-str (math-read-preprocess-string math-exp-str))
 607     (if (memq calc-language calc-lang-allow-percentsigns)
 608         (setq math-exp-str (math-remove-percentsigns math-exp-str)))
 609     (if calc-language-input-filter
 610         (setq math-exp-str (funcall calc-language-input-filter math-exp-str)))
 611     (while (setq math-exp-token
 612                  (string-match "\\.\\.\\([^.]\\|.[^.]\\)" math-exp-str))
 613       (setq math-exp-str
 614             (concat (substring math-exp-str 0 math-exp-token) "\\dots"
 615                             (substring math-exp-str (+ math-exp-token 2)))))
 616     (math-build-parse-table)
 617     (math-read-token)
 618     (let ((val (catch 'syntax (math-read-expr-list))))
 619       (if (stringp val)
 620           (list 'error math-exp-old-pos val)
 621         (if (equal math-exp-token 'end)
 622             val
 623           (list 'error math-exp-old-pos "Syntax error"))))))
 624
 625 ;;;###autoload
 626 (defun math-read-expr-list ()
 627   (let* ((math-exp-keep-spaces nil)
 628          (val (list (math-read-expr-level 0)))
 629          (last val))
 630     (while (equal math-expr-data ",")
 631       (math-read-token)
 632       (let ((rest (list (math-read-expr-level 0))))
 633         (setcdr last rest)
 634         (setq last rest)))
 635     val))
 636
 637 (defvar calc-user-parse-table nil)
 638 (defvar calc-last-main-parse-table nil)
 639 (defvar calc-last-user-lang-parse-table nil)
 640 (defvar calc-last-lang-parse-table nil)
 641 (defvar calc-user-tokens nil)
 642 (defvar calc-user-token-chars nil)
 643
 644 (defvar math-toks nil
 645   "Tokens to pass between math-build-parse-table and math-find-user-tokens.")
 646
 647 ;;;###autoload
 648 (defun math-build-parse-table ()
 649   (let ((mtab (cdr (assq nil calc-user-parse-tables)))
 650         (ltab (cdr (assq calc-language calc-user-parse-tables)))
 651         (lltab (get calc-language 'math-parse-table)))
 652     (or (and (eq mtab calc-last-main-parse-table)
 653              (eq ltab calc-last-user-lang-parse-table)
 654              (eq lltab calc-last-lang-parse-table))
 655         (let ((p (append mtab ltab lltab))
 656               (math-toks nil))
 657           (setq calc-user-parse-table p)
 658           (setq calc-user-token-chars nil)
 659           (while p
 660             (math-find-user-tokens (car (car p)))
 661             (setq p (cdr p)))
 662           (setq calc-user-tokens (mapconcat 'identity
 663                                             (sort (mapcar 'car math-toks)
 664                                                   (function (lambda (x y)
 665                                                               (> (length x)
 666                                                                  (length y)))))
 667                                             "\\|")
 668                 calc-last-main-parse-table mtab
 669                 calc-last-user-lang-parse-table ltab
 670                 calc-last-lang-parse-table lltab)))))
 671
 672 ;;;###autoload
 673 (defun math-find-user-tokens (p)
 674   (while p
 675     (cond ((and (stringp (car p))
 676                 (or (> (length (car p)) 1) (equal (car p) "$")
 677                     (equal (car p) "\""))
 678                 (string-match "[^a-zA-Z0-9]" (car p)))
 679            (let ((s (regexp-quote (car p))))
 680              (if (string-match "\\`[a-zA-Z0-9]" s)
 681                  (setq s (concat "\\<" s)))
 682              (if (string-match "[a-zA-Z0-9]\\'" s)
 683                  (setq s (concat s "\\>")))
 684              (or (assoc s math-toks)
 685                  (progn
 686                    (setq math-toks (cons (list s) math-toks))
 687                    (or (memq (aref (car p) 0) calc-user-token-chars)
 688                        (setq calc-user-token-chars
 689                              (cons (aref (car p) 0)
 690                                    calc-user-token-chars)))))))
 691           ((consp (car p))
 692            (math-find-user-tokens (nth 1 (car p)))
 693            (or (eq (car (car p)) '\?)
 694                (math-find-user-tokens (nth 2 (car p))))))
 695     (setq p (cdr p))))
 696
 697 ;;;###autoload
 698 (defun math-read-token ()
 699   (if (>= math-exp-pos (length math-exp-str))
 700       (setq math-exp-old-pos math-exp-pos
 701             math-exp-token 'end
 702             math-expr-data "\000")
 703     (let (adfn
 704           (ch (aref math-exp-str math-exp-pos)))
 705       (setq math-exp-old-pos math-exp-pos)
 706       (cond ((memq ch '(32 10 9))
 707              (setq math-exp-pos (1+ math-exp-pos))
 708              (if math-exp-keep-spaces
 709                  (setq math-exp-token 'space
 710                        math-expr-data " ")
 711                (math-read-token)))
 712             ((and (memq ch calc-user-token-chars)
 713                   (let ((case-fold-search nil))
 714                     (eq (string-match
 715                          calc-user-tokens math-exp-str math-exp-pos)
 716                         math-exp-pos)))
 717              (setq math-exp-token 'punc
 718                    math-expr-data (math-match-substring math-exp-str 0)
 719                    math-exp-pos (match-end 0)))
 720             ((or (and (>= ch ?a) (<= ch ?z))
 721                  (and (>= ch ?A) (<= ch ?Z)))
 722              (string-match
 723               (cond
 724                ((and (memq calc-language calc-lang-allow-underscores)
 725                      (memq calc-language calc-lang-allow-percentsigns))
 726                 "[a-zA-Z0-9_'#]*")
 727                ((memq calc-language calc-lang-allow-underscores)
 728                                "[a-zA-Z0-9_#]*")
 729                (t "[a-zA-Z0-9'#]*"))
 730               math-exp-str math-exp-pos)
 731              (setq math-exp-token 'symbol
 732                    math-exp-pos (match-end 0)
 733                    math-expr-data (math-restore-dashes
 734                              (math-match-substring math-exp-str 0)))
 735              (if (setq adfn (get calc-language 'math-lang-adjust-words))
 736                  (funcall adfn)))
 737             ((or (and (>= ch ?0) (<= ch ?9))
 738                  (and (eq ch '?\.)
 739                       (eq (string-match "\\.[0-9]" math-exp-str math-exp-pos)
 740                           math-exp-pos))
 741                  (and (eq ch '?_)
 742                       (eq (string-match "_\\.?[0-9]" math-exp-str math-exp-pos)
 743                           math-exp-pos)
 744                       (or (eq math-exp-pos 0)
 745                           (and (not (memq calc-language
 746                                           calc-lang-allow-underscores))
 747                                (eq (string-match "[^])}\"a-zA-Z0-9'$]_"
 748                                                  math-exp-str (1- math-exp-pos))
 749                                    (1- math-exp-pos))))))
 750              (or (and (memq calc-language calc-lang-c-type-hex)
 751                       (string-match "0[xX][0-9a-fA-F]+" math-exp-str math-exp-pos))
 752                  (string-match "_?\\([0-9]+.?0*@ *\\)?\\([0-9]+.?0*' *\\)?\\(0*\\([2-9]\\|1[0-4]\\)\\(#[#]?\\|\\^\\^\\)[0-9a-dA-D.]+[eE][-+_]?[0-9]+\\|0*\\([2-9]\\|[0-2][0-9]\\|3[0-6]\\)\\(#[#]?\\|\\^\\^\\)[0-9a-zA-Z:.]+\\|[0-9]+:[0-9:]+\\|[0-9.]+\\([eE][-+_]?[0-9]+\\)?\"?\\)?"
 753                                math-exp-str math-exp-pos))
 754              (setq math-exp-token 'number
 755                    math-expr-data (math-match-substring math-exp-str 0)
 756                    math-exp-pos (match-end 0)))
 757             ((and (setq adfn
 758                         (assq ch (get calc-language 'math-lang-read-symbol)))
 759                   (eval (nth 1 adfn)))
 760              (eval (nth 2 adfn)))
 761             ((eq ch ?\$)
 762              (if (eq (string-match "\\$\\([1-9][0-9]*\\)" math-exp-str math-exp-pos)
 763                      math-exp-pos)
 764                  (setq math-expr-data (- (string-to-number (math-match-substring
 765                                                             math-exp-str 1))))
 766                (string-match "\\$+" math-exp-str math-exp-pos)
 767                (setq math-expr-data (- (match-end 0) (match-beginning 0))))
 768              (setq math-exp-token 'dollar
 769                    math-exp-pos (match-end 0)))
 770             ((eq ch ?\#)
 771              (if (eq (string-match "#\\([1-9][0-9]*\\)" math-exp-str math-exp-pos)
 772                      math-exp-pos)
 773                  (setq math-expr-data (string-to-number
 774                                  (math-match-substring math-exp-str 1))
 775                        math-exp-pos (match-end 0))
 776                (setq math-expr-data 1
 777                      math-exp-pos (1+ math-exp-pos)))
 778              (setq math-exp-token 'hash))
 779             ((eq (string-match "~=\\|<=\\|>=\\|<>\\|/=\\|\\+/-\\|\\\\dots\\|\\\\ldots\\|\\*\\*\\|<<\\|>>\\|==\\|!=\\|&&&\\||||\\|!!!\\|&&\\|||\\|!!\\|:=\\|::\\|=>"
 780                                math-exp-str math-exp-pos)
 781                  math-exp-pos)
 782              (setq math-exp-token 'punc
 783                    math-expr-data (math-match-substring math-exp-str 0)
 784                    math-exp-pos (match-end 0)))
 785             ((and (eq ch ?\")
 786                   (string-match "\\(\"\\([^\"\\]\\|\\\\.\\)*\\)\\(\"\\|\\'\\)"
 787                                 math-exp-str math-exp-pos))
 788              (setq math-exp-token 'string
 789                    math-expr-data (math-match-substring math-exp-str 1)
 790                    math-exp-pos (match-end 0)))
 791             ((and (setq adfn (get calc-language 'math-lang-read))
 792                   (eval (nth 0 adfn))
 793                   (eval (nth 1 adfn))))
 794             ((eq (string-match "%%.*$" math-exp-str math-exp-pos) math-exp-pos)
 795              (setq math-exp-pos (match-end 0))
 796              (math-read-token))
 797             (t
 798              (if (setq adfn (assq ch (get calc-language 'math-punc-table)))
 799                  (setq ch (cdr adfn)))
 800              (setq math-exp-token 'punc
 801                    math-expr-data (char-to-string ch)
 802                    math-exp-pos (1+ math-exp-pos)))))))
 803
 804 (defconst math-alg-inequalities
 805   '(calcFunc-lt calcFunc-gt calcFunc-leq calcFunc-geq
 806                 calcFunc-eq calcFunc-neq))
 807
 808 (defun math-read-expr-level (exp-prec &optional exp-term)
 809   (let* ((math-expr-opers (math-expr-ops))
 810          (x (math-read-factor))
 811          (first t)
 812          op op2)
 813     (while (and (or (and calc-user-parse-table
 814                          (setq op (calc-check-user-syntax x exp-prec))
 815                          (setq x op
 816                                op '("2x" ident 999999 -1)))
 817                     (and (setq op (assoc math-expr-data math-expr-opers))
 818                          (/= (nth 2 op) -1)
 819                          (or (and (setq op2 (assoc
 820                                              math-expr-data
 821                                              (cdr (memq op math-expr-opers))))
 822                                   (eq (= (nth 3 op) -1)
 823                                       (/= (nth 3 op2) -1))
 824                                   (eq (= (nth 3 op2) -1)
 825                                       (not (math-factor-after)))
 826                                   (setq op op2))
 827                              t))
 828                     (and (or (eq (nth 2 op) -1)
 829                              (memq math-exp-token '(symbol number dollar hash))
 830                              (equal math-expr-data "(")
 831                              (and (equal math-expr-data "[")
 832                                   (not (equal
 833                                         (get calc-language
 834                                              'math-function-open) "["))
 835                                   (not (and math-exp-keep-spaces
 836                                             (eq (car-safe x) 'vec)))))
 837                          (or (not (setq op (assoc math-expr-data math-expr-opers)))
 838                              (/= (nth 2 op) -1))
 839                          (or (not calc-user-parse-table)
 840                              (not (eq math-exp-token 'symbol))
 841                              (let ((p calc-user-parse-table))
 842                                (while (and p
 843                                            (or (not (integerp
 844                                                      (car (car (car p)))))
 845                                                (not (equal
 846                                                      (nth 1 (car (car p)))
 847                                                      math-expr-data))))
 848                                  (setq p (cdr p)))
 849                                (not p)))
 850                          (setq op (assoc "2x" math-expr-opers))))
 851                 (not (and exp-term (equal math-expr-data exp-term)))
 852                 (>= (nth 2 op) exp-prec))
 853       (if (not (equal (car op) "2x"))
 854           (math-read-token))
 855       (and (memq (nth 1 op) '(sdev mod))
 856            (require 'calc-ext))
 857       (setq x (cond ((consp (nth 1 op))
 858                      (funcall (car (nth 1 op)) x op))
 859                     ((eq (nth 3 op) -1)
 860                      (if (eq (nth 1 op) 'ident)
 861                          x
 862                        (if (eq (nth 1 op) 'closing)
 863                            (if (eq (nth 2 op) exp-prec)
 864                                (progn
 865                                  (setq exp-prec 1000)
 866                                  x)
 867                              (throw 'syntax "Mismatched delimiters"))
 868                          (list (nth 1 op) x))))
 869                     ((and (not first)
 870                           (memq (nth 1 op) math-alg-inequalities)
 871                           (memq (car-safe x) math-alg-inequalities))
 872                      (require 'calc-ext)
 873                      (math-composite-inequalities x op))
 874                     (t (list (nth 1 op)
 875                              x
 876                              (math-read-expr-level (nth 3 op) exp-term))))
 877             first nil))
 878     x))
 879
 880 ;; calc-arg-values is defined in calc-ext.el, but is used here.
 881 (defvar calc-arg-values)
 882
 883 ;;;###autoload
 884 (defun calc-check-user-syntax (&optional x prec)
 885   (let ((p calc-user-parse-table)
 886         (matches nil)
 887         match rule)
 888     (while (and p
 889                 (or (not (progn
 890                            (setq rule (car (car p)))
 891                            (if x
 892                                (and (integerp (car rule))
 893                                     (>= (car rule) prec)
 894                                     (equal math-expr-data
 895                                            (car (setq rule (cdr rule)))))
 896                              (equal math-expr-data (car rule)))))
 897                     (let ((save-exp-pos math-exp-pos)
 898                           (save-exp-old-pos math-exp-old-pos)
 899                           (save-exp-token math-exp-token)
 900                           (save-exp-data math-expr-data))
 901                       (or (not (listp
 902                                 (setq matches (calc-match-user-syntax rule))))
 903                           (let ((args (progn
 904                                         (require 'calc-ext)
 905                                         calc-arg-values))
 906                                 (conds nil)
 907                                 temp)
 908                             (if x
 909                                 (setq matches (cons x matches)))
 910                             (setq match (cdr (car p)))
 911                             (while (and (eq (car-safe match)
 912                                             'calcFunc-condition)
 913                                         (= (length match) 3))
 914                               (setq conds (append (math-flatten-lands
 915                                                    (nth 2 match))
 916                                                   conds)
 917                                     match (nth 1 match)))
 918                             (while (and conds match)
 919                               (require 'calc-ext)
 920                               (cond ((eq (car-safe (car conds))
 921                                          'calcFunc-let)
 922                                      (setq temp (car conds))
 923                                      (or (= (length temp) 3)
 924                                          (and (= (length temp) 2)
 925                                               (eq (car-safe (nth 1 temp))
 926                                                   'calcFunc-assign)
 927                                               (= (length (nth 1 temp)) 3)
 928                                               (setq temp (nth 1 temp)))
 929                                          (setq match nil))
 930                                      (setq matches (cons
 931                                                     (math-normalize
 932                                                      (math-multi-subst
 933                                                       (nth 2 temp)
 934                                                       args matches))
 935                                                     matches)
 936                                            args (cons (nth 1 temp)
 937                                                       args)))
 938                                     ((and (eq (car-safe (car conds))
 939                                               'calcFunc-matches)
 940                                           (= (length (car conds)) 3))
 941                                      (setq temp (calcFunc-vmatches
 942                                                  (math-multi-subst
 943                                                   (nth 1 (car conds))
 944                                                   args matches)
 945                                                  (nth 2 (car conds))))
 946                                      (if (eq temp 0)
 947                                          (setq match nil)
 948                                        (while (setq temp (cdr temp))
 949                                          (setq matches (cons (nth 2 (car temp))
 950                                                              matches)
 951                                                args (cons (nth 1 (car temp))
 952                                                           args)))))
 953                                     (t
 954                                      (or (math-is-true (math-simplify
 955                                                         (math-multi-subst
 956                                                          (car conds)
 957                                                          args matches)))
 958                                          (setq match nil))))
 959                               (setq conds (cdr conds)))
 960                             (if match
 961                                 (not (setq match (math-multi-subst
 962                                                   match args matches)))
 963                               (setq math-exp-old-pos save-exp-old-pos
 964                                     math-exp-token save-exp-token
 965                                     math-expr-data save-exp-data
 966                                     math-exp-pos save-exp-pos)))))))
 967       (setq p (cdr p)))
 968     (and p match)))
 969
 970 ;;;###autoload
 971 (defun calc-match-user-syntax (p &optional term)
 972   (let ((matches nil)
 973         (save-exp-pos math-exp-pos)
 974         (save-exp-old-pos math-exp-old-pos)
 975         (save-exp-token math-exp-token)
 976         (save-exp-data math-expr-data)
 977         m)
 978     (while (and p
 979                 (cond ((stringp (car p))
 980                        (and (equal math-expr-data (car p))
 981                             (progn
 982                               (math-read-token)
 983                               t)))
 984                       ((integerp (car p))
 985                        (and (setq m (catch 'syntax
 986                                       (math-read-expr-level
 987                                        (car p)
 988                                        (if (cdr p)
 989                                            (if (consp (nth 1 p))
 990                                                (car (nth 1 (nth 1 p)))
 991                                              (nth 1 p))
 992                                          term))))
 993                             (not (stringp m))
 994                             (setq matches (nconc matches (list m)))))
 995                       ((eq (car (car p)) '\?)
 996                        (setq m (calc-match-user-syntax (nth 1 (car p))))
 997                        (or (nth 2 (car p))
 998                            (setq matches
 999                                  (nconc matches
1000                                         (list
1001                                          (cons 'vec (and (listp m) m))))))
1002                        (or (listp m) (not (nth 2 (car p)))
1003                            (not (eq (aref (car (nth 2 (car p))) 0) ?\$))
1004                            (eq math-exp-token 'end)))
1005                       (t
1006                        (setq m (calc-match-user-syntax (nth 1 (car p))
1007                                                        (car (nth 2 (car p)))))
1008                        (if (listp m)
1009                            (let ((vec (cons 'vec m))
1010                                  opos mm)
1011                              (while (and (listp
1012                                           (setq opos math-exp-pos
1013                                                 mm (calc-match-user-syntax
1014                                                     (or (nth 2 (car p))
1015                                                         (nth 1 (car p)))
1016                                                     (car (nth 2 (car p))))))
1017                                          (> math-exp-pos opos))
1018                                (setq vec (nconc vec mm)))
1019                              (setq matches (nconc matches (list vec))))
1020                          (and (eq (car (car p)) '*)
1021                               (setq matches (nconc matches (list '(vec)))))))))
1022       (setq p (cdr p)))
1023     (if p
1024         (setq math-exp-pos save-exp-pos
1025               math-exp-old-pos save-exp-old-pos
1026               math-exp-token save-exp-token
1027               math-expr-data save-exp-data
1028               matches "Failed"))
1029     matches))
1030
1031 ;;;###autoload
1032 (defun math-remove-dashes (x)
1033   (if (string-match "\\`\\(.*\\)-\\(.*\\)\\'" x)
1034       (math-remove-dashes
1035        (concat (math-match-substring x 1) "#" (math-match-substring x 2)))
1036     x))
1037
1038 (defun math-remove-percentsigns (x)
1039   (if (string-match "\\`\\(.*\\)%\\(.*\\)\\'" x)
1040       (math-remove-percentsigns
1041        (concat (math-match-substring x 1) "o'o" (math-match-substring x 2)))
1042     x))
1043
1044 (defun math-restore-dashes (x)
1045   (if (string-match "\\`\\(.*\\)[#_]\\(.*\\)\\'" x)
1046       (math-restore-dashes
1047        (concat (math-match-substring x 1) "-" (math-match-substring x 2)))
1048     x))
1049
1050 (defun math-restore-placeholders (x)
1051   "Replace placeholders by the proper characters in the symbol x.
1052 This includes `#' for `_' and `'' for `%'.
1053 If the current Calc language does not use placeholders, return nil."
1054   (if (or (memq calc-language calc-lang-allow-underscores)
1055           (memq calc-language calc-lang-allow-percentsigns))
1056       (let ((sx (symbol-name x)))
1057         (when (memq calc-language calc-lang-allow-percentsigns)
1058           (require 'calccomp)
1059           (setq sx (math-to-percentsigns sx)))
1060         (if (memq calc-language calc-lang-allow-underscores)
1061             (setq sx (math-string-restore-underscores sx)))
1062         (intern-soft sx))))
1063
1064 (defun math-string-restore-underscores (x)
1065   "Replace pound signs by underscores in the string x."
1066   (if (string-match "\\`\\(.*\\)#\\(.*\\)\\'" x)
1067       (math-string-restore-underscores
1068        (concat (math-match-substring x 1) "_" (math-match-substring x 2)))
1069     x))
1070
1071 ;;;###autoload
1072 (defun math-read-if (cond op)
1073   (let ((then (math-read-expr-level 0)))
1074     (or (equal math-expr-data ":")
1075         (throw 'syntax "Expected ':'"))
1076     (math-read-token)
1077     (list 'calcFunc-if cond then (math-read-expr-level (nth 3 op)))))
1078
1079 (defun math-factor-after ()
1080   (let ((math-exp-pos math-exp-pos)
1081         math-exp-old-pos math-exp-token math-expr-data)
1082     (math-read-token)
1083     (or (memq math-exp-token '(number symbol dollar hash string))
1084         (and (assoc math-expr-data '(("-") ("+") ("!") ("|") ("/")))
1085              (assoc (concat "u" math-expr-data) math-expr-opers))
1086         (eq (nth 2 (assoc math-expr-data math-expr-opers)) -1)
1087         (assoc math-expr-data '(("(") ("[") ("{"))))))
1088
1089 (defun math-read-factor ()
1090   (let ((math-expr-opers (math-expr-ops))
1091         op)
1092     (cond ((eq math-exp-token 'number)
1093            (let ((num (math-read-number math-expr-data)))
1094              (if (not num)
1095                  (progn
1096                    (setq math-exp-old-pos math-exp-pos)
1097                    (throw 'syntax "Bad format")))
1098              (math-read-token)
1099              (if (and math-read-expr-quotes
1100                       (consp num))
1101                  (list 'quote num)
1102                num)))
1103           ((and calc-user-parse-table
1104                 (setq op (calc-check-user-syntax)))
1105            op)
1106           ((or (equal math-expr-data "-")
1107                (equal math-expr-data "+")
1108                (equal math-expr-data "!")
1109                (equal math-expr-data "|")
1110                (equal math-expr-data "/"))
1111            (setq math-expr-data (concat "u" math-expr-data))
1112            (math-read-factor))
1113           ((and (setq op (assoc math-expr-data math-expr-opers))
1114                 (eq (nth 2 op) -1))
1115            (if (consp (nth 1 op))
1116                (funcall (car (nth 1 op)) op)
1117              (math-read-token)
1118              (let ((val (math-read-expr-level (nth 3 op))))
1119                (cond ((eq (nth 1 op) 'ident)
1120                       val)
1121                      ((and (Math-numberp val)
1122                            (equal (car op) "u-"))
1123                       (math-neg val))
1124                      (t (list (nth 1 op) val))))))
1125           ((eq math-exp-token 'symbol)
1126            (let ((sym (intern math-expr-data)))
1127              (math-read-token)
1128              (if (equal math-expr-data calc-function-open)
1129                  (let ((f (assq sym math-expr-function-mapping)))
1130                    (math-read-token)
1131                    (if (consp (cdr f))
1132                        (funcall (car (cdr f)) f sym)
1133                      (let ((args (if (or (equal math-expr-data calc-function-close)
1134                                          (eq math-exp-token 'end))
1135                                      nil
1136                                    (math-read-expr-list))))
1137                        (if (not (or (equal math-expr-data calc-function-close)
1138                                     (eq math-exp-token 'end)))
1139                            (throw 'syntax "Expected `)'"))
1140                        (math-read-token)
1141                        (if (and (memq calc-language
1142                                       calc-lang-parens-are-subscripts)
1143                                 args
1144                                 (require 'calc-ext)
1145                                 (let ((calc-matrix-mode 'scalar))
1146                                   (math-known-matrixp
1147                                    (list 'var sym
1148                                          (intern
1149                                           (concat "var-"
1150                                                   (symbol-name sym)))))))
1151                            (math-parse-fortran-subscr sym args)
1152                          (if f
1153                              (setq sym (cdr f))
1154                            (and (= (aref (symbol-name sym) 0) ?\\)
1155                                 (< (prefix-numeric-value calc-language-option)
1156                                    0)
1157                                 (setq sym (intern (substring (symbol-name sym)
1158                                                              1))))
1159                            (or (string-match "-" (symbol-name sym))
1160                                (setq sym (intern
1161                                           (concat "calcFunc-"
1162                                                   (symbol-name sym))))))
1163                          (cons sym args)))))
1164                (if math-read-expr-quotes
1165                    sym
1166                  (let ((val (list 'var
1167                                   (intern (math-remove-dashes
1168                                            (symbol-name sym)))
1169                                   (if (string-match "-" (symbol-name sym))
1170                                       sym
1171                                     (intern (concat "var-"
1172                                                     (symbol-name sym)))))))
1173                    (let ((v (or
1174                              (assq (nth 1 val) math-expr-variable-mapping)
1175                              (assq (math-restore-placeholders (nth 1 val))
1176                                    math-expr-variable-mapping))))
1177                      (and v (setq val (if (consp (cdr v))
1178                                           (funcall (car (cdr v)) v val)
1179                                         (list 'var
1180                                               (intern
1181                                                (substring (symbol-name (cdr v))
1182                                                           4))
1183                                               (cdr v))))))
1184                    (while (and (memq calc-language
1185                                      calc-lang-brackets-are-subscripts)
1186                                (equal math-expr-data "["))
1187                      (math-read-token)
1188                      (let ((el (math-read-expr-list)))
1189                        (while el
1190                          (setq val (append (list 'calcFunc-subscr val)
1191                                            (list (car el))))
1192                          (setq el (cdr el))))
1193                      (if (equal math-expr-data "]")
1194                          (math-read-token)
1195                        (throw 'syntax "Expected ']'")))
1196                    val)))))
1197           ((eq math-exp-token 'dollar)
1198            (let ((abs (if (> math-expr-data 0) math-expr-data (- math-expr-data))))
1199              (if (>= (length calc-dollar-values) abs)
1200                  (let ((num math-expr-data))
1201                    (math-read-token)
1202                    (setq calc-dollar-used (max calc-dollar-used num))
1203                    (math-check-complete (nth (1- abs) calc-dollar-values)))
1204                (throw 'syntax (if calc-dollar-values
1205                                   "Too many $'s"
1206                                 "$'s not allowed in this context")))))
1207           ((eq math-exp-token 'hash)
1208            (or calc-hashes-used
1209                (throw 'syntax "#'s not allowed in this context"))
1210            (require 'calc-ext)
1211            (if (<= math-expr-data (length calc-arg-values))
1212                (let ((num math-expr-data))
1213                  (math-read-token)
1214                  (setq calc-hashes-used (max calc-hashes-used num))
1215                  (nth (1- num) calc-arg-values))
1216              (throw 'syntax "Too many # arguments")))
1217           ((equal math-expr-data "(")
1218            (let* ((exp (let ((math-exp-keep-spaces nil))
1219                          (math-read-token)
1220                          (if (or (equal math-expr-data "\\dots")
1221                                  (equal math-expr-data "\\ldots"))
1222                              '(neg (var inf var-inf))
1223                            (math-read-expr-level 0)))))
1224              (let ((math-exp-keep-spaces nil))
1225                (cond
1226                 ((equal math-expr-data ",")
1227                  (progn
1228                    (math-read-token)
1229                    (let ((exp2 (math-read-expr-level 0)))
1230                      (setq exp
1231                            (if (and exp2 (Math-realp exp) (Math-realp exp2))
1232                                (math-normalize (list 'cplx exp exp2))
1233                              (list '+ exp (list '* exp2 '(var i var-i))))))))
1234                 ((equal math-expr-data ";")
1235                  (progn
1236                    (math-read-token)
1237                    (let ((exp2 (math-read-expr-level 0)))
1238                      (setq exp (if (and exp2 (Math-realp exp)
1239                                         (Math-anglep exp2))
1240                                    (math-normalize (list 'polar exp exp2))
1241                                  (require 'calc-ext)
1242                                  (list '* exp
1243                                        (list 'calcFunc-exp
1244                                              (list '*
1245                                                    (math-to-radians-2 exp2)
1246                                                    '(var i var-i)))))))))
1247                 ((or (equal math-expr-data "\\dots")
1248                      (equal math-expr-data "\\ldots"))
1249                  (progn
1250                    (math-read-token)
1251                    (let ((exp2 (if (or (equal math-expr-data ")")
1252                                        (equal math-expr-data "]")
1253                                        (eq math-exp-token 'end))
1254                                    '(var inf var-inf)
1255                                  (math-read-expr-level 0))))
1256                      (setq exp
1257                            (list 'intv
1258                                  (if (equal math-expr-data ")") 0 1)
1259                                  exp
1260                                  exp2)))))))
1261              (if (not (or (equal math-expr-data ")")
1262                           (and (equal math-expr-data "]") (eq (car-safe exp) 'intv))
1263                           (eq math-exp-token 'end)))
1264                  (throw 'syntax "Expected `)'"))
1265              (math-read-token)
1266              exp))
1267           ((eq math-exp-token 'string)
1268            (require 'calc-ext)
1269            (math-read-string))
1270           ((equal math-expr-data "[")
1271            (require 'calc-ext)
1272            (math-read-brackets t "]"))
1273           ((equal math-expr-data "{")
1274            (require 'calc-ext)
1275            (math-read-brackets nil "}"))
1276           ((equal math-expr-data "<")
1277            (require 'calc-ext)
1278            (math-read-angle-brackets))
1279           (t (throw 'syntax "Expected a number")))))
1280
1281 (provide 'calc-aent)
1282
1283 ;; Local variables:
1284 ;; generated-autoload-file: "calc-loaddefs.el"
1285 ;; End:
1286
1287 ;; arch-tag: 5599e45d-e51e-44bb-9a20-9f4ed8c96c32
1288 ;;; calc-aent.el ends here