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