Commit 791af4a7 authored by Troels Henriksen's avatar Troels Henriksen

Make Climacs use Drei. There are known problems (apart from the docs

now being outdated):

* Some syntaxes have not been updated.
* Group functionality has been disabled.
* It's a large change and Climacs has no test suite. Bugs probably
  still remain.

But it should work nicely most of the time. Otherwise, you'll get a
full refund.
parent 6b1c4c43
......@@ -1106,7 +1106,7 @@
(display-parse-tree (target-parse-tree state) syntax pane))))
(defmethod redisplay-pane-with-syntax ((pane climacs-pane) (syntax cl-syntax) current-p)
(defmethod redisplay-pane-with-syntax ((pane drei-pane) (syntax cl-syntax) current-p)
(with-slots (top bot) pane
(setf *cursor-positions* (make-array (1+ (number-of-lines-in-region top bot)))
*current-line* 0
......
;;; -*- Mode: Lisp; Package: CLIMACS-LISP-SYNTAX; -*-
;;; (c) copyright 2004-2005 by
;;; Robert Strandh (strandh@labri.fr)
;;; (c) copyright 2004-2005 by
;;; Elliott Johnson (ejohnson@fasl.info)
;;; (c) copyright 2005 by
;;; Matthieu Villeneuve (matthieu.villeneuve@free.fr)
;;; (c) copyright 2005 by
;;; Aleksandar Bakic (a_bakic@yahoo.com)
;;; (c) copyright 2006 by
;;; Troels Henriksen (athas@sigkill.dk)
;;;
;;; 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.
;;; Commands specific to the Lisp syntax for Climacs.
(in-package :drei-lisp-syntax)
(make-command-table 'climacs-lisp-table
:errorp nil)
(defmethod additional-command-tables append ((frame climacs-gui:climacs) (command-table lisp-table))
'(climacs-lisp-table))
(define-command (com-package :name t :command-table climacs-lisp-table) ()
(let ((package (package-at-mark *current-syntax* *current-point*)))
(esa:display-message (format nil "~A" (if (packagep package)
(package-name package)
package)))))
(define-command (com-set-base :name t :command-table climacs-lisp-table)
((base '(integer 2 36)))
"Set the base for the current buffer."
(setf (base *current-syntax*) base))
(define-command (com-set-package :name t :command-table climacs-lisp-table)
((package 'package))
"Set the package for the current buffer."
(setf (option-specified-package *current-syntax*) package))
(define-command (com-macroexpand-1 :name t :command-table climacs-lisp-table)
()
"Macroexpand-1 the expression at point.
The expanded expression will be displayed in a
\"*Macroexpansion*\"-buffer."
(let*((token (expression-at-mark *current-point* *current-syntax*)))
(if token
(macroexpand-token *current-syntax* token)
(esa:display-message "Nothing to expand at point."))))
(define-command (com-macroexpand-all :name t :command-table climacs-lisp-table)
()
"Completely macroexpand the expression at point.
The expanded expression will be displayed in a
\"*Macroexpansion*\"-buffer."
(let ((token (expression-at-mark *current-point* *current-syntax*)))
(if token
(macroexpand-token *current-syntax* token t)
(esa:display-message "Nothing to expand at point."))))
(define-command (com-compile-and-load-file :name t :command-table climacs-lisp-table)
()
"Compile and load the current file.
Compiler notes will be displayed in a seperate buffer."
(compile-file-interactively *current-buffer* t))
(define-command (com-compile-file :name t :command-table climacs-lisp-table)
()
"Compile the file open in the current buffer.
This command does not load the file after it has been compiled."
(compile-file-interactively *current-buffer* nil))
(define-command (com-goto-location :name t :command-table climacs-lisp-table)
((note 'compiler-note))
"Move point to the part of a given file that caused the
compiler note.
If the file is not already open, a new buffer will be opened with
that file."
(goto-location (location note)))
(define-presentation-to-command-translator compiler-note-to-goto-location-translator
(compiler-note com-goto-location climacs-lisp-table)
(presentation)
(list (presentation-object presentation)))
(define-command (com-goto-xref :name t :command-table climacs-lisp-table)
((xref 'xref))
"Go to the referenced location of a code cross-reference."
(goto-location xref))
(define-presentation-to-command-translator xref-to-goto-location-translator
(xref com-goto-xref climacs-lisp-table)
(presentation)
(list (presentation-object presentation)))
(define-command (com-edit-this-definition :command-table climacs-lisp-table)
()
"Edit definition of the symbol at point.
If there is no symbol at point, this is a no-op."
(let* ((token (this-form *current-point* *current-syntax*))
(this-symbol (token-to-object *current-syntax* token)))
(when (and this-symbol (symbolp this-symbol))
(edit-definition this-symbol))))
(define-command (com-return-from-definition :name t :command-table climacs-lisp-table)
()
"Return point to where it was before the previous Edit
Definition command was issued."
(pop-find-definition-stack))
(esa:set-key 'com-eval-defun
'climacs-lisp-table
'((#\x :control :meta)))
(esa:set-key 'com-macroexpand-1
'climacs-lisp-table
'((#\c :control) (#\Newline)))
(esa:set-key 'com-macroexpand-all
'climacs-lisp-table
'((#\c :control) (#\m :control)))
(esa:set-key 'com-compile-and-load-file
'climacs-lisp-table
'((#\c :control) (#\k :control)))
(esa:set-key 'com-compile-file
'climacs-lisp-table
'((#\c :control) (#\k :meta)))
(esa:set-key 'com-edit-this-definition
'climacs-lisp-table
'((#\. :meta)))
(esa:set-key 'com-return-from-definition
'climacs-lisp-table
'((#\, :meta)))
;;; -*- Mode: Lisp; Package: DREI-LISP-SYNTAX -*-
;;; (c) copyright 2005 by
;;; Robert Strandh (strandh@labri.fr)
;;; (c) copyright 2006 by
;;; Troels Henriksen (athas@sigkill.dk)
;;;
;;; 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.
;;; Add Climacs-dependent functionality to the stock Lisp syntax.
(in-package :drei-lisp-syntax)
(defmethod frame-clear-completions ((frame climacs-gui:climacs))
(let ((completions-pane
(when (typep *application-frame* 'esa-frame-mixin)
(find "Completions" (windows *application-frame*)
:key #'pane-name
:test #'string=))))
(unless (null completions-pane)
(climacs-gui:delete-window completions-pane)
(setf completions-pane nil))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; Compiler note hyperlinking
(defclass location ()()
(:documentation "The base for all locations."))
(defclass error-location (location)
((error-message :initarg :error-message :accessor error-message)))
(defclass actual-location (location)
((source-position :initarg :position :accessor source-position)
(snippet :initarg :snippet :accessor snippet :initform nil))
(:documentation "The base for all non-error locations."))
(defclass buffer-location (actual-location)
((buffer-name :initarg :buffer :accessor buffer-name)))
(defclass file-location (actual-location)
((file-name :initarg :file :accessor file-name)))
(defclass source-location (actual-location)
((source-form :initarg :source-form :accessor source-form)))
(defclass basic-position () ()
(:documentation "The base for all positions."))
(defclass char-position (basic-position)
((char-position :initarg :position :accessor char-position)
(align-p :initarg :align-p :initform nil :accessor align-p)))
(defun make-char-position (position-list)
(make-instance 'char-position :position (second position-list)
:align-p (third position-list)))
(defclass line-position (basic-position)
((start-line :initarg :line :accessor start-line)
(end-line :initarg :end-line :initform nil :accessor end-line)))
(defun make-line-position (position-list)
(make-instance 'line-position :line (second position-list)
:end-line (third position-list)))
(defclass function-name-position (basic-position)
((function-name :initarg :function-name)))
(defun make-function-name-position (position-list)
(make-instance 'function-name-position :function-name (second position-list)))
(defclass source-path-position (basic-position)
((path :initarg :source-path :accessor path)
(start-position :initarg :start-position :accessor start-position)))
(defun make-source-path-position (position-list)
(make-instance 'source-path-position :source-path (second position-list)
:start-position (third position-list)))
(defclass text-anchored-position (basic-position)
((start :initarg :text-anchored :accessor start)
(text :initarg :text :accessor text)
(delta :initarg :delta :accessor delta)))
(defun make-text-anchored-position (position-list)
(make-instance 'text-anchored-position :text-anchored (second position-list)
:text (third position-list)
:delta (fourth position-list)))
(defclass method-position (basic-position)
((name :initarg :method :accessor name)
(specializers :initarg :specializers :accessor specializers)
(qualifiers :initarg :qualifiers :accessor qualifiers)))
(defun make-method-position (position-list)
(make-instance 'method-position :method (second position-list)
:specializers (third position-list)
:qualifiers (last position-list)))
(defun make-location (location-list)
(ecase (first location-list)
(:error (make-instance 'error-location :error-message (second location-list)))
(:location
(destructuring-bind (l buf pos hints) location-list
(declare (ignore l))
(let ((location
(apply #'make-instance
(ecase (first buf)
(:file 'file-location)
(:buffer 'buffer-location)
(:source-form 'source-location))
buf))
(position
(funcall
(ecase (first pos)
(:position #'make-char-position)
(:line #'make-line-position)
(:function-name #'make-function-name-position)
(:source-path #'make-source-path-position)
(:text-anchored #'make-text-anchored-position)
(:method #'make-method-position))
pos)))
(setf (source-position location) position)
(when hints
(setf (snippet location) (rest hints)))
location)))))
(defmethod initialize-instance :after ((note compiler-note) &rest args)
(declare (ignore args))
(setf (location note) (make-location (location note))))
(defun show-note-counts (notes &optional seconds)
(loop with nerrors = 0
with nwarnings = 0
with nstyle-warnings = 0
with nnotes = 0
for note in notes
do (etypecase note
(error-compiler-note (incf nerrors))
(read-error-compiler-note (incf nerrors))
(warning-compiler-note (incf nwarnings))
(style-warning-compiler-note (incf nstyle-warnings))
(note-compiler-note (incf nnotes)))
finally
(esa:display-message "Compilation finished: ~D error~:P ~
~D warning~:P ~D style-warning~:P ~D note~:P ~
~@[[~D secs]~]"
nerrors nwarnings nstyle-warnings nnotes seconds)))
(defun one-line-ify (string)
"Return a single-line version of STRING.
Each newline and following whitespace is replaced by a single space."
(loop with count = 0
while (< count (length string))
with new-string = (make-array 0 :element-type 'character :adjustable t
:fill-pointer 0)
when (char= (char string count) #\Newline)
do (loop while (and (< count (length string))
(whitespacep *current-syntax* (char string count)))
do (incf count)
;; Just ignore whitespace if it is last in the
;; string.
finally (when (< count (length string))
(vector-push-extend #\Space new-string)))
else
do (vector-push-extend (char string count) new-string)
(incf count)
finally (return new-string)))
(defgeneric print-for-menu (object stream))
(defun print-note-for-menu (note stream severity ink)
(with-accessors ((message message) (short-message short-message)) note
(with-drawing-options (stream :ink ink
:text-style (make-text-style :sans-serif :italic nil))
(princ severity stream)
(princ " " stream))
(princ (if short-message
(one-line-ify short-message)
(one-line-ify message))
stream)))
(defmacro def-print-for-menu (class name colour)
`(defmethod print-for-menu ((object ,class) stream)
(print-note-for-menu object stream ,name ,colour)))
(def-print-for-menu error-compiler-note "Error" +red+)
(def-print-for-menu read-error-compiler-note "Read Error" +red+)
(def-print-for-menu warning-compiler-note "Warning" +dark-red+)
(def-print-for-menu style-warning-compiler-note "Style Warning" +brown+)
(def-print-for-menu note-compiler-note "Note" +brown+)
(defun show-notes (notes buffer-name definition)
(let ((stream (climacs-gui:typeout-window
(format nil "~10TCompiler Notes: ~A ~A" buffer-name definition))))
(loop for note in notes
do (with-output-as-presentation (stream note 'compiler-note)
(print-for-menu note stream))
(terpri stream)
count note into length
finally (change-space-requirements stream
:height (* length (stream-line-height stream)))
(scroll-extent stream 0 0))))
(defgeneric goto-location (location))
(defmethod goto-location ((location error-location))
(esa:display-message (error-message location)))
(defmethod goto-location ((location buffer-location))
(let ((buffer (find (buffer-name location)
(buffers *application-frame*)
:test #'string= :key #'name)))
(unless buffer
(esa:display-message "No buffer ~A" (buffer-name location))
(beep)
(return-from goto-location))
(climacs-core:switch-to-buffer (current-window) buffer)
(goto-position (point (current-window))
(char-position (source-position location)))))
(defmethod goto-location ((location file-location))
(let ((buffer (find (file-name location)
(buffers *application-frame*)
:test #'string= :key #'(lambda (buffer)
(let ((path (filepath buffer)))
(when path
(namestring path)))))))
(if buffer
(climacs-core:switch-to-buffer *current-window* buffer)
(find-file (file-name location)))
(goto-position (point (current-window))
(char-position (source-position location)))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; Macroexpansion and evaluation
(defun macroexpand-token (syntax token &optional (all nil))
(with-syntax-package (syntax (start-offset token))
(let* ((string (token-string syntax token))
(expression (read-from-string string))
(expansion (macroexpand-for-drei (get-usable-image syntax)
expression
all))
(expansion-string (with-output-to-string (s)
(pprint expansion s))))
(let ((buffer (climacs-core:switch-to-buffer *current-window* "*Macroexpansion*")))
(set-syntax buffer "Lisp"))
(let ((point (point (current-window)))
(header-string (one-line-ify (subseq string 0
(min 40 (length string))))))
(end-of-buffer point)
(unless (beginning-of-buffer-p point)
(insert-object point #\Newline))
(insert-sequence point
(format nil ";;; Macroexpand-~:[1~;all~] ~A...~%"
all header-string))
(insert-sequence point expansion-string)
(insert-object point #\Newline)))))
(defun compile-file-interactively (buffer &optional load-p)
(cond ((null (filepath buffer))
(esa:display-message "Buffer ~A is not associated with a file" (name buffer)))
(t
(when (and (needs-saving buffer)
(accept 'boolean :prompt (format nil "Save buffer ~A ?" (name buffer))))
(climacs-core:save-buffer buffer))
(let ((*read-base* (base (syntax buffer))))
(multiple-value-bind (result notes)
(compile-file-for-drei (get-usable-image (syntax buffer))
(filepath buffer)
(package-at-mark (syntax buffer) 0) load-p)
(show-note-counts notes (second result))
(when notes (show-notes notes (name buffer) "")))))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; Definition editing
(defparameter *find-definition-stack* '())
(defun pop-find-definition-stack ()
(unless (null *find-definition-stack*)
(let* ((offset+buffer (pop *find-definition-stack*))
(offset (first offset+buffer))
(buffer (second offset+buffer)))
(if (find buffer (buffers *application-frame*))
(progn (climacs-core:switch-to-buffer *current-window* buffer)
(goto-position (point (current-window)) offset))
(pop-find-definition-stack)))))
;; KLUDGE: We need to put more info in the definition objects to begin
;; with.
(defun definition-type (definition)
(let ((data (read-from-string (first definition))))
(case (first data)
((or cl:defclass)
'cl:class)
((or cl:defgeneric
cl:defmethod
cl:defun
cl:defmacro)
'cl:function)
(t t))))
(defun edit-definition (symbol &optional type)
(let ((all-definitions (find-definitions-for-drei
(get-usable-image (syntax (current-buffer)))
symbol)))
(let ((definitions (if (not type)
all-definitions
(remove-if-not #'(lambda (definition)
(eq (definition-type definition) type))
all-definitions))))
(cond ((null definitions)
(esa:display-message "No known definitions for: ~A" symbol)
(beep))
(t
(goto-definition symbol definitions))))))
(defun goto-definition (name definitions)
(let* ((pane (current-window))
(buffer (buffer pane))
(point (point pane))
(offset (offset point)))
(push (list offset buffer) *find-definition-stack*))
(cond ((null (cdr definitions))
(let* ((def (car definitions))
(xref (make-xref def)))
(goto-location xref)))
(t
(let ((xref (show-definitions name definitions)))
(when xref (goto-location xref))))))
(defclass xref ()
((dspec :initarg :dspec :accessor dspec)
(location :initarg :location :accessor location)))
(defun make-xref (xref-list)
(destructuring-bind (dspec location) xref-list
(make-instance 'xref
:dspec dspec
:location (make-location location))))
(defmethod goto-location ((xref xref))
(goto-location (location xref)))
(defun show-definitions (name definitions)
(show-xrefs (loop for xref-list in definitions
collect (make-xref xref-list))
'definition name))
(defun show-xrefs (xrefs type symbol)
(cond ((null xrefs)
(esa:display-message "No references found for ~A." symbol)
(beep))
(t
(flet ((printer (item stream)
(with-drawing-options (stream :ink +dark-blue+
:text-style (make-text-style :fixed nil nil))
(princ (dspec item) stream))))
(let ((stream (climacs-gui:typeout-window
(format nil "~10T~A ~A" type symbol))))
(loop for xref in xrefs
do (with-output-as-presentation (stream xref 'xref)
(printer xref stream))
(terpri stream)
count xref into length
finally (change-space-requirements stream
:height (* length (stream-line-height stream)))
(scroll-extent stream 0 0)))))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; Some group support
;; WARNING, using this group can be dangerous, as Climacs is not
;; really suited to opening up a large amount of buffers that each
;; require a full syntax reparse. FIXME: Groups are currently
;; disabled.
#+nil (climacs-core:define-group "ASDF System Files" (group (system (asdf:find-system (accept 'symbol :prompt "System"))))
(declare (ignore group))
(when system
(mapcar #'asdf:component-pathname
(remove-if-not (lambda (c)
(typep c 'asdf:cl-source-file))
(asdf:module-components system)))))
\ No newline at end of file
......@@ -29,105 +29,31 @@
(defparameter *climacs-directory* (directory-namestring *load-truename*))
(eval-when (:compile-toplevel :load-toplevel :execute)
(defun find-swank-package ()
(find-package :swank))
(defun find-swank-system ()
(handler-case (asdf:find-system :swank)
(asdf:missing-component ())))
(defun find-swank ()
(or (find-swank-package)
(find-swank-system))))
(defsystem :climacs
:depends-on (:mcclim :flexichain :esa #.(if (find-swank-system) :swank (values)))
:depends-on (:mcclim :flexichain)
:components
((:module "cl-automaton"
:components ((:file "automaton-package")
(:file "eqv-hash" :depends-on ("automaton-package"))
(:file "state-and-transition" :depends-on ("eqv-hash"))
(:file "automaton" :depends-on ("state-and-transition" "eqv-hash"))
(:file "regexp" :depends-on ("automaton"))))
(:module "Persistent"
:components ((:file "binseq-package")
(:file "binseq" :depends-on ("binseq-package"))
(:file "obinseq" :depends-on ("binseq-package" "binseq"))
(:file "binseq2" :depends-on ("binseq-package" "obinseq" "binseq"))))
(:file "packages" :depends-on ("cl-automaton" "Persistent"))
(:file "utils" :depends-on ("packages"))
(:file "buffer" :depends-on ("packages"))
(:file "motion" :depends-on ("packages" "buffer" "syntax"))
(:file "editing" :depends-on ("packages" "buffer" "syntax" "motion" "kill-ring"))
(:file "persistent-buffer"
:pathname #p"Persistent/persistent-buffer.lisp"
:depends-on ("packages" "buffer" "Persistent"))
(:file "base" :depends-on ("packages" "utils" "buffer" "persistent-buffer" "kill-ring"))
(:file "abbrev" :depends-on ("packages" "buffer" "base"))
(:file "syntax" :depends-on ("packages" "utils" "buffer" "base"))
(:file "text-syntax" :depends-on ("packages" "base" "buffer" "syntax" "motion"))
(:file "delegating-buffer" :depends-on ("packages" "buffer"))
(:file "kill-ring" :depends-on ("packages"))
(:file "undo" :depends-on ("packages"))
(:file "persistent-undo"
:pathname #p"Persistent/persistent-undo.lisp"
:depends-on ("packages" "buffer" "persistent-buffer" "undo"))
(:file "pane" :depends-on ("packages" "utils" "syntax" "buffer" "base"
"persistent-undo" "persistent-buffer" "abbrev"
"delegating-buffer" "undo"))
(:file "fundamental-syntax" :depends-on ("packages" "syntax" "buffer" "pane"
"base"))
(:file "cl-syntax" :depends-on ("packages" "buffer" "syntax" "base" "pane"))
(:file "html-syntax" :depends-on ("packages" "buffer" "syntax" "base" "pane"))
(:file "prolog-syntax" :depends-on ("packages" "base" "syntax" "pane" "buffer"))
((:file "packages")
(:file "text-syntax" :depends-on ("packages"))
(:file "cl-syntax" :depends-on ("packages"))
(:file "html-syntax" :depends-on ("packages"))
(:file "prolog-syntax" :depends-on ("packages"))
(:file "prolog2paiprolog" :depends-on ("prolog-syntax"))
(:file "ttcn3-syntax" :depends-on ("packages" "buffer" "syntax" "base"
"pane"))
(:file "lisp-syntax" :depends-on ("packages" "utils" "syntax" "buffer" "base" "pane"
"window-commands" "gui" "groups"))
(:file "lisp-syntax-swine" :depends-on ("lisp-syntax"))
(:file "lisp-syntax-commands" :depends-on ("lisp-syntax-swine" "motion-commands"
"editing-commands" "misc-commands"))
#.(if (find-swank)
'(:file "lisp-syntax-swank" :depends-on ("lisp-syntax"))
(values))
(:file "gui" :depends-on ("packages" "utils" "syntax" "base" "buffer" "undo" "pane"
"kill-ring" "text-syntax"
"abbrev" "editing" "motion"))
(:file "io" :depends-on ("packages" "gui"))
(:file "ttcn3-syntax" :depends-on ("packages"))
(:file "climacs-lisp-syntax" :depends-on ("core" #+nil groups))
(:file "climacs-lisp-syntax-commands" :depends-on ("climacs-lisp-syntax" "misc-commands"))
(:file "gui" :depends-on ("packages" "text-syntax"))
(:file "core" :depends-on ("gui"))
(:file "rectangle" :depends-on ("core"))
(:file "groups" :depends-on ("core"))
(:file "io" :depends-on ("packages" "gui"))
#+nil (:file "groups" :depends-on ("core"))
(:file "climacs" :depends-on ("gui" "core"))
;; (:file "buffer-commands" :depends-on ("gui"))
(:file "developer-commands" :depends-on ("gui" "lisp-syntax" "core"))
(:file "motion-commands" :depends-on ("gui" "core"))
(:file "editing-commands" :depends-on ("gui" "core"))
(:file "developer-commands" :depends-on ("core"))
(:file "file-commands" :depends-on ("gui" "core"))
(:file "misc-commands" :depends-on ("gui" "core" "rectangle" "groups"))
(:file "search-commands" :depends-on ("gui" "core"))
(:file "misc-commands" :depends-on ("gui" "core" #+nil "groups"))
(:file "search-commands" :depends-on ("gui" "core" #+nil "groups"))
(:file "window-commands" :depends-on ("gui" "core"))
(:file "unicode-commands" :depends-on ("gui" "core"))
(:file "slidemacs" :depends-on ("packages" "buffer" "syntax" "base" "pane" ))
(:file "slidemacs-gui" :depends-on ("packages" "slidemacs" "pane" "buffer" "syntax" "gui"))))
(defsystem :climacs.tests
:depends-on (:climacs)
:components
((:file "rt" :pathname #p"testing/rt.lisp")
(:file "buffer-test" :depends-on ("rt"))
(:file "base-test" :depends-on ("rt" "buffer-test"))
(:file "kill-ring-test" :depends-on ("buffer-test"))
(:module
"cl-automaton"
:depends-on ("rt")
:components
((:file "automaton-test-package")
(:file "eqv-hash-test" :depends-on ("automaton-test-package"))
(:file "state-and-transition-test" :depends-on ("automaton-test-package"))
(:file "automaton-test" :depends-on ("automaton-test-package"))
(:file "regexp-test" :depends-on ("automaton-test-package"))))))
(:file "slidemacs" :depends-on ("packages" ))
(:file "slidemacs-gui" :depends-on ("packages" "gui" "slidemacs"))))
#+asdf
(defmethod asdf:perform :around ((o asdf:compile-op)
......
......@@ -46,8 +46,8 @@
;; SBCL doesn't inherit dynamic bindings when starting new
;; processes, so start a new processes and THEN setup the colors.
(flet ((run ()
(let ((*bg-color* +black+)
(*fg-color* +gray+)
(let ((*background-color* +black+)
(*foreground-color* +gray+)
(*info-bg-color* +darkslategray+)
(*info-fg-color* +gray+)
(*mini-bg-color* +black+)
......
......@@ -13,323 +13,6 @@
(in-package :climacs-core)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; Misc stuff
(