LMFL#!C(:HOST "SYS" :BACKUP-DATE 2760032448. :SYSTEM-TYPE :LOGICAL :VERSION 1. :TYPE "LISP" :NAME "FOR" :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 2758738919. :AUTHOR "REL3" :LENGTH-IN-BYTES 35796. :LENGTH-IN-BLOCKS 35. :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;;; Functions in this file know about bps, lines, and intervals.;;; They use *INTERVAL* for their limit-checking.;;; Standard motion functions.;;; Modified to handle movement around embedded diagram lines. By rpm from dls 11-26-86.(DEFUN FORWARD-CHAR (BP &OPTIONAL (TIMES 1) FIXUP-P)  "Return a bp which is TIMES characters forward from BP.FIXUP-P non-NIL means if go past beginning or end return a bp to there; otherwise return NIL in that case."  (COND ((ZEROP TIMES) (COPY-BP BP))((> TIMES 0) (DO ((LINE (BP-LINE BP))      (INDEX (BP-INDEX BP) 0)      (LAST-LINE (BP-LINE (INTERVAL-LAST-BP *INTERVAL*)))      (LAST-INDEX (BP-INDEX (INTERVAL-LAST-BP *INTERVAL*))))     (NIL)   (LET ((LL (LINE-LENGTH LINE)) (I (+ INDEX TIMES)))     (COND ((AND (EQ LINE LAST-LINE) (> I LAST-INDEX))    (RETURN (IF FIXUP-P(CREATE-BP LINE LAST-INDEX)NIL)))   ((<= I LL)    (RETURN (CREATE-BP LINE I))))     (SETQ TIMES (- TIMES (- LL INDEX) 1)   LINE (LINE-NEXT LINE))     (DO () ((OR (NULL (GET (LOCF (LINE-PLIST LINE)) :DIAGRAM))      (NULL (LINE-NEXT LINE))))       (SETQ *NUMERIC-ARG-P* T     LINE (LINE-NEXT LINE))))))(T (SETQ TIMES (- TIMES)) (DO ((LINE (BP-LINE BP))      (INDEX (- (BP-INDEX BP) TIMES))      (LINE-LENGTH (BP-INDEX BP))      (FIRST-LINE (BP-LINE (INTERVAL-FIRST-BP *INTERVAL*)))      (FIRST-INDEX (BP-INDEX (INTERVAL-FIRST-BP *INTERVAL*))))     (NIL)   (COND ((AND (EQ LINE FIRST-LINE) (< INDEX FIRST-INDEX))  (RETURN (IF FIXUP-P      (CREATE-BP FIRST-LINE FIRST-INDEX)      NIL))) ((>= INDEX 0)  (RETURN (CREATE-BP LINE INDEX))))   (SETQ TIMES (- TIMES LINE-LENGTH 1) LINE (LINE-PREVIOUS LINE))   (DO ()       ((OR (NULL (GET (LOCF (LINE-PLIST LINE)) :DIAGRAM))    (NULL (LINE-PREVIOUS LINE))))     (SETQ *NUMERIC-ARG-P* T   LINE (LINE-PREVIOUS LINE)))   (SETQ LINE-LENGTH (LINE-LENGTH LINE) INDEX (- LINE-LENGTH TIMES)))))) (DEFUN FORWARD-ITS-CHAR (BP &OPTIONAL (TIMES 1) FIXUP-P)  "Return a bp which is TIMES ITS-equivalent characters forward from BP.Counting characters as ITS-equivalent means count a line break as two chars.FIXUP-P non-NIL means if go past beginning or end return a bp to there; otherwise return NIL in that case."  (COND ((ZEROP TIMES) (COPY-BP BP))((> TIMES 0) (DO ((LINE (BP-LINE BP) (LINE-NEXT LINE))      (INDEX (BP-INDEX BP) 0)      (LAST-LINE (BP-LINE (INTERVAL-LAST-BP *INTERVAL*)))      (LAST-INDEX (BP-INDEX (INTERVAL-LAST-BP *INTERVAL*))))     (NIL)   (LET ((LL (LINE-LENGTH LINE)) (I (+ INDEX TIMES)))     (COND ((AND (EQ LINE LAST-LINE) (> I LAST-INDEX))    (RETURN (IF FIXUP-P(CREATE-BP LINE LAST-INDEX)NIL)))   ((<= I LL)    (RETURN (CREATE-BP LINE I))))     (SETQ TIMES (MAX 0 (- TIMES (- LL INDEX) 2))))))(T (SETQ TIMES (- TIMES)) (DO ((LINE (BP-LINE BP))      (INDEX (- (BP-INDEX BP) TIMES))      (LINE-LENGTH (BP-INDEX BP))      (FIRST-LINE (BP-LINE (INTERVAL-FIRST-BP *INTERVAL*)))      (FIRST-INDEX (BP-INDEX (INTERVAL-FIRST-BP *INTERVAL*))))     (NIL)   (COND ((AND (EQ LINE FIRST-LINE)       (< INDEX FIRST-INDEX))  (RETURN (IF FIXUP-P      (CREATE-BP FIRST-LINE FIRST-INDEX)      NIL))) ((>= INDEX 0)  (RETURN (CREATE-BP LINE INDEX))))   (SETQ TIMES (MAX 0 (- TIMES LINE-LENGTH 2)) LINE (LINE-PREVIOUS LINE) LINE-LENGTH (LINE-LENGTH LINE) INDEX (- LINE-LENGTH TIMES)))))) (DEFUN FORWARD-LINE (BP &OPTIONAL (TIMES 1) FIXUP-P)  "Return a bp which is TIMES lines forward from BP.Zero means the front of the same line.Otherwise the result is at the beginning of a line.TIMES may be negative meaning go up.FIXUP-P non-NIL means if go past beginning or end return a bp to there; otherwise return NIL in that case."  (COND ((ZEROP TIMES) (COPY-BP BP))((PLUSP TIMES) (DO ((LAST-LINE (BP-LINE (INTERVAL-LAST-BP *INTERVAL*)))      (LINE (BP-LINE BP) (LINE-NEXT LINE))      (I 0 (1+ I)))     ((>= I TIMES)      (CREATE-BP LINE 0))   (COND ((EQ LINE LAST-LINE)  (RETURN (IF FIXUP-P      ;; patch 98.148.  ddd, 3/6/84.      (CREATE-BP LINE (BP-INDEX (INTERVAL-LAST-BP *INTERVAL*)))      NIL))))))(T (DO ((FIRST-LINE (BP-LINE (INTERVAL-FIRST-BP *INTERVAL*)))      (LINE (BP-LINE BP) (LINE-PREVIOUS LINE))      (I 0 (1- I)))     ((<= I TIMES)      (UNLESS LINE (FERROR NIL "Report this ZWEI bug thoroughly!")) ;; 94.148.  ddd.      (CREATE-BP LINE (IF (EQ LINE FIRST-LINE)  (BP-INDEX (INTERVAL-FIRST-BP *INTERVAL*))  0)))   (COND ((EQ LINE FIRST-LINE)  (RETURN (IF FIXUP-P      (CREATE-BP LINE (BP-INDEX (INTERVAL-FIRST-BP *INTERVAL*)))      NIL)))))))) (DEFUN FORWARD-LIST (BP &OPTIONAL (TIMES 1) FIXUP-P (LEVEL 0) DOWNP NO-UP-P     &AUX (ORIGINAL-LEVEL LEVEL) (STATE 'NORMAL))  "Return a bp which is TIMES lists forward from BP.Atoms and singlequote-like characters are ignored.  Comments are not ignored.TIMES may be negative meaning go backward.FIXUP-P non-NIL means if go past beginning or end return a bp to there; otherwise return NIL in that case.LEVEL nonzero means move up that many levels of list structure.LEVEL negative means move down; but DOWNP should be T.NO-UP-P means it is forbidden to move up and then down again. NIL is returned if that starts to happen."  (AND (LISP-BP-SYNTACTIC-CONTEXT BP)       ;; If point is inside a string, move past the string entirely,       ;; unless the supposed string is really a #| ... |#,       ;; in which case move down in the code inside that construct.       (OR (AND DOWNP (LOOKING-AT (FORWARD-UP-STRING BP T) "#|"))   (SETQ STATE 'STRING)))  (COND ((ZEROP TIMES) (COPY-BP BP))((PLUSP TIMES) (LET ((TIME 0)       (LAST-BP (INTERVAL-LAST-BP *INTERVAL*)))   (CHARMAP (BP LAST-BP (IF FIXUP-P    (COPY-BP LAST-BP)    NIL))     RESTART     (LET ((SYNTAX (LIST-SYNTAX (CHARMAP-CHAR))))       (CASE STATE     (STRING      (SELECT SYNTAX      (LIST-DOUBLE-QUOTE       (SETQ STATE 'NORMAL))      (LIST-SLASH       (CHARMAP-INCREMENT (IF FIXUP-P      (COPY-BP LAST-BP)      NIL)))))     (NORMAL      (SELECT SYNTAX      (LIST-SLASH       (CHARMAP-INCREMENT (IF FIXUP-P      (COPY-BP LAST-BP)      NIL)))      (LIST-DOUBLE-QUOTE       (SETQ STATE 'STRING))      (LIST-CLOSE       (SETQ LEVEL (1- LEVEL))       (COND (DOWNP      (COND ((< LEVEL ORIGINAL-LEVEL)     (CHARMAP-RETURN (IF FIXUP-P (COPY-BP LAST-BP) NIL)))))     ((AND NO-UP-P (< LEVEL 0))      (CHARMAP-RETURN ()))     ((<= LEVEL 0)      (IF (>= (SETQ TIME (1+ TIME)) TIMES)  (CHARMAP-RETURN (CHARMAP-BP-AFTER))))))      (LIST-OPEN       (COND ((AND (>= (SETQ LEVEL (1+ LEVEL)) 0) DOWNP)      (IF (>= (SETQ TIME (1+ TIME)) TIMES)  (CHARMAP-RETURN (CHARMAP-BP-AFTER)))))))))))))(T (LET ((TIME 0)       (FIRST-BP (INTERVAL-FIRST-BP *INTERVAL*)))   (RCHARMAP (BP FIRST-BP (IF FIXUP-P      (COPY-BP FIRST-BP)      NIL))     RESTART     (OR (= (LIST-SYNTAX (RCHARMAP-CHAR-BEFORE)) LIST-SLASH) (LET ((SYNTAX (LIST-SYNTAX (RCHARMAP-CHAR))))   (CASE STATE (STRING  (SELECT SYNTAX          (LIST-DOUBLE-QUOTE   (SETQ STATE 'NORMAL)))) (NORMAL  (SELECT SYNTAX          (LIST-DOUBLE-QUOTE   (SETQ STATE 'STRING))  (LIST-CLOSE   (AND (>= (SETQ LEVEL (1+ LEVEL)) 0)DOWNP(IF (<= (SETQ TIME (1- TIME)) TIMES)    (RCHARMAP-RETURN (RCHARMAP-BP-BEFORE)))))  (LIST-OPEN   (SETQ LEVEL (1- LEVEL))   (AND NO-UP-P (< LEVEL 0) (RCHARMAP-RETURN NIL))   (AND (<= LEVEL 0)(NOT DOWNP)(IF (<= (SETQ TIME (1- TIME)) TIMES)    (RCHARMAP-RETURN (RCHARMAP-BP-BEFORE))))))))))))))) (DEFUN LINE-OPENS-PARENS (LINE)  "T if LINE contains open parens that are not matched within LINE."  (DO ((I (IF (EQ LINE (BP-LINE (INTERVAL-FIRST-BP *INTERVAL*)))      (BP-INDEX (INTERVAL-FIRST-BP *INTERVAL*))      0)  (1+ I))       (LIM (IF (EQ LINE (BP-LINE (INTERVAL-LAST-BP *INTERVAL*)))(BP-INDEX (INTERVAL-LAST-BP *INTERVAL*))(LINE-LENGTH LINE)))       (STATE 'NORMAL)       (LEVEL 0))      ((>= I LIM) (> LEVEL 0))    (LET* ((CH (MAKE-CHAR (AREF LINE I)))   (SYNTAX (LIST-SYNTAX CH)))      (CASE STATE    (STRING     (SELECT SYNTAX             (LIST-DOUBLE-QUOTE      (SETQ STATE 'NORMAL))     (LIST-SLASH      (SETQ I (1+ I)))))    (NORMAL     (SELECT SYNTAX             (LIST-SLASH      (SETQ I (1+ I)))     (LIST-DOUBLE-QUOTE      (SETQ STATE 'STRING))     (LIST-CLOSE      (SETQ LEVEL (MAX (1- LEVEL) 0)))     (LIST-OPEN      (SETQ LEVEL (1+ LEVEL))))))))) (DEFUN FORWARD-WORD (BP &OPTIONAL (TIMES 1) FIXUP-P)  "Return a bp which is forward across TIMES words from BP.TIMES negative means move backwards.FIXUP-P non-NIL means if go past beginning or end return a bp to there; otherwise return NIL in that case."  (COND ((ZEROP TIMES) (COPY-BP BP))((PLUSP TIMES) (LET ((STATE NIL)       (TIME 0)       (LAST-BP (INTERVAL-LAST-BP *INTERVAL*)))   (CHARMAP (BP LAST-BP (IF (OR FIXUP-P (AND STATE (= (1+ TIME) TIMES)))    (COPY-BP LAST-BP)    NIL))     (LET ((SYNTAX (WORD-SYNTAX (CHARMAP-CHAR))))       (CASE STATE     (NIL      (SELECT SYNTAX  ;use select in case more       (WORD-ALPHABETIC  ;word syntax types appear       (SETQ STATE T))))     (T      (SELECT SYNTAX      (WORD-DELIMITER       (SETQ TIME (1+ TIME))       (IF (>= TIME TIMES)   (CHARMAP-RETURN (CHARMAP-BP-BEFORE))   (SETQ STATE NIL))))))))))(T (LET ((STATE NIL)       (TIME 0)       (FIRST-BP (INTERVAL-FIRST-BP *INTERVAL*)))   (RCHARMAP (BP FIRST-BP (IF (OR FIXUP-P (AND STATE (= (1- TIME) TIMES)))      (COPY-BP FIRST-BP)      NIL))     (LET ((SYNTAX (WORD-SYNTAX (RCHARMAP-CHAR))))       (CASE STATE     (NIL      (SELECT SYNTAX      (WORD-ALPHABETIC       (SETQ STATE T))))     (T      (SELECT SYNTAX      (WORD-DELIMITER (SETQ TIME (1- TIME))      (IF (<= TIME TIMES)  (RCHARMAP-RETURN (RCHARMAP-BP-AFTER))  (SETQ STATE ())))))))))))) (DEFUN FORWARD-TO-WORD (BP &OPTIONAL (TIMES 1) FIXUP-P)  "Return a bp which is forward up to the TIMES word-beginning from BP.TIMES negative means move backwards.FIXUP-P non-NIL means if go past beginning or end return a bp to there; otherwise return NIL in that case."  (CATCH 'LOSSAGE    (COND ((ZEROP TIMES)   (COPY-BP BP))  ((PLUSP TIMES)   (LET ((LAST-BP (INTERVAL-LAST-BP *INTERVAL*)))     (COND ((> TIMES 1)    (SETQ BP (FORWARD-WORD BP (1- TIMES)))    (COND ((NULL BP)   (THROW 'LOSSAGE (IF FIXUP-P (COPY-BP LAST-BP) NIL))))))     (CHARMAP (BP LAST-BP (IF FIXUP-P (COPY-BP LAST-BP) NIL))       (LET ((SYNTAX (WORD-SYNTAX (CHARMAP-CHAR)))) (SELECT SYNTAX         (WORD-ALPHABETIC  (CHARMAP-RETURN (CHARMAP-BP-BEFORE))))))))  (T   (LET ((FIRST-BP (INTERVAL-FIRST-BP *INTERVAL*)))     (COND ((< TIMES -1)    (SETQ BP (FORWARD-WORD BP (1+ TIMES)))    (COND ((NULL BP)   (THROW 'LOSSAGE (IF FIXUP-P (COPY-BP FIRST-BP) NIL))))))     (RCHARMAP (BP FIRST-BP (IF FIXUP-P (COPY-BP FIRST-BP) NIL))       (LET ((SYNTAX (WORD-SYNTAX (RCHARMAP-CHAR)))) (SELECT SYNTAX         (WORD-ALPHABETIC  (RCHARMAP-RETURN (RCHARMAP-BP-AFTER))))))))))) (DEFUN FORWARD-DEFUN (BP &OPTIONAL (TIMES 1) FIXUP-P)  "Return a bp which is forward across TIMES defuns from BP.If BP is within a defun, that is included in the count.TIMES negative means move backwards.FIXUP-P non-NIL means if go past beginning or end return a bp to there; otherwise return NIL in that case."  (COND ((ZEROP TIMES) (COPY-BP BP))((PLUSP TIMES) (BLOCK LUPO   (DO ((I 0 (1+ I)))       ((>= I TIMES) BP)     (DO () (NIL)       (SETQ BP (BEG-LINE BP 1))       (COND ((NULL BP)      (RETURN-FROM LUPO (IF FIXUP-P    (COPY-BP (INTERVAL-LAST-BP *INTERVAL*))    NIL)))     ((= (LIST-SYNTAX (BP-CH-CHAR BP)) LIST-OPEN)      (RETURN NIL)))))))(T (BLOCK LUPO   (DO ((I 0 (1- I)))       ((<= I TIMES) BP)     (DO ((FIRSTP T NIL)) (NIL)       (SETQ BP (BEG-LINE BP (IF (AND FIRSTP (NOT (BEG-LINE-P BP))) 0 -1)))       (COND ((NULL BP)      (RETURN-FROM LUPO (IF FIXUP-P    (COPY-BP (INTERVAL-FIRST-BP *INTERVAL*))    NIL)))     ((= (LIST-SYNTAX (BP-CH-CHAR BP)) LIST-OPEN)      (RETURN NIL))))))))) (DEFUN FORWARD-PAGE (BP &OPTIONAL (TIMES 1) FIXUP-P)  "Return a bp which is TIMES page-separators forward from BP.TIMES negative means move backwards.FIXUP-P non-NIL means if go past beginning or end return a bp to there; otherwise return NIL in that case."  (COND ((ZEROP TIMES) (COPY-BP BP))((PLUSP TIMES) (LET ((STOP-LINE (BP-LINE (INTERVAL-LAST-BP *INTERVAL*)))       (FIRST-LINE (BP-LINE BP)))   (COND ((EQ FIRST-LINE STOP-LINE)  (AND FIXUP-P (COPY-BP (INTERVAL-LAST-BP *INTERVAL*)))) (T  (DO ((LINE (LINE-NEXT FIRST-LINE) (LINE-NEXT LINE)))      ((EQ LINE STOP-LINE)       (COPY-BP (INTERVAL-LAST-BP *INTERVAL*)))    (COND ((AND (>= (LINE-LENGTH LINE) 1)(MEMBER (MAKE-CHAR (AREF LINE 0)) *PAGE-DELIMITER-LIST* :TEST #'EQ))   (AND (<= (SETQ TIMES (1- TIMES)) 0)(RETURN (CREATE-BP LINE 1))))))))))(T (LET ((STOP-LINE (BP-LINE (INTERVAL-FIRST-BP *INTERVAL*)))       (FIRST-LINE (BP-LINE BP)))   (COND ((EQ FIRST-LINE STOP-LINE)  (AND FIXUP-P (COPY-BP (INTERVAL-FIRST-BP *INTERVAL*)))) (T  (DO ((LINE (LINE-PREVIOUS FIRST-LINE) (LINE-PREVIOUS LINE)))      ((EQ LINE STOP-LINE)       (AND FIXUP-P (COPY-BP (INTERVAL-FIRST-BP *INTERVAL*))))    (COND ((AND (>= (LINE-LENGTH LINE) 1)(MEMBER (MAKE-CHAR (AREF LINE 0)) *PAGE-DELIMITER-LIST* :TEST #'EQ))   (AND (>= (SETQ TIMES (1+ TIMES)) 0)(RETURN (CREATE-BP LINE 1)))))))))))) (DEFUN FORWARD-INTERVAL (BP &OPTIONAL (TIMES 1) FIXUP-P)  "Return a bp to the beginning or end of *INTERVAL*.The sign of TIMES determines which.FIXUP-P is ignored; allowed for compatibility with other FORWARD-functions."  BP FIXUP-P;Never out of range  (COPY-BP (IF (MINUSP TIMES)       (INTERVAL-FIRST-BP *INTERVAL*)       (INTERVAL-LAST-BP *INTERVAL*)))) ;; New function from patch 94.207.  ddd/gsl 3/5/84.(DEFUN FORWARD-PARAGRAPH-COMPLETE (BP &OPTIONAL (TIMES 1) FIXUP-P   &AUX BACKWARD-P)  "Like forward-paragraph but includes cr & whitespace before paragraph when going backward, and whitespace on last line of paragraph when going forward."  (IF (ZEROP TIMES)      (COPY-BP BP)      (PROGN(AND (MINUSP TIMES)     (SETQ BACKWARD-P T))(IF BACKWARD-P    (END-LINE (FORWARD-PARAGRAPH BP TIMES FIXUP-P) -1)    (END-LINE (FORWARD-PARAGRAPH BP TIMES FIXUP-P)))))) (DEFUN FORWARD-PARAGRAPH (BP &OPTIONAL (TIMES 1) FIXUP-P  &AUX BACKWARD-P  (FILL-PREFIX-P (PLUSP (LENGTH *FILL-PREFIX*)))  BLANK-P PREV-BLANK-P)  "Return a bp to the TIMES'th paragraph-end forward from BP.TIMES negative means move backwards past that many paragraph-beginnings.FIXUP-P non-NIL means if go past beginning or end return a bp to there; otherwise return NIL in that case."  (AND (MINUSP TIMES)       (SETQ TIMES (- TIMES)     BACKWARD-P T))  (COND ((NOT BACKWARD-P);Move to the beginning of a line (SETQ BP (BEG-LINE BP)))((NOT (BEG-LINE-P BP)) (SETQ BP (BEG-LINE BP 1 T)))(T (LET ((PREV-BP (BEG-LINE BP -1)))   (AND PREV-BP(NOT (LINE-BLANK-OR-DIAGRAM-P (BP-LINE PREV-BP)))(BP-LOOKING-AT-LIST PREV-BP *PAGE-DELIMITER-LIST*)(SETQ BP PREV-BP)))))  (DO ((I 0 (1+ I)))      ((OR (NULL BP) (>= I TIMES)) BP)    (SETQ BLANK-P T)    (DO ((FIRST-P (IF (AND BACKWARD-P (BP-= BP (INTERVAL-LAST-BP *INTERVAL*))) 1 0)  (1+ FIRST-P)))(NIL)      (SETQ PREV-BLANK-P BLANK-P    BLANK-P NIL)      (AND (SETQ BLANK-P (BP-AT-PARAGRAPH-DELIMITER BP FILL-PREFIX-P))   (NOT PREV-BLANK-P)   (OR (> FIRST-P 1)       (NOT BACKWARD-P))   (RETURN))      (COND ((NOT (IF BACKWARD-P      (OR (SETQ BP (BEG-LINE BP -1))  (RETURN))      (PROGN(OR (SETQ BP (BEG-LINE BP 1))    (RETURN))(NOT BLANK-P)))))    ((AND BACKWARD-P  (LINE-PREVIOUS (BP-LINE BP))  (LINE-BLANK-P (LINE-PREVIOUS (BP-LINE BP))))     ;; Don't stop at a nonblank line (such as an indented one) if prev one is blank.     )    ((BP-AT-PARAGRAPH-STARTER BP FILL-PREFIX-P)     (RETURN)))))  ;; If going backwards and stopped at a nonblank line which isn't part of this paragraph,  ;; move to beginning of the following line.  (AND BP       BACKWARD-P       (NOT (LINE-BLANK-P (BP-LINE BP)))       (BP-AT-PARAGRAPH-DELIMITER BP FILL-PREFIX-P)       (SETQ BP (BEG-LINE BP 1 T)))  (OR BP      (AND FIXUP-P   (COPY-BP (IF BACKWARD-P(INTERVAL-FIRST-BP *INTERVAL*)(INTERVAL-LAST-BP *INTERVAL*)))))) ;; Three new functions and a change to BP-AT-PARAGRAPH-STARTER, all from;; patch 94.207.   ddd/gsl 3/5/84.(DEFUN STRING-COL-TO-CHAR-INDEX (LINE COLUMN)  "Given a desired screen column, return index into line which will be there or just beyond,if line is displayed left justified, i.e. allow for tabs and fonts. All indices are base 0."  (IF (= (LENGTH LINE) 0)      0      (DO ((INDEX 0)   (SHEET (WINDOW-SHEET *WINDOW*))   (FONT (SEND *WINDOW* :CURRENT-FONT))   (CHAR-INDEX 1 (1+ CHAR-INDEX))   PIXELS   RESULT)  ((> INDEX COLUMN) (1- RESULT)); base conversion in result(MULTIPLE-VALUE-SETQ (PIXELS RESULT)  (W:SHEET-STRING-LENGTH SHEET LINE 0 CHAR-INDEX NIL FONT))(SETQ INDEX (CEILING PIXELS (W:FONT-CHAR-WIDTH FONT)))))) (DEFUN STRING-CHAR-INDEX-TO-COL (LINE CHAR-INDEX-IN)  "Given a desired char index, return screen column it will terminate in,if line is displayed left justified, i.e. allow for tabs.  All indices are base 0."  (IF (= (LENGTH LINE) 0)      0      (LET ((SHEET (WINDOW-SHEET *WINDOW*))    (FONT (SEND *WINDOW* :CURRENT-FONT))    COLS    PIXELS)(MULTIPLE-VALUE-SETQ (PIXELS COLS)  (W:SHEET-STRING-LENGTH SHEET LINE 0 (1+ CHAR-INDEX-IN) NIL FONT));1+ for base 1.(1- (CEILING PIXELS (W:FONT-CHAR-WIDTH FONT)))))); 1- for base 1 to base 0 conversion.(DEFUN COMMONLY-INDENTED (BP &AUX BEGIN-1 BEGIN BEGIN+1 LINE (MAX-COL 3720))  "Returns a bp with the index set to the minimum indentation of the set of lineswhich are: this line, the previous line, and the next line.  If the previous lineis blank or doesn't exist the index is set to 0.  If the next line is blank ordoesn't exist, it has no influence on the calculation."  (LET ((ALPHABETIC-CASE-AFFECTS-STRING-COMPARISON NIL))    (IF (SETQ LINE (LINE-PREVIOUS (BP-LINE BP)))(IF (SETQ BEGIN-1 (STRING-SEARCH-SET "abcdefghijklmnopqrstuvwxyz1234567890" LINE))    (SETQ BEGIN-1 (STRING-CHAR-INDEX-TO-COL    LINE    (1+ (OR (STRING-REVERSE-SEARCH-SET *WHITESPACE-CHARS* LINE BEGIN-1)    -1))))    (SETQ BEGIN-1 0))(SETQ BEGIN-1 0))    (IF (SETQ LINE (LINE-NEXT (BP-LINE BP)))(IF (SETQ BEGIN+1 (STRING-SEARCH-SET "abcdefghijklmnopqrstuvwxyz1234567890" LINE))    (SETQ BEGIN+1 (STRING-CHAR-INDEX-TO-COL    LINE    (1+ (OR (STRING-REVERSE-SEARCH-SET *WHITESPACE-CHARS* LINE BEGIN+1)    -1))))    (SETQ BEGIN+1 MAX-COL))(SETQ BEGIN+1 MAX-COL))    (SETQ LINE (BP-LINE BP))    (SETQ BEGIN (STRING-CHAR-INDEX-TO-COL LINE (OR (STRING-SEARCH-NOT-SET *WHITESPACE-CHARS* LINE) 0)))    (CREATE-BP (SETQ LINE (BP-LINE BP))       (STRING-COL-TO-CHAR-INDEX LINE (MIN BEGIN-1 BEGIN BEGIN+1))       :NORMAL))) (DEFUN BP-AT-PARAGRAPH-STARTER (BP &OPTIONAL (FILL-PREFIX-P (NOT (ZEROP (LENGTH *FILL-PREFIX*))))&AUX (FRONT-BP (COMMONLY-INDENTED BP)))  "T if BP is in front of all text on a line that starts a paragraph."  (IF FILL-PREFIX-P      (NOT (LOOKING-AT BP *FILL-PREFIX*))      (AND (<= (BP-INDEX BP)       (OR (STRING-SEARCH-NOT-SET *WHITESPACE-CHARS* (BP-LINE BP) (BP-INDEX FRONT-BP))   (LENGTH (BP-LINE BP))));i.e. we are not into text...   (NOT (LINE-BLANK-OR-DIAGRAM-P (BP-LINE BP)));and there exists text on the line    (NOT (BP-LOOKING-AT-LIST FRONT-BP *TEXT-JUSTIFIER-ESCAPE-LIST*));and text is indented   (OR (BP-LOOKING-AT-LIST FRONT-BP *PARAGRAPH-DELIMITER-LIST*)       (BP-LOOKING-AT-LIST FRONT-BP *PAGE-DELIMITER-LIST*))))) (DEFUN BP-AT-PARAGRAPH-DELIMITER (BP &OPTIONAL (FILL-PREFIX-P (NOT (ZEROP (LENGTH *FILL-PREFIX*)))))  "T if BP is on a line which separates paragraphs and is not part of them."  (OR (LINE-BLANK-OR-DIAGRAM-P (BP-LINE BP))      (IF FILL-PREFIX-P  NIL  (AND (BP-LOOKING-AT-LIST BP *TEXT-JUSTIFIER-ESCAPE-LIST*)       (OR (BP-LOOKING-AT-LIST BP *PARAGRAPH-DELIMITER-LIST*)   (BP-LOOKING-AT-LIST BP *PAGE-DELIMITER-LIST*)))))) (DEFUN BP-AT-PARAGRAPH-TERMINATOR (BP &OPTIONAL (FILL-PREFIX-P (NOT (ZEROP (LENGTH *FILL-PREFIX*)))))  "T if BP is on a line which terminates a preceding paragraph."  (OR (LINE-BLANK-OR-DIAGRAM-P (BP-LINE BP))      (IF FILL-PREFIX-P  (NOT (LOOKING-AT BP *FILL-PREFIX*))  (OR (BP-LOOKING-AT-LIST BP *PARAGRAPH-DELIMITER-LIST*)      (BP-LOOKING-AT-LIST BP *PAGE-DELIMITER-LIST*))))) (DEFUN FORWARD-OVER-BLANK-OR-TEXT-JUSTIFIER-LINES (BP)  "Return a bp to the first non-paragraph-terminating line past BP,or to the end of *INTERVAL*."  (DO ((BP BP (BEG-LINE BP 1)))      ((OR (NULL BP) (NOT (BP-AT-PARAGRAPH-DELIMITER BP)))       (OR BP (INTERVAL-LAST-BP *INTERVAL*))))) (DEFUN FORWARD-ATOM (BP &OPTIONAL (TIMES 1) FIXUP-P)  "Return a bp which is forward across TIMES Lisp-atoms from BP.TIMES negative means move backwards.FIXUP-P non-NIL means if go past beginning or end return a bp to there; otherwise return NIL in that case."  (ATOM-WORD-SYNTAX-BIND (FORWARD-WORD BP TIMES FIXUP-P))) (DEFUN FORWARD-SENTENCE (BP &OPTIONAL (TIMES 1) FIXUP-P)  "Return a bp to the TIMES'th sentence-end forward from BP.TIMES negative means move backwards past that many sentence-beginnings.Every paragraph beginning or end is also a sentence beginning or end.FIXUP-P non-NIL means if go past beginning or end return a bp to there; otherwise return NIL in that case."  (COND ((ZEROP TIMES) (COPY-BP BP))((PLUSP TIMES) (DO (PARA-BP      (TIME 0 (1+ TIME))      (STATE NIL)      (FIRST-P T NIL)      (CH))     ((OR (>= TIME TIMES) (NULL BP)) BP)   (SETQ BP (FORWARD-OVER (IF FIRST-P '(#\NEWLINE) *WHITESPACE-CHARS*)  BP))   (SETQ PARA-BP (FORWARD-PARAGRAPH BP 1))   (IF PARA-BP       (LET ((TEM (BACKWARD-OVER *WHITESPACE-CHARS* PARA-BP))) (IF (BP-< BP TEM)     (SETQ PARA-BP TEM)     (PROGN       (SETQ PARA-BP (FORWARD-PARAGRAPH PARA-BP 1))       (IF PARA-BP   (SETQ PARA-BP (BACKWARD-OVER *WHITESPACE-CHARS* PARA-BP))   (SETQ PARA-BP (INTERVAL-LAST-BP *INTERVAL*))))))       (SETQ PARA-BP (INTERVAL-LAST-BP *INTERVAL*)))   (SETQ BP (CHARMAP (BP PARA-BP (AND (OR STATE FIXUP-P) (COPY-BP PARA-BP)))      (SETQ CH (CHARMAP-CH-CHAR))      (AND STATE;If special character last time...   (COND ((OR (CHAR= CH #\NEWLINE)                ;".<cr>" or ". <cr>" win      (AND (EQ STATE 'SP) (CHAR= CH #\SPACE)));".  " wins  (CHARMAP-RETURN (COND ((EQ STATE 'DOT);".<cr>" (CHARMAP-BP-BEFORE))(T (FORWARD-CHAR (CHARMAP-BP-BEFORE) -1))))) ((AND (EQ STATE 'DOT) (CHAR= CH #\SPACE));". "  (SETQ STATE 'SP)) ((AND (EQ STATE 'DOT) (MEMBER CH '(#\" #\' #\) #\]) :TEST #'EQ))) (T  (SETQ STATE NIL))))      (COND ((MEMBER CH '(#\. #\! #\?) :TEST #'EQ)     (SETQ STATE 'DOT)))))))(T (DO ((TIME 0 (1- TIME))      (STATE NIL)      (NFROBS)      (PARA-BP)      (CH))     ((<= TIME TIMES)      (FORWARD-OVER *WHITESPACE-CHARS* (FORWARD-CHAR BP NFROBS)))   (SETQ BP (BACKWARD-OVER '(#\NEWLINE #\SPACE #\TAB) BP))   (SETQ PARA-BP (FORWARD-PARAGRAPH BP -1 T))   (SETQ BP (BACKWARD-OVER '(#\NEWLINE #\SPACE #\" #\' #\) #\]) BP) NFROBS 0)   (SETQ BP (RCHARMAP (BP PARA-BP (AND FIXUP-P (COPY-BP PARA-BP)))      (SETQ CH (RCHARMAP-CH-CHAR))      (COND ((MEMBER STATE '(CR SPSP) :TEST #'EQ)     (DO NIL ((NOT (MEMBER CH '(#\SPACE #\" #\' #\) #\]) :TEST #'EQ)))       (RCHARMAP-DECREMENT (AND FIXUP-P (COPY-BP PARA-BP)))       (SETQ CH (RCHARMAP-CH-CHAR)     NFROBS (1+ NFROBS)))     (AND (MEMBER CH '(#\. #\! #\?) :TEST #'EQ)  (RCHARMAP-RETURN (RCHARMAP-BP-AFTER)))     (SETQ STATE ()   NFROBS 0)))      (COND ((MEMBER STATE '(SP SPSP) :TEST #'EQ)     (SETQ STATE (AND (CHAR= CH #\SPACE) 'SPSP)))    ((CHAR= CH #\SPACE)     (SETQ STATE 'SP))    ((CHAR= CH #\NEWLINE)     (SETQ STATE 'CR)))))   (OR BP (RETURN NIL)))))) ;;; Not-so-standard motion functions.(DEFUN DEFUN-INTERVAL (BP &OPTIONAL (TIMES 1) FIXUP-P (COMMENTS-P T) (TOP-BLANK-P NIL))  "Return an interval surrounding the defun that BP is within, or NIL.If TIMES is > 1, includes additional defuns after that one.COMMENTS-P non-NIL means include comments before the defun.TOP-BLANK-P non-NIL along with COMMENTS-P means include one blank line (if any) before anything else.The second value is the line which opens the list structure of the defun that the interval contains."  (DECLARE (VALUES INTERVAL DEFINITION-LINE))  (PROG (BP1 BP2 BP3 BP4 SBP)(COND ((NULL (SETQ BP1 (FORWARD-DEFUN BP -1)))       (SETQ BP1 (BEG-LINE BP 0))       (COND ((= (LIST-SYNTAX (BP-CHAR BP1)) LIST-OPEN)      (GO BUFBEG1))     (T      (GO BUFBEG)))))(OR (SETQ BP2 (FORWARD-SEXP BP1))    (IF (NOT FIXUP-P)(RETURN NIL)(SETQ BP2 (BEG-LINE (BACKWARD-OVER-COMMENT-LINES (FORWARD-DEFUN BP1 1 T) TOP-BLANK-P)    -1))))(OR (BP-< (END-LINE BP2) BP)    ;; We were in the middle of the defun.    (GO FOUND))(SETQ BP BP1)     BUFBEG(COND ((NULL (SETQ BP1 (FORWARD-DEFUN BP)))       (AND BP2    (SETQ BP1 (FORWARD-DEFUN BP2 -1))    (GO FOUND));At end of buffer, take previous       (RETURN NIL)))     BUFBEG1(OR (SETQ BP2 (FORWARD-SEXP BP1))    (RETURN NIL))     FOUND;; At this point, BP1 and BP2 surround a "defun".  Now we should grab any;; comment lines and intervening blank lines before the beginning, and the;; rest of the last line.(AND (> TIMES 1)     (SETQ BP2 (FORWARD-SEXP BP2 (1- TIMES) T)))(SETQ SBP BP1);Save real starting line     CONTIN(AND COMMENTS-P     (SETQ BP1 (BACKWARD-OVER-COMMENT-LINES BP1 TOP-BLANK-P NIL)))(SETQ BP3 (FORWARD-OVER *BLANKS* BP2))(AND BP3 (OR (= (LIST-SYNTAX (BP-CHAR BP3)) LIST-COMMENT)     (CHAR= (BP-CH-CHAR BP3) #\NEWLINE))     (SETQ BP2 (BEG-LINE BP2 1 T)));; Now try to find any extra close-parens because of a LOCAL-DECLARE(SETQ BP3 (FORWARD-OVER '(#\)) BP2))(AND (NOT (BP-= BP2 BP3))     (SETQ BP4 (FORWARD-SEXP BP3 (- TIMES)))     (BP-< BP4 BP1)     (SETQ BP1 BP4   BP2 BP3)     (GO CONTIN));; Now try to find a package prefix(SETQ BP3 (BACKWARD-OVER-PACKAGE-PREFIX BP1))(WHEN BP3  (SETQ BP1 BP3)  (GO CONTIN))(RETURN (VALUES (CREATE-INTERVAL BP1 BP2) SBP)))) (DEFUN BACKWARD-OVER-PACKAGE-PREFIX (BP)  "Return a bp to the start of the package prefix before BP, or NIL if none."  (LET (BP3 BP4)    (SETQ BP3 (BACKWARD-OVER *WHITESPACE-CHARS* BP)  BP4 (FORWARD-WORD BP3 -1 T))    (AND (CHAR-EQUAL (BP-CHAR-BEFORE BP3) #\:) (BEG-LINE-P BP4) BP4))) (DEFUN BACKWARD-OVER-COMMENT-LINES (BP &OPTIONAL (TOP-BLANK-P T) (UP-P T)    &AUX (LAST-GOOD-LINE (BP-LINE BP)))  "Return a bp back from BP across all comment lines.Blank lines are also skipped if more comment lines are reached thus.TOP-BLANK-P non-NIL means skip one blank line past the last comment line.All blank lines at the beginning of the buffer are skipped.UP-P means skip any list-structure that precedes BP but is notmatched until after BP."  (DO ((LINE (LINE-PREVIOUS (BP-LINE BP)) (LINE-PREVIOUS LINE)))      ((NULL LINE)       (SETQ LAST-GOOD-LINE (BP-LINE (INTERVAL-FIRST-BP *INTERVAL*))))    (CASE (LINE-TYPE LINE)  (:BLANK)  (:COMMENT (SETQ LAST-GOOD-LINE LINE))  (:NORMAL (IF (AND UP-P (LINE-OPENS-PARENS LINE))       (SETQ LAST-GOOD-LINE LINE)       (RETURN)))  (OTHERWISE (RETURN))))  (COND ((EQ LAST-GOOD-LINE (BP-LINE (INTERVAL-FIRST-BP *INTERVAL*))))((NOT TOP-BLANK-P))((MEMBER (LINE-TYPE (LINE-PREVIOUS LAST-GOOD-LINE)) '(:BLANK :FORM) :TEST #'EQ) (SETQ LAST-GOOD-LINE (LINE-PREVIOUS LAST-GOOD-LINE))))  (IF (EQ (LINE-TYPE LAST-GOOD-LINE) :FORM)      (END-OF-LINE LAST-GOOD-LINE)      (BEG-OF-LINE LAST-GOOD-LINE))) (DEFUN SKIP-OVER-BLANK-LINES-AND-COMMENTS (BP &OPTIONAL FIXUP-P)  "Return a bp to the front of the first non-blank non-comment line after BP.If there is non-blank non-comment data following BP on the same linewe return a pointer to that.This is good for finding the next interesting piece of lisp code after a point.FIXUP-P non-NIL means return end of buffer if nothing is found; otherwise return NIL."  (SETQ BP (FORWARD-OVER *BLANKS* BP))  (AND BP (OR (CHAR= (BP-CH-CHAR BP) #\;)      (CHAR= (BP-CH-CHAR BP) #\NEWLINE))       (DO () (NIL) (SETQ BP (BEG-LINE BP 1)) (OR BP (RETURN NIL)) (CASE (LINE-TYPE (BP-LINE BP))       ((:BLANK :COMMENT :FORM))       (OTHERWISE (RETURN BP)))))  (OR BP (AND FIXUP-P      (COPY-BP (INTERVAL-LAST-BP *INTERVAL*))))) (DEFUN FORWARD-OVER-BLANK-OR-PAGE-LINES (BP &OPTIONAL FIXUP-P)  "Return a bp to the front of the first non-blank non-page-separator line after BP.FIXUP-P non-NIL means return end of buffer if nothing is found; otherwise return NIL."  (DO () (NIL)    (SETQ BP (BEG-LINE BP 1))    (OR BP (RETURN NIL))    (CASE (LINE-TYPE (BP-LINE BP))  ((:BLANK :FORM))  (OTHERWISE (RETURN BP))))  (OR BP (AND FIXUP-P      (COPY-BP (INTERVAL-LAST-BP *INTERVAL*))))) (DEFUN BEG-LINE (BP &OPTIONAL (TIMES 0) FIXUP-P)  "Return a bp to the start of the line TIMES lines down from BP.TIMES = 0 means the same line BP is on.  TIMES negative moves up.FIXUP-P means return beginning or end of buffer if try to move past; otherwise return NIL in that case."  (COND ((>= TIMES 0) (DO ((LINE (BP-LINE BP) (LINE-NEXT LINE))      (I TIMES (1- I))      (LAST-LINE (BP-LINE (INTERVAL-LAST-BP *INTERVAL*))))     (NIL)   (COND ((EQ LINE LAST-LINE)  (RETURN (IF (OR (<= I 0) FIXUP-P)      (CREATE-BP LINE (IF (<= I 0)  0  (BP-INDEX (INTERVAL-LAST-BP *INTERVAL*))))      NIL))) ((<= I 0)  (RETURN (CREATE-BP LINE 0))))))(T (DO ((LINE (BP-LINE BP) (LINE-PREVIOUS LINE))      (I TIMES (1+ I))      (FIRST-LINE (BP-LINE (INTERVAL-FIRST-BP *INTERVAL*))))     (NIL)   (COND ((EQ LINE FIRST-LINE)  (RETURN (IF (OR (>= I 0) FIXUP-P)      (CREATE-BP LINE (BP-INDEX (INTERVAL-FIRST-BP *INTERVAL*)))      NIL))) ((>= I 0)  (RETURN (CREATE-BP LINE 0)))))))) (DEFUN END-LINE (BP &OPTIONAL (TIMES 0) FIXUP-P)  "Return a bp to the end of the line TIMES lines down from BP.TIMES = 0 means the same line BP is on.  TIMES negative moves up.FIXUP-P means return beginning or end of buffer if try to move past; otherwise return NIL in that case."  (COND ((>= TIMES 0) (DO ((LINE (BP-LINE BP) (LINE-NEXT LINE))      (I TIMES (1- I))      (LAST-LINE (BP-LINE (INTERVAL-LAST-BP *INTERVAL*))))     (NIL)   (COND ((EQ LINE LAST-LINE)  (RETURN (IF (OR (<= I 0) FIXUP-P)      (CREATE-BP LINE (BP-INDEX (INTERVAL-LAST-BP *INTERVAL*)))      NIL))) ((<= I 0)  (RETURN (CREATE-BP LINE (LINE-LENGTH LINE)))))))(T (DO ((LINE (BP-LINE BP) (LINE-PREVIOUS LINE))      (I TIMES (1+ I))      (FIRST-LINE (BP-LINE (INTERVAL-FIRST-BP *INTERVAL*))))     (NIL)   (COND ((EQ LINE FIRST-LINE)  (RETURN (IF (OR (>= I 0) FIXUP-P)      (CREATE-BP LINE (IF (>= I 0)  (LINE-LENGTH LINE)  (BP-INDEX (INTERVAL-FIRST-BP *INTERVAL*))))      NIL))) ((>= I 0)  (RETURN (CREATE-BP LINE (LINE-LENGTH LINE))))))))) (DEFUN FORWARD-OVER (LIST BP &OPTIONAL (LIMIT-BP (INTERVAL-LAST-BP *INTERVAL*)))  "Return a bp to the first char following BP that is not in LIST.LIST is a list of characters."  (CHARMAP (BP LIMIT-BP (CHARMAP-BP-BEFORE))    (IF (NOT (MEMBER (CHARMAP-CH-CHAR) LIST :TEST #'EQ))(CHARMAP-RETURN (CHARMAP-BP-BEFORE))))) (DEFUN BACKWARD-OVER (LIST BP &OPTIONAL (LIMIT-BP (INTERVAL-FIRST-BP *INTERVAL*)))  "Return a bp after the first char found backward from BP that is not in LIST.LIST is a list of characters."  (RCHARMAP (BP LIMIT-BP (RCHARMAP-BP-AFTER))    (IF (NOT (MEMBER (RCHARMAP-CH-CHAR) LIST :TEST #'EQ))(RCHARMAP-RETURN (RCHARMAP-BP-AFTER))))) (DEFUN DELETE-OVER (LIST BP)  "Delete all characters in LIST that follow BP."  (DELETE-INTERVAL BP (FORWARD-OVER LIST BP) T)) (DEFUN DELETE-BACKWARD-OVER (LIST BP)  "Delete all characters in LIST that precede BP."  (DELETE-INTERVAL (BACKWARD-OVER LIST BP) BP T)) (DEFUN DELETE-AROUND (LIST BP)  "Delete all characters in LIST on either side of BP."  (DELETE-INTERVAL (BACKWARD-OVER LIST BP) (FORWARD-OVER LIST BP) T)) (DEFUN FORWARD-OVER-MATCHING-DELIMITERS (BP &OPTIONAL (TIMES 1) FIXUP-P (LEVEL 0) OPEN CLOSE)  "Return a bp which is TIMES balanced objects forward from BP.TIMES may be negative meaning go backward.FIXUP-P non-NIL means if go past beginning or end return a bp to there; otherwise return NIL in that case.LEVEL nonzero means move up that many levels of list structure.OPEN and CLOSE can specify the pair of delimiters to use, but usually they are deduced form the text being moved over."  (COND ((ZEROP TIMES) (COPY-BP BP))((PLUSP TIMES) (LET ((TIME 0)       (LAST-BP (INTERVAL-LAST-BP *INTERVAL*)))   (CHARMAP (BP LAST-BP (IF FIXUP-P (COPY-BP LAST-BP) NIL))     (LET ((CHAR (CHARMAP-CH-CHAR)))       (COND ((NULL OPEN)      (DO ((L *MATCHING-DELIMITER-LIST* (CDR L)))  ((NULL L)   NIL)(COND ((CHAR= CHAR (CAAR L))       (SETQ OPEN CHAR     CLOSE (CADAR L)     LEVEL 1)       (RETURN)))))     ((CHAR= CHAR CLOSE)      (AND (<= (SETQ LEVEL (1- LEVEL)) 0)   (>= (SETQ TIME (1+ TIME)) TIMES)   (CHARMAP-RETURN (CHARMAP-BP-AFTER))))     ((CHAR= CHAR OPEN)      (SETQ LEVEL (1+ LEVEL))))))))(T (LET ((TIME 0)       (FIRST-BP (INTERVAL-FIRST-BP *INTERVAL*)))   (RCHARMAP (BP FIRST-BP (IF FIXUP-P      (COPY-BP FIRST-BP)      NIL))     (LET ((CHAR (RCHARMAP-CH-CHAR)))       (COND ((NULL OPEN)      (DO ((L *MATCHING-DELIMITER-LIST* (CDR L)))  ((NULL L) NIL)(COND ((CHAR= CHAR (CADAR L))       (SETQ CLOSE CHAR     CLOSE (CAAR L)     LEVEL -1)       (RETURN)))))     ((CHAR= CHAR OPEN)      (AND (>= (SETQ LEVEL (1+ LEVEL)) 0)   (<= (SETQ TIME (1- TIMES)) TIMES)   (RCHARMAP-RETURN (RCHARMAP-BP-BEFORE))))     ((CHAR= CHAR CLOSE)      (SETQ LEVEL (1- LEVEL)))))))))) (DEFUN FORWARD-TO-NEXT-LINE-WITH-NON-WHITE-SPACE-START (BP)  (DO ((LINE (LINE-NEXT (BP-LINE BP)) (LINE-NEXT LINE)))      ((NULL LINE) NIL)    (WHEN (AND (> (LINE-LENGTH LINE) 0)(NOT (MEMBER (AREF LINE 0) '(#\SPACE #\NEWLINE #\TAB) :TEST #'EQ)))      (RETURN (CREATE-BP LINE 0))))) AR #\NEWLINE STREAM))  (FORMAT STREAM "~A