[Maxima-commits] CVS: maxima/src commac.lisp,1.27,1.28 displa.lisp,1.22,1.23

[Robert D. <rob...@us...>]

Update of /cvsroot/maxima/maxima/src
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv13449/src

Modified Files:
	commac.lisp displa.lisp 
Log Message:
Changes to make backslash a line continuation character.

Output: print backslash (instead of hash mark) at the end of
a line when a long atom is broken across lines. (e.g., 100!)

Input: recognize the sequences <backslash> <return> <newline>,
<backslash> <return>, and <backslash> <newline>,
and eat them. Otherwise backslash is not processed by the
new code; other functions farther up the food chain process
backslash as before.

 - src/commac.lisp: revise TYI and TYI-PEEK, new functions TYI-RAW
   and EAT-CONTINUATIONS

 - src/displa.lisp: in DIMENSION-STRING, print a backslash at the end of a line
   (instead of hash mark)

 - tests/rtestparser_continuations_{cr,nl,crnl}.mac: new test scripts
   cr = end-of-line is marked by return only
   nl = end-of-line is marked by newline only
   crnl = end-of-line is marked by return, then newline

When tested on Linux with GCL 2.6.7, SBCL 0.9.4, and Clisp 2.34,
batch ("rtestparser_continuations_cr.mac", test); succeeds,
same with rtestparser_continuations_nl.mac and rtestparser_continuations_crnl.mac.
batch (<filename>); (i.e., without the test argument) succeeds for all three.
load (<filename>); succeeds for all three.

When tested on Windows with GCL 2.6.7, tests with
rtestparser_continuations_nl.mac and rtestparser_continuations_crnl.mac
succeed, but not rtestparser_continuations_cr.mac;
Maxima gets all the way through the test without problems,
then barfs at the very end. batch (<filename>, test); tickles
a bug in GCL's READ-CHAR-NO-HANG when the last line is terminated
by <return>. However, batch ("rtestparser_continuations_cr.mac"); succeeds,
as batch (<filename>) (without test argument) does for the other two.
load (<filename>); fails on rtestparser_continuations_cr.mac
(same READ-CHAR-NO-HANG bug) and succeeds with the other two.


Index: commac.lisp
===================================================================
RCS file: /cvsroot/maxima/maxima/src/commac.lisp,v
retrieving revision 1.27
retrieving revision 1.28
diff -u -d -r1.27 -r1.28
--- commac.lisp	7 Nov 2005 17:37:11 -0000	1.27
+++ commac.lisp	10 Nov 2005 03:37:21 -0000	1.28
@@ -690,7 +690,7 @@
 
 (defvar *prompt-on-read-hang* nil)
 (defvar *read-hang-prompt* "")
-(defun tyi (&optional (stream *standard-input*) eof-option)
+(defun tyi-raw (&optional (stream *standard-input*) eof-option)
   (let ((ch (read-char-no-hang stream nil eof-option)))
     (if ch
 	ch
@@ -700,10 +700,47 @@
 	    (force-output *standard-output*))
 	  (read-char stream nil eof-option)))))
 
+(defun tyi (&optional (stream *standard-input*) eof-option)
+  (let ((ch (tyi-raw stream eof-option)))
+    (if (eq ch eof-option)
+      ch
+      (backslash-check ch stream eof-option))))
+
+; The sequences of characters
+; <anything-except-backslash>
+;   (<backslash> <newline> | <backslash> <return> | <backslash> <return> <newline>)+
+;   <anything>
+; are reduced to <anything-except-backslash> <anything> .
+; Note that this has no effect on <backslash> <anything-but-newline-or-return> .
+
+(let ((previous-tyi #\a))
+  (defun backslash-check (ch stream eof-option)
+    (if (eq previous-tyi #\\ )
+      (progn (setq previous-tyi #\a) ch)
+      (setq previous-tyi
+        (if (eq ch #\\ )
+          (let ((next-char (tyipeek nil stream nil eof-option)))
+            (if (or (eq next-char #\newline) (eq next-char #\return))
+              (eat-continuations ch stream eof-option)
+              ch))
+          ch))))
+  ; We have just read <backslash> and we know the next character is <newline> or <return>.
+  ; Eat line continuations until we come to something which doesn't match, or we reach eof.
+  (defun eat-continuations (ch stream eof-option)
+    (setq ch (tyi-raw stream eof-option))
+    (do () ((not (or (eq ch #\newline) (eq ch #\return))))
+      (let ((next-char (tyipeek nil stream nil eof-option)))
+        (if (and (eq ch #\return) (eq next-char #\newline))
+          (tyi-raw stream eof-option)))
+      (setq ch (tyi-raw stream eof-option))
+      (let ((next-char (tyipeek nil stream nil eof-option)))
+        (if (and (eq ch #\\ ) (or (eq next-char #\return) (eq next-char #\newline)))
+          (setq ch (tyi-raw stream eof-option))
+          (return-from eat-continuations ch))))
+    ch))
+
 (defun tyipeek (&optional peek-type &rest read-args)
-  (if read-args
-      (peek-char peek-type (car read-args))
-      (peek-char peek-type)))
+  (eval `(peek-char ,peek-type ,@read-args)))
 
 ;;I don't think these are terribly useful so why use them.
 

Index: displa.lisp
===================================================================
RCS file: /cvsroot/maxima/maxima/src/displa.lisp,v
retrieving revision 1.22
retrieving revision 1.23
diff -u -d -r1.22 -r1.23
--- displa.lisp	7 Nov 2005 17:37:11 -0000	1.22
+++ displa.lisp	10 Nov 2005 03:37:21 -0000	1.23
@@ -306,7 +306,7 @@
 		(setq result nil w (f+ linel width)))
 	       (t (increment width)
 		  (when (and (= w width) l)
-		    (forcebreak (cons #\# result) width)
+		    (forcebreak (cons #\\ result) width)
 		    (setq result nil w (f+ linel width))
 		    (increment width))
 		  (setq result (rplacd dummy result))))))))