1 ;;; calc-aent.el --- algebraic entry functions for Calc
3 ;; Copyright (C) 1990, 1991, 1992, 1993, 2001, 2002, 2003, 2004,
4 ;; 2005, 2006 Free Software Foundation, Inc.
6 ;; Author: Dave Gillespie <daveg@synaptics.com>
7 ;; Maintainer: Jay Belanger <belanger@truman.edu>
9 ;; This file is part of GNU Emacs.
11 ;; GNU Emacs is distributed in the hope that it will be useful,
12 ;; but WITHOUT ANY WARRANTY. No author or distributor
13 ;; accepts responsibility to anyone for the consequences of using it
14 ;; or for whether it serves any particular purpose or works at all,
15 ;; unless he says so in writing. Refer to the GNU Emacs General Public
16 ;; License for full details.
18 ;; Everyone is granted permission to copy, modify and redistribute
19 ;; GNU Emacs, but only under the conditions described in the
20 ;; GNU Emacs General Public License. A copy of this license is
21 ;; supposed to have been given to you along with GNU Emacs so you
22 ;; can know your rights and responsibilities. It should be in a
23 ;; file named COPYING. Among other things, the copyright notice
24 ;; and this notice must be preserved on all copies.
30 ;; This file is autoloaded from calc.el.
35 (defun calc-do-quick-calc ()
37 (if (eq major-mode 'calc-mode)
38 (calc-algebraic-entry t)
42 (let* ((calc-command-flags nil)
43 (calc-dollar-values calc-quick-prev-results)
45 (enable-recursive-minibuffers t)
46 (calc-language (if (memq calc-language '(nil big))
48 (entry (calc-do-alg-entry "" "Quick calc: " t))
49 (alg-exp (mapcar (function
51 (if (and (not (featurep 'calc-ext))
52 calc-previous-alg-entry
54 "\\`[-0-9._+*/^() ]+\\'"
55 calc-previous-alg-entry))
58 (math-evaluate-expr x))))
60 (when (and (= (length alg-exp) 1)
61 (eq (car-safe (car alg-exp)) 'calcFunc-assign)
62 (= (length (car alg-exp)) 3)
63 (eq (car-safe (nth 1 (car alg-exp))) 'var))
65 (set (nth 2 (nth 1 (car alg-exp))) (nth 2 (car alg-exp)))
66 (calc-refresh-evaltos (nth 2 (nth 1 (car alg-exp))))
67 (setq alg-exp (list (nth 2 (car alg-exp)))))
68 (setq calc-quick-prev-results alg-exp
69 buf (mapconcat (function (lambda (x)
70 (math-format-value x 1000)))
74 (if (and (= (length alg-exp) 1)
75 (memq (car-safe (car alg-exp)) '(nil bigpos bigneg))
77 (= calc-number-radix 10))
78 (setq buf (concat buf " ("
79 (let ((calc-number-radix 16))
80 (math-format-value (car alg-exp) 1000))
82 (let ((calc-number-radix 8))
83 (math-format-value (car alg-exp) 1000))
84 (if (and (integerp (car alg-exp))
86 (< (car alg-exp) 127))
87 (format ", \"%c\"" (car alg-exp))
90 (if (and (< (length buf) (frame-width)) (= (length entry) 1)
92 (let ((long (concat (math-format-value (car entry) 1000)
94 (if (<= (length long) (- (frame-width) 8))
97 (message "Result: %s" buf)))
98 (if (eq last-command-char 10)
100 (kill-new shortbuf)))))
102 (defun calc-do-calc-eval (str separator args)
108 ((and (consp str) (not (symbolp (car str))))
109 (let ((calc-language nil)
110 (math-expr-opers math-standard-opers)
111 (calc-internal-prec 12)
113 (calc-symbolic-mode nil)
114 (calc-matrix-mode nil)
115 (calc-angle-mode 'deg)
116 (calc-number-radix 10)
117 (calc-leading-zeros nil)
118 (calc-group-digits nil)
119 (calc-point-char ".")
120 (calc-frac-format '(":" nil))
121 (calc-prefer-frac nil)
122 (calc-hms-format "%s@ %s' %s\"")
123 (calc-date-format '((H ":" mm C SS pp " ")
124 Www " " Mmm " " D ", " YYYY))
125 (calc-float-format '(float 0))
126 (calc-full-float-format '(float 0))
127 (calc-complex-format nil)
128 (calc-matrix-just nil)
129 (calc-full-vectors t)
130 (calc-break-vectors nil)
131 (calc-vector-commas ",")
132 (calc-vector-brackets "[]")
133 (calc-matrix-brackets '(R O))
134 (calc-complex-mode 'cplx)
135 (calc-infinite-mode nil)
136 (calc-display-strings nil)
137 (calc-simplify-mode nil)
138 (calc-display-working-message 'lots)
141 (set (car strp) (nth 1 strp))
142 (setq strp (cdr (cdr strp))))
143 (calc-do-calc-eval (car str) separator args)))
144 ((eq separator 'eval)
146 ((eq separator 'macro)
148 (let* ((calc-buffer (current-buffer))
149 (calc-window (get-buffer-window calc-buffer))
150 (save-window (selected-window)))
154 (select-window calc-window)
155 (calc-execute-kbd-macro str nil (car args)))
156 (and (window-point save-window)
157 (select-window save-window)))
158 (save-window-excursion
159 (select-window (get-largest-window))
160 (switch-to-buffer calc-buffer)
161 (calc-execute-kbd-macro str nil (car args)))))
164 (or (not (integerp str))
166 (calc-pop (min str (calc-stack-size))))
171 (<= str (calc-stack-size))
172 (math-format-value (calc-top-n str (car args)) 1000)))
173 ((eq separator 'rawtop)
176 (<= str (calc-stack-size))
177 (calc-top-n str (car args))))
179 (let* ((calc-command-flags nil)
181 (calc-language (if (memq calc-language '(nil big))
182 'flat calc-language))
183 (calc-dollar-values (mapcar
188 (setq x (math-read-exprs x))
198 (res (if (stringp str)
199 (math-read-exprs str)
202 (if (eq (car res) 'error)
203 (calc-eval-error (cdr res))
204 (setq res (mapcar 'calc-normalize res))
205 (and (memq 'clear-message calc-command-flags)
207 (cond ((eq separator 'pred)
209 (if (= (length res) 1)
210 (math-is-true (car res))
211 (calc-eval-error '(0 "Single value expected"))))
213 (if (= (length res) 1)
215 (calc-eval-error '(0 "Single value expected"))))
216 ((eq separator 'list)
218 ((memq separator '(num rawnum))
219 (if (= (length res) 1)
220 (if (math-constp (car res))
221 (if (eq separator 'num)
222 (math-format-value (car res) 1000)
227 (calc-explain-why (car calc-next-why))
228 "Number expected"))))
229 (calc-eval-error '(0 "Single value expected"))))
230 ((eq separator 'push)
234 (setq buf (concat buf
235 (and buf (or separator ", "))
236 (math-format-value (car res) 1000))
240 (defvar calc-eval-error nil
241 "Determines how calc handles errors.
242 NIL means return a list containing the character position of error.
243 STRING means return error message as string rather than list.
244 T means abort and give an error message.")
246 (defun calc-eval-error (msg)
248 (if (eq calc-eval-error 'string)
250 (error "%s" (nth 1 msg)))
254 ;;;; Reading an expression in algebraic form.
256 (defun calc-auto-algebraic-entry (&optional prefix)
258 (calc-algebraic-entry prefix t))
260 (defun calc-algebraic-entry (&optional prefix auto)
263 (let ((calc-language (if prefix nil calc-language))
264 (math-expr-opers (if prefix math-standard-opers math-expr-opers)))
265 (calc-alg-entry (and auto (char-to-string last-command-char))))))
267 (defun calc-alg-entry (&optional initial prompt)
268 (let* ((sel-mode nil)
269 (calc-dollar-values (mapcar 'calc-get-stack-element
270 (nthcdr calc-stack-top calc-stack)))
273 (alg-exp (calc-do-alg-entry initial prompt t)))
274 (if (stringp alg-exp)
277 (calc-alg-edit alg-exp))
278 (let* ((calc-simplify-mode (if (eq last-command-char ?\C-j)
281 (nvals (mapcar 'calc-normalize alg-exp)))
283 (calc-record (if (featurep 'calc-ext) (car alg-exp) (car nvals))
285 (calc-pop-push-record-list calc-dollar-used
286 (and (not (equal (car alg-exp)
291 (setq alg-exp (cdr alg-exp)
293 calc-dollar-used 0)))
294 (calc-handle-whys))))
296 (defvar calc-alg-ent-map nil
297 "The keymap used for algebraic entry.")
299 (defvar calc-alg-ent-esc-map nil
300 "The keymap used for escapes in algebraic entry.")
302 (defvar calc-alg-exp)
304 (defun calc-do-alg-entry (&optional initial prompt no-normalize)
305 (let* ((calc-buffer (current-buffer))
306 (blink-paren-function 'calcAlg-blink-matching-open)
307 (calc-alg-exp 'error))
308 (unless calc-alg-ent-map
309 (setq calc-alg-ent-map (copy-keymap minibuffer-local-map))
310 (define-key calc-alg-ent-map "'" 'calcAlg-previous)
311 (define-key calc-alg-ent-map "`" 'calcAlg-edit)
312 (define-key calc-alg-ent-map "\C-m" 'calcAlg-enter)
313 (define-key calc-alg-ent-map "\C-j" 'calcAlg-enter)
315 (setq calc-alg-ent-esc-map (copy-keymap esc-map))
317 (aset (nth 1 calc-alg-ent-esc-map) i 'calcAlg-escape)
319 (define-key calc-alg-ent-map "\e" nil)
320 (if (eq calc-algebraic-mode 'total)
321 (define-key calc-alg-ent-map "\e" calc-alg-ent-esc-map)
322 (define-key calc-alg-ent-map "\ep" 'calcAlg-plus-minus)
323 (define-key calc-alg-ent-map "\em" 'calcAlg-mod)
324 (define-key calc-alg-ent-map "\e=" 'calcAlg-equals)
325 (define-key calc-alg-ent-map "\e\r" 'calcAlg-equals)
326 (define-key calc-alg-ent-map "\e%" 'self-insert-command))
327 (setq calc-aborted-prefix nil)
328 (let ((buf (read-from-minibuffer (or prompt "Algebraic: ")
330 calc-alg-ent-map nil)))
331 (when (eq calc-alg-exp 'error)
332 (when (eq (car-safe (setq calc-alg-exp (math-read-exprs buf))) 'error)
333 (setq calc-alg-exp nil)))
334 (setq calc-aborted-prefix "alg'")
336 (and calc-alg-exp (setq calc-alg-exp (mapcar 'calc-normalize calc-alg-exp))))
339 (defun calcAlg-plus-minus ()
341 (if (calc-minibuffer-contains ".* \\'")
345 (defun calcAlg-mod ()
347 (if (not (calc-minibuffer-contains ".* \\'"))
349 (if (calc-minibuffer-contains ".* mod +\\'")
350 (if calc-previous-modulo
351 (insert (math-format-flat-expr calc-previous-modulo 0))
355 (defun calcAlg-previous ()
357 (if (calc-minibuffer-contains "\\'")
358 (if calc-previous-alg-entry
359 (insert calc-previous-alg-entry)
363 (defun calcAlg-equals ()
367 (if (consp calc-alg-exp)
368 (progn (setq prefix-arg (length calc-alg-exp))
369 (calc-unread-command ?=)))))
371 (defun calcAlg-escape ()
373 (calc-unread-command)
376 (use-local-map calc-mode-map))
379 (defvar calc-plain-entry nil)
380 (defun calcAlg-edit ()
382 (if (or (not calc-plain-entry)
383 (calc-minibuffer-contains
384 "\\`\\([^\"]*\"[^\"]*\"\\)*[^\"]*\"[^\"]*\\'"))
386 (setq calc-alg-exp (minibuffer-contents))
387 (and (> (length calc-alg-exp) 0) (setq calc-previous-alg-entry calc-alg-exp))
392 (defun calcAlg-enter ()
394 (let* ((str (minibuffer-contents))
395 (exp (and (> (length str) 0)
397 (set-buffer calc-buffer)
398 (math-read-exprs str)))))
399 (if (eq (car-safe exp) 'error)
401 (goto-char (minibuffer-prompt-end))
402 (forward-char (nth 1 exp))
404 (calc-temp-minibuffer-message
405 (concat " [" (or (nth 2 exp) "Error") "]"))
406 (calc-clear-unread-commands))
407 (setq calc-alg-exp (if (calc-minibuffer-contains "\\` *\\[ *\\'")
410 (and (> (length str) 0) (setq calc-previous-alg-entry str))
413 (defun calcAlg-blink-matching-open ()
414 (let ((rightpt (point))
416 (rightchar (preceding-char))
422 (setq leftpt (scan-sexps rightpt -1)
423 leftchar (char-after leftpt))
426 (or (and (= rightchar ?\))
428 (and (= rightchar ?\])
432 (looking-at ".+\\(\\.\\.\\|\\\\dots\\|\\\\ldots\\)")))
433 (let ((leftsaved (aref (syntax-table) leftchar))
434 (rightsaved (aref (syntax-table) rightchar)))
437 (cond ((= leftchar ?\[)
438 (aset (syntax-table) leftchar (cons 4 ?\)))
439 (aset (syntax-table) rightchar (cons 5 ?\[)))
441 (aset (syntax-table) leftchar (cons 4 ?\]))
442 (aset (syntax-table) rightchar (cons 5 ?\())))
443 (blink-matching-open))
444 (aset (syntax-table) leftchar leftsaved)
445 (aset (syntax-table) rightchar rightsaved)))
446 (blink-matching-open))))
448 (defun calc-alg-digit-entry ()
450 (cond ((eq last-command-char ?e)
451 (if (> calc-number-radix 14) (format "%d.^" calc-number-radix) "1e"))
452 ((eq last-command-char ?#) (format "%d#" calc-number-radix))
453 ((eq last-command-char ?_) "-")
454 ((eq last-command-char ?@) "0@ ")
455 (t (char-to-string last-command-char)))))
457 ;; The variable calc-digit-value is initially declared in calc.el,
458 ;; but can be set by calcDigit-algebraic and calcDigit-edit.
459 (defvar calc-digit-value)
461 (defun calcDigit-algebraic ()
463 (if (calc-minibuffer-contains ".*[@oh] *[^'m ]+[^'m]*\\'")
465 (setq calc-digit-value (minibuffer-contents))
468 (defun calcDigit-edit ()
470 (calc-unread-command)
471 (setq calc-digit-value (minibuffer-contents))
475 ;;; Algebraic expression parsing. [Public]
477 (defvar math-read-replacement-list
479 ("±" "+/-") ; plus or minus
480 ("×" "*") ; multiplication sign
481 ("÷" ":") ; division sign
482 ("−" "-") ; subtraction sign
483 ("∕" "/") ; division sign
484 ("∗" "*") ; asterisk multiplication
485 ("∞" "inf") ; infinity symbol
539 "A list whose elements (old new) indicate replacements to make
540 in Calc algebraic input.")
542 (defvar math-read-superscripts
543 "⁰¹²³⁴⁵⁶⁷⁸⁹⁺⁻⁽⁾ⁿⁱ" ; 0123456789+-()ni
544 "A string consisting of the superscripts allowed by Calc.")
546 (defvar math-read-subscripts
547 "₀₁₂₃₄₅₆₇₈₉₊₋₍₎" ; 0123456789+-()
548 "A string consisting of the subscripts allowed by Calc.")
550 (defun math-read-preprocess-string (str)
551 "Replace some substrings of STR by Calc equivalents."
553 (replace-regexp-in-string (concat "[" math-read-superscripts "]+")
556 (replace-regexp-in-string (concat "[" math-read-subscripts "]+")
558 (let ((rep-list math-read-replacement-list))
561 (replace-regexp-in-string (nth 0 (car rep-list))
562 (nth 1 (car rep-list)) str))
563 (setq rep-list (cdr rep-list))))
566 ;; The next few variables are local to math-read-exprs (and math-read-expr
567 ;; in calc-ext.el), but are set in functions they call.
569 (defvar math-exp-pos)
570 (defvar math-exp-str)
571 (defvar math-exp-old-pos)
572 (defvar math-exp-token)
573 (defvar math-exp-keep-spaces)
574 (defvar math-expr-data)
576 (defun math-read-exprs (math-exp-str)
577 (let ((math-exp-pos 0)
579 (math-exp-keep-spaces nil)
580 math-exp-token math-expr-data)
581 (setq math-exp-str (math-read-preprocess-string math-exp-str))
582 (if calc-language-input-filter
583 (setq math-exp-str (funcall calc-language-input-filter math-exp-str)))
584 (while (setq math-exp-token (string-match "\\.\\.\\([^.]\\|.[^.]\\)" math-exp-str))
585 (setq math-exp-str (concat (substring math-exp-str 0 math-exp-token) "\\dots"
586 (substring math-exp-str (+ math-exp-token 2)))))
587 (math-build-parse-table)
589 (let ((val (catch 'syntax (math-read-expr-list))))
591 (list 'error math-exp-old-pos val)
592 (if (equal math-exp-token 'end)
594 (list 'error math-exp-old-pos "Syntax error"))))))
596 (defun math-read-expr-list ()
597 (let* ((math-exp-keep-spaces nil)
598 (val (list (math-read-expr-level 0)))
600 (while (equal math-expr-data ",")
602 (let ((rest (list (math-read-expr-level 0))))
607 (defvar calc-user-parse-table nil)
608 (defvar calc-last-main-parse-table nil)
609 (defvar calc-last-lang-parse-table nil)
610 (defvar calc-user-tokens nil)
611 (defvar calc-user-token-chars nil)
613 (defvar math-toks nil
614 "Tokens to pass between math-build-parse-table and math-find-user-tokens.")
616 (defun math-build-parse-table ()
617 (let ((mtab (cdr (assq nil calc-user-parse-tables)))
618 (ltab (cdr (assq calc-language calc-user-parse-tables))))
619 (or (and (eq mtab calc-last-main-parse-table)
620 (eq ltab calc-last-lang-parse-table))
621 (let ((p (append mtab ltab))
623 (setq calc-user-parse-table p)
624 (setq calc-user-token-chars nil)
626 (math-find-user-tokens (car (car p)))
628 (setq calc-user-tokens (mapconcat 'identity
629 (sort (mapcar 'car math-toks)
630 (function (lambda (x y)
634 calc-last-main-parse-table mtab
635 calc-last-lang-parse-table ltab)))))
637 (defun math-find-user-tokens (p)
639 (cond ((and (stringp (car p))
640 (or (> (length (car p)) 1) (equal (car p) "$")
641 (equal (car p) "\""))
642 (string-match "[^a-zA-Z0-9]" (car p)))
643 (let ((s (regexp-quote (car p))))
644 (if (string-match "\\`[a-zA-Z0-9]" s)
645 (setq s (concat "\\<" s)))
646 (if (string-match "[a-zA-Z0-9]\\'" s)
647 (setq s (concat s "\\>")))
648 (or (assoc s math-toks)
650 (setq math-toks (cons (list s) math-toks))
651 (or (memq (aref (car p) 0) calc-user-token-chars)
652 (setq calc-user-token-chars
653 (cons (aref (car p) 0)
654 calc-user-token-chars)))))))
656 (math-find-user-tokens (nth 1 (car p)))
657 (or (eq (car (car p)) '\?)
658 (math-find-user-tokens (nth 2 (car p))))))
661 (defun math-read-token ()
662 (if (>= math-exp-pos (length math-exp-str))
663 (setq math-exp-old-pos math-exp-pos
665 math-expr-data "\000")
666 (let ((ch (aref math-exp-str math-exp-pos)))
667 (setq math-exp-old-pos math-exp-pos)
668 (cond ((memq ch '(32 10 9))
669 (setq math-exp-pos (1+ math-exp-pos))
670 (if math-exp-keep-spaces
671 (setq math-exp-token 'space
674 ((and (memq ch calc-user-token-chars)
675 (let ((case-fold-search nil))
676 (eq (string-match calc-user-tokens math-exp-str math-exp-pos)
678 (setq math-exp-token 'punc
679 math-expr-data (math-match-substring math-exp-str 0)
680 math-exp-pos (match-end 0)))
681 ((or (and (>= ch ?a) (<= ch ?z))
682 (and (>= ch ?A) (<= ch ?Z)))
683 (string-match (if (memq calc-language '(c fortran pascal maple))
686 math-exp-str math-exp-pos)
687 (setq math-exp-token 'symbol
688 math-exp-pos (match-end 0)
689 math-expr-data (math-restore-dashes
690 (math-match-substring math-exp-str 0)))
691 (if (eq calc-language 'eqn)
692 (let ((code (assoc math-expr-data math-eqn-ignore-words)))
696 ((consp (nth 1 code))
698 (if (assoc math-expr-data (cdr code))
699 (setq math-expr-data (format "%s %s"
700 (car code) math-expr-data))))
701 ((eq (nth 1 code) 'punc)
702 (setq math-exp-token 'punc
703 math-expr-data (nth 2 code)))
706 (math-read-token))))))
707 ((or (and (>= ch ?0) (<= ch ?9))
709 (eq (string-match "\\.[0-9]" math-exp-str math-exp-pos)
712 (eq (string-match "_\\.?[0-9]" math-exp-str math-exp-pos)
714 (or (eq math-exp-pos 0)
715 (and (memq calc-language '(nil flat big unform
717 (eq (string-match "[^])}\"a-zA-Z0-9'$]_"
718 math-exp-str (1- math-exp-pos))
719 (1- math-exp-pos))))))
720 (or (and (eq calc-language 'c)
721 (string-match "0[xX][0-9a-fA-F]+" math-exp-str math-exp-pos))
722 (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]+\\)?\"?\\)?"
723 math-exp-str math-exp-pos))
724 (setq math-exp-token 'number
725 math-expr-data (math-match-substring math-exp-str 0)
726 math-exp-pos (match-end 0)))
728 (if (and (eq calc-language 'pascal)
730 "\\(\\$[0-9a-fA-F]+\\)\\($\\|[^0-9a-zA-Z]\\)"
731 math-exp-str math-exp-pos)
733 (setq math-exp-token 'number
734 math-expr-data (math-match-substring math-exp-str 1)
735 math-exp-pos (match-end 1))
736 (if (eq (string-match "\\$\\([1-9][0-9]*\\)" math-exp-str math-exp-pos)
738 (setq math-expr-data (- (string-to-number (math-match-substring
740 (string-match "\\$+" math-exp-str math-exp-pos)
741 (setq math-expr-data (- (match-end 0) (match-beginning 0))))
742 (setq math-exp-token 'dollar
743 math-exp-pos (match-end 0))))
745 (if (eq (string-match "#\\([1-9][0-9]*\\)" math-exp-str math-exp-pos)
747 (setq math-expr-data (string-to-number
748 (math-match-substring math-exp-str 1))
749 math-exp-pos (match-end 0))
750 (setq math-expr-data 1
751 math-exp-pos (1+ math-exp-pos)))
752 (setq math-exp-token 'hash))
753 ((eq (string-match "~=\\|<=\\|>=\\|<>\\|/=\\|\\+/-\\|\\\\dots\\|\\\\ldots\\|\\*\\*\\|<<\\|>>\\|==\\|!=\\|&&&\\||||\\|!!!\\|&&\\|||\\|!!\\|:=\\|::\\|=>"
754 math-exp-str math-exp-pos)
756 (setq math-exp-token 'punc
757 math-expr-data (math-match-substring math-exp-str 0)
758 math-exp-pos (match-end 0)))
760 (string-match "\\(\"\\([^\"\\]\\|\\\\.\\)*\\)\\(\"\\|\\'\\)"
761 math-exp-str math-exp-pos))
762 (if (eq calc-language 'eqn)
764 (setq math-exp-str (copy-sequence math-exp-str))
765 (aset math-exp-str (match-beginning 1) ?\{)
766 (if (< (match-end 1) (length math-exp-str))
767 (aset math-exp-str (match-end 1) ?\}))
769 (setq math-exp-token 'string
770 math-expr-data (math-match-substring math-exp-str 1)
771 math-exp-pos (match-end 0))))
772 ((and (= ch ?\\) (eq calc-language 'tex)
773 (< math-exp-pos (1- (length math-exp-str))))
774 (or (string-match "\\\\hbox *{\\([a-zA-Z0-9]+\\)}"
775 math-exp-str math-exp-pos)
776 (string-match "\\(\\\\\\([a-zA-Z]+\\|[^a-zA-Z]\\)\\)"
777 math-exp-str math-exp-pos))
778 (setq math-exp-token 'symbol
779 math-exp-pos (match-end 0)
780 math-expr-data (math-restore-dashes
781 (math-match-substring math-exp-str 1)))
782 (let ((code (assoc math-expr-data math-latex-ignore-words)))
786 ((eq (nth 1 code) 'punc)
787 (setq math-exp-token 'punc
788 math-expr-data (nth 2 code)))
789 ((and (eq (nth 1 code) 'mat)
790 (string-match " *{" math-exp-str math-exp-pos))
791 (setq math-exp-pos (match-end 0)
794 (let ((right (string-match "}" math-exp-str math-exp-pos)))
796 (setq math-exp-str (copy-sequence math-exp-str))
797 (aset math-exp-str right ?\])))))))
798 ((and (= ch ?\\) (eq calc-language 'latex)
799 (< math-exp-pos (1- (length math-exp-str))))
800 (or (string-match "\\\\hbox *{\\([a-zA-Z0-9]+\\)}"
801 math-exp-str math-exp-pos)
802 (string-match "\\\\text *{\\([a-zA-Z0-9]+\\)}"
803 math-exp-str math-exp-pos)
804 (string-match "\\(\\\\\\([a-zA-Z]+\\|[^a-zA-Z]\\)\\)"
805 math-exp-str math-exp-pos))
806 (setq math-exp-token 'symbol
807 math-exp-pos (match-end 0)
808 math-expr-data (math-restore-dashes
809 (math-match-substring math-exp-str 1)))
810 (let ((code (assoc math-expr-data math-tex-ignore-words))
815 ((eq (nth 1 code) 'punc)
816 (setq math-exp-token 'punc
817 math-expr-data (nth 2 code)))
818 ((and (eq (nth 1 code) 'begenv)
819 (string-match " *{\\([^}]*\\)}" math-exp-str math-exp-pos))
820 (setq math-exp-pos (match-end 0)
821 envname (match-string 1 math-exp-str)
824 (cond ((or (string= envname "matrix")
825 (string= envname "bmatrix")
826 (string= envname "smallmatrix")
827 (string= envname "pmatrix"))
828 (if (string-match (concat "\\\\end{" envname "}")
829 math-exp-str math-exp-pos)
831 (replace-match "]" t t math-exp-str))
832 (error "%s" (concat "No closing \\end{" envname "}"))))))
833 ((and (eq (nth 1 code) 'mat)
834 (string-match " *{" math-exp-str math-exp-pos))
835 (setq math-exp-pos (match-end 0)
838 (let ((right (string-match "}" math-exp-str math-exp-pos)))
840 (setq math-exp-str (copy-sequence math-exp-str))
841 (aset math-exp-str right ?\])))))))
842 ((and (= ch ?\.) (eq calc-language 'fortran)
843 (eq (string-match "\\.[a-zA-Z][a-zA-Z][a-zA-Z]?\\."
844 math-exp-str math-exp-pos) math-exp-pos))
845 (setq math-exp-token 'punc
846 math-expr-data (upcase (math-match-substring math-exp-str 0))
847 math-exp-pos (match-end 0)))
848 ((and (eq calc-language 'math)
849 (eq (string-match "\\[\\[\\|->\\|:>" math-exp-str math-exp-pos)
851 (setq math-exp-token 'punc
852 math-expr-data (math-match-substring math-exp-str 0)
853 math-exp-pos (match-end 0)))
854 ((and (eq calc-language 'eqn)
855 (eq (string-match "->\\|<-\\|+-\\|\\\\dots\\|~\\|\\^"
856 math-exp-str math-exp-pos)
858 (setq math-exp-token 'punc
859 math-expr-data (math-match-substring math-exp-str 0)
860 math-exp-pos (match-end 0))
861 (and (eq (string-match "\\\\dots\\." math-exp-str math-exp-pos)
863 (setq math-exp-pos (match-end 0)))
864 (if (memq (aref math-expr-data 0) '(?~ ?^))
866 ((eq (string-match "%%.*$" math-exp-str math-exp-pos) math-exp-pos)
867 (setq math-exp-pos (match-end 0))
870 (if (and (eq ch ?\{) (memq calc-language '(tex latex eqn)))
872 (if (and (eq ch ?\}) (memq calc-language '(tex latex eqn)))
874 (if (and (eq ch ?\&) (memq calc-language '(tex latex)))
876 (setq math-exp-token 'punc
877 math-expr-data (char-to-string ch)
878 math-exp-pos (1+ math-exp-pos)))))))
880 (defconst math-alg-inequalities
881 '(calcFunc-lt calcFunc-gt calcFunc-leq calcFunc-geq
882 calcFunc-eq calcFunc-neq))
884 (defun math-read-expr-level (exp-prec &optional exp-term)
885 (let* ((x (math-read-factor)) (first t) op op2)
886 (while (and (or (and calc-user-parse-table
887 (setq op (calc-check-user-syntax x exp-prec))
889 op '("2x" ident 999999 -1)))
890 (and (setq op (assoc math-expr-data math-expr-opers))
892 (or (and (setq op2 (assoc
894 (cdr (memq op math-expr-opers))))
895 (eq (= (nth 3 op) -1)
897 (eq (= (nth 3 op2) -1)
898 (not (math-factor-after)))
901 (and (or (eq (nth 2 op) -1)
902 (memq math-exp-token '(symbol number dollar hash))
903 (equal math-expr-data "(")
904 (and (equal math-expr-data "[")
905 (not (eq calc-language 'math))
906 (not (and math-exp-keep-spaces
907 (eq (car-safe x) 'vec)))))
908 (or (not (setq op (assoc math-expr-data math-expr-opers)))
910 (or (not calc-user-parse-table)
911 (not (eq math-exp-token 'symbol))
912 (let ((p calc-user-parse-table))
915 (car (car (car p)))))
917 (nth 1 (car (car p)))
921 (setq op (assoc "2x" math-expr-opers))))
922 (not (and exp-term (equal math-expr-data exp-term)))
923 (>= (nth 2 op) exp-prec))
924 (if (not (equal (car op) "2x"))
926 (and (memq (nth 1 op) '(sdev mod))
928 (setq x (cond ((consp (nth 1 op))
929 (funcall (car (nth 1 op)) x op))
931 (if (eq (nth 1 op) 'ident)
933 (if (eq (nth 1 op) 'closing)
934 (if (eq (nth 2 op) exp-prec)
938 (throw 'syntax "Mismatched delimiters"))
939 (list (nth 1 op) x))))
941 (memq (nth 1 op) math-alg-inequalities)
942 (memq (car-safe x) math-alg-inequalities))
944 (math-composite-inequalities x op))
947 (math-read-expr-level (nth 3 op) exp-term))))
951 ;; calc-arg-values is defined in calc-ext.el, but is used here.
952 (defvar calc-arg-values)
954 (defun calc-check-user-syntax (&optional x prec)
955 (let ((p calc-user-parse-table)
960 (setq rule (car (car p)))
962 (and (integerp (car rule))
964 (equal math-expr-data
965 (car (setq rule (cdr rule)))))
966 (equal math-expr-data (car rule)))))
967 (let ((save-exp-pos math-exp-pos)
968 (save-exp-old-pos math-exp-old-pos)
969 (save-exp-token math-exp-token)
970 (save-exp-data math-expr-data))
972 (setq matches (calc-match-user-syntax rule))))
979 (setq matches (cons x matches)))
980 (setq match (cdr (car p)))
981 (while (and (eq (car-safe match)
983 (= (length match) 3))
984 (setq conds (append (math-flatten-lands
987 match (nth 1 match)))
988 (while (and conds match)
990 (cond ((eq (car-safe (car conds))
992 (setq temp (car conds))
993 (or (= (length temp) 3)
994 (and (= (length temp) 2)
995 (eq (car-safe (nth 1 temp))
997 (= (length (nth 1 temp)) 3)
998 (setq temp (nth 1 temp)))
1006 args (cons (nth 1 temp)
1008 ((and (eq (car-safe (car conds))
1010 (= (length (car conds)) 3))
1011 (setq temp (calcFunc-vmatches
1015 (nth 2 (car conds))))
1018 (while (setq temp (cdr temp))
1019 (setq matches (cons (nth 2 (car temp))
1021 args (cons (nth 1 (car temp))
1024 (or (math-is-true (math-simplify
1029 (setq conds (cdr conds)))
1031 (not (setq match (math-multi-subst
1032 match args matches)))
1033 (setq math-exp-old-pos save-exp-old-pos
1034 math-exp-token save-exp-token
1035 math-expr-data save-exp-data
1036 math-exp-pos save-exp-pos)))))))
1040 (defun calc-match-user-syntax (p &optional term)
1042 (save-exp-pos math-exp-pos)
1043 (save-exp-old-pos math-exp-old-pos)
1044 (save-exp-token math-exp-token)
1045 (save-exp-data math-expr-data)
1048 (cond ((stringp (car p))
1049 (and (equal math-expr-data (car p))
1054 (and (setq m (catch 'syntax
1055 (math-read-expr-level
1058 (if (consp (nth 1 p))
1059 (car (nth 1 (nth 1 p)))
1063 (setq matches (nconc matches (list m)))))
1064 ((eq (car (car p)) '\?)
1065 (setq m (calc-match-user-syntax (nth 1 (car p))))
1070 (cons 'vec (and (listp m) m))))))
1071 (or (listp m) (not (nth 2 (car p)))
1072 (not (eq (aref (car (nth 2 (car p))) 0) ?\$))
1073 (eq math-exp-token 'end)))
1075 (setq m (calc-match-user-syntax (nth 1 (car p))
1076 (car (nth 2 (car p)))))
1078 (let ((vec (cons 'vec m))
1081 (setq opos math-exp-pos
1082 mm (calc-match-user-syntax
1085 (car (nth 2 (car p))))))
1086 (> math-exp-pos opos))
1087 (setq vec (nconc vec mm)))
1088 (setq matches (nconc matches (list vec))))
1089 (and (eq (car (car p)) '*)
1090 (setq matches (nconc matches (list '(vec)))))))))
1093 (setq math-exp-pos save-exp-pos
1094 math-exp-old-pos save-exp-old-pos
1095 math-exp-token save-exp-token
1096 math-expr-data save-exp-data
1100 (defun math-remove-dashes (x)
1101 (if (string-match "\\`\\(.*\\)-\\(.*\\)\\'" x)
1103 (concat (math-match-substring x 1) "#" (math-match-substring x 2)))
1106 (defun math-restore-dashes (x)
1107 (if (string-match "\\`\\(.*\\)[#_]\\(.*\\)\\'" x)
1108 (math-restore-dashes
1109 (concat (math-match-substring x 1) "-" (math-match-substring x 2)))
1112 (defun math-read-if (cond op)
1113 (let ((then (math-read-expr-level 0)))
1114 (or (equal math-expr-data ":")
1115 (throw 'syntax "Expected ':'"))
1117 (list 'calcFunc-if cond then (math-read-expr-level (nth 3 op)))))
1119 (defun math-factor-after ()
1120 (let ((math-exp-pos math-exp-pos)
1121 math-exp-old-pos math-exp-token math-expr-data)
1123 (or (memq math-exp-token '(number symbol dollar hash string))
1124 (and (assoc math-expr-data '(("-") ("+") ("!") ("|") ("/")))
1125 (assoc (concat "u" math-expr-data) math-expr-opers))
1126 (eq (nth 2 (assoc math-expr-data math-expr-opers)) -1)
1127 (assoc math-expr-data '(("(") ("[") ("{"))))))
1129 (defun math-read-factor ()
1131 (cond ((eq math-exp-token 'number)
1132 (let ((num (math-read-number math-expr-data)))
1135 (setq math-exp-old-pos math-exp-pos)
1136 (throw 'syntax "Bad format")))
1138 (if (and math-read-expr-quotes
1142 ((and calc-user-parse-table
1143 (setq op (calc-check-user-syntax)))
1145 ((or (equal math-expr-data "-")
1146 (equal math-expr-data "+")
1147 (equal math-expr-data "!")
1148 (equal math-expr-data "|")
1149 (equal math-expr-data "/"))
1150 (setq math-expr-data (concat "u" math-expr-data))
1152 ((and (setq op (assoc math-expr-data math-expr-opers))
1154 (if (consp (nth 1 op))
1155 (funcall (car (nth 1 op)) op)
1157 (let ((val (math-read-expr-level (nth 3 op))))
1158 (cond ((eq (nth 1 op) 'ident)
1160 ((and (Math-numberp val)
1161 (equal (car op) "u-"))
1163 (t (list (nth 1 op) val))))))
1164 ((eq math-exp-token 'symbol)
1165 (let ((sym (intern math-expr-data)))
1167 (if (equal math-expr-data calc-function-open)
1168 (let ((f (assq sym math-expr-function-mapping)))
1171 (funcall (car (cdr f)) f sym)
1172 (let ((args (if (or (equal math-expr-data calc-function-close)
1173 (eq math-exp-token 'end))
1175 (math-read-expr-list))))
1176 (if (not (or (equal math-expr-data calc-function-close)
1177 (eq math-exp-token 'end)))
1178 (throw 'syntax "Expected `)'"))
1180 (if (and (eq calc-language 'fortran) args
1182 (let ((calc-matrix-mode 'scalar))
1187 (symbol-name sym)))))))
1188 (math-parse-fortran-subscr sym args)
1191 (and (= (aref (symbol-name sym) 0) ?\\)
1192 (< (prefix-numeric-value calc-language-option)
1194 (setq sym (intern (substring (symbol-name sym)
1196 (or (string-match "-" (symbol-name sym))
1199 (symbol-name sym))))))
1201 (if math-read-expr-quotes
1203 (let ((val (list 'var
1204 (intern (math-remove-dashes
1206 (if (string-match "-" (symbol-name sym))
1208 (intern (concat "var-"
1209 (symbol-name sym)))))))
1210 (let ((v (assq (nth 1 val) math-expr-variable-mapping)))
1211 (and v (setq val (if (consp (cdr v))
1212 (funcall (car (cdr v)) v val)
1215 (substring (symbol-name (cdr v))
1218 (while (and (memq calc-language '(c pascal maple))
1219 (equal math-expr-data "["))
1221 (setq val (append (list 'calcFunc-subscr val)
1222 (math-read-expr-list)))
1223 (if (equal math-expr-data "]")
1225 (throw 'syntax "Expected ']'")))
1227 ((eq math-exp-token 'dollar)
1228 (let ((abs (if (> math-expr-data 0) math-expr-data (- math-expr-data))))
1229 (if (>= (length calc-dollar-values) abs)
1230 (let ((num math-expr-data))
1232 (setq calc-dollar-used (max calc-dollar-used num))
1233 (math-check-complete (nth (1- abs) calc-dollar-values)))
1234 (throw 'syntax (if calc-dollar-values
1236 "$'s not allowed in this context")))))
1237 ((eq math-exp-token 'hash)
1238 (or calc-hashes-used
1239 (throw 'syntax "#'s not allowed in this context"))
1241 (if (<= math-expr-data (length calc-arg-values))
1242 (let ((num math-expr-data))
1244 (setq calc-hashes-used (max calc-hashes-used num))
1245 (nth (1- num) calc-arg-values))
1246 (throw 'syntax "Too many # arguments")))
1247 ((equal math-expr-data "(")
1248 (let* ((exp (let ((math-exp-keep-spaces nil))
1250 (if (or (equal math-expr-data "\\dots")
1251 (equal math-expr-data "\\ldots"))
1252 '(neg (var inf var-inf))
1253 (math-read-expr-level 0)))))
1254 (let ((math-exp-keep-spaces nil))
1256 ((equal math-expr-data ",")
1259 (let ((exp2 (math-read-expr-level 0)))
1261 (if (and exp2 (Math-realp exp) (Math-realp exp2))
1262 (math-normalize (list 'cplx exp exp2))
1263 (list '+ exp (list '* exp2 '(var i var-i))))))))
1264 ((equal math-expr-data ";")
1267 (let ((exp2 (math-read-expr-level 0)))
1268 (setq exp (if (and exp2 (Math-realp exp)
1270 (math-normalize (list 'polar exp exp2))
1275 (math-to-radians-2 exp2)
1276 '(var i var-i)))))))))
1277 ((or (equal math-expr-data "\\dots")
1278 (equal math-expr-data "\\ldots"))
1281 (let ((exp2 (if (or (equal math-expr-data ")")
1282 (equal math-expr-data "]")
1283 (eq math-exp-token 'end))
1285 (math-read-expr-level 0))))
1288 (if (equal math-expr-data ")") 0 1)
1291 (if (not (or (equal math-expr-data ")")
1292 (and (equal math-expr-data "]") (eq (car-safe exp) 'intv))
1293 (eq math-exp-token 'end)))
1294 (throw 'syntax "Expected `)'"))
1297 ((eq math-exp-token 'string)
1300 ((equal math-expr-data "[")
1302 (math-read-brackets t "]"))
1303 ((equal math-expr-data "{")
1305 (math-read-brackets nil "}"))
1306 ((equal math-expr-data "<")
1308 (math-read-angle-brackets))
1309 (t (throw 'syntax "Expected a number")))))
1311 (provide 'calc-aent)
1313 ;;; arch-tag: 5599e45d-e51e-44bb-9a20-9f4ed8c96c32
1314 ;;; calc-aent.el ends here