Mercurial > emacs
view lisp/calc/calc-aent.el @ 110523:a5ad4f188e19
Synch Semantic to CEDET 1.0.
Move CEDET ChangeLog entries to new file lisp/cedet/ChangeLog.
* semantic.el (semantic-version): Update to 2.0.
(semantic-mode-map): Add "," and "m" bindings.
(navigate-menu): Update.
* semantic/symref.el (semantic-symref-calculate-rootdir):
New function.
(semantic-symref-detect-symref-tool): Use it.
* semantic/symref/grep.el (semantic-symref-grep-shell): New var.
(semantic-symref-perform-search): Use it. Calculate root dir with
semantic-symref-calculate-rootdir.
(semantic-symref-derive-find-filepatterns): Improve error message.
* semantic/symref/list.el
(semantic-symref-results-mode-map): New bindings.
(semantic-symref-auto-expand-results): New option.
(semantic-symref-results-dump): Obey auto-expand.
(semantic-symref-list-expand-all, semantic-symref-regexp)
(semantic-symref-list-contract-all)
(semantic-symref-list-map-open-hits)
(semantic-symref-list-update-open-hits)
(semantic-symref-list-create-macro-on-open-hit)
(semantic-symref-list-call-macro-on-open-hits): New functions.
(semantic-symref-list-menu-entries)
(semantic-symref-list-menu): New vars.
(semantic-symref-list-map-open-hits): Move cursor to beginning of
match before calling the mapped function.
* semantic/doc.el
(semantic-documentation-comment-preceeding-tag): Do nothing if the
mode doesn't provide comment-start-skip.
* semantic/scope.el
(semantic-analyze-scope-nested-tags-default): Strip duplicates.
(semantic-analyze-scoped-inherited-tag-map): Take the tag we are
looking for as part of the scoped tags list.
* semantic/html.el (semantic-default-html-setup): Add
senator-step-at-tag-classes.
* semantic/decorate/include.el
(semantic-decoration-on-unknown-includes): Change light bgcolor.
(semantic-decoration-on-includes-highlight-default): Check that
the include tag has a postion.
* semantic/complete.el (semantic-collector-local-members):
(semantic-complete-read-tag-local-members)
(semantic-complete-jump-local-members): New class and functions.
(semantic-complete-self-insert): Save excursion before completing.
* semantic/analyze/complete.el
(semantic-analyze-possible-completions-default): If no completions
are found, return the raw by-name-only completion list. Add FLAGS
arguments. Add support for 'no-tc (type constraint) and
'no-unique, or no stripping duplicates.
(semantic-analyze-possible-completions-default): Add FLAGS arg.
* semantic/util-modes.el
(semantic-stickyfunc-show-only-functions-p): New option.
(semantic-stickyfunc-fetch-stickyline): Don't show stickytext for
the very first line in a buffer.
* semantic/util.el (semantic-hack-search)
(semantic-recursive-find-nonterminal-by-name)
(semantic-current-tag-interactive): Deleted.
(semantic-describe-buffer): Fix expand-nonterminal. Add
lex-syntax-mods, type relation separator char, and command
separation char.
(semantic-sanity-check): Only message if called interactively.
* semantic/tag.el (semantic-tag-deep-copy-one-tag): Copy the
:filename property and the tag position.
* semantic/lex-spp.el (semantic-lex-spp-lex-text-string):
Add recursion limit.
* semantic/imenu.el (semantic-imenu-bucketize-type-members):
Make this buffer local, not the obsoleted variable.
* semantic/idle.el: Add breadcrumbs support.
(semantic-idle-summary-current-symbol-info-default)
(semantic-idle-tag-highlight)
(semantic-idle-completion-list-default): Use
semanticdb-without-unloaded-file-searches for speed, and to
conform to the controls that specify if the idle timer is supposed
to be parsing unparsed includes.
(semantic-idle-symbol-highlight-face)
(semantic-idle-symbol-maybe-highlight): Rename from *-summary-*.
Callers changed.
(semantic-idle-work-parse-neighboring-files-flag): Default to nil.
(semantic-idle-work-update-headers-flag): New var.
(semantic-idle-work-for-one-buffer): Use it.
(semantic-idle-local-symbol-highlight): Rename from
semantic-idle-tag-highlight.
(semantic-idle-truncate-long-summaries): New option.
* semantic/ia.el (semantic-ia-cache)
(semantic-ia-get-completions): Deleted. Callers changed.
(semantic-ia-show-variants): New command.
(semantic-ia-show-doc): If doc is empty, don't make a temp buffer.
(semantic-ia-show-summary): If there isn't anything to show, say so.
* semantic/grammar.el (semantic-grammar-create-package):
Save the buffer even in batch mode.
* semantic/fw.el
(semanticdb-without-unloaded-file-searches): New macro.
* semantic/dep.el (semantic-dependency-find-file-on-path):
Fix case dereferencing ede-object when it is a list.
* semantic/db-typecache.el (semanticdb-expand-nested-tag)
(semanticdb-typecache-faux-namespace): New functions.
(semanticdb-typecache-file-tags)
(semanticdb-typecache-merge-streams): Use them.
(semanticdb-typecache-file-tags): When deriving tags from a file,
give the mode a chance to monkey with the tag copy.
(semanticdb-typecache-find-default): Wrap find in save-excursion.
(semanticdb-typecache-find-by-name-helper): Merge found names down.
* semantic/db-global.el
(semanticdb-enable-gnu-global-in-buffer): Don't show messages if
GNU Global is not available and we don't want to throw an error.
* semantic/db-find.el (semanticdb-find-result-nth-in-buffer):
When trying to normalize the tag to a buffer, don't error if
set-buffer method doesn't exist.
* semantic/db-file.el (semanticdb-save-db): Simplify msg.
* semantic/db.el (semanticdb-refresh-table): If forcing a
refresh on a file not in a buffer, use semantic-find-file-noselect
and delete the buffer after use.
(semanticdb-current-database-list): When calculating root via
hooks, force it through true-filename and skip the list of
possible roots.
* semantic/ctxt.el (semantic-ctxt-imported-packages): New.
* semantic/analyze/debug.el
(semantic-analyzer-debug-insert-tag): Reset standard output to
current buffer.
(semantic-analyzer-debug-global-symbol)
(semantic-analyzer-debug-missing-innertype): Change "prefix" to
"symbol" in messages.
* semantic/analyze/refs.el: (semantic-analyze-refs-impl)
(semantic-analyze-refs-proto): When calculating value, make sure
the found tag is 'similar' to the originating tag.
(semantic--analyze-refs-find-tags-with-parent): Attempt to
identify matches via imported symbols of parents.
(semantic--analyze-refs-full-lookup-with-parents): Do a deep
search during the brute search.
* semantic/analyze.el
(semantic-analyze-find-tag-sequence-default): Be robust to
calculated scopes being nil.
* semantic/bovine/c.el (semantic-c-describe-environment): Add
project macro symbol array.
(semantic-c-parse-lexical-token): Add recursion limit.
(semantic-ctxt-imported-packages, semanticdb-expand-nested-tag):
New overrides.
(semantic-expand-c-tag-namelist): Split a full type from a typedef
out to its own tag.
(semantic-expand-c-tag-namelist): Do not split out a typedef'd
inline type if it is an anonymous type.
(semantic-c-reconstitute-token): Use the optional initializers as
a clue that some function is probably a constructor. When
defining the type of these constructors, split the parent name,
and use only the class part, if applicable.
* semantic/bovine/c-by.el:
* semantic/wisent/python-wy.el: Regenerate.
author | Chong Yidong <cyd@stupidchicken.com> |
---|---|
date | Sat, 18 Sep 2010 22:49:54 -0400 |
parents | 1d1d5d9bd884 |
children | c84578d13e42 376148b31b5e |
line wrap: on
line source
;;; calc-aent.el --- algebraic entry functions for Calc ;; Copyright (C) 1990, 1991, 1992, 1993, 2001, 2002, 2003, 2004, ;; 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc. ;; Author: Dave Gillespie <daveg@synaptics.com> ;; Maintainer: Jay Belanger <jay.p.belanger@gmail.com> ;; 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 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ;; 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 <http://www.gnu.org/licenses/>. ;;; 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)) (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.") ;;;###autoload (defun calc-do-quick-calc () (require 'calc-ext) (calc-check-defines) (if (eq major-mode 'calc-mode) (calc-algebraic-entry t) (let (buf shortbuf) (save-excursion (calc-create-buffer) (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))) alg-exp " ") 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)))) (calc-handle-whys) (message "Result: %s" buf))) (if (eq last-command-event 10) (insert shortbuf) (kill-new shortbuf))))) ;;;###autoload (defun calc-do-calc-eval (str separator args) (calc-check-defines) (catch 'calc-error (save-excursion (calc-create-buffer) (cond ((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 (unwind-protect (progn (select-window calc-window) (calc-execute-kbd-macro str nil (car args))) (and (window-point save-window) (select-window save-window))) (save-window-excursion (select-window (get-largest-window)) (switch-to-buffer calc-buffer) (calc-execute-kbd-macro str nil (car args))))) nil) ((eq separator 'pop) (or (not (integerp str)) (= str 0) (calc-pop (min str (calc-stack-size)))) (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)))) (t (let* ((calc-command-flags nil) (calc-next-why nil) (calc-language (if (memq calc-language '(nil big)) 'flat calc-language)) (calc-dollar-values (mapcar (function (lambda (x) (if (stringp x) (progn (setq x (math-read-exprs x)) (if (eq (car-safe x) 'error) (throw 'calc-error (calc-eval-error (cdr x))) (car x))) x))) args)) (calc-dollar-used 0) (res (if (stringp str) (math-read-exprs str) (list str))) buf) (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) res) ((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)) (calc-eval-error (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) nil) (t (while res (setq buf (concat buf (and buf (or separator ", ")) (math-format-value (car res) 1000)) res (cdr res))) buf))))))))) (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))) msg)) ;;;; Reading an expression in algebraic form. ;;;###autoload (defun calc-auto-algebraic-entry (&optional prefix) (interactive "P") (calc-algebraic-entry prefix t)) ;;;###autoload (defun calc-algebraic-entry (&optional prefix auto) (interactive "P") (calc-wrapper (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.") ;;;###autoload (defun calc-alg-entry (&optional initial prompt) (let* ((sel-mode nil) (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) (progn (require 'calc-ext) (calc-alg-edit alg-exp)) (let* ((calc-simplify-mode (if (eq last-command-event ?\C-j) 'none calc-simplify-mode)) (nvals (mapcar 'calc-normalize alg-exp))) (while alg-exp (calc-record (if (featurep 'calc-ext) (car alg-exp) (car nvals)) "alg'") (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))) (calc-handle-whys)))) (defvar calc-alg-ent-map nil "The keymap used for algebraic entry.") (defvar calc-alg-ent-esc-map nil "The keymap used for escapes in algebraic entry.") (defvar calc-alg-exp) ;;;###autoload (defun calc-do-alg-entry (&optional initial prompt no-normalize history) (let* ((calc-buffer (current-buffer)) (blink-paren-function 'calcAlg-blink-matching-open) (calc-alg-exp 'error)) (unless calc-alg-ent-map (setq calc-alg-ent-map (copy-keymap minibuffer-local-map)) (define-key calc-alg-ent-map "'" 'calcAlg-previous) (define-key calc-alg-ent-map "`" 'calcAlg-edit) (define-key calc-alg-ent-map "\C-m" 'calcAlg-enter) (define-key calc-alg-ent-map "\C-j" 'calcAlg-enter) (let ((i 33)) (setq calc-alg-ent-esc-map (copy-keymap esc-map)) (while (< i 127) (aset (nth 1 calc-alg-ent-esc-map) i 'calcAlg-escape) (setq i (1+ i))))) (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)))) calc-alg-exp))) (defun calcAlg-plus-minus () (interactive) (if (calc-minibuffer-contains ".* \\'") (insert "+/- ") (insert " +/- "))) (defun calcAlg-mod () (interactive) (if (not (calc-minibuffer-contains ".* \\'")) (insert " ")) (if (calc-minibuffer-contains ".* mod +\\'") (if calc-previous-modulo (insert (math-format-flat-expr calc-previous-modulo 0)) (beep)) (insert "mod "))) (defun calcAlg-previous () (interactive) (if (calc-minibuffer-contains "\\'") (previous-history-element 1) (insert "'"))) (defun calcAlg-equals () (interactive) (unwind-protect (calcAlg-enter) (if (consp calc-alg-exp) (progn (setq prefix-arg (length calc-alg-exp)) (calc-unread-command ?=))))) (defun calcAlg-escape () (interactive) (calc-unread-command) (save-excursion (calc-select-buffer) (use-local-map calc-mode-map)) (calcAlg-enter)) (defvar calc-plain-entry nil) (defun calcAlg-edit () (interactive) (if (or (not calc-plain-entry) (calc-minibuffer-contains "\\`\\([^\"]*\"[^\"]*\"\\)*[^\"]*\"[^\"]*\\'")) (insert "`") (setq calc-alg-exp (minibuffer-contents)) (exit-minibuffer))) (defvar calc-buffer) (defun calcAlg-enter () (interactive) (let* ((str (minibuffer-contents)) (exp (and (> (length str) 0) (with-current-buffer calc-buffer (math-read-exprs str))))) (if (eq (car-safe exp) 'error) (progn (goto-char (minibuffer-prompt-end)) (forward-char (nth 1 exp)) (beep) (calc-temp-minibuffer-message (concat " [" (or (nth 2 exp) "Error") "]")) (calc-clear-unread-commands)) (setq calc-alg-exp (if (calc-minibuffer-contains "\\` *\\[ *\\'") '((incomplete vec)) exp)) (exit-minibuffer)))) (defun calcAlg-blink-matching-open () (let ((rightpt (point)) (leftpt nil) (rightchar (preceding-char)) leftchar rightsyntax leftsyntax) (save-excursion (condition-case () (setq leftpt (scan-sexps rightpt -1) leftchar (char-after leftpt)) (error nil))) (if (and leftpt (or (and (= rightchar ?\)) (= leftchar ?\[)) (and (= rightchar ?\]) (= leftchar ?\())) (save-excursion (goto-char leftpt) (looking-at ".+\\(\\.\\.\\|\\\\dots\\|\\\\ldots\\)"))) (let ((leftsaved (aref (syntax-table) leftchar)) (rightsaved (aref (syntax-table) rightchar))) (unwind-protect (progn (cond ((= leftchar ?\[) (aset (syntax-table) leftchar (cons 4 ?\))) (aset (syntax-table) rightchar (cons 5 ?\[))) (t (aset (syntax-table) leftchar (cons 4 ?\])) (aset (syntax-table) rightchar (cons 5 ?\()))) (blink-matching-open)) (aset (syntax-table) leftchar leftsaved) (aset (syntax-table) rightchar rightsaved))) (blink-matching-open)))) ;;;###autoload (defun calc-alg-digit-entry () (calc-alg-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) ;;;###autoload (defun calcDigit-algebraic () (interactive) (if (calc-minibuffer-contains ".*[@oh] *[^'m ]+[^'m]*\\'") (calcDigit-key) (setq calc-digit-value (minibuffer-contents)) (exit-minibuffer))) ;;;###autoload (defun calcDigit-edit () (interactive) (calc-unread-command) (setq calc-digit-value (minibuffer-contents)) (exit-minibuffer)) ;;; 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.") ;;;###autoload (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)))) str) ;; 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) ;;;###autoload (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))))) (math-build-parse-table) (math-read-token) (let ((val (catch 'syntax (math-read-expr-list)))) (if (stringp val) (list 'error math-exp-old-pos val) (if (equal math-exp-token 'end) val (list 'error math-exp-old-pos "Syntax error")))))) ;;;###autoload (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 ",") (math-read-token) (let ((rest (list (math-read-expr-level 0)))) (setcdr last rest) (setq last rest))) val)) (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.") ;;;###autoload (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))))) ;;;###autoload (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-Z0-9]" (car p))) (let ((s (regexp-quote (car p)))) (if (string-match "\\`[a-zA-Z0-9]" s) (setq s (concat "\\<" s))) (if (string-match "[a-zA-Z0-9]\\'" s) (setq s (concat s "\\>"))) (or (assoc s math-toks) (progn (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) calc-user-token-chars))))))) ((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)))) ;;;###autoload (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 " ") (math-read-token))) ((and (memq ch calc-user-token-chars) (let ((case-fold-search nil)) (eq (string-match calc-user-tokens math-exp-str math-exp-pos) 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))) (string-match (cond ((and (memq calc-language calc-lang-allow-underscores) (memq calc-language calc-lang-allow-percentsigns)) "[a-zA-Z0-9_'#]*") ((memq calc-language calc-lang-allow-underscores) "[a-zA-Z0-9_#]*") (t "[a-zA-Z0-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) math-exp-pos)) (and (eq ch '?_) (eq (string-match "_\\.?[0-9]" math-exp-str math-exp-pos) math-exp-pos) (or (eq math-exp-pos 0) (and (not (memq calc-language calc-lang-allow-underscores)) (eq (string-match "[^])}\"a-zA-Z0-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) 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) 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) 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)) (math-read-token)) (t (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 math-expr-data (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)) t)) (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))) math-expr-data)))) (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")) (math-read-token)) (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) x (if (eq (nth 1 op) 'closing) (if (eq (nth 2 op) exp-prec) (progn (setq exp-prec 1000) x) (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) x (math-read-expr-level (nth 3 op) exp-term)))) first nil)) x)) ;; calc-arg-values is defined in calc-ext.el, but is used here. (defvar calc-arg-values) ;;;###autoload (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) calc-arg-values)) (conds nil) temp) (if x (setq matches (cons x matches))) (setq match (cdr (car p))) (while (and (eq (car-safe match) 'calcFunc-condition) (= (length match) 3)) (setq conds (append (math-flatten-lands (nth 2 match)) conds) match (nth 1 match))) (while (and conds match) (require 'calc-ext) (cond ((eq (car-safe (car conds)) 'calcFunc-let) (setq temp (car conds)) (or (= (length temp) 3) (and (= (length temp) 2) (eq (car-safe (nth 1 temp)) 'calcFunc-assign) (= (length (nth 1 temp)) 3) (setq temp (nth 1 temp))) (setq match nil)) (setq matches (cons (math-normalize (math-multi-subst (nth 2 temp) args matches)) matches) args (cons (nth 1 temp) args))) ((and (eq (car-safe (car conds)) 'calcFunc-matches) (= (length (car conds)) 3)) (setq temp (calcFunc-vmatches (math-multi-subst (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)) matches) args (cons (nth 1 (car temp)) args))))) (t (or (math-is-true (math-simplify (math-multi-subst (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))) ;;;###autoload (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) m) (while (and p (cond ((stringp (car p)) (and (equal math-expr-data (car p)) (progn (math-read-token) t))) ((integerp (car p)) (and (setq m (catch 'syntax (math-read-expr-level (car p) (if (cdr p) (if (consp (nth 1 p)) (car (nth 1 (nth 1 p))) (nth 1 p)) term)))) (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 (list (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))) (t (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")) matches)) ;;;###autoload (defun math-remove-dashes (x) (if (string-match "\\`\\(.*\\)-\\(.*\\)\\'" x) (math-remove-dashes (concat (math-match-substring x 1) "#" (math-match-substring x 2))) x)) (defun math-remove-percentsigns (x) (if (string-match "\\`\\(.*\\)%\\(.*\\)\\'" x) (math-remove-percentsigns (concat (math-match-substring x 1) "o'o" (math-match-substring x 2))) x)) (defun math-restore-dashes (x) (if (string-match "\\`\\(.*\\)[#_]\\(.*\\)\\'" x) (math-restore-dashes (concat (math-match-substring x 1) "-" (math-match-substring x 2))) x)) (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) (math-string-restore-underscores (concat (math-match-substring x 1) "_" (math-match-substring x 2))) x)) ;;;###autoload (defun math-read-if (cond op) (let ((then (math-read-expr-level 0))) (or (equal math-expr-data ":") (throw 'syntax "Expected ':'")) (math-read-token) (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) (math-read-token) (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)) op) (cond ((eq math-exp-token 'number) (let ((num (math-read-number math-expr-data))) (if (not num) (progn (setq math-exp-old-pos math-exp-pos) (throw 'syntax "Bad format"))) (math-read-token) (if (and math-read-expr-quotes (consp num)) (list 'quote num) num))) ((and calc-user-parse-table (setq op (calc-check-user-syntax))) op) ((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)) (math-read-factor)) ((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) (math-read-token) (let ((val (math-read-expr-level (nth 3 op)))) (cond ((eq (nth 1 op) 'ident) val) ((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))) (math-read-token) (if (equal math-expr-data calc-function-open) (let ((f (assq sym math-expr-function-mapping))) (math-read-token) (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)) nil (math-read-expr-list)))) (if (not (or (equal math-expr-data calc-function-close) (eq math-exp-token 'end))) (throw 'syntax "Expected `)'")) (math-read-token) (if (and (memq calc-language calc-lang-parens-are-subscripts) args (require 'calc-ext) (let ((calc-matrix-mode 'scalar)) (math-known-matrixp (list 'var sym (intern (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) 0) (setq sym (intern (substring (symbol-name sym) 1)))) (or (string-match "-" (symbol-name sym)) (setq sym (intern (concat "calcFunc-" (symbol-name sym)))))) (cons sym args))))) (if math-read-expr-quotes sym (let ((val (list 'var (intern (math-remove-dashes (symbol-name sym))) (if (string-match "-" (symbol-name sym)) 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)) math-expr-variable-mapping)))) (and v (setq val (if (consp (cdr v)) (funcall (car (cdr v)) v val) (list 'var (intern (substring (symbol-name (cdr v)) 4)) (cdr v)))))) (while (and (memq calc-language calc-lang-brackets-are-subscripts) (equal math-expr-data "[")) (math-read-token) (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 "]") (math-read-token) (throw 'syntax "Expected ']'"))) val))))) ((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)) (math-read-token) (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)) (math-read-token) (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)) (math-read-token) (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)) (cond ((equal math-expr-data ",") (progn (math-read-token) (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 ";") (progn (math-read-token) (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")) (progn (math-read-token) (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) exp exp2))))))) (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 `)'")) (math-read-token) exp)) ((eq math-exp-token 'string) (require 'calc-ext) (math-read-string)) ((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) (math-read-angle-brackets)) (t (throw 'syntax "Expected a number"))))) (provide 'calc-aent) ;; Local variables: ;; generated-autoload-file: "calc-loaddefs.el" ;; End: ;; arch-tag: 5599e45d-e51e-44bb-9a20-9f4ed8c96c32 ;;; calc-aent.el ends here