From crhodes at common-lisp.net  Mon May  2 09:05:01 2005
From: crhodes at common-lisp.net (Christophe Rhodes)
Date: Mon,  2 May 2005 11:05:01 +0200 (CEST)
Subject: [climacs-cvs] CVS update: climacs/syntax.lisp 
Message-ID: <20050502090501.08B0188717@common-lisp.net>

Update of /project/climacs/cvsroot/climacs
In directory common-lisp.net:/tmp/cvs-serv13557

Modified Files:
	syntax.lisp 
Log Message:
Use sbit rather than aref, mostly for self-documentation (because it
doesn't actually speed things up much; it's just a constant-factor
optimization)

Date: Mon May  2 11:05:01 2005
Author: crhodes

Index: climacs/syntax.lisp
diff -u climacs/syntax.lisp:1.47 climacs/syntax.lisp:1.48
--- climacs/syntax.lisp:1.47	Sat Apr 16 07:20:29 2005
+++ climacs/syntax.lisp	Mon May  2 11:05:00 2005
@@ -401,8 +401,8 @@
 	   (if (functionp (right-hand-side rule))
 	       (let ((predicted-rules (slot-value to-state 'predicted-rules))
 		     (rule-number (slot-value rule 'number)))
-		 (when (zerop (aref predicted-rules rule-number))
-		   (setf (aref predicted-rules rule-number) 1)
+		 (when (zerop (sbit predicted-rules rule-number))
+		   (setf (sbit predicted-rules rule-number) 1)
 		   (handle-incomplete-item (make-instance 'incomplete-item
 					      :orig-state to-state
 					      :predicted-from item



From abakic at common-lisp.net  Tue May  3 20:45:21 2005
From: abakic at common-lisp.net (Aleksandar Bakic)
Date: Tue,  3 May 2005 22:45:21 +0200 (CEST)
Subject: [climacs-cvs] CVS update: climacs/gui.lisp 
Message-ID: <20050503204521.E1B948871F@common-lisp.net>

Update of /project/climacs/cvsroot/climacs
In directory common-lisp.net:/tmp/cvs-serv29990

Modified Files:
	gui.lisp 
Log Message:
Contribution by John Q. Splittist: Made Find File more portable by
copying some code from cl-fad.

Date: Tue May  3 22:45:17 2005
Author: abakic

Index: climacs/gui.lisp
diff -u climacs/gui.lisp:1.128 climacs/gui.lisp:1.129
--- climacs/gui.lisp:1.128	Sat Mar 19 23:08:31 2005
+++ climacs/gui.lisp	Tue May  3 22:45:17 2005
@@ -621,12 +621,18 @@
 	   (full-so-far (concatenate 'string directory-prefix so-far))
 	   (pathnames
 	    (loop with length = (length full-so-far)
-		  for path in (directory (concatenate 'string
-						       (remove-trail so-far)
-						      "*.*"))
-		  when (let ((mismatch (mismatch (namestring path) full-so-far)))
-			 (or (null mismatch) (= mismatch length)))
-		    collect path))
+	       and wildcard = (concatenate 'string (remove-trail so-far) "*.*")
+	       for path in
+		 #+(or sbcl cmu lispworks) (directory wildcard)
+		 #+openmcl (directory wildcard :directories t)
+		 #+allegro (directory wildcard :directories-are-files nil)
+		 #+cormanlisp (nconc (directory wildcard)
+				      (cl::directory-subdirs dirname))
+		 #-(or sbcl cmu lispworks openmcl allegro cormanlisp)
+		 (directory wildcard)
+	       when (let ((mismatch (mismatch (namestring path) full-so-far)))
+		      (or (null mismatch) (= mismatch length)))
+	       collect path))
 	   (strings (mapcar #'namestring pathnames))
 	   (first-string (car strings))
 	   (length-common-prefix nil)



From abakic at common-lisp.net  Wed May  4 22:51:22 2005
From: abakic at common-lisp.net (Aleksandar Bakic)
Date: Thu,  5 May 2005 00:51:22 +0200 (CEST)
Subject: [climacs-cvs] CVS update: climacs/gui.lisp 
Message-ID: <20050504225122.1953588720@common-lisp.net>

Update of /project/climacs/cvsroot/climacs
In directory common-lisp.net:/tmp/cvs-serv2401

Modified Files:
	gui.lisp 
Log Message:
Contribution by John Q. Splittist: Minibuffer feedback for the Isearch fns.

Date: Thu May  5 00:51:20 2005
Author: abakic

Index: climacs/gui.lisp
diff -u climacs/gui.lisp:1.129 climacs/gui.lisp:1.130
--- climacs/gui.lisp:1.129	Tue May  3 22:45:17 2005
+++ climacs/gui.lisp	Thu May  5 00:51:19 2005
@@ -1092,6 +1092,8 @@
               (offset mark) (if forwardp
                                 (- (offset mark2) (length string))
                                 (+ (offset mark2) (length string)))))
+      (display-message "~:[Failing ~;~]Isearch~:[ backward~;~]: ~A"
+		       success forwardp string)
       (push (make-instance 'isearch-state
                            :search-string string
                            :search-mark mark
@@ -1102,9 +1104,11 @@
         (beep)))))
 
 (define-named-command com-isearch-mode-forward ()
+  (display-message "Isearch: ")
   (isearch-command-loop (current-window) t))
 
 (define-named-command com-isearch-mode-backward ()
+  (display-message "Isearch backward: ")
   (isearch-command-loop (current-window) nil))
 
 (define-named-command com-isearch-append-char ()
@@ -1122,6 +1126,7 @@
 (define-named-command com-isearch-delete-char ()
   (let* ((pane (current-window)))
     (cond ((null (second (isearch-states pane)))
+	   (display-message "Isearch: ")
            (beep))
           (t
            (pop (isearch-states pane))
@@ -1134,7 +1139,10 @@
                        (+ (offset (search-mark state))
                           (length (search-string state)))
                        (- (offset (search-mark state))
-                          (length (search-string state))))))))))
+                          (length (search-string state)))))
+	     (display-message "Isearch~:[ backward~;~]: ~A"
+			      (search-forward-p state)
+			      (search-string state)))))))
 
 (define-named-command com-isearch-forward ()
   (let* ((pane (current-window))



From crhodes at common-lisp.net  Thu May  5 10:59:43 2005
From: crhodes at common-lisp.net (Christophe Rhodes)
Date: Thu,  5 May 2005 12:59:43 +0200 (CEST)
Subject: [climacs-cvs] CVS update: climacs/gui.lisp 
Message-ID: <20050505105943.EF4D28871F@common-lisp.net>

Update of /project/climacs/cvsroot/climacs
In directory common-lisp.net:/tmp/cvs-serv893

Modified Files:
	gui.lisp 
Log Message:
Provide a "comfort" restart, allowing recovery from unhandled lisp 
errors in the dynamic extent of the climacs command loop

Date: Thu May  5 12:59:43 2005
Author: crhodes

Index: climacs/gui.lisp
diff -u climacs/gui.lisp:1.130 climacs/gui.lisp:1.131
--- climacs/gui.lisp:1.130	Thu May  5 00:51:19 2005
+++ climacs/gui.lisp	Thu May  5 12:59:42 2005
@@ -284,11 +284,12 @@
 		 (redisplay-frame-panes frame))))
 	(loop
 	   for maybe-error = t
-	   do (handler-case
-		  (with-input-context ('(command
-					 :command-table 'global-climacs-table))
-		    (object)
-		    (loop
+	   do (with-simple-restart (return-to-climacs "Return to Climacs")
+		(handler-case
+		    (with-input-context ('(command
+					   :command-table 'global-climacs-table))
+		      (object)
+		      (loop
 		       for gestures = '()
 		       do (multiple-value-bind (numarg numargp)
 			      (read-numeric-argument :stream *standard-input*)
@@ -306,15 +307,14 @@
 					     (do-command command)
 					     (return)))
 					  (t nil)))))
-			 (update-climacs))
-		    (t
-		     (do-command object)
-		     (setq maybe-error nil)))
-		(abort-gesture ()
-		  (display-message "Quit")))
-	     (when maybe-error
-	       (beep))
-	     (update-climacs))))))
+		       (update-climacs))
+		      (t
+		       (do-command object)
+		       (setq maybe-error nil)))
+		  (abort-gesture () (display-message "Quit"))))
+	   (when maybe-error
+	     (beep))
+	   (update-climacs))))))
 
 (defmacro simple-command-loop (command-table loop-condition end-clauses)
   (let ((gesture (gensym))



From abakic at common-lisp.net  Thu May  5 23:00:24 2005
From: abakic at common-lisp.net (Aleksandar Bakic)
Date: Fri,  6 May 2005 01:00:24 +0200 (CEST)
Subject: [climacs-cvs] CVS update: climacs/gui.lisp 
Message-ID: <20050505230024.8B517880E0@common-lisp.net>

Update of /project/climacs/cvsroot/climacs
In directory common-lisp.net:/tmp/cvs-serv31112

Modified Files:
	gui.lisp 
Log Message:
Contribution by John Q Splittist: Removed syntax and point reset from
com-switch-to-buffer.

Date: Fri May  6 01:00:23 2005
Author: abakic

Index: climacs/gui.lisp
diff -u climacs/gui.lisp:1.131 climacs/gui.lisp:1.132
--- climacs/gui.lisp:1.131	Thu May  5 12:59:42 2005
+++ climacs/gui.lisp	Fri May  6 01:00:23 2005
@@ -780,9 +780,6 @@
 			:prompt "Switch to buffer"))
 	(pane (current-window)))
     (setf (buffer pane) buffer)
-    (setf (syntax buffer) (make-instance
-			   'basic-syntax :buffer (buffer (point pane))))
-    (beginning-of-buffer (point pane))
     (full-redisplay pane)))
 
 (define-named-command com-kill-buffer ()



From crhodes at common-lisp.net  Fri May  6 16:56:33 2005
From: crhodes at common-lisp.net (Christophe Rhodes)
Date: Fri,  6 May 2005 18:56:33 +0200 (CEST)
Subject: [climacs-cvs] CVS update: climacs/gui.lisp 
Message-ID: <20050506165633.C887B88729@common-lisp.net>

Update of /project/climacs/cvsroot/climacs
In directory common-lisp.net:/tmp/cvs-serv25021

Modified Files:
	gui.lisp 
Log Message:
rearrange the toplevel loop a little

Date: Fri May  6 18:56:33 2005
Author: crhodes

Index: climacs/gui.lisp
diff -u climacs/gui.lisp:1.132 climacs/gui.lisp:1.133
--- climacs/gui.lisp:1.132	Fri May  6 01:00:23 2005
+++ climacs/gui.lisp	Fri May  6 18:56:32 2005
@@ -282,39 +282,46 @@
 	       (when (null (remaining-keys *application-frame*))
 		 (setf (executingp *application-frame*) nil)
 		 (redisplay-frame-panes frame))))
-	(loop
+	(flet ((process-gestures ()
+		 (loop
+		  for gestures = '()
+		  do (multiple-value-bind (numarg numargp)
+			 (read-numeric-argument :stream *standard-input*)
+		       (loop 
+			(setf *current-gesture* (climacs-read-gesture))
+			(setf gestures 
+			      (nconc gestures (list *current-gesture*)))
+			(let ((item (find-gestures gestures 'global-climacs-table)))
+			  (cond 
+			    ((not item)
+			     (beep) (return))
+			    ((eq (command-menu-item-type item) :command)
+			     (let ((command (command-menu-item-value item)))
+			       (unless (consp command)
+				 (setf command (list command)))
+			       (setf command (substitute-numeric-argument-marker command numarg))
+			       (setf command (substitute-numeric-argument-p command numargp))
+			       (do-command command)
+			       (return)))
+			    (t nil)))))
+		  do (update-climacs))))
+	  (loop
 	   for maybe-error = t
-	   do (with-simple-restart (return-to-climacs "Return to Climacs")
-		(handler-case
-		    (with-input-context ('(command
-					   :command-table 'global-climacs-table))
-		      (object)
-		      (loop
-		       for gestures = '()
-		       do (multiple-value-bind (numarg numargp)
-			      (read-numeric-argument :stream *standard-input*)
-			    (loop (setf *current-gesture* (climacs-read-gesture))
-				  (setf gestures (nconc gestures (list *current-gesture*)))
-				  (let ((item (find-gestures gestures 'global-climacs-table)))
-				    (cond ((not item)
-					   (beep) (return))
-					  ((eq (command-menu-item-type item) :command)
-					   (let ((command (command-menu-item-value item)))
-					     (unless (consp command)
-					       (setf command (list command)))
-					     (setf command (substitute-numeric-argument-marker command numarg))
-					     (setf command (substitute-numeric-argument-p command numargp))
-					     (do-command command)
-					     (return)))
-					  (t nil)))))
-		       (update-climacs))
-		      (t
-		       (do-command object)
-		       (setq maybe-error nil)))
-		  (abort-gesture () (display-message "Quit"))))
-	   (when maybe-error
-	     (beep))
-	   (update-climacs))))))
+	   do (restart-case
+		  (progn
+		    (handler-case
+			(with-input-context 
+			      ('(command :command-table 'global-climacs-table))
+			    (object)
+		            (process-gestures)
+			  (t
+			   (do-command object)
+			   (setq maybe-error nil)))
+		      (abort-gesture () (display-message "Quit")))
+		    (when maybe-error
+		      (beep))
+		    (update-climacs))
+		(return-to-climacs () nil))))))))
 
 (defmacro simple-command-loop (command-table loop-condition end-clauses)
   (let ((gesture (gensym))



From abakic at common-lisp.net  Fri May  6 22:32:31 2005
From: abakic at common-lisp.net (Aleksandar Bakic)
Date: Sat,  7 May 2005 00:32:31 +0200 (CEST)
Subject: [climacs-cvs] CVS update: climacs/gui.lisp climacs/packages.lisp
	climacs/pane.lisp 
Message-ID: <20050506223231.E15D6880A4@common-lisp.net>

Update of /project/climacs/cvsroot/climacs
In directory common-lisp.net:/tmp/cvs-serv21864

Modified Files:
	gui.lisp packages.lisp pane.lisp 
Log Message:
Contribution by John Q Splittist: Renamed occurrences of `filename'
(actually referring to pathnames) to `filepath'.

Date: Sat May  7 00:32:28 2005
Author: abakic

Index: climacs/gui.lisp
diff -u climacs/gui.lisp:1.133 climacs/gui.lisp:1.134
--- climacs/gui.lisp:1.133	Fri May  6 18:56:32 2005
+++ climacs/gui.lisp	Sat May  7 00:32:28 2005
@@ -693,14 +693,14 @@
     (declare (ignore success))
     (or pathname string)))
 
-(defun pathname-filename (pathname)
+(defun filepath-filename (pathname)
   (if (null (pathname-type pathname))
       (pathname-name pathname)
       (concatenate 'string (pathname-name pathname)
 		   "." (pathname-type pathname))))
 
 (define-named-command com-find-file ()
-  (let ((filename (accept 'completable-pathname
+  (let ((filepath (accept 'completable-pathname
 			  :prompt "Find File"))
 	(buffer (make-instance 'climacs-buffer))
 	(pane (current-window)))
@@ -709,11 +709,11 @@
     (setf (syntax buffer) (make-instance
 			   'basic-syntax :buffer (buffer (point pane))))
     ;; Don't want to create the file if it doesn't exist.
-    (when (probe-file filename) 
-      (with-open-file (stream filename :direction :input)
+    (when (probe-file filepath) 
+      (with-open-file (stream filepath :direction :input)
 	(input-from-stream stream buffer 0)))
-    (setf (filename buffer) filename
-	  (name buffer) (pathname-filename filename)
+    (setf (filepath buffer) filepath
+	  (name buffer) (filepath-filename filepath)
 	  (needs-saving buffer) nil)
     (beginning-of-buffer (point pane))
     ;; this one is needed so that the buffer modification protocol
@@ -721,19 +721,19 @@
     (redisplay-frame-panes *application-frame*)))
 
 (defun save-buffer (buffer)
-  (let ((filename (or (filename buffer)
+  (let ((filepath (or (filepath buffer)
 		      (accept 'completable-pathname
 			      :prompt "Save Buffer to File"))))
-    (with-open-file (stream filename :direction :output :if-exists :supersede)
+    (with-open-file (stream filepath :direction :output :if-exists :supersede)
       (output-to-stream stream buffer 0 (size buffer)))
-    (setf (filename buffer) filename
-	  (name buffer) (pathname-filename filename))
-    (display-message "Wrote: ~a" (filename buffer))
+    (setf (filepath buffer) filepath
+	  (name buffer) (filepath-filename filepath))
+    (display-message "Wrote: ~a" (filepath buffer))
     (setf (needs-saving buffer) nil)))
 
 (define-named-command com-save-buffer ()
   (let ((buffer (buffer (current-window))))
-    (if (or (null (filename buffer))
+    (if (or (null (filepath buffer))
 	    (needs-saving buffer))
 	(save-buffer buffer)
 	(display-message "No changes need to be saved from ~a" (name buffer)))))
@@ -756,15 +756,15 @@
     (frame-exit *application-frame*)))
 
 (define-named-command com-write-buffer ()
-  (let ((filename (accept 'completable-pathname
+  (let ((filepath (accept 'completable-pathname
 			  :prompt "Write Buffer to File"))
 	(buffer (buffer (current-window))))
-    (with-open-file (stream filename :direction :output :if-exists :supersede)
+    (with-open-file (stream filepath :direction :output :if-exists :supersede)
       (output-to-stream stream buffer 0 (size buffer)))
-    (setf (filename buffer) filename
-	  (name buffer) (pathname-filename filename)
+    (setf (filepath buffer) filepath
+	  (name buffer) (filepath-filename filepath)
 	  (needs-saving buffer) nil)
-    (display-message "Wrote: ~a" (filename buffer))))
+    (display-message "Wrote: ~a" (filepath buffer))))
 
 (define-presentation-method accept
     ((type buffer) stream (view textual-view) &key)
@@ -809,9 +809,9 @@
   (full-redisplay (current-window)))
 
 (define-named-command com-load-file ()
-  (let ((filename (accept 'completable-pathname
+  (let ((filepath (accept 'completable-pathname
 			  :prompt "Load File")))
-    (load filename)))
+    (load filepath)))
 
 (define-named-command com-beginning-of-buffer ()
   (beginning-of-buffer (point (current-window))))


Index: climacs/packages.lisp
diff -u climacs/packages.lisp:1.61 climacs/packages.lisp:1.62
--- climacs/packages.lisp:1.61	Fri Apr 22 10:19:11 2005
+++ climacs/packages.lisp	Sat May  7 00:32:28 2005
@@ -123,7 +123,7 @@
 (defpackage :climacs-pane
   (:use :clim-lisp :clim :climacs-buffer :climacs-base :climacs-abbrev
 	:climacs-syntax :flexichain :undo)
-  (:export #:climacs-buffer #:needs-saving #:filename
+  (:export #:climacs-buffer #:needs-saving #:filepath
 	   #:climacs-pane #:point #:mark
 	   #:redisplay-pane #:full-redisplay
 	   #:page-down #:page-up


Index: climacs/pane.lisp
diff -u climacs/pane.lisp:1.24 climacs/pane.lisp:1.25
--- climacs/pane.lisp:1.24	Wed Apr  6 07:31:53 2005
+++ climacs/pane.lisp	Sat May  7 00:32:28 2005
@@ -182,8 +182,8 @@
 (defclass climacs-textual-view (textual-view tabify-mixin)
   ())
 
-(defclass filename-mixin ()
-  ((filename :initform nil :accessor filename)))
+(defclass filepath-mixin ()
+  ((filepath :initform nil :accessor filepath)))
 
 ;(defgeneric indent-tabs-mode (climacs-buffer))
 
@@ -193,7 +193,7 @@
 (defclass extended-binseq2-buffer (binseq2-buffer p-undo-mixin abbrev-mixin) ()
   (:documentation "Extensions accessible via marks."))
 
-(defclass climacs-buffer (delegating-buffer filename-mixin name-mixin)
+(defclass climacs-buffer (delegating-buffer filepath-mixin name-mixin)
   ((needs-saving :initform nil :accessor needs-saving)
    (syntax :accessor syntax)
    (indent-tabs-mode :initarg indent-tabs-mode :initform t



From crhodes at common-lisp.net  Sat May  7 16:41:04 2005
From: crhodes at common-lisp.net (Christophe Rhodes)
Date: Sat,  7 May 2005 18:41:04 +0200 (CEST)
Subject: [climacs-cvs] CVS update: climacs/prolog-syntax.lisp 
Message-ID: <20050507164104.2D73B88704@common-lisp.net>

Update of /project/climacs/cvsroot/climacs
In directory common-lisp.net:/tmp/cvs-serv14244

Modified Files:
	prolog-syntax.lisp 
Log Message:
Improve the Prolog tokenizer.  We now recognize
  * binary constants: 0b...
  * octal constants:  0o...
  * hexadecimal constants: 0x...
  * char-code constants: 0'<quoted-char>
  * escaped characters in quoted strings:
    ** meta escapes such as \"
    ** control escapes such as \a
    ** numeric escapes such as \0177\ and \xabcd\
    ** "" (within a char-code-string) and '' (within a quoted-atom)

Date: Sat May  7 18:41:03 2005
Author: crhodes

Index: climacs/prolog-syntax.lisp
diff -u climacs/prolog-syntax.lisp:1.17 climacs/prolog-syntax.lisp:1.18
--- climacs/prolog-syntax.lisp:1.17	Sun Apr 17 17:44:39 2005
+++ climacs/prolog-syntax.lisp	Sat May  7 18:41:03 2005
@@ -111,7 +111,8 @@
   
   (def (name t) identifier graphic quoted semicolon cut)
   (def (variable t) anonymous named)
-  (def (integer t))
+  (def (integer t) integer-constant character-code-constant binary-constant
+                   octal-constant hexadecimal-constant)
   (def (float-number t))
   (def (char-code-list t))
   (def (open-ct))
@@ -157,6 +158,58 @@
 	   (bo ()
 	     (vector-pop string)
 	     (backward-object scan)))
+      (macrolet ((read-quoted-char (char)
+		   `(block read-quoted-char
+		     (let ((o (object-after scan)))
+		       (tagbody
+			START
+			  (cond 
+			    ((eql o #\\) (fo) (go ESCAPE))
+			    ((eql o ,char) (fo) (go QUOTE))
+			    (t (fo) (return-from read-quoted-char t)))
+			QUOTE
+			  (if (end-of-buffer-p scan)
+			      (return-from read-quoted-char nil)
+			      (let ((o (object-after scan)))
+				(cond
+				  ((eql o ,char) (fo) (return-from read-quoted-char t))
+				  (t (return-from read-quoted-char nil)))))
+			ESCAPE
+			  (if (end-of-buffer-p scan)
+			      (return (make-instance 'error-lexeme))
+			      (let ((o (object-after scan)))
+				(cond
+				  ;; meta (6.5.5)
+				  ((position o "\\'\"`") (fo) (return-from read-quoted-char t))
+				  ;; symbolic (6.4.2.1)
+				  ((position o "abfnrtv") (fo) (return-from read-quoted-char t))
+				  ;; octal
+				  ((digit-char-p o 8) (fo)
+				   (tagbody
+				    LOOP
+				      (when (end-of-buffer-p scan)
+					(return (make-instance 'error-lexeme)))
+				      (let ((o (object-after scan)))
+					(cond
+					  ((eql o #\\) (fo) (return-from read-quoted-char t))
+					  ((digit-char-p o 8) (fo) (go LOOP))
+					  (t (return (make-instance 'error-lexeme)))))))
+				  ((eql o #\x) (fo)
+				   (if (or (end-of-buffer-p scan)
+					   (not (digit-char-p (object-after scan) 16)))
+				       (return (make-instance 'error-lexeme))
+				       (progn 
+					 (fo)
+					 (tagbody
+					  LOOP
+					    (when (end-of-buffer-p scan)
+					      (return (make-instance 'error-lexeme)))
+					    (let ((o (object-after scan)))
+					      (cond
+						((eql o #\\) (fo) (return-from read-quoted-char t))
+						((digit-char-p o 16) (fo) (go LOOP))
+						(t (return (make-instance 'error-lexeme)))))))))
+				  (t (return (make-instance 'error-lexeme)))))))))))
       (let ((object (object-after scan)))
 	(block nil
 	  (tagbody
@@ -173,6 +226,7 @@
 		(fo) (return (make-instance 'cut-lexeme)))
 	       ((eql object #\_) (fo) (go VARIABLE))
 	       ((upper-case-p object) (fo) (go NAMED-VARIABLE))
+	       ((eql object #\0) (fo) (go NUMBER-OR-INTEGER))
 	       ((digit-char-p object) (fo) (go NUMBER))
 	       ((eql object #\") (fo) (go CHAR-CODE-LIST))
 	       ((eql object #\()
@@ -243,14 +297,10 @@
 		   (return (make-instance 'end-lexeme)))
 		  (t (return (make-instance 'graphic-lexeme))))))
 	   QUOTED-TOKEN
-	     (loop until (end-of-buffer-p scan)
-		;; FIXME
-		until (eql (object-after scan) #\')
-		do (fo))
-	     (if (end-of-buffer-p scan)
-		 (return (make-instance 'error-lexeme))
-                 (progn (fo)
-                        (return (make-instance 'quoted-lexeme))))
+	     (loop named #:mu
+		   until (end-of-buffer-p scan)
+		   while (read-quoted-char #\'))
+	     (return (make-instance 'quoted-lexeme))
 	   VARIABLE
 	     (if (or (end-of-buffer-p scan)
                      (let ((object (object-after scan)))
@@ -265,20 +315,47 @@
                             (eql object #\_)))
 		do (fo))
 	     (return (make-instance 'named-lexeme))
+	   NUMBER-OR-INTEGER
+	     (if (end-of-buffer-p scan)
+		 (return (make-instance 'integer-lexeme))
+		 (let ((object (object-after scan)))
+		   (cond
+		     ((eql object #\') (fo) (go CHARACTER-CODE-CONSTANT))
+		     ((eql object #\b) (fo) (go BINARY-CONSTANT))
+		     ((eql object #\o) (fo) (go OCTAL-CONSTANT))
+		     ((eql object #\x) (fo) (go HEXADECIMAL-CONSTANT))
+		     ((digit-char-p object) (fo) (go NUMBER))
+		     ;; FIXME: floats
+		     (t (return (make-instance 'integer-lexeme))))))
+	   CHARACTER-CODE-CONSTANT
+	     (if (read-quoted-char #\')
+		 (return (make-instance 'character-code-constant-lexeme))
+		 (return (make-instance 'error-lexeme)))
+	   BINARY-CONSTANT
+	     (loop until (end-of-buffer-p scan)
+		   while (digit-char-p (object-after scan) 2)
+		   do (fo))
+	     (return (make-instance 'binary-constant-lexeme))
+	   OCTAL-CONSTANT
+	     (loop until (end-of-buffer-p scan)
+		   while (digit-char-p (object-after scan) 8)
+		   do (fo))
+	     (return (make-instance 'octal-constant-lexeme))
+	   HEXADECIMAL-CONSTANT
+	     (loop until (end-of-buffer-p scan)
+		   while (digit-char-p (object-after scan) 16)
+		   do (fo))
+	     (return (make-instance 'hexadecimal-constant-lexeme))
 	   NUMBER
 	     (loop until (end-of-buffer-p scan)
-		while (digit-char-p (object-after scan))
-		do (fo))
-	     (return (make-instance 'integer-lexeme))
+		   while (digit-char-p (object-after scan))
+		   do (fo))
+	     (return (make-instance 'integer-constant-lexeme))
 	   CHAR-CODE-LIST
-	     (loop until (end-of-buffer-p scan)
-		;; FIXME
-		until (eql (object-after scan) #\")
-		do (fo))
-	     (if (end-of-buffer-p scan)
-		 (return (make-instance 'error-lexeme))
-		 (progn (fo)
-			(return (make-instance 'char-code-list-lexeme))))))))))
+	     (loop named #:mu
+		   until (end-of-buffer-p scan)
+		   while (read-quoted-char #\"))
+	     (return (make-instance 'char-code-list-lexeme)))))))))
 
 ;;; parser
 



From abakic at common-lisp.net  Sun May  8 20:16:34 2005
From: abakic at common-lisp.net (Aleksandar Bakic)
Date: Sun,  8 May 2005 22:16:34 +0200 (CEST)
Subject: [climacs-cvs] CVS update: climacs/gui.lisp 
Message-ID: <20050508201634.48C53880A4@common-lisp.net>

Update of /project/climacs/cvsroot/climacs
In directory common-lisp.net:/tmp/cvs-serv21151

Modified Files:
	gui.lisp 
Log Message:
Contribution by John Q Splittist: Feedback and default replacements
for Query Replace.

Date: Sun May  8 22:16:33 2005
Author: abakic

Index: climacs/gui.lisp
diff -u climacs/gui.lisp:1.134 climacs/gui.lisp:1.135
--- climacs/gui.lisp:1.134	Sat May  7 00:32:28 2005
+++ climacs/gui.lisp	Sun May  8 22:16:32 2005
@@ -1185,54 +1185,79 @@
       (/= (offset mark) offset-before))))
 
 (define-named-command com-query-replace ()
-  (let* ((string1 (handler-case (accept 'string :prompt "Query replace")
+  (let* ((pane (current-window))
+	 (old-state (query-replace-state pane))
+	 (old-string1 (when old-state (string1 old-state)))
+	 (old-string2 (when old-state (string2 old-state)))
+	 (string1 (handler-case 
+		      (if old-string1
+			  (accept 'string 
+				  :prompt "Query Replace"
+				  :default old-string1
+				  :default-type 'string)
+			  (accept 'string :prompt "Query Replace"))
 		    (error () (progn (beep)
 				     (display-message "Empty string")
 				     (return-from com-query-replace nil)))))
-         (string2 (handler-case (accept 'string
-					:prompt (format nil "Query replace ~A with"
-							string1))
+         (string2 (handler-case 
+		      (if old-string2
+			  (accept 'string
+				  :prompt (format nil "Query Replace ~A with"
+						  string1)
+				  :default old-string2
+				  :default-type 'string)
+			  (accept 'string
+				  :prompt (format nil "Query Replace ~A with" string1)))
 		    (error () (progn (beep)
 				     (display-message "Empty string")
 				     (return-from com-query-replace nil)))))
-         (pane (current-window))
-         (point (point pane)))
+         (point (point pane))
+	 (occurrences 0))
+    (declare (special string1 string2 occurrences))
     (when (query-replace-find-next-match point string1)
       (setf (query-replace-state pane) (make-instance 'query-replace-state
                                                       :string1 string1
                                                       :string2 string2)
             (query-replace-mode pane) t)
+      (display-message "Query Replace ~A with ~A:"
+		       string1 string2)
       (simple-command-loop 'query-replace-climacs-table
-                           (query-replace-mode pane)
-                           ((setf (query-replace-mode pane) nil))))))
+			   (query-replace-mode pane)
+			   ((setf (query-replace-mode pane) nil))))
+    (display-message "Replaced ~A occurrence~:P" occurrences)))
 
 (define-named-command com-query-replace-replace ()
+  (declare (special string1 string2 occurrences))
   (let* ((pane (current-window))
          (point (point pane))
          (buffer (buffer pane))
-         (state (query-replace-state pane))
-         (string1-length (length (string1 state))))
+         (string1-length (length string1)))
     (backward-object point string1-length)
     (let* ((offset1 (offset point))
            (offset2 (+ offset1 string1-length))
            (region-case (buffer-region-case buffer offset1 offset2)))
       (delete-range point string1-length)
-      (insert-sequence point (string2 state))
-      (setf offset2 (+ offset1 (length (string2 state))))
+      (insert-sequence point string2)
+      (setf offset2 (+ offset1 (length string2)))
       (finish-output *error-output*)
       (case region-case
         (:upper-case (upcase-buffer-region buffer offset1 offset2))
         (:lower-case (downcase-buffer-region buffer offset1 offset2))
         (:capitalized (capitalize-buffer-region buffer offset1 offset2))))
-    (unless (query-replace-find-next-match point (string1 state))
-      (setf (query-replace-mode pane) nil))))
+    (incf occurrences)
+    (if (query-replace-find-next-match point string1)
+	(display-message "Query Replace ~A with ~A:"
+		       string1 string2)
+	(setf (query-replace-mode pane) nil))))
 
 (define-named-command com-query-replace-skip ()
+  (declare (special string1 string2))
   (let* ((pane (current-window))
-         (point (point pane))
-         (state (query-replace-state pane)))
-    (unless (query-replace-find-next-match point (string1 state))
-      (setf (query-replace-mode pane) nil))))
+         (point (point pane)))
+    (if (query-replace-find-next-match point string1)
+	(display-message "Query Replace ~A with ~A:"
+			 string1 string2)
+	(setf (query-replace-mode pane) nil))))
 
 (define-named-command com-query-replace-exit ()
   (setf (query-replace-mode (current-window)) nil))



From rstrandh at common-lisp.net  Mon May  9 13:12:50 2005
From: rstrandh at common-lisp.net (Robert Strandh)
Date: Mon,  9 May 2005 15:12:50 +0200 (CEST)
Subject: [climacs-cvs] CVS update: climacs/syntax.lisp
	climacs/html-syntax.lisp 
Message-ID: <20050509131250.12B5988704@common-lisp.net>

Update of /project/climacs/cvsroot/climacs
In directory common-lisp.net:/tmp/cvs-serv8821

Modified Files:
	syntax.lisp html-syntax.lisp 
Log Message:
Prediction is now done at the beginning of advance-parse, which
means the next token is available to the predictor.

Added a :predict-test to the add-rule macro making it possible to
control when prediction is reasonable.

Added :predict-test to a few rules of HTML syntax to speed up the parser. 


Date: Mon May  9 15:12:47 2005
Author: rstrandh

Index: climacs/syntax.lisp
diff -u climacs/syntax.lisp:1.48 climacs/syntax.lisp:1.49
--- climacs/syntax.lisp:1.48	Mon May  2 11:05:00 2005
+++ climacs/syntax.lisp	Mon May  9 15:12:47 2005
@@ -205,6 +205,7 @@
   ((left-hand-side :initarg :left-hand-side :reader left-hand-side)
    (right-hand-side :initarg :right-hand-side :reader right-hand-side)
    (symbols :initarg :symbols :reader symbols)
+   (predict-test :initarg :predict-test :reader predict-test)
    (number)))
 
 (defclass grammar ()
@@ -212,7 +213,7 @@
    (hash :initform (make-hash-table) :accessor hash)
    (number-of-rules :initform 0)))
 
-(defmacro grammar-rule ((left-hand-side arrow arglist &body body))
+(defmacro grammar-rule ((left-hand-side arrow arglist &body body) &key predict-test)
   (declare (ignore arrow))
   (labels ((var-of (arg)
 	     (if (symbolp arg)
@@ -244,7 +245,8 @@
 			     (symbolp (car body)))
 			 `(make-instance ',left-hand-side , at body)
 			 `(progn , at body)))
-	:symbols ,(coerce (mapcar #'sym-of arglist) 'vector))))
+	:symbols ,(coerce (mapcar #'sym-of arglist) 'vector)
+	:predict-test ,predict-test)))
 
 
 (defmacro grammar (&body body)
@@ -308,14 +310,15 @@
     (cond ((null remaining)
 	   nil)
 	  ((functionp remaining)
-	   (handle-incomplete-item (make-instance 'incomplete-item
-				      :orig-state (orig-state prev-item)
-				      :predicted-from (predicted-from prev-item)
-				      :rule (rule prev-item)
-				      :dot-position (1+ (dot-position prev-item))
-				      :parse-trees (cons parse-tree (parse-trees prev-item))
-				      :suffix remaining)
-				   orig-state to-state))
+	   (handle-incomplete-item
+	    (make-instance 'incomplete-item
+	       :orig-state (orig-state prev-item)
+	       :predicted-from (predicted-from prev-item)
+	       :rule (rule prev-item)
+	       :dot-position (1+ (dot-position prev-item))
+	       :parse-trees (cons parse-tree (parse-trees prev-item))
+	       :suffix remaining)
+	    orig-state to-state))
 	  (t
 	   (let* ((parse-trees (cons parse-tree (parse-trees prev-item)))
 		  (start (find-if-not #'null parse-trees
@@ -389,30 +392,45 @@
 	    (t (push parse-tree (gethash from-state parse-trees))
 	       (handle-parse-tree))))))
 
+(defun predict (item state tokens)
+  (dolist (rule (gethash (aref (symbols (rule item)) (dot-position item))
+			 (hash (parser-grammar (parser state)))))
+    (if (functionp (right-hand-side rule))
+	(let ((predicted-rules (slot-value state 'predicted-rules))
+	      (rule-number (slot-value rule 'number))
+	      (predict-test (predict-test rule)))
+	  (when (zerop (sbit predicted-rules rule-number))
+	    (setf (sbit predicted-rules rule-number) 1)
+	    (when (or (null predict-test)
+		      (some predict-test tokens))
+	      (handle-and-predict-incomplete-item
+	       (make-instance 'incomplete-item
+		  :orig-state state
+		  :predicted-from item
+		  :rule rule
+		  :dot-position 0
+		  :suffix (right-hand-side rule))
+	       state tokens))))
+	(potentially-handle-parse-tree (right-hand-side rule) state state)))
+  (loop for parse-tree in (gethash state (parse-trees state))
+	do (derive-and-handle-item item parse-tree state state)))
+
 (defun handle-incomplete-item (item orig-state to-state)
   (declare (optimize speed))
   (cond ((find item (the list (gethash orig-state (incomplete-items to-state)))
  	       :test #'item-equal)
 	  nil)
  	(t
- 	 (push item (gethash orig-state (incomplete-items to-state)))
-	 (dolist (rule (gethash (aref (symbols (rule item)) (dot-position item))
-				(hash (parser-grammar (parser to-state)))))
-	   (if (functionp (right-hand-side rule))
-	       (let ((predicted-rules (slot-value to-state 'predicted-rules))
-		     (rule-number (slot-value rule 'number)))
-		 (when (zerop (sbit predicted-rules rule-number))
-		   (setf (sbit predicted-rules rule-number) 1)
-		   (handle-incomplete-item (make-instance 'incomplete-item
-					      :orig-state to-state
-					      :predicted-from item
-					      :rule rule
-					      :dot-position 0
-					      :suffix (right-hand-side rule))
-					   to-state to-state)))
-	       (potentially-handle-parse-tree (right-hand-side rule) to-state to-state)))
-	 (loop for parse-tree in (gethash to-state (parse-trees to-state))
- 	       do (derive-and-handle-item item parse-tree to-state to-state)))))
+ 	 (push item (gethash orig-state (incomplete-items to-state))))))
+
+(defun handle-and-predict-incomplete-item (item state tokens)
+  (declare (optimize speed))
+  (cond ((find item (the list (gethash state (incomplete-items state)))
+ 	       :test #'item-equal)
+	  nil)
+ 	(t
+ 	 (push item (gethash state (incomplete-items state)))
+	 (predict item state tokens))))
 
 (defmethod initialize-instance :after ((parser parser) &rest args)
   (declare (ignore args))
@@ -424,13 +442,14 @@
 		      (or (subtypep (target parser) sym)
 			  (subtypep sym (target parser))))
 		(if (functionp (right-hand-side rule))
-		    (handle-incomplete-item (make-instance 'incomplete-item
-					       :orig-state initial-state
-					       :predicted-from nil
-					       :rule rule
-					       :dot-position 0
-					       :suffix (right-hand-side rule))
-					    initial-state initial-state)
+		    (handle-incomplete-item
+		     (make-instance 'incomplete-item
+			:orig-state initial-state
+			:predicted-from nil
+			:rule rule
+			:dot-position 0
+			:suffix (right-hand-side rule))
+		     initial-state initial-state)
 		    (potentially-handle-parse-tree
 		     (right-hand-side rule) initial-state initial-state))))))
 
@@ -442,6 +461,11 @@
 	  do (return parse-tree)))
 
 (defun advance-parse (parser tokens state)
+  (maphash (lambda (from-state items)
+	     (declare (ignore from-state))
+	     (dolist (item items)
+	       (predict item state tokens)))
+	   (incomplete-items state))
   (let ((new-state (make-instance 'parser-state :parser parser)))
     (loop for token in tokens 
 	  do (potentially-handle-parse-tree token state new-state))


Index: climacs/html-syntax.lisp
diff -u climacs/html-syntax.lisp:1.29 climacs/html-syntax.lisp:1.30
--- climacs/html-syntax.lisp:1.29	Mon Apr 11 08:27:13 2005
+++ climacs/html-syntax.lisp	Mon May  9 15:12:47 2005
@@ -22,6 +22,11 @@
 
 (in-package :climacs-html-syntax)
 
+(define-syntax html-syntax ("HTML" (basic-syntax))
+  ((lexer :reader lexer)
+   (valid-parse :initform 1)
+   (parser)))
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;;
 ;;; grammar classes
@@ -40,6 +45,31 @@
 
 (defclass html-tag (html-token) ())
 
+(defclass html-start-tag (html-tag)
+  ((start :initarg :start)
+   (name :initarg :name)
+   (attributes :initform nil :initarg :attributes)
+   (end :initarg :end)))
+
+(defmethod display-parse-tree ((entity html-start-tag) (syntax html-syntax) pane)
+  (with-slots (start name attributes end) entity
+    (display-parse-tree start syntax pane)
+    (display-parse-tree name syntax pane)
+    (unless (null attributes)
+      (display-parse-tree attributes syntax pane))
+    (display-parse-tree end syntax pane)))
+
+(defclass html-end-tag (html-tag)
+  ((start :initarg :start)
+   (name :initarg :name)
+   (end :initarg :end)))
+
+(defmethod display-parse-tree ((entity html-end-tag) (syntax html-syntax) pane)
+  (with-slots (start name attributes end) entity
+    (display-parse-tree start syntax pane)
+    (display-parse-tree name syntax pane)
+    (display-parse-tree end syntax pane)))
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;;
 ;;; lexer
@@ -74,19 +104,15 @@
 		 (t
 		  (fo) (make-instance 'delimiter))))))))
 
-(define-syntax html-syntax ("HTML" (basic-syntax))
-  ((lexer :reader lexer)
-   (valid-parse :initform 1)
-   (parser)))
-
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;;
 ;;; parser
 
 (defparameter *html-grammar* (grammar))
 
-(defmacro add-html-rule (rule)
-  `(add-rule (grammar-rule ,rule) *html-grammar*))
+(defmacro add-html-rule (rule &key predict-test)
+  `(add-rule (grammar-rule ,rule :predict-test ,predict-test)
+	     *html-grammar*))
 
 (defun word-is (word string)
   (string-equal (coerce (buffer-sequence (buffer word) (start-offset word) (end-offset word)) 'string)
@@ -94,23 +120,27 @@
 
 (defmacro define-start-tag (name string)
   `(progn
-     (defclass ,name (html-tag) ())
+     (defclass ,name (html-start-tag) ())
 
      (add-html-rule
       (,name -> (start-tag-start
 		 (word (and (= (end-offset start-tag-start) (start-offset word))
 			    (word-is word ,string)))
-		 (tag-end (= (end-offset word) (start-offset tag-end))))))))
+		 (tag-end (= (end-offset word) (start-offset tag-end))))
+	     :start start-tag-start :name word :end tag-end))))
 
 (defmacro define-end-tag (name string)
   `(progn
-     (defclass ,name (html-tag) ())
+     (defclass ,name (html-end-tag) ())
 
      (add-html-rule
       (,name -> (end-tag-start
 		 (word (and (= (end-offset end-tag-start) (start-offset word))
 			    (word-is word ,string)))
-		 (tag-end (= (end-offset word) (start-offset tag-end))))))))
+		 (tag-end (= (end-offset word) (start-offset tag-end))))
+	     :start end-tag-start :name word :end tag-end)
+      :predict-test (lambda (token)
+		      (typep token 'end-tag-start)))))
 
 (defmacro define-tag-pair (start-name end-name string)
   `(progn (define-start-tag ,start-name ,string)
@@ -310,7 +340,9 @@
 (defclass $inline (html-nonterminal)
   ((contents :initarg :contents)))
      
-(add-html-rule ($inline -> (inline-element) :contents inline-element))
+(add-html-rule ($inline -> (inline-element) :contents inline-element)
+	       :predict-test (lambda (token)
+			       (typep token 'start-tag-start)))
 (add-html-rule ($inline -> (word) :contents word))
 (add-html-rule ($inline -> (delimiter) :contents delimiter))
 
@@ -326,7 +358,9 @@
   ((contents :initarg :contents)))
      
 (add-html-rule ($flow -> ($inline) :contents $inline))
-(add-html-rule ($flow -> (block-level-element) :contents block-level-element))
+(add-html-rule ($flow -> (block-level-element) :contents block-level-element)
+	       :predict-test (lambda (token)
+			       (typep token 'start-tag-start)))
 
 (defmethod display-parse-tree ((entity $flow) (syntax html-syntax) pane)
   (with-slots (contents) entity
@@ -379,11 +413,7 @@
 
 (define-list <a>-attributes <a>-attribute)
 
-(defclass <a> (html-tag)
-  ((start :initarg :start)
-   (name :initarg :name)
-   (attributes :initarg :attributes)
-   (end :initarg :end)))
+(defclass <a> (html-start-tag) ())
 
 (add-html-rule (<a> -> (start-tag-start
 			(word (and (= (end-offset start-tag-start) (start-offset word))
@@ -392,13 +422,6 @@
 			tag-end)
 		    :start start-tag-start :name word :attributes <a>-attributes :end tag-end))
 
-(defmethod display-parse-tree ((entity <a>) (syntax html-syntax) pane)
-  (with-slots (start name attributes end) entity
-    (display-parse-tree start syntax pane)
-    (display-parse-tree name syntax pane)
-    (display-parse-tree attributes syntax pane)
-    (display-parse-tree end syntax pane)))
-
 (define-end-tag </a> "a")
 
 (defclass a-element (inline-element)
@@ -431,11 +454,7 @@
 
 ;;;;;;;;;;;;;;; p element
 
-(defclass <p> (html-tag)
-  ((start :initarg :start)
-   (name :initarg :name)
-   (attributes :initarg :attributes)
-   (end :initarg :end)))
+(defclass <p> (html-start-tag) ())
 
 (add-html-rule (<p> -> (start-tag-start
 			(word (and (= (end-offset start-tag-start) (start-offset word))
@@ -444,13 +463,6 @@
 			tag-end)
 		    :start start-tag-start :name word :attributes common-attributes :end tag-end))
 
-(defmethod display-parse-tree ((entity <p>) (syntax html-syntax) pane)
-  (with-slots (start name attributes end) entity
-    (display-parse-tree start syntax pane)
-    (display-parse-tree name syntax pane)
-    (display-parse-tree attributes syntax pane)
-    (display-parse-tree end syntax pane)))
-
 (define-end-tag </p> "p")
 
 (defclass p-element (block-level-element)
@@ -469,11 +481,7 @@
 
 ;;;;;;;;;;;;;;; li element
 
-(defclass <li> (html-tag)
-  ((start :initarg :start)
-   (name :initarg :name)
-   (attributes :initarg :attributes)
-   (end :initarg :end)))
+(defclass <li> (html-start-tag) ())
 
 (add-html-rule (<li> -> (start-tag-start
 			 (word (and (= (end-offset start-tag-start) (start-offset word))
@@ -485,13 +493,6 @@
 		     :attributes common-attributes
 		     :end tag-end))
 
-(defmethod display-parse-tree ((entity <li>) (syntax html-syntax) pane)
-  (with-slots (start name attributes end) entity
-    (display-parse-tree start syntax pane)
-    (display-parse-tree name syntax pane)
-    (display-parse-tree attributes syntax pane)
-    (display-parse-tree end syntax pane)))
-
 (define-end-tag </li> "li")
 
 (defclass li-element (html-nonterminal)
@@ -513,11 +514,7 @@
 
 ;;;;;;;;;;;;;;; ul element
 
-(defclass <ul> (html-tag)
-  ((start :initarg :start)
-   (name :initarg :name)
-   (attributes :initarg :attributes)
-   (end :initarg :end)))
+(defclass <ul> (html-start-tag) ())
 
 (add-html-rule (<ul> -> (start-tag-start
 			 (word (and (= (end-offset start-tag-start) (start-offset word))
@@ -529,13 +526,6 @@
 		     :attributes common-attributes
 		     :end tag-end))
 
-(defmethod display-parse-tree ((entity <ul>) (syntax html-syntax) pane)
-  (with-slots (start name attributes end) entity
-    (display-parse-tree start syntax pane)
-    (display-parse-tree name syntax pane)
-    (display-parse-tree attributes syntax pane)
-    (display-parse-tree end syntax pane)))
-
 (define-end-tag </ul> "ul")
 
 (define-nonempty-list li-elements li-element)
@@ -624,11 +614,7 @@
 
 (define-list <html>-attributes <html>-attribute)
 
-(defclass <html> (html-tag)
-  ((start :initarg :start)
-   (name :initarg :name)
-   (attributes :initarg :attributes)
-   (end :initarg :end)))
+(defclass <html> (html-start-tag) ())
 
 (add-html-rule (<html> -> (start-tag-start
 			   (word (and (= (end-offset start-tag-start) (start-offset word))
@@ -637,13 +623,6 @@
 			   tag-end)
 		       :start start-tag-start :name word :attributes <html>-attributes :end tag-end))
 
-(defmethod display-parse-tree ((entity <html>) (syntax html-syntax) pane)
-  (with-slots (start name attributes end) entity
-    (display-parse-tree start syntax pane)
-    (display-parse-tree name syntax pane)
-    (display-parse-tree attributes syntax pane)
-    (display-parse-tree end syntax pane)))
-
 (define-end-tag </html> "html")
 
 (defclass html (html-nonterminal)
@@ -736,13 +715,14 @@
      (when (and (end-offset entity) (mark> (end-offset entity) top))
        (call-next-method))))
 
-(defmethod display-parse-tree ((entity html-token) (syntax html-syntax) pane)
+(defmethod display-parse-tree ((entity html-lexeme) (syntax html-syntax) pane)
   (flet ((cache-test (t1 t2)
-	   (and (eq t1 t2)
-		(eq (slot-value t1 'ink)
-		    (medium-ink (sheet-medium pane)))
-		(eq (slot-value t1 'face)
-		    (text-style-face (medium-text-style (sheet-medium pane)))))))
+	   (let ((result (and (eq t1 t2)
+			      (eq (slot-value t1 'ink)
+				  (medium-ink (sheet-medium pane)))
+			      (eq (slot-value t1 'face)
+				  (text-style-face (medium-text-style (sheet-medium pane)))))))
+	     result)))
     (updating-output (pane :unique-id entity
 			   :id-test #'eq
 			   :cache-value entity
@@ -761,7 +741,7 @@
   (with-drawing-options (pane :ink +green4+)
     (call-next-method)))
 
-(defmethod display-parse-tree :before ((entity html-token) (syntax html-syntax) pane)
+(defmethod display-parse-tree :before ((entity html-lexeme) (syntax html-syntax) pane)
   (handle-whitespace pane (buffer pane) *white-space-start* (start-offset entity))
   (setf *white-space-start* (end-offset entity)))
 



From rstrandh at common-lisp.net  Mon May  9 14:09:31 2005
From: rstrandh at common-lisp.net (Robert Strandh)
Date: Mon,  9 May 2005 16:09:31 +0200 (CEST)
Subject: [climacs-cvs] CVS update: climacs/cl-syntax.lisp 
Message-ID: <20050509140931.2E3AC88704@common-lisp.net>

Update of /project/climacs/cvsroot/climacs
In directory common-lisp.net:/tmp/cvs-serv13872

Modified Files:
	cl-syntax.lisp 
Log Message:
Improvements to CL syntax in the form of a patch from Andreas Fuchs.


Date: Mon May  9 16:09:30 2005
Author: rstrandh

Index: climacs/cl-syntax.lisp
diff -u climacs/cl-syntax.lisp:1.12 climacs/cl-syntax.lisp:1.13
--- climacs/cl-syntax.lisp:1.12	Fri Apr 29 22:10:32 2005
+++ climacs/cl-syntax.lisp	Mon May  9 16:09:30 2005
@@ -53,6 +53,8 @@
 (defclass paren-close (cl-lexeme) ())
 (defclass comma (cl-lexeme) ())
 (defclass quote-symbol (cl-lexeme) ())
+(defclass colon (cl-lexeme) ())
+(defclass ampersand (cl-lexeme) ())
 (defclass double-quote (cl-lexeme) ())
 (defclass hex (cl-lexeme) ())
 (defclass pipe (cl-lexeme) ())
@@ -78,6 +80,8 @@
 	(#\, (fo) (make-instance 'comma))
 	(#\" (fo) (make-instance 'double-quote)) 
 	(#\' (fo) (make-instance 'quote-symbol))
+	(#\: (fo) (make-instance 'colon))
+        (#\& (fo) (make-instance 'ampersand))
 	(#\# (fo) (make-instance 'hex))
 	(#\| (fo) (make-instance 'pipe))
 	(#\` (fo) (make-instance 'backquote))
@@ -115,7 +119,7 @@
 (defun neutralcharp (var)
   (and (characterp var)
        (not (member var '(#\( #\) #\, #\" #\' #\# #\| #\` #\@ #\; #\\
-			  #\/ #\. #\+ #\- #\Newline #\Space #\Tab)
+			  #\: #\/ #\Newline #\Space #\Tab)
 		    :test #'char=))))
 
 
@@ -783,6 +787,98 @@
       (display-parse-tree start syntax pane))
     (display-parse-tree item syntax pane))) 
 
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;Qualified symbols
+
+;; XXX: There's a bit of duplication going on here. I'm not sure if
+;; that could be reduced by clever inheritance. But then, it's only
+;; OAOOM.
+
+(defclass qualified-symbol (cl-entry)
+     ((package-name :initarg :package-name)
+      (colon1 :initarg :colon1)
+      (colon2 :initarg :colon2)
+      (symbol-name :initarg :symbol-name)))
+
+(defclass qualified-exported-symbol (cl-entry)
+     ((package-name :initarg :package-name)
+      (colon :initarg :colon)
+      (symbol-name :initarg :symbol-name)))
+
+(add-cl-rule (qualified-symbol -> ((package-name default-item)
+                                   (colon1 colon (= (end-offset package-name)
+                                                    (start-offset colon1)))
+                                   (colon2 colon (= (end-offset colon1)
+                                                    (start-offset colon2)))
+                                   (symbol-name default-item (= (end-offset colon2)
+                                                                (start-offset symbol-name))))
+                             :package-name package-name
+                             :colon1 colon1
+                             :colon2 colon2
+                             :symbol-name symbol-name))
+
+(add-cl-rule (qualified-exported-symbol -> ((package-name default-item)
+                                            (colon colon (= (end-offset package-name)
+                                                            (start-offset colon)))
+                                            (symbol-name default-item (= (end-offset colon)
+                                                                         (start-offset symbol-name))))
+                                        :package-name package-name
+                                        :colon colon
+                                        :symbol-name symbol-name))
+
+(defmethod display-parse-tree ((entity qualified-symbol) (syntax cl-syntax) pane)
+  (with-slots (package-name colon1 colon2 symbol-name) entity
+       (with-drawing-options (pane :text-style (make-text-style :fix :bold nil) :ink +purple+)
+         (display-parse-tree package-name syntax pane)     
+         (display-parse-tree colon1 syntax pane)
+         (display-parse-tree colon2 syntax pane))
+       (display-parse-tree symbol-name syntax pane)))
+
+(defmethod display-parse-tree ((entity qualified-exported-symbol) (syntax cl-syntax) pane)
+  (with-slots (package-name colon symbol-name) entity
+     (display-parse-tree package-name syntax pane)
+       (with-drawing-options (pane :ink (make-rgb-color 0.0 0.0 1.0))
+         (display-parse-tree colon syntax pane))
+       (display-parse-tree symbol-name syntax pane)))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;Keyword symbols
+
+(defclass keyword-symbol (cl-entry)
+     ((start :initarg :start)
+      (item :initarg :item)))
+
+(add-cl-rule (keyword-symbol -> ((start colon)
+                                 (item identifier))
+                             :start start :item item))
+
+(defmethod display-parse-tree ((entity keyword-symbol) (syntax cl-syntax) pane)
+  (with-slots (start item) entity
+     (with-text-face (pane :bold)
+       (display-parse-tree start syntax pane)
+       (display-parse-tree item syntax pane))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;Lambda list Keywords
+
+(defclass lambda-list-keyword (cl-entry)
+     ((start :initarg :start)
+      (item :initarg :item)))
+
+(add-cl-rule (lambda-list-keyword -> ((start ampersand)
+                                      (item default-item (and
+                                                          (= (end-offset start)
+                                                             (start-offset item))
+                                                          (member item
+                                                                  '( ;; ordinary LLs
+                                                                    "optional" "rest" "key" "aux" "allow-other-keys"
+                                                                    ;; macro LLs
+                                                                    "body" "whole" "environment")
+                                                                  :test #'default-item-is))))
+                                  :start start :item item))
+
+(defmethod display-parse-tree ((entity lambda-list-keyword) (syntax cl-syntax) pane)
+  (with-slots (start item) entity
+     (with-drawing-options (pane :ink +blue+)
+       (display-parse-tree start syntax pane)
+       (display-parse-tree item syntax pane))))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;Backquoted expr
 
@@ -850,6 +946,10 @@
 (add-cl-rule (cl-terminal -> (balanced-comment) :item balanced-comment))
 (add-cl-rule (cl-terminal -> (cl-string) :item cl-string))
 (add-cl-rule (cl-terminal -> (quoted-expr) :item quoted-expr))
+(add-cl-rule (cl-terminal -> (keyword-symbol) :item keyword-symbol))
+(add-cl-rule (cl-terminal -> (lambda-list-keyword) :item lambda-list-keyword))
+(add-cl-rule (cl-terminal -> (qualified-symbol) :item qualified-symbol))
+(add-cl-rule (cl-terminal -> (qualified-exported-symbol) :item qualified-exported-symbol))
 (add-cl-rule (cl-terminal -> (backquoted-expr) :item backquoted-expr))
 (add-cl-rule (cl-terminal -> (char-item) :item char-item))
 (add-cl-rule (cl-terminal -> (unquoted-expr) :item unquoted-expr))
@@ -925,19 +1025,21 @@
 (defun handle-whitespace (pane buffer start end)
   (let ((space-width (space-width pane))
 	(tab-width (tab-width pane)))
-    (loop while (< start end)
-       do (ecase (buffer-object buffer start)
-	    (#\Newline (terpri pane)
-		       (setf (aref *cursor-positions* (incf *current-line*))
-			     (multiple-value-bind (x y) (stream-cursor-position pane)
-			       (declare (ignore x))
-			       y)))
-	    (#\Space (stream-increment-cursor-position
-		      pane space-width 0))
-	    (#\Tab (let ((x (stream-cursor-position pane)))
-		     (stream-increment-cursor-position
-		      pane (- tab-width (mod x tab-width)) 0))))
-	 (incf start))))		    
+    (loop while (and (< start end)
+                     (whitespacep (buffer-object buffer start)))
+          do (ecase (buffer-object buffer start)
+               (#\Newline (terpri pane)
+                          (setf (aref *cursor-positions* (incf *current-line*))
+                                (multiple-value-bind (x y) (stream-cursor-position pane)
+                                  (declare (ignore x))
+                                  y)))
+               (#\Space (stream-increment-cursor-position
+                         pane space-width 0))
+               (#\Tab (let ((x (stream-cursor-position pane)))
+                        (stream-increment-cursor-position
+                         pane (- tab-width (mod x tab-width)) 0)))
+               (#\Page nil))
+	 (incf start))))
 
 (defmethod display-parse-tree :around ((entity cl-parse-tree) syntax pane)
   (with-slots (top bot) pane



From rstrandh at common-lisp.net  Mon May  9 14:13:45 2005
From: rstrandh at common-lisp.net (Robert Strandh)
Date: Mon,  9 May 2005 16:13:45 +0200 (CEST)
Subject: [climacs-cvs] CVS update: climacs/buffer.lisp climacs/gui.lisp 
Message-ID: <20050509141345.D155D88704@common-lisp.net>

Update of /project/climacs/cvsroot/climacs
In directory common-lisp.net:/tmp/cvs-serv14014

Modified Files:
	buffer.lisp gui.lisp 
Log Message:
Patch from John Q Splittist making Climacs not ask about saving buffers
without associated file names. 


Date: Mon May  9 16:13:45 2005
Author: rstrandh

Index: climacs/buffer.lisp
diff -u climacs/buffer.lisp:1.29 climacs/buffer.lisp:1.30
--- climacs/buffer.lisp:1.29	Fri Feb 25 08:11:24 2005
+++ climacs/buffer.lisp	Mon May  9 16:13:44 2005
@@ -1,35 +1,3 @@
-;;; -*- Mode: Lisp; Package: CLIMACS-BUFFER -*-
-
-;;;  (c) copyright 2004-2005 by
-;;;           Robert Strandh (strandh at labri.fr)
-;;;  (c) copyright 2004-2005 by
-;;;           Elliott Johnson (ejohnson at fasl.info)
-;;;  (c) copyright 2005 by
-;;;           Matthieu Villeneuve (matthieu.villeneuve at free.fr)
-
-;;; This library is free software; you can redistribute it and/or
-;;; modify it under the terms of the GNU Library General Public
-;;; License as published by the Free Software Foundation; either
-;;; version 2 of the License, or (at your option) any later version.
-;;;
-;;; This library is distributed in the hope that it will be useful,
-;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-;;; Library General Public License for more details.
-;;;
-;;; You should have received a copy of the GNU Library General Public
-;;; License along with this library; if not, write to the
-;;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-;;; Boston, MA  02111-1307  USA.
-
-;;; A not-so-stupid implementation of the buffer protocol.  This
-;;; implementation serves two purposes: First, so that higher-level
-;;; functionality can be built on top of a working implementation of
-;;; the buffer protocol, and second, to use as a comparison for
-;;; testing a new, better implementation of the buffer protocol.
-
-(in-package :climacs-buffer)
-
 (defclass buffer () ()
   (:documentation "A base class for all buffers. A buffer conceptually contains a
 large array of arbitrary objects.  Lines of objects are separated by


Index: climacs/gui.lisp
diff -u climacs/gui.lisp:1.135 climacs/gui.lisp:1.136
--- climacs/gui.lisp:1.135	Sun May  8 22:16:32 2005
+++ climacs/gui.lisp	Mon May  9 16:13:44 2005
@@ -741,13 +741,14 @@
 (define-named-command (com-quit) ()
   (loop for buffer in (buffers *application-frame*)
 	when (and (needs-saving buffer)
+		  (filename buffer)
 		  (handler-case (accept 'boolean
 					:prompt (format nil "Save buffer: ~a ?" (name buffer)))
 		    (error () (progn (beep)
 				     (display-message "Invalid answer")
 				     (return-from com-quit nil)))))
 	  do (save-buffer buffer))
-  (when (or (notany #'needs-saving
+  (when (or (notany #'(lambda (buffer) (and (needs-saving buffer) (filename buffer)))
 		    (buffers *application-frame*))
 	    (handler-case (accept 'boolean :prompt "Modified buffers exist.  Quit anyway?")
 	      (error () (progn (beep)



From rstrandh at common-lisp.net  Mon May  9 14:47:47 2005
From: rstrandh at common-lisp.net (Robert Strandh)
Date: Mon,  9 May 2005 16:47:47 +0200 (CEST)
Subject: [climacs-cvs] CVS update: climacs/gui.lisp climacs/pane.lisp 
Message-ID: <20050509144747.B385288704@common-lisp.net>

Update of /project/climacs/cvsroot/climacs
In directory common-lisp.net:/tmp/cvs-serv17603

Modified Files:
	gui.lisp pane.lisp 
Log Message:
Patch from John Q Splittist making the behavior of points in panes 
more natural.


Date: Mon May  9 16:47:45 2005
Author: rstrandh

Index: climacs/gui.lisp
diff -u climacs/gui.lisp:1.136 climacs/gui.lisp:1.137
--- climacs/gui.lisp:1.136	Mon May  9 16:13:44 2005
+++ climacs/gui.lisp	Mon May  9 16:47:45 2005
@@ -704,6 +704,7 @@
 			  :prompt "Find File"))
 	(buffer (make-instance 'climacs-buffer))
 	(pane (current-window)))
+    (setf (point (buffer pane)) (clone-mark (point pane)))
     (push buffer (buffers *application-frame*))
     (setf (buffer (current-window)) buffer)
     (setf (syntax buffer) (make-instance
@@ -787,6 +788,7 @@
   (let ((buffer (accept 'buffer
 			:prompt "Switch to buffer"))
 	(pane (current-window)))
+    (setf (point (buffer pane)) (clone-mark (point pane)))
     (setf (buffer pane) buffer)
     (full-redisplay pane)))
 
@@ -966,7 +968,8 @@
     (multiple-value-bind (vbox new-pane) (make-pane-constellation)
       (let* ((current-window (current-window))
 	     (constellation-root (parent3 current-window)))
-        (setf (buffer new-pane) (buffer current-window)
+        (setf (point (buffer current-window)) (clone-mark (point current-window))
+	      (buffer new-pane) (buffer current-window)
               (auto-fill-mode new-pane) (auto-fill-mode current-window)
               (auto-fill-column new-pane) (auto-fill-column current-window))
 	(push new-pane (windows *application-frame*))
@@ -980,7 +983,8 @@
     (multiple-value-bind (vbox new-pane) (make-pane-constellation)
       (let* ((current-window (current-window))
 	     (constellation-root (parent3 current-window)))
-        (setf (buffer new-pane) (buffer current-window)
+        (setf (point (buffer current-window)) (clone-mark (point current-window))
+	      (buffer new-pane) (buffer current-window)
               (auto-fill-mode new-pane) (auto-fill-mode current-window)
               (auto-fill-column new-pane) (auto-fill-column current-window))
 	(push new-pane (windows *application-frame*))


Index: climacs/pane.lisp
diff -u climacs/pane.lisp:1.25 climacs/pane.lisp:1.26
--- climacs/pane.lisp:1.25	Sat May  7 00:32:28 2005
+++ climacs/pane.lisp	Mon May  9 16:47:45 2005
@@ -196,6 +196,7 @@
 (defclass climacs-buffer (delegating-buffer filepath-mixin name-mixin)
   ((needs-saving :initform nil :accessor needs-saving)
    (syntax :accessor syntax)
+   (point :initform nil :initarg :point :accessor point)
    (indent-tabs-mode :initarg indent-tabs-mode :initform t
                      :accessor indent-tabs-mode))
   (:default-initargs
@@ -204,13 +205,14 @@
 
 (defmethod initialize-instance :after ((buffer climacs-buffer) &rest args)
   (declare (ignore args))
-  (with-slots (syntax) buffer
+  (with-slots (syntax point) buffer
      (setf syntax (make-instance
-		   'basic-syntax :buffer (implementation buffer)))))
+		   'basic-syntax :buffer (implementation buffer))
+	   point (clone-mark (low-mark buffer) :right))))
 
 (defclass climacs-pane (application-pane)
   ((buffer :initform (make-instance 'climacs-buffer) :accessor buffer)
-   (point :initform nil :initarg :point :reader point)
+   (point :initform nil :initarg :point :accessor point)
    (mark :initform nil :initarg :mark :accessor mark)
    (top :reader top)
    (bot :reader bot)
@@ -240,6 +242,7 @@
 (defmethod initialize-instance :after ((pane climacs-pane) &rest args)
   (declare (ignore args))
   (with-slots (buffer point mark) pane
+     (setf point (clone-mark (point buffer)))
      (when (null point)
        (setf point (clone-mark (low-mark buffer) :right)))
      (when (null mark)
@@ -256,7 +259,7 @@
 
 (defmethod (setf buffer) :after (buffer (pane climacs-pane))
   (with-slots (point mark top bot) pane
-       (setf point (clone-mark (low-mark buffer) :right)
+       (setf point (clone-mark (point buffer))
 	     mark (clone-mark (low-mark buffer) :right)
 	     top (clone-mark (low-mark buffer) :left)
 	     bot (clone-mark (high-mark buffer) :right))))



From crhodes at common-lisp.net  Tue May 10 16:28:55 2005
From: crhodes at common-lisp.net (Christophe Rhodes)
Date: Tue, 10 May 2005 18:28:55 +0200 (CEST)
Subject: [climacs-cvs] CVS update: climacs/buffer.lisp climacs/gui.lisp 
Message-ID: <20050510162855.741D4880A4@common-lisp.net>

Update of /project/climacs/cvsroot/climacs
In directory common-lisp.net:/tmp/cvs-serv19641

Modified Files:
	buffer.lisp gui.lisp 
Log Message:
Restore the (in-package ...) and the copyright information to 
buffer.lisp

The buffer accessor is FILEPATH, not FILENAME

Date: Tue May 10 18:28:54 2005
Author: crhodes

Index: climacs/buffer.lisp
diff -u climacs/buffer.lisp:1.30 climacs/buffer.lisp:1.31
--- climacs/buffer.lisp:1.30	Mon May  9 16:13:44 2005
+++ climacs/buffer.lisp	Tue May 10 18:28:53 2005
@@ -1,3 +1,35 @@
+;;; -*- Mode: Lisp; Package: CLIMACS-BUFFER -*-
+
+;;;  (c) copyright 2004-2005 by
+;;;           Robert Strandh (strandh at labri.fr)
+;;;  (c) copyright 2004-2005 by
+;;;           Elliott Johnson (ejohnson at fasl.info)
+;;;  (c) copyright 2005 by
+;;;           Matthieu Villeneuve (matthieu.villeneuve at free.fr)
+
+;;; This library is free software; you can redistribute it and/or
+;;; modify it under the terms of the GNU Library General Public
+;;; License as published by the Free Software Foundation; either
+;;; version 2 of the License, or (at your option) any later version.
+;;;
+;;; This library is distributed in the hope that it will be useful,
+;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+;;; Library General Public License for more details.
+;;;
+;;; You should have received a copy of the GNU Library General Public
+;;; License along with this library; if not, write to the
+;;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;;; Boston, MA  02111-1307  USA.
+
+;;; A not-so-stupid implementation of the buffer protocol.  This
+;;; implementation serves two purposes: First, so that higher-level
+;;; functionality can be built on top of a working implementation of
+;;; the buffer protocol, and second, to use as a comparison for
+;;; testing a new, better implementation of the buffer protocol.
+
+(in-package :climacs-buffer)
+
 (defclass buffer () ()
   (:documentation "A base class for all buffers. A buffer conceptually contains a
 large array of arbitrary objects.  Lines of objects are separated by


Index: climacs/gui.lisp
diff -u climacs/gui.lisp:1.137 climacs/gui.lisp:1.138
--- climacs/gui.lisp:1.137	Mon May  9 16:47:45 2005
+++ climacs/gui.lisp	Tue May 10 18:28:53 2005
@@ -742,14 +742,14 @@
 (define-named-command (com-quit) ()
   (loop for buffer in (buffers *application-frame*)
 	when (and (needs-saving buffer)
-		  (filename buffer)
+		  (filepath buffer)
 		  (handler-case (accept 'boolean
 					:prompt (format nil "Save buffer: ~a ?" (name buffer)))
 		    (error () (progn (beep)
 				     (display-message "Invalid answer")
 				     (return-from com-quit nil)))))
 	  do (save-buffer buffer))
-  (when (or (notany #'(lambda (buffer) (and (needs-saving buffer) (filename buffer)))
+  (when (or (notany #'(lambda (buffer) (and (needs-saving buffer) (filepath buffer)))
 		    (buffers *application-frame*))
 	    (handler-case (accept 'boolean :prompt "Modified buffers exist.  Quit anyway?")
 	      (error () (progn (beep)



From crhodes at common-lisp.net  Tue May 17 09:25:18 2005
From: crhodes at common-lisp.net (Christophe Rhodes)
Date: Tue, 17 May 2005 11:25:18 +0200 (CEST)
Subject: [climacs-cvs] CVS update: Module imported: papers/ilc2005/syntax
Message-ID: <20050517092518.56DCD880A4@common-lisp.net>

Update of /project/climacs/cvsroot/papers/ilc2005/syntax
In directory common-lisp.net:/tmp/cvs-serv20734

Log Message:
Initial import

Status:

Vendor Tag:	INITIAL
Release Tags:	start
		
N papers/ilc2005/syntax/climacssyntax.tex
cvs: ERROR: cannot write file /project/climacs/cvsroot/papers/ilc2005/syntax/climacssyntax.tex,v: No such file or directory
N papers/ilc2005/syntax/acm_proc_article-sp.cls
cvs: ERROR: cannot write file /project/climacs/cvsroot/papers/ilc2005/syntax/acm_proc_article-sp.cls,v: No such file or directory
N papers/ilc2005/syntax/climacssyntax.bib
cvs: ERROR: cannot write file /project/climacs/cvsroot/papers/ilc2005/syntax/climacssyntax.bib,v: No such file or directory

No conflicts created by this import

Date: Tue May 17 11:25:17 2005
Author: crhodes
New module papers/ilc2005/syntax added


From crhodes at common-lisp.net  Tue May 17 09:52:34 2005
From: crhodes at common-lisp.net (Christophe Rhodes)
Date: Tue, 17 May 2005 11:52:34 +0200 (CEST)
Subject: [climacs-cvs] CVS update: Module imported: papers/ilc2005/syntax
Message-ID: <20050517095234.F0E2B880A4@common-lisp.net>

Update of /project/climacs/cvsroot/papers/ilc2005/syntax
In directory common-lisp.net:/tmp/cvs-serv22723

Log Message:
Initial import

Status:

Vendor Tag:	INITIAL
Release Tags:	start
		
N papers/ilc2005/syntax/climacssyntax.tex
N papers/ilc2005/syntax/acm_proc_article-sp.cls
N papers/ilc2005/syntax/climacssyntax.bib

No conflicts created by this import

Date: Tue May 17 11:52:34 2005
Author: crhodes
New module papers/ilc2005/syntax added


From crhodes at common-lisp.net  Tue May 17 11:05:01 2005
From: crhodes at common-lisp.net (Christophe Rhodes)
Date: Tue, 17 May 2005 13:05:01 +0200 (CEST)
Subject: [climacs-cvs] CVS update: papers/ilc2005/syntax/climacssyntax.tex 
Message-ID: <20050517110501.B9457880DF@common-lisp.net>

Update of /project/climacs/cvsroot/papers/ilc2005/syntax
In directory common-lisp.net:/tmp/cvs-serv27571

Modified Files:
	climacssyntax.tex 
Log Message:
Use the geometry package to enforce the formatting requirements
  (sadly, it appears that there's no way of doing so without specifying 
  either letterpaper or a4paper.  Sorry.)

Minor other tinkering

Date: Tue May 17 13:05:00 2005
Author: crhodes

Index: papers/ilc2005/syntax/climacssyntax.tex
diff -u papers/ilc2005/syntax/climacssyntax.tex:1.1.1.1 papers/ilc2005/syntax/climacssyntax.tex:1.2
--- papers/ilc2005/syntax/climacssyntax.tex:1.1.1.1	Tue May 17 11:52:34 2005
+++ papers/ilc2005/syntax/climacssyntax.tex	Tue May 17 13:05:00 2005
@@ -1,8 +1,9 @@
 \documentclass{acm_proc_article-sp}
 
+\usepackage[a4paper,textwidth=7in,textheight=9in]{geometry}
+
 \begin{document}
 
-%\usepackage{geometry}
 %\geometry{letterpaper}
 %\usepackage{graphicx}
 %\usepackage{amssymb}
@@ -46,9 +47,10 @@
   using a per-buffer function for its parsing.
 \end{abstract}
 
-\category{H.4}{Information Systems Applications}{Miscellaneous}[possibly]
+\category{D.2.3}{Coding Tools and Techniques}{Program editors}
+\category{D.3.4}{Processors}{Incremental compilers}
 
-\keywords{I, don't, know}
+\keywords{Editors, Parsing, Tablature}
 
 \section{Overview}
 



From bmastenbrook at common-lisp.net  Tue May 17 12:56:24 2005
From: bmastenbrook at common-lisp.net (Brian Mastenbrook)
Date: Tue, 17 May 2005 14:56:24 +0200 (CEST)
Subject: [climacs-cvs] CVS update: papers/ilc2005/syntax/climacssyntax.bib
	papers/ilc2005/syntax/climacssyntax.tex 
Message-ID: <20050517125624.9E57E880DF@common-lisp.net>

Update of /project/climacs/cvsroot/papers/ilc2005/syntax
In directory common-lisp.net:/tmp/cvs-serv1290

Modified Files:
	climacssyntax.bib climacssyntax.tex 
Log Message:
MORE CITATIONS

Date: Tue May 17 14:56:23 2005
Author: bmastenbrook

Index: papers/ilc2005/syntax/climacssyntax.bib
diff -u papers/ilc2005/syntax/climacssyntax.bib:1.1.1.1 papers/ilc2005/syntax/climacssyntax.bib:1.2
--- papers/ilc2005/syntax/climacssyntax.bib:1.1.1.1	Tue May 17 11:52:34 2005
+++ papers/ilc2005/syntax/climacssyntax.bib	Tue May 17 14:56:23 2005
@@ -10,7 +10,7 @@
   OPTmonth = 	 {},
   OPTnote = 	 {},
   OPTannote = 	 {}
-}
+}  
 
 @InProceedings{ecolm-graz,
   author = 	 {Tim Crawford and Michael Gale and David Lewis},
@@ -63,6 +63,14 @@
   publisher = {Franz Inc.},
   OPTnote = 	 {},
   OPTannote = 	 {}
+}
+
+ at InProceedings{flexichain,
+  author =       {Robert Strandh and Matthieu Villeneuve and Timothy Moore},
+  title =        {Flexichain: An editable sequence and its gap-buffer implementation},
+  booktitle = {1st European Lisp and Scheme Workshop},
+  year = {2004},
+  address = {Oslo}
 }
 
 @Article{mckayacm,


Index: papers/ilc2005/syntax/climacssyntax.tex
diff -u papers/ilc2005/syntax/climacssyntax.tex:1.2 papers/ilc2005/syntax/climacssyntax.tex:1.3
--- papers/ilc2005/syntax/climacssyntax.tex:1.2	Tue May 17 13:05:00 2005
+++ papers/ilc2005/syntax/climacssyntax.tex	Tue May 17 14:56:23 2005
@@ -29,8 +29,9 @@
   \email{strandh at labri.fr}
   \alignauthor Brian Mastenbrook\\
   \affaddr{Motorola}\\
-  \affaddr{Somewhere in the US}\\
-  \email{brian at mastenbrook.net} % or maybe a Motorola address?
+  \affaddr{1303 E. Algonquin Road}\\
+  \affaddr{Schaumburg, IL, USA  60196}\\
+  \email{Brian.Mastenbrook at motorola.com}
 }
 
 \maketitle
@@ -56,15 +57,15 @@
 
 The Climacs text editor is a combination of frameworks for buffer
 representation and buffer contents parsing with a CLIM-based display
-engine. The Flexichain library provides an editable sequence
-representation and mark (cursor) management based on a circular gap
-buffer. This library is used by the buffer protocol, which provides a
-standard interface to common text editor buffer operations. The syntax
-protocol provides a method for interfacing a lexical analyzer and
-parser with the text editor. An implementation of the Earley parsing
-algorithm is provided to simplify the creation of syntaxes for common
-context-free grammars. Syntax modules also define methods to draw
-syntax objects in the Climacs window.
+engine. The Flexichain library \cite{flexichain} provides an editable
+sequence representation and mark (cursor) management based on a
+circular gap buffer. This library is used by the buffer protocol,
+which provides a standard interface to common text editor buffer
+operations. The syntax protocol provides a method for interfacing a
+lexical analyzer and parser with the text editor. An implementation of
+the Earley parsing algorithm is provided to simplify the creation of
+syntaxes for common context-free grammars. Syntax modules also define
+methods to draw syntax objects in the Climacs window.
 
 \section{Buffer Protocol}
 



From crhodes at common-lisp.net  Wed May 18 09:51:44 2005
From: crhodes at common-lisp.net (Christophe Rhodes)
Date: Wed, 18 May 2005 11:51:44 +0200 (CEST)
Subject: [climacs-cvs] CVS update: papers/ilc2005/syntax/besfantlach.eps
	papers/ilc2005/syntax/besfantlach.pdf
	papers/ilc2005/syntax/climacssyntax.tex 
Message-ID: <20050518095144.C88DF88731@common-lisp.net>

Update of /project/climacs/cvsroot/papers/ilc2005/syntax
In directory common-lisp.net:/tmp/cvs-serv14862

Modified Files:
	climacssyntax.tex 
Added Files:
	besfantlach.eps besfantlach.pdf 
Log Message:
Add TabCode figure

Date: Wed May 18 11:51:43 2005
Author: crhodes





Index: papers/ilc2005/syntax/climacssyntax.tex
diff -u papers/ilc2005/syntax/climacssyntax.tex:1.3 papers/ilc2005/syntax/climacssyntax.tex:1.4
--- papers/ilc2005/syntax/climacssyntax.tex:1.3	Tue May 17 14:56:23 2005
+++ papers/ilc2005/syntax/climacssyntax.tex	Wed May 18 11:51:43 2005
@@ -1,5 +1,7 @@
 \documentclass{acm_proc_article-sp}
 
+\newcommand{\TabCode}{\textit{TabCode}}
+
 \usepackage[a4paper,textwidth=7in,textheight=9in]{geometry}
 
 \begin{document}
@@ -138,6 +140,25 @@
 by the parser, with language keywords appearing in a separate color.
 
 \subsection{Per-Buffer Syntax}
+
+\begin{figure*}
+  \begin{center}
+    \parbox{0.45\linewidth}{\includegraphics{besfantlach}}
+    \parbox{0.25\linewidth}{\texttt{\\ [1cm]\noindent
+        Qa1a2b3c4c5a6\\
+        Ea2\\
+        a6\\
+        d6\\
+        a2b3\\
+        d2f3\\
+        d6\\
+        |}}
+    \caption{An extract from `Fantasia Ioannis Dooland Angli
+      \textit{Lachrimae}', Jean-Baptiste Besard, \textit{Thesaurus
+        Harmonicus} (1603), f.16v, and its \TabCode\ encoding.}
+    \label{fig:besfantlach}
+  \end{center}
+\end{figure*}
 
 Christophe should describe the tabcode editor here.
 



From crhodes at common-lisp.net  Wed May 18 13:56:46 2005
From: crhodes at common-lisp.net (Christophe Rhodes)
Date: Wed, 18 May 2005 15:56:46 +0200 (CEST)
Subject: [climacs-cvs] CVS update: papers/ilc2005/syntax/climacssyntax.tex 
Message-ID: <20050518135646.F00278873F@common-lisp.net>

Update of /project/climacs/cvsroot/papers/ilc2005/syntax
In directory common-lisp.net:/tmp/cvs-serv522

Modified Files:
	climacssyntax.tex 
Log Message:
Some more small additions

Date: Wed May 18 15:56:46 2005
Author: crhodes

Index: papers/ilc2005/syntax/climacssyntax.tex
diff -u papers/ilc2005/syntax/climacssyntax.tex:1.4 papers/ilc2005/syntax/climacssyntax.tex:1.5
--- papers/ilc2005/syntax/climacssyntax.tex:1.4	Wed May 18 11:51:43 2005
+++ papers/ilc2005/syntax/climacssyntax.tex	Wed May 18 15:56:45 2005
@@ -127,7 +127,10 @@
 Christophe might want to describe the Prolog syntax a bit here. In
 particular any details having to do with the implementation of
 operator precedence as specified in the ISO Prolog standard might be
-interesting.
+interesting.  [ Maybe just the \textit{priority} stuff? I think that's
+the only interesting bit of non-context-freeness; user-defined
+operators is OK because you can't actually define and use a new
+operator in the same directive. ]
 
 The TTCN3 syntax is implemented with a high-level macro which defines
 classes and adds syntax rules using the syntax protocol for each
@@ -160,7 +163,37 @@
   \end{center}
 \end{figure*}
 
-Christophe should describe the tabcode editor here.
+\TabCode\ is a textual format for description of lute tablature.  In
+its simplest form, it is a sequence of whitespace-delimited
+independent words, where each word represents either a set of frets to
+depress and strings to be sounded, or alternatively some element of
+musical notation (such as a barline); figure \ref{fig:besfantlach}
+demonstrates a fragment of manuscript, and its \TabCode encoding.  It
+is also possible to encode more complex elements of lute tablature
+notation in \TabCode: ornaments, beaming, connecting lines and other
+complex elements can all be accommodated.
+
+\TabCode\ has been used to produce scholarly editions of lute works
+\cite{Weiss} and to computer-based musicological studies (as in
+\cite{ecolm-graz} for example).  
+
+\TabCode\ has a rather ad-hoc cobbled together grammar.  Tokenising is
+easy; determining which elements of the notation are best captured is
+not so easy.  Chords, obviously; beams, comments...  Should we try to
+capture a BNF or something?  I suppose it depends how we're doing for
+space.
+
+Need whole-buffer function to present an alternative whole-system view
+on the data.  
+
+Editor is in use for cataloguing European lute music, and supports
+research into more advanced notations (for e.g. editorial comment, or
+manuscript markup)
+
+Efficiency concerns assuaged by typical locality of edit, incremental
+redisplay on the tablature buffer.
+
+MIDI feedback.
 
 \section{Conclusion}
 



From crhodes at common-lisp.net  Thu May 19 09:04:27 2005
From: crhodes at common-lisp.net (Christophe Rhodes)
Date: Thu, 19 May 2005 11:04:27 +0200 (CEST)
Subject: [climacs-cvs] CVS update: climacs/gui.lisp 
Message-ID: <20050519090427.C46A78873A@common-lisp.net>

Update of /project/climacs/cvsroot/climacs
In directory common-lisp.net:/tmp/cvs-serv6573

Modified Files:
	gui.lisp 
Log Message:
Add com-insert-file (from David Lewis)

Date: Thu May 19 11:04:27 2005
Author: crhodes

Index: climacs/gui.lisp
diff -u climacs/gui.lisp:1.138 climacs/gui.lisp:1.139
--- climacs/gui.lisp:1.138	Tue May 10 18:28:53 2005
+++ climacs/gui.lisp	Thu May 19 11:04:26 2005
@@ -721,6 +721,20 @@
     ;; resets the low and high marks after redisplay
     (redisplay-frame-panes *application-frame*)))
 
+(define-named-command com-insert-file ()
+  (let ((filename (accept 'completable-pathname
+			  :prompt "Insert File"))
+	(pane (current-window)))
+    (when (probe-file filename)
+      (setf (mark pane) (clone-mark (point pane) :left))
+      (with-open-file (stream filename :direction :input)
+	(input-from-stream stream
+			   (buffer pane)
+			   (offset (point pane))))
+      (psetf (offset (mark pane)) (offset (point pane))
+	     (offset (point pane)) (offset (mark pane))))
+    (redisplay-frame-panes *application-frame*)))
+
 (defun save-buffer (buffer)
   (let ((filepath (or (filepath buffer)
 		      (accept 'completable-pathname
@@ -1458,6 +1472,7 @@
 (c-x-set-key '(#\e) 'com-call-last-kbd-macro)
 (c-x-set-key '(#\c :control) 'com-quit)
 (c-x-set-key '(#\f :control) 'com-find-file)
+(c-x-set-key '(#\i) 'com-insert-file)
 (c-x-set-key '(#\k) 'com-kill-buffer)
 (c-x-set-key '(#\l :control) 'com-load-file)
 (c-x-set-key '(#\o) 'com-other-window)



From crhodes at common-lisp.net  Fri May 20 08:18:33 2005
From: crhodes at common-lisp.net (Christophe Rhodes)
Date: Fri, 20 May 2005 10:18:33 +0200 (CEST)
Subject: [climacs-cvs] CVS update: papers/ilc2005/syntax/climacssyntax.tex 
Message-ID: <20050520081833.B737788743@common-lisp.net>

Update of /project/climacs/cvsroot/papers/ilc2005/syntax
In directory common-lisp.net:/tmp/cvs-serv27048

Modified Files:
	climacssyntax.tex 
Log Message:
tiny extrapolations on current structure

Date: Fri May 20 10:18:33 2005
Author: crhodes

Index: papers/ilc2005/syntax/climacssyntax.tex
diff -u papers/ilc2005/syntax/climacssyntax.tex:1.5 papers/ilc2005/syntax/climacssyntax.tex:1.6
--- papers/ilc2005/syntax/climacssyntax.tex:1.5	Wed May 18 15:56:45 2005
+++ papers/ilc2005/syntax/climacssyntax.tex	Fri May 20 10:18:33 2005
@@ -102,6 +102,9 @@
 approach is appropriate when the parse tree will also be used for some
 other display or analysis of the text in the buffer.
 
+Earley parser: discussion of generality and asymptotic efficiency (in
+general and for usual cases).
+
 \section{Syntaxes}
 
 We describe two different approaches to syntax analysis in the Climacs
@@ -127,11 +130,23 @@
 Christophe might want to describe the Prolog syntax a bit here. In
 particular any details having to do with the implementation of
 operator precedence as specified in the ISO Prolog standard might be
-interesting.  [ Maybe just the \textit{priority} stuff? I think that's
+interesting.  
+
+[ Maybe just the \textit{priority} stuff? I think that's
 the only interesting bit of non-context-freeness; user-defined
 operators is OK because you can't actually define and use a new
 operator in the same directive. ]
 
+Float tokenizer (not interesting, but not yet done)
+
+Need for inheritable grammars / tokenizers: most Prologs deviate from
+ISO slightly, mostly in surface syntax rather than in the engine.
+Examples: \verb+"ab\x011\"+, \texttt{0'''}, \texttt{[H|T]} when
+\texttt{|} is an operator.
+
+Possibility (probably ``Future Work'') to make nice integrated Prolog
+environment.
+
 The TTCN3 syntax is implemented with a high-level macro which defines
 classes and adds syntax rules using the syntax protocol for each
 terminal and non-terminal in the grammar. The syntax of this macro
@@ -183,6 +198,11 @@
 capture a BNF or something?  I suppose it depends how we're doing for
 space.
 
+Ornaments are simple to model, as they are merely modifiers to note
+objects; higher-level grouping things (beams, connecting lines) have
+their own semi-independent identity, despite not being notated as such
+in the textual \TabCode.
+
 Need whole-buffer function to present an alternative whole-system view
 on the data.  
 
@@ -190,10 +210,11 @@
 research into more advanced notations (for e.g. editorial comment, or
 manuscript markup)
 
-Efficiency concerns assuaged by typical locality of edit, incremental
-redisplay on the tablature buffer.
+Efficiency concerns assuaged by typical locality of edit, CLIM
+incremental redisplay on the tablature buffer.
 
-MIDI feedback.
+MIDI feedback.  At present, based on Apple's extremely badly
+documented CoreMIDI framework; a port to alsalib is on the cards.
 
 \section{Conclusion}
 



From crhodes at common-lisp.net  Fri May 20 11:48:42 2005
From: crhodes at common-lisp.net (Christophe Rhodes)
Date: Fri, 20 May 2005 13:48:42 +0200 (CEST)
Subject: [climacs-cvs] CVS update: papers/ilc2005/syntax/barley.eps
	papers/ilc2005/syntax/barley.pdf
	papers/ilc2005/syntax/climacssyntax.bib
	papers/ilc2005/syntax/climacssyntax.tex 
Message-ID: <20050520114842.865F78874D@common-lisp.net>

Update of /project/climacs/cvsroot/papers/ilc2005/syntax
In directory common-lisp.net:/tmp/cvs-serv7313

Modified Files:
	climacssyntax.bib climacssyntax.tex 
Added Files:
	barley.eps barley.pdf 
Log Message:
Add a couple of editor references

Rearrange the introduction a little bit

add another figure of more complex tablature

Date: Fri May 20 13:48:41 2005
Author: crhodes





Index: papers/ilc2005/syntax/climacssyntax.bib
diff -u papers/ilc2005/syntax/climacssyntax.bib:1.2 papers/ilc2005/syntax/climacssyntax.bib:1.3
--- papers/ilc2005/syntax/climacssyntax.bib:1.2	Tue May 17 14:56:23 2005
+++ papers/ilc2005/syntax/climacssyntax.bib	Fri May 20 13:48:40 2005
@@ -117,3 +117,23 @@
   OPTannote = 	 {}
 }
 
+ at inproceedings{greenberg,
+ author = {Bernard S. Greenberg},
+ title = "{Multics Emacs (Prose and Cons): A commercial text-processing system in Lisp}",
+ booktitle = {LFP '80: Proceedings of the 1980 ACM conference on LISP and functional programming},
+ year = {1980},
+ pages = {6--12},
+ location = {Stanford University, California, United States},
+ publisher = {ACM Press},
+ address = {New York, NY, USA},
+}
+
+ at inproceedings{woodZ,
+ author = {Steven R. Wood},
+ title = "{Z -- the 95\% program editor}",
+ booktitle = {Proceedings of the ACM SIGPLAN SIGOA symposium on Text manipulation},
+ year = {1981},
+ isbn = {0-89791-050-8},
+ pages = {1--7},
+ location = {Portland, Oregon, United States}},
+ }
\ No newline at end of file


Index: papers/ilc2005/syntax/climacssyntax.tex
diff -u papers/ilc2005/syntax/climacssyntax.tex:1.6 papers/ilc2005/syntax/climacssyntax.tex:1.7
--- papers/ilc2005/syntax/climacssyntax.tex:1.6	Fri May 20 10:18:33 2005
+++ papers/ilc2005/syntax/climacssyntax.tex	Fri May 20 13:48:41 2005
@@ -55,21 +55,55 @@
 
 \keywords{Editors, Parsing, Tablature}
 
-\section{Overview}
+\section{Introduction}
+
+The field of advanced text editors is a crowded one, with a long
+history and an apparent ability to cause passionate argument.
+
+[ Does anyone know enough about the history of editors? ]
+
+\begin{itemize}
+\item ed
+\item vi (vim)
+\item emacs (Zmacs) (emacs time line) \cite{greenberg}
+\item some kind of interlispy/smalltalky structure editor?  
+\item Z -- the 95\% text editor \cite{woodZ}.  Note that WiB didn't
+  win!
+\end{itemize}
+
+Discuss lameness of emacs-like regexoid analysis in e.g. CL mode;
+maybe mention how it falls over dramatically in perl mode (where
+context starts really mattering)
+\begin{itemize}
+\item non-locality leading to confusion in \verb+#| |#+
+\item paren-in-column-1 hack (and its workaround in docstrings:
+  \verb+\(+)
+\end{itemize}
 
 The Climacs text editor is a combination of frameworks for buffer
 representation and buffer contents parsing with a CLIM-based display
-engine. The Flexichain library \cite{flexichain} provides an editable
-sequence representation and mark (cursor) management based on a
-circular gap buffer. This library is used by the buffer protocol,
-which provides a standard interface to common text editor buffer
-operations. The syntax protocol provides a method for interfacing a
-lexical analyzer and parser with the text editor. An implementation of
-the Earley parsing algorithm is provided to simplify the creation of
-syntaxes for common context-free grammars. Syntax modules also define
-methods to draw syntax objects in the Climacs window.
+engine.  It includes the Flexichain library \cite{flexichain}, which
+provides an editable sequence representation and mark (cursor)
+management based on a circular gap buffer; and an implementation of a
+slight modification of the Earley parsing algorithm \cite{earley}, to
+assist in the creation of syntax-aware editing modes.
+
+The Climacs buffer protocol, which provides a standard interface to
+common text editor buffer operations, uses the Flexichain library; we
+discuss this protocol in more detail in section \ref{sec:buffer}.  The
+syntax protocol, which we discuss in section \ref{sec:syntax},
+provides a method for interfacing a lexical analyzer and parser with
+the text editor, and provides for defining methods to draw syntax
+objects in the Climacs window.  In section \ref{sec:syntaxes} we
+discuss the implementation of syntactic analysis for various
+programming languages, including Common Lisp; in section
+\ref{sec:tabeditor}, we discuss an application with Climacs at its
+core to support editing a textual representation of lute tablature.
+We discuss avenues for further development in section
+\ref{sec:conclusions}.
 
 \section{Buffer Protocol}
+\label{sec:buffer}
 
 The buffer protocol provides a set of methods for modifying and
 reading the contents of a buffer which can contain arbitrary objects.
@@ -87,6 +121,7 @@
 unspecialized.
 
 \section{Syntax Protocol}
+\label{sec:syntax}
 
 A syntax in Climacs is an incremental parser which creates and updates
 a parse tree of a buffer's contents, and provides a mechanism for
@@ -103,16 +138,20 @@
 other display or analysis of the text in the buffer.
 
 Earley parser: discussion of generality and asymptotic efficiency (in
-general and for usual cases).
+general and for usual cases).  Possibility of replacement in case of
+complicated grammars?  (What was that parsing algorithm that someone
+mentioned on \verb+#lisp+?)
 
 \section{Syntaxes}
+\label{sec:syntaxes}
 
 We describe two different approaches to syntax analysis in the Climacs
 editor. Per-window parsing is used by the provided modes for HTML,
 Common Lisp, Prolog, and TTCN3. Each of these syntaxes is implemented
 with the provided Earley parser \cite{earley}. The lute tablature
 editor uses a per-buffer function for its syntax analysis and
-implements a simple recursive-descent parsing algorithm.
+implements a simple recursive-descent parsing algorithm.  (FIXME: is
+this true?  I don't know enough about parsing)
 
 \subsection{Per-Window Syntaxes}
 
@@ -157,7 +196,8 @@
 macro defines basic display functions for the syntax objects produced
 by the parser, with language keywords appearing in a separate color.
 
-\subsection{Per-Buffer Syntax}
+\subsection{Per-Buffer Syntax: a tablature editor}
+\label{sec:tabeditor}
 
 \begin{figure*}
   \begin{center}
@@ -178,6 +218,26 @@
   \end{center}
 \end{figure*}
 
+\begin{figure*}
+  \begin{center}
+    \parbox{0.45\linewidth}{\includegraphics{barley}}
+    \parbox{0.25\linewidth}{\texttt{\\ [1cm]\noindent
+        Sa1(E)d5(C5:8)\\
+        a2.\\
+        d3\\
+        b3.\\
+        d3\\
+        a2.\\
+        a1:\\
+        d3.(C-5:4)\\
+        |}}
+    \caption{An extract from `Lachrime by I. D.' from \textit{A New
+        Booke of Tabliture}, published by William Barley (London,
+      1596), E1r, and its \TabCode\ encoding.}
+    \label{fig:barley}
+  \end{center}
+\end{figure*}
+
 \TabCode\ is a textual format for description of lute tablature.  In
 its simplest form, it is a sequence of whitespace-delimited
 independent words, where each word represents either a set of frets to
@@ -186,7 +246,8 @@
 demonstrates a fragment of manuscript, and its \TabCode encoding.  It
 is also possible to encode more complex elements of lute tablature
 notation in \TabCode: ornaments, beaming, connecting lines and other
-complex elements can all be accommodated.
+complex elements can all be accommodated (see figure \ref{fig:barley}
+for examples of more these more complex elements).
 
 \TabCode\ has been used to produce scholarly editions of lute works
 \cite{Weiss} and to computer-based musicological studies (as in
@@ -216,9 +277,11 @@
 MIDI feedback.  At present, based on Apple's extremely badly
 documented CoreMIDI framework; a port to alsalib is on the cards.
 
-\section{Conclusion}
+\section{Future Work and Conclusions}
+\label{sec:conclusions}
 
-I like Jello. Jello is good.
+I like Jello.  Jello is good.  We should enable people to make better
+Jello.
 
 \nocite{*}
 



From crhodes at common-lisp.net  Fri May 20 13:35:22 2005
From: crhodes at common-lisp.net (Christophe Rhodes)
Date: Fri, 20 May 2005 15:35:22 +0200 (CEST)
Subject: [climacs-cvs] CVS update: papers/ilc2005/syntax/climacssyntax.bib
	papers/ilc2005/syntax/climacssyntax.tex 
Message-ID: <20050520133522.E67DE88750@common-lisp.net>

Update of /project/climacs/cvsroot/papers/ilc2005/syntax
In directory common-lisp.net:/tmp/cvs-serv13676

Modified Files:
	climacssyntax.bib climacssyntax.tex 
Log Message:
One or two more things that we might want to discuss

Date: Fri May 20 15:35:22 2005
Author: crhodes

Index: papers/ilc2005/syntax/climacssyntax.bib
diff -u papers/ilc2005/syntax/climacssyntax.bib:1.3 papers/ilc2005/syntax/climacssyntax.bib:1.4
--- papers/ilc2005/syntax/climacssyntax.bib:1.3	Fri May 20 13:48:40 2005
+++ papers/ilc2005/syntax/climacssyntax.bib	Fri May 20 15:35:22 2005
@@ -130,7 +130,7 @@
 
 @inproceedings{woodZ,
  author = {Steven R. Wood},
- title = "{Z -- the 95\% program editor}",
+ title = "{Z -- The 95\% Program Editor}",
  booktitle = {Proceedings of the ACM SIGPLAN SIGOA symposium on Text manipulation},
  year = {1981},
  isbn = {0-89791-050-8},


Index: papers/ilc2005/syntax/climacssyntax.tex
diff -u papers/ilc2005/syntax/climacssyntax.tex:1.7 papers/ilc2005/syntax/climacssyntax.tex:1.8
--- papers/ilc2005/syntax/climacssyntax.tex:1.7	Fri May 20 13:48:41 2005
+++ papers/ilc2005/syntax/climacssyntax.tex	Fri May 20 15:35:22 2005
@@ -186,6 +186,12 @@
 Possibility (probably ``Future Work'') to make nice integrated Prolog
 environment.
 
+At present, one parse error implies the invalidation of the rest of
+the file.  This adds a burden on the mode implementor that the syntax
+analyser be both bug-free and correspond with reality; a
+slightly-buggy or incomplete syntax mode will render the whole thing
+useless.  Violation of WiB?
+
 The TTCN3 syntax is implemented with a high-level macro which defines
 classes and adds syntax rules using the syntax protocol for each
 terminal and non-terminal in the grammar. The syntax of this macro
@@ -243,11 +249,11 @@
 independent words, where each word represents either a set of frets to
 depress and strings to be sounded, or alternatively some element of
 musical notation (such as a barline); figure \ref{fig:besfantlach}
-demonstrates a fragment of manuscript, and its \TabCode encoding.  It
+demonstrates a fragment of manuscript, and its \TabCode\ encoding.  It
 is also possible to encode more complex elements of lute tablature
-notation in \TabCode: ornaments, beaming, connecting lines and other
-complex elements can all be accommodated (see figure \ref{fig:barley}
-for examples of more these more complex elements).
+notation in \TabCode: ornaments, fingering marks, beaming, connecting
+lines and other complex elements can all be accommodated (see figure
+\ref{fig:barley} for examples of more these more complex elements).
 
 \TabCode\ has been used to produce scholarly editions of lute works
 \cite{Weiss} and to computer-based musicological studies (as in



From crhodes at common-lisp.net  Fri May 20 14:44:56 2005
From: crhodes at common-lisp.net (Christophe Rhodes)
Date: Fri, 20 May 2005 16:44:56 +0200 (CEST)
Subject: [climacs-cvs] CVS update: papers/ilc2005/syntax/climacssyntax.bib
	papers/ilc2005/syntax/climacssyntax.tex 
Message-ID: <20050520144456.452EB88750@common-lisp.net>

Update of /project/climacs/cvsroot/papers/ilc2005/syntax
In directory common-lisp.net:/tmp/cvs-serv17307

Modified Files:
	climacssyntax.bib climacssyntax.tex 
Log Message:
One more prehistoric editor reference

Date: Fri May 20 16:44:55 2005
Author: crhodes

Index: papers/ilc2005/syntax/climacssyntax.bib
diff -u papers/ilc2005/syntax/climacssyntax.bib:1.4 papers/ilc2005/syntax/climacssyntax.bib:1.5
--- papers/ilc2005/syntax/climacssyntax.bib:1.4	Fri May 20 15:35:22 2005
+++ papers/ilc2005/syntax/climacssyntax.bib	Fri May 20 16:44:55 2005
@@ -136,4 +136,13 @@
  isbn = {0-89791-050-8},
  pages = {1--7},
  location = {Portland, Oregon, United States}},
- }
\ No newline at end of file
+ }
+
+ at inproceedings{Pike94,
+  author    = {Rob Pike},
+  title     = "{Acme: A User Interface for Programmers}",
+  booktitle = {USENIX Winter},
+  year      = {1994},
+  pages     = {223-234},
+  bibsource = {DBLP, http://dblp.uni-trier.de}
+}
\ No newline at end of file


Index: papers/ilc2005/syntax/climacssyntax.tex
diff -u papers/ilc2005/syntax/climacssyntax.tex:1.8 papers/ilc2005/syntax/climacssyntax.tex:1.9
--- papers/ilc2005/syntax/climacssyntax.tex:1.8	Fri May 20 15:35:22 2005
+++ papers/ilc2005/syntax/climacssyntax.tex	Fri May 20 16:44:55 2005
@@ -69,6 +69,7 @@
 \item some kind of interlispy/smalltalky structure editor?  
 \item Z -- the 95\% text editor \cite{woodZ}.  Note that WiB didn't
   win!
+\item Plan9 / Acme (mouse-oriented) \cite{Pike94}
 \end{itemize}
 
 Discuss lameness of emacs-like regexoid analysis in e.g. CL mode;
@@ -81,9 +82,9 @@
 \end{itemize}
 
 The Climacs text editor is a combination of frameworks for buffer
-representation and buffer contents parsing with a CLIM-based display
-engine.  It includes the Flexichain library \cite{flexichain}, which
-provides an editable sequence representation and mark (cursor)
+representation and parsing parsing, loosely coupled with a CLIM-based
+display engine.  It includes the Flexichain library \cite{flexichain},
+which provides an editable sequence representation and mark (cursor)
 management based on a circular gap buffer; and an implementation of a
 slight modification of the Earley parsing algorithm \cite{earley}, to
 assist in the creation of syntax-aware editing modes.
@@ -120,6 +121,12 @@
 only base-char objects this vector is a base-string; otherwise, it is
 unspecialized.
 
+``Protocol'' is not just an empty claim, as there are already multiple
+buffer implementations: Aleksandr Bakic's persistent buffer
+implementation, providing a cheap implementation of the undo protocol.
+(FIXME: a citation, either to something ``in preparation'' or to some
+previous description of the ideas?)
+
 \section{Syntax Protocol}
 \label{sec:syntax}
 
@@ -268,7 +275,14 @@
 Ornaments are simple to model, as they are merely modifiers to note
 objects; higher-level grouping things (beams, connecting lines) have
 their own semi-independent identity, despite not being notated as such
-in the textual \TabCode.
+in the textual \TabCode.  Beams and connecting lines can overlap
+(thinking linearly, not on the manuscript!) in non-trivial ways:
+
+\begin{verbatim}
+        [   beamed section   ]
+  word  word  word  word  word
+  ^____ line ____^
+\end{verbatim}
 
 Need whole-buffer function to present an alternative whole-system view
 on the data.  



From bmastenbrook at common-lisp.net  Sat May 21 16:32:17 2005
From: bmastenbrook at common-lisp.net (Brian Mastenbrook)
Date: Sat, 21 May 2005 18:32:17 +0200 (CEST)
Subject: [climacs-cvs] CVS update: papers/ilc2005/syntax/climacssyntax.bib
	papers/ilc2005/syntax/climacssyntax.tex 
Message-ID: <20050521163217.BE18588743@common-lisp.net>

Update of /project/climacs/cvsroot/papers/ilc2005/syntax
In directory common-lisp.net:/tmp/cvs-serv15600

Modified Files:
	climacssyntax.bib climacssyntax.tex 
Log Message:

Date: Sat May 21 18:32:16 2005
Author: bmastenbrook

Index: papers/ilc2005/syntax/climacssyntax.bib
diff -u papers/ilc2005/syntax/climacssyntax.bib:1.5 papers/ilc2005/syntax/climacssyntax.bib:1.6
--- papers/ilc2005/syntax/climacssyntax.bib:1.5	Fri May 20 16:44:55 2005
+++ papers/ilc2005/syntax/climacssyntax.bib	Sat May 21 18:32:16 2005
@@ -145,4 +145,12 @@
   year      = {1994},
   pages     = {223-234},
   bibsource = {DBLP, http://dblp.uni-trier.de}
+}
+
+ at book{FinsethCraft,
+  author = {Craig A. Finseth},
+  title = {The Craft of Text Editing},
+  publisher = {Springer-Verlag},
+  year = {1991, 1999--},
+  note = {http://www.finseth.com/craft}
 }


Index: papers/ilc2005/syntax/climacssyntax.tex
diff -u papers/ilc2005/syntax/climacssyntax.tex:1.9 papers/ilc2005/syntax/climacssyntax.tex:1.10
--- papers/ilc2005/syntax/climacssyntax.tex:1.9	Fri May 20 16:44:55 2005
+++ papers/ilc2005/syntax/climacssyntax.tex	Sat May 21 18:32:16 2005
@@ -33,7 +33,7 @@
   \affaddr{Motorola}\\
   \affaddr{1303 E. Algonquin Road}\\
   \affaddr{Schaumburg, IL, USA  60196}\\
-  \email{Brian.Mastenbrook at motorola.com}
+  \email{brian at mastenbrook.net}
 }
 
 \maketitle
@@ -58,13 +58,10 @@
 \section{Introduction}
 
 The field of advanced text editors is a crowded one, with a long
-history and an apparent ability to cause passionate argument.
-
-[ Does anyone know enough about the history of editors? ]
+history and an apparent ability to cause passionate argument. Climacs is philosophically part of the Emacs editor tradition, which has spawned many variants with many different approaches to buffer management, incremental redisplay, and syntax analysis. 
 
 \begin{itemize}
-\item ed
-\item vi (vim)
+\item TECO
 \item emacs (Zmacs) (emacs time line) \cite{greenberg}
 \item some kind of interlispy/smalltalky structure editor?  
 \item Z -- the 95\% text editor \cite{woodZ}.  Note that WiB didn't



From bmastenbrook at common-lisp.net  Sat May 21 20:14:02 2005
From: bmastenbrook at common-lisp.net (Brian Mastenbrook)
Date: Sat, 21 May 2005 22:14:02 +0200 (CEST)
Subject: [climacs-cvs] CVS update: papers/ilc2005/syntax/climacssyntax.tex 
Message-ID: <20050521201402.8AFCC88753@common-lisp.net>

Update of /project/climacs/cvsroot/papers/ilc2005/syntax
In directory common-lisp.net:/tmp/cvs-serv28137

Modified Files:
	climacssyntax.tex 
Log Message:
MORE SYNTAX

Date: Sat May 21 22:14:00 2005
Author: bmastenbrook

Index: papers/ilc2005/syntax/climacssyntax.tex
diff -u papers/ilc2005/syntax/climacssyntax.tex:1.10 papers/ilc2005/syntax/climacssyntax.tex:1.11
--- papers/ilc2005/syntax/climacssyntax.tex:1.10	Sat May 21 18:32:16 2005
+++ papers/ilc2005/syntax/climacssyntax.tex	Sat May 21 22:14:00 2005
@@ -58,33 +58,38 @@
 \section{Introduction}
 
 The field of advanced text editors is a crowded one, with a long
-history and an apparent ability to cause passionate argument. Climacs is philosophically part of the Emacs editor tradition, which has spawned many variants with many different approaches to buffer management, incremental redisplay, and syntax analysis. 
+history and an apparent ability to cause passionate argument. Climacs is philosophically part of the Emacs editor tradition, which has spawned many variants with many different approaches to buffer management, incremental redisplay, and syntax analysis. Emacs itself traces its lineage to TECO, where Emacs was originally implemented as a set of TECO macros. Climacs is compared to several interesting variants of Emacs in Table \ref{table:editorcompare}.
 
-\begin{itemize}
-\item TECO
-\item emacs (Zmacs) (emacs time line) \cite{greenberg}
-\item some kind of interlispy/smalltalky structure editor?  
-\item Z -- the 95\% text editor \cite{woodZ}.  Note that WiB didn't
-  win!
-\item Plan9 / Acme (mouse-oriented) \cite{Pike94}
-\end{itemize}
+\begin{figure*}
\begin{center}
+\begin{tabular}{|c|c|c|c|c|}
+\hline \textbf{Editor} & \textbf{Buffer Implementation} & \textbf{Syntax Analysis} & \textbf{Language}
+\\
+\hline TECO & Gap Buffer & Unknown & Assembly + TECO Macros
+\\
+\hline Zmacs & Probably doubly-linked list of lines & None & MacLisp
+\\
+\hline GNU Emacs & Gap Buffer & Regular Expressions & C + Emacs Lisp
+\\
+\hline Hemlock & Doubly-linked list of lines & None & Common Lisp
+\\
+\hline FRED & Gap Buffer & None & PPC Assembly + Common Lisp
+\\
+\hline Deuce & Doubly-linked lists of lines & Unknown & Dylan
+\\
+\hline Climacs & Multiple & Multiple & Common Lisp
+\\\hline
+\end{tabular}
+\caption{Implementation strategies of multiple Emacs variants}
\end{center}
\label{table:editorcompare}
\end{figure*}
 
-Discuss lameness of emacs-like regexoid analysis in e.g. CL mode;
-maybe mention how it falls over dramatically in perl mode (where
-context starts really mattering)
-\begin{itemize}
-\item non-locality leading to confusion in \verb+#| |#+
-\item paren-in-column-1 hack (and its workaround in docstrings:
-  \verb+\(+)
-\end{itemize}
+Climacs' syntax analysis is a flexible protocol which can be implemented with a full language lexer and parser. GNU Emacs, the most commonly used Emacs-like editor, uses regular expressions for its syntax analysis. Because these regular expressions are applied lazily and not on the whole buffer, constructs such as Common Lisp's nestable \verb+#| |#+ block comments will often confuse the regular expressions. If the parser starts after the opening \verb+#|+ then the closing \verb+|#+ will be treated as the start of an escaped symbol name. Even if the regular expression parses the whole block comment correctly, other expressions can still match on the contents of the comment, leading to issues when the first character in a column in the block comment is the start of a definition. Emacs users quickly learn to insert a space before the open paren to work around Emacs' font-lock deficiencies.
 
 The Climacs text editor is a combination of frameworks for buffer
 representation and parsing parsing, loosely coupled with a CLIM-based
 display engine.  It includes the Flexichain library \cite{flexichain},
 which provides an editable sequence representation and mark (cursor)
-management based on a circular gap buffer; and an implementation of a
+management based on a linked lists of lines, some of which are represented as a circular gap buffer; and an implementation of a
 slight modification of the Earley parsing algorithm \cite{earley}, to
-assist in the creation of syntax-aware editing modes.
+assist in the creation of syntax-aware editing modes. An application can combine a particular implementation of the buffer protocol, the syntax protocol, and its own display methods to produce a sophisticated editor for a particular language.
 
 The Climacs buffer protocol, which provides a standard interface to
 common text editor buffer operations, uses the Flexichain library; we



From rstrandh at common-lisp.net  Sun May 22 10:53:59 2005
From: rstrandh at common-lisp.net (Robert Strandh)
Date: Sun, 22 May 2005 12:53:59 +0200 (CEST)
Subject: [climacs-cvs] CVS update: papers/ilc2005/syntax/climacssyntax.tex 
Message-ID: <20050522105359.F3A29886FB@common-lisp.net>

Update of /project/climacs/cvsroot/papers/ilc2005/syntax
In directory common-lisp.net:/tmp/cvs-serv15544

Modified Files:
	climacssyntax.tex 
Log Message:
Made the description of the current buffer protocol implementation more
accurate.

Date: Sun May 22 12:53:59 2005
Author: rstrandh

Index: papers/ilc2005/syntax/climacssyntax.tex
diff -u papers/ilc2005/syntax/climacssyntax.tex:1.11 papers/ilc2005/syntax/climacssyntax.tex:1.12
--- papers/ilc2005/syntax/climacssyntax.tex:1.11	Sat May 21 22:14:00 2005
+++ papers/ilc2005/syntax/climacssyntax.tex	Sun May 22 12:53:59 2005
@@ -23,8 +23,8 @@
   \affaddr{London SE14 6NW, UK}\\
   \email{c.rhodes at gold.ac.uk}
   \alignauthor Robert Strandh\\
-  \affaddr{Equipe Image et son, LaBRI}\\
-  \affaddr{Domaine Universitaire}\\
+  \affaddr{LaBRI}\\
+  \affaddr{Universit\'{e} Bordeaux 1}\\
   \affaddr{351, cours de la Lib\'{e}ration}\\
   \affaddr{33405 Talence Cedex}
   \affaddr{FRANCE}\\
@@ -84,12 +84,16 @@
 Climacs' syntax analysis is a flexible protocol which can be implemented with a full language lexer and parser. GNU Emacs, the most commonly used Emacs-like editor, uses regular expressions for its syntax analysis. Because these regular expressions are applied lazily and not on the whole buffer, constructs such as Common Lisp's nestable \verb+#| |#+ block comments will often confuse the regular expressions. If the parser starts after the opening \verb+#|+ then the closing \verb+|#+ will be treated as the start of an escaped symbol name. Even if the regular expression parses the whole block comment correctly, other expressions can still match on the contents of the comment, leading to issues when the first character in a column in the block comment is the start of a definition. Emacs users quickly learn to insert a space before the open paren to work around Emacs' font-lock deficiencies.
 
 The Climacs text editor is a combination of frameworks for buffer
-representation and parsing parsing, loosely coupled with a CLIM-based
-display engine.  It includes the Flexichain library \cite{flexichain},
-which provides an editable sequence representation and mark (cursor)
-management based on a linked lists of lines, some of which are represented as a circular gap buffer; and an implementation of a
+representation and parsing, loosely coupled with a CLIM-based display
+engine.  It includes the Flexichain library \cite{flexichain}, which
+provides an editable sequence representation and mark (cursor)
+management using a simple linked lists used for implementing the
+buffer protocol; and an implementation of a
 slight modification of the Earley parsing algorithm \cite{earley}, to
-assist in the creation of syntax-aware editing modes. An application can combine a particular implementation of the buffer protocol, the syntax protocol, and its own display methods to produce a sophisticated editor for a particular language.
+assist in the creation of syntax-aware editing modes. An application
+can combine a particular implementation of the buffer protocol, the
+syntax protocol, and its own display methods to produce a
+sophisticated editor for a particular language.
 
 The Climacs buffer protocol, which provides a standard interface to
 common text editor buffer operations, uses the Flexichain library; we
@@ -115,13 +119,17 @@
 buffer protocol is independent of any implementation of the protocol,
 which allows flexible representations of buffers.
 
-Climacs provides an implementation of buffers as a 2-3-tree of lines.
-A line can be considered opened or closed. Editing operations are
-performed on opened lines, which are represented as a cursorchain. A
-fixed number of lines are kept opened according to a LRU scheme. When
-a line is closed it is converted to a vector. If the line contains
-only base-char objects this vector is a base-string; otherwise, it is
-unspecialized.
+The aim is for Climacs to provide several implementations of the
+buffer protocol, one of which will use a sequence of lines organized
+into a tree for quick access.  In this implementation, a line can be
+considered opened or closed. Editing operations are performed on
+opened lines, which are represented as a cursorchain (a Flexichain
+with an arbitrary number of cursors). A fixed number of lines are kept
+opened according to a LRU scheme. When a line is closed it is
+converted to a vector. If the line contains only base-char objects
+this vector is a base-string; otherwise, it is unspecialized.
+Currently, however, Climacs uses a single cursorchain for the entire
+buffer, in effect making it a simple gap-buffer implementation.  
 
 ``Protocol'' is not just an empty claim, as there are already multiple
 buffer implementations: Aleksandr Bakic's persistent buffer



From abakic at common-lisp.net  Sun May 22 11:47:27 2005
From: abakic at common-lisp.net (Aleksandar Bakic)
Date: Sun, 22 May 2005 13:47:27 +0200 (CEST)
Subject: [climacs-cvs] CVS update: papers/ilc2005/syntax/climacssyntax.tex 
Message-ID: <20050522114727.42AA5886FB@common-lisp.net>

Update of /project/climacs/cvsroot/papers/ilc2005/syntax
In directory common-lisp.net:/tmp/cvs-serv19050

Modified Files:
	climacssyntax.tex 
Log Message:
Minor fixes. I'll try to add some background/references soon.

Date: Sun May 22 13:47:26 2005
Author: abakic

Index: papers/ilc2005/syntax/climacssyntax.tex
diff -u papers/ilc2005/syntax/climacssyntax.tex:1.12 papers/ilc2005/syntax/climacssyntax.tex:1.13
--- papers/ilc2005/syntax/climacssyntax.tex:1.12	Sun May 22 12:53:59 2005
+++ papers/ilc2005/syntax/climacssyntax.tex	Sun May 22 13:47:26 2005
@@ -132,8 +132,8 @@
 buffer, in effect making it a simple gap-buffer implementation.  
 
 ``Protocol'' is not just an empty claim, as there are already multiple
-buffer implementations: Aleksandr Bakic's persistent buffer
-implementation, providing a cheap implementation of the undo protocol.
+buffer implementations: Aleksandar Bakic's persistent buffer
+implementations, providing a cheap implementation of the undo protocol.
 (FIXME: a citation, either to something ``in preparation'' or to some
 previous description of the ideas?)
 



From bmastenbrook at common-lisp.net  Mon May 23 01:00:25 2005
From: bmastenbrook at common-lisp.net (Brian Mastenbrook)
Date: Mon, 23 May 2005 03:00:25 +0200 (CEST)
Subject: [climacs-cvs] CVS update: climacs/ttcn3-syntax.lisp
	climacs/climacs.asd 
Message-ID: <20050523010025.A4B70880DF@common-lisp.net>

Update of /project/climacs/cvsroot/climacs
In directory common-lisp.net:/tmp/cvs-serv1250

Modified Files:
	climacs.asd 
Added Files:
	ttcn3-syntax.lisp 
Log Message:
Add the TTCN3 syntax

Date: Mon May 23 03:00:24 2005
Author: bmastenbrook



Index: climacs/climacs.asd
diff -u climacs/climacs.asd:1.28 climacs/climacs.asd:1.29
--- climacs/climacs.asd:1.28	Fri Apr 22 10:18:26 2005
+++ climacs/climacs.asd	Mon May 23 03:00:24 2005
@@ -64,6 +64,7 @@
    "cl-syntax"
    "html-syntax"
    "prolog-syntax"
+   "ttcn3-syntax"
    "gui"
    ;;---- optional ----
    "testing/rt"



From bmastenbrook at common-lisp.net  Mon May 23 01:05:56 2005
From: bmastenbrook at common-lisp.net (Brian Mastenbrook)
Date: Mon, 23 May 2005 03:05:56 +0200 (CEST)
Subject: [climacs-cvs] CVS update: papers/ilc2005/syntax/parserclasses.eps
	papers/ilc2005/syntax/parserclasses.pdf
	papers/ilc2005/syntax/ttcn3msc.eps
	papers/ilc2005/syntax/ttcn3msc.pdf
	papers/ilc2005/syntax/climacssyntax.tex 
Message-ID: <20050523010556.04DEC880DF@common-lisp.net>

Update of /project/climacs/cvsroot/papers/ilc2005/syntax
In directory common-lisp.net:/tmp/cvs-serv1803

Modified Files:
	climacssyntax.tex 
Added Files:
	parserclasses.eps parserclasses.pdf ttcn3msc.eps ttcn3msc.pdf 
Log Message:
Buffer protocol description; some syntax

Date: Mon May 23 03:05:55 2005
Author: bmastenbrook









Index: papers/ilc2005/syntax/climacssyntax.tex
diff -u papers/ilc2005/syntax/climacssyntax.tex:1.13 papers/ilc2005/syntax/climacssyntax.tex:1.14
--- papers/ilc2005/syntax/climacssyntax.tex:1.13	Sun May 22 13:47:26 2005
+++ papers/ilc2005/syntax/climacssyntax.tex	Mon May 23 03:05:55 2005
@@ -58,42 +58,65 @@
 \section{Introduction}
 
 The field of advanced text editors is a crowded one, with a long
-history and an apparent ability to cause passionate argument. Climacs is philosophically part of the Emacs editor tradition, which has spawned many variants with many different approaches to buffer management, incremental redisplay, and syntax analysis. Emacs itself traces its lineage to TECO, where Emacs was originally implemented as a set of TECO macros. Climacs is compared to several interesting variants of Emacs in Table \ref{table:editorcompare}.
+history and an apparent ability to cause passionate argument. Climacs
+is philosophically part of the Emacs editor tradition, which has
+spawned many variants with many different approaches to buffer
+management, incremental redisplay, and syntax analysis. Emacs itself
+traces its lineage to TECO, where Emacs was originally implemented as
+a set of TECO macros. Climacs is compared to several interesting
+variants of Emacs in Table \ref{table:editorcompare}.
 
-\begin{figure*}
\begin{center}
+\begin{figure*}
+\begin{center}
 \begin{tabular}{|c|c|c|c|c|}
 \hline \textbf{Editor} & \textbf{Buffer Implementation} & \textbf{Syntax Analysis} & \textbf{Language}
 \\
-\hline TECO & Gap Buffer & Unknown & Assembly + TECO Macros
+\hline TECO & Gap buffer & Unknown & Assembly + TECO Macros
 \\
 \hline Zmacs & Probably doubly-linked list of lines & None & MacLisp
 \\
-\hline GNU Emacs & Gap Buffer & Regular Expressions & C + Emacs Lisp
+\hline GNU Emacs & Gap buffer & Regular Expressions & C + Emacs Lisp
 \\
 \hline Hemlock & Doubly-linked list of lines & None & Common Lisp
 \\
-\hline FRED & Gap Buffer & None & PPC Assembly + Common Lisp
+\hline FRED & Gap buffer & None & PPC Assembly + Common Lisp
 \\
 \hline Deuce & Doubly-linked lists of lines & Unknown & Dylan
 \\
 \hline Climacs & Multiple & Multiple & Common Lisp
 \\\hline
 \end{tabular}
-\caption{Implementation strategies of multiple Emacs variants}
\end{center}
\label{table:editorcompare}
\end{figure*}
-
-Climacs' syntax analysis is a flexible protocol which can be implemented with a full language lexer and parser. GNU Emacs, the most commonly used Emacs-like editor, uses regular expressions for its syntax analysis. Because these regular expressions are applied lazily and not on the whole buffer, constructs such as Common Lisp's nestable \verb+#| |#+ block comments will often confuse the regular expressions. If the parser starts after the opening \verb+#|+ then the closing \verb+|#+ will be treated as the start of an escaped symbol name. Even if the regular expression parses the whole block comment correctly, other expressions can still match on the contents of the comment, leading to issues when the first character in a column in the block comment is the start of a definition. Emacs users quickly learn to insert a space before the open paren to work around Emacs' font-lock deficiencies.
+\caption{Implementation strategies of multiple Emacs variants}
+\end{center}
+\label{table:editorcompare}
+\end{figure*}
+
+Climacs' syntax analysis is a flexible protocol which can be
+implemented with a full language lexer and parser. GNU Emacs, the most
+commonly used Emacs-like editor, uses regular expressions for its
+syntax analysis. Because these regular expressions are applied lazily
+and not on the whole buffer, constructs such as Common Lisp's nestable
+\verb+#| |#+ block comments will often confuse the regular
+expressions. If the parser starts after the opening \verb+#|+ then the
+closing \verb+|#+ will be treated as the start of an escaped symbol
+name. Even if the regular expression parses the whole block comment
+correctly, other expressions can still match on the contents of the
+comment, leading to issues when the first character in a column in the
+block comment is the start of a definition. Emacs users quickly learn
+to insert a space before the open paren to work around Emacs'
+font-lock deficiencies.
 
 The Climacs text editor is a combination of frameworks for buffer
 representation and parsing, loosely coupled with a CLIM-based display
 engine.  It includes the Flexichain library \cite{flexichain}, which
 provides an editable sequence representation and mark (cursor)
 management using a simple linked lists used for implementing the
-buffer protocol; and an implementation of a
-slight modification of the Earley parsing algorithm \cite{earley}, to
-assist in the creation of syntax-aware editing modes. An application
-can combine a particular implementation of the buffer protocol, the
-syntax protocol, and its own display methods to produce a
-sophisticated editor for a particular language.
+buffer protocol; and an implementation of a slight modification of the
+Earley parsing algorithm \cite{earley}, to assist in the creation of
+syntax-aware editing modes. An application can combine a particular
+implementation of the buffer protocol, the syntax protocol, and its
+own display methods to produce a sophisticated editor for a particular
+language.
 
 The Climacs buffer protocol, which provides a standard interface to
 common text editor buffer operations, uses the Flexichain library; we
@@ -112,39 +135,119 @@
 \section{Buffer Protocol}
 \label{sec:buffer}
 
-The buffer protocol provides a set of methods for modifying and
-reading the contents of a buffer which can contain arbitrary objects.
-Typically these objects are characters, but the buffer can contain any
-object that the syntax protocol can display in the Climacs window. The
-buffer protocol is independent of any implementation of the protocol,
-which allows flexible representations of buffers.
-
-The aim is for Climacs to provide several implementations of the
-buffer protocol, one of which will use a sequence of lines organized
-into a tree for quick access.  In this implementation, a line can be
-considered opened or closed. Editing operations are performed on
-opened lines, which are represented as a cursorchain (a Flexichain
-with an arbitrary number of cursors). A fixed number of lines are kept
-opened according to a LRU scheme. When a line is closed it is
-converted to a vector. If the line contains only base-char objects
-this vector is a base-string; otherwise, it is unspecialized.
-Currently, however, Climacs uses a single cursorchain for the entire
-buffer, in effect making it a simple gap-buffer implementation.  
-
-``Protocol'' is not just an empty claim, as there are already multiple
-buffer implementations: Aleksandar Bakic's persistent buffer
-implementations, providing a cheap implementation of the undo protocol.
-(FIXME: a citation, either to something ``in preparation'' or to some
-previous description of the ideas?)
+Climacs abstracts the implementation of editable sequences as editor
+buffers using the buffer protocol. The buffer protocol provides a set
+of methods for modifying and reading the contents of a buffer, and
+setting and retrieving marks in the buffer. Buffers can contain
+arbitrary objects. Typically these objects are characters, but the
+buffer can contain any object that the syntax protocol can display in
+the Climacs window. The buffer protocol is independent of any
+implementation of the protocol, which allows flexible representations
+of buffers.
+
+Currently Climacs uses a single Flexichain ``cursorchain'' as the
+editable sequence representation for standard buffers. A cursorchain
+is a circular gap buffer with an arbitrary number of cursors in the
+buffer. Climacs uses these cursors as the implementation of marks in
+the buffer. The single gap-buffer implementation is used by many other
+editors, including GNU Emacs. Flexichain improves on this by making
+the gap buffer circular in its underlying representation; the start of
+the sequence is stored in a separate slot, along with the beginning of
+the gap.
+
+Climacs also provides a buffer implementation utilizing functional
+data structures as the editable sequence representation. This buffer
+implementation provides a low-cost implementation of undo along
+multiple edit histories. (FIXME: a citation, either to something ``in
+preparation'' or to some previous description of the ideas? It would
+help if someone with more understanding than I of this buffer
+implementation would sketch this out.)
+
+Climacs is intended to provide other buffer implementations, one of
+which will use a sequence of lines organized into a tree for quick
+access. In this structure, a line can be considered opened or
+closed. When a line is opened, it is represented as a Flexichain
+cursorchain. All editing operations are performed on open lines. A
+fixed number of lines are kept opened according to a
+least-recently-used scheme. When a line is closed it is converted to a
+vector for efficient storage and access. If the line contains only
+base-char objects this vector is a base-string; otherwise, it is
+unspecialized.
+
+This structure has the advantage of efficient line-based access in the
+buffer. It also provides much less pessimistic behavior than that of a
+single gap buffer when a user is editing two disparate sections in a
+large file. With a single gap buffer, the gap must be moved to the
+point of edit before an edit operation is allowed. When the buffer is
+large and edit operations occur frequently at multiple locations in
+the buffer, this requires a substantial amount of copying between
+edits. In this situation single-gap-buffer editors like Emacs will
+noticably pause between edits to move the gap. A structure which
+contains a sequence of lines and keeps the most recently used lines
+open as gap buffers can operate as a multi-gap buffer with automatic
+gap placement, while not providing pessimistic performance when
+accessing a specific line in the buffer.
+
+The efficiency of Climacs buffers depends greatly on the
+implementation of the buffer protocol that is used. Space efficiency
+will also depend on the implementation of Common Lisp which is used to
+run Climacs. In Steel Bank Common Lisp, the type character is
+represented with the full 22 bits used by the Unicode character
+space. External character encodings other than Unicode are converted
+to Unicode when a file is read in to memory. If the characters are
+stored in a specialized array, this will net a worst case space
+efficiency of four bytes of every byte in the file. However, the time
+advantages of this representation outweigh the space
+inefficiency. Searching for an individual character in a sequence of
+characters encoded in UTF-8 is $O(n)$, because each individual
+character must be examined to determine the number of octets which are
+stored to represent that character.
+
+The Flexichain library uses an unspecialized vector for its storage,
+which uses one machine word per element, either as an immediate value
+or as a pointer to a larger element. Climacs buffers can contain any
+object, so in a suitably complex syntax and buffer protocol
+implementation an object in a buffer may 
 
 \section{Syntax Protocol}
 \label{sec:syntax}
 
-A syntax in Climacs is an incremental parser which creates and updates
-a parse tree of a buffer's contents, and provides a mechanism for
-drawing these parsed objects in a window. The parser accepts lexemes
-produced by an incremental lexical analyzer associated with the
-syntax.
+\begin{figure*}
+  \begin{center}
+    \includegraphics{parserclasses}
+    \caption{Organization of classes used by a typical syntax}
+    \label{fig:syntaxclasses}
+  \end{center}
+\end{figure*}
+
+Climacs is designed to allow multiple implementation strategies for
+buffer parsers and syntax-aware display mechanisms. The set of hooks
+that Climacs provides to allow this is the syntax protocol. A syntax
+in Climacs is a class and set of methods which provide a lexical
+analyzer, parser, and display methods for a buffer. The incremental
+parser associated with a syntax creates and updates a parse tree of a
+buffer's contents, and provides a mechanism for drawing these parsed
+objects in a window. The parser accepts lexemes produced by an
+incremental lexical analyzer. Display is handled by drawing methods
+implemented using the CLIM high-level display toolkit.
+
+Though a syntax is free to choose its own implementation strategy,
+lexical analysis and parsing of the buffer is typically done in an
+object-oriented fashion. The lexer operates on objects in the buffer,
+usually characters, and returns objects of various classes. Each
+parser production is represented by a class. In complex syntaxes, the
+parser rules can be quite complicated and involve arbitrary code, but
+for a simple grammar the parsing rules can be entirely represented by
+matching on the classes returned by the tokenizer and parser. Figure
+\ref{fig:syntaxclasses} shows the organization of classes in the TTCN3
+grammar.
+
+Climacs provides an Earley parser \cite{earley} which is sufficient to
+parse most context-free grammars. Earley parser: discussion of
+generality and asymptotic efficiency (in general and for usual cases).
+Possibility of replacement in case of complicated grammars?  (What was
+that parsing algorithm that someone mentioned on \verb+#lisp+?
+\textit{I have no idea.})
 
 The syntax analysis can be applied either in a per-window or
 per-buffer function. The per-window approach is best suited to
@@ -154,11 +257,6 @@
 approach is appropriate when the parse tree will also be used for some
 other display or analysis of the text in the buffer.
 
-Earley parser: discussion of generality and asymptotic efficiency (in
-general and for usual cases).  Possibility of replacement in case of
-complicated grammars?  (What was that parsing algorithm that someone
-mentioned on \verb+#lisp+?)
-
 \section{Syntaxes}
 \label{sec:syntaxes}
 
@@ -186,7 +284,7 @@
 Christophe might want to describe the Prolog syntax a bit here. In
 particular any details having to do with the implementation of
 operator precedence as specified in the ISO Prolog standard might be
-interesting.  
+interesting.
 
 [ Maybe just the \textit{priority} stuff? I think that's
 the only interesting bit of non-context-freeness; user-defined
@@ -209,6 +307,12 @@
 slightly-buggy or incomplete syntax mode will render the whole thing
 useless.  Violation of WiB?
 
+The Testing and Test Control Notation 3 (TTCN3) language is a language
+which captures detailed test specifications. TTCN provides both a
+textual ``core'' grammar and a graphical presentation format similar
+to Message Sequence Charts (see figure \ref{fig:ttcn3gr}). Climacs
+currently provides an editor for a subset of the TTCN3 core language.
+
 The TTCN3 syntax is implemented with a high-level macro which defines
 classes and adds syntax rules using the syntax protocol for each
 terminal and non-terminal in the grammar. The syntax of this macro
@@ -218,6 +322,20 @@
 receive their own non-terminal entry in the grammar. In addition, this
 macro defines basic display functions for the syntax objects produced
 by the parser, with language keywords appearing in a separate color.
+
+\begin{figure*}
+  \begin{center}
+    \parbox{0.45\linewidth}{\includegraphics{ttcn3msc}}
+    \parbox{0.25\linewidth}{\texttt{\\ [1cm]\noindent
+        testcase MyTestCase (inout integer MyPar)\\
+        runs on MyMTCtype system SystemType \{\\
+        var integer MyVar := 1;\\
+        MyMTCPort.send(MyTemplate);\\
+        \}}}
+    \caption{A fragment of TTCN3 and its corresponding Graphical Representation (GR)}
+    \label{fig:ttcn3gr}
+  \end{center}
+\end{figure*}
 
 \subsection{Per-Buffer Syntax: a tablature editor}
 \label{sec:tabeditor}



From rstrandh at common-lisp.net  Mon May 23 04:06:40 2005
From: rstrandh at common-lisp.net (Robert Strandh)
Date: Mon, 23 May 2005 06:06:40 +0200 (CEST)
Subject: [climacs-cvs] CVS update: papers/ilc2005/syntax/climacssyntax.tex 
Message-ID: <20050523040640.E5CBE88726@common-lisp.net>

Update of /project/climacs/cvsroot/papers/ilc2005/syntax
In directory common-lisp.net:/tmp/cvs-serv12718

Modified Files:
	climacssyntax.tex 
Log Message:
Corrected some statements about the current implementation that were
incorrect.  Added conclusions and future work. 


Date: Mon May 23 06:06:40 2005
Author: rstrandh

Index: papers/ilc2005/syntax/climacssyntax.tex
diff -u papers/ilc2005/syntax/climacssyntax.tex:1.14 papers/ilc2005/syntax/climacssyntax.tex:1.15
--- papers/ilc2005/syntax/climacssyntax.tex:1.14	Mon May 23 03:05:55 2005
+++ papers/ilc2005/syntax/climacssyntax.tex	Mon May 23 06:06:39 2005
@@ -42,7 +42,7 @@
   The Climacs text editor is a CLIM implementation of a text editor in
   the Emacs tradition.  Climacs was designed to allow for incremental
   parsing of the buffer contents, so that a sophisticated analysis of
-  the buffer contents can be performed without impacting performance.
+  the contents can be performed without impacting performance.
   We describe two different syntax modules: a module for a
   sequentially-defined syntax of a typical programming language, doing
   the bulk of its parsing in a per-window function; and an interactive
@@ -103,20 +103,21 @@
 correctly, other expressions can still match on the contents of the
 comment, leading to issues when the first character in a column in the
 block comment is the start of a definition. Emacs users quickly learn
-to insert a space before the open paren to work around Emacs'
+to insert a space before the open parenthesis to work around Emacs'
 font-lock deficiencies.
 
 The Climacs text editor is a combination of frameworks for buffer
 representation and parsing, loosely coupled with a CLIM-based display
 engine.  It includes the Flexichain library \cite{flexichain}, which
 provides an editable sequence representation and mark (cursor)
-management using a simple linked lists used for implementing the
-buffer protocol; and an implementation of a slight modification of the
-Earley parsing algorithm \cite{earley}, to assist in the creation of
-syntax-aware editing modes. An application can combine a particular
-implementation of the buffer protocol, the syntax protocol, and its
-own display methods to produce a sophisticated editor for a particular
-language.
+management using a simple linked list for implementing the buffer
+protocol.  Climacs also includes an implementation of a slight
+modification of the Earley parsing algorithm \cite{earley}, to assist
+in the creation of syntax-aware editing modes, though such modes can
+use any appropriate parsing algorithm.  An application can combine a
+particular implementation of the buffer protocol, the syntax protocol,
+and its own display methods to produce a sophisticated editor for a
+particular language.
 
 The Climacs buffer protocol, which provides a standard interface to
 common text editor buffer operations, uses the Flexichain library; we
@@ -125,7 +126,7 @@
 provides a method for interfacing a lexical analyzer and parser with
 the text editor, and provides for defining methods to draw syntax
 objects in the Climacs window.  In section \ref{sec:syntaxes} we
-discuss the implementation of syntactic analysis for various
+discuss the implementation of syntactic analyses for various
 programming languages, including Common Lisp; in section
 \ref{sec:tabeditor}, we discuss an application with Climacs at its
 core to support editing a textual representation of lute tablature.
@@ -257,6 +258,36 @@
 approach is appropriate when the parse tree will also be used for some
 other display or analysis of the text in the buffer.
 
+Climacs includes a parser that uses the Earley \cite{earley} parsing
+algorithm.  There are many advantages of this algorithm in the context
+of text editing.  Perhaps most importantly, it does not require any
+preprocessing of the grammar, which makes it necessary for the entire
+grammar to be known ahead of time.  This means that the user can
+load Lisp files containing additional syntax rules to complete the
+existing ones without having to apply any costly grammar analysis.
+Other advantages include the possibility of using ambiguous grammars,
+since the Earley parsing algorithm accepts the full class of
+context-free grammars.  This feature is crucial in certain
+applications, for instance in a grammar checker for natural
+languages.  The Climacs syntax protocol can, but is not required
+to, use the provided Earley parser.  It can use any algorithm with an
+explicit representation of the parser state, which is a necessary, but
+not sufficient, requirement for making the parsing algorithm
+incremental. 
+
+However, the Earley parsing algorithm is relatively slow compared to
+table-based algorithms such as the LR shift/reduce algorithm.
+Worst-case complexity is $O(n^3)$ where $n$ is the size of the input.
+It drops to $O(n^2)$ for unambiguous grammars and to $O(n)$ for a
+large class of grammars suitable for parsing programming langauges.
+Even so, the complexity is often proportional to the size of the
+grammar (which is considered a constant by Earley), which can be
+problematic in a text editor.  We have yet to determine whether the
+implementation of the Earley algorithm that we provide will turn out
+to be sufficiently fast for most Climacs syntax modules.  Other
+possibilities include the Tomita parsing algorithm which provides more
+generality than LR, but which is nearly as fast in most cases. 
+
 \section{Syntaxes}
 \label{sec:syntaxes}
 
@@ -428,8 +459,55 @@
 \section{Future Work and Conclusions}
 \label{sec:conclusions}
 
-I like Jello.  Jello is good.  We should enable people to make better
-Jello.
+Given the relatively small amount of work (only a few person-months)
+that has been put into Climacs so far, it is already a very competent
+and stable editor.  Using CLIM (and in particular the McCLIM
+implementation) as the display engine has allowed the project to
+progress much more rapidly than what would have been possible
+otherwise.  However, Climacs has also revealed some serious
+limitations and performance problems of the McCLIM library.  We
+maintain that using CLIM and McCLIM was the best choice, and in fact
+advantageous to other McCLIM users as well, since work is being done
+to correct and improve it for use with Climacs. 
+
+Due to its reliance on fairly well-defined protocols, the Climacs text
+editor framework is flexible enough to allow for different future
+directions.  Turning the Common Lisp syntax module into an excellent
+programming tool for Lisp programmers is high on the list of
+priorities, for many reasons.  First, it will encourage further work
+on Climacs.  Second, the Common Lisp syntax module is likely to become
+one of the more advanced ones to exist for Climacs, given that Climacs
+has unique and direct access to the features of the underlying Common
+Lisp implementation.  Thus, the Common Lisp syntax module is likely to
+exercise the Climacs protocols to a very high degree.  This will allow
+us to improve those protocols as well as their corresponding
+implementations. 
+
+Another future direction high up on the list of priorites is the
+planned implementation of the buffer protocol.  Representing a line
+being editied as a flexichain can greatly improve the performance of
+some crucial operations that currently require looping over each
+buffer object until a newline character is found.  Other operations
+that are currently prohibitive include knowing the line- and column
+number of a given mark. 
+
+However, our plans for Climacs go further than creating an improved
+implementation of Emacs.  We intend to make Climacs a fully-integrated
+CLIM application.  This implies among other things using the
+presentation-type system of CLIM to exchange objects between Climacs
+and other CLIM appliations such as an inspector application, a
+debugger pane, etc.  We also hope that implementors of other CLIM
+applications such as mail readers, news readers, etc, will consider
+using Climacs for creating messages.
+
+We are often asked whether applications such as VM and Gnus for GNU
+Emacs will be available for Climacs.  Our opinion is that such
+applications currenltly run as GNU Emacs subsystems, simply because
+GNU Emacs does not have an independent substrate such as CLIM for
+creating user interfaces.  Climacs is itself a CLIM application, and
+applications such as mail readers and news readers that do not require
+editable buffers should instead be implemented directly as CLIM
+applications, perhaps calling Climacs to write messages.
 
 \nocite{*}
 



From crhodes at common-lisp.net  Mon May 23 10:21:43 2005
From: crhodes at common-lisp.net (Christophe Rhodes)
Date: Mon, 23 May 2005 12:21:43 +0200 (CEST)
Subject: [climacs-cvs] CVS update: papers/ilc2005/syntax/climacssyntax.bib
	papers/ilc2005/syntax/climacssyntax.tex 
Message-ID: <20050523102143.1E3D188704@common-lisp.net>

Update of /project/climacs/cvsroot/papers/ilc2005/syntax
In directory common-lisp.net:/tmp/cvs-serv2490

Modified Files:
	climacssyntax.bib climacssyntax.tex 
Log Message:
Mostly describe Prolog syntax.  One or two fixups

Date: Mon May 23 12:21:41 2005
Author: crhodes

Index: papers/ilc2005/syntax/climacssyntax.bib
diff -u papers/ilc2005/syntax/climacssyntax.bib:1.6 papers/ilc2005/syntax/climacssyntax.bib:1.7
--- papers/ilc2005/syntax/climacssyntax.bib:1.6	Sat May 21 18:32:16 2005
+++ papers/ilc2005/syntax/climacssyntax.bib	Mon May 23 12:21:41 2005
@@ -153,4 +153,18 @@
   publisher = {Springer-Verlag},
   year = {1991, 1999--},
   note = {http://www.finseth.com/craft}
-}
\ No newline at end of file
+}
+
+ at Manual{ISOProlog,
+  title = 	 "{Information technology -- Programming languages -- Prolog -- Part 1: General core}",
+  key = 	 {ISO/IEC 13211-1:1995},
+  OPTauthor = 	 {},
+  organization = {ISO},
+  OPTaddress = 	 {},
+  OPTedition = 	 {},
+  OPTmonth = 	 {},
+  year = 	 {1995},
+  OPTnote = 	 {},
+  OPTannote = 	 {}
+}
+


Index: papers/ilc2005/syntax/climacssyntax.tex
diff -u papers/ilc2005/syntax/climacssyntax.tex:1.15 papers/ilc2005/syntax/climacssyntax.tex:1.16
--- papers/ilc2005/syntax/climacssyntax.tex:1.15	Mon May 23 06:06:39 2005
+++ papers/ilc2005/syntax/climacssyntax.tex	Mon May 23 12:21:41 2005
@@ -61,10 +61,13 @@
 history and an apparent ability to cause passionate argument. Climacs
 is philosophically part of the Emacs editor tradition, which has
 spawned many variants with many different approaches to buffer
-management, incremental redisplay, and syntax analysis. Emacs itself
+management, incremental redisplay, and syntax analysis.  Emacs itself
 traces its lineage to TECO, where Emacs was originally implemented as
-a set of TECO macros. Climacs is compared to several interesting
-variants of Emacs in Table \ref{table:editorcompare}.
+a set of TECO macros.  Climacs is compared to several interesting
+variants of Emacs in Table \ref{table:editorcompare}; more information
+about text editing in general, and some editors we shall not discuss
+further, can be found in \cite{FinsethCraft,greenberg,Pike94,woodZ}
+and references therein.
 
 \begin{figure*}
 \begin{center}
@@ -107,17 +110,17 @@
 font-lock deficiencies.
 
 The Climacs text editor is a combination of frameworks for buffer
-representation and parsing, loosely coupled with a CLIM-based display
-engine.  It includes the Flexichain library \cite{flexichain}, which
-provides an editable sequence representation and mark (cursor)
-management using a simple linked list for implementing the buffer
-protocol.  Climacs also includes an implementation of a slight
-modification of the Earley parsing algorithm \cite{earley}, to assist
-in the creation of syntax-aware editing modes, though such modes can
-use any appropriate parsing algorithm.  An application can combine a
-particular implementation of the buffer protocol, the syntax protocol,
-and its own display methods to produce a sophisticated editor for a
-particular language.
+representation and parsing, loosely coupled with a CLIM-based
+\cite{mckayacm} display engine.  It includes the Flexichain library
+\cite{flexichain}, which provides an editable sequence representation
+and mark (cursor) management using a simple linked list for
+implementing the buffer protocol.  Climacs also includes an
+implementation of a slight modification of the Earley parsing
+algorithm \cite{earley}, to assist in the creation of syntax-aware
+editing modes, though such modes can use any appropriate parsing
+algorithm.  An application can combine a particular implementation of
+the buffer protocol, the syntax protocol, and its own display methods
+to produce a sophisticated editor for a particular language.
 
 The Climacs buffer protocol, which provides a standard interface to
 common text editor buffer operations, uses the Flexichain library; we
@@ -182,8 +185,8 @@
 point of edit before an edit operation is allowed. When the buffer is
 large and edit operations occur frequently at multiple locations in
 the buffer, this requires a substantial amount of copying between
-edits. In this situation single-gap-buffer editors like Emacs will
-noticably pause between edits to move the gap. A structure which
+edits. In this situation single-gap-buffer editors such as GNU Emacs
+will noticably pause between edits to move the gap. A structure which
 contains a sequence of lines and keeps the most recently used lines
 open as gap buffers can operate as a multi-gap buffer with automatic
 gap placement, while not providing pessimistic performance when
@@ -193,14 +196,14 @@
 implementation of the buffer protocol that is used. Space efficiency
 will also depend on the implementation of Common Lisp which is used to
 run Climacs. In Steel Bank Common Lisp, the type character is
-represented with the full 22 bits used by the Unicode character
-space. External character encodings other than Unicode are converted
-to Unicode when a file is read in to memory. If the characters are
-stored in a specialized array, this will net a worst case space
-efficiency of four bytes of every byte in the file. However, the time
-advantages of this representation outweigh the space
-inefficiency. Searching for an individual character in a sequence of
-characters encoded in UTF-8 is $O(n)$, because each individual
+represented with the full 21 bits used by the Unicode character space.
+External character encodings other than Unicode are converted to
+UTF-32 when a file is read in to memory.  If the characters are stored
+in a specialized array, this will net a worst case space efficiency of
+four bytes of every byte in the file. However, the time advantages of
+this representation outweigh the space inefficiency.  Searching for an
+individual character in a sequence of characters encoded in UTF-8 (or
+other variable-length encoding) is $O(n)$, because each individual
 character must be examined to determine the number of octets which are
 stored to represent that character.
 
@@ -208,7 +211,7 @@
 which uses one machine word per element, either as an immediate value
 or as a pointer to a larger element. Climacs buffers can contain any
 object, so in a suitably complex syntax and buffer protocol
-implementation an object in a buffer may 
+implementation an object in a buffer may ... may what?  FIXME
 
 \section{Syntax Protocol}
 \label{sec:syntax}
@@ -243,13 +246,6 @@
 \ref{fig:syntaxclasses} shows the organization of classes in the TTCN3
 grammar.
 
-Climacs provides an Earley parser \cite{earley} which is sufficient to
-parse most context-free grammars. Earley parser: discussion of
-generality and asymptotic efficiency (in general and for usual cases).
-Possibility of replacement in case of complicated grammars?  (What was
-that parsing algorithm that someone mentioned on \verb+#lisp+?
-\textit{I have no idea.})
-
 The syntax analysis can be applied either in a per-window or
 per-buffer function. The per-window approach is best suited to
 analysis of text where the parse tree will be used only for display
@@ -286,18 +282,19 @@
 implementation of the Earley algorithm that we provide will turn out
 to be sufficiently fast for most Climacs syntax modules.  Other
 possibilities include the Tomita parsing algorithm which provides more
-generality than LR, but which is nearly as fast in most cases. 
+generality than LR, but which is nearly as fast in most cases.
 
 \section{Syntaxes}
 \label{sec:syntaxes}
 
 We describe two different approaches to syntax analysis in the Climacs
 editor. Per-window parsing is used by the provided modes for HTML,
-Common Lisp, Prolog, and TTCN3. Each of these syntaxes is implemented
-with the provided Earley parser \cite{earley}. The lute tablature
-editor uses a per-buffer function for its syntax analysis and
-implements a simple recursive-descent parsing algorithm.  (FIXME: is
-this true?  I don't know enough about parsing)
+Common Lisp, Prolog, and a Testing Control Notation (TTCN3).  Each of
+these syntaxes is implemented with the provided Earley parser
+\cite{earley}.  The lute tablature editor uses a per-buffer function
+for its syntax analysis and implements a simple recursive-descent
+parsing algorithm.  (FIXME: is this true?  I don't know enough about
+parsing)
 
 \subsection{Per-Window Syntaxes}
 
@@ -312,25 +309,35 @@
 rules to accommodate the level of analysis to parse the language's
 grammar.
 
-Christophe might want to describe the Prolog syntax a bit here. In
-particular any details having to do with the implementation of
-operator precedence as specified in the ISO Prolog standard might be
-interesting.
-
-[ Maybe just the \textit{priority} stuff? I think that's
-the only interesting bit of non-context-freeness; user-defined
-operators is OK because you can't actually define and use a new
-operator in the same directive. ]
-
-Float tokenizer (not interesting, but not yet done)
-
-Need for inheritable grammars / tokenizers: most Prologs deviate from
-ISO slightly, mostly in surface syntax rather than in the engine.
-Examples: \verb+"ab\x011\"+, \texttt{0'''}, \texttt{[H|T]} when
-\texttt{|} is an operator.
-
-Possibility (probably ``Future Work'') to make nice integrated Prolog
-environment.
+Implementing the Prolog syntax proved a good test of the established
+framework.  Firstly, and most importantly, ISO Prolog \cite{ISOProlog}
+is not a context-free grammar: \textit{terms} have an implicit
+priority affecting their parse.\footnote{Formally, the grammar could
+  be made context-free by introducing 1200 new production rules.}  The
+implementation of Earley's algorithm, however, was able to address
+this additional complexity with no difficulty.
+
+Another area of difficulty is the fact that parsing a Prolog text can
+change the grammar itself through the use of the \texttt{op/3}
+directive: including
+\begin{verbatim}
+  :- op(100,xfy,<>).
+\end{verbatim}
+in a Prolog text means that, after parsing this directive, the token
+\texttt{<>} must be recognized as an right-associative operator with
+priority 100 in the grammar.  This is achievable by keeping a cache of
+parsed \texttt{op/3} directives, and maintaining and invalidating it
+in parallel with the parse of the buffer itself.
+
+While the Prolog syntax included with Climacs is a demonstration of
+the potential of strongly syntax-aware editors, it is not yet a
+practical tool for Prolog programmers, as most implementations of
+Prolog deviate from strict ISO compliance.  On the level of surface
+syntax, interpretation of quoting rules and escape sequences in
+strings are very variable, while additionally treatment of operators
+in currently-available Prologs can differ markedly from the standard
+requirements.  Nevertheless, work is underway to use Climacs' syntax
+analysis to provide a front-end for a Prolog development environment.
 
 At present, one parse error implies the invalidation of the rest of
 the file.  This adds a burden on the mode implementor that the syntax
@@ -410,20 +417,20 @@
   \end{center}
 \end{figure*}
 
-\TabCode\ is a textual format for description of lute tablature.  In
-its simplest form, it is a sequence of whitespace-delimited
-independent words, where each word represents either a set of frets to
-depress and strings to be sounded, or alternatively some element of
-musical notation (such as a barline); figure \ref{fig:besfantlach}
-demonstrates a fragment of manuscript, and its \TabCode\ encoding.  It
-is also possible to encode more complex elements of lute tablature
-notation in \TabCode: ornaments, fingering marks, beaming, connecting
-lines and other complex elements can all be accommodated (see figure
-\ref{fig:barley} for examples of more these more complex elements).
-
-\TabCode\ has been used to produce scholarly editions of lute works
-\cite{Weiss} and to computer-based musicological studies (as in
-\cite{ecolm-graz} for example).  
+\TabCode\ \cite{tabcode} is a textual format for description of lute
+tablature.  In its simplest form, it is a sequence of
+whitespace-delimited independent words, where each word represents
+either a set of frets to depress and strings to be sounded, or
+alternatively some element of musical notation (such as a barline);
+figure \ref{fig:besfantlach} demonstrates a fragment of manuscript,
+and its \TabCode\ encoding.  It is also possible to encode more
+complex elements of lute tablature notation in \TabCode: ornaments,
+fingering marks, beaming, connecting lines and other complex elements
+can all be accommodated (see figure \ref{fig:barley} for examples of
+some of these more complex elements).  \TabCode\ has been used to
+produce scholarly editions of lute works \cite{Weiss} and to assist in
+computer-based musicological studies (as in \cite{ecolm-graz} for
+example).
 
 \TabCode\ has a rather ad-hoc cobbled together grammar.  Tokenising is
 easy; determining which elements of the notation are best captured is
@@ -462,13 +469,14 @@
 Given the relatively small amount of work (only a few person-months)
 that has been put into Climacs so far, it is already a very competent
 and stable editor.  Using CLIM (and in particular the McCLIM
-implementation) as the display engine has allowed the project to
-progress much more rapidly than what would have been possible
-otherwise.  However, Climacs has also revealed some serious
-limitations and performance problems of the McCLIM library.  We
-maintain that using CLIM and McCLIM was the best choice, and in fact
-advantageous to other McCLIM users as well, since work is being done
-to correct and improve it for use with Climacs. 
+\cite{ilc2002-moore} implementation) as the display engine has allowed
+the project to progress much more rapidly than would otherwise have
+been possible.  However, Climacs development has also revealed some
+serious limitations and performance problems of the McCLIM library.
+Nevertheless, we maintain that using CLIM and McCLIM was the best
+choice, and in fact advantageous to other McCLIM users as well, as the
+deficiencies in McCLIM implementation are being addressed and other
+improvements made for use with Climacs.
 
 Due to its reliance on fairly well-defined protocols, the Climacs text
 editor framework is flexible enough to allow for different future
@@ -483,7 +491,7 @@
 us to improve those protocols as well as their corresponding
 implementations. 
 
-Another future direction high up on the list of priorites is the
+Another future direction high up on the list of priorities is the
 planned implementation of the buffer protocol.  Representing a line
 being editied as a flexichain can greatly improve the performance of
 some crucial operations that currently require looping over each
@@ -491,7 +499,14 @@
 that are currently prohibitive include knowing the line- and column
 number of a given mark. 
 
-However, our plans for Climacs go further than creating an improved
+One disadvantage of the current parsing scheme is that a single parse
+error prevents analysis of the rest of the buffer, which is
+potentially disturbing to a user's workflow.  For relatively simple
+grammars such as \TabCode, it is simple enough to resynchronize at the
+next token, whereas for more complex grammars the resolution is less
+clear.
+
+Our plans for Climacs go further than creating an improved
 implementation of Emacs.  We intend to make Climacs a fully-integrated
 CLIM application.  This implies among other things using the
 presentation-type system of CLIM to exchange objects between Climacs
@@ -502,19 +517,20 @@
 
 We are often asked whether applications such as VM and Gnus for GNU
 Emacs will be available for Climacs.  Our opinion is that such
-applications currenltly run as GNU Emacs subsystems, simply because
-GNU Emacs does not have an independent substrate such as CLIM for
-creating user interfaces.  Climacs is itself a CLIM application, and
+applications currently run as GNU Emacs subsystems simply because GNU
+Emacs does not have an independent substrate such as CLIM for creating
+user interfaces.  Climacs is itself a CLIM application, and
 applications such as mail readers and news readers that do not require
 editable buffers should instead be implemented directly as CLIM
 applications, perhaps calling Climacs to write messages.
 
-\nocite{*}
+%\nocite{*}
 
 \section*{Acknowledgments}
 
-C.R. is supported by EPSRC grant GR/\-S84750/\-01.  B.M. acknowledges
-Motorola's generous support.
+The authors wish to thank Aleksandr Bakic for fruitful discussions.
+B.M.\ acknowledges Motorola's generous support.  C.R.\ is supported by
+EPSRC grant GR/\-S84750/\-01.
 
 \bibliographystyle{acm}
 \bibliography{climacssyntax}



From crhodes at common-lisp.net  Mon May 23 11:34:59 2005
From: crhodes at common-lisp.net (Christophe Rhodes)
Date: Mon, 23 May 2005 13:34:59 +0200 (CEST)
Subject: [climacs-cvs] CVS update: papers/ilc2005/syntax/boardfig.eps
	papers/ilc2005/syntax/boardfig.pdf
	papers/ilc2005/syntax/climacssyntax.bib
	papers/ilc2005/syntax/climacssyntax.tex 
Message-ID: <20050523113459.EE91388704@common-lisp.net>

Update of /project/climacs/cvsroot/papers/ilc2005/syntax
In directory common-lisp.net:/tmp/cvs-serv6888

Modified Files:
	climacssyntax.bib climacssyntax.tex 
Added Files:
	boardfig.eps boardfig.pdf 
Log Message:
Initial stab at describing interesting bits of the tabeditor

Date: Mon May 23 13:34:58 2005
Author: crhodes





Index: papers/ilc2005/syntax/climacssyntax.bib
diff -u papers/ilc2005/syntax/climacssyntax.bib:1.7 papers/ilc2005/syntax/climacssyntax.bib:1.8
--- papers/ilc2005/syntax/climacssyntax.bib:1.7	Mon May 23 12:21:41 2005
+++ papers/ilc2005/syntax/climacssyntax.bib	Mon May 23 13:34:58 2005
@@ -149,14 +149,14 @@
 
 @book{FinsethCraft,
   author = {Craig A. Finseth},
-  title = {The Craft of Text Editing},
+  title = "{The Craft of Text Editing}",
   publisher = {Springer-Verlag},
   year = {1991, 1999--},
   note = {http://www.finseth.com/craft}
 }
 
 @Manual{ISOProlog,
-  title = 	 "{Information technology -- Programming languages -- Prolog -- Part 1: General core}",
+  title = 	 "{Prolog -- Part 1: General core}",
   key = 	 {ISO/IEC 13211-1:1995},
   OPTauthor = 	 {},
   organization = {ISO},
@@ -165,6 +165,16 @@
   OPTmonth = 	 {},
   year = 	 {1995},
   OPTnote = 	 {},
+  OPTannote = 	 {}
+}
+
+ at Unpublished{tabxml,
+  author = 	 {Frans Wiering and Tim Crawford and David Lewis},
+  title = 	 "{Creating an XML vocabulary for encoding lute music}",
+  note = 	 {In preparation},
+  OPTkey = 	 {},
+  OPTmonth = 	 {},
+  OPTyear = 	 {},
   OPTannote = 	 {}
 }
 


Index: papers/ilc2005/syntax/climacssyntax.tex
diff -u papers/ilc2005/syntax/climacssyntax.tex:1.16 papers/ilc2005/syntax/climacssyntax.tex:1.17
--- papers/ilc2005/syntax/climacssyntax.tex:1.16	Mon May 23 12:21:41 2005
+++ papers/ilc2005/syntax/climacssyntax.tex	Mon May 23 13:34:58 2005
@@ -432,36 +432,72 @@
 computer-based musicological studies (as in \cite{ecolm-graz} for
 example).
 
-\TabCode\ has a rather ad-hoc cobbled together grammar.  Tokenising is
-easy; determining which elements of the notation are best captured is
-not so easy.  Chords, obviously; beams, comments...  Should we try to
-capture a BNF or something?  I suppose it depends how we're doing for
-space.
-
-Ornaments are simple to model, as they are merely modifiers to note
-objects; higher-level grouping things (beams, connecting lines) have
-their own semi-independent identity, despite not being notated as such
-in the textual \TabCode.  Beams and connecting lines can overlap
-(thinking linearly, not on the manuscript!) in non-trivial ways:
-
-\begin{verbatim}
-        [   beamed section   ]
-  word  word  word  word  word
-  ^____ line ____^
-\end{verbatim}
-
-Need whole-buffer function to present an alternative whole-system view
-on the data.  
-
-Editor is in use for cataloguing European lute music, and supports
-research into more advanced notations (for e.g. editorial comment, or
-manuscript markup)
-
-Efficiency concerns assuaged by typical locality of edit, CLIM
-incremental redisplay on the tablature buffer.
-
-MIDI feedback.  At present, based on Apple's extremely badly
-documented CoreMIDI framework; a port to alsalib is on the cards.
+The \TabCode\ language itself has developed to provide a terse and
+intuitive encoding of tablature, rather than a well-formed grammar for
+parsing.  Simple \TabCode, as in figure \ref{fig:besfantlach},
+presents no problems: each chord is an optional rhythm sign (a capital
+letter), followed by zero or more notes as fret--string pairs
+(letter--number combinations).  Adding ornaments and fingering marks
+to this structure is simple, as they are merely optional modifiers to
+each note, and can be parsed as such.
+
+\begin{figure}
+  \begin{center}
+    \includegraphics{boardfig}
+    \caption{Extract from 'An Almand by mr Jo Dowland Bacheler of
+      musique', \textit{The Board Lute Book} (GB:Lam MS 603), f.13.
+      Note in particular the connecting lines in this bar, joining
+      chords within beams to an unbeamed chord.}
+    \label{fig:board}
+  \end{center}
+\end{figure}
+
+More complex to model are beams and connecting lines, which have their
+own semi-independent identity, despite being encoded in \TabCode\ as
+modifiers to individual tokens.  In particular, the existence of beams
+and connecting lines means that we cannot parse a buffer into a
+sequence of tabwords and thence into hypothetical higher-level
+structures such as \texttt{beamed-group} and \texttt{connected-pair},
+because these higher-level structures can overlap in non-trivial ways,
+as in figure \ref{fig:board}.  Instead, we deal with these modifiers by
+invoking a parser on the sequence of parsed buffer elements to
+generate parallel sequences of beams, connecting lines and other such
+tablature elements.
+
+The tablature editor that has been developed in parallel with Climacs
+is in use for a project to catalogue European lute music, and
+additionally supports research \cite{tabxml} into more advanced
+notations and extensions of \TabCode\ (to provide a means to encode
+editorial comments or alterations, or markup of distinguishing
+features of a specific source ma\-nu\-script).
+
+When the tablature editor is in use, the user has in addition to the
+usual editor window a scrollable graphical display of the tablature
+encoded within the buffer.  Individual tablature elements are
+presented to this CLIM pane, allowing the graphical display to provide
+mouse-activated commands, such as one which moves the buffer cursor to
+the beginning of the tabword encoding a particular element.
+
+Since we are presenting an alternative view of the whole buffer's
+contents, we analyse the entire buffer's contents on every edit,
+rather than bounding our analysis by the extent of the visible textual
+area.  To mitigate the efficiency concerns that this might suggest, it
+should first be noted that the typical length of a \TabCode\ file is
+of the order of 200--300 words, which requires only little time to
+parse on modern hardware.  However, such a parsing scheme would stress
+the display engine if a complete redraw were forced on every edit, so
+we have implemented the obvious optimizations: the extent of the edit,
+along with its typical locality of effect, are used to limit the
+damaged region as before, so preserving the identity of unaffected
+tabwords; this identity can then be used in a cache informing CLIM's
+incremental redisplay mechanism.
+
+To assist the editorial process, we have also implemented MIDI audio
+feedback: in addition to a command to render the entire tablature, we
+provide several gestures to play individual chords: one intended for
+use during the initial entry of the encoding, to act as a rapid
+error-detection aid, and a motion command and mouse gesture to assist
+revision and navigation.
 
 \section{Future Work and Conclusions}
 \label{sec:conclusions}



From crhodes at common-lisp.net  Mon May 23 12:25:56 2005
From: crhodes at common-lisp.net (Christophe Rhodes)
Date: Mon, 23 May 2005 14:25:56 +0200 (CEST)
Subject: [climacs-cvs] CVS update: papers/ilc2005/syntax/climacssyntax.tex 
Message-ID: <20050523122556.6775088704@common-lisp.net>

Update of /project/climacs/cvsroot/papers/ilc2005/syntax
In directory common-lisp.net:/tmp/cvs-serv9619

Modified Files:
	climacssyntax.tex 
Log Message:
Minor revisions

Date: Mon May 23 14:25:55 2005
Author: crhodes

Index: papers/ilc2005/syntax/climacssyntax.tex
diff -u papers/ilc2005/syntax/climacssyntax.tex:1.17 papers/ilc2005/syntax/climacssyntax.tex:1.18
--- papers/ilc2005/syntax/climacssyntax.tex:1.17	Mon May 23 13:34:58 2005
+++ papers/ilc2005/syntax/climacssyntax.tex	Mon May 23 14:25:55 2005
@@ -319,7 +319,7 @@
 
 Another area of difficulty is the fact that parsing a Prolog text can
 change the grammar itself through the use of the \texttt{op/3}
-directive: including
+directive: the inclusion of
 \begin{verbatim}
   :- op(100,xfy,<>).
 \end{verbatim}
@@ -422,15 +422,15 @@
 whitespace-delimited independent words, where each word represents
 either a set of frets to depress and strings to be sounded, or
 alternatively some element of musical notation (such as a barline);
-figure \ref{fig:besfantlach} demonstrates a fragment of manuscript,
-and its \TabCode\ encoding.  It is also possible to encode more
-complex elements of lute tablature notation in \TabCode: ornaments,
-fingering marks, beaming, connecting lines and other complex elements
-can all be accommodated (see figure \ref{fig:barley} for examples of
-some of these more complex elements).  \TabCode\ has been used to
-produce scholarly editions of lute works \cite{Weiss} and to assist in
-computer-based musicological studies (as in \cite{ecolm-graz} for
-example).
+figure \ref{fig:besfantlach} shows a fragment of manuscript, and
+demonstrates its \TabCode\ encoding.  It is also possible to encode
+more complex elements of lute tablature notation in \TabCode:
+ornaments, fingering marks, beaming, connecting lines and other
+complex elements can all be accommodated (see figure \ref{fig:barley}
+for examples of some of these more complex elements).  \TabCode\ has
+been used to produce scholarly editions of lute works \cite{Weiss} and
+to assist in computer-based musicological studies (as in
+\cite{ecolm-graz} for example).
 
 The \TabCode\ language itself has developed to provide a terse and
 intuitive encoding of tablature, rather than a well-formed grammar for
@@ -444,7 +444,7 @@
 \begin{figure}
   \begin{center}
     \includegraphics{boardfig}
-    \caption{Extract from 'An Almand by mr Jo Dowland Bacheler of
+    \caption{Extract from `An Almand by mr Jo Dowland Bacheler of
       musique', \textit{The Board Lute Book} (GB:Lam MS 603), f.13.
       Note in particular the connecting lines in this bar, joining
       chords within beams to an unbeamed chord.}
@@ -502,17 +502,17 @@
 \section{Future Work and Conclusions}
 \label{sec:conclusions}
 
-Given the relatively small amount of work (only a few person-months)
-that has been put into Climacs so far, it is already a very competent
-and stable editor.  Using CLIM (and in particular the McCLIM
-\cite{ilc2002-moore} implementation) as the display engine has allowed
-the project to progress much more rapidly than would otherwise have
-been possible.  However, Climacs development has also revealed some
-serious limitations and performance problems of the McCLIM library.
-Nevertheless, we maintain that using CLIM and McCLIM was the best
-choice, and in fact advantageous to other McCLIM users as well, as the
-deficiencies in McCLIM implementation are being addressed and other
-improvements made for use with Climacs.
+Climacs is already a very competent and stable editor, especially
+given the relatively small amount of work (only a few person-months)
+that has been put into it so far.  Using CLIM (and in particular the
+McCLIM \cite{ilc2002-moore} implementation) as the display engine has
+allowed the project to progress much more rapidly than would otherwise
+have been possible.  However, Climacs development has also revealed
+some serious limitations and performance problems of the McCLIM
+library.  Nevertheless, we maintain that using CLIM and McCLIM was the
+best choice, and in fact advantageous to other McCLIM users as well,
+as the deficiencies in McCLIM implementation are being addressed and
+other improvements made for use with Climacs.
 
 Due to its reliance on fairly well-defined protocols, the Climacs text
 editor framework is flexible enough to allow for different future
@@ -527,20 +527,20 @@
 us to improve those protocols as well as their corresponding
 implementations. 
 
-Another future direction high up on the list of priorities is the
-planned implementation of the buffer protocol.  Representing a line
-being editied as a flexichain can greatly improve the performance of
-some crucial operations that currently require looping over each
-buffer object until a newline character is found.  Other operations
-that are currently prohibitive include knowing the line- and column
-number of a given mark. 
+Another important future direction is the planned implementation of
+the buffer protocol.  Representing a line being edited as a flexichain
+can greatly improve the performance of some crucial operations that
+currently require looping over each buffer object until a newline
+character is found.  Other operations that are currently prohibitive
+include knowing the line- and column number of a given mark.
 
 One disadvantage of the current parsing scheme is that a single parse
 error prevents analysis of the rest of the buffer, which is
 potentially disturbing to a user's workflow.  For relatively simple
 grammars such as \TabCode, it is simple enough to resynchronize at the
 next token, whereas for more complex grammars the resolution is less
-clear.
+clear.  Providing a framework for customizeable resynchronising of the
+parser after a parse error would allow for more user-friendly editing.
 
 Our plans for Climacs go further than creating an improved
 implementation of Emacs.  We intend to make Climacs a fully-integrated



From crhodes at common-lisp.net  Mon May 23 12:35:48 2005
From: crhodes at common-lisp.net (Christophe Rhodes)
Date: Mon, 23 May 2005 14:35:48 +0200 (CEST)
Subject: [climacs-cvs] CVS update: papers/ilc2005/syntax/climacssyntax.tex 
Message-ID: <20050523123548.D2D9688704@common-lisp.net>

Update of /project/climacs/cvsroot/papers/ilc2005/syntax
In directory common-lisp.net:/tmp/cvs-serv10537

Modified Files:
	climacssyntax.tex 
Log Message:
A tiny bit more detail for tabcode

Date: Mon May 23 14:35:48 2005
Author: crhodes

Index: papers/ilc2005/syntax/climacssyntax.tex
diff -u papers/ilc2005/syntax/climacssyntax.tex:1.18 papers/ilc2005/syntax/climacssyntax.tex:1.19
--- papers/ilc2005/syntax/climacssyntax.tex:1.18	Mon May 23 14:25:55 2005
+++ papers/ilc2005/syntax/climacssyntax.tex	Mon May 23 14:35:48 2005
@@ -492,12 +492,21 @@
 tabwords; this identity can then be used in a cache informing CLIM's
 incremental redisplay mechanism.
 
+We handle parse errors on a word-by-word basis, so that even during
+editing the vast majority of a tabcode buffer can be graphically
+presented, rather than only up to the current location; by returning
+our best guess at the intent of a particular word and resynchronizing
+at the next whitespace, we can preserve the tablature view mostly
+unchanged for most editing operations.
+
 To assist the editorial process, we have also implemented MIDI audio
 feedback: in addition to a command to render the entire tablature, we
 provide several gestures to play individual chords: one intended for
 use during the initial entry of the encoding, to act as a rapid
 error-detection aid, and a motion command and mouse gesture to assist
-revision and navigation.
+revision and navigation.  At present, this MIDI support is based on
+Apple's CoreMIDI framework on Mac OS X; a port to alsa-lib on Linux is
+in progress.
 
 \section{Future Work and Conclusions}
 \label{sec:conclusions}



From bmastenbrook at common-lisp.net  Mon May 23 13:02:20 2005
From: bmastenbrook at common-lisp.net (Brian Mastenbrook)
Date: Mon, 23 May 2005 15:02:20 +0200 (CEST)
Subject: [climacs-cvs] CVS update: papers/ilc2005/syntax/parserclasses.eps
	papers/ilc2005/syntax/parserclasses.pdf 
Message-ID: <20050523130220.0B1E688704@common-lisp.net>

Update of /project/climacs/cvsroot/papers/ilc2005/syntax
In directory common-lisp.net:/tmp/cvs-serv12514

Modified Files:
	parserclasses.eps parserclasses.pdf 
Log Message:
Change the font

Date: Mon May 23 15:02:19 2005
Author: bmastenbrook

Index: papers/ilc2005/syntax/parserclasses.eps
diff -u papers/ilc2005/syntax/parserclasses.eps:1.1 papers/ilc2005/syntax/parserclasses.eps:1.2
--- papers/ilc2005/syntax/parserclasses.eps:1.1	Mon May 23 03:05:55 2005
+++ papers/ilc2005/syntax/parserclasses.eps	Mon May 23 15:02:19 2005
@@ -7,7 +7,7 @@
 %%DocumentData: Clean7Bit
 %%LanguageLevel: 2
 %%Pages: 1
-%%BoundingBox: 0 0 289 151
+%%BoundingBox: 0 0 288 146
 %%EndComments
 %%BeginProlog
 %%BeginFile: cg-pdf.ps
@@ -639,14 +639,14 @@
 %%BeginSetup
 %%EndSetup
 %%Page: 1 1
-%%PageBoundingBox: 0 0 289 151
+%%PageBoundingBox: 0 0 288 146
 %%BeginPageSetup
 cg_md begin
 bp
 sdmtx
-%RBIBeginFontSubset: RBDFCA+BitstreamVeraSans-Roman
-%!FontType1-1.0: RBDFCA+BitstreamVeraSans-Roman 1.0000.2.0000
-
14 dict begin/FontName /RBDFCA+BitstreamVeraSans-Roman def
+%RBIBeginFontSubset: XCXBXZ+Times-Roman
+%!FontType1-1.0: XCXBXZ+Times-Roman 1.0000.0.0000
+
14 dict begin/FontName /XCXBXZ+Times-Roman def
 
/PaintType 0 def
 
/Encoding 256 array 0 1 255{1 index exch/.notdef put}for
 
dup 33 /space put
@@ -672,14 +672,17 @@
 
{currentfile 0(%APLsfntEnd\n)/SubFileDecode filter flushfile}if
 
/FontType 42 def
 
/FontMatrix matrix def
-
/FontBBox[2048 55 1 index div -426 2 index div 1821 3 index div 1556 5 -1 roll div]cvx def
+
/FontBBox[2048 9 1 index div -448 2 index div 1588 3 index div 1404 5 -1 roll div]cvx def
 
/sfnts [<
-
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
-
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
-
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
-
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
-
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
-
05361003350B03341E03330D0332310B0532FE03310B03302F0B05300D032F0B032E2D09052E10032D09032C32032B2A25052B64032A2912052A25032912032827250528410327250326250B05260F03250B0324FE0323FE03220F03210110052112032064031FFA031E1D0D051E64031D0D031C1142051CFE031BFA031A42031911420519FE031864031716190517FE031601100516190315FE0314FE0313FE031211420512FE0311022D05114203107D030F64030EFE030D0C16050DFE030C0110050C16030BFE030A100309FE0308022D0508FE030714030664030401100504FE03401503022D0503FE0302011005022D0301100300FE0301B80164858D012B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B002B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B1D
+
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
+
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
+
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
+
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
+
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
+
061226002B2B2B2B012B2B2B2B2B8100715D015D1A0133320015140223220035000706151412333236353402233734FDC7C60104FCC8C0FEF601593A64A18F70799A922502970113FEFCD8C7FEDA011AD5019E345BDFB2FECCCEA7AD01323C0000020009FE4203C203B1000C003300C440593609362196199925AA25A527E427F527080A2505274A2503A62401452401220810430D1C33DA242E431C32DE2318201150171C18921B0C0B0A03052E102E29332D1F110C0A05021E1B083E23071B070263290B33320E054426B80202400A351E272E2F11C0100110B801FFB135342FCCF45D3CFDE410F6ED003F3C3FED3F3FED11391117391112393901111217390010F5EDFC01F52B2B3130437940182428030703280526010724052601042702260006250826012B2B012B2B818101715D00715D24163332363534262322061511013E0135113426232206073537363732161D013637363332161514022322272627111416171521016167466C999F694A7AFEC25E3325330B13125F05C4050542325A5F8AC7EFB538294036426FFE117443D7C0B8B65B2CFE09FDAB06444903C04C2B0203211F0144090687422038EBCCC8FEBA0E1538FEB9652E082300000000010009000002B103AF00290088404CC41E013722011F29010343001C29202424431C2820230B20043F0A1C0B9210221F1E032B24242204030429141D1320801D01201D301D021D951D1027170729280A801A011A2B1327242F0403B801FFB4AF2B012B2A2FCC5DF43CFDE410C45D003F3C3F4DE4CCED715D1239113912173901111217390010F5EDFC01F52B2B015D3130005D015D373E013511342623220607353E0137363732161D013E0133321615140623222623220615111416371521095C3C25310A21123978173235070340774033403125264D162366505DFE132108315001C36355050421142A0913180A10A459643D2E293846713CFE3D5643022100000000020068FFED02C903B10031003201034021130013011602290D390D680C690D790B790C880C0A2908301C31D140011C210000B80191B331D1402DB80121400F222A181C19D1401B1C211A1F1A011AB80191B319D14015B80121402B21120D000A082226230D0A04051F3332120705332A0B320F1A01EF1AFF1A021A4608413200302701273422B801F340100027700FA00FC00F030F4600340134332FCC5D76D4185DE4ED10D45D1239ED76C45D71182F003FED3F3CED11173901111239123900103D1AEC181AF4E55D01103D1AED181AF4ED00103D1AEC1A18F4E501101A3DED1A18F4ED31304379401C28292021101106070629081E012011221E000728051E0021101F1E01002B2B012B2B81818181005D13331617163332363534262F012E013534363332163332363733132326272623220615141F01161514
+
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
+
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
+
7233B802AB400B1F6B2F6C1F6A2C4B1F632EB8019A400F1F2E2C371F532FBB1F512F721F4F2CB80401B21F4944B80401B21F482FBA0401001F01F3400D411D1F412F1D1F3D3ECD1F3B44B80201B21F392EB8019AB21F343EB80401B21F322EB80201B61F313E4C1F2B2EB80404B61F2A54311F2233B80201402D1F5567075F075507370735073007260725071E071D071408120810080E080C080A080808060804080208000814B8FFE0402B00000100140610000001000604000001000410000001001002000001000200000001000002010802004A00B801FF85B0018D16763F183F123E113946443E113946443E113946443E113946443E11394660443E11394660442B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B1DB0964B5358B0AA1D59B0324B5358B0FF1D594BB03553205C58B901E701E54544B901E601E545445958B9012101E7455258B901E70121445959184BB04C5058B801E64569B801E7456961B0405258B901E601E645B040614459594BB05653205C58B9002901E64544B9005401E645445958B902360029455258B9002902364459594BB08953205C58B9002F01E74544B9004401E745445958B902E4002F455258B9002F02E44459594BB0CD53205C58B188294544B1292945445958B9052E0088455258B90088052E4459594BB8020153205C58B90130002F4544B12F2F45445958B90AB00130455258B901300AB04459594BB01D53205C58B133334544B13E3345445958B13233455258B133324459594BB02F53205C58B133334544B12C3345445958B15233455258B133524459594BB05B53205C58B133334544B12E3345445958B1A033455258B133A04459592B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B65422B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2BB35B9B819C456523456023456560234560B08B766818B080622020B1819B4565234520B003266062636820B003266165B09B236544B081234420B15B9C4565234520B003266062636820B003266165B09C236544B05B2344B1009C455458B19C406544B25B405B4523614459B3868D7145456523456023456560234560B089766818B080622020B1718D4565234520B003266062636820B003266165B08D236544B071234420B186454565234520B003266062636820B003266165B045236544B0862344B10045455458B145406544B286408645236144592B2B2B2B4569534273737373737373737373737373737373737373737475755E73735E00
 
00>] def
 
/CharStrings 18 dict dup begin
 
/.notdef 0 def
@@ -707,12 +710,13 @@
 
{currentfile 0(%APLT1End\n)/SubFileDecode filter flushfile}if
 
/FontType 1 def
 
/FontMatrix [ 0.00048828125 0 0 0.00048828125 0 0 ] def
-
/FontBBox{55 -426 1821 1556}def
-
/UniqueID 4447637 def
+
/FontBBox{9 -448 1588 1404}def
+
/UniqueID 4087593 def
 
currentdict currentfile eexec
-
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
-
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
-
2136BAA4D733B9C78BD63C1EA15A388A92F7543BB63C78C458A885615A5F6D3F147B6E2BFDE4BA0D7B45365BCD34759E2B24A51633E470C0F586C8BAEC972F66F5E9FE73236B6F734783F5F986F21609DC50B4C549A2069ADB2D7F2D08FFE6411EF0DFCB2213374C78239F35AC5AADE46EF638D00036CC54E9001C7D813F714C71093FCADF45E7A4F36E64268D7172F3B614A3124FDFBECEC492A0EDDA4D5BB336F6631EF31D46E63CC3E8811D97EB38B90B56EECD6901FBB3285F4DDA3209B981B3008A8F2585C6D70DC86AD18CAB5B3E1E6C27A87C81EC9916417AF7E743AA93E73579D5AF9FE4E35248D4D7A799F1AED9C2CC5901D2DCAA70518D97E18C70120EC0341B5D7BE58BB991B22C75D6704F35E5CC3424B16457CE093F44C8C5C7D929B55C228F9F20AA469E6B77ECC8C486BEA9FD8BF0F2E4813320BEADF085D157DB1C313C10391DE50A3CD797EFC71104D9B42576E3566DC07B67B56B87A498E9981B6C6B61E512057E435ABBCB71DA95197A5028895CBDFBB31808A2E123BE246FFB4B4ED79638D02E5E4C3DAB6BE4C66E66BBE9D4EF09208696C208AEF06D5E9A15AEB703B6C2414961BF172AE9E65619B8A626BAB5B96C65B215E7021B7493E070FC1E33F8FC2D4958C17D566E6616958BFE623F5069A6671FE4BC6DF247456DAF0CE77009C5DDA55F5B310E0CFE3F09E8BDDE8B526AAE301F55196E4B63A226D0F8E7AE84D01E80230C9D74E02AFD12B9168A9FFC776342D685F46FFEAF5B44CDA2F076C7E6F2BEBC890F31A97B8224958007C2D7D992F189D8E4D15D322D4D513A12B087D2CD51421F05C6BC93EF5D149884B891F581CF58FAB2A47C09FC2513106B37E8653D5A977CFFED67447B12BDA466F363E7C48E382FB7123842AF5C6C81D84585D12A776F62DC7A8B06D0F8D29E88D7DADD6BE6695A2B35916A428E637C58A7F64C17BE115CA38B003E2322EDA95E0A599CE51B2905C0DC969054716066759ECB106D3F6C5830CD16895FDC97A6A155B73E603EB17C16C0F38752B57D3DEFA8A8C2E5089FAD6A1F31A5D8F3E2BA005748F8B3434055CE5310EB3E129103ADEEBD067BC2424A419AF7A80A2C92421E0F1F1A742ECE19C5
+
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
+
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
+
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
+
70B954306B5E1DF080C89C9CE5E0BF4F6E681B900C4DB1FC21A84E218A0AE89D7F9D52F86F4FFAEA622184A4824EC0425792F70E32B3F9C4A5390CBA659FE5C8CF86FF04DC16A1897101D7485EC9F26F6021A60C64078CFFEFE7944778EAE2B3B142E5940D4F4B8CF6419F06945FB9B3900AD8B477161A5A9A2E68F402FF620C5ACE2D250BFEDCD163A49B8E20A233F9CF3D7A718DCF08BF5354940098318BE5738C6EA02F8799A0B412EFDCD78DF3A4C733D6083B06B04D73BF4CDF27C8A214F3A0C2EBEC4FDC8E2B010027D63D52FCC080C4284AD9EB20B61161B32685D3B0A187A2CE00FE92FE32D0EA13377D047B4D629EA775E19CCA78B21C90C8F581164719B09978303E1061231C8CF49D6BB0BF8229B79C1D200BD1230D920F9EDF3AC7D3DAFF948DE42735A4DBA9985A0796D45E4D42FADCC226282530E596BD04DFB348EA6524941A9D8AE8B956E6ECF71616C6204931FA0188A0AE6BC4D38FED6244771FF45640124DBE9DBF517127B67E5F3EE5AD46453D006CF5BB4B257BFDE8E07CD892F3AD0976E301691D83C44031266F0642443C363F064E20171C1F36B34276C1A096CE862663FE07A3FD720B33B84218CFD5AD2D32ABF56B4A631206B4BB4BA013EEC2641E7E9183264C2E694EB57BDD3A54D635E1BB831FE3C8B03C3AFBBB2B3B24A3D9CDD38B829B2EF1B6539467F6FF01D2CD8F53C3CEE26E69BDEF6478957FD781282B94667A27AB0D3258853CDD755AC33DE2B4034D38F03BB4EB41389610C7E76F9FCE0341CB958D00617648143E8B51E10B1F3A344E60710CA54BED7A482EB4607466F1E94BAE6FDB08F7A0FC6F726B98DD48CF4A66C33034E6CEAAF40B56B84767C1A5EC50604EA2CAA3A82FEEC032948905E05817BF27D1CAC0DBFBB28FAD9CEED30108D7FB275577E6C6B5EBA1C254075C13D802C83A35B4216ABB3E251EB994F7E172ED3150B975CE8A49CE627B7002E255A9A1C30ED7ADCC7CCBE98B12AFA49943F5770C4A3C146CA0D6B7C8D47CE373DC78AED6418AED215E337DBD6414783E5EECF4ABB5C526A777EBAF43033DE6D3B924FFDD7169EE4E82B440510950A4D53307158A1F685C6F3370B692A27CCBA2EA9291D69D63EF5603F8E557AA70306CD83F4E226398ADFF5D1FF150EBFE42EFC8148E48033A6DEDF87D826DF341FD37C13EE183A1CDBB7CF3532869BDF1B263778D77AE11672DA3AE06C3B3B648BE86B6B80F082463F83BB248543A74DD9EAA73CF2EBE055F688F7C5B10CA28E3A964
 
0000000000000000000000000000000000000000000000000000000000000000
 
0000000000000000000000000000000000000000000000000000000000000000
 
0000000000000000000000000000000000000000000000000000000000000000
@@ -725,11 +729,11 @@
 
%APLT1End
 
 %RBIEndFontSubset
-/RBDFCA+BitstreamVeraSans-Roman cguidfix
-/F1.1/RBDFCA+BitstreamVeraSans-Roman renmfont
-%RBIBeginFontSubset: DIVZDX+BitstreamVeraSans-Bold
-%!FontType1-1.0: DIVZDX+BitstreamVeraSans-Bold 1.0000.2.0000
-
14 dict begin/FontName /DIVZDX+BitstreamVeraSans-Bold def
+/XCXBXZ+Times-Roman cguidfix
+/F1.1/XCXBXZ+Times-Roman renmfont
+%RBIBeginFontSubset: DOWFRX+Times-Bold
+%!FontType1-1.0: DOWFRX+Times-Bold 1.0000.0.0000
+
14 dict begin/FontName /DOWFRX+Times-Bold def
 
/PaintType 0 def
 
/Encoding 256 array 0 1 255{1 index exch/.notdef put}for
 
dup 33 /p put
@@ -745,13 +749,16 @@
 
{currentfile 0(%APLsfntEnd\n)/SubFileDecode filter flushfile}if
 
/FontType 42 def
 
/FontMatrix matrix def
-
/FontBBox[2048 27 1 index div -426 2 index div 1374 3 index div 1444 5 -1 roll div]cvx def
+
/FontBBox[2048 33 1 index div -422 2 index div 1550 3 index div 1384 5 -1 roll div]cvx def
 
/sfnts [<
-
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
-
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
-
74696A496D3FEFC0F4FC63DA043DFEF0303033352B2E0B0923A0ABB3B42323011034343A39302F0D081EA2A5B2AC1E000001001B000003A4059E00130078401A0E05080F03A11101B308A1000A080B09020904000D10120E541410FC3CC4FC3CC4C412393931002FC4ECF43CEC3211393930014BB00F544BB010545B4BB011545B4BB012545B58BD0014FFC00001001400140040381137385940183F003F1302000200030F100F1150025003501560026003095D005D01112111211114163B011121222635112311331102330171FE8F3E5CB8FECDD4B1B2B2059EFEC2FF00FE254E37FF00B1D401DB0100013E00000000010000000200001E1140D25F0F3CF5001F080000000000BEB6C92F00000000BEB6C92F001BFE56055E05A400010008000100000000000000010000076DFE1D00000B85FE68FE680B5600010000000000000000000000000000000804CD00660352006F05660058056D005805BA00AC03F200AC04C3006A03D3001B00000026003E00C8011E016C01AE025A02BA0000000100000008004E0002004500040002001000400007000005ED07A70002000141840280012600FE000301250011000301240121003A0005012400FA000301230016000301220121003A0005012200FE00030121003A0003012000FA0003011F00BB0003011E00640003011D00FE0003011C00190003011B001E0003011A00FE0003011900FE0003011800FE0003011700FE0003011600FE000301150114000E0005011500FE00030114000E0003011300FE0003011200FE0003010F010E007D0005010F00FE0003010E007D0003010D010C008C0005010D00FE0003010D00C00004010C010B00590005010C008C0003010C00800004010B010A00260005010B00590003010B00400004010A00260003010900FE0003010800FE00030107000C00030107008000040106B2972E054113010600FA0003010500FA0003010400FE0003010300190003010200FA0003010100FA0003010040FF7D03FF3E03FEFE03FCFB2C05FCFE03FB2C03FAFE03F9F84705F97D03F84703F7FA03F6FE03F5FE03F4FE03F3BB03F2FE03F1FE03F0FE03EF1E03EEFE03EDEC0A05EDFE03EC0A03EC4004EBEA0A05EB3203EA0A03E9FA03E8911605E8FE03E7FA03E6FA03E5911605E5FE03E4FE03E3FE03E2FE03E1FE03E0FE03DFFE03DEFA03DDDC1805DD6403DC1803DBA01E05DB6403DAD92505DAFA03D92503D8D12505D8FA03D7D61405D71603D6D51005D61403D51003D4D30B05D42003D30B03D2D12505D2FA03D1911605D12503D0940C05D02303CFCE1405CF2603CECD1205CE1403CD1203CC911605CC1D03CB1403CAC9BB05CAFE03C9C85D05C9BB03C98004C840FFC72505C85D03C84004C72503C6FE03C56403C4901005C4FE03C31C03C2FE03C1FE03C0BF3A05C0
-
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
-
2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B002B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B1D00
+
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
+
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
+
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
+
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
+
144010170117490E070906201F0A111A220A221B2A0504B80260400960228022D0220322212FCC5DF43CFDE410E6003F3C3F3FED5DED11173911393901111217392B2B2B01103C5D3130005D015D373E013F01113426273521153E0133321615140623222623220615111416171521253B2E02022C4101854180543F654739415F1329533B58FDDE31072A3C3C022D402E0832A15564514E3C4E7A655EFE7D663308310000020034FFE302E803C90039003A00E3402A15121A2D560B960CB42CC62CE62CF52C080D11022C2912252D660BC80EC627C628C629D6290A90000100B801E2B339B34035B80109B5212E9F1B011BB80169B31AB34016B8010940532113250A02041F25130704252E0B3A073A3A1A100C070322020A25220740191E1AB31C1E21481B3E47EC07010782002B802B902B032B3C40381E39011E2139220022E322012282A010B010C010D01004103C3B2FCCD65DED5DF4E41A3DED10ED1A1810D65DED5D76F4761A3DEDF4ED181A11123939711112392F003F3FED3FED111739101AEC1AF4ED5D00101AEC1AF4ED5D3130015D005D13331E01333236353427262F01262726353436333216333236373311232E01232206151417161F011617161514062322262F012E0123220607230134391EA4564F4A28163198783435A6954192121915072D341D845844431E1D5170683050A5A529533D2313090711191031015901369379473A372715184A3B45455E77AD2B1513FED8687E4C2C2424252736322F507572C511150C07021B2003E60000010021FFE5029E0509001E0064401F0B1C01154715110B4001210B0070080906401C211149190B2040142115470BB80119400C400721080D2A1D00401C211EB90260001F2FFC1AC81ACC3CFD3C1A3DCD181AE476DC1AC81AC4003FED1AC81A3FCCFD3C1A3DCC181A111239762F3130015D13353637363736373311331523111417163332363717060706232227263511211B28352F5D4C34C3C30D142E28361B312432587F483668035539192231346675FEA65AFD982B1D2D39321854355D1B348902980000000001000000000000A6637BA45F0F3CF50111080000000000BEB7848C00000000BEB7848C0021FE5A060E0568000100090001000000000000000100000600FE0000000E6CFE2EFE2E07F60001000000000000000000000000000000080639002502AA005A04000034038D002E04730025038D0025031D003402AA002100000034005201180190023802B0037803DC0000000100000008005F000300850008000200100010003B000007E809D100040001B800312BB800272BB5900690070215B8028BB2471F14B8028AB2471F13B80289B2471F12B80288B2471F11B80287B2471F10B80286B2471F0FB80285B2471F0EB80284B2471F0DB80283B2471F0CB80282B2471F
+
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
+
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
+
2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B65422B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2BB38BE089A4456523456023456560234560B08B766818B080622020B189E04565234520B003266062636820B003266165B0E0236544B089234420B18BA44565234520B003266062636820B003266165B0A4236544B08B2344B100A4455458B1A4406544B28B408B4523614459B34EA24C91456523456023456560234560B089766818B080622020B14CA24565234520B003266062636820B003266165B0A2236544B04C234420B14E914565234520B003266062636820B003266165B091236544B04E2344B10091455458B191406544B24E404E4523614459456953427373737373737373737373737574747373737373732B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B73000000
 
00>] def
 
/CharStrings 8 dict dup begin
 
/.notdef 0 def
@@ -769,11 +776,11 @@
 
{currentfile 0(%APLT1End\n)/SubFileDecode filter flushfile}if
 
/FontType 1 def
 
/FontMatrix [ 0.00048828125 0 0 0.00048828125 0 0 ] def
-
/FontBBox{27 -426 1374 1444}def
-
/UniqueID 4082130 def
+
/FontBBox{33 -422 1550 1384}def
+
/UniqueID 4228260 def
 
currentdict currentfile eexec
-
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
-
66793828FD19939FD006D9CBB8B6973E56C0AC184648B2BE0D74C42F46B49FA4F89236449E95E89F392F805A4366BAFD437B36B817040664842C808D617E9D33E5F2A8A008D3DDA1442ED8EF7018B27B9CF767BA4A48AA5A1F713A56CAE3E57108EA634D14908D30D0C009F0BE4E5F5E6BF8A3C3BF44484BF3D8D276275DFDF02D6B9C8E664C3231DC2B3A32343F80234868D1805FB5C07645AEF04A497D1E908FC7AA6D07D637DF41A940D060C62A772A3D9B348D41563960FE53A9824E6EE1953102AE602D21003A5211C4936FAE979063770093E8E113C931E514FCB32C10044800F515D33328F3EC2E965946C7FE898689487B045828B4B8AD0D1A1822951F9E5D38D3D015213545BF148CC9746EC184835D3A2A794C6F4E4C28FC7B721D118E3807C6DA6F105856AF50614954E0039D225BE1926EE9A61E970D2DAC98E8B40531C04557A526B2424030ED58EC7397337B91B94230C0D744F148DF09631B353069FEBED5A2AA4E0928A9E4B73E8A0A1114E4B73E645E5888EB395247567D32803F25399CE004781824ABF71FB231BA13188939F88D30A67857CEE320240771B088B1B434EEC89EE15C164C9FCA74CD020CCA40921BD17B0B1082163CC8D62DB968CCD32D3D9958DD680290EACB050B49181762B28743DA1748FE31899E222164DB2FABE8450DCB9E447C74F6ACC3A52A9DB7A555C75159348379A3B39693BDACDFDD40689555BE72A58CD03ED12E0D47B47BCE1FFC0089C14B6C70864D723D11993D396B53E2540BFBA14AB97DFCA77BB9EAE690DA5DB0820DF16883A0BC3086C97F40D553D38F65F303AA1EA3A9C80657384E00B3DA5105107CF63C861CBF8287CDD68880F987D2DFC33C3D68DF464C55A7129FE48AC8F6E15FBD0991A5D451944C531B56FF39E4E3B79F7A9A68AEAB272E276D3D1F17BD34C7B21466C17F8911DDBF655D50B35D
+
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
+
35CA0F3891EDC4F43A6368E133C3405961446301A42A9A3C396A80D3D4A5FE748C09BA80844CA2C5E8848D48105C0AF1149B5AE869E3B2FD4ADB8488858867DF23A858CEB297762FDD522280B9B710CD2AF312F4F755FB0F12EFCEC68EFE1AF1D7364BD2AD461A079AA280A8C059496D3C07960E519307EA480FA9B3B755C2A7AADD379D5C54176EFCDE3C3D8024BC1865B487CFE8E375D7EF0BCD9EB25DC15E1635B241A009EC1D44C83799721D019B47946619BAD683FF6C9EDC198B72008D9E17305843A13372F95ECA4203FA4F71D3A636594833A387889B5150C6F6DB40C916F4C47AB39ACDECDD2E45DDAFC72C068F0C0A35257A99F7AA99E25E89E941086DDC21FC63CBEF5BC4CC57DE9393FF075749C1BF36C4940C87089108CA0C4DA209B08669054ECD6E12F41E5812B4BD2F09AA9211879EF664EF733441932F6DCDF26179093338FDE1520D5171D9520EECC9E2262B4EF06DD99B6E429553617D980FD3660D332A3C118B64A4B5FB833A7AC16222B82DB30E2C2712F2405B91CC7CDE0F8F9AC74BE484E79DFC049ECD3D3101F13DFAB04F605148707529FEF900CDAADBB4A81C242B050D8A52E5A89460D0420BF60A990039EE9E49CAC0FDDCFF851E6240B271EE479C6E6512FBF8124660C98A1B631DFDF0A39FAE514CABB10593E35934A711BAFF121AC3AABA3AD3B12F71DFEA50FD0E864F6B58E400FD40E9E56C0D4522B1DF6DA08C9E3E1C8079EC74A981B520747DD083740E8AA78508A0A6A1D80F4741944375DF7CD6D5BC11CAAE1E28FF49FDF2A991ED11F45554E0FEC249618BBB0E02F0305A6449AF16A732C4F6C40E6C5529D6BE6F66CC0EF6B2D756BFD02A4802C979298CD9F8B16051D8612FFC2A4F2CA91795110EDF9822C0737E1D7D9EA0550BE809CB075B14EE13585A2B8AD12CDE835321BCDCDEE51C6C2417AE4F06D486842A5A89F1595BBA0A6A67EC0176DA8ACC54E252B33CCE56DD6940056F83E2815C0339934E1ED5C40D54B7A73F84CD8667F53BD2A6800C73E87E830CD9C7BE5B86A2243087739927CE57EDAE70A39F7C480FEA36A6F3A4AAF3065FA08E09D7286AACFA1CA2DA5DD1F8711A3FED16A3E707098D6E0A9BF4FB6A966206D62B0DAE5B170C86DCB4A9447B5D7AAC6F99A150C970C0ECB0FE735E7740BD25549B2B851EF36401F4EE630969E29D6B48977D22D295E5748F7951BB5BEC18CADF2C3DA98BB5108CB68CDAFB0C2CCAB0B49376490925D3DE48CA0B071161678FB6726068838DA9AB157644B5B9337D717FF85C0A11E78C02557B7FF9EDABF484E090094B396C0164DD41
 
0000000000000000000000000000000000000000000000000000000000000000
 
0000000000000000000000000000000000000000000000000000000000000000
 
0000000000000000000000000000000000000000000000000000000000000000
@@ -786,11 +793,11 @@
 
%APLT1End
 
 %RBIEndFontSubset
-/DIVZDX+BitstreamVeraSans-Bold cguidfix
-/F2.1/DIVZDX+BitstreamVeraSans-Bold renmfont
-%RBIBeginFontSubset: DKQZDX+BitstreamVeraSans-Roman
-%!FontType1-1.0: DKQZDX+BitstreamVeraSans-Roman 1.0000.2.0000
-
14 dict begin/FontName /DKQZDX+BitstreamVeraSans-Roman def
+/DOWFRX+Times-Bold cguidfix
+/F2.1/DOWFRX+Times-Bold renmfont
+%RBIBeginFontSubset: RVNFRX+Times-Roman
+%!FontType1-1.0: RVNFRX+Times-Roman 1.0000.0.0000
+
14 dict begin/FontName /RVNFRX+Times-Roman def
 
/PaintType 0 def
 
/Encoding 256 array 0 1 255{1 index exch/.notdef put}for
 
dup 33 /gid1 put
@@ -800,11 +807,13 @@
 
{currentfile 0(%APLsfntEnd\n)/SubFileDecode filter flushfile}if
 
/FontType 42 def
 
/FontMatrix matrix def
-
/FontBBox[2048 102 1 index div -362 2 index div 1126 3 index div 1444 5 -1 roll div]cvx def
+
/FontBBox[2048 33 1 index div 0 2 index div 1431 3 index div 1355 5 -1 roll div]cvx def
 
/sfnts [<
-
74727565000900000000000063767420000000000000009C000001FC6670676D00000000000002980000008B676C7966000000000000032400000044686561640000000000000368000000386868656100000000000003A000000024686D747800000000000003C4000000086C6F636100000000000003CC000000066D61787000000000000003D4000000207072657000000000000003F400000568013500B800CB00CB00C100AA009C01A600B800660000007100CB00A002B20085007500B800C301CB0189022D00CB00A600F000D300AA008700CB03AA0400014A003300CB000000D9050200F4015400B4009C01390114013907060400044E04B4045204B804E704CD0037047304CD04600473013303A2055605A60556053903C5021200C9001F00B801DF007300BA03E9033303BC0444040E00DF03CD03AA00E503AA0404000000CB008F00A4007B00B80014016F007F027B0252008F00C705CD009A009A006F00CB00CD019E01D300F000BA018300D5009803040248009E01D500C100CB00F600830354027F00000333026600D300C700A400CD008F009A0073040005D5010A00FE022B00A400B4009C00000062009C0000001D032D05D505D505D505F0007F007B005400A406B80614072301D300B800CB00A601C301EC069300A000D3035C037103DB0185042304A80448008F0139011401390360008F05D5019A0614072306660179046004600460047B009C00000277046001AA00E904600762007B00C5007F027B000000B4025205CD006600BC00660077061000CD013B01850389008F007B0000001D00CD074A042F009C009C0000077D006F0000006F0335006A006F007B00AE00B2002D0396008F027B00F600830354063705F6008F009C04E10266008F018D02F600CD03440029006604EE007300001400B6060504030201002C2010B002254964B040515820C859212D2CB002254964B040515820C859212D2C20100720B00050B00D7920B8FFFF5058041B0559B0051CB0032508B0042523E120B00050B00D7920B8FFFF5058041B0559B0051CB0032508E12D2C4B505820B0FD454459212D2CB002254560442D2C4B5358B00225B0022545445921212D2C45442D0000020066FE96046605A400030007001A400C04FB0006FB0108057F0204002FC4D4EC310010D4ECD4EC301311211125211121660400FC73031BFCE5FE96070EF8F2720629000100000002000037B568175F0F3CF5001F080000000000BEB6C92F00000000BEB6C92F0066FE96046605A400000008000100000000000000010000076DFE1D00000ABCFE89FE890A4C00010000000000000000000000000000000204CD0066051700000000002200220000000100000002004D000200420004000200100040000700000415056800030001B8028040FFFBFE03FA1403F9
-
2503F83203F79603F60E03F5FE03F4FE03F32503F20E03F19603F02503EF8A4105EFFE03EE9603ED9603ECFA03EBFA03EAFE03E93A03E84203E7FE03E63203E5E45305E59603E48A4105E45303E3E22F05E3FA03E22F03E1FE03E0FE03DF3203DE1403DD9603DCFE03DB1203DA7D03D9BB03D8FE03D68A4105D67D03D5D44705D57D03D44703D3D21B05D3FE03D21B03D1FE03D0FE03CFFE03CEFE03CD9603CCCB1E05CCFE03CB1E03CA3203C9FE03C6851105C61C03C51603C4FE03C3FE03C2FE03C1FE03C0FE03BFFE03BEFE03BDFE03BCFE03BBFE03BA1103B9862505B9FE03B8B7BB05B8FE03B7B65D05B7BB03B78004B6B52505B65D40FF03B64004B52503B4FE03B39603B2FE03B1FE03B0FE03AFFE03AE6403AD0E03ACAB2505AC6403ABAA1205AB2503AA1203A98A4105A9FA03A8FE03A7FE03A6FE03A51203A4FE03A3A20E05A33203A20E03A16403A08A4105A096039FFE039E9D0C059EFE039D0C039C9B19059C64039B9A10059B19039A1003990A0398FE0397960D0597FE03960D03958A410595960394930E05942803930E0392FA039190BB0591FE03908F5D0590BB039080048F8E25058F5D038F40048E25038DFE038C8B2E058CFE038B2E038A8625058A410389880B05891403880B03878625058764038685110586250385110384FE038382110583FE0382110381FE0380FE037FFE0340FF7E7D7D057EFE037D7D037C64037B5415057B25037AFE0379FE03780E03770C03760A0375FE0374FA0373FA0372FA0371FA0370FE036FFE036EFE036C21036BFE036A1142056A530369FE03687D036711420566FE0365FE0364FE0363FE0362FE03613A0360FA035E0C035DFE035BFE035AFE0359580A0559FA03580A035716190557320356FE035554150555420354150353011005531803521403514A130551FE03500B034FFE034E4D10054EFE034D10034CFE034B4A13054BFE034A4910054A1303491D0D05491003480D0347FE0346960345960344FE0343022D0543FA0342BB03414B0340FE033FFE033E3D12053E14033D3C0F053D12033C3B0D053C40FF0F033B0D033AFE0339FE033837140538FA033736100537140336350B05361003350B03341E03330D0332310B0532FE03310B03302F0B05300D032F0B032E2D09052E10032D09032C32032B2A25052B64032A2912052A25032912032827250528410327250326250B05260F03250B0324FE0323FE03220F03210110052112032064031FFA031E1D0D051E64031D0D031C1142051CFE031BFA031A42031911420519FE031864031716190517FE031601100516190315FE0314FE0313FE031211420512FE0311022D05114203107D030F64030EFE030D0C16050DFE030C0110050C16030BFE030A100309FE0308022D0508FE030714030664030401100504FE03401503022D
-
0503FE0302011005022D0301100300FE0301B80164858D012B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B002B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B1D
+
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
+
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
+
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
+
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
+
5B405B4523614459B3868D7145456523456023456560234560B089766818B080622020B1718D4565234520B003266062636820B003266165B08D236544B071234420B186454565234520B003266062636820B003266165B045236544B0862344B10045455458B145406544B286408645236144592B2B2B2B4569534273737373737373737373737373737373737373737475755E73735E00
 
00>] def
 
/CharStrings 2 dict dup begin
 
/.notdef 0 def
@@ -816,10 +825,10 @@
 
{currentfile 0(%APLT1End\n)/SubFileDecode filter flushfile}if
 
/FontType 1 def
 
/FontMatrix [ 0.00048828125 0 0 0.00048828125 0 0 ] def
-
/FontBBox{102 -362 1126 1444}def
-
/UniqueID 4354327 def
+
/FontBBox{33 0 1431 1355}def
+
/UniqueID 4282895 def
 
currentdict currentfile eexec
-
54544758EC884CF30C3CD503CEDBFF3839C47C3C3333173232E3FDBFF439491DB843E1924E63AA7726BBB0485AB56D93D8C0906F647A47162891E73FFC2A9873C4B1EAC5EEBDFFC4D06084FBD84139DF4583C6E259D10699944D1068C9C45667DCCCFB9B7EA01B606435EDCBD273ABAC093D14085CCBAC149BD7382E842CFE0D7FE4FD2EF589A2471F6074A80A8B675C2F7A50D63AC1EF90D787BADD11633CB01CF6EE3B37AAF9078A69AC4740E9B6525D78BBD839551A1CB80DB8682FA5E87591BBD6EE8B946063A2A58D9CA3685AB305495DC5FB5747EB8A9A059C4976C0FE4EEAB1D56FF47F1E9664ED9F4A7DAB763AF92B2F6CF2FA7DEC24710E0B9096E30F772BA7FEA9BDBE496C42ED2CEB58F54E80BDF57CE7B4DB6CCFE7182F43BF93CCA0767AF95D62C5D2C3DC6AE1E6D139F51A2C63432117F1714C5566572EE9967A715420ABDCD1D7BD74F8450B89965FCC81C6ACA565C5F3CCF91D430D1F953E4F1A645300A98DD8C47CD64555F08F422340A85404EAE0D3229C4F9336B9470CACBD6BBF3395104750A915CC6EAAC197668267B8C62D2764C8CD69FD937CA3C924D997A0EDE7964BEB9EA2F92EF70C5E5DA0AA5567765E71F2B911B3C5586B741EEB93F3C73016EC16BFF283758900903D203992EFC8BAFAF13579C602F38C92725788540EA741B17F7A4B26645F1AC6C6DD680CE8F1F60AEE27914E830D02D10E72F735C6FFE3A6B6B64515362B34A7059F5813C794FAE6FE0B8DAAC01F7E4B706CE9E65EFDC945608364C1AC96802ADC987CAE4A078EB7179E0847AC4107F92E5D8A11F5F08BEB7EDB4FB7647A735F7BE665B48156D4982862F2ADB5F137CD65AF53E26C7AE22934441A8A15AAB14724614CDC5D74666E4DE55C96225BD1BD740C12C9380A238ADC1A3A5EFF81797AC4D75EAC484F89A05F82F82B39C494136B80AB9114D2FE9D48D01E798FA655039CB764BB0CBC6A00C997381FFF
+
54544758EC884CF30C3CD503CEDBFF3839C47C3C3333173232E3FDBFF439491DB843E1924E63AA7726BBB0485AB56D93D8C0906F647A47162891E73FFC2A9873C4B1EAC5EEBDFFC4D06084FBD84139DF4583C6E259D10699944D1068C9C45667DCCCFB9B7EA01B606435EDCBD273ABAC093D14085CCBAC149BD7382E842CFE0D7FE4FD2EF589A2471F6074A80A8B675C2F7A50D63AC1EF90D787BADD11633CB01CF6EE3B37AAF9078A69AC4740E9B6525D78BBD839551A1CB80DB8682FA5E87591BBD6EE8B946063A2A58D9CA3685AB305495DC5FB5747EB8A9A059C4976C0FE4EEAB1D56FF47F1E9664ED9F4A7DAB763AF92B2F6CF2FA7DEC24710E0B9096E30F772BA7FEA9BDBE496C42ED2CEB58F54E80BDF57CE7B4DB6CCFE7182F43BF93CCA0767AF95D62C5D2C3DC6AE1E6D139F51A2C63432117F1714C5566572EE9967A715420ABDCD1D7BD74F8450B89965FCC81C6ACA565C5F3CCF91D430D1F953E4F1A645300A98DD8C47CD64555F08F422340A85404EAE0D3229C4F9336B9470CACBD6BBF3395104750A915CC6EAAC197668267B8C62D2764C8CD69FD937CA3C924D997A0EDE7964BEB9EA2F92EF70C5E5DA0AA5567765E71F2B911B3C5586B741EEB93F3C73016EC16BFF283758900903D203992EFC8BAFAF13579C602F38C92725788540EA741B17F7A4B26645F1AC6C6DD680CE8F1F60AEE279148EC39EE9402EDDBB3D94F960D3B0B296E7E68C3D0406E652095434F0F8F7C96D58E18728F4539E6932AEE08DBFFFC6F2F0E4EC573EC19B834B60372D568508806A5774B61F9562D0273733A27E9958AFA13CC4B756A6C388298D6518A6C74FAC9AACCBDDA3C605EF7220CB38BDE52890A81888549FBF45DA880B682C3752E139F88E8A890F6EAB779B82B14B7D77642C5592AA9830EAF2A72BDBDE4CBFDA4627267A62CC75E6583D7595A0011BD81EA38BFE6D015C66DA29836F89C
 
0000000000000000000000000000000000000000000000000000000000000000
 
0000000000000000000000000000000000000000000000000000000000000000
 
0000000000000000000000000000000000000000000000000000000000000000
@@ -832,11 +841,11 @@
 
%APLT1End
 
 %RBIEndFontSubset
-/DKQZDX+BitstreamVeraSans-Roman cguidfix
-/F3.1/DKQZDX+BitstreamVeraSans-Roman renmfont
-%RBIBeginFontSubset: BRTJLA+BitstreamVeraSans-Oblique
-%!FontType1-1.0: BRTJLA+BitstreamVeraSans-Oblique 1.0000.2.0000
-
14 dict begin/FontName /BRTJLA+BitstreamVeraSans-Oblique def
+/RVNFRX+Times-Roman cguidfix
+/F3.1/RVNFRX+Times-Roman renmfont
+%RBIBeginFontSubset: NNGXNZ+Times-Italic
+%!FontType1-1.0: NNGXNZ+Times-Italic 1.0000.0.0000
+
14 dict begin/FontName /NNGXNZ+Times-Italic def
 
/PaintType 0 def
 
/Encoding 256 array 0 1 255{1 index exch/.notdef put}for
 
dup 33 /l put
@@ -861,14 +870,19 @@
 
{currentfile 0(%APLsfntEnd\n)/SubFileDecode filter flushfile}if
 
/FontType 42 def
 
/FontMatrix matrix def
-
/FontBBox[2048 -53 1 index div -426 2 index div 1855 3 index div 1556 5 -1 roll div]cvx def
+
/FontBBox[2048 -157 1 index div -422 2 index div 1571 3 index div 1398 5 -1 roll div]cvx def
 
/sfnts [<
-
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
-
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
-
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
-
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
-
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
-
3A03A2FE03A13203A09F5305A096039F4D41059F53039E32039D14039C96039B0A039AFE03991203987D0397BB0396FE03944D4105947D0393FE0392914705927D03914703908F1B0590FE038F1B038EFE038DFE038CFE038BFE038A891E058AFE03891E0388320387FE0384160383FE0382FE0381FE0380FE037FFE037EFE037D4B25057D64037CFE037B11037A79BB057AFE0379785D0579BB0379800478772505785D0378400477250376FE03759603746403730E0372712505726403717012057125037012036F4D41056FFA036E40FFFE036DFE036CFE036B16036A693A056A6403694B2505693A03684E0B0568180367660E05673203660E03656403644D410564960363FE0362610C0562FE03610C03605F19056064035F5E10055F19035E10035D0A035C5B0D055CFE035B0D035A4D41055A960359580E05592803580E0357FA035655BB0556FE0355545D0555BB0355800454532505545D0354400453250352FE0351502E0551FE03502E034F4E0B054F14034E0B034D4B25054D41034C4B25054CFE034B4A11054B25034A110349FE034847110548FE0347110346FE0345FE0344FE0343427D0543FE03427D0341FE0340FA033FFA033EFA033C3642053CFE033BC8033A3642053A530339FE407003387D033736420536042D0536420335FE0334FE03333A0332FA03300C032FFE032DFE032CFE032B042D052B31032A100329031005292303281E0327260E05276403260E0325010A05253203240C1805247D0323053A0523FE03220C180522BB0321031005211B03201F0B05200F0320B8FFC0409A041F0B031E09031E40041D10031C053A051C96031B96031A1925051A6403191812051925031812031716250517410316250315FE0314FE0313FA031211190512FE031103100511190310FE030FFE030E053A050E96030D0C18050D7D030C0B0C050C18030B0C030AFE0308053A050896030603100506FE0305042D05053A0304031005042D0303100302010A05021803010A03014004001C0301B80164858D012B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B002B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B1D
+
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
+
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
+
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
+
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
+
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
+
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
+
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
+
00B80166B334FF2D1BB8016640281AFF1328250D0A0420050D23100A252308282A084016262027130705274030262D0B9408A4080208B8025DB72A479B23AB230223B8025D4022141001102A101B00401923211AA6401C23211B364033232134A64001232100AB36352FCC7DF61A3DED1A18F41A3DED1A1810D61A3DED1A18F41A3DED1A18111239392F71FD5D762F18FD5D003F1AC8181AED3FED1AC8181A0111123911123939111239001112173910F4ED0010F4ED3130015D005D13331617163332363534262F01262726353436333216333236373303232627262322061514161F011E0115140623222623220607234921161E376D3D531510534B131D7D73317E1719180A1D29210D1A30682C451F3747372EB87F29980C14130821012A79386756472C38177B702639395785251411FEE461315B3735293E4F664F643A6C942212120000000001004DFFEA025E045E002700A7405B051D051E051F561F661F761F851F951F0806184405E915F91504401F21202049181802031B020304030A13400521030317020313171817171F1203181F1202020317950E1406401F2120461B43240B0228280310024602280A29282FCC2B103C01762F182B3C2B10C0003FED76DC1A3DCC1A183FCCFD01870E2E2B102B1005073C0208103C00101AC8011A10CC10C8080211123939011076C82F1A3DC91A183130015D005D3E013713233436373E013F013E013316171E010F01330723030616333237363717070E01232226354D0203BC980810656F60100309050A0403010139A30CAAB40510131A2F1B401A0E56833B332E4A150B02BB1B0E072B50721304050202070B06DA43FD5F1221341C530F158165362200000000010055FFE903CB038C004400F94092501601023B1A311A32251D25312532351D540657185638583A641D6437951D96360F402A202B482B461D3738383A39393A35351B076F0068280623074B0A4044351D0E041B2822242F143938222104351D0D0E0E1F124444001B35351F121D1D1C0A071C281B0614372F303D0B44451D46280010464456449444C444E444054444450A1C10421D541DCB1D031D1D460A46452FCC2B103C012F5D2B3C2B103C017D2F5D182B3C2B10C010C018003FE4ED3F2B3C003F870E2E2B057D10C4870E2E182B7D10C4011112173900111239392B1217391A180010F5ED2BFC01F58710087DC408C40EC401111039762F1A19CC181A3130015D005D133E0135342623353F0136160F01030E01151416333236373637363733030E0115141633323637363736371706070623222635343637363F01230607062322272635343637EA02033346939F05080103B107061A153BB1453E34203C97BD05080C0F0F20180B1D12251C2E3263552C380A0B121C16078A4F897A211B34040502D20A11092B131C1D1E
+
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
+
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
+
071FAC072B2B2B2B2B4B5379BF009001EE0007009001BF0007009001B1B60790CE0790AC072B2B2B2B2B181DB0964B5358B0AA1D59B0324B5358B0FF1D594BB02E53205C58B9023F023D4544B9023E023D45445958B900DE023F455258B9023F00DE4459594BB05A53205C58B9001F023F4544B9003A023F45445958B901AA001F455258B9001F01AA4459594BB06353205C58B90020023E4544B90050023E45445958B902770020455258B9002002774459594BB0E453205C58B1723A4544B13A3A45445958B904BD0072455258B9007204BD4459594BB0E453205C58B18B3A4544B13A3A45445958B904BD008B455258B9008B04BD4459594BB01B53205C58B127274544B1432745445958B12227455258B127224459594BB02453205C58B127274544B1542745445958B12E27455258B1272E4459594BB03753205C58B127274544B1282745445958B14727455258B127474459592B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B65422B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B4569534216003F3F182B103C012F070CB0062342B00723422B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B2B73737373737373732B2B2B0000
 
00>] def
 
/CharStrings 17 dict dup begin
 
/.notdef 0 def
@@ -895,13 +909,14 @@
 
{currentfile 0(%APLT1End\n)/SubFileDecode filter flushfile}if
 
/FontType 1 def
 
/FontMatrix [ 0.00048828125 0 0 0.00048828125 0 0 ] def
-
/FontBBox{-53 -426 1855 1556}def
-
/UniqueID 4037153 def
+
/FontBBox{-157 -422 1571 1398}def
+
/UniqueID 4058487 def
 
currentdict currentfile eexec
-
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
-
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
-
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
-
9868ECFA0923BA49EEFBE4F10DBD919678C1EED7E31F7255FF23B7C632445664E42BA370C5436DB2BCD00C533AC2267FFCC9A6B5D1DE16D1A2A12EE6AF8E5D7A5BD8B4440893FAAD
+
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
+
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
+
2248F27E2C8273BC879B1A9E5288D06D7CE2026B8B3AB970E507E04CE0463F87B80DDDB30F5071B67635C7D8A090BD0FEC9A3C4B51EAE7A3A2BA503B92364AAF644E8381CD690D712C7DAFBA60119995C9EE833710893FC4F05CC401628CB68B5A1B2B180C4D2997CE0CBFC1E2E327AFC233C8FE43B36C421FA3771A3BAB07D258E9320A2FA9BB27AC46BE916140D5DA0C2D11FD3998DB36C1D92B9F608A85D51309B8AD98120CF55ECFFC0DA9586617B5D2CF8691EF7560BAB3C9F5FD12CCA45C8952B948CE946EF6674C5C45987879B56684AB15685E24336B0960A4347BB7CF6AC7ECB34BB3AB1E945821C25B758F1AF5764CD68354E641313950C9B586C8784712998573720417F18CD47593B91A00CF400EEA4AC032068E96375308245614004C1305D81853BBB35C6B07BDE4375D8CE74FD4440E75CC3BA0B615DD42A97818719E50985D0347410DAC6DBE896C21C26511F121082D7C86D458074D28009F3589AA4142027EC69BE35961AF7124BB37D3CC780D170CD017047925DCFB279AE45BEF54BA29E78A0403BA7BF56D84F589B400B3A6518A758F5BC09338C9F19E76BA9A86068CB408CFDB653240E0FC946A226995157AC41F87385FCE1B4FF6569A83DB26DBF0985C846896AF0D85CA8EC125969E0DB6BC90765C5B2B19D97935EA8B537876F5BDA6F92CBE17EF5806A756C976B7A9A4E41455684BC8425202B5381960720D8A42B51A8304BDE0108E2E2F3A7EBBAB825EB270C7544DFC5E87BAB7F5DC4014B9A1BBD23E903AEE5F9009F457EB1D96FFF59948ABFDECD72CA2490D8456ABB8FE8130CFA971CA0F38375D242DFDF635077EF9CA6836D80BB35CDF05DC8276CD7F4B058CE983D915098AD4608DE43ABAC6977CC85A15983F820CCAB43B753DAE598FBC133CFC9D8987105595DCD501B7F3DB807B666643BF054E98E03C0FFA65058277552DF68AE49B091437FB3331B0C66FA66032F540847FB0678F5A3B13FEE7524FD6F6C86A624988F8A81B76679740E792634CE92B8661417BCBE7033A74245F1A1C9813EEDB5E8F09A4C55DB9018E0767CF3F09B9A5E481C8959BE4F8C71A9D2607754EAEF738F8F161CEBA16A26A601CC3A6847144F4E292E0963ED5F81BA13EE6B0BB450E0F1D3C6BBD0F1292D90A4D27B21C432CD4F50FAC441F49FE82795D4E2818A29C4A2C99BD85A1332FBDB64E80CF51C9B5F0A6D8361CA181C6EEA7CCE2E959389674EF6C3489E1237BEE9B885B009EE31EF66F9BB3E784ABD7BA806F1E8B08F40E6F942E56E505699FCBAFA1A95F2DC661176D535F4C1A35B8C1DF35B9C8ACCC4F2686BBF9B9498DD3680E5E00BFFB24CEF77B34480F7E9CB3B3370C7C52FEA08733C9EEFC74E3BB90028F317A6122BC2E45BAF0AEB238068A1180655DCDA1DD0DFB85E3491A4D505B58C08A92C52766119697
+
2BC15E8787ADCB1E156266AAE6B1C49DF301E7F42564248955AB17BC932D1362364AD853607518EA146229D9E179BC08A26E16572FCA042C2E2B3A0B16C7F7921DFDA77B0C64619B57E77D5323EAAA2271E9641395EEA3A00D6D53FA57919764464DFEEBE0A4E4DE5FC44D6C88D1639E2DC1351994AFE09703705568E4C089942EBC8DB4FAA31B414ADB7B91A5B87A9328261E9C1B2AD6DEAB0D27870E96ADAE00889607899644713AB727662A57A99A8A479AD2A018DFE2211FB5CF3CA2311D59EE369E049F3AE7B14D3455C845329FC413A2049AAECF485B7A315537D34CDE2D0EDB009986FAD9F0B5AB66943EB343F4708FFBBB13ED7E32BB970E32634540C9782C1C04E058C92A20BA88CD567C516E1DA69F5A05BF8EEA3ADA858A083847653002179504044E15AD5989428469686810F3C8A19A7827AC2FB00B79D7BA2D69A700218FC78A3151E2458FC9788C66C5DC352D73795B7289BBE2B984B2F41BA9CE706AB72264BF3756E84FFC15EA48AC680A3C4FE773AAC794190EE6EF0C858B45DCF4C134839D050A4B332735D90653DCA6C19CE170C538D407504AF139A843C1F0D5EEAC7FCD19E55432F2A630B69459EE3D0B88F0B22B6C71073D3F1A245CE3441877FC700A91C8676907CD4FB8D42CDDD972A36F39428D32309B58B8ABDFC61A4A0E22150596740DCFFE44F0CBF02BB6BB42BC28BEA3EAFFDEC17B5BBB783830A1D92BE33AAC96F77E69E9008D9F8A0FA8F81F721D4B6F8F5698BCB4545B9ACC0C6DC4C6A9C42C87F883271E58066BFC139C12BCE1766958093DB21C62E0B42D1DC193A431EE93436AEC9B20A5A24D3A8E8E17CC904937967701A3D79C916045696D522AA613B7F4D1376C0F8EE4E6182CD42811B8BF33265292307EEE19EA9577195798C0F635E776FF4B92E50311472C8A760FB4C3AD32C409FE397FD5B68C6F8E0570B81EB609C3AA5D2609F8951175F4901EBCE8AF0308BDAE3A30392EF3456A9BAF1F0B3EA972307A407A734382C358BD94E29A9F2281AB6F42F3F6B31C48F81A39BF7FDB3F2D5818AD6A5428863FC37FB94E098C55A89DE0F51AA40A69795D7457D7EF1300FDCD80781D6963D4FA069845CCBEDA19A9DBD0B0529E9FC2027F27346A1A4015C339AB0AF5F9B7C8C5238D59C0421AFA5F465FF28E21126A25C104E335A84BB1CF0F2AFB055570615A292EA8CAA76497AC14D207AFCEAAB04D462404ECE47F95E770F400D60E4FB3C5609DA4A0B6E3FEDE1928629C82A35D77B698AC7326CF3F9A4D71A5E2C2FE86547275B9A6DE4EA6BFAF0EF52300CCB63B8CC2B37478818F26930A5C5A541E3EA705F71181E4AE804CC107D04C15FC3328CD7743E6C7915FA050FF08D44A0A7A0911B597B99805EA8D81DA32F734F281F8A9DD059D61232C1AC0CA2F4529AFAB6244BD59614B6587B1077F44A2
+
ACCB10C00DF2884B36E11B96EF5EEBB20E9E379C70DBE0229F2DCBAFA629600D27D9BA5E0FEA14F9D6610BA865B2E903EB9D6B857943BE351C7A3B289D1D7C0F1D04A64BD8C61435CECB3514BCF0C4480C34CA31C6DD8FAD73A362144EF27E054756F6E1EF36E4399A444045EFCE31C8F5070C1395A559BF5B6A94B7F62C0426F849D864D690661A25B71B81B7D67ABCA1D91FA5E9D07CBC2508E5062E73393E5525759F42BAB0C5AD1C8FF133E03CA7CE920E7197BF4172DAC56D33F1330EDAFCF9E4DB250C3CD0F60783A1CA35E4B41C2676502F0840E74E68850CE070848EA249DD18E234C13A5EE70CC65DEE42CC2E605FDCF82CC7ECED349926D657CB319B77399DEA2F3ADB52BEE590555FECB2F96CBC0FE3BA661046A8BC2043806DB24B074400BA955CD6D16DE1BEA60E1918021AD3D07AAFAF1E427551355EAE7EC412FDA1924222B66B9140A83F69750D11829533366BCBDF6D78590E76905D3CFBCD9E000F00706A9A5F9AD076094F6FF0B3FB6DFFCE62A6C2E5DB4FCC231D0BB548EAD38CB5849C10DE814CEF1DD5120E2E6F158A31B1AEED8B0EF264F04502C1826184A17E3B8A0F7A75776ECB5762F7F69A75F6C183F167763FBD682AF28500825C988CC927ED37642D414D6C9CA3EB292A53009F51CCC60D5F9B27A32C8164D4740266AC0608595CF2EE5AB85CE02410EED02F8E3503FC2D3AF0013DA04350A9B9B74502E3068D7881332529100EAB8BD6EF2AC8B3689384A72AD6793B6CBEAF54072F41FF32EA022278786E36F07F6155487BD401C639D5A287566390A24DF466760EA9E960C6C764D8D81D76B5C62DF5C186C485883EA7A41FF4BEEBD8433E38FB882B209174011963C109C944C7C6B8E9
 
0000000000000000000000000000000000000000000000000000000000000000
 
0000000000000000000000000000000000000000000000000000000000000000
 
0000000000000000000000000000000000000000000000000000000000000000
@@ -914,289 +929,264 @@
 
%APLT1End
 
 %RBIEndFontSubset
-/BRTJLA+BitstreamVeraSans-Oblique cguidfix
-/F4.1/BRTJLA+BitstreamVeraSans-Oblique renmfont
+/NNGXNZ+Times-Italic cguidfix
+/F4.1/NNGXNZ+Times-Italic renmfont
+[ /CIEBasedABC 4 dict dup begin 
+/WhitePoint [ 0.9505 1.0000 1.0891 ] def 
+/DecodeABC [ { 1.8008  exp } bind { 1.8008  exp } bind { 1.8008  exp } bind ] def 
+/MatrixABC [ 0.4294 0.2332 0.0202 0.3278 0.6737 0.1105 0.1933 0.0938 0.9580 ] def 
+/RangeLMN [ 0.0 0.9505 0.0 1.0000 0.0 1.0891 ] def 
+end ] /Cs1 exch/ColorSpace dr pop
 [ /CIEBasedA 5 dict dup begin /WhitePoint [ 0.9505 1.0000 1.0891 ] def 
 /DecodeA { { 1.8008  exp } bind  exec} bind 
 def 
 /MatrixA [ 0.9642 1.0000 0.8249 ] def 
 /RangeLMN [ 0.0 2.0000 0.0 2.0000 0.0 2.0000 ] def 
 /DecodeLMN [ { 0.9857  mul} bind { 1.0000  mul} bind { 1.3202  mul} bind ] def 
-end ] /Cs1 exch/ColorSpace dr pop
-[ /CIEBasedABC 4 dict dup begin 
-/WhitePoint [ 0.9505 1.0000 1.0891 ] def 
-/DecodeABC [ { 1.8008  exp } bind { 1.8008  exp } bind { 1.8008  exp } bind ] def 
-/MatrixABC [ 0.4294 0.2332 0.0202 0.3278 0.6737 0.1105 0.1933 0.0938 0.9580 ] def 
-/RangeLMN [ 0.0 0.9505 0.0 1.0000 0.0 1.0891 ] def 
 end ] /Cs2 exch/ColorSpace dr pop
 %%EndPageSetup
-1 i
 /Cs1 SC
-1 sc
-q
-0.67062378 150.04382 m
-288.32938 150.04382 l
-288.32938 0.9561615 l
-0.67062378 0.9561615 l
-0.67062378 150.04382 l
-W
--32.734909 174.17004 m
-323.59079 174.17004 l
-323.59079 -279.89777 l
--32.734909 -279.89777 l
-h
-f
-/Cs2 SC
 0 0 0 sc
-127.20059 144.1889 m
-128.40854 142.98096 128.40854 141.02255 127.20059 139.81461 c
-125.99268 138.60666 124.03423 138.60666 122.82629 139.81461 c
-121.61835 141.02255 121.61835 142.98096 122.82629 144.1889 c
-124.03423 145.39685 125.99268 145.39685 127.20059 144.1889 c
+q
+128.814 140.8548 m
+130.07773 139.59338 130.07773 137.54819 128.814 136.28677 c
+127.55029 135.02534 125.50138 135.02534 124.23768 136.28677 c
+122.97395 137.54819 122.97395 139.59338 124.23768 140.8548 c
+125.50138 142.11624 127.55029 142.11624 128.814 140.8548 c
 f
 1 J
 1 j
-0.61862099 0 0 -0.61862099 -32.734909 174.17004 cm
+0.64719099 0 0 -0.64601767 -38.507862 172.16371 cm
 258.53552 48.464478 m
-260.48816 50.417114 260.48816 53.582886 258.53552 55.535522 c
-256.58292 57.488174 253.41708 57.488174 251.46448 55.535522 c
-249.51184 53.582886 249.51184 50.417114 251.46448 48.464478 c
-253.41708 46.511826 256.58292 46.511826 258.53552 48.464478 c
+260.48816 50.417084 260.48816 53.582916 258.53552 55.535507 c
+256.58292 57.488159 253.41708 57.488159 251.46449 55.535507 c
+249.51184 53.582916 249.51184 50.417084 251.46449 48.464478 c
+253.41708 46.511841 256.58292 46.511841 258.53552 48.464478 c
 S
-/Cs1 SC
-0 sc
-0.61862099 0 0 -0.61862099 125.01344 142.00175 cm
-/F1.1[ 12 0 0 -12 0 0]sf
-6 3.5 m
-(!!)[ 3.816000 3.816000 ] xS
-/F2.1[ 12 0 0 -12 0 0]sf
-13.628906 3.5 m
-(!"#$%&'#%%)[ 8.592001 8.100001 5.916000 7.140000 8.136000 4.980000 5.736000 5.916000 8.136000 8.136000 ] xS
 /Cs2 SC
+0 sc
+0.64719099 0 0 -0.64601767 126.52584 138.57079 cm
+/F1.1[ 13 0 0 -13 0 0]sf
+5.5 2 m
+(!!)[ 3.250000 3.250000 ] xS
+/F2.1[ 13 0 0 -13 0 0]sf
+12 2 m
+(!"#$%&'#)[ 7.228000 6.500000 5.772000 5.057000 5.772000 4.329000 4.329000 5.772000 ] xS
+56.528809 2 m
+(%%)[ 5.772000 5.772000 ] xS
+/Cs1 SC
 0 0 0 sc
 CM
-127.20059 115.73233 m
-128.40854 114.52438 128.40854 112.56598 127.20059 111.35803 c
-125.99268 110.15009 124.03423 110.15009 122.82629 111.35803 c
-121.61835 112.56598 121.61835 114.52438 122.82629 115.73233 c
-124.03423 116.94028 125.99268 116.94028 127.20059 115.73233 c
+128.814 111.13799 m
+130.07773 109.87657 130.07773 107.83138 128.814 106.56997 c
+127.55029 105.30853 125.50138 105.30853 124.23768 106.56997 c
+122.97395 107.83138 122.97395 109.87657 124.23768 111.13799 c
+125.50138 112.39942 127.55029 112.39942 128.814 111.13799 c
 f
-0.61862099 0 0 -0.61862099 -32.734909 174.17004 cm
-258.53552 94.464493 m
-260.48816 96.417114 260.48816 99.582901 258.53552 101.53551 c
-256.58292 103.48817 253.41708 103.48817 251.46448 101.53551 c
-249.51184 99.582901 249.51184 96.417114 251.46448 94.464493 c
-253.41708 92.511841 256.58292 92.511841 258.53552 94.464493 c
+0.64719099 0 0 -0.64601767 -38.507862 172.16371 cm
+258.53552 94.464478 m
+260.48816 96.417084 260.48816 99.582916 258.53552 101.53551 c
+256.58292 103.48816 253.41708 103.48816 251.46449 101.53551 c
+249.51184 99.582916 249.51184 96.417084 251.46449 94.464478 c
+253.41708 92.511841 256.58292 92.511841 258.53552 94.464478 c
 S
-/Cs1 SC
-0 sc
-0.61862099 0 0 -0.61862099 125.01344 113.54519 cm
-/F1.1[ 12 0 0 -12 0 0]sf
-6 3.5 m
-(!!""#$%&'\(\)*+&"\))[ 3.816000 3.816000 4.704000 4.704000 6.600000 7.608000 7.632000 4.332000 7.620000 7.356000 4.932000 6.252000 7.380001 4.332000 4.704000 4.932000 ] xS
-96.451164 3.5 m
-(++)[ 7.380001 7.380001 ] xS
 /Cs2 SC
+0 sc
+0.64719099 0 0 -0.64601767 126.52584 108.85398 cm
+/F1.1[ 13 0 0 -13 0 0]sf
+5.5 2 m
+(!!""#$%&'\(\)*+&"\)++)[ 3.250000 3.250000 3.614000 3.614000 5.772000 6.500000 6.500000 4.329000 6.500000 5.772000 4.329000 5.057000 5.772000 4.329000 3.614000 4.329000 5.772000 5.772000 ] xS
+/Cs1 SC
 0 0 0 sc
-0.61862099 0 0 -0.61862099 -32.734909 174.17004 cm
-255.00002 57.000015 m
+0.64719099 0 0 -0.64601767 -38.507862 172.16371 cm
+255.00002 57 m
 255.00002 83.099991 l
 S
 CM
-125.01344 117.81366 m
-126.86931 122.76263 l
-123.15758 122.76263 l
+126.52584 113.31149 m
+128.46741 118.47964 l
+124.58427 118.47964 l
 h
-125.01344 117.81366 m
+126.52584 113.31149 m
 f
 0 J
 0 j
-0.61862099 0 0 -0.61862099 -32.734909 174.17004 cm
-255.00002 91.099976 m
+0.64719099 0 0 -0.64601767 -38.507862 172.16371 cm
+255.00002 91.100006 m
 258 83.099991 l
-252 83.099991 l
+252.00002 83.099991 l
 h
-255.00002 91.099976 m
+255.00002 91.100006 m
 S
 CM
-127.20059 87.275787 m
-128.40854 86.067841 128.40854 84.109406 127.20059 82.901489 c
-125.99268 81.693542 124.03423 81.693542 122.82629 82.901489 c
-121.61835 84.109406 121.61835 86.067841 122.82629 87.275787 c
-124.03423 88.483704 125.99268 88.483704 127.20059 87.275787 c
+128.814 81.421173 m
+130.07773 80.15976 130.07773 78.114571 128.814 76.853157 c
+127.55029 75.591721 125.50138 75.591721 124.23768 76.853157 c
+122.97395 78.114571 122.97395 80.15976 124.23768 81.421173 c
+125.50138 82.68261 127.55029 82.68261 128.814 81.421173 c
 f
 1 J
 1 j
-1 M
-0.61862099 0 0 -0.61862099 -32.734909 174.17004 cm
+0.64719099 0 0 -0.64601767 -38.507862 172.16371 cm
 258.53552 140.46448 m
-260.48816 142.4171 260.48816 145.5829 258.53552 147.53552 c
-256.58292 149.48817 253.41708 149.48817 251.46448 147.53552 c
-249.51184 145.5829 249.51184 142.4171 251.46448 140.46448 c
-253.41708 138.51186 256.58292 138.51186 258.53552 140.46448 c
+260.48816 142.41708 260.48816 145.58292 258.53552 147.53552 c
+256.58292 149.48816 253.41708 149.48816 251.46449 147.53552 c
+249.51184 145.58292 249.51184 142.41708 251.46449 140.46448 c
+253.41708 138.51184 256.58292 138.51184 258.53552 140.46448 c
 S
-/Cs1 SC
-0 sc
-0.61862099 0 0 -0.61862099 125.01344 85.088623 cm
-6 3.5 m
-(!!""#$%&+$"\),)[ 3.816000 3.816000 4.704000 4.704000 6.600000 7.608000 7.632000 4.332000 7.380001 7.608000 4.704000 4.932000 7.104000 ] xS
-10 M
 /Cs2 SC
+0 sc
+0.64719099 0 0 -0.64601767 126.52584 79.137161 cm
+5.5 2 m
+(!!""#$%&+$"\),)[ 3.250000 3.250000 3.614000 3.614000 5.772000 6.500000 6.500000 4.329000 5.772000 6.500000 3.614000 4.329000 6.500000 ] xS
+/Cs1 SC
 0 0 0 sc
-0.61862099 0 0 -0.61862099 -32.734909 174.17004 cm
+0.64719099 0 0 -0.64601767 -38.507862 172.16371 cm
 255.00002 103 m
-255.00002 129.09998 l
+255.00002 129.10001 l
 S
 CM
-125.01344 89.357086 m
-126.86931 94.306061 l
-123.15758 94.306061 l
+126.52584 83.594681 m
+128.46741 88.762825 l
+124.58427 88.762825 l
 h
-125.01344 89.357086 m
+126.52584 83.594681 m
 f
 0 J
 0 j
-0.61862099 0 0 -0.61862099 -32.734909 174.17004 cm
-255.00002 137.09998 m
-258 129.09998 l
-252 129.09998 l
+0.64719099 0 0 -0.64601767 -38.507862 172.16371 cm
+255.00002 137.09999 m
+258 129.10001 l
+252.00002 129.10001 l
 h
-255.00002 137.09998 m
+255.00002 137.09999 m
 S
 CM
-98.744019 15.515747 m
-99.951965 14.3078 99.951965 12.349335 98.744019 11.141449 c
-97.536102 9.9335022 95.577637 9.9335022 94.369736 11.141449 c
-93.161789 12.349335 93.161789 14.3078 94.369736 15.515747 c
-95.577637 16.723694 97.536102 16.723694 98.744019 15.515747 c
+99.043213 6.4831243 m
+100.30694 5.2217069 100.30694 3.176523 99.043213 1.9151049 c
+97.779503 0.65366703 95.730606 0.65366703 94.466896 1.9151049 c
+93.203163 3.176523 93.203163 5.2217069 94.466896 6.4831243 c
+95.730606 7.7445626 97.779503 7.7445626 99.043213 6.4831243 c
 f
 1 J
 1 j
-0.61862099 0 0 -0.61862099 -32.734909 174.17004 cm
-212.53552 256.46451 m
-214.48816 258.41708 214.48816 261.58292 212.53552 263.53555 c
-210.58292 265.48816 207.41707 265.48816 205.46448 263.53555 c
-203.51186 261.58292 203.51186 258.41708 205.46448 256.46451 c
-207.41707 254.51186 210.58292 254.51186 212.53552 256.46451 c
+0.64719099 0 0 -0.64601767 -38.507862 172.16371 cm
+212.53552 256.46448 m
+214.48817 258.41708 214.48817 261.58292 212.53552 263.53552 c
+210.58293 265.48816 207.41708 265.48816 205.46449 263.53552 c
+203.51186 261.58292 203.51186 258.41708 205.46449 256.46448 c
+207.41708 254.51184 210.58293 254.51184 212.53552 256.46448 c
 S
-/Cs1 SC
-0 sc
-0.61862099 0 0 -0.61862099 96.556877 13.32859 cm
-6 3.5 m
-(!!""#$%&"+\))[ 3.816000 3.816000 4.704000 4.704000 6.600000 7.608000 7.632000 4.332000 4.704000 7.380001 4.932000 ] xS
-66.017578 3.5 m
-(-.$\(/)[ 11.688001 3.336000 7.608000 7.356000 3.336000 ] xS
 /Cs2 SC
+0 sc
+0.64719099 0 0 -0.64601767 96.755051 4.1991148 cm
+5.5 2 m
+(!!""#$%&"+\)-.$\(/)[ 3.250000 3.250000 3.614000 3.614000 5.772000 6.500000 6.500000 4.329000 3.614000 5.772000 4.329000 10.114000 3.614000 6.500000 5.772000 3.614000 ] xS
+/Cs1 SC
 0 0 0 sc
-0.61862099 0 0 -0.61862099 -32.734909 174.17004 cm
-253.15639 148.64905 m
-214.49303 246.14813 l
+0.64719099 0 0 -0.64601767 -38.507862 172.16371 cm
+253.15639 148.64908 m
+214.49303 246.14812 l
 S
 CM
-98.130646 17.297211 m
-101.68013 21.213562 l
-98.229797 22.581787 l
+98.401505 8.3434916 m
+102.11492 12.433266 l
+98.505234 13.862095 l
 h
-98.130646 17.297211 m
+98.401505 8.3434916 m
 f
 0 J
 0 j
-0.61862099 0 0 -0.61862099 -32.734909 174.17004 cm
-211.54401 253.58473 m
-217.28174 247.25397 l
-211.70428 245.04225 l
+0.64719099 0 0 -0.64601767 -38.507862 172.16371 cm
+211.54399 253.58472 m
+217.28175 247.25397 l
+211.70427 245.04224 l
 h
-211.54401 253.58473 m
+211.54399 253.58472 m
 S
 CM
-127.20059 30.36264 m
-128.40854 29.154694 128.40854 27.196289 127.20059 25.988342 c
-125.99268 24.780396 124.03423 24.780396 122.82629 25.988342 c
-121.61835 27.196289 121.61835 29.154694 122.82629 30.36264 c
-124.03423 31.570587 125.99268 31.570587 127.20059 30.36264 c
+128.814 21.987547 m
+130.07773 20.726131 130.07773 18.680946 128.814 17.419529 c
+127.55029 16.158091 125.50138 16.158091 124.23768 17.419529 c
+122.97395 18.680946 122.97395 20.726131 124.23768 21.987547 c
+125.50138 23.248987 127.55029 23.248987 128.814 21.987547 c
 f
 1 J
 1 j
-0.61862099 0 0 -0.61862099 -32.734909 174.17004 cm
+0.64719099 0 0 -0.64601767 -38.507862 172.16371 cm
 258.53552 232.46448 m
-260.48816 234.41713 260.48816 237.58289 258.53552 239.53551 c
-256.58292 241.48817 253.41708 241.48817 251.46448 239.53551 c
-249.51184 237.58289 249.51184 234.41713 251.46448 232.46448 c
+260.48816 234.41705 260.48816 237.5829 258.53552 239.53551 c
+256.58292 241.48816 253.41708 241.48816 251.46449 239.53551 c
+249.51184 237.5829 249.51184 234.41705 251.46449 232.46448 c
 253.41708 230.51184 256.58292 230.51184 258.53552 232.46448 c
 S
-/Cs1 SC
-0 sc
-0.61862099 0 0 -0.61862099 125.01344 28.175493 cm
-6 3.5 m
-(!!""#$%&$0$"+\))[ 3.816000 3.816000 4.704000 4.704000 6.600000 7.608000 7.632000 4.332000 7.608000 7.344000 7.608000 4.704000 7.380001 4.932000 ] xS
-88.570312 3.5 m
-(-.$\(/)[ 11.688001 3.336000 7.608000 7.356000 3.336000 ] xS
 /Cs2 SC
+0 sc
+0.64719099 0 0 -0.64601767 126.52584 19.703539 cm
+5.5 2 m
+(!!""#$%&$0$"+\)-.$\(/)[ 3.250000 3.250000 3.614000 3.614000 5.772000 6.500000 6.500000 4.329000 6.500000 6.500000 6.500000 3.614000 5.772000 4.329000 10.114000 3.614000 6.500000 5.772000 3.614000 ] xS
+/Cs1 SC
 0 0 0 sc
-0.61862099 0 0 -0.61862099 -32.734909 174.17004 cm
-255.00002 149.00002 m
-255.00002 221.09998 l
+0.64719099 0 0 -0.64601767 -38.507862 172.16371 cm
+255.00002 149 m
+255.00002 221.09999 l
 S
 CM
-125.01344 32.44397 m
-126.86931 37.392914 l
-123.15758 37.392914 l
+126.52584 24.161055 m
+128.46741 29.329195 l
+124.58427 29.329195 l
 h
-125.01344 32.44397 m
+126.52584 24.161055 m
 f
 0 J
 0 j
-0.61862099 0 0 -0.61862099 -32.734909 174.17004 cm
-255.00002 229.09999 m
-258 221.09998 l
-252 221.09998 l
+0.64719099 0 0 -0.64601767 -38.507862 172.16371 cm
+255.00002 229.09998 m
+258 221.09999 l
+252.00002 221.09999 l
 h
-255.00002 229.09999 m
+255.00002 229.09998 m
 S
 CM
-70.28746 69.954376 m
-71.495407 68.746429 71.495407 66.788025 70.28746 65.580078 c
-69.079536 64.372162 67.121078 64.372162 65.913162 65.580078 c
-64.705223 66.788025 64.705223 68.746429 65.913162 69.954376 c
-67.121078 71.162323 69.079536 71.162323 70.28746 69.954376 c
+69.272423 63.33268 m
+70.536156 62.071259 70.536156 60.026081 69.272423 58.76466 c
+68.008713 57.503223 65.959816 57.503223 64.696106 58.76466 c
+63.432381 60.026081 63.432381 62.071259 64.696106 63.33268 c
+65.959816 64.594116 68.008713 64.594116 69.272423 63.33268 c
 f
 1 J
 1 j
-0.61862099 0 0 -0.61862099 -32.734909 174.17004 cm
+0.64719099 0 0 -0.64601767 -38.507862 172.16371 cm
 166.53552 168.46448 m
-168.48816 170.41713 168.48816 173.58287 166.53552 175.53552 c
-164.58292 177.48816 161.41707 177.48816 159.46448 175.53552 c
-157.51184 173.58287 157.51184 170.41713 159.46448 168.46448 c
-161.41707 166.51184 164.58292 166.51184 166.53552 168.46448 c
+168.48817 170.41707 168.48817 173.58292 166.53552 175.53552 c
+164.5829 177.48816 161.41707 177.48816 159.46446 175.53552 c
+157.51184 173.58292 157.51184 170.41707 159.46446 168.46448 c
+161.41707 166.51184 164.5829 166.51184 166.53552 168.46448 c
 S
-/Cs1 SC
+/Cs2 SC
 0 sc
-0.61862099 0 0 -0.61862099 68.100311 67.767235 cm
--100.53516 3.5 m
-(!!""#$%&/+)[ 3.816000 3.816000 4.704000 4.704000 6.600000 7.608000 7.632000 4.332000 3.336000 7.380001 ] xS
--46.822266 3.5 m
-(1)s
--40.089844 3.5 m
-(+-+)[ 7.380001 11.688001 7.380001 ] xS
-/F3.1[ 12 0 0 -12 0 0]sf
--13.641843 3.5 m
+0.64719099 0 0 -0.64601767 66.984268 61.048672 cm
+-84.106445 2 m
+(!!""#$%&/+1+-+)[ 3.250000 3.250000 3.614000 3.614000 5.772000 6.500000 6.500000 4.329000 3.614000 5.772000 6.500000 5.772000 10.114000 5.772000 ] xS
+/F3.1[ 13 0 0 -13 0 0]sf
+-9.733449 2 m
 (!)s
-/Cs2 SC
+/Cs1 SC
 0 0 0 sc
-0.61862099 0 0 -0.61862099 -32.734909 174.17004 cm
-250.2157 145.45613 m
-177.25536 167.66139 l
+0.64719099 0 0 -0.64601767 -38.507862 172.16371 cm
+250.21568 145.45609 m
+177.25536 167.66141 l
 S
 CM
-72.184441 69.010223 m
-77.459343 68.67572 l
-76.378632 72.226654 l
+71.257019 62.34671 m
+76.775528 61.997391 l
+75.644913 65.705551 l
 h
-72.184441 69.010223 m
+71.257019 62.34671 m
 f
 0 J
 0 j
-0.61862099 0 0 -0.61862099 -32.734909 174.17004 cm
+0.64719099 0 0 -0.64601767 -38.507862 172.16371 cm
 169.60199 169.99072 m
 178.12886 170.53143 l
 176.3819 164.79138 l
@@ -1205,144 +1195,142 @@
 S
 1 1 1 sc
 CM
-70.28746 30.36264 m
-71.495407 29.154694 71.495407 27.196289 70.28746 25.988342 c
-69.079536 24.780396 67.121078 24.780396 65.913162 25.988342 c
-64.705223 27.196289 64.705223 29.154694 65.913162 30.36264 c
-67.121078 31.570587 69.079536 31.570587 70.28746 30.36264 c
+69.272423 21.987547 m
+70.536156 20.726131 70.536156 18.680946 69.272423 17.419529 c
+68.008713 16.158091 65.959816 16.158091 64.696106 17.419529 c
+63.432381 18.680946 63.432381 20.726131 64.696106 21.987547 c
+65.959816 23.248987 68.008713 23.248987 69.272423 21.987547 c
 f
 1 J
 1 j
 0 0 0 sc
-0.61862099 0 0 -0.61862099 -32.734909 174.17004 cm
+0.64719099 0 0 -0.64601767 -38.507862 172.16371 cm
 166.53552 232.46448 m
-168.48816 234.41713 168.48816 237.58289 166.53552 239.53551 c
-164.58292 241.48817 161.41707 241.48817 159.46448 239.53551 c
-157.51184 237.58289 157.51184 234.41713 159.46448 232.46448 c
-161.41707 230.51184 164.58292 230.51184 166.53552 232.46448 c
+168.48817 234.41705 168.48817 237.5829 166.53552 239.53551 c
+164.5829 241.48816 161.41707 241.48816 159.46446 239.53551 c
+157.51184 237.5829 157.51184 234.41705 159.46446 232.46448 c
+161.41707 230.51184 164.5829 230.51184 166.53552 232.46448 c
 S
-/Cs1 SC
+/Cs2 SC
 0 sc
-0.61862099 0 0 -0.61862099 68.100311 28.175493 cm
-/F1.1[ 12 0 0 -12 0 0]sf
--112.77539 3.5 m
-(!!)[ 3.816000 3.816000 ] xS
-/F4.1[ 12 0 0 -12 0 0]sf
--105.14648 3.5 m
-(!"#"$"%&!'\(\("\()[ 3.336000 7.380001 7.104000 7.380001 11.688001 7.380001 3.816000 6.600000 3.336000 7.356000 6.252000 6.252000 7.380001 6.252000 ] xS
-/F3.1[ 12 0 0 -12 0 0]sf
--13.634766 3.5 m
+0.64719099 0 0 -0.64601767 66.984268 19.703539 cm
+/F1.1[ 13 0 0 -13 0 0]sf
+-92.40918 2 m
+(!!)[ 3.250000 3.250000 ] xS
+/F4.1[ 13 0 0 -13 0 0]sf
+-85.90918 2 m
+(!"#"$"%&!'\(\("\()[ 3.614000 5.772000 5.772000 5.772000 9.386001 5.772000 3.250000 5.772000 3.614000 6.500000 5.057000 5.057000 5.772000 5.057000 ] xS
+/F3.1[ 13 0 0 -13 0 0]sf
+-9.75 2 m
 (!)s
-/Cs2 SC
+/Cs1 SC
 0 0 0 sc
-0.61862099 0 0 -0.61862099 -32.734909 174.17004 cm
-163 177.00002 m
-163 221.09998 l
+0.64719099 0 0 -0.64601767 -38.507862 172.16371 cm
+163 177 m
+163 221.09999 l
 S
 CM
-68.100311 32.44397 m
-69.956177 37.392914 l
-66.244453 37.392914 l
+66.984268 24.161055 m
+68.925842 29.329195 l
+65.042694 29.329195 l
 h
-68.100311 32.44397 m
+66.984268 24.161055 m
 f
 0 J
 0 j
-0.61862099 0 0 -0.61862099 -32.734909 174.17004 cm
-163 229.09999 m
-166 221.09998 l
-160 221.09998 l
+0.64719099 0 0 -0.64601767 -38.507862 172.16371 cm
+163 229.09998 m
+166 221.09999 l
+160 221.09999 l
 h
-163 229.09999 m
+163 229.09998 m
 S
 CM
-184.11372 48.921265 m
-185.32167 47.713318 185.32167 45.754913 184.11372 44.546967 c
-182.90581 43.33902 180.94736 43.33902 179.73943 44.546967 c
-178.53148 45.754913 178.53148 47.713318 179.73943 48.921265 c
-180.94736 50.129211 182.90581 50.129211 184.11372 48.921265 c
+188.35556 41.36808 m
+189.61929 40.106663 189.61929 38.061478 188.35556 36.80006 c
+187.09186 35.53862 185.04295 35.53862 183.77925 36.80006 c
+182.51552 38.061478 182.51552 40.106663 183.77925 41.36808 c
+185.04295 42.629517 187.09186 42.629517 188.35556 41.36808 c
 f
 1 J
 1 j
-0.61862099 0 0 -0.61862099 -32.734909 174.17004 cm
-350.53552 202.46449 m
-352.48816 204.41711 352.48816 207.58287 350.53552 209.53552 c
-348.58292 211.48816 345.41708 211.48816 343.46448 209.53552 c
-341.51184 207.58287 341.51184 204.41711 343.46448 202.46449 c
-345.41708 200.51184 348.58292 200.51184 350.53552 202.46449 c
+0.64719099 0 0 -0.64601767 -38.507862 172.16371 cm
+350.53552 202.46446 m
+352.48819 204.41707 352.48819 207.58292 350.53552 209.53552 c
+348.58292 211.48816 345.41711 211.48816 343.46448 209.53552 c
+341.51187 207.58292 341.51187 204.41707 343.46448 202.46446 c
+345.41711 200.51184 348.58292 200.51184 350.53552 202.46446 c
 S
-/Cs1 SC
-0 sc
-0.61862099 0 0 -0.61862099 181.92657 46.734123 cm
-/F1.1[ 12 0 0 -12 0 0]sf
-6 3.5 m
-(!!+-'",)[ 3.816000 3.816000 7.380001 11.688001 7.620000 4.704000 7.104000 ] xS
-51.914062 3.5 m
-(&""#$%&"+\))[ 4.332000 4.704000 4.704000 6.600000 7.608000 7.632000 4.332000 4.704000 7.380001 4.932000 ] xS
-108.6328 3.5 m
-(-.$\(/*)[ 11.688001 3.336000 7.608000 7.356000 3.336000 6.252000 ] xS
 /Cs2 SC
+0 sc
+0.64719099 0 0 -0.64601767 186.06741 39.084068 cm
+/F1.1[ 13 0 0 -13 0 0]sf
+5.5 2 m
+(!!+-'",&""#$%&"+\)-.$\(/*)[ 3.250000 3.250000 5.772000 10.114000 6.500000 3.614000 6.500000 4.329000 3.614000 3.614000 5.772000 6.500000 6.500000 4.329000 3.614000 5.772000 4.329000 10.114000 3.614000 6.500000 5.772000 3.614000 5.057000 ] xS
+/Cs1 SC
 0 0 0 sc
-0.61862099 0 0 -0.61862099 -32.734909 174.17004 cm
-259.14706 146.7948 m
-334.64316 197.67258 l
+0.64719099 0 0 -0.64601767 -38.507862 172.16371 cm
+259.14706 146.79477 m
+334.64316 197.67255 l
 S
 CM
-178.3864 49.119904 m
-175.31952 53.424652 l
-173.24521 50.346649 l
+182.36374 41.575508 m
+179.15521 46.070908 l
+176.98511 42.856583 l
 h
-178.3864 49.119904 m
+182.36374 41.575508 m
 f
 0 J
 0 j
-0.61862099 0 0 -0.61862099 -32.734909 174.17004 cm
-341.27731 202.14337 m
-336.3197 195.18475 l
-332.96658 200.16034 l
+0.64719099 0 0 -0.64601767 -38.507862 172.16371 cm
+341.27731 202.1434 m
+336.31973 195.18475 l
+332.96658 200.16035 l
 h
-341.27731 202.14337 m
+341.27731 202.1434 m
 S
 1 1 1 sc
 CM
-184.11372 69.954376 m
-185.32167 68.746429 185.32167 66.788025 184.11372 65.580078 c
-182.90581 64.372162 180.94736 64.372162 179.73943 65.580078 c
-178.53148 66.788025 178.53148 68.746429 179.73943 69.954376 c
-180.94736 71.162323 182.90581 71.162323 184.11372 69.954376 c
+188.35556 63.33268 m
+189.61929 62.071259 189.61929 60.026081 188.35556 58.76466 c
+187.09186 57.503223 185.04295 57.503223 183.77925 58.76466 c
+182.51552 60.026081 182.51552 62.071259 183.77925 63.33268 c
+185.04295 64.594116 187.09186 64.594116 188.35556 63.33268 c
 f
 1 J
 1 j
 0 0 0 sc
-0.61862099 0 0 -0.61862099 -32.734909 174.17004 cm
+0.64719099 0 0 -0.64601767 -38.507862 172.16371 cm
 350.53552 168.46448 m
-352.48816 170.41713 352.48816 173.58287 350.53552 175.53552 c
-348.58292 177.48816 345.41708 177.48816 343.46448 175.53552 c
-341.51184 173.58287 341.51184 170.41713 343.46448 168.46448 c
-345.41708 166.51184 348.58292 166.51184 350.53552 168.46448 c
+352.48819 170.41707 352.48819 173.58292 350.53552 175.53552 c
+348.58292 177.48816 345.41711 177.48816 343.46448 175.53552 c
+341.51187 173.58292 341.51187 170.41707 343.46448 168.46448 c
+345.41711 166.51184 348.58292 166.51184 350.53552 168.46448 c
 S
-/Cs1 SC
-0 sc
-0.61862099 0 0 -0.61862099 181.92657 67.767235 cm
-/F4.1[ 12 0 0 -12 0 0]sf
-6 3.5 m
-(%%\)'*\("*%\)*+,-&./+0%&!'\(\("\()[ 3.816000 3.816000 7.620000 7.356000 4.932000 6.252000 7.380001 4.932000 3.816000 7.620000 4.932000 7.344000 7.620000 7.608000 6.600000 4.704000 3.336000 7.344000 7.608000 3.816000 6.600000 3.336000 7.356000 6.252000 6.252000 7.380001 6.252000 ] xS
 /Cs2 SC
+0 sc
+0.64719099 0 0 -0.64601767 186.06741 61.048672 cm
+/F4.1[ 13 0 0 -13 0 0]sf
+5.5 2 m
+(%%\)'*\("*%\)*)[ 3.250000 3.250000 6.500000 6.500000 5.057000 5.057000 5.772000 5.057000 3.250000 6.500000 5.057000 ] xS
+60.280273 2 m
+(+,-&./+0%&!'\(\("\()[ 6.500000 6.500000 6.500000 5.772000 3.614000 3.614000 6.500000 6.500000 3.250000 5.772000 3.614000 6.500000 5.057000 5.057000 5.772000 5.057000 ] xS
+/Cs1 SC
 0 0 0 sc
-0.61862099 0 0 -0.61862099 -32.734909 174.17004 cm
-259.7843 145.45605 m
-332.74463 167.66139 l
+0.64719099 0 0 -0.64601767 -38.507862 172.16371 cm
+259.7843 145.45609 m
+332.74463 167.66141 l
 S
 CM
-177.84242 69.010223 m
-173.64825 72.226654 l
-172.56754 68.67572 l
+181.79465 62.34671 m
+177.40677 65.705551 l
+176.27614 61.997391 l
 h
-177.84242 69.010223 m
+181.79465 62.34671 m
 f
 0 J
 0 j
-0.61862099 0 0 -0.61862099 -32.734909 174.17004 cm
+0.64719099 0 0 -0.64601767 -38.507862 172.16371 cm
 340.39798 169.99072 m
 333.6181 164.79138 l
 331.87112 170.53143 l


Index: papers/ilc2005/syntax/parserclasses.pdf



From bmastenbrook at common-lisp.net  Mon May 23 13:10:40 2005
From: bmastenbrook at common-lisp.net (Brian Mastenbrook)
Date: Mon, 23 May 2005 15:10:40 +0200 (CEST)
Subject: [climacs-cvs] CVS update: papers/ilc2005/syntax/climacssyntax.tex 
Message-ID: <20050523131040.A671E88704@common-lisp.net>

Update of /project/climacs/cvsroot/papers/ilc2005/syntax
In directory common-lisp.net:/tmp/cvs-serv12654

Modified Files:
	climacssyntax.tex 
Log Message:
Kill the TTCN-3 GR diagram

Date: Mon May 23 15:10:40 2005
Author: bmastenbrook

Index: papers/ilc2005/syntax/climacssyntax.tex
diff -u papers/ilc2005/syntax/climacssyntax.tex:1.19 papers/ilc2005/syntax/climacssyntax.tex:1.20
--- papers/ilc2005/syntax/climacssyntax.tex:1.19	Mon May 23 14:35:48 2005
+++ papers/ilc2005/syntax/climacssyntax.tex	Mon May 23 15:10:40 2005
@@ -243,8 +243,8 @@
 parser rules can be quite complicated and involve arbitrary code, but
 for a simple grammar the parsing rules can be entirely represented by
 matching on the classes returned by the tokenizer and parser. Figure
-\ref{fig:syntaxclasses} shows the organization of classes in the TTCN3
-grammar.
+\ref{fig:syntaxclasses} shows the organization of classes in the
+TTCN-3 grammar.
 
 The syntax analysis can be applied either in a per-window or
 per-buffer function. The per-window approach is best suited to
@@ -289,7 +289,7 @@
 
 We describe two different approaches to syntax analysis in the Climacs
 editor. Per-window parsing is used by the provided modes for HTML,
-Common Lisp, Prolog, and a Testing Control Notation (TTCN3).  Each of
+Common Lisp, Prolog, and a Testing Control Notation (TTCN-3).  Each of
 these syntaxes is implemented with the provided Earley parser
 \cite{earley}.  The lute tablature editor uses a per-buffer function
 for its syntax analysis and implements a simple recursive-descent
@@ -301,7 +301,7 @@
 Climacs currently provides four syntaxes using a per-window parsing
 function. Of these the Prolog syntax is the most complete and
 implements the entire ISO Prolog syntax. The HTML, Common Lisp, and
-TTCN3 syntaxes are somewhat less complete in their implementation.
+TTCN-3 syntaxes are somewhat less complete in their implementation.
 Each syntax is free to implement its lexical analyzer and parser in
 the manner which is most convenient for its grammar. All of these
 syntaxes use the provided implementation of the Earley parsing
@@ -345,13 +345,13 @@
 slightly-buggy or incomplete syntax mode will render the whole thing
 useless.  Violation of WiB?
 
-The Testing and Test Control Notation 3 (TTCN3) language is a language
-which captures detailed test specifications. TTCN provides both a
-textual ``core'' grammar and a graphical presentation format similar
-to Message Sequence Charts (see figure \ref{fig:ttcn3gr}). Climacs
-currently provides an editor for a subset of the TTCN3 core language.
+The Testing and Test Control Notation 3 (TTCN-3) language is a
+language which captures detailed test specifications. TTCN provides
+both a textual ``core'' grammar and a graphical presentation format
+similar to Message Sequence Charts. Climacs currently provides an
+editor for a subset of the TTCN-3 core language.
 
-The TTCN3 syntax is implemented with a high-level macro which defines
+The TTCN-3 syntax is implemented with a high-level macro which defines
 classes and adds syntax rules using the syntax protocol for each
 terminal and non-terminal in the grammar. The syntax of this macro
 resembles the BNF form in which the official core grammar is
@@ -360,20 +360,6 @@
 receive their own non-terminal entry in the grammar. In addition, this
 macro defines basic display functions for the syntax objects produced
 by the parser, with language keywords appearing in a separate color.
-
-\begin{figure*}
-  \begin{center}
-    \parbox{0.45\linewidth}{\includegraphics{ttcn3msc}}
-    \parbox{0.25\linewidth}{\texttt{\\ [1cm]\noindent
-        testcase MyTestCase (inout integer MyPar)\\
-        runs on MyMTCtype system SystemType \{\\
-        var integer MyVar := 1;\\
-        MyMTCPort.send(MyTemplate);\\
-        \}}}
-    \caption{A fragment of TTCN3 and its corresponding Graphical Representation (GR)}
-    \label{fig:ttcn3gr}
-  \end{center}
-\end{figure*}
 
 \subsection{Per-Buffer Syntax: a tablature editor}
 \label{sec:tabeditor}



From bmastenbrook at common-lisp.net  Mon May 23 13:27:30 2005
From: bmastenbrook at common-lisp.net (Brian Mastenbrook)
Date: Mon, 23 May 2005 15:27:30 +0200 (CEST)
Subject: [climacs-cvs] CVS update: papers/ilc2005/syntax/climacssyntax.tex 
Message-ID: <20050523132730.7FB3F88704@common-lisp.net>

Update of /project/climacs/cvsroot/papers/ilc2005/syntax
In directory common-lisp.net:/tmp/cvs-serv13692

Modified Files:
	climacssyntax.tex 
Log Message:
LESS FIXME

Date: Mon May 23 15:27:29 2005
Author: bmastenbrook

Index: papers/ilc2005/syntax/climacssyntax.tex
diff -u papers/ilc2005/syntax/climacssyntax.tex:1.20 papers/ilc2005/syntax/climacssyntax.tex:1.21
--- papers/ilc2005/syntax/climacssyntax.tex:1.20	Mon May 23 15:10:40 2005
+++ papers/ilc2005/syntax/climacssyntax.tex	Mon May 23 15:27:29 2005
@@ -211,7 +211,10 @@
 which uses one machine word per element, either as an immediate value
 or as a pointer to a larger element. Climacs buffers can contain any
 object, so in a suitably complex syntax and buffer protocol
-implementation an object in a buffer may ... may what?  FIXME
+implementation any buffer object might correspond to an arbitrary
+number of bytes in the file. For instance, it is concievable that a
+buffer implementation might compress sections of the buffer which are
+not in use.
 
 \section{Syntax Protocol}
 \label{sec:syntax}



From bmastenbrook at common-lisp.net  Mon May 23 13:39:01 2005
From: bmastenbrook at common-lisp.net (Brian Mastenbrook)
Date: Mon, 23 May 2005 15:39:01 +0200 (CEST)
Subject: [climacs-cvs] CVS update: papers/ilc2005/syntax/climacssyntax.tex 
Message-ID: <20050523133901.29C3C88704@common-lisp.net>

Update of /project/climacs/cvsroot/papers/ilc2005/syntax
In directory common-lisp.net:/tmp/cvs-serv14594

Modified Files:
	climacssyntax.tex 
Log Message:
Add my "Future Work" paragraph

Date: Mon May 23 15:39:00 2005
Author: bmastenbrook

Index: papers/ilc2005/syntax/climacssyntax.tex
diff -u papers/ilc2005/syntax/climacssyntax.tex:1.21 papers/ilc2005/syntax/climacssyntax.tex:1.22
--- papers/ilc2005/syntax/climacssyntax.tex:1.21	Mon May 23 15:27:29 2005
+++ papers/ilc2005/syntax/climacssyntax.tex	Mon May 23 15:39:00 2005
@@ -523,7 +523,15 @@
 Lisp implementation.  Thus, the Common Lisp syntax module is likely to
 exercise the Climacs protocols to a very high degree.  This will allow
 us to improve those protocols as well as their corresponding
-implementations. 
+implementations.
+
+The TTCN-3 grammar is currently defined on the core textual
+language. For a large subset of this language, there is a direct
+correspondance between TTCN-3 textual notation and TTCN-3 Graphical
+Representation (GR) diagrams. Implementing a live-updating TTCN-3 GR
+display of a parsed buffer will, in addition to being a useful
+application, serve as a demonstration of the utility of maintaining a
+full parse tree of a buffer.
 
 Another important future direction is the planned implementation of
 the buffer protocol.  Representing a line being edited as a flexichain



From bmastenbrook at common-lisp.net  Mon May 23 13:57:23 2005
From: bmastenbrook at common-lisp.net (Brian Mastenbrook)
Date: Mon, 23 May 2005 15:57:23 +0200 (CEST)
Subject: [climacs-cvs] CVS update: papers/ilc2005/syntax/climacssyntax.bib
	papers/ilc2005/syntax/climacssyntax.tex
	papers/ilc2005/syntax/ttcn3msc.eps
	papers/ilc2005/syntax/ttcn3msc.pdf 
Message-ID: <20050523135723.DF81888704@common-lisp.net>

Update of /project/climacs/cvsroot/papers/ilc2005/syntax
In directory common-lisp.net:/tmp/cvs-serv15539

Modified Files:
	climacssyntax.bib climacssyntax.tex 
Removed Files:
	ttcn3msc.eps ttcn3msc.pdf 
Log Message:
A few more small modifications; only one FIXME remains.

Date: Mon May 23 15:57:22 2005
Author: bmastenbrook

Index: papers/ilc2005/syntax/climacssyntax.bib
diff -u papers/ilc2005/syntax/climacssyntax.bib:1.8 papers/ilc2005/syntax/climacssyntax.bib:1.9
--- papers/ilc2005/syntax/climacssyntax.bib:1.8	Mon May 23 13:34:58 2005
+++ papers/ilc2005/syntax/climacssyntax.bib	Mon May 23 15:57:22 2005
@@ -178,3 +178,16 @@
   OPTannote = 	 {}
 }
 
+ at Manual{TTCN3,
+  title = {Methods for Testing and Specification (MTS); The Testing and Test Control Notation version 3; Part 1: TTCN-3 Core Language},
+  key = {ETSI ES 201 873-1 V2.2.1},
+  organization = {The European Telecommunications Standards Institute},
+  year = {2003}
+}
+
+ at Manual{MSC,
+  title = {Message Sequence Chart (MSC)},
+  key = {ITU-T Z.120},
+  organization = {International Telecommunication Union},
+  year = {1999}
+}


Index: papers/ilc2005/syntax/climacssyntax.tex
diff -u papers/ilc2005/syntax/climacssyntax.tex:1.22 papers/ilc2005/syntax/climacssyntax.tex:1.23
--- papers/ilc2005/syntax/climacssyntax.tex:1.22	Mon May 23 15:39:00 2005
+++ papers/ilc2005/syntax/climacssyntax.tex	Mon May 23 15:57:22 2005
@@ -295,9 +295,8 @@
 Common Lisp, Prolog, and a Testing Control Notation (TTCN-3).  Each of
 these syntaxes is implemented with the provided Earley parser
 \cite{earley}.  The lute tablature editor uses a per-buffer function
-for its syntax analysis and implements a simple recursive-descent
-parsing algorithm.  (FIXME: is this true?  I don't know enough about
-parsing)
+for its syntax analysis and implements a simple state-machine parser
+for its regular notation.
 
 \subsection{Per-Window Syntaxes}
 
@@ -346,13 +345,15 @@
 the file.  This adds a burden on the mode implementor that the syntax
 analyser be both bug-free and correspond with reality; a
 slightly-buggy or incomplete syntax mode will render the whole thing
-useless.  Violation of WiB?
-
-The Testing and Test Control Notation 3 (TTCN-3) language is a
-language which captures detailed test specifications. TTCN provides
-both a textual ``core'' grammar and a graphical presentation format
-similar to Message Sequence Charts. Climacs currently provides an
-editor for a subset of the TTCN-3 core language.
+useless. We plan on implementing a resynchroniziation method for
+parsers, which would allow the parse to continue at the next valid
+parsable state in the buffer; see section \ref{sec:conclusions}.
+
+The Testing and Test Control Notation 3 (TTCN-3) language \cite{TTCN3}
+is a language which captures detailed test specifications. TTCN
+provides both a textual ``core'' grammar and a graphical presentation
+format similar to Message Sequence Charts (MSCs) \cite{MSC}. Climacs
+currently provides an editor for a subset of the TTCN-3 core language.
 
 The TTCN-3 syntax is implemented with a high-level macro which defines
 classes and adds syntax rules using the syntax protocol for each







From crhodes at common-lisp.net  Mon May 23 14:26:16 2005
From: crhodes at common-lisp.net (Christophe Rhodes)
Date: Mon, 23 May 2005 16:26:16 +0200 (CEST)
Subject: [climacs-cvs] CVS update: papers/ilc2005/syntax/climacssyntax.tex 
Message-ID: <20050523142616.3C8EA88704@common-lisp.net>

Update of /project/climacs/cvsroot/papers/ilc2005/syntax
In directory common-lisp.net:/tmp/cvs-serv17345

Modified Files:
	climacssyntax.tex 
Log Message:
A bit more explanation of tablature, following feedback from members of 
the group here.

Date: Mon May 23 16:26:15 2005
Author: crhodes

Index: papers/ilc2005/syntax/climacssyntax.tex
diff -u papers/ilc2005/syntax/climacssyntax.tex:1.23 papers/ilc2005/syntax/climacssyntax.tex:1.24
--- papers/ilc2005/syntax/climacssyntax.tex:1.23	Mon May 23 15:57:22 2005
+++ papers/ilc2005/syntax/climacssyntax.tex	Mon May 23 16:26:15 2005
@@ -202,8 +202,8 @@
 in a specialized array, this will net a worst case space efficiency of
 four bytes of every byte in the file. However, the time advantages of
 this representation outweigh the space inefficiency.  Searching for an
-individual character in a sequence of characters encoded in UTF-8 (or
-other variable-length encoding) is $O(n)$, because each individual
+individual character in a sequence of $n$ characters encoded in UTF-8
+(or other variable-length encoding) is $O(n)$, because each individual
 character must be examined to determine the number of octets which are
 stored to represent that character.
 
@@ -315,7 +315,7 @@
 framework.  Firstly, and most importantly, ISO Prolog \cite{ISOProlog}
 is not a context-free grammar: \textit{terms} have an implicit
 priority affecting their parse.\footnote{Formally, the grammar could
-  be made context-free by introducing 1200 new production rules.}  The
+  be made context-free by introducing 2400 new production rules.}  The
 implementation of Earley's algorithm, however, was able to address
 this additional complexity with no difficulty.
 
@@ -402,25 +402,29 @@
         |}}
     \caption{An extract from `Lachrime by I. D.' from \textit{A New
         Booke of Tabliture}, published by William Barley (London,
-      1596), E1r, and its \TabCode\ encoding.}
+      1596), E1r, and its \TabCode\ encoding.  The parenthesized
+      characters encode the lines joining and spanning the example,
+      while the individual punctuation characters refer to the
+      fingering marks.}
     \label{fig:barley}
   \end{center}
 \end{figure*}
 
 \TabCode\ \cite{tabcode} is a textual format for description of lute
-tablature.  In its simplest form, it is a sequence of
-whitespace-delimited independent words, where each word represents
-either a set of frets to depress and strings to be sounded, or
-alternatively some element of musical notation (such as a barline);
-figure \ref{fig:besfantlach} shows a fragment of manuscript, and
-demonstrates its \TabCode\ encoding.  It is also possible to encode
-more complex elements of lute tablature notation in \TabCode:
-ornaments, fingering marks, beaming, connecting lines and other
-complex elements can all be accommodated (see figure \ref{fig:barley}
-for examples of some of these more complex elements).  \TabCode\ has
-been used to produce scholarly editions of lute works \cite{Weiss} and
-to assist in computer-based musicological studies (as in
-\cite{ecolm-graz} for example).
+tablature, a form of musical notation.  In its simplest form, it is a
+sequence of whitespace-delimited independent words, where each word
+represents either a set of string--fret coordinates for the player's
+left hand specifying the note or chord to be played or alternatively
+some other element of musical notation (such as a barline); figure
+\ref{fig:besfantlach} shows a fragment of tablature, and demonstrates
+its \TabCode\ encoding.  It is also possible to encode more complex
+elements of lute tablature notation in \TabCode: ornaments, fingering
+marks, beaming, connecting lines and other complex elements can all be
+accommodated (see figure \ref{fig:barley} for examples of some of
+these more complex elements).  \TabCode\ has been used to produce
+scholarly editions of lute works \cite{Weiss} and to assist in
+computer-based musicological studies (as in \cite{ecolm-graz} for
+example).
 
 The \TabCode\ language itself has developed to provide a terse and
 intuitive encoding of tablature, rather than a well-formed grammar for
@@ -442,15 +446,17 @@
   \end{center}
 \end{figure}
 
-More complex to model are beams and connecting lines, which have their
-own semi-independent identity, despite being encoded in \TabCode\ as
+More complex to model are beams\footnote{the term `beam' is used for
+  the grid-like representation of repeated rhythm signs, adapted from
+  standard music notation.} and connecting lines, which have their own
+semi-independent identity, despite being encoded in \TabCode\ as
 modifiers to individual tokens.  In particular, the existence of beams
 and connecting lines means that we cannot parse a buffer into a
 sequence of tabwords and thence into hypothetical higher-level
 structures such as \texttt{beamed-group} and \texttt{connected-pair},
 because these higher-level structures can overlap in non-trivial ways,
-as in figure \ref{fig:board}.  Instead, we deal with these modifiers by
-invoking a parser on the sequence of parsed buffer elements to
+as in figure \ref{fig:board}.  Instead, we deal with these modifiers
+by invoking a parser on the sequence of parsed buffer elements to
 generate parallel sequences of beams, connecting lines and other such
 tablature elements.
 
@@ -490,13 +496,13 @@
 unchanged for most editing operations.
 
 To assist the editorial process, we have also implemented MIDI audio
-feedback: in addition to a command to render the entire tablature, we
-provide several gestures to play individual chords: one intended for
-use during the initial entry of the encoding, to act as a rapid
-error-detection aid, and a motion command and mouse gesture to assist
-revision and navigation.  At present, this MIDI support is based on
-Apple's CoreMIDI framework on Mac OS X; a port to alsa-lib on Linux is
-in progress.
+feedback: in addition to a command to render the entire tablature in
+sound, we provide several gestures to play individual chords: one
+intended for use during the initial entry of the encoding, to act as a
+rapid error-detection aid, and a motion command and mouse gesture to
+assist revision and navigation.  At present, this MIDI support is
+based on Apple's CoreMIDI framework on Mac OS X; a port to alsa-lib on
+Linux is in progress.
 
 \section{Future Work and Conclusions}
 \label{sec:conclusions}



From crhodes at common-lisp.net  Tue May 24 09:08:44 2005
From: crhodes at common-lisp.net (Christophe Rhodes)
Date: Tue, 24 May 2005 11:08:44 +0200 (CEST)
Subject: [climacs-cvs] CVS update: papers/ilc2005/syntax/climacssyntax.tex 
Message-ID: <20050524090844.5F0EF88751@common-lisp.net>

Update of /project/climacs/cvsroot/papers/ilc2005/syntax
In directory common-lisp.net:/tmp/cvs-serv20661

Modified Files:
	climacssyntax.tex 
Log Message:
The word from the organizers is that they don't need the paper to be in
ACM format: plain article.cls is fine.  Make it so, and in the process
deuglify some bits.

Date: Tue May 24 11:08:43 2005
Author: crhodes

Index: papers/ilc2005/syntax/climacssyntax.tex
diff -u papers/ilc2005/syntax/climacssyntax.tex:1.24 papers/ilc2005/syntax/climacssyntax.tex:1.25
--- papers/ilc2005/syntax/climacssyntax.tex:1.24	Mon May 23 16:26:15 2005
+++ papers/ilc2005/syntax/climacssyntax.tex	Tue May 24 11:08:43 2005
@@ -1,11 +1,16 @@
-\documentclass{acm_proc_article-sp}
+\documentclass[11pt]{article}
+
+%\newenvironment{figure*}{figure}
 
 \newcommand{\TabCode}{\textit{TabCode}}
 
-\usepackage[a4paper,textwidth=7in,textheight=9in]{geometry}
+\usepackage[a4paper,textwidth=6.7in,textheight=8.7in]{geometry}
+\usepackage{graphics}
+\usepackage{times}
 
-\begin{document}
+\pagestyle{empty}
 
+\begin{document}
 %\geometry{letterpaper}
 %\usepackage{graphicx}
 %\usepackage{amssymb}
@@ -13,30 +18,37 @@
 %\DeclareGraphicsRule{.tif}{png}{.png}{`convert #1 `dirname #1`/`basename #1 .tif`.png}
 
 \title{Syntax Analysis in the Climacs Text Editor}
-\numberofauthors{3}
+%\numberofauthors{3}
 \author{
-  \alignauthor Christophe Rhodes\\
-  \affaddr{Centre for Cognition, Computation and Culture}\\
-  \affaddr{Goldsmiths College}\\
-  \affaddr{University of London}\\
-  \affaddr{New Cross Gate}\\
-  \affaddr{London SE14 6NW, UK}\\
-  \email{c.rhodes at gold.ac.uk}
-  \alignauthor Robert Strandh\\
-  \affaddr{LaBRI}\\
-  \affaddr{Universit\'{e} Bordeaux 1}\\
-  \affaddr{351, cours de la Lib\'{e}ration}\\
-  \affaddr{33405 Talence Cedex}
-  \affaddr{FRANCE}\\
-  \email{strandh at labri.fr}
-  \alignauthor Brian Mastenbrook\\
-  \affaddr{Motorola}\\
-  \affaddr{1303 E. Algonquin Road}\\
-  \affaddr{Schaumburg, IL, USA  60196}\\
-  \email{brian at mastenbrook.net}
+  \begin{tabular}[t]{c}
+    \bf Christophe Rhodes\\
+    Department of Computing\\
+    Goldsmiths College\\
+    University of London\\
+    New Cross Gate\\
+    London SE14 6NW, UK\\
+    \tt c.rhodes at gold.ac.uk
+  \end{tabular}
+  \begin{tabular}[t]{c}
+    \bf Robert Strandh\\
+    LaBRI\\
+    Universit\'{e} Bordeaux 1\\
+    351, cours de la Lib\'{e}ration\\
+    33405 Talence Cedex\\
+    FRANCE\\
+    \tt strandh at labri.fr
+  \end{tabular}
+  \begin{tabular}[t]{c}
+    \bf Brian Mastenbrook\\
+    Motorola\\
+    1303 E. Algonquin Road\\
+    Schaumburg, IL, USA  60196\\
+    \tt brian at mastenbrook.net
+  \end{tabular}
 }
 
 \maketitle
+\thispagestyle{empty}
 
 \begin{abstract}
   The Climacs text editor is a CLIM implementation of a text editor in
@@ -50,10 +62,10 @@
   using a per-buffer function for its parsing.
 \end{abstract}
 
-\category{D.2.3}{Coding Tools and Techniques}{Program editors}
-\category{D.3.4}{Processors}{Incremental compilers}
+%\category{D.2.3}{Coding Tools and Techniques}{Program editors}
+%\category{D.3.4}{Processors}{Incremental compilers}
 
-\keywords{Editors, Parsing, Tablature}
+%\keywords{Editors, Parsing, Tablature}
 
 \section{Introduction}
 
@@ -71,8 +83,10 @@
 
 \begin{figure*}
 \begin{center}
+{\small
 \begin{tabular}{|c|c|c|c|c|}
-\hline \textbf{Editor} & \textbf{Buffer Implementation} & \textbf{Syntax Analysis} & \textbf{Language}
+\hline
+ \textbf{Editor} & \textbf{Buffer Implementation} & \textbf{Syntax Analysis} & \textbf{Language}
 \\
 \hline TECO & Gap buffer & Unknown & Assembly + TECO Macros
 \\
@@ -89,6 +103,7 @@
 \hline Climacs & Multiple & Multiple & Common Lisp
 \\\hline
 \end{tabular}
+}
 \caption{Implementation strategies of multiple Emacs variants}
 \end{center}
 \label{table:editorcompare}



From crhodes at common-lisp.net  Tue May 24 09:20:20 2005
From: crhodes at common-lisp.net (Christophe Rhodes)
Date: Tue, 24 May 2005 11:20:20 +0200 (CEST)
Subject: [climacs-cvs] CVS update: papers/ilc2005/syntax/climacssyntax.bib
	papers/ilc2005/syntax/climacssyntax.tex
	papers/ilc2005/syntax/acm_proc_article-sp.cls 
Message-ID: <20050524092020.75ECB88751@common-lisp.net>

Update of /project/climacs/cvsroot/papers/ilc2005/syntax
In directory common-lisp.net:/tmp/cvs-serv21552

Modified Files:
	climacssyntax.bib climacssyntax.tex 
Removed Files:
	acm_proc_article-sp.cls 
Log Message:
Remove acm_proc_article-sp.cls

Add discussion from amb about persistent buffer implementations

Date: Tue May 24 11:20:19 2005
Author: crhodes

Index: papers/ilc2005/syntax/climacssyntax.bib
diff -u papers/ilc2005/syntax/climacssyntax.bib:1.9 papers/ilc2005/syntax/climacssyntax.bib:1.10
--- papers/ilc2005/syntax/climacssyntax.bib:1.9	Mon May 23 15:57:22 2005
+++ papers/ilc2005/syntax/climacssyntax.bib	Tue May 24 11:20:19 2005
@@ -152,7 +152,7 @@
   title = "{The Craft of Text Editing}",
   publisher = {Springer-Verlag},
   year = {1991, 1999--},
-  note = {http://www.finseth.com/craft}
+  note = {\url{http://www.finseth.com/craft}}
 }
 
 @Manual{ISOProlog,
@@ -191,3 +191,28 @@
   organization = {International Telecommunication Union},
   year = {1999}
 }
+
+ at Unpublished{dessy,
+  author = 	 {Robert Will},
+  title = 	 "{Algebraic Collections: A Standard for Functional Data Structures}",
+  note = 	 {\url{http://www.stud.tu-ilmenau.de/~robertw/dessy/fun/}},
+  OPTkey = 	 {},
+  OPTmonth = 	 {},
+  OPTyear = 	 {},
+  OPTannote = 	 {}
+}
+
+ at Article{adams,
+  author = 	 {Stephen Adams},
+  title = 	 "{Functional pearls: Efficient sets -- a balancing act}",
+  journal = 	 {Journal of Functional Programming},
+  year = 	 {1993},
+  OPTkey = 	 {},
+  volume = 	 {3},
+  number = 	 {4},
+  OPTpages = 	 {553--561},
+  OPTmonth = 	 {},
+  OPTnote = 	 {},
+  OPTannote = 	 {}
+}
+


Index: papers/ilc2005/syntax/climacssyntax.tex
diff -u papers/ilc2005/syntax/climacssyntax.tex:1.25 papers/ilc2005/syntax/climacssyntax.tex:1.26
--- papers/ilc2005/syntax/climacssyntax.tex:1.25	Tue May 24 11:08:43 2005
+++ papers/ilc2005/syntax/climacssyntax.tex	Tue May 24 11:20:19 2005
@@ -6,6 +6,7 @@
 
 \usepackage[a4paper,textwidth=6.7in,textheight=8.7in]{geometry}
 \usepackage{graphics}
+\usepackage{url}
 \usepackage{times}
 
 \pagestyle{empty}
@@ -76,12 +77,12 @@
 management, incremental redisplay, and syntax analysis.  Emacs itself
 traces its lineage to TECO, where Emacs was originally implemented as
 a set of TECO macros.  Climacs is compared to several interesting
-variants of Emacs in Table \ref{table:editorcompare}; more information
+variants of Emacs in table \ref{table:editorcompare}; more information
 about text editing in general, and some editors we shall not discuss
 further, can be found in \cite{FinsethCraft,greenberg,Pike94,woodZ}
 and references therein.
 
-\begin{figure*}
+\begin{table}
 \begin{center}
 {\small
 \begin{tabular}{|c|c|c|c|c|}
@@ -107,7 +108,7 @@
 \caption{Implementation strategies of multiple Emacs variants}
 \end{center}
 \label{table:editorcompare}
-\end{figure*}
+\end{table}
 
 Climacs' syntax analysis is a flexible protocol which can be
 implemented with a full language lexer and parser. GNU Emacs, the most
@@ -174,13 +175,28 @@
 the sequence is stored in a separate slot, along with the beginning of
 the gap.
 
-Climacs also provides a buffer implementation utilizing functional
-data structures as the editable sequence representation. This buffer
-implementation provides a low-cost implementation of undo along
-multiple edit histories. (FIXME: a citation, either to something ``in
-preparation'' or to some previous description of the ideas? It would
-help if someone with more understanding than I of this buffer
-implementation would sketch this out.)
+Climacs also provides three purely functional (aka fully persistent)
+buffer implementations, all based on work in progress \cite{dessy} by
+Robert Will in Haskell, which builds upon older work by Stephen Adams
+\cite{adams}.  The underlying data structure is a balanced binary tree
+with an abstracted-away rebalancing scheme, supporting sequence
+operations needed by the Climacs buffer protocol at reasonable speed
+($O(\log~N$)).  The first implementation, {\tt binseq-buffer}, uses
+one tree whose leaf nodes (buffer elements) can be arbitrary objects.
+An optimized implementation, {\tt obinseq-buffer}, uses less space but
+buffer elements must be non-nil atoms. Finally, {\tt binseq2-buffer}
+combines the previous two implementations, by using a tree whose leaf
+nodes contain the optimized trees representing lines; the benefit of
+this implementation are faster ($O(\log~N)$) operations dealing with
+lines and columns. All the three implementations enable simple and
+inexpensive undo/redo operations because older buffer versions are
+kept as a whole in memory. The space cost of these implementations is
+not negligible, however, significant portions of older buffer versions
+are simply shared with newer buffer versions. Also, it is not
+necessary separately to remember editing operations in undo records,
+in order to preserve precise buffer history. Besides the undo
+operation simplification, the persistent buffer implementations
+facilitate further purely functional operations on Climacs buffers.
 
 Climacs is intended to provide other buffer implementations, one of
 which will use a sequence of lines organized into a tree for quick





From rstrandh at common-lisp.net  Tue May 24 11:43:08 2005
From: rstrandh at common-lisp.net (Robert Strandh)
Date: Tue, 24 May 2005 13:43:08 +0200 (CEST)
Subject: [climacs-cvs] CVS update: papers/ilc2005/syntax/climacssyntax.tex 
Message-ID: <20050524114308.EFE7D8874F@common-lisp.net>

Update of /project/climacs/cvsroot/papers/ilc2005/syntax
In directory common-lisp.net:/tmp/cvs-serv29989

Modified Files:
	climacssyntax.tex 
Log Message:
Minor fixes. 

Included a paragraph on CL syntax.

Date: Tue May 24 13:43:08 2005
Author: rstrandh

Index: papers/ilc2005/syntax/climacssyntax.tex
diff -u papers/ilc2005/syntax/climacssyntax.tex:1.26 papers/ilc2005/syntax/climacssyntax.tex:1.27
--- papers/ilc2005/syntax/climacssyntax.tex:1.26	Tue May 24 11:20:19 2005
+++ papers/ilc2005/syntax/climacssyntax.tex	Tue May 24 13:43:08 2005
@@ -188,10 +188,10 @@
 combines the previous two implementations, by using a tree whose leaf
 nodes contain the optimized trees representing lines; the benefit of
 this implementation are faster ($O(\log~N)$) operations dealing with
-lines and columns. All the three implementations enable simple and
+lines and columns. All three implementations enable simple and
 inexpensive undo/redo operations because older buffer versions are
 kept as a whole in memory. The space cost of these implementations is
-not negligible, however, significant portions of older buffer versions
+not negligible.  However, significant portions of older buffer versions
 are simply shared with newer buffer versions. Also, it is not
 necessary separately to remember editing operations in undo records,
 in order to preserve precise buffer history. Besides the undo
@@ -238,14 +238,16 @@
 character must be examined to determine the number of octets which are
 stored to represent that character.
 
-The Flexichain library uses an unspecialized vector for its storage,
-which uses one machine word per element, either as an immediate value
-or as a pointer to a larger element. Climacs buffers can contain any
-object, so in a suitably complex syntax and buffer protocol
-implementation any buffer object might correspond to an arbitrary
-number of bytes in the file. For instance, it is concievable that a
-buffer implementation might compress sections of the buffer which are
-not in use.
+The Flexichain library was designed to be able to take advantage of
+specialized lisp vectors for compact storage, though this possibility
+is not used by the Climacs buffer implementation.  Instead Climacs
+uses an unspecialized vector for its storage, which uses one machine
+word per element, either as an immediate value or as a pointer to a
+larger element. Climacs buffers can contain any object, so in a
+suitably complex syntax and buffer protocol implementation any buffer
+object might correspond to an arbitrary number of bytes in the
+file. For instance, it is concievable that a buffer implementation
+might compress sections of the buffer which are not in use.
 
 \section{Syntax Protocol}
 \label{sec:syntax}
@@ -291,7 +293,7 @@
 Climacs includes a parser that uses the Earley \cite{earley} parsing
 algorithm.  There are many advantages of this algorithm in the context
 of text editing.  Perhaps most importantly, it does not require any
-preprocessing of the grammar, which makes it necessary for the entire
+preprocessing of the grammar, which would make it necessary for the entire
 grammar to be known ahead of time.  This means that the user can
 load Lisp files containing additional syntax rules to complete the
 existing ones without having to apply any costly grammar analysis.
@@ -396,6 +398,13 @@
 macro defines basic display functions for the syntax objects produced
 by the parser, with language keywords appearing in a separate color.
 
+Much like the other per-window syntax modules, the one for Common Lisp
+uses high-level macros, some of which come with the Earley parser
+framework in order to build a highly modular grammar for parsing all
+of the Common Lisp language.  This syntax module was built by a group
+of undergraduate students at the University of Bordeaux, and is
+currently being tested and improved. 
+
 \subsection{Per-Buffer Syntax: a tablature editor}
 \label{sec:tabeditor}
 
@@ -547,7 +556,7 @@
 some serious limitations and performance problems of the McCLIM
 library.  Nevertheless, we maintain that using CLIM and McCLIM was the
 best choice, and in fact advantageous to other McCLIM users as well,
-as the deficiencies in McCLIM implementation are being addressed and
+as the deficiencies in the McCLIM implementation are being addressed and
 other improvements made for use with Climacs.
 
 Due to its reliance on fairly well-defined protocols, the Climacs text



From crhodes at common-lisp.net  Tue May 24 14:23:45 2005
From: crhodes at common-lisp.net (Christophe Rhodes)
Date: Tue, 24 May 2005 16:23:45 +0200 (CEST)
Subject: [climacs-cvs] CVS update: papers/ilc2005/syntax/climacssyntax.bib
	papers/ilc2005/syntax/climacssyntax.tex 
Message-ID: <20050524142345.ADB288874F@common-lisp.net>

Update of /project/climacs/cvsroot/papers/ilc2005/syntax
In directory common-lisp.net:/tmp/cvs-serv7545

Modified Files:
	climacssyntax.bib climacssyntax.tex 
Log Message:
Add Tomita's parser reference.

Mostly trivial red-ink local modifications to the text.  I have a 
tendency to overly-passive sentence structure; it may be that I have 
pushed it too far in that direction.  Do not feel inhibited from further 
changing things.

Date: Tue May 24 16:23:44 2005
Author: crhodes

Index: papers/ilc2005/syntax/climacssyntax.bib
diff -u papers/ilc2005/syntax/climacssyntax.bib:1.10 papers/ilc2005/syntax/climacssyntax.bib:1.11
--- papers/ilc2005/syntax/climacssyntax.bib:1.10	Tue May 24 11:20:19 2005
+++ papers/ilc2005/syntax/climacssyntax.bib	Tue May 24 16:23:44 2005
@@ -210,7 +210,21 @@
   OPTkey = 	 {},
   volume = 	 {3},
   number = 	 {4},
-  OPTpages = 	 {553--561},
+  pages = 	 {553--561},
+  OPTmonth = 	 {},
+  OPTnote = 	 {},
+  OPTannote = 	 {}
+}
+
+ at Article{tomita,
+  author = 	 {Masaru Tomita},
+  title = 	 "{An Efficient Augmented--Context--Free Parsing Algorithm}",
+  journal = 	 {Computational Linguistics},
+  year = 	 {1987},
+  OPTkey = 	 {},
+  volume = 	 {13},
+  number = 	 {1--2},
+  pages = 	 {31--46},
   OPTmonth = 	 {},
   OPTnote = 	 {},
   OPTannote = 	 {}


Index: papers/ilc2005/syntax/climacssyntax.tex
diff -u papers/ilc2005/syntax/climacssyntax.tex:1.27 papers/ilc2005/syntax/climacssyntax.tex:1.28
--- papers/ilc2005/syntax/climacssyntax.tex:1.27	Tue May 24 13:43:08 2005
+++ papers/ilc2005/syntax/climacssyntax.tex	Tue May 24 16:23:44 2005
@@ -71,21 +71,22 @@
 \section{Introduction}
 
 The field of advanced text editors is a crowded one, with a long
-history and an apparent ability to cause passionate argument. Climacs
+history and an apparent ability to cause passionate argument.  Climacs
 is philosophically part of the Emacs editor tradition, which has
 spawned many variants with many different approaches to buffer
 management, incremental redisplay, and syntax analysis.  Emacs itself
 traces its lineage to TECO, where Emacs was originally implemented as
-a set of TECO macros.  Climacs is compared to several interesting
-variants of Emacs in table \ref{table:editorcompare}; more information
-about text editing in general, and some editors we shall not discuss
-further, can be found in \cite{FinsethCraft,greenberg,Pike94,woodZ}
-and references therein.
+a set of TECO macros.  A summary comparison of Climacs to a
+non-exhaustive set of Emacs variants is presented in table
+\ref{table:editorcompare}; more information about text editing in
+general, and particulars of some editors we shall not discuss further,
+can be found in \cite{FinsethCraft,greenberg,Pike94,woodZ} and
+references therein.
 
 \begin{table}
 \begin{center}
 {\small
-\begin{tabular}{|c|c|c|c|c|}
+\begin{tabular}{|c|c|c|c|}
 \hline
  \textbf{Editor} & \textbf{Buffer Implementation} & \textbf{Syntax Analysis} & \textbf{Language}
 \\
@@ -113,40 +114,39 @@
 Climacs' syntax analysis is a flexible protocol which can be
 implemented with a full language lexer and parser. GNU Emacs, the most
 commonly used Emacs-like editor, uses regular expressions for its
-syntax analysis. Because these regular expressions are applied lazily
-and not on the whole buffer, constructs such as Common Lisp's nestable
-\verb+#| |#+ block comments will often confuse the regular
-expressions. If the parser starts after the opening \verb+#|+ then the
-closing \verb+|#+ will be treated as the start of an escaped symbol
-name. Even if the regular expression parses the whole block comment
-correctly, other expressions can still match on the contents of the
-comment, leading to issues when the first character in a column in the
-block comment is the start of a definition. Emacs users quickly learn
-to insert a space before the open parenthesis to work around Emacs'
-font-lock deficiencies.
+syntax analysis.  As well as the issue that regular expressions cannot
+be used to parse the general case of non-regular constructs such as
+Common Lisp's nestable \verb+#| |#+ block comments, the lazy
+application of those regular expressions can lead to additional
+erroneous parses: if the parser starts after the opening \verb+#|+
+then the closing \verb+|#+ will be treated as the start of an escaped
+symbol name.  Even if the regular expression parses the whole block
+comment correctly, other expressions can still match on the contents
+of the comment, leading to issues when the first character in a column
+in the block comment is the start of a definition: Emacs users quickly
+learn to insert a space before the open parenthesis to work around
+Emacs' font-lock deficiencies.
 
 The Climacs text editor is a combination of frameworks for buffer
 representation and parsing, loosely coupled with a CLIM-based
 \cite{mckayacm} display engine.  It includes the Flexichain library
 \cite{flexichain}, which provides an editable sequence representation
-and mark (cursor) management using a simple linked list for
-implementing the buffer protocol.  Climacs also includes an
-implementation of a slight modification of the Earley parsing
-algorithm \cite{earley}, to assist in the creation of syntax-aware
-editing modes, though such modes can use any appropriate parsing
-algorithm.  An application can combine a particular implementation of
-the buffer protocol, the syntax protocol, and its own display methods
-to produce a sophisticated editor for a particular language.
-
-The Climacs buffer protocol, which provides a standard interface to
-common text editor buffer operations, uses the Flexichain library; we
-discuss this protocol in more detail in section \ref{sec:buffer}.  The
-syntax protocol, which we discuss in section \ref{sec:syntax},
-provides a method for interfacing a lexical analyzer and parser with
-the text editor, and provides for defining methods to draw syntax
-objects in the Climacs window.  In section \ref{sec:syntaxes} we
-discuss the implementation of syntactic analyses for various
-programming languages, including Common Lisp; in section
+and mark (cursor) management, and an implementation of the Earley
+parsing algorithm \cite{earley}, to assist in the creation of
+syntax-aware editing modes.  An application can combine a particular
+implementation of the buffer protocol, the syntax protocol, and its
+own display methods to produce a sophisticated editor for a particular
+language.
+
+The rest of this paper is organised as follows: we discuss the Climacs
+buffer protocol, which provides a standard interface to common text
+editor buffer operations, in section \ref{sec:buffer}.  The syntax
+protocol, which we discuss in section \ref{sec:syntax}, provides a
+mechanism for attaching a lexical analyser and parser to the text
+editor, and provides for defining methods to draw syntax objects in
+the Climacs window.  In section \ref{sec:syntaxes} we present some
+details of the implementation of syntactic analysis of editor buffers
+for various programming languages, including Common Lisp; in section
 \ref{sec:tabeditor}, we discuss an application with Climacs at its
 core to support editing a textual representation of lute tablature.
 We discuss avenues for further development in section
@@ -155,99 +155,96 @@
 \section{Buffer Protocol}
 \label{sec:buffer}
 
-Climacs abstracts the implementation of editable sequences as editor
-buffers using the buffer protocol. The buffer protocol provides a set
-of methods for modifying and reading the contents of a buffer, and
-setting and retrieving marks in the buffer. Buffers can contain
-arbitrary objects. Typically these objects are characters, but the
-buffer can contain any object that the syntax protocol can display in
-the Climacs window. The buffer protocol is independent of any
-implementation of the protocol, which allows flexible representations
-of buffers.
-
-Currently Climacs uses a single Flexichain ``cursorchain'' as the
-editable sequence representation for standard buffers. A cursorchain
-is a circular gap buffer with an arbitrary number of cursors in the
-buffer. Climacs uses these cursors as the implementation of marks in
-the buffer. The single gap-buffer implementation is used by many other
-editors, including GNU Emacs. Flexichain improves on this by making
-the gap buffer circular in its underlying representation; the start of
-the sequence is stored in a separate slot, along with the beginning of
-the gap.
-
-Climacs also provides three purely functional (aka fully persistent)
-buffer implementations, all based on work in progress \cite{dessy} by
-Robert Will in Haskell, which builds upon older work by Stephen Adams
-\cite{adams}.  The underlying data structure is a balanced binary tree
-with an abstracted-away rebalancing scheme, supporting sequence
-operations needed by the Climacs buffer protocol at reasonable speed
-($O(\log~N$)).  The first implementation, {\tt binseq-buffer}, uses
-one tree whose leaf nodes (buffer elements) can be arbitrary objects.
-An optimized implementation, {\tt obinseq-buffer}, uses less space but
-buffer elements must be non-nil atoms. Finally, {\tt binseq2-buffer}
-combines the previous two implementations, by using a tree whose leaf
-nodes contain the optimized trees representing lines; the benefit of
-this implementation are faster ($O(\log~N)$) operations dealing with
-lines and columns. All three implementations enable simple and
-inexpensive undo/redo operations because older buffer versions are
-kept as a whole in memory. The space cost of these implementations is
-not negligible.  However, significant portions of older buffer versions
-are simply shared with newer buffer versions. Also, it is not
-necessary separately to remember editing operations in undo records,
-in order to preserve precise buffer history. Besides the undo
+The Climacs buffer protocol abstracts the operations performed on an
+editor buffer -- or any editable sequence of arbitrary objects -- from
+the implementation of those operations on a given data structure.
+This protocol is a set of generic functions for modifying and reading
+the contents of a buffer, and setting and retrieving marks in the
+buffer.  The protocol abstraction is independent of any particular
+implementation, allowing flexible representations of buffers.
+
+Currently Climacs uses a single {\tt cursorchain} from the Flexichain
+library as the editable sequence representation for standard buffers.
+A \texttt{cursorchain} is a circular gap buffer with an arbitrary
+number of cursors in the buffer.  Climacs uses these cursors as the
+implementation of marks in the buffer. The single gap-buffer
+implementation is used by many other editors, including GNU Emacs.
+Flexichain improves on this by making the gap buffer circular in its
+underlying representation; the start of the sequence is stored in a
+separate slot, along with the beginning of the gap.
+
+Climacs also provides three purely functional (or fully persistent)
+buffer implementations, all based on functional data structures
+\cite{adams,dessy}.  The underlying data structure is a balanced
+binary tree with an abstracted-away rebalancing scheme, supporting
+sequence operations needed by the Climacs buffer protocol at
+reasonable $O(\log~n)$ efficiency.  The first implementation, {\tt
+  binseq-buffer}, uses one tree whose leaf nodes (buffer elements) can
+be arbitrary objects.  An optimised implementation, {\tt
+  obinseq-buffer}, uses less space but buffer elements must be
+non-{\tt nil} atoms. Finally, {\tt binseq2-buffer} combines the
+previous two implementations, by using a tree whose leaf nodes contain
+the optimised trees representing lines; the benefit of this
+implementation are faster ($O(\log~n)$, compared with $O(n)$)
+operations dealing with lines and columns.  All three implementations
+enable simple and inexpensive undo/redo operations because older
+buffer versions are kept as a whole in memory, so there is no need to
+store editing operations to facilitate undo.  Besides the undo
 operation simplification, the persistent buffer implementations
 facilitate further purely functional operations on Climacs buffers.
-
-Climacs is intended to provide other buffer implementations, one of
-which will use a sequence of lines organized into a tree for quick
-access. In this structure, a line can be considered opened or
-closed. When a line is opened, it is represented as a Flexichain
-cursorchain. All editing operations are performed on open lines. A
-fixed number of lines are kept opened according to a
-least-recently-used scheme. When a line is closed it is converted to a
-vector for efficient storage and access. If the line contains only
-base-char objects this vector is a base-string; otherwise, it is
-unspecialized.
+The space cost of these implementations is not negligible, though it
+is alleviated by sharing significant portions of older buffer versions
+with newer versions.
+
+There is scope for provision of further buffer implementations in
+Climacs, one of which will use a sequence of lines organised into a
+tree for quick access.  In this structure, a line can be considered
+opened or closed.  When a line is opened, it is represented as a
+Flexichain {\tt cursorchain}.  All editing operations are performed on
+open lines, and a fixed number of lines are kept opened according to a
+least-recently-used scheme.  When a line is closed it is converted to
+a vector for efficient storage and access.  If the line contains only
+{\tt base-char} objects this vector is a {\tt base-string}; otherwise,
+it is unspecialised.
 
 This structure has the advantage of efficient line-based access in the
-buffer. It also provides much less pessimistic behavior than that of a
-single gap buffer when a user is editing two disparate sections in a
-large file. With a single gap buffer, the gap must be moved to the
-point of edit before an edit operation is allowed. When the buffer is
-large and edit operations occur frequently at multiple locations in
-the buffer, this requires a substantial amount of copying between
-edits. In this situation single-gap-buffer editors such as GNU Emacs
-will noticably pause between edits to move the gap. A structure which
-contains a sequence of lines and keeps the most recently used lines
-open as gap buffers can operate as a multi-gap buffer with automatic
-gap placement, while not providing pessimistic performance when
-accessing a specific line in the buffer.
+buffer. It also provides much better behaviour than that of a single
+gap buffer when a user is editing two disparate sections in a large
+file.  With a single gap buffer, the gap must be moved to the point of
+edit before an edit operation is allowed; when the buffer is large and
+edit operations occur frequently at multiple locations in the buffer,
+this requires a substantial amount of copying between edits. In this
+situation single-gap-buffer editors such as GNU Emacs will noticeably
+pause between edits to move the gap.  A structure which contains a
+sequence of lines and keeps the most recently used lines open as gap
+buffers can operate as a multi-gap buffer with automatic gap
+placement, while not suffering poor performance when accessing a
+specific line in the buffer.
 
-The efficiency of Climacs buffers depends greatly on the
+The efficiency of Climacs buffers depends of course on the
 implementation of the buffer protocol that is used. Space efficiency
 will also depend on the implementation of Common Lisp which is used to
-run Climacs. In Steel Bank Common Lisp, the type character is
+run Climacs. In Steel Bank Common Lisp, the type {\tt character} is
 represented with the full 21 bits used by the Unicode character space.
-External character encodings other than Unicode are converted to
-UTF-32 when a file is read in to memory.  If the characters are stored
-in a specialized array, this will net a worst case space efficiency of
-four bytes of every byte in the file. However, the time advantages of
-this representation outweigh the space inefficiency.  Searching for an
-individual character in a sequence of $n$ characters encoded in UTF-8
-(or other variable-length encoding) is $O(n)$, because each individual
-character must be examined to determine the number of octets which are
-stored to represent that character.
+External character encodings are converted to UTF-32 when a file is
+read in to memory.  If the characters are stored in a specialised
+array, this will net a worst case space efficiency of four bytes of
+every byte in the file. However, the time advantages of this
+representation outweigh the space inefficiency for our purposes.
+Searching for an individual character in a sequence of $n$ characters
+encoded in UTF-8 (or other variable-length encoding) is $O(n)$,
+because each individual character must be examined to determine the
+number of octets which are stored to represent that character.
 
 The Flexichain library was designed to be able to take advantage of
-specialized lisp vectors for compact storage, though this possibility
-is not used by the Climacs buffer implementation.  Instead Climacs
-uses an unspecialized vector for its storage, which uses one machine
-word per element, either as an immediate value or as a pointer to a
-larger element. Climacs buffers can contain any object, so in a
-suitably complex syntax and buffer protocol implementation any buffer
-object might correspond to an arbitrary number of bytes in the
-file. For instance, it is concievable that a buffer implementation
-might compress sections of the buffer which are not in use.
+specialised lisp vectors for compact storage, though this possibility
+is not used by the current Climacs buffer implementation.  Instead
+Climacs uses an unspecialised vector for its storage, which uses one
+machine word per element, either as an immediate value or as a pointer
+to a larger element.  More space-efficient buffer implementations are
+possible, should it be necessary: for instance, it is conceivable that
+a buffer implementation might choose to compress sections of the
+buffer which are not in use.
 
 \section{Syntax Protocol}
 \label{sec:syntax}
@@ -255,7 +252,7 @@
 \begin{figure*}
   \begin{center}
     \includegraphics{parserclasses}
-    \caption{Organization of classes used by a typical syntax}
+    \caption{Organisation of classes used by a typical syntax}
     \label{fig:syntaxclasses}
   \end{center}
 \end{figure*}
@@ -264,72 +261,75 @@
 buffer parsers and syntax-aware display mechanisms. The set of hooks
 that Climacs provides to allow this is the syntax protocol. A syntax
 in Climacs is a class and set of methods which provide a lexical
-analyzer, parser, and display methods for a buffer. The incremental
+analyser, parser, and display methods for a buffer. The incremental
 parser associated with a syntax creates and updates a parse tree of a
 buffer's contents, and provides a mechanism for drawing these parsed
 objects in a window. The parser accepts lexemes produced by an
-incremental lexical analyzer. Display is handled by drawing methods
+incremental lexical analyser. Display is handled by drawing methods
 implemented using the CLIM high-level display toolkit.
 
-Though a syntax is free to choose its own implementation strategy,
-lexical analysis and parsing of the buffer is typically done in an
-object-oriented fashion. The lexer operates on objects in the buffer,
-usually characters, and returns objects of various classes. Each
-parser production is represented by a class. In complex syntaxes, the
-parser rules can be quite complicated and involve arbitrary code, but
-for a simple grammar the parsing rules can be entirely represented by
-matching on the classes returned by the tokenizer and parser. Figure
-\ref{fig:syntaxclasses} shows the organization of classes in the
-TTCN-3 grammar.
+Though an implementation of a syntax is free to choose its own parser
+implementation strategy, lexical analysis and parsing of the buffer is
+typically done in an object-oriented fashion. The lexer operates on
+objects in the buffer, usually characters, and returns objects of
+various classes. Each parser production is represented by a class. In
+complex syntaxes, the parser rules can be quite complicated and
+involve arbitrary code, but for a simple grammar the parsing rules can
+be entirely represented by matching on the classes returned by the
+tokeniser and parser. Figure \ref{fig:syntaxclasses} shows the
+organisation of classes in the TTCN-3 grammar.
 
-The syntax analysis can be applied either in a per-window or
-per-buffer function. The per-window approach is best suited to
+The syntax analysis is divided between a per-window and a per-buffer
+function.  Performing the analysis per-window is best suited to
 analysis of text where the parse tree will be used only for display
 and editing, as it is less important if the parse tree for off-screen
-text is up-to-date at every point during an edit. The per-buffer
+text is up-to-date at every point during an edit.  The per-buffer
 approach is appropriate when the parse tree will also be used for some
-other display or analysis of the text in the buffer.
-
-Climacs includes a parser that uses the Earley \cite{earley} parsing
-algorithm.  There are many advantages of this algorithm in the context
-of text editing.  Perhaps most importantly, it does not require any
-preprocessing of the grammar, which would make it necessary for the entire
-grammar to be known ahead of time.  This means that the user can
-load Lisp files containing additional syntax rules to complete the
-existing ones without having to apply any costly grammar analysis.
-Other advantages include the possibility of using ambiguous grammars,
+other display or analysis of the text in the buffer, though it is also
+used for invalidating a region of the previous parse based on the
+extent of the region damaged by an edit.
+
+Climacs includes a parser generator that implements the Earley
+\cite{earley} algorithm.  There are many advantages of this algorithm
+in the context of text editing.  Perhaps most importantly, no grammar
+preprocessing is required: so it is not necessary for the entire
+grammar to be known ahead of time.  This means that the user can load
+Lisp files containing additional syntax rules to complete the existing
+ones without having to apply any costly grammar analysis.  Other
+advantages include the possibility of handling ambiguous grammars,
 since the Earley parsing algorithm accepts the full class of
 context-free grammars.  This feature is crucial in certain
-applications, for instance in a grammar checker for natural
-languages.  The Climacs syntax protocol can, but is not required
-to, use the provided Earley parser.  It can use any algorithm with an
-explicit representation of the parser state, which is a necessary, but
+applications, for instance in a grammar checker for natural languages.
+Implementations of the Climacs syntax protocol may, but are not
+required to, use the provided Earley parser: any algorithm with an
+explicit representation of the parser state (which is a necessary, but
 not sufficient, requirement for making the parsing algorithm
-incremental. 
+incremental) is potentially suitable.
 
-However, the Earley parsing algorithm is relatively slow compared to
-table-based algorithms such as the LR shift/reduce algorithm.
-Worst-case complexity is $O(n^3)$ where $n$ is the size of the input.
-It drops to $O(n^2)$ for unambiguous grammars and to $O(n)$ for a
-large class of grammars suitable for parsing programming langauges.
-Even so, the complexity is often proportional to the size of the
-grammar (which is considered a constant by Earley), which can be
-problematic in a text editor.  We have yet to determine whether the
-implementation of the Earley algorithm that we provide will turn out
-to be sufficiently fast for most Climacs syntax modules.  Other
-possibilities include the Tomita parsing algorithm which provides more
-generality than LR, but which is nearly as fast in most cases.
+It should be noted that the Earley parsing algorithm is relatively
+slow compared to table-based algorithms such as the LR shift/reduce
+algorithm.  Worst-case complexity is $O(n^3)$ where $n$ is the size of
+the input.  It drops to $O(n^2)$ for unambiguous grammars and to
+$O(n)$ for a large class of grammars suitable for parsing programming
+languages.  Additionally, the complexity is often proportional to the
+size of the grammar (which is considered a constant by Earley), which
+can be problematic in a text editor.  We have yet to determine whether
+the implementation of the Earley algorithm that we provide will turn
+out to be sufficiently fast for most Climacs syntax modules.  Other
+possibilities include the Tomita parsing algorithm \cite{tomita} which
+provides more generality than LR, but which is nearly as fast in most
+cases.
 
 \section{Syntaxes}
 \label{sec:syntaxes}
 
-We describe two different approaches to syntax analysis in the Climacs
-editor. Per-window parsing is used by the provided modes for HTML,
-Common Lisp, Prolog, and a Testing Control Notation (TTCN-3).  Each of
-these syntaxes is implemented with the provided Earley parser
-\cite{earley}.  The lute tablature editor uses a per-buffer function
-for its syntax analysis and implements a simple state-machine parser
-for its regular notation.
+We describe examples illustrating two different approaches to syntax
+analysis in the Climacs editor.  Per-window parsing is used by the
+provided modes for HTML, Common Lisp, Prolog, and a Testing Control
+Notation (TTCN-3).  Each of these syntaxes is implemented with the
+provided Earley parser \cite{earley}.  The lute tablature editor uses
+a per-buffer function for its syntax analysis and implements a simple
+state-machine parser for its regular notation.
 
 \subsection{Per-Window Syntaxes}
 
@@ -337,7 +337,7 @@
 function. Of these the Prolog syntax is the most complete and
 implements the entire ISO Prolog syntax. The HTML, Common Lisp, and
 TTCN-3 syntaxes are somewhat less complete in their implementation.
-Each syntax is free to implement its lexical analyzer and parser in
+Each syntax is free to implement its lexical analyser and parser in
 the manner which is most convenient for its grammar. All of these
 syntaxes use the provided implementation of the Earley parsing
 algorithm, but each provides its own set of macros for defining parser
@@ -348,9 +348,9 @@
 framework.  Firstly, and most importantly, ISO Prolog \cite{ISOProlog}
 is not a context-free grammar: \textit{terms} have an implicit
 priority affecting their parse.\footnote{Formally, the grammar could
-  be made context-free by introducing 2400 new production rules.}  The
-implementation of Earley's algorithm, however, was able to address
-this additional complexity with no difficulty.
+  be made context-free by introducing a large number of new production
+  rules.}  The implementation of Earley's algorithm, however, was able
+to address this additional complexity with no difficulty.
 
 Another area of difficulty is the fact that parsing a Prolog text can
 change the grammar itself through the use of the \texttt{op/3}
@@ -359,7 +359,7 @@
   :- op(100,xfy,<>).
 \end{verbatim}
 in a Prolog text means that, after parsing this directive, the token
-\texttt{<>} must be recognized as an right-associative operator with
+\texttt{<>} must be recognised as an right-associative operator with
 priority 100 in the grammar.  This is achievable by keeping a cache of
 parsed \texttt{op/3} directives, and maintaining and invalidating it
 in parallel with the parse of the buffer itself.
@@ -371,16 +371,19 @@
 syntax, interpretation of quoting rules and escape sequences in
 strings are very variable, while additionally treatment of operators
 in currently-available Prologs can differ markedly from the standard
-requirements.  Nevertheless, work is underway to use Climacs' syntax
-analysis to provide a front-end for a Prolog development environment.
+requirements; this means that working code written for these Prologs
+can be flagged as a parse error by Climacs.  Nevertheless, work is
+underway to use Climacs' syntax analysis to provide a front-end for a
+Prolog development environment.
 
 At present, one parse error implies the invalidation of the rest of
 the file.  This adds a burden on the mode implementor that the syntax
 analyser be both bug-free and correspond with reality; a
-slightly-buggy or incomplete syntax mode will render the whole thing
-useless. We plan on implementing a resynchroniziation method for
-parsers, which would allow the parse to continue at the next valid
-parsable state in the buffer; see section \ref{sec:conclusions}.
+slightly-buggy or incomplete syntax mode can severely impair the
+utility of the editor.  We plan to implement a resynchronisation
+method for parsers, which would allow the parse to continue at the
+next valid parsable state in the buffer; see section
+\ref{sec:conclusions}.
 
 The Testing and Test Control Notation 3 (TTCN-3) language \cite{TTCN3}
 is a language which captures detailed test specifications. TTCN
@@ -396,7 +399,7 @@
 productions in the form of ``any number of'' or ``one or more of''
 receive their own non-terminal entry in the grammar. In addition, this
 macro defines basic display functions for the syntax objects produced
-by the parser, with language keywords appearing in a separate color.
+by the parser, with language keywords appearing in a separate colour.
 
 Much like the other per-window syntax modules, the one for Common Lisp
 uses high-level macros, some of which come with the Earley parser
@@ -442,7 +445,7 @@
         |}}
     \caption{An extract from `Lachrime by I. D.' from \textit{A New
         Booke of Tabliture}, published by William Barley (London,
-      1596), E1r, and its \TabCode\ encoding.  The parenthesized
+      1596), E1r, and its \TabCode\ encoding.  The parenthesised
       characters encode the lines joining and spanning the example,
       while the individual punctuation characters refer to the
       fingering marks.}
@@ -453,7 +456,7 @@
 \TabCode\ \cite{tabcode} is a textual format for description of lute
 tablature, a form of musical notation.  In its simplest form, it is a
 sequence of whitespace-delimited independent words, where each word
-represents either a set of string--fret coordinates for the player's
+represents either a set of fret--string coordinates for the player's
 left hand specifying the note or chord to be played or alternatively
 some other element of musical notation (such as a barline); figure
 \ref{fig:besfantlach} shows a fragment of tablature, and demonstrates
@@ -522,18 +525,19 @@
 of the order of 200--300 words, which requires only little time to
 parse on modern hardware.  However, such a parsing scheme would stress
 the display engine if a complete redraw were forced on every edit, so
-we have implemented the obvious optimizations: the extent of the edit,
+we have implemented the obvious optimisations: the extent of the edit,
 along with its typical locality of effect, are used to limit the
 damaged region as before, so preserving the identity of unaffected
 tabwords; this identity can then be used in a cache informing CLIM's
 incremental redisplay mechanism.
 
 We handle parse errors on a word-by-word basis, so that even during
-editing the vast majority of a tabcode buffer can be graphically
+editing the vast majority of a \TabCode\  buffer can be graphically
 presented, rather than only up to the current location; by returning
-our best guess at the intent of a particular word and resynchronizing
+our best guess at the intent of a particular word and resynchronising
 at the next whitespace, we can preserve the tablature view mostly
-unchanged for most editing operations.
+unchanged for most editing operations, and highlight individual errors
+for the user's attention.
 
 To assist the editorial process, we have also implemented MIDI audio
 feedback: in addition to a command to render the entire tablature in
@@ -547,41 +551,43 @@
 \section{Future Work and Conclusions}
 \label{sec:conclusions}
 
-Climacs is already a very competent and stable editor, especially
-given the relatively small amount of work (only a few person-months)
-that has been put into it so far.  Using CLIM (and in particular the
-McCLIM \cite{ilc2002-moore} implementation) as the display engine has
-allowed the project to progress much more rapidly than would otherwise
-have been possible.  However, Climacs development has also revealed
-some serious limitations and performance problems of the McCLIM
-library.  Nevertheless, we maintain that using CLIM and McCLIM was the
-best choice, and in fact advantageous to other McCLIM users as well,
-as the deficiencies in the McCLIM implementation are being addressed and
-other improvements made for use with Climacs.
+Climacs is already a very capable editor, especially given the
+relatively small amount of work (only a few person-months) that has
+been put into it so far.  Using CLIM (and in particular the McCLIM
+\cite{ilc2002-moore} implementation) as the display engine has allowed
+the project to progress much more rapidly than would otherwise have
+been possible.  It should be noted that Climacs development has also
+revealed some serious limitations and performance problems of the
+McCLIM library.  Nevertheless, we maintain that using CLIM and McCLIM
+was the best choice, and in fact advantageous to other McCLIM users as
+well, as the deficiencies in the McCLIM implementation are being
+addressed and other improvements made for use with Climacs.
 
 Due to its reliance on fairly well-defined protocols, the Climacs text
 editor framework is flexible enough to allow for different future
 directions.  Turning the Common Lisp syntax module into an excellent
 programming tool for Lisp programmers is high on the list of
-priorities, for many reasons.  First, it will encourage further work
-on Climacs.  Second, the Common Lisp syntax module is likely to become
+priorities, for several reasons: first, it will encourage further work
+on Climacs; second, the Common Lisp syntax module is likely to become
 one of the more advanced ones to exist for Climacs, given that Climacs
 has unique and direct access to the features of the underlying Common
-Lisp implementation.  Thus, the Common Lisp syntax module is likely to
-exercise the Climacs protocols to a very high degree.  This will allow
-us to improve those protocols as well as their corresponding
-implementations.
+Lisp implementation.\footnote{The possibility of providing this level
+  of editor integration for Prolog, given the existence of Prolog
+  implementations embedded in Lisps, is also of interest.}  Thus, the
+Common Lisp syntax module is likely to exercise the Climacs protocols
+to a very high degree.  This will allow us to improve those protocols
+as well as their corresponding implementations.
 
 The TTCN-3 grammar is currently defined on the core textual
 language. For a large subset of this language, there is a direct
-correspondance between TTCN-3 textual notation and TTCN-3 Graphical
+correspondence between TTCN-3 textual notation and TTCN-3 Graphical
 Representation (GR) diagrams. Implementing a live-updating TTCN-3 GR
 display of a parsed buffer will, in addition to being a useful
 application, serve as a demonstration of the utility of maintaining a
 full parse tree of a buffer.
 
 Another important future direction is the planned implementation of
-the buffer protocol.  Representing a line being edited as a flexichain
+the buffer protocol.  Representing a line being edited as a Flexichain
 can greatly improve the performance of some crucial operations that
 currently require looping over each buffer object until a newline
 character is found.  Other operations that are currently prohibitive
@@ -590,32 +596,32 @@
 One disadvantage of the current parsing scheme is that a single parse
 error prevents analysis of the rest of the buffer, which is
 potentially disturbing to a user's workflow.  For relatively simple
-grammars such as \TabCode, it is simple enough to resynchronize at the
+grammars such as \TabCode, it is simple enough to resynchronise at the
 next token, whereas for more complex grammars the resolution is less
-clear.  Providing a framework for customizeable resynchronising of the
+clear.  Providing a framework for customisable resynchronising of the
 parser after a parse error would allow for more user-friendly editing.
 
 Our plans for Climacs go further than creating an improved
 implementation of Emacs.  We intend to make Climacs a fully-integrated
 CLIM application.  This implies among other things using the
 presentation-type system of CLIM to exchange objects between Climacs
-and other CLIM appliations such as an inspector application, a
+and other CLIM applications such as an inspector application, a
 debugger pane, etc.  We also hope that implementors of other CLIM
 applications such as mail readers, news readers, etc, will consider
 using Climacs for creating messages.
 
-We are often asked whether applications such as VM and Gnus for GNU
-Emacs will be available for Climacs.  Our opinion is that such
+We are often asked whether Emacs-based applications such as VM and
+Gnus will be available for Climacs.  Our opinion is that such
 applications currently run as GNU Emacs subsystems simply because GNU
 Emacs does not have an independent substrate such as CLIM for creating
 user interfaces.  Climacs is itself a CLIM application, and
 applications such as mail readers and news readers that do not require
 editable buffers should instead be implemented directly as CLIM
-applications, perhaps calling Climacs to write messages.
+applications, optionally calling Climacs to compose and edit messages.
 
 %\nocite{*}
 
-\section*{Acknowledgments}
+\section*{Acknowledgements}
 
 The authors wish to thank Aleksandr Bakic for fruitful discussions.
 B.M.\ acknowledges Motorola's generous support.  C.R.\ is supported by



From bmastenbrook at common-lisp.net  Tue May 24 15:01:49 2005
From: bmastenbrook at common-lisp.net (Brian Mastenbrook)
Date: Tue, 24 May 2005 17:01:49 +0200 (CEST)
Subject: [climacs-cvs] CVS update: papers/ilc2005/syntax/climacssyntax.tex 
Message-ID: <20050524150149.BC06F8874F@common-lisp.net>

Update of /project/climacs/cvsroot/papers/ilc2005/syntax
In directory common-lisp.net:/tmp/cvs-serv10331

Modified Files:
	climacssyntax.tex 
Log Message:
Update the section about the proposed sequence-of-lines structure

Date: Tue May 24 17:01:49 2005
Author: bmastenbrook

Index: papers/ilc2005/syntax/climacssyntax.tex
diff -u papers/ilc2005/syntax/climacssyntax.tex:1.28 papers/ilc2005/syntax/climacssyntax.tex:1.29
--- papers/ilc2005/syntax/climacssyntax.tex:1.28	Tue May 24 16:23:44 2005
+++ papers/ilc2005/syntax/climacssyntax.tex	Tue May 24 17:01:49 2005
@@ -196,30 +196,34 @@
 is alleviated by sharing significant portions of older buffer versions
 with newer versions.
 
-There is scope for provision of further buffer implementations in
-Climacs, one of which will use a sequence of lines organised into a
-tree for quick access.  In this structure, a line can be considered
-opened or closed.  When a line is opened, it is represented as a
-Flexichain {\tt cursorchain}.  All editing operations are performed on
-open lines, and a fixed number of lines are kept opened according to a
-least-recently-used scheme.  When a line is closed it is converted to
-a vector for efficient storage and access.  If the line contains only
-{\tt base-char} objects this vector is a {\tt base-string}; otherwise,
-it is unspecialised.
+It is anticipated that Climacs will provide several other buffer
+implementations, one of which will use a sequence of lines organised
+into a tree for quick access.  In this structure, a line can be
+considered opened or closed.  When a line is opened, it is represented
+as a Flexichain {\tt cursorchain}.  All editing operations are
+performed on open lines, and a fixed number of lines are kept opened
+according to a least-recently-used scheme.  When a line is closed it
+is converted to a vector for efficient storage and access.  If the
+line contains only {\tt base-char} objects this vector is a {\tt
+  base-string}; otherwise, it is unspecialised.
 
 This structure has the advantage of efficient line-based access in the
-buffer. It also provides much better behaviour than that of a single
-gap buffer when a user is editing two disparate sections in a large
-file.  With a single gap buffer, the gap must be moved to the point of
-edit before an edit operation is allowed; when the buffer is large and
-edit operations occur frequently at multiple locations in the buffer,
-this requires a substantial amount of copying between edits. In this
-situation single-gap-buffer editors such as GNU Emacs will noticeably
-pause between edits to move the gap.  A structure which contains a
-sequence of lines and keeps the most recently used lines open as gap
-buffers can operate as a multi-gap buffer with automatic gap
-placement, while not suffering poor performance when accessing a
-specific line in the buffer.
+buffer, in contrast to a single gap buffer implementation, where
+determining the line number of a mark or placing a mark at a specific
+line is $O(n)$, as the entire buffer must be scanned to determine how
+many newlines precede the mark. The proposed structure also provides
+much better behaviour than that of a single gap buffer when a user is
+editing two disparate sections in a large file.  With a single gap
+buffer, the gap must be moved to the point of edit before an edit
+operation is allowed; when the buffer is large and edit operations
+occur frequently at multiple locations in the buffer, this requires a
+substantial amount of copying between edits. In this situation
+single-gap-buffer editors such as GNU Emacs will noticeably pause
+between edits to move the gap.  A structure which contains a sequence
+of lines and keeps the most recently used lines open as gap buffers
+can operate as a multi-gap buffer with automatic gap placement, while
+not suffering poor performance when accessing a specific line in the
+buffer.
 
 The efficiency of Climacs buffers depends of course on the
 implementation of the buffer protocol that is used. Space efficiency



From bmastenbrook at common-lisp.net  Tue May 24 19:41:35 2005
From: bmastenbrook at common-lisp.net (Brian Mastenbrook)
Date: Tue, 24 May 2005 21:41:35 +0200 (CEST)
Subject: [climacs-cvs] CVS update: papers/ilc2005/syntax/climacssyntax.tex 
Message-ID: <20050524194135.CE85788766@common-lisp.net>

Update of /project/climacs/cvsroot/papers/ilc2005/syntax
In directory common-lisp.net:/tmp/cvs-serv27120

Modified Files:
	climacssyntax.tex 
Log Message:
Expand use of CLIM acronym; rewrite last paragraph to make it less pessimistic

Date: Tue May 24 21:41:35 2005
Author: bmastenbrook

Index: papers/ilc2005/syntax/climacssyntax.tex
diff -u papers/ilc2005/syntax/climacssyntax.tex:1.29 papers/ilc2005/syntax/climacssyntax.tex:1.30
--- papers/ilc2005/syntax/climacssyntax.tex:1.29	Tue May 24 17:01:49 2005
+++ papers/ilc2005/syntax/climacssyntax.tex	Tue May 24 21:41:35 2005
@@ -128,15 +128,15 @@
 Emacs' font-lock deficiencies.
 
 The Climacs text editor is a combination of frameworks for buffer
-representation and parsing, loosely coupled with a CLIM-based
-\cite{mckayacm} display engine.  It includes the Flexichain library
-\cite{flexichain}, which provides an editable sequence representation
-and mark (cursor) management, and an implementation of the Earley
-parsing algorithm \cite{earley}, to assist in the creation of
-syntax-aware editing modes.  An application can combine a particular
-implementation of the buffer protocol, the syntax protocol, and its
-own display methods to produce a sophisticated editor for a particular
-language.
+representation and parsing, loosely coupled with a display engine
+based on the Common Lisp Interface Manager (CLIM) \cite{mckayacm}.  It
+includes the Flexichain library \cite{flexichain}, which provides an
+editable sequence representation and mark (cursor) management, and an
+implementation of the Earley parsing algorithm \cite{earley}, to
+assist in the creation of syntax-aware editing modes.  An application
+can combine a particular implementation of the buffer protocol, the
+syntax protocol, and its own display methods to produce a
+sophisticated editor for a particular language.
 
 The rest of this paper is organised as follows: we discuss the Climacs
 buffer protocol, which provides a standard interface to common text
@@ -615,13 +615,14 @@
 using Climacs for creating messages.
 
 We are often asked whether Emacs-based applications such as VM and
-Gnus will be available for Climacs.  Our opinion is that such
-applications currently run as GNU Emacs subsystems simply because GNU
-Emacs does not have an independent substrate such as CLIM for creating
-user interfaces.  Climacs is itself a CLIM application, and
-applications such as mail readers and news readers that do not require
-editable buffers should instead be implemented directly as CLIM
-applications, optionally calling Climacs to compose and edit messages.
+Gnus will be available for Climacs. We expect that replacements for
+these tools will use CLIM to provide a rich client user
+interface. Rather than fitting a mail reader into the framework of a
+text editor, applications can use CLIM's comprehensive user
+interface. Climacs will then provide a best-of-class buffer editor for
+these applications without restricting the ability of the application
+to work with graphics, graph layout, mouse interaction, multiple
+application panes, or other functions that CLIM does especially well.
 
 %\nocite{*}
 



From bmastenbrook at common-lisp.net  Tue May 24 21:01:56 2005
From: bmastenbrook at common-lisp.net (Brian Mastenbrook)
Date: Tue, 24 May 2005 23:01:56 +0200 (CEST)
Subject: [climacs-cvs] CVS update: papers/ilc2005/syntax/climacssyntax.tex 
Message-ID: <20050524210156.02A2088766@common-lisp.net>

Update of /project/climacs/cvsroot/papers/ilc2005/syntax
In directory common-lisp.net:/tmp/cvs-serv32521

Modified Files:
	climacssyntax.tex 
Log Message:
Clean up the COLON of DOOM!

Date: Tue May 24 23:01:56 2005
Author: bmastenbrook

Index: papers/ilc2005/syntax/climacssyntax.tex
diff -u papers/ilc2005/syntax/climacssyntax.tex:1.30 papers/ilc2005/syntax/climacssyntax.tex:1.31
--- papers/ilc2005/syntax/climacssyntax.tex:1.30	Tue May 24 21:41:35 2005
+++ papers/ilc2005/syntax/climacssyntax.tex	Tue May 24 23:01:56 2005
@@ -114,18 +114,18 @@
 Climacs' syntax analysis is a flexible protocol which can be
 implemented with a full language lexer and parser. GNU Emacs, the most
 commonly used Emacs-like editor, uses regular expressions for its
-syntax analysis.  As well as the issue that regular expressions cannot
-be used to parse the general case of non-regular constructs such as
-Common Lisp's nestable \verb+#| |#+ block comments, the lazy
-application of those regular expressions can lead to additional
-erroneous parses: if the parser starts after the opening \verb+#|+
-then the closing \verb+|#+ will be treated as the start of an escaped
-symbol name.  Even if the regular expression parses the whole block
-comment correctly, other expressions can still match on the contents
-of the comment, leading to issues when the first character in a column
-in the block comment is the start of a definition: Emacs users quickly
-learn to insert a space before the open parenthesis to work around
-Emacs' font-lock deficiencies.
+syntax analysis.  However regular expressions cannot be used to parse
+the general case of non-regular constructs such as Common Lisp's
+nestable \verb+#| |#+ block comments. The lazy application of those
+regular expressions will also lead to additional erroneous parses even
+when nesting is not taken into account when the parser starts after
+the opening \verb+#|+ then the closing \verb+|#+ will be treated as
+the start of an escaped symbol name.  Even if the regular expression
+parses the whole block comment correctly, other expressions can still
+match on the contents of the comment, leading to issues when the first
+character in a column in the block comment is the start of a
+definition. Emacs users quickly learn to insert a space before the
+open parenthesis to work around Emacs' font-lock deficiencies.
 
 The Climacs text editor is a combination of frameworks for buffer
 representation and parsing, loosely coupled with a display engine
@@ -246,7 +246,7 @@
 Climacs uses an unspecialised vector for its storage, which uses one
 machine word per element, either as an immediate value or as a pointer
 to a larger element.  More space-efficient buffer implementations are
-possible, should it be necessary: for instance, it is conceivable that
+possible, should it be necessary. For instance, it is conceivable that
 a buffer implementation might choose to compress sections of the
 buffer which are not in use.
 
@@ -296,7 +296,7 @@
 Climacs includes a parser generator that implements the Earley
 \cite{earley} algorithm.  There are many advantages of this algorithm
 in the context of text editing.  Perhaps most importantly, no grammar
-preprocessing is required: so it is not necessary for the entire
+preprocessing is required, so it is not necessary for the entire
 grammar to be known ahead of time.  This means that the user can load
 Lisp files containing additional syntax rules to complete the existing
 ones without having to apply any costly grammar analysis.  Other
@@ -305,10 +305,9 @@
 context-free grammars.  This feature is crucial in certain
 applications, for instance in a grammar checker for natural languages.
 Implementations of the Climacs syntax protocol may, but are not
-required to, use the provided Earley parser: any algorithm with an
-explicit representation of the parser state (which is a necessary, but
-not sufficient, requirement for making the parsing algorithm
-incremental) is potentially suitable.
+required to, use the provided Earley parser. Any algorithm with an
+explicit representation of the parser state is suitable for use by an
+incremental parse system like that of Climacs' syntax protocol.
 
 It should be noted that the Earley parsing algorithm is relatively
 slow compared to table-based algorithms such as the LR shift/reduce
@@ -350,7 +349,7 @@
 
 Implementing the Prolog syntax proved a good test of the established
 framework.  Firstly, and most importantly, ISO Prolog \cite{ISOProlog}
-is not a context-free grammar: \textit{terms} have an implicit
+is not a context-free grammar; \textit{terms} have an implicit
 priority affecting their parse.\footnote{Formally, the grammar could
   be made context-free by introducing a large number of new production
   rules.}  The implementation of Earley's algorithm, however, was able
@@ -358,7 +357,7 @@
 
 Another area of difficulty is the fact that parsing a Prolog text can
 change the grammar itself through the use of the \texttt{op/3}
-directive: the inclusion of
+directive. The inclusion of
 \begin{verbatim}
   :- op(100,xfy,<>).
 \end{verbatim}
@@ -465,7 +464,7 @@
 some other element of musical notation (such as a barline); figure
 \ref{fig:besfantlach} shows a fragment of tablature, and demonstrates
 its \TabCode\ encoding.  It is also possible to encode more complex
-elements of lute tablature notation in \TabCode: ornaments, fingering
+elements of lute tablature notation in \TabCode. Ornaments, fingering
 marks, beaming, connecting lines and other complex elements can all be
 accommodated (see figure \ref{fig:barley} for examples of some of
 these more complex elements).  \TabCode\ has been used to produce
@@ -476,7 +475,7 @@
 The \TabCode\ language itself has developed to provide a terse and
 intuitive encoding of tablature, rather than a well-formed grammar for
 parsing.  Simple \TabCode, as in figure \ref{fig:besfantlach},
-presents no problems: each chord is an optional rhythm sign (a capital
+presents no problems. Each chord is an optional rhythm sign (a capital
 letter), followed by zero or more notes as fret--string pairs
 (letter--number combinations).  Adding ornaments and fingering marks
 to this structure is simple, as they are merely optional modifiers to
@@ -529,7 +528,7 @@
 of the order of 200--300 words, which requires only little time to
 parse on modern hardware.  However, such a parsing scheme would stress
 the display engine if a complete redraw were forced on every edit, so
-we have implemented the obvious optimisations: the extent of the edit,
+we have implemented the obvious optimisations. The extent of the edit,
 along with its typical locality of effect, are used to limit the
 damaged region as before, so preserving the identity of unaffected
 tabwords; this identity can then be used in a cache informing CLIM's
@@ -544,8 +543,8 @@
 for the user's attention.
 
 To assist the editorial process, we have also implemented MIDI audio
-feedback: in addition to a command to render the entire tablature in
-sound, we provide several gestures to play individual chords: one
+feedback. We provide a command to render the entire tablature in
+sound, and several gestures to play individual chords: one
 intended for use during the initial entry of the encoding, to act as a
 rapid error-detection aid, and a motion command and mouse gesture to
 assist revision and navigation.  At present, this MIDI support is



From crhodes at common-lisp.net  Tue May 24 21:14:39 2005
From: crhodes at common-lisp.net (Christophe Rhodes)
Date: Tue, 24 May 2005 23:14:39 +0200 (CEST)
Subject: [climacs-cvs] CVS update: papers/ilc2005/syntax/climacssyntax.tex 
Message-ID: <20050524211439.546E088766@common-lisp.net>

Update of /project/climacs/cvsroot/papers/ilc2005/syntax
In directory common-lisp.net:/tmp/cvs-serv32603

Modified Files:
	climacssyntax.tex 
Log Message:
after careful consideration, reintroduce one and a half colons

Date: Tue May 24 23:14:38 2005
Author: crhodes

Index: papers/ilc2005/syntax/climacssyntax.tex
diff -u papers/ilc2005/syntax/climacssyntax.tex:1.31 papers/ilc2005/syntax/climacssyntax.tex:1.32
--- papers/ilc2005/syntax/climacssyntax.tex:1.31	Tue May 24 23:01:56 2005
+++ papers/ilc2005/syntax/climacssyntax.tex	Tue May 24 23:14:38 2005
@@ -246,7 +246,7 @@
 Climacs uses an unspecialised vector for its storage, which uses one
 machine word per element, either as an immediate value or as a pointer
 to a larger element.  More space-efficient buffer implementations are
-possible, should it be necessary. For instance, it is conceivable that
+possible, should it be necessary; for instance, it is conceivable that
 a buffer implementation might choose to compress sections of the
 buffer which are not in use.
 
@@ -305,7 +305,7 @@
 context-free grammars.  This feature is crucial in certain
 applications, for instance in a grammar checker for natural languages.
 Implementations of the Climacs syntax protocol may, but are not
-required to, use the provided Earley parser. Any algorithm with an
+required to, use the provided Earley parser: any algorithm with an
 explicit representation of the parser state is suitable for use by an
 incremental parse system like that of Climacs' syntax protocol.
 
@@ -475,11 +475,11 @@
 The \TabCode\ language itself has developed to provide a terse and
 intuitive encoding of tablature, rather than a well-formed grammar for
 parsing.  Simple \TabCode, as in figure \ref{fig:besfantlach},
-presents no problems. Each chord is an optional rhythm sign (a capital
-letter), followed by zero or more notes as fret--string pairs
-(letter--number combinations).  Adding ornaments and fingering marks
-to this structure is simple, as they are merely optional modifiers to
-each note, and can be parsed as such.
+presents no problems.  In such a simple case, each chord is an
+optional rhythm sign (a capital letter), followed by zero or more
+notes as fret--string pairs (letter--number combinations).  Adding
+ornaments and fingering marks to this structure is simple, as they are
+merely optional modifiers to each note, and can be parsed as such.
 
 \begin{figure}
   \begin{center}



From crhodes at common-lisp.net  Tue May 24 21:15:33 2005
From: crhodes at common-lisp.net (Christophe Rhodes)
Date: Tue, 24 May 2005 23:15:33 +0200 (CEST)
Subject: [climacs-cvs] CVS update: papers/ilc2005/syntax/climacssyntax.tex 
Message-ID: <20050524211533.7CB1688766@common-lisp.net>

Update of /project/climacs/cvsroot/papers/ilc2005/syntax
In directory common-lisp.net:/tmp/cvs-serv604

Modified Files:
	climacssyntax.tex 
Log Message:
One last fixup, not colon-related

Date: Tue May 24 23:15:32 2005
Author: crhodes

Index: papers/ilc2005/syntax/climacssyntax.tex
diff -u papers/ilc2005/syntax/climacssyntax.tex:1.32 papers/ilc2005/syntax/climacssyntax.tex:1.33
--- papers/ilc2005/syntax/climacssyntax.tex:1.32	Tue May 24 23:14:38 2005
+++ papers/ilc2005/syntax/climacssyntax.tex	Tue May 24 23:15:32 2005
@@ -528,8 +528,8 @@
 of the order of 200--300 words, which requires only little time to
 parse on modern hardware.  However, such a parsing scheme would stress
 the display engine if a complete redraw were forced on every edit, so
-we have implemented the obvious optimisations. The extent of the edit,
-along with its typical locality of effect, are used to limit the
+we have implemented some obvious optimisations.  The extent of the
+edit, along with its typical locality of effect, are used to limit the
 damaged region as before, so preserving the identity of unaffected
 tabwords; this identity can then be used in a cache informing CLIM's
 incremental redisplay mechanism.



From crhodes at common-lisp.net  Tue May 24 21:29:25 2005
From: crhodes at common-lisp.net (Christophe Rhodes)
Date: Tue, 24 May 2005 23:29:25 +0200 (CEST)
Subject: [climacs-cvs] CVS update: papers/ilc2005/syntax/climacssyntax.tex 
Message-ID: <20050524212925.59EEE88766@common-lisp.net>

Update of /project/climacs/cvsroot/papers/ilc2005/syntax
In directory common-lisp.net:/tmp/cvs-serv1108

Modified Files:
	climacssyntax.tex 
Log Message:
last minute pernickety fiddling: [british] date formatting, because if I
mangle all the spelling to British English I might as well go whole hog;
\noindent for the abstract because having an indent there is just completely
barking.

Date: Tue May 24 23:29:24 2005
Author: crhodes

Index: papers/ilc2005/syntax/climacssyntax.tex
diff -u papers/ilc2005/syntax/climacssyntax.tex:1.33 papers/ilc2005/syntax/climacssyntax.tex:1.34
--- papers/ilc2005/syntax/climacssyntax.tex:1.33	Tue May 24 23:15:32 2005
+++ papers/ilc2005/syntax/climacssyntax.tex	Tue May 24 23:29:24 2005
@@ -8,6 +8,7 @@
 \usepackage{graphics}
 \usepackage{url}
 \usepackage{times}
+\usepackage[british]{babel}
 
 \pagestyle{empty}
 
@@ -52,6 +53,7 @@
 \thispagestyle{empty}
 
 \begin{abstract}
+  \noindent
   The Climacs text editor is a CLIM implementation of a text editor in
   the Emacs tradition.  Climacs was designed to allow for incremental
   parsing of the buffer contents, so that a sophisticated analysis of



From abakic at common-lisp.net  Tue May 24 21:32:43 2005
From: abakic at common-lisp.net (Aleksandar Bakic)
Date: Tue, 24 May 2005 23:32:43 +0200 (CEST)
Subject: [climacs-cvs] CVS update: climacs/Persistent/persistent-undo.lisp 
Message-ID: <20050524213243.09FDF88766@common-lisp.net>

Update of /project/climacs/cvsroot/climacs/Persistent
In directory common-lisp.net:/tmp/cvs-serv1770/Persistent

Modified Files:
	persistent-undo.lisp 
Log Message:
A minor mark-taming bug fix. The persistent undo/redo is a bit out of
sync with the undo/redo methods on standard-undo-tree (especially
redo), so I might have to define a p-undo-tree class and corresponding
undo/redo methods to get around the problem.

Date: Tue May 24 23:32:43 2005
Author: abakic

Index: climacs/Persistent/persistent-undo.lisp
diff -u climacs/Persistent/persistent-undo.lisp:1.1 climacs/Persistent/persistent-undo.lisp:1.2
--- climacs/Persistent/persistent-undo.lisp:1.1	Sat Mar 19 23:08:32 2005
+++ climacs/Persistent/persistent-undo.lisp	Tue May 24 23:32:43 2005
@@ -61,4 +61,5 @@
      (climacs-buffer::cursors buffer)
      #'(lambda (c) (flexichain::weak-pointer-value c buffer))
      #'(lambda (wpc)
-	 (setf (cursor-pos wpc) (min (cursor-pos wpc) (1- (size buffer))))))))
\ No newline at end of file
+	 (setf (cursor-pos wpc)
+	       (max 0 (min (cursor-pos wpc) (1- (size buffer)))))))))
\ No newline at end of file



From crhodes at common-lisp.net  Tue May 24 21:36:10 2005
From: crhodes at common-lisp.net (Christophe Rhodes)
Date: Tue, 24 May 2005 23:36:10 +0200 (CEST)
Subject: [climacs-cvs] CVS update: papers/ilc2005/syntax/climacssyntax.tex 
Message-ID: <20050524213610.60B3388766@common-lisp.net>

Update of /project/climacs/cvsroot/papers/ilc2005/syntax
In directory common-lisp.net:/tmp/cvs-serv2039

Modified Files:
	climacssyntax.tex 
Log Message:
Spell check one last time.  Fix Aleksandar's name.  Add one comma (not
even a colon).

Date: Tue May 24 23:36:09 2005
Author: crhodes

Index: papers/ilc2005/syntax/climacssyntax.tex
diff -u papers/ilc2005/syntax/climacssyntax.tex:1.34 papers/ilc2005/syntax/climacssyntax.tex:1.35
--- papers/ilc2005/syntax/climacssyntax.tex:1.34	Tue May 24 23:29:24 2005
+++ papers/ilc2005/syntax/climacssyntax.tex	Tue May 24 23:36:09 2005
@@ -116,7 +116,7 @@
 Climacs' syntax analysis is a flexible protocol which can be
 implemented with a full language lexer and parser. GNU Emacs, the most
 commonly used Emacs-like editor, uses regular expressions for its
-syntax analysis.  However regular expressions cannot be used to parse
+syntax analysis.  However, regular expressions cannot be used to parse
 the general case of non-regular constructs such as Common Lisp's
 nestable \verb+#| |#+ block comments. The lazy application of those
 regular expressions will also lead to additional erroneous parses even
@@ -629,7 +629,7 @@
 
 \section*{Acknowledgements}
 
-The authors wish to thank Aleksandr Bakic for fruitful discussions.
+The authors wish to thank Aleksandar Bakic for fruitful discussions.
 B.M.\ acknowledges Motorola's generous support.  C.R.\ is supported by
 EPSRC grant GR/\-S84750/\-01.
 



From crhodes at common-lisp.net  Thu May 26 08:31:57 2005
From: crhodes at common-lisp.net (Christophe Rhodes)
Date: Thu, 26 May 2005 10:31:57 +0200 (CEST)
Subject: [climacs-cvs] CVS update: climacs/cl-syntax.lisp climacs/gui.lisp
	climacs/html-syntax.lisp climacs/prolog-syntax.lisp
	climacs/syntax.lisp climacs/text-syntax.lisp
	climacs/ttcn3-syntax.lisp 
Message-ID: <20050526083157.650188874C@common-lisp.net>

Update of /project/climacs/cvsroot/climacs
In directory common-lisp.net:/tmp/cvs-serv29479

Modified Files:
	cl-syntax.lisp gui.lisp html-syntax.lisp prolog-syntax.lisp 
	syntax.lisp text-syntax.lisp ttcn3-syntax.lisp 
Log Message:
OK, no-one complained too much, so I'm going ahead with the syntax
file-type changes discussed in <sqmzqrhbma.fsf at cam.ac.uk>: 
DEFINE-SYNTAX's syntax is changed incompatibly.

Date: Thu May 26 10:31:53 2005
Author: crhodes

Index: climacs/cl-syntax.lisp
diff -u climacs/cl-syntax.lisp:1.13 climacs/cl-syntax.lisp:1.14
--- climacs/cl-syntax.lisp:1.13	Mon May  9 16:09:30 2005
+++ climacs/cl-syntax.lisp	Thu May 26 10:31:53 2005
@@ -111,10 +111,12 @@
 		    (make-instance 'other-entry))))))))
 
 
-(define-syntax cl-syntax ("Common-lisp" (basic-syntax))
+(define-syntax cl-syntax (basic-syntax)
   ((lexer :reader lexer)
    (valid-parse :initform 1)
-   (parser)))
+   (parser))
+  (:name "Common Lisp")
+  (:pathname-types "lisp" "lsp" "cl"))
 
 (defun neutralcharp (var)
   (and (characterp var)


Index: climacs/gui.lisp
diff -u climacs/gui.lisp:1.139 climacs/gui.lisp:1.140
--- climacs/gui.lisp:1.139	Thu May 19 11:04:26 2005
+++ climacs/gui.lisp	Thu May 26 10:31:53 2005
@@ -699,6 +699,16 @@
       (concatenate 'string (pathname-name pathname)
 		   "." (pathname-type pathname))))
 
+(defun syntax-class-name-for-filepath (filepath)
+  (or (climacs-syntax::syntax-description-class-name
+       (find (or (pathname-type filepath)
+		 (pathname-name filepath))
+	     climacs-syntax::*syntaxes*
+	     :test (lambda (x y)
+		     (member x y :test #'string=))
+	     :key #'climacs-syntax::syntax-description-pathname-types))
+      'basic-syntax))
+
 (define-named-command com-find-file ()
   (let ((filepath (accept 'completable-pathname
 			  :prompt "Find File"))
@@ -707,8 +717,10 @@
     (setf (point (buffer pane)) (clone-mark (point pane)))
     (push buffer (buffers *application-frame*))
     (setf (buffer (current-window)) buffer)
-    (setf (syntax buffer) (make-instance
-			   'basic-syntax :buffer (buffer (point pane))))
+    (setf (syntax buffer)
+	  (make-instance
+	   (syntax-class-name-for-filepath filepath)
+	   :buffer (buffer (point pane))))
     ;; Don't want to create the file if it doesn't exist.
     (when (probe-file filepath) 
       (with-open-file (stream filepath :direction :input)


Index: climacs/html-syntax.lisp
diff -u climacs/html-syntax.lisp:1.30 climacs/html-syntax.lisp:1.31
--- climacs/html-syntax.lisp:1.30	Mon May  9 15:12:47 2005
+++ climacs/html-syntax.lisp	Thu May 26 10:31:53 2005
@@ -22,10 +22,12 @@
 
 (in-package :climacs-html-syntax)
 
-(define-syntax html-syntax ("HTML" (basic-syntax))
+(define-syntax html-syntax (basic-syntax)
   ((lexer :reader lexer)
    (valid-parse :initform 1)
-   (parser)))
+   (parser))
+  (:name "HTML")
+  (:pathname-types "html" "htm"))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;;


Index: climacs/prolog-syntax.lisp
diff -u climacs/prolog-syntax.lisp:1.18 climacs/prolog-syntax.lisp:1.19
--- climacs/prolog-syntax.lisp:1.18	Sat May  7 18:41:03 2005
+++ climacs/prolog-syntax.lisp	Thu May 26 10:31:53 2005
@@ -26,10 +26,12 @@
 (defclass prolog-parse-tree (parse-tree)
   ())
 
-(define-syntax prolog-syntax ("Prolog" (basic-syntax))
+(define-syntax prolog-syntax (basic-syntax)
   ((lexer :reader lexer)
    (valid-parse :initform 1)
-   (parser)))
+   (parser))
+  (:name "Prolog")
+  (:pathname-types "pl"))
 
 (defparameter *prolog-grammar* (grammar))
 


Index: climacs/syntax.lisp
diff -u climacs/syntax.lisp:1.49 climacs/syntax.lisp:1.50
--- climacs/syntax.lisp:1.49	Mon May  9 15:12:47 2005
+++ climacs/syntax.lisp	Thu May 26 10:31:53 2005
@@ -39,6 +39,50 @@
 
 (defparameter *syntaxes* '())
 
+(defstruct (syntax-description (:type list))
+  (name (error "required argument") :type string)
+  (class-name (error "required argument") :type symbol)
+  (pathname-types nil :type list))
+
+(defmacro define-syntax (class-name superclasses slots &rest options)
+  (let ((defclass-options nil)
+	(default-initargs nil)
+	(name nil)
+	(pathname-types nil))
+    (dolist (option options)
+      (case (car option)
+	((:name)
+	 (if name
+	     (error "More than one ~S option provided to ~S"
+		    ':name 'define-syntax)
+	     (setf name (cadr option))))
+	((:pathname-types)
+	 (if pathname-types
+	     (error "More than one ~S option provided to ~S"
+		    ':pathname-types 'define-syntax)
+	     (setf pathname-types (cdr option))))
+	((:default-initargs)
+	 (if default-initargs
+	     (error "More than one ~S option provided to ~S"
+		    ':default-initargs 'define-syntax)
+	     (setf default-initargs (cdr option))))
+	(t (push (cdr option) defclass-options))))
+    (unless name
+      (error "~S not supplied to ~S" ':name 'define-syntax))
+    ;; FIXME: the :NAME initarg looks, well, a bit generic, and could
+    ;; collide with user-defined syntax initargs.  Use
+    ;; CLIMACS-SYNTAX::%NAME instead.
+    (setf default-initargs (list* :name name default-initargs))
+    `(progn
+      (push (make-syntax-description
+	     :name ,name :class-name ',class-name
+	     :pathname-types ',pathname-types)
+       *syntaxes*)
+      (defclass ,class-name ,superclasses ,slots
+	(:default-initargs , at default-initargs)
+	, at defclass-options))))
+
+#+nil
 (defmacro define-syntax (class-name (name superclasses) &body body)
   `(progn (push '(,name . ,class-name) *syntaxes*)
 	  (defclass ,class-name ,superclasses
@@ -52,8 +96,8 @@
 		      (lambda (so-far action)
 			(complete-from-possibilities
 			 so-far *syntaxes* '() :action action
-			 :name-key #'car
-			 :value-key #'cdr))
+			 :name-key #'syntax-description-name
+			 :value-key #'syntax-description-class-name))
 		      :partial-completers '(#\Space)
 		      :allow-any-input t)
     (declare (ignore success string))
@@ -63,8 +107,11 @@
 ;;;
 ;;; Basic syntax
 
-(define-syntax basic-syntax ("Basic" (syntax))
-  ())
+;;; FIXME: this is a really bad name.  It's even worse if it's
+;;; case-insensitive.  Emacs' "Fundamental" isn't too bad.
+(define-syntax basic-syntax (syntax)
+  ()
+  (:name "Basic"))
 
 (defmethod update-syntax (buffer (syntax basic-syntax))
   (declare (ignore buffer))


Index: climacs/text-syntax.lisp
diff -u climacs/text-syntax.lisp:1.6 climacs/text-syntax.lisp:1.7
--- climacs/text-syntax.lisp:1.6	Sun Mar 13 21:51:48 2005
+++ climacs/text-syntax.lisp	Thu May 26 10:31:53 2005
@@ -57,8 +57,10 @@
             (setf low-position (floor (+ low-position 1 high-position) 2)))
      finally (return low-position)))
 
-(define-syntax text-syntax ("Text" (basic-syntax))
-  ((paragraphs :initform (make-instance 'standard-flexichain))))
+(define-syntax text-syntax (basic-syntax)
+  ((paragraphs :initform (make-instance 'standard-flexichain)))
+  (:name "Text")
+  (:pathname-types "text" "txt" "README"))
 
 (defmethod update-syntax (buffer (syntax text-syntax))
   (let* ((high-offset (min (+ (offset (high-mark buffer)) 3) (size buffer)))


Index: climacs/ttcn3-syntax.lisp
diff -u climacs/ttcn3-syntax.lisp:1.1 climacs/ttcn3-syntax.lisp:1.2
--- climacs/ttcn3-syntax.lisp:1.1	Mon May 23 03:00:24 2005
+++ climacs/ttcn3-syntax.lisp	Thu May 26 10:31:53 2005
@@ -119,10 +119,12 @@
 	     (make-instance 'identifier))
 	    (t (fo) (make-instance 'other-entry)))))))))
 
-(define-syntax ttcn3-syntax ("TTCN3" (basic-syntax))
+(define-syntax ttcn3-syntax (basic-syntax)
   ((lexer :reader lexer)
    (valid-parse :initform 1)
-   (parser)))
+   (parser))
+  (:name "TTCN3")
+  (:pathname-types "ttcn" "ttcn3"))
 
 (defparameter *ttcn3-grammar* (grammar))
 



From crhodes at common-lisp.net  Thu May 26 13:22:35 2005
From: crhodes at common-lisp.net (Christophe Rhodes)
Date: Thu, 26 May 2005 15:22:35 +0200 (CEST)
Subject: [climacs-cvs] CVS update: climacs/prolog-syntax.lisp 
Message-ID: <20050526132235.C0A4888756@common-lisp.net>

Update of /project/climacs/cvsroot/climacs
In directory common-lisp.net:/tmp/cvs-serv14358

Modified Files:
	prolog-syntax.lisp 
Log Message:
Support op/3 directives in Prolog syntax.

* *THIS-SYNTAX* bound in UPDATE-SYNTAX-FOR-DISPLAY so that parser rules
  can modify the syntax state;
* SLOT-MISSING bandage for encapsulating LTERM;
* Fragile OP/3-DIRECTIVE-FOO stuff to walk the parse-tree.

Despite those caveats, it seems to work.

Date: Thu May 26 15:22:34 2005
Author: crhodes

Index: climacs/prolog-syntax.lisp
diff -u climacs/prolog-syntax.lisp:1.19 climacs/prolog-syntax.lisp:1.20
--- climacs/prolog-syntax.lisp:1.19	Thu May 26 10:31:53 2005
+++ climacs/prolog-syntax.lisp	Thu May 26 15:22:33 2005
@@ -29,12 +29,19 @@
 (define-syntax prolog-syntax (basic-syntax)
   ((lexer :reader lexer)
    (valid-parse :initform 1)
-   (parser))
+   (parser)
+   (operator-directives :initform nil :accessor operator-directives))
   (:name "Prolog")
   (:pathname-types "pl"))
 
 (defparameter *prolog-grammar* (grammar))
 
+;;; *THIS-SYNTAX* is bound around calls to the parser, so that the
+;;; parser rules can update the operator directive table.  Possibly
+;;; this functionality ought to be offered by the syntax module
+;;; itself?
+(defvar *this-syntax*)
+
 (defmacro define-prolog-rule ((&rest rule) &body body)
   `(add-rule (grammar-rule (, at rule , at body)) *prolog-grammar*))
 
@@ -431,6 +438,8 @@
    (open-ct :initarg :open-ct :accessor open-ct)
    (arg-list :initarg :arg-list :accessor arg-list)
    (close :initarg :close :accessor close)))
+(defmethod arity ((f functional-compound-term))
+  (arg-list-length (arg-list f)))
 (defclass bracketed-term (term)
   ((open :initarg :open :accessor open)
    (term :initarg :term :accessor term)
@@ -563,6 +572,16 @@
 (defclass arg-list-pair (arg-list)
   ((comma :initarg :comma :accessor comma)
    (arg-list :initarg :arg-list :accessor arg-list)))
+(defmethod arg-list-length ((a arg-list))
+  1)
+(defmethod arg-list-length ((a arg-list-pair))
+  ;; Hoho.  See also Felleisen (ECOOP 2004) about TRE and OO.
+  (1+ (arg-list-length (arg-list a))))
+
+(defmethod arg-list-nth (n (a arg-list))
+  (if (= n 0)
+      (exp a)
+      (arg-list-nth (1- n) (arg-list a))))
 
 (defmethod display-parse-tree ((entity arg-list) (syntax prolog-syntax) pane)
   (display-parse-tree (exp entity) syntax pane))
@@ -666,10 +685,83 @@
   (display-parse-tree (comma entity) syntax pane)
   (display-parse-tree (tlist entity) syntax pane))
 
+;;; FIXME FIXME FIXME!!!
+;;;
+;;; This is a band-aid for not having taken the time to sort out an
+;;; LTERM "protocol".  I think the proper solution is to
+;;;
+;;; * make an "encapsulating-lterm" subclass of lterm, and use it in
+;;; the lterm -> term rule;
+;;;
+;;; * for all the relevant questions we can ask of terms
+;;; (COMPOUND-TERM-P, ARITY, FUNCTOR, NUMERIC-CONSTANT-P, and so on)
+;;; implement methods which do the right thing for this
+;;; encapsulating-lterm class, and also for bracketed-term.
+;;;
+;;; this SLOT-MISSING hack will cause pain later.  Please FIXME.
+;;;
+;;; CSR, 2005-05-26.
+(defmethod slot-missing (class (lterm lterm) name operation &optional value)
+  (case operation
+    (slot-value (slot-value (term lterm) name))))
+
 ;;; 6.2.1
+(defun op/3-directive-p (directive)
+  (with-slots (directive-term) directive
+    (with-slots (term) directive-term
+      (with-slots (right) term
+	(and (compound-term-p right)
+	     (string= (canonical-name (functor right)) "op")
+	     (= (arity right) 3))))))
+
+(defun op/3-directive-priority (directive)
+  (with-slots (directive-term) directive
+    (with-slots (term) directive-term
+      (with-slots (right) term
+	(let* ((a (arg-list right))
+	       ;; FIXME: error-checking
+	       (exp (arg-list-nth 0 a))
+	       (term (term exp)))
+	  (when (numeric-constant-p term)
+	    (let ((value (numeric-constant-value term)))
+	      (and (<= 0 value 1200) value))))))))
+
+(defun op/3-directive-specifier (directive)
+  (with-slots (directive-term) directive
+    (with-slots (term) directive-term
+      (with-slots (right) term
+	(let* ((a (arg-list right))
+	       (exp (arg-list-nth 1 a))
+	       (term (term exp)))
+	  (let ((string (coerce (buffer-sequence (buffer term)
+						 (start-offset term)
+						 (end-offset term))
+				'string)))
+	    (cdr (assoc string '(("fx" . :fx) ("fy" . :fy)
+				 ("xfx" . :xfx) ("xfy" . :xfy) ("yfx" . :yfx)
+				 ("xf" . :xf) ("yf" . :yf))
+			:test #'string=))))))))
+
+(defun op/3-directive-operator (directive)
+  (with-slots (directive-term) directive
+    (with-slots (term) directive-term
+      (with-slots (right) term
+	(let* ((a (arg-list right))
+	       (exp (arg-list-nth 2 a))
+	       (term (term exp)))
+	  (let ((value (slot-value term 'value)))
+	    (when (typep value 'atom)
+	      (canonical-name value))))))))
+	   
 (define-prolog-rule (prolog-text -> (prolog-text directive))
+  (when (and (op/3-directive-p directive)
+	     (op/3-directive-priority directive)
+	     (op/3-directive-specifier directive)
+	     (op/3-directive-operator directive))
+    ;; FIXME: argh.
+    (push directive (operator-directives *this-syntax*)))
   (make-instance 'directive-prolog-text :directive directive
-                 :text-rest prolog-text))
+		 :text-rest prolog-text))
 (define-prolog-rule (prolog-text -> (prolog-text clause))
   (make-instance 'clause-prolog-text :clause clause :text-rest prolog-text))
 (define-prolog-rule (prolog-text -> ())
@@ -906,8 +998,15 @@
                        *predefined-operators*)
         :key #'opspec-name :test #'string=))
 (defun find-defined-operator (name specifiers)
-  (declare (ignore name specifiers))
-  nil)
+  (let ((operator-directives (operator-directives *this-syntax*)))
+    (dolist (d operator-directives)
+      (when (> (start-offset name) (end-offset d))
+	(when (string= (canonical-name name) (op/3-directive-operator d))
+	  (when (member (op/3-directive-specifier d) specifiers)
+	    (return (make-opspec :name (op/3-directive-operator d)
+				 :priority (op/3-directive-priority d)
+				 :specifier (op/3-directive-specifier d)))))))))
+		       
 (defun operatorp (name)
   (or (find-predefined-operator name '(:xf :yf :fx :fx :xfx :xfy :yfx))
       (find-defined-operator name '(:xf :yf :fx :fx :xfx :xfy :yfx))))
@@ -921,12 +1020,20 @@
    'string))
 
 (defun numeric-constant-p (thing)
-  (and (typep thing 'constant-term)
-       (let ((value (value thing)))
-         (or (typep value 'integer)
-             (and (consp value)
-                  (typep (car value) 'atom)
-                  (typep (cadr value) 'integer))))))
+  (if (typep thing 'lterm)
+      (numeric-constant-p (term thing))
+      (and (typep thing 'constant-term)
+	   (let ((value (value thing)))
+	     (or (typep value 'integer)
+		 (and (consp value)
+		      (typep (car value) 'atom)
+		      (typep (cadr value) 'integer)))))))
+
+(defun numeric-constant-value (thing)
+  (parse-integer
+   (coerce
+    (buffer-sequence (buffer thing) (start-offset thing) (end-offset thing))
+    'string)))
 
 (defun first-lexeme (thing)
   ;; FIXME: we'll need to implement this.
@@ -942,6 +1049,8 @@
 	    (high-mark (high-mark buffer)))
         (setf (offset scan)
               (end-offset (lexeme lexer (1- valid-lex))))
+	;; this magic belongs in a superclass' method.  (It's not the
+	;; same as HTML/Common Lisp relexing, though)
         (loop named relex
 	      do (skip-inter-lexeme-objects lexer scan)
               until (end-of-buffer-p scan)
@@ -976,15 +1085,21 @@
 	      do (delete* climacs-syntax::lexemes valid-lex)))
       ;; parse up to the limit of validity imposed by the lexer, or
       ;; the bottom of the visible area, whichever comes sooner
-      (loop until (= valid-parse valid-lex)
-	    until (mark<= bot (start-offset (lexeme lexer (1- valid-parse))))
-	    do (let ((current-token (lexeme lexer (1- valid-parse)))
-		     (next-lexeme (lexeme lexer valid-parse)))
-		 (setf (slot-value next-lexeme 'state)
-		       (advance-parse parser (list next-lexeme) 
-				      (slot-value current-token 'state)))
-		 (incf valid-parse))))))
-
+      ;;
+      ;; This is ugly, but apparently necessary to be able to refer to
+      ;; the syntax in question: (syntax (buffer thing)) doesn't work,
+      ;; because SYNTAX isn't part of the buffer protocol, and (buffer
+      ;; thing) can return a delegating buffer.
+      (let ((*this-syntax* syntax))
+	(loop until (= valid-parse valid-lex)
+	      until (mark<= bot (start-offset (lexeme lexer (1- valid-parse))))
+	      do (let ((current-token (lexeme lexer (1- valid-parse)))
+		       (next-lexeme (lexeme lexer valid-parse)))
+		   (setf (slot-value next-lexeme 'state)
+			 (advance-parse parser (list next-lexeme) 
+					(slot-value current-token 'state)))
+		   (incf valid-parse)))))))
+  
 (defmethod inter-lexeme-object-p ((lexer prolog-lexer) object)
   (member object '(#\Space #\Newline #\Tab)))
 
@@ -992,6 +1107,8 @@
   (with-slots (lexer valid-parse) syntax
     (let* ((low-mark (low-mark buffer))
 	   (high-mark (high-mark buffer)))
+      ;; this bit really belongs in a method on a superclass --
+      ;; something like incremental-lexer.
       (when (mark<= low-mark high-mark)
 	(with-slots (climacs-syntax::lexemes valid-lex)
 	    lexer
@@ -1004,7 +1121,16 @@
 			   (setf start (1+ middle))
 			   (setf end middle))))
 	    (setf valid-lex start)
-	    (setf valid-parse start)))))))
+	    (setf valid-parse start))))
+      ;; this bit is truly prolog-syntax specific.
+      (when (mark<= low-mark high-mark)
+	(with-slots (operator-directives) syntax
+	  (do ((directives operator-directives (cdr directives)))
+	      ((null directives) (setf operator-directives nil))
+	    (when (< (end-offset (car directives))
+		     (offset low-mark))
+	      (setf operator-directives directives)
+	      (return nil))))))))
 
 ;;; display
 



From crhodes at common-lisp.net  Fri May 27 13:25:02 2005
From: crhodes at common-lisp.net (Christophe Rhodes)
Date: Fri, 27 May 2005 15:25:02 +0200 (CEST)
Subject: [climacs-cvs] CVS update: climacs/prolog-syntax.lisp 
Message-ID: <20050527132502.2F43A88743@common-lisp.net>

Update of /project/climacs/cvsroot/climacs
In directory common-lisp.net:/tmp/cvs-serv3987

Modified Files:
	prolog-syntax.lisp 
Log Message:
Fix for multiple op/3 directives with the same operator.

Date: Fri May 27 15:25:01 2005
Author: crhodes

Index: climacs/prolog-syntax.lisp
diff -u climacs/prolog-syntax.lisp:1.20 climacs/prolog-syntax.lisp:1.21
--- climacs/prolog-syntax.lisp:1.20	Thu May 26 15:22:33 2005
+++ climacs/prolog-syntax.lisp	Fri May 27 15:25:01 2005
@@ -747,11 +747,13 @@
     (with-slots (term) directive-term
       (with-slots (right) term
 	(let* ((a (arg-list right))
-	       (exp (arg-list-nth 2 a))
-	       (term (term exp)))
-	  (let ((value (slot-value term 'value)))
-	    (when (typep value 'atom)
-	      (canonical-name value))))))))
+	       (exp (arg-list-nth 2 a)))
+	  (etypecase exp
+	    (exp-atom (canonical-name (atom exp)))
+	    (exp-term (let* ((term (term exp))
+			     (value (slot-value term 'value)))
+			  (when (typep value 'atom)
+			    (canonical-name value))))))))))
 	   
 (define-prolog-rule (prolog-text -> (prolog-text directive))
   (when (and (op/3-directive-p directive)



From rstrandh at common-lisp.net  Mon May 30 07:19:54 2005
From: rstrandh at common-lisp.net (Robert Strandh)
Date: Mon, 30 May 2005 09:19:54 +0200 (CEST)
Subject: [climacs-cvs] CVS update: climacs/climacs.html 
Message-ID: <20050530071954.5EC518873A@common-lisp.net>

Update of /project/climacs/cvsroot/climacs
In directory common-lisp.net:/tmp/cvs-serv12519

Modified Files:
	climacs.html 
Log Message:
fixed a spelling error.

Date: Mon May 30 09:19:53 2005
Author: rstrandh

Index: climacs/climacs.html
diff -u climacs/climacs.html:1.6 climacs/climacs.html:1.7
--- climacs/climacs.html:1.6	Mon Apr 11 07:28:51 2005
+++ climacs/climacs.html	Mon May 30 09:19:53 2005
@@ -15,7 +15,7 @@
 <ul>
 <li>Emacs Lisp est un langage sp?cialement con?u pour impl?menter
     Emacs.  Depuis la conception de GNU Emacs et du langage Emacs
-    LIsp, Common Lisp a ?t? normalis? et propose ? la fois une
+    Lisp, Common Lisp a ?t? normalis? et propose ? la fois une
     efficacit? bien sup?rieure ? celle de Emacs Lisp (car Emacs Lisp
     est impl?ment? sous la forme d'un interpr?teur ?crit en C) et des
     fonctionnalit?s plus sophistiqu?s (macros, CLOS, etc).  Le choix



From rstrandh at common-lisp.net  Mon May 30 07:25:15 2005
From: rstrandh at common-lisp.net (Robert Strandh)
Date: Mon, 30 May 2005 09:25:15 +0200 (CEST)
Subject: [climacs-cvs] CVS update: climacs/lisp-syntax.lisp
	climacs/climacs.asd climacs/gui.lisp climacs/packages.lisp
	climacs/syntax.lisp 
Message-ID: <20050530072515.E2E928873A@common-lisp.net>

Update of /project/climacs/cvsroot/climacs
In directory common-lisp.net:/tmp/cvs-serv12579

Modified Files:
	climacs.asd gui.lisp packages.lisp syntax.lisp 
Added Files:
	lisp-syntax.lisp 
Log Message:
Alternative syntax for editing common lisp (called "Lisp").

I have not completely lost hope of making the Earley-based syntax
module fast enough, but as of now I don't know how.

This syntax module provides an incremental resynchronizing LR parser
for Common Lisp.  It is fast enough the parse tree for the entire
buffer is kept updated, as opposed to just for what is visible in the
CLIM pane. 

Ultimately, I hope to factor out the parts that are not specific to
Lisp into a different module, perhaps the existing syntax.lisp file.
I'll be interested in your opinions. 


Date: Mon May 30 09:25:14 2005
Author: rstrandh



Index: climacs/climacs.asd
diff -u climacs/climacs.asd:1.29 climacs/climacs.asd:1.30
--- climacs/climacs.asd:1.29	Mon May 23 03:00:24 2005
+++ climacs/climacs.asd	Mon May 30 09:25:13 2005
@@ -65,6 +65,7 @@
    "html-syntax"
    "prolog-syntax"
    "ttcn3-syntax"
+   "lisp-syntax"
    "gui"
    ;;---- optional ----
    "testing/rt"


Index: climacs/gui.lisp
diff -u climacs/gui.lisp:1.140 climacs/gui.lisp:1.141
--- climacs/gui.lisp:1.140	Thu May 26 10:31:53 2005
+++ climacs/gui.lisp	Mon May 30 09:25:13 2005
@@ -270,7 +270,11 @@
 		 (motion-before-beginning ()
 		   (beep) (display-message "Beginning of buffer"))
 		 (motion-after-end ()
-		   (beep) (display-message "End of buffer")))
+		   (beep) (display-message "End of buffer"))
+		 (no-expression ()
+		   (beep) (display-message "No expression around point"))
+		 (no-such-operation ()
+		   (beep) (display-message "Operation unavailable for syntax")))
 	       (setf (previous-command *standard-output*)
 		     (if (consp command)
 			 (car command)
@@ -1375,6 +1379,33 @@
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;; 
+;;; For testing purposes
+
+(define-named-command com-reset-profile ()
+  (sb-profile:reset))
+
+(define-named-command com-report-profile ()
+  (sb-profile:report))
+
+(define-named-command com-recompile ()
+  (asdf:operate 'asdf:load-op :climacs))
+
+(define-named-command com-backward-expression ((count 'integer :prompt "Number of expressions"))
+  (declare (ignore count))
+  (let* ((pane (current-window))
+	 (point (point pane))
+	 (syntax (syntax (buffer pane))))
+    (backward-expression point syntax)))
+
+(define-named-command com-forward-expression ((count 'integer :prompt "Number of expresssions"))
+  (declare (ignore count))
+  (let* ((pane (current-window))
+	 (point (point pane))
+	 (syntax (syntax (buffer pane))))
+    (forward-expression point syntax)))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; 
 ;;; Global and dead-escape command tables
 
 (make-command-table 'global-climacs-table :errorp nil)
@@ -1459,6 +1490,9 @@
 (global-set-key #\Backspace `(com-backward-delete-object ,*numeric-argument-marker*))
 
 (global-set-key '(:insert) 'com-toggle-overwrite-mode)
+
+(global-set-key '(#\b :control :meta) `(com-backward-expression ,*numeric-argument-marker*))
+(global-set-key '(#\f :control :meta) `(com-forward-expression ,*numeric-argument-marker*))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;; 


Index: climacs/packages.lisp
diff -u climacs/packages.lisp:1.62 climacs/packages.lisp:1.63
--- climacs/packages.lisp:1.62	Sat May  7 00:32:28 2005
+++ climacs/packages.lisp	Mon May 30 09:25:13 2005
@@ -103,7 +103,9 @@
 	   #:parse-stack-top #:target-parse-tree #:parse-state-empty-p
 	   #:parse-stack-next #:parse-stack-symbol
 	   #:parse-stack-parse-trees #:map-over-parse-trees
+	   #:no-such-operation #:no-expression
            #:syntax-line-indentation
+	   #:forward-expression #:backward-expression
 	   #:redisplay-pane-with-syntax
 	   #:beginning-of-paragraph #:end-of-paragraph))
 
@@ -149,6 +151,11 @@
   (:shadow "ATOM" "CLOSE" "EXP" "INTEGER" "OPEN" "VARIABLE"))
 
 (defpackage :climacs-cl-syntax
+  (:use :clim-lisp :clim :climacs-buffer :climacs-base 
+	:climacs-syntax :flexichain :climacs-pane)
+  (:export))
+
+(defpackage :climacs-lisp-syntax
   (:use :clim-lisp :clim :climacs-buffer :climacs-base 
 	:climacs-syntax :flexichain :climacs-pane)
   (:export))


Index: climacs/syntax.lisp
diff -u climacs/syntax.lisp:1.50 climacs/syntax.lisp:1.51
--- climacs/syntax.lisp:1.50	Thu May 26 10:31:53 2005
+++ climacs/syntax.lisp	Mon May 30 09:25:13 2005
@@ -25,6 +25,20 @@
 (defclass syntax (name-mixin)
   ((buffer :initarg :buffer :reader buffer)))
 
+(define-condition no-such-operation (simple-error)
+  ()
+  (:report (lambda (condition stream)
+	     (format stream "Operation unavailable for this syntax")))
+  (:documentation "This condition is signaled whenever an attempt is
+made to execute an operation that is unavailable for the particular syntax" ))
+
+(define-condition no-expression (simple-error)
+  ()
+  (:report (lambda (condition stream)
+	     (format stream "No expression at point")))
+  (:documentation "This condition is signaled whenever an attempt is
+made to execute a by-experssion motion command and no expression is available." ))
+
 (defgeneric update-syntax (buffer syntax))
 
 (defgeneric update-syntax-for-display (buffer syntax from to))
@@ -33,6 +47,10 @@
   (:documentation "Return the correct indentation for the line containing
 the mark, according to the specified syntax."))
 
+(defgeneric forward-expression (mark syntax))
+
+(defgeneric backward-expression (mark syntax))
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;;
 ;;; Syntax completion
@@ -124,6 +142,12 @@
 (defmethod syntax-line-indentation (mark tab-width (syntax basic-syntax))
   (declare (ignore mark tab-width))
   0)
+
+(defmethod forward-expression (mark syntax)
+  (error 'no-such-operation))
+
+(defmethod backward-expression (mark syntax)
+  (error 'no-such-operation))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;;



From rstrandh at common-lisp.net  Mon May 30 07:51:33 2005
From: rstrandh at common-lisp.net (Robert Strandh)
Date: Mon, 30 May 2005 09:51:33 +0200 (CEST)
Subject: [climacs-cvs] CVS update: climacs/gui.lisp 
Message-ID: <20050530075133.6E7778873A@common-lisp.net>

Update of /project/climacs/cvsroot/climacs
In directory common-lisp.net:/tmp/cvs-serv15020

Modified Files:
	gui.lisp 
Log Message:
added reader conditionals around calls to sb-profile:xxx

Date: Mon May 30 09:51:32 2005
Author: rstrandh

Index: climacs/gui.lisp
diff -u climacs/gui.lisp:1.141 climacs/gui.lisp:1.142
--- climacs/gui.lisp:1.141	Mon May 30 09:25:13 2005
+++ climacs/gui.lisp	Mon May 30 09:51:32 2005
@@ -1382,10 +1382,12 @@
 ;;; For testing purposes
 
 (define-named-command com-reset-profile ()
-  (sb-profile:reset))
+  #+sbcl (sb-profile:reset)
+  #-sbcl nil)
 
 (define-named-command com-report-profile ()
-  (sb-profile:report))
+  #+sbcl (sb-profile:report)
+  #-sbcl nil)
 
 (define-named-command com-recompile ()
   (asdf:operate 'asdf:load-op :climacs))



From rstrandh at common-lisp.net  Mon May 30 09:00:36 2005
From: rstrandh at common-lisp.net (Robert Strandh)
Date: Mon, 30 May 2005 11:00:36 +0200 (CEST)
Subject: [climacs-cvs] CVS update: climacs/lisp-syntax.lisp 
Message-ID: <20050530090036.DE8D78873A@common-lisp.net>

Update of /project/climacs/cvsroot/climacs
In directory common-lisp.net:/tmp/cvs-serv18572

Modified Files:
	lisp-syntax.lisp 
Log Message:
Add parsing rules for `#:' so that prolog-syntax.lisp parses OK.

Date: Mon May 30 11:00:35 2005
Author: rstrandh

Index: climacs/lisp-syntax.lisp
diff -u climacs/lisp-syntax.lisp:1.1 climacs/lisp-syntax.lisp:1.2
--- climacs/lisp-syntax.lisp:1.1	Mon May 30 09:25:13 2005
+++ climacs/lisp-syntax.lisp	Mon May 30 11:00:35 2005
@@ -179,6 +179,7 @@
 (defclass text-lexeme (lisp-lexeme) ())
 (defclass reader-conditional-positive-lexeme (lisp-lexeme) ())
 (defclass reader-conditional-negative-lexeme (lisp-lexeme) ())
+(defclass uninterned-symbol-lexeme (lisp-lexeme) ())
 
 (defmethod skip-inter ((syntax lisp-syntax) state scan)
   (macrolet ((fo () `(forward-object scan)))
@@ -236,6 +237,8 @@
 			 (make-instance 'reader-conditional-positive-lexeme))
 		    (#\- (fo)
 			 (make-instance 'reader-conditional-negative-lexeme))
+		    (#\: (fo)
+			 (make-instance 'uninterned-symbol-lexeme))
 		    (t (fo) (make-instance 'error-lexeme)))))
 	(t (cond ((constituentp object)
 		  (loop until (end-of-buffer-p scan)
@@ -605,6 +608,22 @@
 
 (define-lisp-action (|#- form form | t)
   (reduce-rule reader-conditional-negative-form 3))
+
+;;;;;;;;;;;;;;;; uninterned symbol
+
+;;; parse trees
+(defclass uninterned-symbol-form (form) ())
+
+(define-parser-state |#: | (form-may-follow) ())
+(define-parser-state |#: form | (lexer-toplevel-state parser-state) ())
+
+(define-new-lisp-state (form-may-follow uninterned-symbol-lexeme) |' |)
+(define-new-lisp-state (|#: | form) |#: form |)
+
+;;; reduce according to the rule form -> #: form
+(define-lisp-action (|#: form | t)
+  (reduce-rule uninterned-symbol-form 2))
+
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;;



From rstrandh at common-lisp.net  Mon May 30 09:09:49 2005
From: rstrandh at common-lisp.net (Robert Strandh)
Date: Mon, 30 May 2005 11:09:49 +0200 (CEST)
Subject: [climacs-cvs] CVS update: climacs/base.lisp 
Message-ID: <20050530090949.8D4F788756@common-lisp.net>

Update of /project/climacs/cvsroot/climacs
In directory common-lisp.net:/tmp/cvs-serv19477

Modified Files:
	base.lisp 
Log Message:
patches to constituentp and whitespacep
(thanks to Splittist)


Date: Mon May 30 11:09:49 2005
Author: rstrandh

Index: climacs/base.lisp
diff -u climacs/base.lisp:1.38 climacs/base.lisp:1.39
--- climacs/base.lisp:1.38	Sun Mar 13 21:51:48 2005
+++ climacs/base.lisp	Mon May 30 11:09:48 2005
@@ -177,13 +177,16 @@
   "A predicate to ensure that an object is a constituent character."
   (and (characterp obj)
        #+sbcl (sb-impl::constituentp obj)
-       #-sbcl (alphanumericp obj)))
+       #-sbcl (or (alphanumericp obj)
+                  (member obj '(#\! #\$ #\% #\& #\* #\+ #\- #\. #\/
+                                #\: #\< #\= #\> #\? #\@ #\^ #\~ #\_
+                                #\{ #\} #\[ #\] )))))
 
 (defun whitespacep (obj)
   "A predicate to ensure that an object is a whitespace character."
   (and (characterp obj)
        #+sbcl (sb-impl::whitespacep obj)
-       #-sbcl (member obj '(#\Space #\Tab))))
+       #-sbcl (member obj '(#\Space #\Tab #\Newline))))
 
 (defun forward-to-word-boundary (mark)
   "Move the mark forward to the beginning of the next word."



From rstrandh at common-lisp.net  Mon May 30 09:33:40 2005
From: rstrandh at common-lisp.net (Robert Strandh)
Date: Mon, 30 May 2005 11:33:40 +0200 (CEST)
Subject: [climacs-cvs] CVS update: climacs/gui.lisp climacs/lisp-syntax.lisp
	climacs/packages.lisp climacs/syntax.lisp 
Message-ID: <20050530093340.2309388757@common-lisp.net>

Update of /project/climacs/cvsroot/climacs
In directory common-lisp.net:/tmp/cvs-serv21260

Modified Files:
	gui.lisp lisp-syntax.lisp packages.lisp syntax.lisp 
Log Message:
New command `eval-defun' bound to C-M-x

Date: Mon May 30 11:33:39 2005
Author: rstrandh

Index: climacs/gui.lisp
diff -u climacs/gui.lisp:1.142 climacs/gui.lisp:1.143
--- climacs/gui.lisp:1.142	Mon May 30 09:51:32 2005
+++ climacs/gui.lisp	Mon May 30 11:33:39 2005
@@ -1406,6 +1406,12 @@
 	 (syntax (syntax (buffer pane))))
     (forward-expression point syntax)))
 
+(define-named-command com-eval-defun ()
+  (let* ((pane (current-window))
+	 (point (point pane))
+	 (syntax (syntax (buffer pane))))
+    (eval-defun point syntax)))
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;; 
 ;;; Global and dead-escape command tables
@@ -1495,6 +1501,7 @@
 
 (global-set-key '(#\b :control :meta) `(com-backward-expression ,*numeric-argument-marker*))
 (global-set-key '(#\f :control :meta) `(com-forward-expression ,*numeric-argument-marker*))
+(global-set-key '(#\x :control :meta) '(com-eval-defun))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;; 


Index: climacs/lisp-syntax.lisp
diff -u climacs/lisp-syntax.lisp:1.2 climacs/lisp-syntax.lisp:1.3
--- climacs/lisp-syntax.lisp:1.2	Mon May 30 11:00:35 2005
+++ climacs/lisp-syntax.lisp	Mon May 30 11:33:39 2005
@@ -415,14 +415,14 @@
 
 (define-parser-state |form* | (lexer-toplevel-state parser-state) ())
 (define-parser-state form-may-follow (lexer-toplevel-state parser-state) ())
-(define-parser-state initial-state (form-may-follow) ())
+(define-parser-state |initial-state | (form-may-follow) ())
 
-(define-new-lisp-state (initial-state form) initial-state)
+(define-new-lisp-state (|initial-state | form) |initial-state |)
 
-(define-lisp-action (initial-state (eql nil))
+(define-lisp-action (|initial-state | (eql nil))
   (make-instance 'form* :children (pop-all syntax)))
 
-(define-new-lisp-state (initial-state form*) |form* | )
+(define-new-lisp-state (|initial-state | form*) |form* | )
   
 (define-lisp-action (|form* | (eql nil))
   (throw 'done nil))
@@ -742,7 +742,7 @@
 	   (setf stack-top (find-last-valid-lexeme stack-top (offset low-mark)))
 	   (setf (offset scan) (if (null stack-top) 0 (end-offset stack-top))
 		 current-state (if (null stack-top)
-				   initial-state
+				   |initial-state |
 				   (new-state syntax
 					      (parser-state stack-top)
 					      stack-top)))
@@ -958,3 +958,14 @@
     (if potential-form
 	(setf (offset mark) (end-offset potential-form))
 	(error 'no-expression))))
+
+(defmethod eval-defun (mark (syntax lisp-syntax))
+  (with-slots (stack-top) syntax
+     (loop for form in (children stack-top)
+	   when (and (mark<= (start-offset form) mark)
+		     (mark<= mark (end-offset form)))
+	     do (return (eval (read-from-string 
+			       (coerce (buffer-sequence (buffer syntax)
+							(start-offset form)
+							(end-offset form))
+				       'string)))))))
\ No newline at end of file


Index: climacs/packages.lisp
diff -u climacs/packages.lisp:1.63 climacs/packages.lisp:1.64
--- climacs/packages.lisp:1.63	Mon May 30 09:25:13 2005
+++ climacs/packages.lisp	Mon May 30 11:33:39 2005
@@ -106,6 +106,7 @@
 	   #:no-such-operation #:no-expression
            #:syntax-line-indentation
 	   #:forward-expression #:backward-expression
+	   #:eval-defun
 	   #:redisplay-pane-with-syntax
 	   #:beginning-of-paragraph #:end-of-paragraph))
 


Index: climacs/syntax.lisp
diff -u climacs/syntax.lisp:1.51 climacs/syntax.lisp:1.52
--- climacs/syntax.lisp:1.51	Mon May 30 09:25:13 2005
+++ climacs/syntax.lisp	Mon May 30 11:33:39 2005
@@ -28,6 +28,7 @@
 (define-condition no-such-operation (simple-error)
   ()
   (:report (lambda (condition stream)
+	     (declare (ignore condition))
 	     (format stream "Operation unavailable for this syntax")))
   (:documentation "This condition is signaled whenever an attempt is
 made to execute an operation that is unavailable for the particular syntax" ))
@@ -35,6 +36,7 @@
 (define-condition no-expression (simple-error)
   ()
   (:report (lambda (condition stream)
+	     (declare (ignore condition))
 	     (format stream "No expression at point")))
   (:documentation "This condition is signaled whenever an attempt is
 made to execute a by-experssion motion command and no expression is available." ))
@@ -51,6 +53,8 @@
 
 (defgeneric backward-expression (mark syntax))
 
+(defgeneric eval-defun (mark syntax))
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;;
 ;;; Syntax completion
@@ -147,6 +151,9 @@
   (error 'no-such-operation))
 
 (defmethod backward-expression (mark syntax)
+  (error 'no-such-operation))
+
+(defmethod eval-defun (mark syntax)
   (error 'no-such-operation))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;



From rstrandh at common-lisp.net  Mon May 30 13:47:24 2005
From: rstrandh at common-lisp.net (Robert Strandh)
Date: Mon, 30 May 2005 15:47:24 +0200 (CEST)
Subject: [climacs-cvs] CVS update: climacs/lisp-syntax.lisp 
Message-ID: <20050530134724.1F0908873A@common-lisp.net>

Update of /project/climacs/cvsroot/climacs
In directory common-lisp.net:/tmp/cvs-serv4197

Modified Files:
	lisp-syntax.lisp 
Log Message:
prettified keyword symbols.

Date: Mon May 30 15:47:21 2005
Author: rstrandh

Index: climacs/lisp-syntax.lisp
diff -u climacs/lisp-syntax.lisp:1.3 climacs/lisp-syntax.lisp:1.4
--- climacs/lisp-syntax.lisp:1.3	Mon May 30 11:33:39 2005
+++ climacs/lisp-syntax.lisp	Mon May 30 15:47:21 2005
@@ -806,6 +806,13 @@
   (with-drawing-options (pane :ink +red+)
     (call-next-method)))
 
+(defmethod display-parse-tree ((parse-symbol token-lexeme) (syntax lisp-syntax) pane)
+  (if (and (> (end-offset parse-symbol) (start-offset parse-symbol))
+	   (eql (buffer-object (buffer syntax) (start-offset parse-symbol)) #\:))
+      (with-drawing-options (pane :ink +dark-violet+)
+	(call-next-method))
+      (call-next-method)))
+
 (defmethod display-parse-tree ((parser-symbol lisp-lexeme) (syntax lisp-syntax) pane)
   (flet ((cache-test (t1 t2)
 	   (and (eq t1 t2)