LMFL#!C(:HOST "SYS" :BACKUP-DATE 2760032498. :SYSTEM-TYPE :LOGICAL :VERSION 1. :TYPE "LISP" :NAME "STREAM" :DIRECTORY ("REL3-SOURCE" "ZMACS") :SOURCE-PATTERN "( :DIRECTORY (\"REL3-SOURCE\") :NAME :WILD :TYPE :WILD :VERSION :NEWEST)" :VERSION-LIMIT 0. :CHARACTERS T :NOT-BACKED-UP T :CREATION-DATE 2758739796. :AUTHOR "REL3" :LENGTH-IN-BYTES 67450. :LENGTH-IN-BLOCKS 66. :BYTE-SIZE 8.)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ;;; -*- Mode:Common-Lisp; Package:ZWEI; Base:8 -*-;;;                           RESTRICTED RIGHTS LEGEND;;;Use, duplication, or disclosure by the Government is subject to;;;restrictions as set forth in subdivision (b)(3)(ii) of the Rights in;;;Technical Data and Computer Software clause at 52.227-7013.;;;;;;                     TEXAS INSTRUMENTS INCORPORATED.;;;                              P.O. BOX 2909;;;                           AUSTIN, TEXAS 78769;;;                                 MS 2151;;;;;; Copyright (C) 1985, 1987 Texas Instruments Incorporated. All rights reserved.;;; Copyright (C) 1980, Massachusetts Institute of Technology;;; The editor stream;;;??? The current way of printing BARFs isn't all THAT good.(DEFPROP *EDITOR-STREAM-REQUIRE-ACTIVATION* T MODE-SETTABLE-P) (ADD-INITIALIZATION 'EDITOR-STREAM    '(INITIALIZE-EDITOR-STREAM-FLAGS)    '(:WARM)) (DEFUN INITIALIZE-EDITOR-STREAM-FLAGS ()  (SETQ *INSIDE-EDITOR-STREAM* NIL)  (SETQ EDITOR-STREAM-DEFER-REDISPLAY NIL)  (SETQ *STREAM-IBEAM-SHOULD-BLINK* NIL)) (DEFFLAVOR EDITOR-STREAM-MIXIN   (W:IO-BUFFER    (*INSIDE-EDITOR-STREAM* T)    *STREAM-SHEET*    *STREAM-START-BP*    (*STREAM-COMMAND-POINT* NIL)    (*STREAM-INPUT-HISTORY* NIL)    *STREAM-BP*    *STREAM-BLINKER*)   ()  (:DEFAULT-INIT-PLIST    :IBEAM-BLINKER-P T    :EDITOR-CLOSURE-VARIABLES EDITOR-STREAM-CLOSURE-VARIABLES    :COMTAB *STREAM-COMTAB*    :MODE-LINE-LIST '("EDITOR-STREAM " "(" *MODE-NAME-LIST* ")"      (*EDITOR-STREAM-ACTIVATION-NEEDED* " {Not activating}" :ELSE "")))  (:REQUIRED-FLAVORS TOP-LEVEL-DISPLAYER-MIXIN DISPLAYER)  (:INITABLE-INSTANCE-VARIABLES *STREAM-SHEET*)  (:GETTABLE-INSTANCE-VARIABLES *STREAM-SHEET* *STREAM-INPUT-HISTORY*)  (:SETTABLE-INSTANCE-VARIABLES *STREAM-COMMAND-POINT*)  (:SPECIAL-INSTANCE-VARIABLES *INSIDE-EDITOR-STREAM*)  (:INIT-KEYWORDS :IBEAM-BLINKER-P)) (DEFMETHOD (EDITOR-STREAM-MIXIN :AFTER :INIT) (INIT-PLIST)  (SETQ *STREAM-INPUT-HISTORY* (MAKE-HISTORY (STRING-APPEND "input history of "    (SEND *STREAM-SHEET* :NAME))))  (SETQ W:IO-BUFFER (SEND *STREAM-SHEET* :IO-BUFFER))  (SETQ *STREAM-BLINKER* (WINDOW-POINT-BLINKER *STREAM-SHEET*))  (AND (GET INIT-PLIST :IBEAM-BLINKER-P)       (LET ((BLINKER (W:MAKE-BLINKER *STREAM-SHEET* 'STREAM-IBEAM-BLINKER       :EDITOR-STREAM SELF       :VISIBILITY NIL))) (SETF (WINDOW-SPECIAL-BLINKER-LIST *STREAM-SHEET*)       (DELETE (ASSOC 'STREAM-BLINK-IBEAM      (WINDOW-SPECIAL-BLINKER-LIST *STREAM-SHEET*)      :TEST #'EQ)       (THE LIST (WINDOW-SPECIAL-BLINKER-LIST *STREAM-SHEET*))       :TEST #'EQ)) (PUSH `(STREAM-BLINK-IBEAM . ,BLINKER)       (WINDOW-SPECIAL-BLINKER-LIST *STREAM-SHEET*))))  (SYSTEM:%USING-BINDING-INSTANCES (CLOSURE-BINDINGS EDITOR-CLOSURE))  (SETQ *EDITOR-STREAM* SELF*WINDOW* *STREAM-SHEET**EDITOR-STREAM-START-BP* *STREAM-START-BP*)  (PUSH 'STREAM-PRE-COMMAND-HOOK *COMMAND-HOOK*)  (PUSH 'STREAM-COMMAND-HOOK *POST-COMMAND-HOOK*)) (DEFMETHOD (EDITOR-STREAM-MIXIN :AFTER :SET-INTERVAL-INTERNAL) (IGNORE)  (LET ((INT (WINDOW-INTERVAL *STREAM-SHEET*)))    (IF (VARIABLE-BOUNDP *STREAM-START-BP*)(MOVE-BP *STREAM-START-BP* (INTERVAL-LAST-BP INT))(SETQ *STREAM-START-BP* (COPY-BP (INTERVAL-LAST-BP INT) :NORMAL)))    (SETQ *STREAM-BP* (WINDOW-POINT *STREAM-SHEET*))    (MOVE-BP *STREAM-BP* *STREAM-START-BP*))) ;; The window used by an editor stream must support the operations;; :ENTER-EDITOR, :EXIT-EDITOR and :ACTIVATION-NEEDED.  These tell the window;; what state the editor stream is in, so the window can display something;; to tell the user.  :ENTER-EDITOR says the stream is now running the editor.;; :EXIT-EDITOR says the stream is no longer inside the editor.;; :ACTIVATION-NEEDED says the stream is inside the editor;; and will not leave the editor until the user gives an explicit;; Activate command.;; ZWEI windows, which are used by ZTOP streams, just ignore these operations;; since ZTOP can use the ordinary editor mode line to display the information.;; EDITOR-STREAM-WINDOWs, since they do not have a mode line permanently displayed,;; use those operations to display that information in the label.;;; This is an editor window which is also an editor stream instead;;; of an ordinary sort of stream.(DEFFLAVOR EDITOR-STREAM-WINDOW   ((LABEL-STATE NIL)    (BASE-TICK *TICK*))   (EDITOR-STREAM-MIXIN    TOP-LEVEL-DISPLAYER-MIXIN    EDITOR-WINDOW-WITH-POP-UP-MINI-BUFFER-MIXIN    ZWEI-WINDOW)  :GETTABLE-INSTANCE-VARIABLES  (:DEFAULT-INIT-PLIST    :MORE-P T    :RIGHT-MARGIN-CHARACTER-FLAG 0)) (DEFMETHOD (EDITOR-STREAM-WINDOW :AFTER :INIT) (IGNORE)  (SEND SELF :EXIT-EDITOR)  (EDITOR-WINDOW-WITH-POP-UP-MINI-BUFFER-MIXIN-POSITION-MODE-LINE-WINDOW)) (DEFMETHOD (EDITOR-STREAM-WINDOW :BEFORE :INIT) (IGNORE)  (SETQ *STREAM-SHEET* SELF));;;Undefine this method because it no longer applies.;;;By rpm (from pf) on 7-7-86.;(DEFMETHOD (EDITOR-STREAM-WINDOW :AROUND :PRINT-NOTIFICATION) (CONTIN MAP CONTIN-ARGS &REST IGNORE);  (WITH-BP (TEM *STREAM-BP* ':MOVES);    (WITH-BP (OLD-POINT POINT ':MOVES);      (MOVE-BP *STREAM-BP* *STREAM-START-BP*);      (LET ((EDITOR-STREAM-DEFER-REDISPLAY T));(AROUND-METHOD-CONTINUE CONTIN MAP CONTIN-ARGS));      (MOVE-BP *STREAM-START-BP* *STREAM-BP*);      (MOVE-BP POINT OLD-POINT);      (MOVE-BP *STREAM-BP* TEM)));  (STREAM-REDISPLAY)) (DEFMETHOD (EDITOR-STREAM-WINDOW :ENTER-EDITOR) ()  (COND ((EQ LABEL-STATE :READING) (SEND SELF :DELAYED-SET-LABEL       (FORMAT NIL "~A  Editing; insert text at end to resume reading" W:NAME)) (SETQ LABEL-STATE :EDITOR)))) (DEFMETHOD (EDITOR-STREAM-WINDOW :EXIT-EDITOR) ()  (COND ((NEQ LABEL-STATE :READING) (IF W:LABEL-NEEDS-UPDATING     ;; An :ENTER-EDITOR has been done but label hasn't redisplayed yet.     ;; Just cancel the label redisplay, since it is really still right.     (SETQ W:LABEL-NEEDS-UPDATING NIL)     ;; Label is really wrong.     (SEND SELF :SET-LABEL (FORMAT NIL "~A  Actively reading and evaluating" W:NAME))) (SETQ LABEL-STATE :READING)))) (DEFMETHOD (EDITOR-STREAM-WINDOW :ACTIVATION-NEEDED) ()  (COND ((NEQ LABEL-STATE :ACTIVATION-NEEDED) (SETQ W:LABEL-NEEDS-UPDATING NIL) (SEND SELF :SET-LABEL       (FORMAT NIL "~A  Type ~A to resume reading of input"       (SEND SELF :NAME)       (KEY-FOR-COMMAND 'COM-ACTIVATE(SYMEVAL-IN-CLOSURE EDITOR-CLOSURE *COMTAB*)NIL NIL #\END))) (SETQ LABEL-STATE :ACTIVATION-NEEDED)))) ;Inhibit ZWEI-FRAME's tendency to put the label into the name in the select menu.(DEFMETHOD (EDITOR-STREAM-WINDOW :NAME-FOR-SELECTION) ()  W:NAME) ;;; Basic I/O operations on editor streams.;;; The output operations here type directly on the sheet;;; as well as updating the buffer.;;; The input operations here have special hacks to detect when they are called;;; inside the rubout handler.  Note that RUBOUT-HANDLER is non-nil when;;; input is being done with rubout handling (editing, in our case);;;; but it is NIL when input is being done on behalf of the rubout handler.;;; *EDITOR-STREAM-ALREADY-KNOWS* is T at that time; it is how you can;;; distinguish the two reasons why RUBOUT-HANDLER might be NIL.;;; *INSIDE-EDITOR-STREAM* is NIL when inside the editor proper or editor redisplay;;; (This is not quite the same as when *EDITOR-STREAM-ALREADY-KNOWS* is T);;;; T at all other times while inside operations on the editor stream.;;; It enables more processing and glitching in ZWEI windows,;;; which must not happen in the editor redisplay.(DEFMACRO STREAM-IMMEDIATE-OUTPUT (&BODY BODY)  "Perform BODY if no redisplay is pending and direct output is feasible.It may also do the redisplay and then perform BODY.BODY should be code to do output to have the effect of redisplayfor changes already made to the buffer."  `(OR (STREAM-MAYBE-REDISPLAY)       (PROGN . ,BODY))) (DEFMETHOD (EDITOR-STREAM-MIXIN :WRITE-CHAR) (CH)  (LET ((*WINDOW* *STREAM-SHEET*))    (INSERT-MOVING *STREAM-BP* CH)    (STREAM-IMMEDIATE-OUTPUT      (W::SHEET-TYO *STREAM-SHEET* CH))))(DEFMETHOD (EDITOR-STREAM-MIXIN :TYO) (CH)  (SEND SELF :WRITE-CHAR (INT-CHAR CH)))(DEFMETHOD (EDITOR-STREAM-MIXIN :STRING-OUT) (STR &OPTIONAL (START 0) END)  (LET ((*WINDOW* *STREAM-SHEET*))    (INSERT-MOVING *STREAM-BP* (IF (AND (ZEROP START) (NULL END))   STR   (NSUBSTRING STR START END)))    (STREAM-IMMEDIATE-OUTPUT      (W:SHEET-STRING-OUT *STREAM-SHEET* STR START END)))) (DEFMETHOD (EDITOR-STREAM-MIXIN :LINE-OUT) (STR &OPTIONAL (START 0) END)  (LET ((*WINDOW* *STREAM-SHEET*))    (INSERT-MOVING *STREAM-BP* (IF (AND (ZEROP START) (NULL END))   STR   (NSUBSTRING STR START END)))    (INSERT-MOVING *STREAM-BP* #\NEWLINE)    (STREAM-IMMEDIATE-OUTPUT      (W:SHEET-STRING-OUT *STREAM-SHEET* STR START END)      (W:SHEET-CRLF *STREAM-SHEET*)))) (DEFMETHOD (EDITOR-STREAM-MIXIN :AROUND :LISTEN) (CONT MT ARGS)  (OR (NOT (OR (NOT RUBOUT-HANDLER)       (BP-= *STREAM-BP*     (INTERVAL-LAST-BP (WINDOW-INTERVAL *STREAM-SHEET*)))))      (AROUND-METHOD-CONTINUE CONT MT ARGS))) (DEFMETHOD (EDITOR-STREAM-MIXIN :BEFORE :CLEAR-INPUT) ()  (UNLESS (BP-= *STREAM-BP* (INTERVAL-LAST-BP (WINDOW-INTERVAL *STREAM-SHEET*)))    (LET ((*WINDOW* *STREAM-SHEET*)  (*INTERVAL* (WINDOW-INTERVAL *STREAM-SHEET*)))      (KILL-INTERVAL *STREAM-BP*     (INTERVAL-LAST-BP (WINDOW-INTERVAL *STREAM-SHEET*))     T))    (FORMAT SELF "~&Killing the rest of the buffer to clear input.  It is on the kill ring."))) (DEFMETHOD (EDITOR-STREAM-MIXIN :READ-ANY-NO-HANG) (&OPTIONAL IGNORE)  (AND RUBOUT-HANDLER       (FERROR NIL ":READ-ANY-NO-HANG while inside RUBOUT-HANDLER"))  (W:KBD-IO-BUFFER-GET W:IO-BUFFER T))(DEFMETHOD (EDITOR-STREAM-MIXIN :ANY-TYI-NO-HANG) (&OPTIONAL IGNORE)  (AND RUBOUT-HANDLER       (FERROR NIL ":ANY-TYI-NO-HANG while inside RUBOUT-HANDLER"))  (W:KBD-IO-BUFFER-GET W:IO-BUFFER T));;; Actual rubout handling.(DEFMETHOD (EDITOR-STREAM-MIXIN :READ-ANY) (&OPTIONAL IGNORE)  (COND (RUBOUT-HANDLER ;; If input is being edited... (IF (AND (NULL *SRE-INPUT-POINT*)  (NOT (BP-= *STREAM-BP* (INTERVAL-LAST-BP (WINDOW-INTERVAL *STREAM-SHEET*)))))     ;; If we have more to fetch from the buffer, just fetch it.     (PROG1       (MAKE-CHAR (BP-CHAR *STREAM-BP*))  ;Give buffered character if any       (MUST-REDISPLAY *STREAM-SHEET* DIS-BPS)  ;We are moving point, so...       (LET ((*INTERVAL* INTERVAL)) (IBP *STREAM-BP*)))     ;; We have to get more input, probably invoking the editor.     (LET ((*EDITOR-STREAM-ALREADY-KNOWS* T))       (SEND SELF :STREAM-RUBOUT-HANDLER))));; If input is not being edited...(T ;; Then we read it directly, as if were not an editor stream. ;; Make sure screen is right before we read it. ;; But if came from within the rubout handler, that is already done. (OR *EDITOR-STREAM-ALREADY-KNOWS*     (STREAM-REDISPLAY)) (COND ((W:KBD-IO-BUFFER-GET W:IO-BUFFER T))       (T(SEND SELF :NOTICE :INPUT-WAIT)(W:KBD-IO-BUFFER-GET W:IO-BUFFER))))))(DEFMETHOD (EDITOR-STREAM-MIXIN :ANY-TYI) (&OPTIONAL IGNORE)  (COND (RUBOUT-HANDLER ;; If input is being edited... (IF (AND (NULL *SRE-INPUT-POINT*)  (NOT (BP-= *STREAM-BP* (INTERVAL-LAST-BP (WINDOW-INTERVAL *STREAM-SHEET*)))))     ;; If we have more to fetch from the buffer, just fetch it.     (PROG1       (CHAR-CODE (BP-CHAR *STREAM-BP*))  ;Give buffered character if any       (MUST-REDISPLAY *STREAM-SHEET* DIS-BPS)  ;We are moving point, so...       (LET ((*INTERVAL* INTERVAL)) (IBP *STREAM-BP*)))     ;; We have to get more input, probably invoking the editor.     (LET ((*EDITOR-STREAM-ALREADY-KNOWS* T))       (SEND SELF :STREAM-RUBOUT-HANDLER))));; If input is not being edited...(T ;; Then we read it directly, as if were not an editor stream. ;; Make sure screen is right before we read it. ;; But if came from within the rubout handler, that is already done. (OR *EDITOR-STREAM-ALREADY-KNOWS*     (STREAM-REDISPLAY)) (COND ((W:KBD-IO-BUFFER-GET W:IO-BUFFER T))       (T(SEND SELF :NOTICE :INPUT-WAIT)(W:KBD-IO-BUFFER-GET W:IO-BUFFER))))))(DEFMETHOD (EDITOR-STREAM-MIXIN :UNREAD-ANY) (CH)  (IF RUBOUT-HANDLER      (LET ((*INTERVAL* (SEND *STREAM-SHEET* :INTERVAL)))(DBP *STREAM-BP*))      (W:IO-BUFFER-UNGET W:IO-BUFFER CH)))(DEFMETHOD (EDITOR-STREAM-MIXIN :UNTYI) (CH)  (SEND SELF :UNREAD-ANY CH));This is the "rubout handler" itself.  We call the supplied function;after binding RUBOUT-HANDLER to T.  That function, which might be READ,;does its input as usual, but the :READ-ANY operation acts differently;because RUBOUT-HANDLER is T.  Specifically, it may invoke :STREAM-RUBOUT-HANDLER.(DEFMETHOD (EDITOR-STREAM-MIXIN :RUBOUT-HANDLER)   (RUBOUT-HANDLER-ARGS FUNCTION &REST ARGS    &AUX TEM (*WINDOW* *STREAM-SHEET*) *STREAM-DEFER-OUTPUT-NOT-AT-END* COMMAND-POINT)  (IF *STREAM-COMMAND-POINT*      (PROGN(MOVE-BP *STREAM-START-BP* *STREAM-BP*)(SETQ COMMAND-POINT *STREAM-COMMAND-POINT*)(FLUSH-BP COMMAND-POINT)(SETQ *STREAM-COMMAND-POINT* NIL))      (MOVE-BP *STREAM-START-BP* (INTERVAL-LAST-BP (WINDOW-INTERVAL *STREAM-SHEET*))))  (LET ((PROMPT-OPTION (ASSOC :PROMPT RUBOUT-HANDLER-ARGS :TEST #'EQ)))    (WHEN PROMPT-OPTION      (IF (ARRAYP (CADR PROMPT-OPTION))  (PRINC (CADR PROMPT-OPTION) SELF)  (FUNCALL (CADR PROMPT-OPTION) SELF NIL))      (MOVE-BP *STREAM-START-BP* (INTERVAL-LAST-BP (WINDOW-INTERVAL *STREAM-SHEET*)))))  (LET ((INITIAL-INPUT (CADR (ASSOC :INITIAL-INPUT RUBOUT-HANDLER-ARGS :TEST #'EQ)))(INITIAL-INPUT-POINTER (CADR (ASSOC :INITIAL-INPUT-POINTER RUBOUT-HANDLER-ARGS :TEST #'EQ)))(*INTERVAL* (WINDOW-INTERVAL *STREAM-SHEET*)))  ;need this in forward-char    (WHEN INITIAL-INPUT      (INSERT *STREAM-START-BP* INITIAL-INPUT)      (OR COMMAND-POINT  (NOT INITIAL-INPUT-POINTER)  (SETQ COMMAND-POINT (FORWARD-CHAR *STREAM-START-BP* INITIAL-INPUT-POINTER)))))  (STREAM-MAYBE-REDISPLAY)  (CATCH 'W::RETURN-FROM-RUBOUT-HANDLER    (DO ((RUBOUT-HANDLER T)  ;Establish rubout handler (*SRE-ACTIVATION-CHARACTER* NIL) (*STREAM-EDITING-COMMAND* (CDR (ASSOC :EDITING-COMMAND RUBOUT-HANDLER-ARGS :TEST #'EQ))) (*STREAM-PASS-THROUGH* (CDR (ASSOC :PASS-THROUGH RUBOUT-HANDLER-ARGS :TEST #'EQ))) (*STREAM-COMMAND-HANDLER* (ASSOC :COMMAND RUBOUT-HANDLER-ARGS :TEST #'EQ)) (*STREAM-ACTIVATION-HANDLER* (ASSOC :ACTIVATION RUBOUT-HANDLER-ARGS :TEST #'EQ)) (*STREAM-DO-NOT-ECHO* (CDR (ASSOC :DO-NOT-ECHO RUBOUT-HANDLER-ARGS :TEST #'EQ))) (*STREAM-PREEMPTABLE* (ASSOC :PREEMPTABLE RUBOUT-HANDLER-ARGS :TEST #'EQ)))(NIL)      (WITH-BP (START-OF-MSG-BP *STREAM-START-BP* ':NORMAL)(WITH-BP (END-OF-MSG-BP *STREAM-START-BP* ':NORMAL)  (CATCH 'RUBOUT-HANDLER    (CONDITION-CASE (ERROR)(LET ((*SRE-STREAM-BP* *STREAM-BP*)      (*SRE-STREAM-START-BP* *STREAM-START-BP*)      (*SRE-WINDOW* *STREAM-SHEET*)      *SRE-INPUT-END-BP*      (*SRE-INPUT-POINT* COMMAND-POINT))  (CONDITION-BIND ((ERROR 'STREAM-READ-ERROR-HANDLER))    (RETURN      (LET (LIST)(SETQ LIST (MULTIPLE-VALUE-LIST (APPLY FUNCTION ARGS)))(LET ((*INTERVAL* (WINDOW-INTERVAL *STREAM-SHEET*)))  (DELETE-INTERVAL *STREAM-BP* (INTERVAL-LAST-BP *INTERVAL*)));; Make sure to redisplay after the read operation, because if we don't,;; a yank followed by an activation could cause a deleted line to still have;; a corresponding pline, which messes things up.  This change also seems to;; affect Ztop Mode. Modified by rpm (from pf) on 7-7-86.(MUST-REDISPLAY *STREAM-SHEET* DIS-TEXT)  (STREAM-REDISPLAY)                  (VALUES-LIST LIST)))))      (SYSTEM:PARSE-ERROR       (LET ((*STREAM-DEFER-OUTPUT-NOT-AT-END* T)) (TERPRI SELF) (PRINC ">>ERROR: " SELF) (SEND ERROR :REPORT SELF) (TERPRI SELF))       (MOVE-BP *STREAM-START-BP* *STREAM-BP*)       (MOVE-BP END-OF-MSG-BP *STREAM-START-BP*)       (MOVE-BP *STREAM-BP* (INTERVAL-LAST-BP (WINDOW-INTERVAL *STREAM-SHEET*)))       (MUST-REDISPLAY *STREAM-SHEET* DIS-BPS) (STREAM-REDISPLAY)       (DO () (NIL) (SEND SELF :READ-CHAR)))))  ;; Send :notice :input-wait to reset the more-vpos after editing.  ;; There's probably a better way, but this one works.  ;; Modifed by rpm (from pf) on 7-7-86.  (LET ((*INSIDE-EDITOR-STREAM* T))    (SEND *STREAM-SHEET* :NOTICE :INPUT-WAIT))  ;; Here if editor throws to RUBOUT-HANDLER  ;; to cause the input we have to be read over again.  ;; First, delete any error message we got from a previous parsing.  (COND ((NOT (BP-= START-OF-MSG-BP END-OF-MSG-BP)) (DELETE-INTERVAL START-OF-MSG-BP END-OF-MSG-BP T) (MUST-REDISPLAY *STREAM-SHEET* DIS-TEXT) (STREAM-REDISPLAY T)))  ;; Now start over again reading from the front of the input.  (MOVE-BP *STREAM-BP* *STREAM-START-BP*)  (SETQ COMMAND-POINT NIL)  (MUST-REDISPLAY *STREAM-SHEET* DIS-BPS)))      ;; When a rubout or other editing operation is done, throws back to that      ;; catch to reread the input.  But if the :FULL-RUBOUT option was specified      ;; and everything was rubbed out, we return NIL and the specified value.      (AND (BP-= *STREAM-START-BP* (INTERVAL-LAST-BP (WINDOW-INTERVAL *STREAM-SHEET*)))   (SETQ TEM (ASSOC :FULL-RUBOUT RUBOUT-HANDLER-ARGS :TEST #'EQ))   (RETURN (VALUES NIL (CADR TEM))))))) ;;; Catch all errors from inside read and make a copy of the text so far so the error message;;; looks reasonable(DEFUN STREAM-READ-ERROR-HANDLER (IGNORE &REST IGNORE)  (COND (RUBOUT-HANDLER (INSERT-INTERVAL *SRE-STREAM-BP* *SRE-STREAM-START-BP* *SRE-STREAM-BP*) (MUST-REDISPLAY *SRE-WINDOW* DIS-TEXT)))  NIL) ;This is a separate demon method so that ZTOP-STREAM-MIXIN will not override it.(DEFMETHOD (EDITOR-STREAM-MIXIN :AFTER :RUBOUT-HANDLER) (OPTIONS &REST IGNORE)  (UNLESS (OR (CADR (ASSOC :NO-INPUT-SAVE OPTIONS :TEST #'EQ))      (CADR (ASSOC :DONT-SAVE OPTIONS :TEST #'EQ)))    (PUSH-ON-HISTORY (STRING-INTERVAL *STREAM-START-BP* (WINDOW-POINT *STREAM-SHEET*))     *STREAM-INPUT-HISTORY*))) (DEFMETHOD (EDITOR-STREAM-MIXIN :REFRESH-RUBOUT-HANDLER) (&REST IGNORE)  (UNLESS (BP-< *STREAM-START-BP* *SRE-INPUT-POINT*)    (MOVE-BP *SRE-INPUT-POINT* *STREAM-START-BP*))  (LET ((CONTENTS (STRING-INTERVAL *STREAM-START-BP* *SRE-INPUT-END-BP*))(POINT-OFFSET (BP-DIFFERENCE *SRE-INPUT-POINT* *STREAM-START-BP*))(*INTERVAL* (WINDOW-INTERVAL *STREAM-SHEET*)))    (MOVE-BP *STREAM-START-BP* (INTERVAL-LAST-BP (WINDOW-INTERVAL *STREAM-SHEET*)))    (INSERT *STREAM-START-BP* CONTENTS)    (MOVE-BP *STREAM-BP* (FORWARD-CHAR *STREAM-START-BP* POINT-OFFSET T))    (SETQ *SRE-INPUT-POINT* (COPY-BP *STREAM-BP*))    (MUST-REDISPLAY *STREAM-SHEET* DIS-TEXT)    (STREAM-REDISPLAY T))) (DEFUN BP-DIFFERENCE (BP2 BP1)  (LET ((BP (COPY-BP BP1))(*INTERVAL* (BP-TOP-LEVEL-NODE BP1)))    (DO ((I 0 (1+ I)))((BP-= BP BP2) I)      (IBP BP)))) ;Do one :READ-ANY for a read being done with rubout handling.(DEFMETHOD (EDITOR-STREAM-MIXIN :STREAM-RUBOUT-HANDLER) (&AUX (RUBOUT-HANDLER NIL) CHAR)  ;; If there is a saved-up activation character, return it from :READ-ANY now.  ;; This happens at the end of a rescan of the input.  (IF *SRE-ACTIVATION-CHARACTER*      (PROG1*SRE-ACTIVATION-CHARACTER*(SETQ *SRE-ACTIVATION-CHARACTER* NIL))      ;; We could just call the editor, but we must pass certain characters (editing-commands)      ;; that the program doing the read is handling, and we also want to      ;; save some time for alphabetic characters.      (PROGN(IF *SRE-INPUT-POINT*    (MUST-REDISPLAY *STREAM-SHEET* DIS-BPS)    (SETQ CHAR (SEND SELF :READ-ANY)));; Just type out and insert self-inserting printing characters;; but not if they are the caller's editing-commands or activations or commands,;; or if they have been redefined in the editor itself.(IF (AND (CHARACTERP CHAR) (NOT (OR (MEMBER CHAR *STREAM-EDITING-COMMAND* :TEST #'EQ)  (SI:ASSQ-CAREFUL CHAR *STREAM-EDITING-COMMAND*))) (NOT (AND *STREAM-COMMAND-HANDLER*   (APPLY (CADR *STREAM-COMMAND-HANDLER*)  CHAR (CDDR *STREAM-COMMAND-HANDLER*)))) (NOT (AND *STREAM-ACTIVATION-HANDLER*   (APPLY (CADR *STREAM-ACTIVATION-HANDLER*)  CHAR (CDDR *STREAM-ACTIVATION-HANDLER*)))) (NOT (MEMBER CHAR *STREAM-DO-NOT-ECHO* :TEST #'EQ)) (OR (AND (OR (CHAR< CHAR #\SPACE)      (ALPHA-CHAR-P CHAR))  (EQ 'COM-ORDINARILY-SELF-INSERT      (COMMAND-LOOKUP CHAR *STREAM-COMTAB*)))     (AND (ZEROP (CHAR-FONT CHAR))  (ZEROP (CHAR-BITS CHAR))  (MEMBER CHAR *STREAM-PASS-THROUGH* :TEST #'EQ))))    (LET ((*WINDOW* *STREAM-SHEET*))      (INSERT-MOVING *STREAM-BP* CHAR)      (STREAM-IMMEDIATE-OUTPUT(W::SHEET-TYO *STREAM-SHEET* CHAR))      CHAR)    ;; Otherwise, run the editor till COM-ACTIVATE throws to us,    ;; then throw to RUBOUT-HANDLER to restart the read using the buffer contents.    ;; Move editor point to where we are reading.    (PROGN      (MOVE-BP *STREAM-BP* (OR *SRE-INPUT-POINT*       (INTERVAL-LAST-BP (WINDOW-INTERVAL *STREAM-SHEET*))))      (SETQ *SRE-INPUT-POINT* NIL)      ;; Update buffer display and window data so editor gets consistent data.      (STREAM-REDISPLAY T)      ;; Unread this character so editor will execute it.      (WHEN CHAR(W:IO-BUFFER-UNGET (SEND *STREAM-SHEET* :IO-BUFFER) CHAR))      ;; Edit.      (SET-IN-CLOSURE EDITOR-CLOSURE '*EDITOR-STREAM-ACTIVATION-NEEDED* NIL)      ;; PASS-ON characters throw here      ;; to return from the :READ-ANY method.      (CATCH 'RETURN-FROM-READ-ANY(LET ((*STREAM-IBEAM-SHOULD-BLINK* NIL)      (*INSIDE-EDITOR-STREAM* NIL))  (BIND (LOCF (W:SHEET-MORE-VPOS *STREAM-SHEET*)) NIL)  (UNLESS (BP-= *STREAM-BP* (INTERVAL-LAST-BP (WINDOW-INTERVAL *STREAM-SHEET*)))    (SEND SELF :ENTER-EDITOR)    (SETQ *STREAM-IBEAM-SHOULD-BLINK* T)    (LET ((IBEAM-BLINKER (CDR (ASSOC 'STREAM-BLINK-IBEAM     (WINDOW-SPECIAL-BLINKER-LIST *STREAM-SHEET*)     :TEST #'EQ))))      (WHEN IBEAM-BLINKER(STREAM-BLINK-IBEAM IBEAM-BLINKER *STREAM-SHEET* *STREAM-BP* NIL))))  (UNWIND-PROTECT (SEND *STREAM-SHEET* :EDIT EDITOR-CLOSURE)    (SEND *STREAM-SHEET* :EXIT-EDITOR)    ;; Put blinker into ordinary stream mode instead of editor mode.    (MULTIPLE-VALUE-BIND (X Y) (W:BLINKER-READ-CURSORPOS *STREAM-BLINKER*)      (W:SHEET-SET-CURSORPOS *STREAM-SHEET* X Y))    (SEND *STREAM-BLINKER* :SET-FOLLOW-P T)  ;Make the blinker follow again    (W:BLINKER-SET-VISIBILITY *STREAM-BLINKER*       (IF (EQ *STREAM-SHEET* W:SELECTED-WINDOW)   :BLINK   :ON)))  ;; Tell the :RUBOUT-HANDLER method to restart the read.  (THROW 'RUBOUT-HANDLER T)))))))) ;;; Call editor redisplay from the editing stream.(DEFMETHOD (EDITOR-STREAM-WINDOW :AFTER :REFRESH) (&OPTIONAL IGNORE)  (OR W:RESTORED-BITS-P      (NOT (W:SHEET-EXPOSED-P *STREAM-SHEET*))      (STREAM-REDISPLAY T))) ;Fix up the PLINE data of a window to correspond to the text in its interval,;on the assumption that we updated the screen by hand already.(DEFUN FAKE-OUT-TOP-LINE (WINDOW BUFFER &AUX START-LINE START-INDEX START-PLINE LAST-BP SHEET)  (SETQ LAST-BP (INTERVAL-LAST-BP BUFFER)SHEET (WINDOW-SHEET WINDOW))  (SETQ START-PLINE (DO ((PLINE 0 (1+ PLINE)) (N-PLINES (WINDOW-N-PLINES WINDOW)) (LINE))((>= PLINE N-PLINES) (1- N-PLINES))      (SETQ LINE (PLINE-LINE WINDOW PLINE))      (AND (OR (NULL LINE)       (> (LINE-TICK LINE) (PLINE-TICK WINDOW PLINE)))   (RETURN (1- PLINE)))))  ;; If the screen was glitched, the pline structure is all wrong.  (IF (OR (NEQ (BP-LINE (WINDOW-START-BP WINDOW))       (PLINE-LINE WINDOW 0))  (/= (BP-INDEX (WINDOW-START-BP WINDOW))      (PLINE-FROM-INDEX WINDOW 0)))      (SETQ START-PLINE -1))  (IF (MINUSP START-PLINE)      (LET ((BP (OR (WINDOW-START-BP WINDOW)    (INTERVAL-FIRST-BP (WINDOW-INTERVAL WINDOW)))))(SETQ START-LINE (BP-LINE BP)      START-INDEX (BP-INDEX BP)      START-PLINE 0))      (PROGN(SETQ START-LINE (PLINE-LINE WINDOW START-PLINE)      START-INDEX (PLINE-TO-INDEX WINDOW START-PLINE))(AND (>= START-INDEX (LINE-LENGTH START-LINE))  ;Includes CR     (SETQ START-LINE (LINE-NEXT START-LINE)   START-INDEX 0   START-PLINE (1+ START-PLINE)))))  (BLOCK LINES    (DO ((LINE START-LINE (LINE-NEXT LINE)) (FROM-INDEX START-INDEX 0) (TO-INDEX) (PLINE START-PLINE) (N-PLINES (WINDOW-N-PLINES WINDOW)) (STOP-LINE (BP-LINE LAST-BP)) (LH (W:SHEET-LINE-HEIGHT SHEET)) (I) (TW));; If we exhaust the test there is to display, mark remaining screen lines as empty.((NULL LINE) (DO ((PLINE PLINE (1+ PLINE)))     ((= PLINE N-PLINES))   (SETF (PLINE-LINE WINDOW PLINE) NIL)   (SETF (PLINE-TICK WINDOW PLINE) NIL)   (SETF (PLINE-MARKING-LEFT WINDOW PLINE) NIL)))      (IF (= PLINE N-PLINES)  (RETURN))      (SETQ TO-INDEX (IF (EQ LINE STOP-LINE) (BP-INDEX LAST-BP) (LINE-LENGTH LINE)))      (DO () (NIL)(MULTIPLE-VALUE-SETQ (TW NIL I)  (W:SHEET-COMPUTE-MOTION SHEET 0 0 LINE FROM-INDEX TO-INDEX NIL 0 LH))(OR (NUMBERP I)    (SETQ I (1+ (LINE-LENGTH LINE))))(SETF (PLINE-LINE WINDOW PLINE) LINE)(SETF (PLINE-FROM-INDEX WINDOW PLINE) FROM-INDEX)(SETF (PLINE-TO-INDEX WINDOW PLINE) I)(SETF (PLINE-TICK WINDOW PLINE) *TICK*)(SETF (PLINE-MARKING-LEFT WINDOW PLINE) NIL)(SETF (PLINE-TEXT-WIDTH WINDOW PLINE) (IF (<= I (LINE-LENGTH LINE))  TW  (+ TW (W:SHEET-CHAR-WIDTH SHEET))))(SETQ FROM-INDEX I)(AND (>= (SETQ PLINE (1+ PLINE)) N-PLINES)     (RETURN-FROM LINES))(AND (> FROM-INDEX TO-INDEX)     (RETURN)))      ;; This is another way of exhausting the text we have to display.      (IF (EQ LINE STOP-LINE)  (RETURN    (DO ((PLINE PLINE (1+ PLINE)))((= PLINE N-PLINES))      (SETF (PLINE-LINE WINDOW PLINE) NIL)      (SETF (PLINE-TICK WINDOW PLINE) NIL)      (SETF (PLINE-MARKING-LEFT WINDOW PLINE) NIL))))))) (DEFUN STREAM-MAYBE-REDISPLAY ()  "Maybe redisplay the buffer; then return NIL if caller should update screen explicitly.This function may redisplay and return T,may refrain from redisplay and return T.If explicit updating will work, always does nothing and returns NILbecause explicit updating is certainly fast."  (DECLARE (:SELF-FLAVOR EDITOR-STREAM-MIXIN))  (W:PREPARE-SHEET (*STREAM-SHEET*) NIL)  (COND (EDITOR-STREAM-DEFER-REDISPLAY ;; If redisplay is deferred, don't do it, but arrange to do it later. ;; Say we did redisplay, to prevent direct output. (MUST-REDISPLAY *STREAM-SHEET* DIS-TEXT) T)((NOT (WINDOW-READY-P *STREAM-SHEET* NIL)) (SEND *STREAM-SHEET* :PREPARE-FOR-REDISPLAY) (MUST-REDISPLAY *STREAM-SHEET* DIS-TEXT) (OR *STREAM-DEFER-OUTPUT-NOT-AT-END*     (STREAM-REDISPLAY)) T)((> (WINDOW-REDISPLAY-DEGREE *STREAM-SHEET*) DIS-BPS) (OR *STREAM-DEFER-OUTPUT-NOT-AT-END*     (STREAM-REDISPLAY)) T)((AND (BP-= *STREAM-BP* (INTERVAL-LAST-BP (WINDOW-INTERVAL *STREAM-SHEET*)))      (NOT RUBOUT-HANDLER))  ;Always redisplay on typein ;; Turn off editor blinkers if faking redisplay (DOLIST (BL (WINDOW-SPECIAL-BLINKER-LIST *STREAM-SHEET*))   (W:BLINKER-SET-VISIBILITY (CDR BL) NIL)) NIL)(T (MUST-REDISPLAY *STREAM-SHEET* DIS-TEXT) (OR *STREAM-DEFER-OUTPUT-NOT-AT-END*     (STREAM-REDISPLAY)) T))) (DEFUN STREAM-REDISPLAY (&OPTIONAL FORCE-TO-COMPLETION &AUX (*TERMINAL-IO* *STREAM-SHEET*))  "Invoke editor redisplay while in an editor stream output operation, not inside the editor.Used by stream output operations that are not doing direct outputto the sheet, after they update the buffer."  (DECLARE (:SELF-FLAVOR EDITOR-STREAM-MIXIN))  (W:PROCESS-TYPEAHEAD W:IO-BUFFER #'(LAMBDA (CH) (COND ((ATOM CH)   CH)  ((EQ (CAR CH) 'REDISPLAY)   NIL)  (T   CH))))  (BIND (LOCF (W:SHEET-MORE-VPOS *STREAM-SHEET*)) NIL)  ;; If editor redisplay is required, do it.  ;; Otherwise, there may have been immediate output by the stream.  ;; If there is any, we update the editor's redisplay data here.  (IF (<= (WINDOW-REDISPLAY-DEGREE *STREAM-SHEET*) DIS-BPS)      (FAKE-OUT-TOP-LINE *STREAM-SHEET* (WINDOW-INTERVAL *STREAM-SHEET*)))  (FUNCALL EDITOR-CLOSURE 'REDISPLAY *STREAM-SHEET* :POINT NIL NIL FORCE-TO-COMPLETION)  (SEND *STREAM-BLINKER* :SET-FOLLOW-P T)  (W:BLINKER-SET-VISIBILITY *STREAM-BLINKER*     (IF (EQ *STREAM-SHEET* W:SELECTED-WINDOW) :BLINK :ON))) ;;; Editor hooks and editor commands for interfacing to the EDITOR-STREAM-MIXIN.;Make sure that STREAM-PRE-COMMAND-HOOK-1 is not called inside the minibuffer.(DEFUN STREAM-PRE-COMMAND-HOOK (CHAR)  (IF (NEQ *INTERVAL* (WINDOW-INTERVAL *MINI-BUFFER-WINDOW*))      (STREAM-PRE-COMMAND-HOOK-1 CHAR))) ;;; Command hook, throw out if character is to be passed through as an editing command(DEFUN STREAM-PRE-COMMAND-HOOK-1 (CHAR)  (COND ((OR (MEMBER CHAR *STREAM-EDITING-COMMAND* :TEST #'EQ)     (SI:ASSQ-CAREFUL CHAR *STREAM-EDITING-COMMAND*)) (SETQ *SRE-INPUT-END-BP* (COPY-BP (INTERVAL-LAST-BP *INTERVAL*))) (SETQ *SRE-INPUT-POINT* (COPY-BP *SRE-STREAM-BP*)) (MOVE-BP *SRE-STREAM-BP* (INTERVAL-LAST-BP *INTERVAL*)) (THROW 'RETURN-FROM-READ-ANY CHAR))((AND *STREAM-COMMAND-HANDLER*      (APPLY (CADR *STREAM-COMMAND-HANDLER*)     CHAR (CDDR *STREAM-COMMAND-HANDLER*))) (SEND *SRE-WINDOW* :SET-*STREAM-COMMAND-POINT* (COPY-BP *SRE-STREAM-BP* :NORMAL)) (MOVE-BP *SRE-STREAM-BP* *SRE-STREAM-START-BP*) (THROW 'W::RETURN-FROM-RUBOUT-HANDLER(VALUES  `(:COMMAND ,CHAR ,(OR *NUMERIC-ARG* 1))  :COMMAND)))((OR (MEMBER CHAR *STREAM-DO-NOT-ECHO* :TEST #'EQ)     (AND *STREAM-ACTIVATION-HANDLER*  (APPLY (CADR *STREAM-ACTIVATION-HANDLER*) CHAR (CDDR *STREAM-ACTIVATION-HANDLER*)))) (SETQ *SRE-ACTIVATION-CHARACTER* (IF (MEMBER CHAR *STREAM-DO-NOT-ECHO* :TEST #'EQ)      CHAR      `(:ACTIVATION ,CHAR ,(OR *NUMERIC-ARG* 1)))) (THROW 'RUBOUT-HANDLER T)))  ;; Tell label to change at redisplay after this command finishes,  ;; so that if this command activates, there will be no change.  (SEND *WINDOW* :ENTER-EDITOR)  ;; Tell the ibeam blinker to start blinking at next redisplay, also.  (SETQ *STREAM-IBEAM-SHOULD-BLINK* T)) ;I'm not really sure what value is right; this will prevent blowouts comparing priorities.(DEFPROP STREAM-PRE-COMMAND-HOOK 0 COMMAND-HOOK-PRIORITY) (DEFUN STREAM-COMMAND-HOOK (CHAR)  (IF (NEQ *INTERVAL* (WINDOW-INTERVAL *MINI-BUFFER-WINDOW*))    (STREAM-COMMAND-HOOK-1 CHAR))) ;;; Command hook.;;; If at the end of the buffer after the command, send through the buffered input.;;; *EDITOR-STREAM-ACTIVATION-NEEDED* means we were elsewhere than the end of the buffer;;;   once upon a time, and shouldnt activate until the user requests it.;;; *EDITOR-STREAM-REQUIRE-ACTIVATION* is the user-settable flag the enables this mode(DEFUN STREAM-COMMAND-HOOK-1 (CHAR)  (COND ((BP-= (POINT) (INTERVAL-LAST-BP *INTERVAL*)) (OR *EDITOR-STREAM-ACTIVATION-NEEDED*     (NOT (OR (GRAPHIC-CHAR-P CHAR) ;ISO support added by rpm on 11-25-86.      (MEMBER CHAR '(#\TAB #\NEWLINE) :TEST #'EQ)      (AND (ZEROP (CHAR-FONT CHAR))   (ZEROP (CHAR-BITS CHAR))   (MEMBER CHAR *STREAM-PASS-THROUGH* :TEST #'EQ))))     (EQ *LAST-COMMAND-TYPE* 'INDENT-NEW-LINE)     (COM-ACTIVATE)))  ;Automatically activate(*EDITOR-STREAM-REQUIRE-ACTIVATION* (SETQ *EDITOR-STREAM-ACTIVATION-NEEDED* T)))) ;I'm not really sure what value is right; this will prevent blowouts comparing priorities.(DEFPROP STREAM-COMMAND-HOOK 0 COMMAND-HOOK-PRIORITY) ;;; Special editor commands for editor streams.(DEFUN INITIALIZE-STREAM-COMTAB ()  (COND ((NOT (VARIABLE-BOUNDP *STREAM-COMTAB*)) (SETQ *STREAM-COMTAB* (SET-COMTAB NIL '(#\END COM-ACTIVATE #\CLEAR-INPUT COM-STREAM-CLEAR #\PAGE COM-RECENTER-TO-TOP #\c-c COM-YANK-INPUT-HISTORY #\m-c COM-YANK-POP #\c-m-Y COM-YANK-AND-ROTATE-INPUT-HISTORY #\c-\a COM-QUICK-ARGLIST-INTO-BUFFER #\TAB COM-INDENT-FOR-LISP #\RUBOUT COM-TAB-HACKING-RUBOUT #\C-RUBOUT COM-RUBOUT)   '(("Require Activation Mode" . COM-REQUIRE-ACTIVATION-MODE-1)))) (SET-COMTAB-INDIRECTION *STREAM-COMTAB* *STANDARD-COMTAB*)))) (ADD-INITIALIZATION "INITIALIZE-STREAM-COMTAB"    '(INITIALIZE-STREAM-COMTAB)    '(:NORMAL)    '*EDITOR-INITIALIZATION-LIST*) (DEFCOM COM-ACTIVATE "Begin execution of buffered input." ()  (COND ((WINDOW-MARK-P *WINDOW*)  ;If there is a region (WITH-BP (BP (INTERVAL-LAST-BP *INTERVAL*) ':NORMAL)   (INSERT-INTERVAL BP (POINT) (MARK))  ;copy it to the end   (DELETE-INTERVAL *EDITOR-STREAM-START-BP* BP T)) (AND (CHAR= (BP-CHAR-BEFORE (INTERVAL-LAST-BP *INTERVAL*)) #\NEWLINE)      (DELETE-INTERVAL (FORWARD-CHAR (INTERVAL-LAST-BP *INTERVAL*) -1)       (INTERVAL-LAST-BP *INTERVAL*)       T)) (SETF (WINDOW-MARK-P *WINDOW*) NIL) (MUST-REDISPLAY *WINDOW* DIS-TEXT)))  (MOVE-BP (POINT) (INTERVAL-LAST-BP *INTERVAL*))  (SETQ *EDITOR-STREAM-ACTIVATION-NEEDED* NIL)  ;So that mode line updated right  (MUST-REDISPLAY *WINDOW* DIS-BPS)  (SEND *WINDOW* :EXIT-EDITOR)  ;Prevent redisplay from updating label now  ;to say we are in the editor,  ;if it hasn't already.  (REDISPLAY *WINDOW* :NONE NIL NIL T)  ;Force completion so state is consistent  ;for direct output by the stream.  (REDISPLAY-MODE-LINE)  (LET ((IBEAM-BLINKER (CDR (ASSOC 'STREAM-BLINK-IBEAM   (WINDOW-SPECIAL-BLINKER-LIST *WINDOW*)   :TEST #'EQ))))    (W:BLINKER-SET-VISIBILITY IBEAM-BLINKER NIL))  (THROW 'EXIT-TOP-LEVEL T)) (DEFMINOR COM-REQUIRE-ACTIVATION-MODE-1 REQUIRE-ACTIVATION-MODE-1 "Require Activation" 1  "Require an End command to resume reading inputif you once move the cursor away from the end of the buffer." ()  (SETQ *EDITOR-STREAM-REQUIRE-ACTIVATION* T)) (DEFCOM COM-STREAM-CLEAR "Delete the form being typed in" ()  (CONTEXT-CHECK '*EDITOR-STREAM-START-BP*)  (SETQ *CURRENT-COMMAND-TYPE* 'KILL)  (LET ((POINT (POINT)))    (MOVE-BP POINT (INTERVAL-LAST-BP *INTERVAL*))    (KILL-INTERVAL *EDITOR-STREAM-START-BP* POINT T NIL))  DIS-TEXT) (DEFCOM COM-RECENTER-TO-TOP "Glitch screen to show start of form at top" ()  (CONTEXT-CHECK '*EDITOR-STREAM-START-BP*)  (RECENTER-WINDOW *WINDOW* :START *EDITOR-STREAM-START-BP*)  DIS-NONE) (DEFCOM COM-QUICK-ARGLIST-INTO-BUFFER "Insert arglist result into buffer" ()  (CONTEXT-CHECK '*EDITOR-STREAM-START-BP*)  (LET ((STRING (WITH-OUTPUT-TO-STRING (S) (QUICK-ARGLIST S)))(BP (SKIP-OVER-BLANK-LINES-AND-COMMENTS *EDITOR-STREAM-START-BP* T)))    (INSERT-MOVING BP *COMMENT-BEGIN*)    (INSERT-MOVING BP STRING)    (INSERT-MOVING BP #\NEWLINE))  DIS-TEXT) (DEFCOM COM-YANK-INPUT-HISTORY "Insert the previous input string." ()  (CONTEXT-CHECK *WINDOW* :OPERATION-HANDLED-P :*STREAM-INPUT-HISTORY*)  (HISTORY-YANK (SEND *WINDOW* :*STREAM-INPUT-HISTORY*)));;;  Another c-m-y yank-and-rotate hack, this one for the editor top level.(DEFCOM COM-YANK-AND-ROTATE-INPUT-HISTORY "Insert the previous input string, rotate if done more than once." ()  (CONTEXT-CHECK *WINDOW* :OPERATION-HANDLED-P :*STREAM-INPUT-HISTORY*)  (IF (TYPEP *LAST-COMMAND-TYPE* 'HISTORY)      (COM-YANK-POP)      (HISTORY-YANK (SEND *WINDOW* :*STREAM-INPUT-HISTORY*)))) ;;; Special ibeam blinker(DEFFLAVOR STREAM-IBEAM-BLINKER   (EDITOR-STREAM)   (W:IBEAM-BLINKER)  (:DEFAULT-INIT-PLIST :HALF-PERIOD 32)  (:INITABLE-INSTANCE-VARIABLES EDITOR-STREAM)) (DEFMETHOD (STREAM-IBEAM-BLINKER :COMPUTE-BLINKER-POSITION) (POINT)  (SEND EDITOR-STREAM :COMPUTE-BLINKER-POSITION POINT)) ;;; Blink the ibeam while we are in the editor.(DEFUN STREAM-BLINK-IBEAM (BLINKER WINDOW POINT IGNORE &AUX X Y)  WINDOW  (AND *STREAM-IBEAM-BLINKER-P*       (MULTIPLE-VALUE-SETQ (X Y) (SEND BLINKER :COMPUTE-BLINKER-POSITION POINT)))  (COND (X (W:BLINKER-SET-CURSORPOS BLINKER X Y) (W:BLINKER-SET-VISIBILITY BLINKER ':BLINK))(T (W:BLINKER-SET-VISIBILITY BLINKER NIL)))) ;Note: There is a different method for ZTOP streams.(DEFMETHOD (EDITOR-STREAM-MIXIN :COMPUTE-BLINKER-POSITION) (BP)  (AND (EQ (BP-TOP-LEVEL-NODE BP) (WINDOW-INTERVAL *STREAM-SHEET*))       *STREAM-IBEAM-SHOULD-BLINK*       (FIND-BP-IN-WINDOW-COORDS *STREAM-START-BP* *STREAM-SHEET*))) ;;;The actual editor top level, a lisp listener in an editor window;;Make the default deexposed-typeout-action :permit, just like a listener.;;Use W:delay-notification-mixin instead of W:notification-mixin because;;the current way can lead to confusion if the start of the input is;;at a point that has since scrolled off the screen.  This decision may;;not be the best one, but I feel it is better than the current way.;;Modified by rpm (from pf) on 7-7-86.(DEFFLAVOR EDITOR-TOP-LEVEL   ()   (W:LISTENER-MIXIN    W:NOTIFICATION-MIXIN;    W:DELAY-NOTIFICATION-MIXIN  -- not just now.    EDITOR-STREAM-WINDOW)  (:DEFAULT-INIT-PLIST :DEEXPOSED-TYPEOUT-ACTION :PERMIT));;;Don't save undo information, it conses too much.;;;Method added 7-7-86 by rpm (from pf).(DEFMETHOD (EDITOR-TOP-LEVEL :AFTER :INIT) (IGNORE)  (SETF (NODE-UNDO-STATUS INTERVAL) :DONT));;;For better finger information.  See chaos:user-activity-string.;;;Other possibilities are "Editor Top Level" (too long), "ZDT" (I don't like it),;;;and "Editing Lisp" (ambiguous). Method added on 7-7-86 by rpm (from pf).(DEFMETHOD (EDITOR-TOP-LEVEL :USER-ACTIVITY-STRING) ()  "Lisp (Edit)")(DEFUN ZDT (&OPTIONAL (ON-P (NOT (TYPEP *TERMINAL-IO* 'EDITOR-TOP-LEVEL))))  "Enter or leave editor top level.  ON-P is T to enter, NIL to leave."  (COND (ON-P (INITIALIZE-STREAM-COMTAB) (OR (VARIABLE-BOUNDP *ZDT-WINDOW*)     (SETQ *ZDT-WINDOW* (W:MAKE-WINDOW 'EDITOR-TOP-LEVEL))) (SEND *ZDT-WINDOW* :SELECT T))(T (SEND *ZDT-WINDOW* :DESELECT T)))) ;;; Additional standard stream operations that editor streams support.(DEFMETHOD (EDITOR-STREAM-MIXIN :FRESH-LINE) ()  (IF (ZEROP (BP-INDEX *STREAM-BP*))      NIL      (PROGN(SEND SELF :WRITE-CHAR #\NEWLINE)T))) (DEFMETHOD (EDITOR-STREAM-MIXIN :UNWRITE-CHAR-MARK) ()  (SEND SELF :READ-BP)) (DEFMETHOD (EDITOR-STREAM-MIXIN :READ-BP) ()  (COPY-BP *STREAM-BP*)) (DEFMETHOD (EDITOR-STREAM-MIXIN :UNREAD-CHAR) (-MARK-)  (LET ((*WINDOW* *STREAM-SHEET*))    (DELETE-INTERVAL -MARK- *STREAM-BP* T))  (MUST-REDISPLAY *STREAM-SHEET* DIS-TEXT)  (STREAM-REDISPLAY)) (DEFMETHOD (EDITOR-STREAM-MIXIN :SET-BP) (BP)  (MOVE-BP *STREAM-BP* BP)  (MUST-REDISPLAY *STREAM-SHEET* DIS-BPS)  (STREAM-REDISPLAY)) (DEFMETHOD (EDITOR-STREAM-MIXIN :DELETE-TEXT) ()  (LET ((*WINDOW* *STREAM-SHEET*))    (DELETE-INTERVAL *INTERVAL*))  (MUST-REDISPLAY *STREAM-SHEET* DIS-TEXT)  (STREAM-REDISPLAY)) (DEFMETHOD (EDITOR-STREAM-MIXIN :DELETE-INTERVAL) (FROM-BP &OPTIONAL TO-BP IN-ORDER-P)  (LET ((*WINDOW* *STREAM-SHEET*))    (DELETE-INTERVAL FROM-BP TO-BP IN-ORDER-P))  (MUST-REDISPLAY *STREAM-SHEET* DIS-TEXT)  (STREAM-REDISPLAY)) (DEFMETHOD (EDITOR-STREAM-MIXIN :TEXT-DELETED) ()  (MUST-REDISPLAY *STREAM-SHEET* DIS-TEXT)  (STREAM-REDISPLAY)) ;;; Clear the screen by scrolling everything off of it(DEFMETHOD (EDITOR-STREAM-MIXIN :CLEAR-SCREEN) ()  (RECENTER-WINDOW *STREAM-SHEET* :RELATIVE (- (WINDOW-N-PLINES *STREAM-SHEET*) 1))  (STREAM-REDISPLAY)) (DEFMETHOD (EDITOR-STREAM-MIXIN :READ-CURSORPOS) (&OPTIONAL (UNITS ':PIXEL))  (STREAM-REDISPLAY)    ;Get window data structure up to date for any immediate output.  (MULTIPLE-VALUE-BIND (X Y)      (FIND-BP-IN-WINDOW-COORDS *STREAM-BP* *STREAM-SHEET*)    (CASE UNITS  (:PIXEL)  (:CHARACTER   (IF (AND X Y)       (SETQ X (TRUNCATE X (W:SHEET-CHAR-WIDTH (WINDOW-SHEET *STREAM-SHEET*)))     Y (TRUNCATE Y (W:SHEET-LINE-HEIGHT (WINDOW-SHEET *STREAM-SHEET*))))       (SETQ X (BP-INDEX *STREAM-BP*)     Y 0)))  (OTHERWISE   (FERROR NIL "~S is not a known unit." UNITS)))    (VALUES X Y))) (DEFMETHOD (EDITOR-STREAM-MIXIN :SET-CURSORPOS) (X Y &OPTIONAL (UNITS ':PIXEL))  (CASE UNITS(:PIXEL)(:CHARACTER (AND X (SETQ X (* X (W:SHEET-CHAR-WIDTH (WINDOW-SHEET *STREAM-SHEET*))))) (AND Y (SETQ Y (* Y (W:SHEET-LINE-HEIGHT (WINDOW-SHEET *STREAM-SHEET*))))))(OTHERWISE (FERROR NIL "~S is not a known unit." UNITS)))  (STREAM-REDISPLAY)  (MOVE-BP *STREAM-BP* (BP-FROM-COORDS *STREAM-SHEET* X Y))  (MUST-REDISPLAY *STREAM-SHEET* DIS-TEXT)  (STREAM-REDISPLAY)) (DEFMETHOD (EDITOR-STREAM-MIXIN :INCREMENT-CURSORPOS) (DX DY &OPTIONAL (UNITS ':PIXEL))  (CASE UNITS(:PIXEL)(:CHARACTER (AND DX (SETQ DX (* DX (W:SHEET-CHAR-WIDTH (WINDOW-SHEET *STREAM-SHEET*))))) (AND DY (SETQ DY (* DY (W:SHEET-LINE-HEIGHT (WINDOW-SHEET *STREAM-SHEET*))))))(OTHERWISE (FERROR NIL "~S is not a known unit." UNITS)))  (LET ((STARTING-INDENTATION (FIND-BP-IN-WINDOW-COORDS *STREAM-BP* *STREAM-SHEET*))(*WINDOW* *STREAM-SHEET*))    (WHEN (AND DY (NOT (ZEROP DY)))      (SETQ STARTING-INDENTATION 0)      (INSERT-CHARS *STREAM-BP* #\NEWLINE    (TRUNCATE DY (W:SHEET-LINE-HEIGHT *STREAM-SHEET*))))    (INDENT-TO *STREAM-BP* (+ STARTING-INDENTATION (OR DX 0)))    (STREAM-IMMEDIATE-OUTPUT      (W:PREPARE-SHEET (*STREAM-SHEET*) (W:SHEET-INCREMENT-BITPOS *STREAM-SHEET* DX DY))))) (DEFUN BP-FROM-COORDS (WINDOW X Y &AUX SHEET LINE PLINE CHAR-POS LH REAL-PLINE START END)  (SETQ SHEET (WINDOW-SHEET WINDOW))  (SETQ LH (W:SHEET-LINE-HEIGHT SHEET)PLINE (SETQ REAL-PLINE (TRUNCATE Y LH)))  (COND ((MINUSP PLINE) (SETQ PLINE 0))((>= PLINE (WINDOW-N-PLINES WINDOW)) (SETQ PLINE (WINDOW-N-PLINES WINDOW))))  (DO ()      ((OR (NULL (PLINE-LINE WINDOW PLINE))   (ZEROP (PLINE-FROM-INDEX WINDOW PLINE))))    (AND (ZEROP PLINE) (RETURN))    (SETQ PLINE (1- PLINE)))  ;; If there is no line there, extend the buffer until there is one  (OR (SETQ LINE (PLINE-LINE WINDOW PLINE))      (DO ((I 0 (1+ I))   (P PLINE (1- P)))  ((PLINE-LINE WINDOW P)   (LET ((LAST-BP (INTERVAL-LAST-BP *INTERVAL*)))     (DOTIMES (J I)       (INSERT LAST-BP #\NEWLINE))     (SETQ LINE (BP-LINE LAST-BP))))))  (SETQ START (PLINE-FROM-INDEX WINDOW PLINE))  (LET ((BP (INTERVAL-FIRST-BP (WINDOW-INTERVAL WINDOW))))    (AND (EQ LINE (BP-LINE BP)) (SETQ START (MIN START (BP-INDEX BP)))))  (LET ((BP (INTERVAL-LAST-BP (WINDOW-INTERVAL WINDOW))))    (AND (EQ LINE (BP-LINE BP)) (SETQ END (BP-INDEX BP))))  (MULTIPLE-VALUE-SETQ (NIL NIL CHAR-POS)  ;Find character to right    (W:SHEET-COMPUTE-MOTION SHEET 0 (* PLINE LH) LINE     START END NIL     (MAX 0 X) (* REAL-PLINE LH)))  ;; If there is no such index, extend the line  (IF CHAR-POS      (CREATE-BP LINE CHAR-POS)      (INDENT-TO (CREATE-BP LINE (LINE-LENGTH LINE)) X SHEET))) (DEFMETHOD (EDITOR-STREAM-MIXIN :HOME-CURSOR) ()  (SEND SELF :SET-CURSORPOS 0 0)) (DEFMETHOD (EDITOR-STREAM-MIXIN :CLEAR-EOL) ()  (LET ((*WINDOW* *STREAM-SHEET*)(*INTERVAL* (WINDOW-INTERVAL *STREAM-SHEET*)))    (DELETE-INTERVAL *STREAM-BP* (END-LINE *STREAM-BP* 0 T) T))  (MUST-REDISPLAY *STREAM-SHEET* DIS-TEXT)  (STREAM-REDISPLAY)) (DEFMETHOD (EDITOR-STREAM-MIXIN :CLEAR-EOF) ()  (LET ((*WINDOW* *STREAM-SHEET*)(*INTERVAL* (WINDOW-INTERVAL *STREAM-SHEET*)))    (DELETE-INTERVAL *STREAM-BP* (INTERVAL-LAST-BP *INTERVAL*) T))  (MUST-REDISPLAY *STREAM-SHEET* DIS-TEXT)  (STREAM-REDISPLAY)) (DEFMETHOD (EDITOR-STREAM-MIXIN :CLEAR-CHAR) ()  (LET ((LINE (BP-LINE *STREAM-BP*))(IDX (BP-INDEX *STREAM-BP*)))    (SETF (AREF LINE IDX) #\SPACE)    (MUNG-LINE LINE))  (MUST-REDISPLAY *STREAM-SHEET* DIS-TEXT)  (STREAM-REDISPLAY));;;Need this method so password-asking won't end up with all the XXXs hanging;;;around in the buffer. Method added on 7-7-86 by rpm (from pf).(DEFMETHOD (EDITOR-STREAM-MIXIN :CLEAR-BETWEEN-CURSORPOSES) (START-X START-Y END-X END-Y)  (STREAM-REDISPLAY)  (LET ((FROM-BP (BP-FROM-COORDS *STREAM-SHEET* START-X START-Y))(TO-BP (BP-FROM-COORDS *STREAM-SHEET* END-XEND-Y))(*WINDOW* *STREAM-SHEET*)(*INTERVAL* (WINDOW-INTERVAL *STREAM-SHEET*)))    (DELETE-INTERVAL FROM-BP TO-BP))  (MUST-REDISPLAY *STREAM-SHEET* DIS-TEXT)  (STREAM-REDISPLAY))(DEFMETHOD (EDITOR-STREAM-MIXIN :INSERT-LINE) (&OPTIONAL (NLINES 1))  (LET ((*WINDOW* *STREAM-SHEET*))    (DOTIMES (I NLINES)      (INSERT *STREAM-BP* #\NEWLINE)))  (MUST-REDISPLAY *STREAM-SHEET* DIS-TEXT)  (STREAM-REDISPLAY)) (DEFMETHOD (EDITOR-STREAM-MIXIN :DELETE-LINE) (&OPTIONAL (NLINES 1))  (LET ((*WINDOW* *STREAM-SHEET*))    (DELETE-INTERVAL *STREAM-BP* (FORWARD-LINE *STREAM-BP* NLINES T) T))  (MUST-REDISPLAY *STREAM-SHEET* DIS-TEXT)  (STREAM-REDISPLAY)) (DEFMETHOD (EDITOR-STREAM-MIXIN :INSERT-CHAR) (&OPTIONAL (NCHARS 1))  (LET ((*WINDOW* *STREAM-SHEET*))    (DOTIMES (I NCHARS)      (INSERT *STREAM-BP* #\SPACE)))  (MUST-REDISPLAY *STREAM-SHEET* DIS-TEXT)  (STREAM-REDISPLAY)) (DEFMETHOD (EDITOR-STREAM-MIXIN :DELETE-CHAR) (&OPTIONAL (NCHARS 1))  (LET ((*WINDOW* *STREAM-SHEET*))    (DELETE-INTERVAL *STREAM-BP* (FORWARD-CHAR *STREAM-BP* NCHARS T) T))  (MUST-REDISPLAY *STREAM-SHEET* DIS-TEXT)  (STREAM-REDISPLAY)) ;;; Editors always insert, this should be close, therefore.(DEFMETHOD (EDITOR-STREAM-MIXIN :INSERT-STRING) (STRING &OPTIONAL (START 0) END)  (SEND SELF :STRING-OUT STRING START END)) (DEFFLAVOR EDITOR-STREAM-WITHOUT-WINDOW-MIXIN   ()   ()  (:REQUIRED-FLAVORS EDITOR-STREAM-MIXIN)  (:DOCUMENTATION :MIXIN "Mix this into kinds of EDITOR-STREAM-MIXINsthat are not also windows.")) (DEFMETHOD (EDITOR-STREAM-WITHOUT-WINDOW-MIXIN :READ-CHAR) (&REST ARGS)  (LOOP (LET ((CHAR (LEXPR-SEND SELF :READ-ANY ARGS)))  (UNLESS (CONSP CHAR)    (RETURN CHAR)))))(DEFMETHOD (EDITOR-STREAM-WITHOUT-WINDOW-MIXIN :TYI) (&REST ARGS)  (LOOP (LET ((CHAR (LEXPR-SEND SELF :ANY-TYI ARGS)))  (UNLESS (CONSP CHAR)    (RETURN CHAR)))))(DEFMETHOD (EDITOR-STREAM-WITHOUT-WINDOW-MIXIN :HOME-DOWN)   EDITOR-STREAM-WITHOUT-WINDOW-MIXIN-PASS-ON-MESSAGE-TO-WINDOW) (DEFMETHOD (EDITOR-STREAM-WITHOUT-WINDOW-MIXIN :SIZE)   EDITOR-STREAM-WITHOUT-WINDOW-MIXIN-PASS-ON-MESSAGE-TO-WINDOW) (DEFMETHOD (EDITOR-STREAM-WITHOUT-WINDOW-MIXIN :INSIDE-SIZE)   EDITOR-STREAM-WITHOUT-WINDOW-MIXIN-PASS-ON-MESSAGE-TO-WINDOW) (DEFMETHOD (EDITOR-STREAM-WITHOUT-WINDOW-MIXIN :REFRESH)   EDITOR-STREAM-WITHOUT-WINDOW-MIXIN-PASS-ON-MESSAGE-TO-WINDOW) (DEFMETHOD (EDITOR-STREAM-WITHOUT-WINDOW-MIXIN :PREPARE-FOR-REDISPLAY)   EDITOR-STREAM-WITHOUT-WINDOW-MIXIN-PASS-ON-MESSAGE-TO-WINDOW) (DEFMETHOD (EDITOR-STREAM-WITHOUT-WINDOW-MIXIN :TYPEOUT-WINDOW)   EDITOR-STREAM-WITHOUT-WINDOW-MIXIN-PASS-ON-MESSAGE-TO-WINDOW) (DEFMETHOD (EDITOR-STREAM-WITHOUT-WINDOW-MIXIN :MODE-LINE-WINDOW)   EDITOR-STREAM-WITHOUT-WINDOW-MIXIN-PASS-ON-MESSAGE-TO-WINDOW) (DEFMETHOD (EDITOR-STREAM-WITHOUT-WINDOW-MIXIN :PUT-POINT-AT-PLINE)   EDITOR-STREAM-WITHOUT-WINDOW-MIXIN-PASS-ON-MESSAGE-TO-WINDOW) (DEFMETHOD (EDITOR-STREAM-WITHOUT-WINDOW-MIXIN :NEW-SCROLL-POSITION)   EDITOR-STREAM-WITHOUT-WINDOW-MIXIN-PASS-ON-MESSAGE-TO-WINDOW) (DEFMETHOD (EDITOR-STREAM-WITHOUT-WINDOW-MIXIN :REDISPLAY)   EDITOR-STREAM-WITHOUT-WINDOW-MIXIN-PASS-ON-MESSAGE-TO-WINDOW) (DEFMETHOD (EDITOR-STREAM-WITHOUT-WINDOW-MIXIN :BEEP)   EDITOR-STREAM-WITHOUT-WINDOW-MIXIN-PASS-ON-MESSAGE-TO-WINDOW) (DEFMETHOD (EDITOR-STREAM-WITHOUT-WINDOW-MIXIN :CLEAR-INPUT)   EDITOR-STREAM-WITHOUT-WINDOW-MIXIN-PASS-ON-MESSAGE-TO-WINDOW) (DEFMETHOD (EDITOR-STREAM-WITHOUT-WINDOW-MIXIN :SIZE-IN-CHARACTERS)   EDITOR-STREAM-WITHOUT-WINDOW-MIXIN-PASS-ON-MESSAGE-TO-WINDOW) (DEFMETHOD (EDITOR-STREAM-WITHOUT-WINDOW-MIXIN :COMPUTE-MOTION)   EDITOR-STREAM-WITHOUT-WINDOW-MIXIN-PASS-ON-MESSAGE-TO-WINDOW) (DEFMETHOD (EDITOR-STREAM-WITHOUT-WINDOW-MIXIN :STRING-LENGTH)   EDITOR-STREAM-WITHOUT-WINDOW-MIXIN-PASS-ON-MESSAGE-TO-WINDOW) (DEFMETHOD (EDITOR-STREAM-WITHOUT-WINDOW-MIXIN :CHARACTER-WIDTH)   EDITOR-STREAM-WITHOUT-WINDOW-MIXIN-PASS-ON-MESSAGE-TO-WINDOW) (DEFMETHOD (EDITOR-STREAM-WITHOUT-WINDOW-MIXIN :FORCE-KBD-INPUT)   EDITOR-STREAM-WITHOUT-WINDOW-MIXIN-PASS-ON-MESSAGE-TO-WINDOW) (DEFMETHOD (EDITOR-STREAM-WITHOUT-WINDOW-MIXIN :HANDLE-EXCEPTIONS)   EDITOR-STREAM-WITHOUT-WINDOW-MIXIN-PASS-ON-MESSAGE-TO-WINDOW) (DEFMETHOD (EDITOR-STREAM-WITHOUT-WINDOW-MIXIN :NOTICE)  ;for :INPUT-WAIT   EDITOR-STREAM-WITHOUT-WINDOW-MIXIN-PASS-ON-MESSAGE-TO-WINDOW) (DEFUN EDITOR-STREAM-WITHOUT-WINDOW-MIXIN-PASS-ON-MESSAGE-TO-WINDOW (&REST REST)  (DECLARE (:SELF-FLAVOR EDITOR-STREAM-WITHOUT-WINDOW-MIXIN))  (APPLY *STREAM-SHEET* REST)) (DEFMETHOD (EDITOR-STREAM-WITHOUT-WINDOW-MIXIN :BEFORE :INIT) (IGNORE)  (SETQ W:IO-BUFFER (SEND *STREAM-SHEET* :IO-BUFFER))) ;;; Streams that type into a specified window.;;; This is so that, given any ZWEI window at all, you can create;;; an editor stream which will use that window.(DEFFLAVOR EDITOR-STREAM-FROM-WINDOW   ()   (EDITOR-STREAM-WITHOUT-WINDOW-MIXIN    EDITOR-STREAM-MIXIN    TOP-LEVEL-DISPLAYER-MIXIN    DISPLAYER)) ;Given a ZWEI-WINDOW structure, return an editor stream that uses it.(DEFUN MAKE-EDITOR-STREAM-FROM-WINDOW (WINDOW)  (OR (DOLIST (STREAM *STREAMS-FROM-WINDOWS*)(AND (EQ WINDOW (SEND STREAM :*STREAM-SHEET*))     (RETURN STREAM)))      (LET ((INIT-PLIST (LIST :*STREAM-SHEET* WINDOW)))(LET ((STREAM (INSTANTIATE-FLAVOR 'EDITOR-STREAM-FROM-WINDOW  (LOCF INIT-PLIST)  T NIL W:SHEET-AREA)))  (PUSH STREAM *STREAMS-FROM-WINDOWS*)  STREAM)))) ;;; Editor top level major mode for ZMACS.;;; ZTOP streams differ from ordinary EDITOR-STREAM-MIXINs in that;;; they work with ZMACS-WINDOWS (and are based on EDITOR-STREAM-FROM-WINDOW);;; and the stream is used in a separate stack group while ZMACS runs in;;; its normal stack group.  This causes the way of getting into and out of;;; the rubout processor to be different.;;; The evaluation stack group has a special binding of PRIN1;;; to put semicolons before output.;;; Something suitable for binding PRIN1 to(DEFUN ZTOP-EVALUATION-PRIN1 (EXP &OPTIONAL (*ZTOP-EVALUATION-PRIN1-STREAM* *STANDARD-OUTPUT*))  (AND *ZTOP-COMMENT-EVALUATION-RESULT-P*       (SEND *ZTOP-EVALUATION-PRIN1-STREAM* :STRING-OUT *ZTOP-COMMENT-EVALUATION-RESULT-P*))  (IF *ZTOP-GRIND-EVALUATION-RESULT-P*      (GRIND-TOP-LEVEL EXP 132 'ZTOP-EVALUATION-PRIN1-IO NIL 'DISPLACED NIL)      (PRIN1 EXP 'ZTOP-EVALUATION-PRIN1-IO))) (DEFUN ZTOP-EVALUATION-PRIN1-IO (OP &REST REST)  (PROG1    (APPLY *ZTOP-EVALUATION-PRIN1-STREAM* OP REST)    (OR (AND (EQ OP :WRITE-CHAR)     (CHAR= (CAR REST) #\NEWLINE)     *ZTOP-COMMENT-EVALUATION-RESULT-P*     (SEND *ZTOP-EVALUATION-PRIN1-STREAM* :STRING-OUT *ZTOP-COMMENT-EVALUATION-RESULT-P*))(AND (EQ OP :TYO)     (= (CAR REST) (CHAR-INT #\NEWLINE))     *ZTOP-COMMENT-EVALUATION-RESULT-P*     (SEND *ZTOP-EVALUATION-PRIN1-STREAM* :STRING-OUT *ZTOP-COMMENT-EVALUATION-RESULT-P*))))) (DEFPROP *ZTOP-REQUIRE-ACTIVATION* T MODE-SETTABLE-P) (DEFMAJOR COM-ZTOP-MODE ZTOP-MODE "ZTOP" "Sets things up for zmacs buffer editor top level." ()  (COMMAND-HOOK (MAKE-ZTOP-COMMAND-HOOK *INTERVAL* *WINDOW*) *POST-COMMAND-HOOK*)  (COMMAND-HOOK (MAKE-ZTOP-PRE-COMMAND-HOOK *INTERVAL* *WINDOW*) *COMMAND-HOOK*)  (SETQ *SPACE-INDENT-FLAG* T)  (SETQ *PARAGRAPH-DELIMITER-LIST* NIL)  (SETQ *COMMENT-START* 'LISP-FIND-COMMENT-START-AND-END)  (SET-COMTAB *MODE-COMTAB*      '(#\END COM-FINISH-ZTOP-EVALUATION#\c-NEWLINE COM-FINISH-ZTOP-EVALUATION#\ABORT COM-ZTOP-ABORT#\m-ABORT COM-ZTOP-ABORT-ALL#\c-m-Y COM-ZTOP-YANK-AND-ROTATE-INPUT-HISTORY#\c-C COM-ZTOP-YANK-INPUT-HISTORY#\m-c COM-YANK-POP;Make M-C rotate what C-C yanks.#\CLEAR-SCREEN COM-RECENTER-WINDOW#\TAB COM-INDENT-FOR-LISP#\RUBOUT COM-TAB-HACKING-RUBOUT#\c-RUBOUT COM-RUBOUT)      '(("Require Activation Mode" . COM-REQUIRE-ACTIVATION-MODE)))  (SETQ *MODE-LINE-LIST* (APPEND *MODE-LINE-LIST* '((*ZTOP-ACTIVATION-NEEDED* "  Type End to resume reading input")   (*ZTOP-READING-INPUT* "  Reading input")   (*ZTOP-EDITING* "  Editing"))))  (PROGN (AND (TYPEP *INTERVAL* 'FILE-BUFFER)      (SETQ *LAST-ZTOP-BUFFER* *INTERVAL*)))) (DEFPROP ZTOP-MODE :LISP EDITING-TYPE) ;Create a buffer and put it in ZTOP mode. (DEFUN MAKE-ZTOP-BUFFER (&OPTIONAL (NAME "ZTOP") &AUX BUFFER)  (SETQ BUFFER (CREATE-ONE-BUFFER-TO-GO NAME))  (SETF (BUFFER-SAVED-MAJOR-MODE BUFFER) 'ZTOP-MODE)  BUFFER) ;Make a ztop stream and a command hook for a specified ZMACS buffer.;If we already made them for this buffer, reuse them.;The command hook used for ZTOP is a gensym;whose function definition is closure of an explicit lambda in this function.(DEFUN MAKE-ZTOP-COMMAND-HOOK (BUFFER WINDOW &AUX ZTOP-STREAM HOOK-CLOSURE HOOK)  (SETQ *CURRENT-COMMAND-TYPE* 'ZTOP-MODE)  (COND ((SETQ HOOK (ASSOC BUFFER *ZTOP-COMMAND-HOOK-ALIST* :TEST #'EQ)) (SETQ HOOK (CDR HOOK)       HOOK-CLOSURE (SYMBOL-FUNCTION HOOK)       ZTOP-STREAM (SYMEVAL-IN-CLOSURE HOOK-CLOSURE '*ZTOP-STREAM*)) (SEND ZTOP-STREAM :SET-STREAM-WINDOW WINDOW))(T (SETQ ZTOP-STREAM       (LET ((INIT-PLIST (LIST :*STREAM-SHEET* WINDOW       :*ZMACS-SG* SYSTEM:%CURRENT-STACK-GROUP       :BUFFER BUFFER))) (INSTANTIATE-FLAVOR 'ZTOP-STREAM-FROM-WINDOW (LOCF INIT-PLIST)     T NIL W:SHEET-AREA))) (SEND BUFFER :PUTPROP ZTOP-STREAM 'ZTOP-STREAM) (SETQ HOOK-CLOSURE (LET-CLOSED ((*ZTOP-INTERVAL* BUFFER) (*ZTOP-STREAM* ZTOP-STREAM))      #'(LAMBDA (IGNORE)  (AND (EQ *INTERVAL* *ZTOP-INTERVAL*)       (SEND *ZTOP-STREAM* :COMMAND-HOOK *CURRENT-COMMAND-TYPE*))))       HOOK (GENSYM)) (FDEFINE HOOK HOOK-CLOSURE T NIL) (SETF (GET HOOK 'COMMAND-HOOK-PRIORITY) 1000) (PUSH (CONS BUFFER HOOK) *ZTOP-COMMAND-HOOK-ALIST*) (SETQ *ZTOP-EDITING* NIL       *ZTOP-READING-INPUT* T       *ZTOP-ACTIVATION-NEEDED* NIL)))  HOOK) ;; We assume that MAKE-ZTOP-COMMAND-HOOK has already been called;; on the same window and buffer.(DEFUN MAKE-ZTOP-PRE-COMMAND-HOOK (BUFFER WINDOW &AUX ZTOP-STREAM HOOK-CLOSURE HOOK)  WINDOW  (SETQ *CURRENT-COMMAND-TYPE* 'ZTOP-MODE)  (UNLESS (SETQ HOOK (CDR (ASSOC BUFFER *ZTOP-PRE-COMMAND-HOOK-ALIST* :TEST #'EQ)))    (SETQ ZTOP-STREAM (GET BUFFER 'ZTOP-STREAM))    (SETQ HOOK-CLOSURE (LET-CLOSED ((*ZTOP-INTERVAL* BUFFER)    (*ZTOP-STREAM* ZTOP-STREAM)) #'(LAMBDA (CHAR)     (AND (EQ *INTERVAL* *ZTOP-INTERVAL*)  (SEND *ZTOP-STREAM* :PRE-COMMAND-HOOK CHAR))))  HOOK (GENSYM))    (FDEFINE HOOK HOOK-CLOSURE T NIL)    (SETF (GET HOOK 'COMMAND-HOOK-PRIORITY) 1000)    (PUSH (CONS BUFFER HOOK) *ZTOP-PRE-COMMAND-HOOK-ALIST*))  HOOK) ;;; Special commands used while in ZTOP mode.(DEFMINOR COM-REQUIRE-ACTIVATION-MODE REQUIRE-ACTIVATION-MODE "Require Activation" 1  "Require an End command in ZTOP to resume reading inputif you once move the cursor away from the end of the buffer." ()  (SETQ *ZTOP-REQUIRE-ACTIVATION* T)) ;;; This is like the DO-IT command in HENRY's ZTOP(DEFCOM COM-FINISH-ZTOP-EVALUATION "Begin execution of buffered input." ()  (LET ((ZTOP-BUFFER *INTERVAL*)ZTOP-STREAMSTREAM-START-BP)    (OR (SETQ ZTOP-STREAM (SEND *INTERVAL* :GET 'ZTOP-STREAM))(SETQ ZTOP-BUFFER (OR *LAST-ZTOP-BUFFER* (MAKE-ZTOP-BUFFER))      ZTOP-STREAM (SEND ZTOP-BUFFER :GET 'ZTOP-STREAM)))    (SETQ STREAM-START-BP (SEND ZTOP-STREAM :*STREAM-START-BP*))    (COND ((WINDOW-MARK-P *WINDOW*)  ;If there is a region   (SETF (WINDOW-MARK-P *WINDOW*) NIL)   (WITH-BP (BP (INTERVAL-LAST-BP ZTOP-BUFFER) ':NORMAL)     (INSERT-INTERVAL BP (POINT) (MARK))  ;copy it to the end     (DELETE-INTERVAL STREAM-START-BP BP T))   (COND ((NEQ *INTERVAL* ZTOP-BUFFER)  (SEND ZTOP-BUFFER :SET-ATTRIBUTE :PACKAGE *PACKAGE*)  (SETF (BUFFER-PACKAGE ZTOP-BUFFER) *PACKAGE*)  (SEND ZTOP-STREAM :SET-PACKAGE *PACKAGE*)  (DO-IT-SELECT-WINDOW-BUFFER ZTOP-BUFFER))))  ((NEQ *INTERVAL* ZTOP-BUFFER)   (BARF "There is no region"))))  (LET ((LAST-BP (INTERVAL-LAST-BP *INTERVAL*)))    (LET ((CH (BP-CHAR-BEFORE LAST-BP)))      (COND ((CHAR= CH #\NEWLINE)     (DELETE-INTERVAL (FORWARD-CHAR LAST-BP -1) LAST-BP T))    ((= (LIST-SYNTAX CH) LIST-ALPHABETIC)     (INSERT LAST-BP #\SPACE))))    (MOVE-BP (POINT) LAST-BP))  (SETQ *CURRENT-COMMAND-TYPE* 'ACTIVATE-ZTOP)  DIS-TEXT) ;;; Henry's more winning remote-evaluation ztop buffer selector (slightly modified)(DEFUN DO-IT-SELECT-WINDOW-BUFFER (BUFFER)  ;; If there's a window with this buffer in it, switch to that window.  ;; otherwise, switch to the buffer in the current window.  (DO ((REST-WINDOWS (FRAME-EXPOSED-WINDOWS) (CDR REST-WINDOWS))       (WINDOW))      ((COND ((NULL REST-WINDOWS)      (MAKE-BUFFER-CURRENT BUFFER)      T)     ((EQ (WINDOW-INTERVAL (SETQ WINDOW (CAR REST-WINDOWS))) BUFFER)      (MAKE-WINDOW-CURRENT WINDOW)      T))))) (DEFCOM COM-SELECT-LAST-ZTOP-BUFFER "Move to the most recently used ZTOP mode buffer." ()  (MAKE-BUFFER-CURRENT (OR *LAST-ZTOP-BUFFER* (MAKE-ZTOP-BUFFER)))  DIS-TEXT) (DEFCOM COM-ZTOP-ABORT "Abort program that is running in the Ztop buffer." ()  (SEND (SEND *INTERVAL* :GET 'ZTOP-STREAM) :ZTOP-ABORT)  DIS-TEXT) (DEFCOM COM-ZTOP-ABORT-ALL "Abort the running program all the way to top level." ()  (SEND (SEND *INTERVAL* :GET 'ZTOP-STREAM) :ZTOP-ABORT-ALL)  DIS-TEXT)(DEFCOM COM-ZTOP-YANK-INPUT-HISTORY "Yank the previous input." ()  (HISTORY-YANK (SEND (GET *INTERVAL* 'ZTOP-STREAM) :*STREAM-INPUT-HISTORY*)));;;  A hack so c-m-y will both yank and rotate.(DEFCOM COM-ZTOP-YANK-AND-ROTATE-INPUT-HISTORY "Yank the previous input, rotate if done more than once." ()  (IF (TYPEP *LAST-COMMAND-TYPE* 'HISTORY)      (COM-YANK-POP)      (HISTORY-YANK (SEND (GET *INTERVAL* 'ZTOP-STREAM) :*STREAM-INPUT-HISTORY*))))  ;;; Define the flavors for the actual streams used by ZTOP.(DEFFLAVOR ZTOP-STREAM-FROM-WINDOW   ()   (ZTOP-STREAM-MIXIN EDITOR-STREAM-FROM-WINDOW));;; Method added by rpm on 7-8-86 (from phd).(DEFMETHOD (ZWEI::ZTOP-STREAM-FROM-WINDOW :CLEAR-INPUT) (&REST IGNORE)  NIL) (DEFFLAVOR ZTOP-STREAM-MIXIN   (*ZMACS-SG*    *ZTOP-SG*    *STREAM-START-BP*    (*STREAM-ACTIVATION-NEEDED* NIL)    (*RUBOUT-HANDLER-ARGS* NIL)    (*RUBOUT-HANDLER-STATE* ':NORMAL))   ()  (:REQUIRED-FLAVORS EDITOR-STREAM-FROM-WINDOW)  (:INIT-KEYWORDS :BUFFER)  (:INITABLE-INSTANCE-VARIABLES *ZMACS-SG*)  (:GETTABLE-INSTANCE-VARIABLES *STREAM-START-BP*)) (DEFMETHOD (ZTOP-STREAM-MIXIN :AFTER :INIT) (INIT-PLIST)  (SETQ *ZTOP-SG* (MAKE-STACK-GROUP "ZTOP" :REGULAR-PDL-SIZE 40000 :SPECIAL-PDL-SIZE 4000))  (SETQ *STREAM-INPUT-HISTORY* (MAKE-HISTORY (STRING-APPEND "input history of "    (BUFFER-NAME (GET INIT-PLIST :BUFFER)))))  (INITIALIZE-ZTOP-SG SELF)) (DEFMETHOD (ZTOP-STREAM-MIXIN :SET-PACKAGE) (PKG)  ;; Tell the execution SG about a new package.  (MULTIPLE-VALUE-BIND (NIL LOC)      (SYMEVAL-IN-STACK-GROUP '*PACKAGE* *ZTOP-SG*)    (SETF (CONTENTS LOC) PKG))  (MULTIPLE-VALUE-BIND (NIL LOC)      (SYMEVAL-IN-STACK-GROUP '*ZTOP-PACKAGE* *ZTOP-SG*)    (SETF (CONTENTS LOC) PKG))) (DEFUN INITIALIZE-ZTOP-SG (STREAM)  (DECLARE (:SELF-FLAVOR ZTOP-STREAM-MIXIN))  (STACK-GROUP-PRESET *ZTOP-SG* 'ZTOP-TOP-LEVEL STREAM)  (FUNCALL *ZTOP-SG*)  (STREAM-REDISPLAY T)) ;This is the top level loop of the execution stack group.(DEFUN ZTOP-TOP-LEVEL (ZTOP-STREAM &AUX (PRIN1 *ZTOP-PRIN1*)       (*PACKAGE* *PACKAGE*) (*ZTOP-PACKAGE* *PACKAGE*))  (DO () (NIL)    (CATCH 'ZTOP-TOP-LEVEL      (SI:LISP-TOP-LEVEL1 ZTOP-STREAM)))) ;Unlike other editor streams, a ZTOP stream must be able to be told to;change which sheet it prints on, if you visit the ZTOP buffer in a different ZMACS window.(DEFMETHOD (ZTOP-STREAM-MIXIN :SET-STREAM-WINDOW) (WINDOW)  (MULTIPLE-VALUE-BIND (NIL TEM)      (SYMEVAL-IN-STACK-GROUP 'PRIN1 *ZTOP-SG*)    (SETF (CDR TEM) *ZTOP-PRIN1*))  (COND ((NEQ WINDOW *STREAM-SHEET*) (SETQ *STREAM-SHEET* WINDOW       *STREAM-BLINKER* (WINDOW-POINT-BLINKER *STREAM-SHEET*)       *STREAM-BP* (WINDOW-POINT *STREAM-SHEET*)) (LET ((BLINKER (W:MAKE-BLINKER *STREAM-SHEET* 'STREAM-IBEAM-BLINKER :EDITOR-STREAM SELF :VISIBILITY NIL)))   (SETF (WINDOW-SPECIAL-BLINKER-LIST *STREAM-SHEET*) (DELETE (ASSOC 'STREAM-BLINK-IBEAM(WINDOW-SPECIAL-BLINKER-LIST *STREAM-SHEET*):TEST #'EQ) (THE LIST (WINDOW-SPECIAL-BLINKER-LIST *STREAM-SHEET*)) :TEST #'EQ))   (PUSH `(STREAM-BLINK-IBEAM . ,BLINKER) (WINDOW-SPECIAL-BLINKER-LIST *STREAM-SHEET*)))))) (DEFMETHOD (ZTOP-STREAM-MIXIN :BEFORE :RUBOUT-HANDLER) (ARGS &REST IGNORE)  (SETQ *STREAM-ACTIVATION-NEEDED* NIL*ZTOP-PACKAGE* *PACKAGE**RUBOUT-HANDLER-ARGS* ARGS*RUBOUT-HANDLER-STATE* (IF (BP-= *STREAM-BP* (INTERVAL-LAST-BP (WINDOW-INTERVAL *STREAM-SHEET*)))   :NORMAL   :EDITING)*ZTOP-READING-INPUT* (EQ *RUBOUT-HANDLER-STATE* :NORMAL)*ZTOP-EDITING* (NOT *ZTOP-READING-INPUT*)*ZTOP-ACTIVATION-NEEDED* NIL)) (DEFMETHOD (ZTOP-STREAM-MIXIN :AFTER :RUBOUT-HANDLER) (&REST IGNORE)  ;;Get package for evaling in  (SETQ *PACKAGE* (SYMEVAL-IN-STACK-GROUP '*PACKAGE* *ZMACS-SG*))  (STREAM-REDISPLAY T))  ;Redisplay typeahead;;; This method gets called when the buffer is empty, co-call the other stack group(DEFMETHOD (ZTOP-STREAM-MIXIN :STREAM-RUBOUT-HANDLER) ()  ;; If everything has been typed out correctly, update the window datastructure  (AND (< (WINDOW-REDISPLAY-DEGREE *STREAM-SHEET*) DIS-TEXT)       (FAKE-OUT-TOP-LINE *STREAM-SHEET* (WINDOW-INTERVAL *STREAM-SHEET*)))  ;; Avoid confusing the :RUBOUT-HANDLER method after a EDITING-COMMAND character.  (SETQ *SRE-INPUT-END-BP* NIL*SRE-INPUT-POINT* NIL)  (IF *SRE-ACTIVATION-CHARACTER*      (PROG1*SRE-ACTIVATION-CHARACTER*(SETQ *SRE-ACTIVATION-CHARACTER* NIL))      (PROGN(SETQ *ZTOP-SG* SYSTEM:%CURRENT-STACK-GROUP)(WITH-BP (OLD-STREAM-BP *STREAM-BP* ':NORMAL)  (LET ((RESUME-INFORMATION (FUNCALL *ZMACS-SG*)))    (COND ((EQ RESUME-INFORMATION :RESCAN)   (THROW 'RUBOUT-HANDLER T))  ((EQ RESUME-INFORMATION :KEEP-READING)   (MOVE-BP *STREAM-BP* OLD-STREAM-BP)   (SEND SELF :READ-ANY))  ((EQ (CAR RESUME-INFORMATION) :EDITING-COMMAND)   (SETQ *SRE-INPUT-END-BP* (CADR RESUME-INFORMATION) *SRE-INPUT-POINT* (CADDR RESUME-INFORMATION))   (CADDDR RESUME-INFORMATION))  ((EQ (CAR RESUME-INFORMATION) :COMMAND)   (SETQ *STREAM-COMMAND-POINT* (COPY-BP *STREAM-BP* :NORMAL))   (MOVE-BP *STREAM-BP* *STREAM-START-BP*)   (THROW 'W::RETURN-FROM-RUBOUT-HANDLER  (VALUES (CADR RESUME-INFORMATION)  :COMMAND)))  ((EQ (CAR RESUME-INFORMATION) :ACTIVATION)   (SETQ *SRE-ACTIVATION-CHARACTER* (CADR RESUME-INFORMATION))   (THROW 'RUBOUT-HANDLER T)))))))) ;;; Command hook, called by editor before each command.;;; The purpose is to detect editing-commands, activations and commands;;; as requested by the invocation of :RUBOUT-HANDLER.;;; If this character is any of those, we cause it to be ignored;;; by the editor, after the resuming the execution stack group;;; and giving it full information about the character we encountered.(DEFMETHOD (ZTOP-STREAM-MIXIN :PRE-COMMAND-HOOK)   (CHAR &AUX    (EDITING-COMMAND (CDR (ASSOC :EDITING-COMMAND *RUBOUT-HANDLER-ARGS* :TEST #'EQ)))    (DO-NOT-ECHO (CDR (ASSOC :DO-NOT-ECHO *RUBOUT-HANDLER-ARGS* :TEST #'EQ)))    (COMMAND-HANDLER (ASSOC :COMMAND *RUBOUT-HANDLER-ARGS* :TEST #'EQ))    (ACTIVATION-HANDLER (ASSOC :ACTIVATION *RUBOUT-HANDLER-ARGS* :TEST #'EQ)))  (COND ((OR (MEMBER CHAR EDITING-COMMAND :TEST #'EQ)     (SI:ASSQ-CAREFUL CHAR EDITING-COMMAND)) (RESUME-ZTOP-SG (PROG1 `(:EDITING-COMMAND ,(COPY-BP (INTERVAL-LAST-BP *INTERVAL*))   ,(COPY-BP (POINT)) ,CHAR)(MOVE-BP (POINT) (INTERVAL-LAST-BP *INTERVAL*)))) (SETQ *CURRENT-COMMAND-TYPE* 'EDITING-COMMAND) (THROW 'COMMAND-EXECUTE T))((AND COMMAND-HANDLER      (APPLY (CADR COMMAND-HANDLER) CHAR (CDDR COMMAND-HANDLER))) (RESUME-ZTOP-SG `(:COMMAND (:COMMAND ,CHAR ,(OR *NUMERIC-ARG* 1)))) (SETQ *CURRENT-COMMAND-TYPE* 'EDITING-COMMAND) (THROW 'COMMAND-EXECUTE T))((OR (MEMBER CHAR DO-NOT-ECHO :TEST #'EQ)     (AND ACTIVATION-HANDLER  (APPLY (CADR ACTIVATION-HANDLER) CHAR (CDDR ACTIVATION-HANDLER)))) (SETQ *RUBOUT-HANDLER-STATE* :NORMAL) (SETQ *ZTOP-ACTIVATION-NEEDED* NIL       *ZTOP-EDITING* NIL       *ZTOP-READING-INPUT* T) (REDISPLAY-MODE-LINE) (RESUME-ZTOP-SG `(:ACTIVATION ,(IF (MEMBER CHAR DO-NOT-ECHO :TEST #'EQ)    CHAR    `(:ACTIVATION ,CHAR ,(OR *NUMERIC-ARG* 1))))) (SETQ *CURRENT-COMMAND-TYPE* 'ACTIVATE-ZTOP) (THROW 'COMMAND-EXECUTE T)))) ;;; This gets called by the editor after each command(DEFMETHOD (ZTOP-STREAM-MIXIN :COMMAND-HOOK) (TYPE &AUX (OLD-STATE *RUBOUT-HANDLER-STATE*))  (UNLESS (EQ TYPE 'EDITING-COMMAND)    (AND (ASSOC :FULL-RUBOUT *RUBOUT-HANDLER-ARGS* :TEST #'EQ) (BP-= *STREAM-START-BP* *STREAM-BP*) (SETQ OLD-STATE :EDITING       TYPE :FULL-RUBOUT))    (SETQ *RUBOUT-HANDLER-STATE* (IF (AND (BP-= *STREAM-BP* (INTERVAL-LAST-BP (WINDOW-INTERVAL *STREAM-SHEET*)))  (OR (NOT *STREAM-ACTIVATION-NEEDED*)      (EQ TYPE 'ACTIVATE-ZTOP))  (MEMBER TYPE '(SELF-INSERT INSERT-CR ACTIVATE-ZTOP ZTOP-MODE :FULL-RUBOUT)  :TEST #'EQ))     :NORMAL     :EDITING))    (IF (EQ *RUBOUT-HANDLER-STATE* :EDITING)(SETQ *STREAM-ACTIVATION-NEEDED* *ZTOP-REQUIRE-ACTIVATION*)(PROGN  (AND (NEQ OLD-STATE :NORMAL)  ;If we were editing       (MOVE-BP *STREAM-BP* *STREAM-START-BP*))  (SETQ *ZMACS-SG* SYSTEM:%CURRENT-STACK-GROUP)  (RESUME-ZTOP-SG (IF (EQ OLD-STATE :EDITING)      :RESCAN      :KEEP-READING))  (AND (NEQ OLD-STATE :NORMAL)       (MUST-REDISPLAY *STREAM-SHEET* DIS-BPS)))))  (SETQ *ZTOP-ACTIVATION-NEEDED* *STREAM-ACTIVATION-NEEDED*)  (SETQ *ZTOP-EDITING* (AND (NOT *ZTOP-ACTIVATION-NEEDED*)    (EQ *RUBOUT-HANDLER-STATE* :EDITING)))  (SETQ *ZTOP-READING-INPUT* (AND (NOT *ZTOP-ACTIVATION-NEEDED*)  (NOT *ZTOP-EDITING*)))) (DEFUN RESUME-ZTOP-SG (ARG)  (DECLARE (:SELF-FLAVOR ZTOP-STREAM-MIXIN))  (SEND CURRENT-PROCESS :ADD-COROUTINE-STACK-GROUP *ZTOP-SG*)  ;; If the editor has changed our package, tell the execution SG.  (MULTIPLE-VALUE-BIND (VALUE LOC)      (SYMEVAL-IN-STACK-GROUP '*ZTOP-PACKAGE* *ZTOP-SG*)    (UNLESS (EQ VALUE *PACKAGE*)      (SETF (CONTENTS LOC) *PACKAGE*)      (MULTIPLE-VALUE-BIND (NIL LOC)  (SYMEVAL-IN-STACK-GROUP '*PACKAGE* *ZTOP-SG*)(SETF (CONTENTS LOC) *PACKAGE*))))  (LET ((NORMAL-EXIT-P NIL))    (UNWIND-PROTECT(PROG1  (FUNCALL *ZTOP-SG* ARG)  (SETQ NORMAL-EXIT-P T)  ;; If the execution SG has changed its package, propagate to editor.  (SETQ *PACKAGE* (SYMEVAL-IN-STACK-GROUP '*ZTOP-PACKAGE* *ZTOP-SG*))  (SETF (BUFFER-PACKAGE *INTERVAL*) *PACKAGE*))      (OR NORMAL-EXIT-P  (INITIALIZE-ZTOP-SG SELF))))) ;Decide whether and where to blink the ibeam blinker.(DEFMETHOD (ZTOP-STREAM-MIXIN :COMPUTE-BLINKER-POSITION) (BP)  (AND (EQ (BP-TOP-LEVEL-NODE BP)   (BP-TOP-LEVEL-NODE *STREAM-START-BP*))       (NOT *ZTOP-READING-INPUT*)       (FIND-BP-IN-WINDOW-COORDS *STREAM-START-BP* *STREAM-SHEET*))) ;Executed in the editor sg to abort the execution sg.(DEFMETHOD (ZTOP-STREAM-MIXIN :ZTOP-ABORT) ()  (EH:SG-ABORT *ZTOP-SG*)) ;Executed in the editor sg to abort the execution sg.(DEFMETHOD (ZTOP-STREAM-MIXIN :ZTOP-ABORT-ALL) ()  (EH::SG-APPLY-NO-TRAP *ZTOP-SG*'W:KBD-INTERCEPT-ABORT-ALL'(#\m-ABORT)T T)) OF-EDITOR-HIERARCHY) ()  W:SUPERIOR) (DEFMETHOD (ZWEI-PANE-MIXIN :EDITOR-WINDOWS) ()  (OR (SEND W:SUPERIOR :SEND-IF-HANDLES :EDITO