emacs: lisp/calc/calc-aent.el comparison

comparison lisp/calc/calc-aent.el @ 90054:f2ebccfa87d4

Revision: miles@gnu.org--gnu-2004/emacs--unicode--0--patch-74 Merge from emacs--cvs-trunk--0 Patches applied: * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-709 Update from CVS: src/indent.c (Fvertical_motion): Fix last change. * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-710 - miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-715 Update from CVS * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-716 Merge from gnus--rel--5.10 * miles@gnu.org--gnu-2004/gnus--rel--5.10--patch-74 Update from CVS

author	Miles Bader <miles@gnu.org>
date	Wed, 08 Dec 2004 05:02:30 +0000
parents	cb7f41387eb3 157fd661769f
children	fb79180b618d

comparison

equal deleted inserted replaced

-:fff5f1a61d92
+:f2ebccfa87d4
 ;;; calc-aent.el --- algebraic entry functions for Calc
 ;; Copyright (C) 1990, 1991, 1992, 1993, 2001 Free Software Foundation, Inc.
 ;; Author: Dave Gillespie <daveg@synaptics.com>
-;; Maintainers: D. Goel <deego@gnufans.org>
+;; Maintainer: Jay Belanger <belanger@truman.edu>
-;;              Colin Walters <walters@debian.org>
 ;; This file is part of GNU Emacs.
 ;; GNU Emacs is distributed in the hope that it will be useful,
 ;; but WITHOUT ANY WARRANTY.  No author or distributor
 ;;; Commentary:
 ;;; Code:
 ;; This file is autoloaded from calc.el.
 (require 'calc)
 (require 'calc-macs)
-(eval-when-compile '(require calc-macs))
-(defun calc-Need-calc-aent () nil)
 (defun calc-do-quick-calc ()
 (calc-check-defines)
 (if (eq major-mode 'calc-mode)
 (calc-algebraic-entry t)
 	       (calc-language (if (memq calc-language '(nil big))
 				  'flat calc-language))
 	       (entry (calc-do-alg-entry "" "Quick calc: " t))
 	       (alg-exp (mapcar (function
 				 (lambda (x)
-				   (if (and (not calc-extensions-loaded)
+				   (if (and (not (featurep 'calc-ext))
 					    calc-previous-alg-entry
 					    (string-match
 					     "\\`[-0-9._+*/^() ]+\\'"
 					     calc-previous-alg-entry))
 				       (calc-normalize x)
-				     (calc-extensions)
+				     (require 'calc-ext)
 				     (math-evaluate-expr x))))
 				entry)))
 	  (when (and (= (length alg-exp) 1)
 		     (eq (car-safe (car alg-exp)) 'calcFunc-assign)
 		     (= (length (car alg-exp)) 3)
 		     (eq (car-safe (nth 1 (car alg-exp))) 'var))
-	    (calc-extensions)
+	    (require 'calc-ext)
 	    (set (nth 2 (nth 1 (car alg-exp))) (nth 2 (car alg-exp)))
 	    (calc-refresh-evaltos (nth 2 (nth 1 (car alg-exp))))
 	    (setq alg-exp (list (nth 2 (car alg-exp)))))
 	  (setq calc-quick-prev-results alg-exp
 		buf (mapconcat (function (lambda (x)
 					 (< (car alg-exp) 127))
 				    (format ", \"%c\"" (car alg-exp))
 				  "")
 				")")))
 	  (if (and (< (length buf) (frame-width)) (= (length entry) 1)
-		   calc-extensions-loaded)
+		   (featurep 'calc-ext))
 	      (let ((long (concat (math-format-value (car entry) 1000)
 				  " =>  " buf)))
 		(if (<= (length long) (- (frame-width) 8))
 		    (setq buf long))))
 	  (calc-handle-whys)
 	    (setq strp (cdr (cdr strp))))
 	  (calc-do-calc-eval (car str) separator args)))
 ((eq separator 'eval)
 	(eval str))
 ((eq separator 'macro)
-	(calc-extensions)
+	(require 'calc-ext)
 	(let* ((calc-buffer (current-buffer))
 	       (calc-window (get-buffer-window calc-buffer))
 	       (save-window (selected-window)))
 	  (if calc-window
 	      (unwind-protect
 	      (calc-eval-error (cdr res))
 	    (setq res (mapcar 'calc-normalize res))
 	    (and (memq 'clear-message calc-command-flags)
 		 (message ""))
 	    (cond ((eq separator 'pred)
-		   (calc-extensions)
+		   (require 'calc-ext)
 		   (if (= (length res) 1)
 		       (math-is-true (car res))
 		     (calc-eval-error '(0 "Single value expected"))))
 		  ((eq separator 'raw)
 		   (if (= (length res) 1)
 					 (and buf (or separator ", "))
 					 (math-format-value (car res) 1000))
 			     res (cdr res)))
 		     buf)))))))))
+(defvar calc-eval-error nil
+"Determines how calc handles errors.
+NIL means return a list containing the character position of error.
+STRING means return error message as string rather than list.
+T means abort and give an error message.")
 (defun calc-eval-error (msg)
-(if (and (boundp 'calc-eval-error)
+(if calc-eval-error
-	   calc-eval-error)
 (if (eq calc-eval-error 'string)
 	  (nth 1 msg)
 	(error "%s" (nth 1 msg)))
 msg))
 	 (calc-dollar-used 0)
 	 (calc-plain-entry t)
 	 (alg-exp (calc-do-alg-entry initial prompt t)))
 (if (stringp alg-exp)
 	(progn
-	  (calc-extensions)
+	  (require 'calc-ext)
 	  (calc-alg-edit alg-exp))
 (let* ((calc-simplify-mode (if (eq last-command-char ?\C-j)
 				     'none
 				   calc-simplify-mode))
 	     (nvals (mapcar 'calc-normalize alg-exp)))
 	(while alg-exp
-	  (calc-record (if calc-extensions-loaded (car alg-exp) (car nvals))
+	  (calc-record (if (featurep 'calc-ext) (car alg-exp) (car nvals))
 		       "alg'")
 	  (calc-pop-push-record-list calc-dollar-used
 				     (and (not (equal (car alg-exp)
 						      (car nvals)))
-					  calc-extensions-loaded
+					  (featurep 'calc-ext)
 					  "")
 				     (list (car nvals)))
 	  (setq alg-exp (cdr alg-exp)
 		nvals (cdr nvals)
 		calc-dollar-used 0)))
 (insert "`")
 (setq calc-alg-exp (minibuffer-contents))
 (and (> (length calc-alg-exp) 0) (setq calc-previous-alg-entry calc-alg-exp))
 (exit-minibuffer)))
+(defvar calc-buffer)
 (defun calcAlg-enter ()
 (interactive)
 (let* ((str (minibuffer-contents))
 	 (exp (and (> (length str) 0)
 		   (save-excursion
 	 ((eq last-command-char ?#) (format "%d#" calc-number-radix))
 	 ((eq last-command-char ?_) "-")
 	 ((eq last-command-char ?@) "0@ ")
 	 (t (char-to-string last-command-char)))))
+;; The variable calc-digit-value is initially declared in calc.el,
+;; but can be set by calcDigit-algebraic and calcDigit-edit.
+(defvar calc-digit-value)
 (defun calcDigit-algebraic ()
 (interactive)
 (if (calc-minibuffer-contains ".*[@oh] *[^'m ]+[^'m]*\\'")
 (calcDigit-key)
 (setq calc-digit-value (minibuffer-contents))
 (exit-minibuffer))
 ;;; Algebraic expression parsing.   [Public]
-;;; The next few variables are local to math-read-exprs (and math-read-expr)
+;; The next few variables are local to math-read-exprs (and math-read-expr
-;;; but are set in functions they call.
+;; in calc-ext.el), but are set in functions they call.
 (defvar math-exp-pos)
 (defvar math-exp-str)
 (defvar math-exp-old-pos)
 (defvar math-exp-token)
 (defvar math-exp-keep-spaces)
+(defvar math-expr-data)
 (defun math-read-exprs (math-exp-str)
 (let ((math-exp-pos 0)
 	(math-exp-old-pos 0)
 	(math-exp-keep-spaces nil)
 	math-exp-token math-expr-data)
+(setq math-exp-str (math-read-preprocess-string math-exp-str))
 (if calc-language-input-filter
 	(setq math-exp-str (funcall calc-language-input-filter math-exp-str)))
 (while (setq math-exp-token (string-match "\\.\\.\\([^.]\\|.[^.]\\)" math-exp-str))
 (setq math-exp-str (concat (substring math-exp-str 0 math-exp-token) "\\dots"
 			    (substring math-exp-str (+ math-exp-token 2)))))
 		 (setq ch ?\,))
 	     (setq math-exp-token 'punc
 		   math-expr-data (char-to-string ch)
 		   math-exp-pos (1+ math-exp-pos)))))))
+(defconst math-alg-inequalities
+'(calcFunc-lt calcFunc-gt calcFunc-leq calcFunc-geq
+		calcFunc-eq calcFunc-neq))
 (defun math-read-expr-level (exp-prec &optional exp-term)
 (let* ((x (math-read-factor)) (first t) op op2)
 (while (and (or (and calc-user-parse-table
 			 (setq op (calc-check-user-syntax x exp-prec))
 		(not (and exp-term (equal math-expr-data exp-term)))
 		(>= (nth 2 op) exp-prec))
 (if (not (equal (car op) "2x"))
 	  (math-read-token))
 (and (memq (nth 1 op) '(sdev mod))
-	   (calc-extensions))
+	   (require 'calc-ext))
 (setq x (cond ((consp (nth 1 op))
 		     (funcall (car (nth 1 op)) x op))
 		    ((eq (nth 3 op) -1)
 		     (if (eq (nth 1 op) 'ident)
 			 x
 			     (throw 'syntax "Mismatched delimiters"))
 			 (list (nth 1 op) x))))
 		    ((and (not first)
 			  (memq (nth 1 op) math-alg-inequalities)
 			  (memq (car-safe x) math-alg-inequalities))
-		     (calc-extensions)
+		     (require 'calc-ext)
 		     (math-composite-inequalities x op))
 		    (t (list (nth 1 op)
 			     x
 			     (math-read-expr-level (nth 3 op) exp-term))))
 	    first nil))
 			  (save-exp-token math-exp-token)
 			  (save-exp-data math-expr-data))
 		      (or (not (listp
 				(setq matches (calc-match-user-syntax rule))))
 			  (let ((args (progn
-					(calc-extensions)
+					(require 'calc-ext)
 					calc-arg-values))
 				(conds nil)
 				temp)
 			    (if x
 				(setq matches (cons x matches)))
 			      (setq conds (append (math-flatten-lands
 						   (nth 2 match))
 						  conds)
 				    match (nth 1 match)))
 			    (while (and conds match)
-			      (calc-extensions)
+			      (require 'calc-ext)
 			      (cond ((eq (car-safe (car conds))
 					 'calcFunc-let)
 				     (setq temp (car conds))
 				     (or (= (length temp) 3)
 					 (and (= (length temp) 2)
 	      math-exp-token save-exp-token
 	      math-expr-data save-exp-data
 	      matches "Failed"))
 matches))
-(defconst math-alg-inequalities
-'(calcFunc-lt calcFunc-gt calcFunc-leq calcFunc-geq
-		calcFunc-eq calcFunc-neq))
 (defun math-remove-dashes (x)
 (if (string-match "\\`\\(.*\\)-\\(.*\\)\\'" x)
 (math-remove-dashes
 (concat (math-match-substring x 1) "#" (math-match-substring x 2)))
 x))
 		       (if (not (or (equal math-expr-data calc-function-close)
 				    (eq math-exp-token 'end)))
 			   (throw 'syntax "Expected `)'"))
 		       (math-read-token)
 		       (if (and (eq calc-language 'fortran) args
-				(calc-extensions)
+				(require 'calc-ext)
 				(let ((calc-matrix-mode 'scalar))
 				  (math-known-matrixp
 				   (list 'var sym
 					 (intern
 					  (concat "var-"
 				  "Too many $'s"
 				"$'s not allowed in this context")))))
 	  ((eq math-exp-token 'hash)
 	   (or calc-hashes-used
 	       (throw 'syntax "#'s not allowed in this context"))
-	   (calc-extensions)
+	   (require 'calc-ext)
 	   (if (<= math-expr-data (length calc-arg-values))
 	       (let ((num math-expr-data))
 		 (math-read-token)
 		 (setq calc-hashes-used (max calc-hashes-used num))
 		 (nth (1- num) calc-arg-values))
 		   (math-read-token)
 		   (let ((exp2 (math-read-expr-level 0)))
 		     (setq exp (if (and exp2 (Math-realp exp)
 					(Math-anglep exp2))
 				   (math-normalize (list 'polar exp exp2))
-				 (calc-extensions)
+				 (require 'calc-ext)
 				 (list '* exp
 				       (list 'calcFunc-exp
 					     (list '*
 						   (math-to-radians-2 exp2)
 						   '(var i var-i)))))))))
 			  (eq math-exp-token 'end)))
 		 (throw 'syntax "Expected `)'"))
 	     (math-read-token)
 	     exp))
 	  ((eq math-exp-token 'string)
-	   (calc-extensions)
+	   (require 'calc-ext)
 	   (math-read-string))
 	  ((equal math-expr-data "[")
-	   (calc-extensions)
+	   (require 'calc-ext)
 	   (math-read-brackets t "]"))
 	  ((equal math-expr-data "{")
-	   (calc-extensions)
+	   (require 'calc-ext)
 	   (math-read-brackets nil "}"))
 	  ((equal math-expr-data "<")
-	   (calc-extensions)
+	   (require 'calc-ext)
 	   (math-read-angle-brackets))
 	  (t (throw 'syntax "Expected a number")))))
+(provide 'calc-aent)
 ;;; arch-tag: 5599e45d-e51e-44bb-9a20-9f4ed8c96c32
 ;;; calc-aent.el ends here

Mercurial > emacs

comparison lisp/calc/calc-aent.el @ 90054:f2ebccfa87d4