Skip to content
Fetching contributors…
Cannot retrieve contributors at this time
1273 lines (1202 sloc) 41.5 KB
;;; calc-aent.el --- algebraic entry functions for Calc
;; Copyright (C) 1990-1993, 2001-2015 Free Software Foundation, Inc.
;; Author: Dave Gillespie <>
;; Maintainer: Jay Belanger <>
;; This file is part of GNU Emacs.
;; GNU Emacs is free software: you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation, either version 3 of the License, or
;; (at your option) any later version.
;; GNU Emacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; GNU General Public License for more details.
;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs. If not, see <>.
;;; Commentary:
;;; Code:
;; This file is autoloaded from calc.el.
(require 'calc)
(require 'calc-macs)
;; Declare functions which are defined elsewhere.
(declare-function calc-refresh-evaltos "calc-ext" (&optional which-var))
(declare-function calc-execute-kbd-macro "calc-prog" (mac arg &rest prefix))
(declare-function math-is-true "calc-ext" (expr))
(declare-function calc-explain-why "calc-stuff" (why &optional more))
(declare-function calc-alg-edit "calc-yank" (str))
(declare-function math-composite-inequalities "calc-prog" (x op))
(declare-function math-flatten-lands "calc-rewr" (expr))
(declare-function math-multi-subst "calc-map" (expr olds news))
(declare-function calcFunc-vmatches "calc-rewr" (expr pat))
(declare-function math-simplify "calc-alg" (top-expr))
(declare-function math-known-matrixp "calc-arith" (a))
(declare-function math-parse-fortran-subscr "calc-lang" (sym args))
(declare-function math-to-radians-2 "calc-math" (a &optional force-symbolic))
(declare-function math-read-string "calc-ext" ())
(declare-function math-read-brackets "calc-vec" (space-sep math-rb-close))
(declare-function math-read-angle-brackets "calc-forms" ())
(declare-function math-to-percentsigns "calccomp" (x))
(defvar calc-quick-calc-history nil
"The history list for quick-calc.")
(defun calc-do-quick-calc ()
(require 'calc-ext)
(if (eq major-mode 'calc-mode)
(calc-algebraic-entry t)
(let (buf shortbuf)
(let* ((calc-command-flags nil)
(calc-dollar-values calc-quick-prev-results)
(calc-dollar-used 0)
(enable-recursive-minibuffers t)
(calc-language (if (memq calc-language '(nil big))
'flat calc-language))
(entry (calc-do-alg-entry "" "Quick calc: " t 'calc-quick-calc-history))
(alg-exp (mapcar 'math-evaluate-expr entry)))
(when (and (= (length alg-exp) 1)
(eq (car-safe (car alg-exp)) 'calcFunc-assign)
(= (length (car alg-exp)) 3)
(eq (car-safe (nth 1 (car alg-exp))) 'var))
(set (nth 2 (nth 1 (car alg-exp))) (nth 2 (car alg-exp)))
(calc-refresh-evaltos (nth 2 (nth 1 (car alg-exp))))
(setq alg-exp (list (nth 2 (car alg-exp)))))
(setq calc-quick-prev-results alg-exp
buf (mapconcat (function (lambda (x)
(math-format-value x 1000)))
" ")
shortbuf buf)
(if (and (= (length alg-exp) 1)
(memq (car-safe (car alg-exp)) '(nil bigpos bigneg))
(< (length buf) 20)
(= calc-number-radix 10))
(setq buf (concat buf " ("
(let ((calc-number-radix 16))
(math-format-value (car alg-exp) 1000))
", "
(let ((calc-number-radix 8))
(math-format-value (car alg-exp) 1000))
", "
(let ((calc-number-radix 2))
(math-format-value (car alg-exp) 1000))
(if (and (integerp (car alg-exp))
(> (car alg-exp) 0)
(< (car alg-exp) 127))
(format ", \"%c\"" (car alg-exp))
(if (and (< (length buf) (frame-width)) (= (length entry) 1)
(featurep 'calc-ext))
(let ((long (concat (math-format-value (car entry) 1000)
" => " buf)))
(if (<= (length long) (- (frame-width) 8))
(setq buf long))))
(message "Result: %s" buf)))
(if (eq last-command-event 10)
(insert shortbuf)
(kill-new shortbuf)))))
(defun calc-do-calc-eval (str separator args)
(catch 'calc-error
((and (consp str) (not (symbolp (car str))))
(let ((calc-language nil)
(math-expr-opers (math-standard-ops))
(calc-internal-prec 12)
(calc-word-size 32)
(calc-symbolic-mode nil)
(calc-matrix-mode nil)
(calc-angle-mode 'deg)
(calc-number-radix 10)
(calc-twos-complement-mode nil)
(calc-leading-zeros nil)
(calc-group-digits nil)
(calc-point-char ".")
(calc-frac-format '(":" nil))
(calc-prefer-frac nil)
(calc-hms-format "%s@ %s' %s\"")
(calc-date-format '((H ":" mm C SS pp " ")
Www " " Mmm " " D ", " YYYY))
(calc-float-format '(float 0))
(calc-full-float-format '(float 0))
(calc-complex-format nil)
(calc-matrix-just nil)
(calc-full-vectors t)
(calc-break-vectors nil)
(calc-vector-commas ",")
(calc-vector-brackets "[]")
(calc-matrix-brackets '(R O))
(calc-complex-mode 'cplx)
(calc-infinite-mode nil)
(calc-display-strings nil)
(calc-simplify-mode nil)
(calc-display-working-message 'lots)
(strp (cdr str)))
(while strp
(set (car strp) (nth 1 strp))
(setq strp (cdr (cdr strp))))
(calc-do-calc-eval (car str) separator args)))
((eq separator 'eval)
(eval str))
((eq separator 'macro)
(require 'calc-ext)
(let* ((calc-buffer (current-buffer))
(calc-window (get-buffer-window calc-buffer))
(save-window (selected-window)))
(if calc-window
(select-window calc-window)
(calc-execute-kbd-macro str nil (car args)))
(and (window-point save-window)
(select-window save-window)))
(select-window (get-largest-window))
(switch-to-buffer calc-buffer)
(calc-execute-kbd-macro str nil (car args)))))
((eq separator 'pop)
(or (not (integerp str))
(= str 0)
(calc-pop (min str (calc-stack-size))))
((eq separator 'top)
(and (integerp str)
(> str 0)
(<= str (calc-stack-size))
(math-format-value (calc-top-n str (car args)) 1000)))
((eq separator 'rawtop)
(and (integerp str)
(> str 0)
(<= str (calc-stack-size))
(calc-top-n str (car args))))
(let* ((calc-command-flags nil)
(calc-next-why nil)
(calc-language (if (memq calc-language '(nil big))
'flat calc-language))
(calc-dollar-values (mapcar
(lambda (x)
(if (stringp x)
(setq x (math-read-exprs x))
(if (eq (car-safe x)
(throw 'calc-error
(cdr x)))
(car x)))
(calc-dollar-used 0)
(res (if (stringp str)
(math-read-exprs str)
(list str)))
(if (eq (car res) 'error)
(calc-eval-error (cdr res))
(setq res (mapcar 'calc-normalize res))
(and (memq 'clear-message calc-command-flags)
(message ""))
(cond ((eq separator 'pred)
(require 'calc-ext)
(if (= (length res) 1)
(math-is-true (car res))
(calc-eval-error '(0 "Single value expected"))))
((eq separator 'raw)
(if (= (length res) 1)
(car res)
(calc-eval-error '(0 "Single value expected"))))
((eq separator 'list)
((memq separator '(num rawnum))
(if (= (length res) 1)
(if (math-constp (car res))
(if (eq separator 'num)
(math-format-value (car res) 1000)
(car res))
(list 0
(if calc-next-why
(calc-explain-why (car calc-next-why))
"Number expected"))))
(calc-eval-error '(0 "Single value expected"))))
((eq separator 'push)
(calc-push-list res)
(t (while res
(setq buf (concat buf
(and buf (or separator ", "))
(math-format-value (car res) 1000))
res (cdr res)))
(defvar calc-eval-error nil
"Determines how calc handles errors.
If nil, return a list containing the character position of error.
STRING means return error message as string rather than list.
The value t means abort and give an error message.")
(defun calc-eval-error (msg)
(if calc-eval-error
(if (eq calc-eval-error 'string)
(nth 1 msg)
(error "%s" (nth 1 msg)))
;;;; Reading an expression in algebraic form.
(defun calc-auto-algebraic-entry (&optional prefix)
(interactive "P")
(calc-algebraic-entry prefix t))
(defun calc-algebraic-entry (&optional prefix auto)
(interactive "P")
(let ((calc-language (if prefix nil calc-language))
(math-expr-opers (if prefix (math-standard-ops) (math-expr-ops))))
(calc-alg-entry (and auto (char-to-string last-command-event))))))
(defvar calc-alg-entry-history nil
"History for algebraic entry.")
(defun calc-alg-entry (&optional initial prompt)
(let* ((calc-dollar-values (mapcar #'calc-get-stack-element
(nthcdr calc-stack-top calc-stack)))
(calc-dollar-used 0)
(calc-plain-entry t)
(alg-exp (calc-do-alg-entry initial prompt t 'calc-alg-entry-history)))
(if (stringp alg-exp)
(require 'calc-ext)
(calc-alg-edit alg-exp))
(let* ((calc-simplify-mode (if (eq last-command-event ?\C-j)
(nvals (mapcar 'calc-normalize alg-exp)))
(while alg-exp
(calc-record (if (featurep 'calc-ext) (car alg-exp) (car nvals))
(calc-pop-push-record-list calc-dollar-used
(and (not (equal (car alg-exp)
(car nvals)))
(featurep 'calc-ext)
(list (car nvals)))
(setq alg-exp (cdr alg-exp)
nvals (cdr nvals)
calc-dollar-used 0)))
(defvar calc-alg-ent-map
(let ((map (make-sparse-keymap)))
(set-keymap-parent map minibuffer-local-map)
(define-key map "'" 'calcAlg-previous)
(define-key map "`" 'calcAlg-edit)
(define-key map "\C-m" 'calcAlg-enter)
(define-key map "\C-j" 'calcAlg-enter)
"The keymap used for algebraic entry.")
(defvar calc-alg-ent-esc-map
(let ((map (make-keymap))
(i 33))
(set-keymap-parent map esc-map)
(while (< i 127)
(define-key map (vector i) 'calcAlg-escape)
(setq i (1+ i)))
"The keymap used for escapes in algebraic entry.")
(defvar calc-alg-exp)
(defun calc-do-alg-entry (&optional initial prompt no-normalize history)
(let* ((calc-buffer (current-buffer))
(blink-matching-check-function 'calcAlg-blink-matching-check)
(calc-alg-exp 'error))
(define-key calc-alg-ent-map "\e" nil)
(if (eq calc-algebraic-mode 'total)
(define-key calc-alg-ent-map "\e" calc-alg-ent-esc-map)
(define-key calc-alg-ent-map "\e+" 'calcAlg-plus-minus)
(define-key calc-alg-ent-map "\em" 'calcAlg-mod)
(define-key calc-alg-ent-map "\e=" 'calcAlg-equals)
(define-key calc-alg-ent-map "\e\r" 'calcAlg-equals)
(define-key calc-alg-ent-map "\ep" 'previous-history-element)
(define-key calc-alg-ent-map "\en" 'next-history-element)
(define-key calc-alg-ent-map "\e%" 'self-insert-command))
(setq calc-aborted-prefix nil)
(let ((buf (read-from-minibuffer (or prompt "Algebraic: ")
(or initial "")
calc-alg-ent-map nil history)))
(when (eq calc-alg-exp 'error)
(when (eq (car-safe (setq calc-alg-exp (math-read-exprs buf))) 'error)
(setq calc-alg-exp nil)))
(setq calc-aborted-prefix "alg'")
(or no-normalize
(and calc-alg-exp (setq calc-alg-exp (mapcar 'calc-normalize calc-alg-exp))))
(defun calcAlg-plus-minus ()
(if (calc-minibuffer-contains ".* \\'")
(insert "+/- ")
(insert " +/- ")))
(defun calcAlg-mod ()
(if (not (calc-minibuffer-contains ".* \\'"))
(insert " "))
(if (calc-minibuffer-contains ".* mod +\\'")
(if calc-previous-modulo
(insert (math-format-flat-expr calc-previous-modulo 0))
(insert "mod ")))
(defun calcAlg-previous ()
(if (calc-minibuffer-contains "\\'")
(previous-history-element 1)
(insert "'")))
(defun calcAlg-equals ()
(if (consp calc-alg-exp)
(progn (setq prefix-arg (length calc-alg-exp))
(calc-unread-command ?=)))))
(defun calcAlg-escape ()
(use-local-map calc-mode-map))
(defvar calc-plain-entry nil)
(defun calcAlg-edit ()
(if (or (not calc-plain-entry)
(insert "`")
(setq calc-alg-exp (minibuffer-contents))
(defvar calc-buffer)
(defun calcAlg-enter ()
(let* ((str (minibuffer-contents))
(exp (and (> (length str) 0)
(with-current-buffer calc-buffer
(math-read-exprs str)))))
(if (eq (car-safe exp) 'error)
(goto-char (minibuffer-prompt-end))
(forward-char (nth 1 exp))
(concat " [" (or (nth 2 exp) "Error") "]"))
(setq calc-alg-exp (if (calc-minibuffer-contains "\\` *\\[ *\\'")
'((incomplete vec))
(defun calcAlg-blink-matching-check (leftpt rightpt)
(let ((rightchar (char-before rightpt))
(leftchar (if leftpt (char-after leftpt))))
(if (and leftpt
(or (and (= rightchar ?\))
(= leftchar ?\[))
(and (= rightchar ?\])
(= leftchar ?\()))
(goto-char leftpt)
(looking-at ".+\\(\\.\\.\\|\\\\dots\\|\\\\ldots\\)")))
;; [2..5) perfectly valid!
(blink-matching-check-mismatch leftpt rightpt))))
(defun calc-alg-digit-entry ()
(cond ((eq last-command-event ?e)
(if (> calc-number-radix 14) (format "%d.^" calc-number-radix) "1e"))
((eq last-command-event ?#) (format "%d#" calc-number-radix))
((eq last-command-event ?_) "-")
((eq last-command-event ?@) "0@ ")
(t (char-to-string last-command-event)))))
;; The variable calc-digit-value is initially declared in calc.el,
;; but can be set by calcDigit-algebraic and calcDigit-edit.
(defvar calc-digit-value)
(defun calcDigit-algebraic ()
(if (calc-minibuffer-contains ".*[@oh] *[^'m ]+[^'m]*\\'")
(setq calc-digit-value (minibuffer-contents))
(defun calcDigit-edit ()
(setq calc-digit-value (minibuffer-contents))
;;; Algebraic expression parsing. [Public]
(defvar math-read-replacement-list
'(;; Misc symbols
("±" "+/-") ; plus or minus
("×" "*") ; multiplication sign
("÷" ":") ; division sign
("" "-") ; subtraction sign
("" "/") ; division sign
("" "*") ; asterisk multiplication
("" "inf") ; infinity symbol
("" "<=")
("" ">=")
("" "<=")
("" ">=")
("µ" "μ")
;; fractions
("¼" "(1:4)") ; 1/4
("½" "(1:2)") ; 1/2
("¾" "(3:4)") ; 3/4
("" "(1:3)") ; 1/3
("" "(2:3)") ; 2/3
("" "(1:5)") ; 1/5
("" "(2:5)") ; 2/5
("" "(3:5)") ; 3/5
("" "(4:5)") ; 4/5
("" "(1:6)") ; 1/6
("" "(5:6)") ; 5/6
("" "(1:8)") ; 1/8
("" "(3:8)") ; 3/8
("" "(5:8)") ; 5/8
("" "(7:8)") ; 7/8
("" "1:") ; 1/...
;; superscripts
("" "0") ; 0
("¹" "1") ; 1
("²" "2") ; 2
("³" "3") ; 3
("" "4") ; 4
("" "5") ; 5
("" "6") ; 6
("" "7") ; 7
("" "8") ; 8
("" "9") ; 9
("" "+") ; +
("" "-") ; -
("" "(") ; (
("" ")") ; )
("" "n") ; n
("" "i") ; i
;; subscripts
("" "0") ; 0
("" "1") ; 1
("" "2") ; 2
("" "3") ; 3
("" "4") ; 4
("" "5") ; 5
("" "6") ; 6
("" "7") ; 7
("" "8") ; 8
("" "9") ; 9
("" "+") ; +
("" "-") ; -
("" "(") ; (
("" ")")) ; )
"A list whose elements (old new) indicate replacements to make
in Calc algebraic input.")
(defvar math-read-superscripts
"⁰¹²³⁴⁵⁶⁷⁸⁹⁺⁻⁽⁾ⁿⁱ" ; 0123456789+-()ni
"A string consisting of the superscripts allowed by Calc.")
(defvar math-read-subscripts
"₀₁₂₃₄₅₆₇₈₉₊₋₍₎" ; 0123456789+-()
"A string consisting of the subscripts allowed by Calc.")
(defun math-read-preprocess-string (str)
"Replace some substrings of STR by Calc equivalents."
(setq str
(replace-regexp-in-string (concat "[" math-read-superscripts "]+")
"^(\\&)" str))
(setq str
(replace-regexp-in-string (concat "[" math-read-subscripts "]+")
"_(\\&)" str))
(let ((rep-list math-read-replacement-list))
(while rep-list
(setq str
(replace-regexp-in-string (nth 0 (car rep-list))
(nth 1 (car rep-list)) str))
(setq rep-list (cdr rep-list))))
;; The next few variables are local to math-read-exprs (and math-read-expr
;; in calc-ext.el), but are set in functions they call.
(defvar math-exp-pos)
(defvar math-exp-str)
(defvar math-exp-old-pos)
(defvar math-exp-token)
(defvar math-exp-keep-spaces)
(defvar math-expr-data)
(defun math-read-exprs (math-exp-str)
(let ((math-exp-pos 0)
(math-exp-old-pos 0)
(math-exp-keep-spaces nil)
math-exp-token math-expr-data)
(setq math-exp-str (math-read-preprocess-string math-exp-str))
(if (memq calc-language calc-lang-allow-percentsigns)
(setq math-exp-str (math-remove-percentsigns math-exp-str)))
(if calc-language-input-filter
(setq math-exp-str (funcall calc-language-input-filter math-exp-str)))
(while (setq math-exp-token
(string-match "\\.\\.\\([^.]\\|.[^.]\\)" math-exp-str))
(setq math-exp-str
(concat (substring math-exp-str 0 math-exp-token) "\\dots"
(substring math-exp-str (+ math-exp-token 2)))))
(let ((val (catch 'syntax (math-read-expr-list))))
(if (stringp val)
(list 'error math-exp-old-pos val)
(if (equal math-exp-token 'end)
(list 'error math-exp-old-pos "Syntax error"))))))
(defun math-read-expr-list ()
(let* ((math-exp-keep-spaces nil)
(val (list (math-read-expr-level 0)))
(last val))
(while (equal math-expr-data ",")
(let ((rest (list (math-read-expr-level 0))))
(setcdr last rest)
(setq last rest)))
(defvar calc-user-parse-table nil)
(defvar calc-last-main-parse-table nil)
(defvar calc-last-user-lang-parse-table nil)
(defvar calc-last-lang-parse-table nil)
(defvar calc-user-tokens nil)
(defvar calc-user-token-chars nil)
(defvar math-toks nil
"Tokens to pass between math-build-parse-table and math-find-user-tokens.")
(defun math-build-parse-table ()
(let ((mtab (cdr (assq nil calc-user-parse-tables)))
(ltab (cdr (assq calc-language calc-user-parse-tables)))
(lltab (get calc-language 'math-parse-table)))
(or (and (eq mtab calc-last-main-parse-table)
(eq ltab calc-last-user-lang-parse-table)
(eq lltab calc-last-lang-parse-table))
(let ((p (append mtab ltab lltab))
(math-toks nil))
(setq calc-user-parse-table p)
(setq calc-user-token-chars nil)
(while p
(math-find-user-tokens (car (car p)))
(setq p (cdr p)))
(setq calc-user-tokens (mapconcat 'identity
(sort (mapcar 'car math-toks)
(function (lambda (x y)
(> (length x)
(length y)))))
calc-last-main-parse-table mtab
calc-last-user-lang-parse-table ltab
calc-last-lang-parse-table lltab)))))
(defun math-find-user-tokens (p)
(while p
(cond ((and (stringp (car p))
(or (> (length (car p)) 1) (equal (car p) "$")
(equal (car p) "\""))
(string-match "[^a-zA-Zα-ωΑ-Ω0-9]" (car p)))
(let ((s (regexp-quote (car p))))
(if (string-match "\\`[a-zA-Zα-ωΑ-Ω0-9]" s)
(setq s (concat "\\<" s)))
(if (string-match "[a-zA-Zα-ωΑ-Ω0-9]\\'" s)
(setq s (concat s "\\>")))
(or (assoc s math-toks)
(setq math-toks (cons (list s) math-toks))
(or (memq (aref (car p) 0) calc-user-token-chars)
(setq calc-user-token-chars
(cons (aref (car p) 0)
((consp (car p))
(math-find-user-tokens (nth 1 (car p)))
(or (eq (car (car p)) '\?)
(math-find-user-tokens (nth 2 (car p))))))
(setq p (cdr p))))
(defun math-read-token ()
(if (>= math-exp-pos (length math-exp-str))
(setq math-exp-old-pos math-exp-pos
math-exp-token 'end
math-expr-data "\000")
(let (adfn
(ch (aref math-exp-str math-exp-pos)))
(setq math-exp-old-pos math-exp-pos)
(cond ((memq ch '(32 10 9))
(setq math-exp-pos (1+ math-exp-pos))
(if math-exp-keep-spaces
(setq math-exp-token 'space
math-expr-data " ")
((and (memq ch calc-user-token-chars)
(let ((case-fold-search nil))
(eq (string-match
calc-user-tokens math-exp-str math-exp-pos)
(setq math-exp-token 'punc
math-expr-data (math-match-substring math-exp-str 0)
math-exp-pos (match-end 0)))
((or (and (>= ch ?a) (<= ch ?z))
(and (>= ch ?A) (<= ch ?Z))
(and (>= ch ?α) (<= ch ?ω))
(and (>= ch ?Α) (<= ch ?Ω)))
((and (memq calc-language calc-lang-allow-underscores)
(memq calc-language calc-lang-allow-percentsigns))
((memq calc-language calc-lang-allow-underscores)
(t "[a-zA-Zα-ωΑ-Ω0-9'#]*"))
math-exp-str math-exp-pos)
(setq math-exp-token 'symbol
math-exp-pos (match-end 0)
math-expr-data (math-restore-dashes
(math-match-substring math-exp-str 0)))
(if (setq adfn (get calc-language 'math-lang-adjust-words))
(funcall adfn)))
((or (and (>= ch ?0) (<= ch ?9))
(and (eq ch '?\.)
(eq (string-match "\\.[0-9]" math-exp-str math-exp-pos)
(and (eq ch '?_)
(eq (string-match "_\\.?[0-9]" math-exp-str math-exp-pos)
(or (eq math-exp-pos 0)
(and (not (memq calc-language
(eq (string-match "[^])}\"a-zA-Zα-ωΑ-Ω0-9'$]_"
math-exp-str (1- math-exp-pos))
(1- math-exp-pos))))))
(or (and (memq calc-language calc-lang-c-type-hex)
(string-match "0[xX][0-9a-fA-F]+" math-exp-str math-exp-pos))
(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]+\\)?\"?\\)?"
math-exp-str math-exp-pos))
(setq math-exp-token 'number
math-expr-data (math-match-substring math-exp-str 0)
math-exp-pos (match-end 0)))
((and (setq adfn
(assq ch (get calc-language 'math-lang-read-symbol)))
(eval (nth 1 adfn)))
(eval (nth 2 adfn)))
((eq ch ?\$)
(if (eq (string-match "\\$\\([1-9][0-9]*\\)" math-exp-str math-exp-pos)
(setq math-expr-data (- (string-to-number (math-match-substring
math-exp-str 1))))
(string-match "\\$+" math-exp-str math-exp-pos)
(setq math-expr-data (- (match-end 0) (match-beginning 0))))
(setq math-exp-token 'dollar
math-exp-pos (match-end 0)))
((eq ch ?\#)
(if (eq (string-match "#\\([1-9][0-9]*\\)" math-exp-str math-exp-pos)
(setq math-expr-data (string-to-number
(math-match-substring math-exp-str 1))
math-exp-pos (match-end 0))
(setq math-expr-data 1
math-exp-pos (1+ math-exp-pos)))
(setq math-exp-token 'hash))
((eq (string-match "~=\\|<=\\|>=\\|<>\\|/=\\|\\+/-\\|\\\\dots\\|\\\\ldots\\|\\*\\*\\|<<\\|>>\\|==\\|!=\\|&&&\\||||\\|!!!\\|&&\\|||\\|!!\\|:=\\|::\\|=>"
math-exp-str math-exp-pos)
(setq math-exp-token 'punc
math-expr-data (math-match-substring math-exp-str 0)
math-exp-pos (match-end 0)))
((and (eq ch ?\")
(string-match "\\(\"\\([^\"\\]\\|\\\\.\\)*\\)\\(\"\\|\\'\\)"
math-exp-str math-exp-pos))
(setq math-exp-token 'string
math-expr-data (math-match-substring math-exp-str 1)
math-exp-pos (match-end 0)))
((and (setq adfn (get calc-language 'math-lang-read))
(eval (nth 0 adfn))
(eval (nth 1 adfn))))
((eq (string-match "%%.*$" math-exp-str math-exp-pos) math-exp-pos)
(setq math-exp-pos (match-end 0))
(if (setq adfn (assq ch (get calc-language 'math-punc-table)))
(setq ch (cdr adfn)))
(setq math-exp-token 'punc
math-expr-data (char-to-string ch)
math-exp-pos (1+ math-exp-pos)))))))
(defconst math-alg-inequalities
'(calcFunc-lt calcFunc-gt calcFunc-leq calcFunc-geq
calcFunc-eq calcFunc-neq))
(defun math-read-expr-level (exp-prec &optional exp-term)
(let* ((math-expr-opers (math-expr-ops))
(x (math-read-factor))
(first t)
op op2)
(while (and (or (and calc-user-parse-table
(setq op (calc-check-user-syntax x exp-prec))
(setq x op
op '("2x" ident 999999 -1)))
(and (setq op (assoc math-expr-data math-expr-opers))
(/= (nth 2 op) -1)
(or (and (setq op2 (assoc
(cdr (memq op math-expr-opers))))
(eq (= (nth 3 op) -1)
(/= (nth 3 op2) -1))
(eq (= (nth 3 op2) -1)
(not (math-factor-after)))
(setq op op2))
(and (or (eq (nth 2 op) -1)
(memq math-exp-token '(symbol number dollar hash))
(equal math-expr-data "(")
(and (equal math-expr-data "[")
(not (equal
(get calc-language
'math-function-open) "["))
(not (and math-exp-keep-spaces
(eq (car-safe x) 'vec)))))
(or (not (setq op (assoc math-expr-data math-expr-opers)))
(/= (nth 2 op) -1))
(or (not calc-user-parse-table)
(not (eq math-exp-token 'symbol))
(let ((p calc-user-parse-table))
(while (and p
(or (not (integerp
(car (car (car p)))))
(not (equal
(nth 1 (car (car p)))
(setq p (cdr p)))
(not p)))
(setq op (assoc "2x" math-expr-opers))))
(not (and exp-term (equal math-expr-data exp-term)))
(>= (nth 2 op) exp-prec))
(if (not (equal (car op) "2x"))
(and (memq (nth 1 op) '(sdev mod))
(require 'calc-ext))
(setq x (cond ((consp (nth 1 op))
(funcall (car (nth 1 op)) x op))
((eq (nth 3 op) -1)
(if (eq (nth 1 op) 'ident)
(if (eq (nth 1 op) 'closing)
(if (eq (nth 2 op) exp-prec)
(setq exp-prec 1000)
(throw 'syntax "Mismatched delimiters"))
(list (nth 1 op) x))))
((and (not first)
(memq (nth 1 op) math-alg-inequalities)
(memq (car-safe x) math-alg-inequalities))
(require 'calc-ext)
(math-composite-inequalities x op))
(t (list (nth 1 op)
(math-read-expr-level (nth 3 op) exp-term))))
first nil))
;; calc-arg-values is defined in calc-ext.el, but is used here.
(defvar calc-arg-values)
(defun calc-check-user-syntax (&optional x prec)
(let ((p calc-user-parse-table)
(matches nil)
match rule)
(while (and p
(or (not (progn
(setq rule (car (car p)))
(if x
(and (integerp (car rule))
(>= (car rule) prec)
(equal math-expr-data
(car (setq rule (cdr rule)))))
(equal math-expr-data (car rule)))))
(let ((save-exp-pos math-exp-pos)
(save-exp-old-pos math-exp-old-pos)
(save-exp-token math-exp-token)
(save-exp-data math-expr-data))
(or (not (listp
(setq matches (calc-match-user-syntax rule))))
(let ((args (progn
(require 'calc-ext)
(conds nil)
(if x
(setq matches (cons x matches)))
(setq match (cdr (car p)))
(while (and (eq (car-safe match)
(= (length match) 3))
(setq conds (append (math-flatten-lands
(nth 2 match))
match (nth 1 match)))
(while (and conds match)
(require 'calc-ext)
(cond ((eq (car-safe (car conds))
(setq temp (car conds))
(or (= (length temp) 3)
(and (= (length temp) 2)
(eq (car-safe (nth 1 temp))
(= (length (nth 1 temp)) 3)
(setq temp (nth 1 temp)))
(setq match nil))
(setq matches (cons
(nth 2 temp)
args matches))
args (cons (nth 1 temp)
((and (eq (car-safe (car conds))
(= (length (car conds)) 3))
(setq temp (calcFunc-vmatches
(nth 1 (car conds))
args matches)
(nth 2 (car conds))))
(if (eq temp 0)
(setq match nil)
(while (setq temp (cdr temp))
(setq matches (cons (nth 2 (car temp))
args (cons (nth 1 (car temp))
(or (math-is-true (math-simplify
(car conds)
args matches)))
(setq match nil))))
(setq conds (cdr conds)))
(if match
(not (setq match (math-multi-subst
match args matches)))
(setq math-exp-old-pos save-exp-old-pos
math-exp-token save-exp-token
math-expr-data save-exp-data
math-exp-pos save-exp-pos)))))))
(setq p (cdr p)))
(and p match)))
(defun calc-match-user-syntax (p &optional term)
(let ((matches nil)
(save-exp-pos math-exp-pos)
(save-exp-old-pos math-exp-old-pos)
(save-exp-token math-exp-token)
(save-exp-data math-expr-data)
(while (and p
(cond ((stringp (car p))
(and (equal math-expr-data (car p))
((integerp (car p))
(and (setq m (catch 'syntax
(car p)
(if (cdr p)
(if (consp (nth 1 p))
(car (nth 1 (nth 1 p)))
(nth 1 p))
(not (stringp m))
(setq matches (nconc matches (list m)))))
((eq (car (car p)) '\?)
(setq m (calc-match-user-syntax (nth 1 (car p))))
(or (nth 2 (car p))
(setq matches
(nconc matches
(cons 'vec (and (listp m) m))))))
(or (listp m) (not (nth 2 (car p)))
(not (eq (aref (car (nth 2 (car p))) 0) ?\$))
(eq math-exp-token 'end)))
(setq m (calc-match-user-syntax (nth 1 (car p))
(car (nth 2 (car p)))))
(if (listp m)
(let ((vec (cons 'vec m))
opos mm)
(while (and (listp
(setq opos math-exp-pos
mm (calc-match-user-syntax
(or (nth 2 (car p))
(nth 1 (car p)))
(car (nth 2 (car p))))))
(> math-exp-pos opos))
(setq vec (nconc vec mm)))
(setq matches (nconc matches (list vec))))
(and (eq (car (car p)) '*)
(setq matches (nconc matches (list '(vec)))))))))
(setq p (cdr p)))
(if p
(setq math-exp-pos save-exp-pos
math-exp-old-pos save-exp-old-pos
math-exp-token save-exp-token
math-expr-data save-exp-data
matches "Failed"))
(defun math-remove-dashes (x)
(if (string-match "\\`\\(.*\\)-\\(.*\\)\\'" x)
(concat (math-match-substring x 1) "#" (math-match-substring x 2)))
(defun math-remove-percentsigns (x)
(if (string-match "\\`\\(.*\\)%\\(.*\\)\\'" x)
(concat (math-match-substring x 1) "o'o" (math-match-substring x 2)))
(defun math-restore-dashes (x)
(if (string-match "\\`\\(.*\\)[#_]\\(.*\\)\\'" x)
(concat (math-match-substring x 1) "-" (math-match-substring x 2)))
(defun math-restore-placeholders (x)
"Replace placeholders by the proper characters in the symbol x.
This includes `#' for `_' and `'' for `%'.
If the current Calc language does not use placeholders, return nil."
(if (or (memq calc-language calc-lang-allow-underscores)
(memq calc-language calc-lang-allow-percentsigns))
(let ((sx (symbol-name x)))
(when (memq calc-language calc-lang-allow-percentsigns)
(require 'calccomp)
(setq sx (math-to-percentsigns sx)))
(if (memq calc-language calc-lang-allow-underscores)
(setq sx (math-string-restore-underscores sx)))
(intern-soft sx))))
(defun math-string-restore-underscores (x)
"Replace pound signs by underscores in the string x."
(if (string-match "\\`\\(.*\\)#\\(.*\\)\\'" x)
(concat (math-match-substring x 1) "_" (math-match-substring x 2)))
(defun math-read-if (cond op)
(let ((then (math-read-expr-level 0)))
(or (equal math-expr-data ":")
(throw 'syntax "Expected ':'"))
(list 'calcFunc-if cond then (math-read-expr-level (nth 3 op)))))
(defun math-factor-after ()
(let ((math-exp-pos math-exp-pos)
math-exp-old-pos math-exp-token math-expr-data)
(or (memq math-exp-token '(number symbol dollar hash string))
(and (assoc math-expr-data '(("-") ("+") ("!") ("|") ("/")))
(assoc (concat "u" math-expr-data) math-expr-opers))
(eq (nth 2 (assoc math-expr-data math-expr-opers)) -1)
(assoc math-expr-data '(("(") ("[") ("{"))))))
(defun math-read-factor ()
(let ((math-expr-opers (math-expr-ops))
(cond ((eq math-exp-token 'number)
(let ((num (math-read-number math-expr-data)))
(if (not num)
(setq math-exp-old-pos math-exp-pos)
(throw 'syntax "Bad format")))
(if (and math-read-expr-quotes
(consp num))
(list 'quote num)
((and calc-user-parse-table
(setq op (calc-check-user-syntax)))
((or (equal math-expr-data "-")
(equal math-expr-data "+")
(equal math-expr-data "!")
(equal math-expr-data "|")
(equal math-expr-data "/"))
(setq math-expr-data (concat "u" math-expr-data))
((and (setq op (assoc math-expr-data math-expr-opers))
(eq (nth 2 op) -1))
(if (consp (nth 1 op))
(funcall (car (nth 1 op)) op)
(let ((val (math-read-expr-level (nth 3 op))))
(cond ((eq (nth 1 op) 'ident)
((and (Math-numberp val)
(equal (car op) "u-"))
(math-neg val))
(t (list (nth 1 op) val))))))
((eq math-exp-token 'symbol)
(let ((sym (intern math-expr-data)))
(if (equal math-expr-data calc-function-open)
(let ((f (assq sym math-expr-function-mapping)))
(if (consp (cdr f))
(funcall (car (cdr f)) f sym)
(let ((args (if (or (equal math-expr-data calc-function-close)
(eq math-exp-token 'end))
(if (not (or (equal math-expr-data calc-function-close)
(eq math-exp-token 'end)))
(throw 'syntax "Expected `)'"))
(if (and (memq calc-language
(require 'calc-ext)
(let ((calc-matrix-mode 'scalar))
(list 'var sym
(concat "var-"
(symbol-name sym)))))))
(math-parse-fortran-subscr sym args)
(if f
(setq sym (cdr f))
(and (= (aref (symbol-name sym) 0) ?\\)
(< (prefix-numeric-value calc-language-option)
(setq sym (intern (substring (symbol-name sym)
(or (string-match "-" (symbol-name sym))
(setq sym (intern
(concat "calcFunc-"
(symbol-name sym))))))
(cons sym args)))))
(if math-read-expr-quotes
(let ((val (list 'var
(intern (math-remove-dashes
(symbol-name sym)))
(if (string-match "-" (symbol-name sym))
(intern (concat "var-"
(symbol-name sym)))))))
(let ((v (or
(assq (nth 1 val) math-expr-variable-mapping)
(assq (math-restore-placeholders (nth 1 val))
(and v (setq val (if (consp (cdr v))
(funcall (car (cdr v)) v val)
(list 'var
(substring (symbol-name (cdr v))
(cdr v))))))
(while (and (memq calc-language
(equal math-expr-data "["))
(let ((el (math-read-expr-list)))
(while el
(setq val (append (list 'calcFunc-subscr val)
(list (car el))))
(setq el (cdr el))))
(if (equal math-expr-data "]")
(throw 'syntax "Expected ']'")))
((eq math-exp-token 'dollar)
(let ((abs (if (> math-expr-data 0) math-expr-data (- math-expr-data))))
(if (>= (length calc-dollar-values) abs)
(let ((num math-expr-data))
(setq calc-dollar-used (max calc-dollar-used num))
(math-check-complete (nth (1- abs) calc-dollar-values)))
(throw 'syntax (if calc-dollar-values
"Too many $'s"
"$'s not allowed in this context")))))
((eq math-exp-token 'hash)
(or calc-hashes-used
(throw 'syntax "#'s not allowed in this context"))
(require 'calc-ext)
(if (<= math-expr-data (length calc-arg-values))
(let ((num math-expr-data))
(setq calc-hashes-used (max calc-hashes-used num))
(nth (1- num) calc-arg-values))
(throw 'syntax "Too many # arguments")))
((equal math-expr-data "(")
(let* ((exp (let ((math-exp-keep-spaces nil))
(if (or (equal math-expr-data "\\dots")
(equal math-expr-data "\\ldots"))
'(neg (var inf var-inf))
(math-read-expr-level 0)))))
(let ((math-exp-keep-spaces nil))
((equal math-expr-data ",")
(let ((exp2 (math-read-expr-level 0)))
(setq exp
(if (and exp2 (Math-realp exp) (Math-realp exp2))
(math-normalize (list 'cplx exp exp2))
(list '+ exp (list '* exp2 '(var i var-i))))))))
((equal math-expr-data ";")
(let ((exp2 (math-read-expr-level 0)))
(setq exp (if (and exp2 (Math-realp exp)
(Math-anglep exp2))
(math-normalize (list 'polar exp exp2))
(require 'calc-ext)
(list '* exp
(list 'calcFunc-exp
(list '*
(math-to-radians-2 exp2)
'(var i var-i)))))))))
((or (equal math-expr-data "\\dots")
(equal math-expr-data "\\ldots"))
(let ((exp2 (if (or (equal math-expr-data ")")
(equal math-expr-data "]")
(eq math-exp-token 'end))
'(var inf var-inf)
(math-read-expr-level 0))))
(setq exp
(list 'intv
(if (equal math-expr-data ")") 0 1)
(if (not (or (equal math-expr-data ")")
(and (equal math-expr-data "]") (eq (car-safe exp) 'intv))
(eq math-exp-token 'end)))
(throw 'syntax "Expected `)'"))
((eq math-exp-token 'string)
(require 'calc-ext)
((equal math-expr-data "[")
(require 'calc-ext)
(math-read-brackets t "]"))
((equal math-expr-data "{")
(require 'calc-ext)
(math-read-brackets nil "}"))
((equal math-expr-data "<")
(require 'calc-ext)
(t (throw 'syntax "Expected a number")))))
(provide 'calc-aent)
;; Local variables:
;; coding: utf-8
;; generated-autoload-file: "calc-loaddefs.el"
;; End:
;;; calc-aent.el ends here
Something went wrong with that request. Please try again.