Update of /project/climacs/cvsroot/climacs
In directory common-lisp.net:/tmp/cvs-serv19199
Modified Files:
climacs.asd gui.lisp packages.lisp pane.lisp syntax.lisp
Log Message:
Fixed the display-message function so that it actually displays a message
in the minibuffer.
Implemented an incremental Earley parser for the syntax module.
Date: Wed Feb 2 08:59:41 2005
Author: rstrandh
Index: climacs/climacs.asd
diff -u climacs/climacs.asd:1.16 climacs/climacs.asd:1.17
--- climacs/climacs.asd:1.16 Wed Jan 26 17:10:40 2005
+++ climacs/climacs.asd Wed Feb 2 08:59:41 2005
@@ -61,6 +61,7 @@
"abbrev"
"syntax"
"text-syntax"
+ "html-syntax"
"kill-ring"
"undo"
"pane"
Index: climacs/gui.lisp
diff -u climacs/gui.lisp:1.105 climacs/gui.lisp:1.106
--- climacs/gui.lisp:1.105 Sun Jan 30 23:17:30 2005
+++ climacs/gui.lisp Wed Feb 2 08:59:41 2005
@@ -77,6 +77,7 @@
info-pane)))
(int (make-pane 'minibuffer-pane
:width 900 :height 20 :max-height 20 :min-height 20
+ :display-function 'display-minibuffer
:scroll-bars nil)))
(:layouts
(default
@@ -85,6 +86,18 @@
int)))
(:top-level (climacs-top-level)))
+(defparameter *message* nil)
+
+(defun display-message (format-string &rest format-args)
+ (setf *message*
+ (apply #'format nil format-string format-args)))
+
+(defun display-minibuffer (frame pane)
+ (declare (ignore frame))
+ (unless (null *message*)
+ (princ *message* pane)
+ (setf *message* nil)))
+
(defmacro current-window () ; shouldn't this be an inlined function? --amb
`(car (windows *application-frame*)))
@@ -107,9 +120,6 @@
(let ((frame (make-application-frame 'climacs)))
(run-frame-top-level frame)))
-(defun display-message (format-string &rest format-args)
- (apply #'format *standard-input* format-string format-args))
-
(defun display-info (frame pane)
(declare (ignore frame))
(with-slots (climacs-pane) pane
@@ -649,7 +659,7 @@
(pane (current-window)))
(push buffer (buffers *application-frame*))
(setf (buffer (current-window)) buffer)
- (setf (syntax buffer) (make-instance 'basic-syntax))
+ (setf (syntax buffer) (make-instance 'basic-syntax :buffer buffer))
;; Don't want to create the file if it doesn't exist.
(when (probe-file filename)
(with-open-file (stream filename :direction :input)
@@ -722,7 +732,7 @@
(let ((buffer (accept 'buffer
:prompt "Switch to buffer")))
(setf (buffer (current-window)) buffer)
- (setf (syntax buffer) (make-instance 'basic-syntax))
+ (setf (syntax buffer) (make-instance 'basic-syntax :buffer buffer))
(beginning-of-buffer (point (current-window)))
(full-redisplay (current-window))))
@@ -800,7 +810,8 @@
(let* ((pane (current-window))
(buffer (buffer pane)))
(setf (syntax buffer)
- (make-instance (accept 'syntax :prompt "Set Syntax")))
+ (make-instance (accept 'syntax :prompt "Set Syntax")
+ :buffer buffer))
(setf (offset (low-mark buffer)) 0
(offset (high-mark buffer)) (size buffer))))
@@ -1242,6 +1253,18 @@
(point (point pane))
(syntax (syntax (buffer pane))))
(end-of-paragraph point syntax)))
+
+(define-named-command com-backward-to-error ()
+ (let* ((pane (current-window))
+ (point (point pane))
+ (syntax (syntax (buffer pane))))
+ (display-message "~a" (backward-to-error point syntax))))
+
+(define-named-command com-forward-to-error ()
+ (let* ((pane (current-window))
+ (point (point pane))
+ (syntax (syntax (buffer pane))))
+ (display-message "~a" (forward-to-error point syntax))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
Index: climacs/packages.lisp
diff -u climacs/packages.lisp:1.44 climacs/packages.lisp:1.45
--- climacs/packages.lisp:1.44 Sun Jan 30 23:17:31 2005
+++ climacs/packages.lisp Wed Feb 2 08:59:41 2005
@@ -86,7 +86,8 @@
#:basic-syntax
#:update-syntax
#:syntax-line-indentation
- #:beginning-of-paragraph #:end-of-paragraph))
+ #:beginning-of-paragraph #:end-of-paragraph
+ #:forward-to-error #:backward-to-error))
(defpackage :climacs-kill-ring
(:use :clim-lisp :flexichain)
Index: climacs/pane.lisp
diff -u climacs/pane.lisp:1.16 climacs/pane.lisp:1.17
--- climacs/pane.lisp:1.16 Sun Jan 30 23:17:31 2005
+++ climacs/pane.lisp Wed Feb 2 08:59:41 2005
@@ -167,11 +167,15 @@
(defclass climacs-buffer (standard-buffer abbrev-mixin filename-mixin name-mixin undo-mixin) ;PB
((needs-saving :initform nil :accessor needs-saving)
- (syntax :initarg :syntax :initform (make-instance 'basic-syntax) :accessor syntax)
+ (syntax :accessor syntax)
(indent-tabs-mode :initarg indent-tabs-mode :initform t
:accessor indent-tabs-mode))
(:default-initargs :name "*scratch*"))
+(defmethod initialize-instance :after ((buffer climacs-buffer) &rest args)
+ (declare (ignore args))
+ (with-slots (syntax) buffer
+ (setf syntax (make-instance 'basic-syntax :buffer buffer))))
(defclass climacs-pane (application-pane)
((buffer :initform (make-instance 'climacs-buffer) :accessor buffer)
Index: climacs/syntax.lisp
diff -u climacs/syntax.lisp:1.28 climacs/syntax.lisp:1.29
--- climacs/syntax.lisp:1.28 Tue Jan 18 00:10:24 2005
+++ climacs/syntax.lisp Wed Feb 2 08:59:41 2005
@@ -22,7 +22,8 @@
(in-package :climacs-syntax)
-(defclass syntax (name-mixin) ())
+(defclass syntax (name-mixin)
+ ((buffer :initarg :buffer)))
(defgeneric update-syntax (buffer syntax))
@@ -70,3 +71,217 @@
(defmethod syntax-line-indentation (mark tab-width (syntax basic-syntax))
(declare (ignore mark tab-width))
0)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;; Incremental Earley parser
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;; grammar
+
+(defclass rule ()
+ ((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)))
+
+(defclass grammar ()
+ ((rules :initarg :rules :reader rules)))
+
+(defmacro grammar (&body body)
+ (labels ((var-of (arg)
+ (if (symbolp arg)
+ arg
+ (car arg)))
+ (sym-of (arg)
+ (cond ((symbolp arg) arg)
+ ((= (length arg) 3) (cadr arg))
+ ((symbolp (cadr arg)) (cadr arg))
+ (t (car arg))))
+ (test-of (arg)
+ (cond ((symbolp arg) t)
+ ((= (length arg) 3) (caddr arg))
+ ((symbolp (cadr arg)) t)
+ (t (cadr arg))))
+ (build-rule (arglist body)
+ (if (null arglist)
+ body
+ (let ((arg (car arglist)))
+ `(lambda (,(var-of arg))
+ (when (and (typep ,(var-of arg) ',(sym-of arg))
+ ,(test-of arg))
+ ,(build-rule (cdr arglist) body))))))
+ (make-rule (rule)
+ `(make-instance 'rule
+ :left-hand-side ',(car rule)
+ :right-hand-side
+ ,(build-rule (caddr rule)
+ (if (or (= (length rule) 3)
+ (symbolp (cadddr rule)))
+ `(make-instance ',(car rule) ,@(cdddr rule))
+ `(progn ,@(cdddr rule))))
+ :symbols ,(coerce (mapcar #'sym-of (caddr rule)) 'vector))))
+ `(make-instance 'grammar
+ :rules (list ,@(mapcar #'make-rule body)))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;; parser
+
+(defclass parser ()
+ ((grammar :initarg :grammar)
+ (target :initarg :target :reader target)
+ (initial-state :reader initial-state)
+ (lexer :initarg :lexer)))
+
+(defclass rule-item () ())
+
+(defclass incomplete-item (rule-item)
+ ((rule :initarg :rule :reader rule)
+ (dot-position :initarg :dot-position :reader dot-position)
+ (parse-trees :initarg :parse-trees :reader parse-trees)
+ (suffix :initarg :suffix :reader suffix)))
+
+(defmethod print-object ((item incomplete-item) stream)
+ (format stream "[~a ->" (left-hand-side (rule item)))
+ (loop for i from 0 below (dot-position item)
+ do (format stream " ~a" (aref (symbols (rule item)) i)))
+ (format stream " *")
+ (loop for i from (dot-position item) below (length (symbols (rule item)))
+ do (format stream " ~a" (aref (symbols (rule item)) i)))
+ (format stream "]"))
+
+(defclass complete-item (rule-item)
+ ((parse-tree :initarg :parse-tree :reader parse-tree)))
+
+(defmethod print-object ((item complete-item) stream)
+ (format stream "[~a]" (parse-tree item)))
+
+(defgeneric derive-item (prev-item parse-tree))
+
+(defmethod derive-item ((prev-item incomplete-item) parse-tree)
+ (let ((remaining (funcall (suffix prev-item) parse-tree)))
+ (cond ((null remaining)
+ nil)
+ ((functionp remaining)
+ (make-instance 'incomplete-item
+ :rule (rule prev-item)
+ :dot-position (1+ (dot-position prev-item))
+ :parse-trees (cons parse-tree (parse-trees prev-item))
+ :suffix remaining))
+ (t
+ (make-instance 'complete-item
+ :parse-tree remaining)))))
+
+(defgeneric item-equal (item1 item2))
+
+(defgeneric parse-tree-equal (tree1 tree2))
+
+(defmethod item-equal ((item1 rule-item) (item2 rule-item))
+ nil)
+
+(defmethod item-equal ((item1 incomplete-item) (item2 incomplete-item))
+ (and (eq (rule item1) (rule item2))
+ (eq (length (parse-trees item1)) (length (parse-trees item2)))
+ (every #'parse-tree-equal (parse-trees item1) (parse-trees item2))))
+
+(defmethod parse-tree-equal (tree1 tree2)
+ (eq (class-of tree1) (class-of tree2)))
+
+(defgeneric parse-tree-better (tree1 tree2))
+
+(defmethod parse-tree-better (tree1 tree2)
+ nil)
+
+(defclass parser-state ()
+ ((grammar :initarg :grammar :reader state-grammar)
+ (incomplete-items :initform (make-hash-table :test #'eq)
+ :reader incomplete-items)
+ (parse-trees :initform (make-hash-table :test #'eq)
+ :reader parse-trees)))
+
+(defun map-over-incomplete-items (state fun)
+ (maphash (lambda (key incomplete-items)
+ (loop for incomplete-item in incomplete-items
+ do (funcall fun key incomplete-item)))
+ (incomplete-items state)))
+
+(defgeneric handle-item (item orig-state to-state))
+
+(defun potentially-handle-parse-tree (parse-tree from-state to-state)
+ (let ((parse-trees (parse-trees to-state)))
+ (flet ((handle-parse-tree ()
+ (map-over-incomplete-items from-state
+ (lambda (orig-state incomplete-item)
+ (handle-item (derive-item incomplete-item parse-tree)
+ orig-state to-state)))))
+ (cond ((find parse-tree (gethash from-state parse-trees)
+ :test #'parse-tree-better)
+ (setf (gethash from-state parse-trees)
+ (cons parse-tree
+ (remove parse-tree (gethash from-state parse-trees)
+ :test #'parse-tree-better)))
+ (handle-parse-tree))
+ ((find parse-tree (gethash from-state parse-trees)
+ :test (lambda (x y) (or (parse-tree-better y x) (parse-tree-equal y x))))
+ nil)
+ (t (push parse-tree (gethash from-state parse-trees))
+ (handle-parse-tree))))))
+
+(defmethod handle-item ((item (eql nil)) orig-state to-state)
+ nil)
+
+(defmethod handle-item ((item incomplete-item) orig-state to-state)
+ (cond ((find item (gethash orig-state (incomplete-items to-state))
+ :test #'item-equal)
+ nil)
+ (t
+ (push item (gethash orig-state (incomplete-items to-state)))
+ (loop for rule in (rules (state-grammar to-state))
+ do (when (let ((sym1 (aref (symbols (rule item)) (dot-position item)))
+ (sym2 (left-hand-side rule)))
+ (or (subtypep sym1 sym2) (subtypep sym2 sym1)))
+ (handle-item (if (functionp (right-hand-side rule))
+ (make-instance 'incomplete-item
+ :rule rule
+ :dot-position 0
+ :parse-trees '()
+ :suffix (right-hand-side rule))
+ (make-instance 'complete-item
+ :parse-tree (right-hand-side rule)))
+ to-state to-state)))
+ (loop for parse-tree in (gethash to-state (parse-trees to-state))
+ do (handle-item (derive-item item parse-tree)
+ to-state to-state)))))
+
+(defmethod handle-item ((item complete-item) orig-state to-state)
+ (potentially-handle-parse-tree (parse-tree item) orig-state to-state))
+
+(defmethod initialize-instance :after ((parser parser) &rest args)
+ (declare (ignore args))
+ (with-slots (grammar initial-state) parser
+ (setf initial-state (make-instance 'parser-state :grammar grammar))
+ (loop for rule in (rules grammar)
+ do (when (let ((sym (left-hand-side rule)))
+ (or (subtypep (target parser) sym)
+ (subtypep sym (target parser))))
+ (handle-item (if (functionp (right-hand-side rule))
+ (make-instance 'incomplete-item
+ :rule rule
+ :dot-position 0
+ :parse-trees '()
+ :suffix (right-hand-side rule))
+ (make-instance 'complete-item
+ :parse-tree (right-hand-side rule)))
+ initial-state initial-state)))))
+
+(defun advance-parse (parser tokens state)
+ (with-slots (grammar) parser
+ (let ((new-state (make-instance 'parser-state :grammar grammar)))
+ (loop for token in tokens
+ do (potentially-handle-parse-tree token state new-state))
+ new-state)))
+
+(defclass lexer () ())
+
+(defgeneric lex (lexer))
