Changes between Initial Version and Version 1 of HemlockUser/EditingLisp

Nov 5, 2007, 5:36:28 PM (13 years ago)



  • HemlockUser/EditingLisp

    v1 v1  
     3= 8 Editing Lisp =
     5Hemlock provides a large number of powerful commands for editing Lisp
     6code. It is possible for a text editor to provide a much higher level
     7of support for editing Lisp than ordinary programming languages, since
     8its syntax is much simpler.
     10== 8.1 Lisp Mode ==
     12Lisp mode is a major mode used for editing Lisp code. Although most
     13Lisp specific commands are globally bound, Lisp mode is necessary to
     14enable Lisp indentation, commenting, and
     15parenthesis-matching. Whenever the user or some Hemlock mechanism
     16turns on Lisp mode, the mode's setup includes locally setting Current
     17Package (see section 9.3) in that buffer if its value is non-existent
     18there; the value used is "USER".
     20Lisp Mode                [Command]
     22This command sets the major mode of the current buffer to Lisp.
     25== 8.2 Form Manipulation ==
     27These commands manipulate Lisp forms, the printed representations of
     28Lisp objects. A form is either an expression balanced with respect to
     29parentheses or an atom such as a symbol or string.
     31Forward Form    (bound to C-M-f)         [Command]
     33Backward Form   (bound to C-M-b)         [Command]
     35Forward Form moves to the end of the current or next form, while
     36Backward Form moves to the beginning of the current or previous
     37form. A prefix argument is treated as a repeat count.
     41Forward Kill Form       (bound to C-M-k)         [Command]
     43Backward Kill Form      (bound to C-M-Delete, C-M-Backspace)     [Command]
     45Forward Kill Form kills text from the point to the end of the current
     46form. If at the end of a list, but inside the close parenthesis, then
     47kill the close parenthesis. Backward Kill Form is the same, except it
     48goes in the other direction. A prefix argument is treated as a repeat
     53Mark Form       (bound to C-M-@)         [Command]
     55This command sets the mark at the end of the current or next form.
     58Transpose Forms         (bound to C-M-t)         [Command]
     60This command transposes the forms before and after the point and moves
     61forward. A prefix argument is treated as a repeat count. If the prefix
     62argument is negative, then the point is moved backward after the
     63transposition is done, reversing the effect of the equivalent positive
     68Insert ()       (bound to M-()   [Command]
     70This command inserts an open and a close parenthesis, leaving the
     71point inside the open parenthesis. If a prefix argument is supplied,
     72then the close parenthesis is put at the end of the form that many
     73forms from the point.
     77Extract Form             [Command]
     79This command replaces the current containing list with the next
     80form. The entire affected area is pushed onto the kill ring. If an
     81argument is supplied, that many upward levels of list nesting is
     82replaced by the next form. This is similar to Extract List, but this
     83command is more generally useful since it works on any kind of form;
     84it is also more intuitive since it operates on the next form as many
     85Lisp mode commands do.
     87== 8.3 List Manipulation ==
     89List commands are similar to form commands, but they only pay
     90attention to lists, ignoring any atomic objects that may appear. These
     91commands are useful because they can skip over many symbols and move
     92up and down in the list structure.
     94Forward List    (bound to C-M-n)         [Command]
     96Backward List   (bound to C-M-p)         [Command]
     98Forward List moves the point to immediately after the end of the next
     99list at the current level of list structure. If there is not another
     100list at the current level, then it moves up past the end of the
     101containing list. Backward List is identical, except that it moves
     102backward and leaves the point at the beginning of the list. The prefix
     103argument is used as a repeat count.
     106Forward Up List         (bound to C-M-))         [Command]
     108Backward Up List        (bound to C-M-(, C-M-u)  [Command]
     110Forward Up List moves to after the end of the enclosing list. Backward
     111Up List moves to the beginning. The prefix argument is used as a
     112repeat count.
     116Down List       (bound to C-M-d)         [Command]
     118This command moves to just after the beginning of the next list. The
     119prefix argument is used as a repeat count.
     123Extract List    (bound to C-M-x)         [Command]
     125This command "extracts" the current list from the list which contains
     126it. The outer list is deleted, leaving behind the current list. The
     127entire affected area is pushed on the kill ring, so that this possibly
     128catastrophic operation can be undone. The prefix argument is used as a
     129repeat count.
     131== 8.4 Defun Manipulation ==
     133A defun is a list whose open parenthesis is against the left
     134margin. It is called this because an occurrence of the defun top level
     135form usually satisfies this definition, but other top level forms such
     136as a defstruct and defmacro work just as well.
     138End of Defun    (bound to C-M-e, C-M-])  [Command]
     140Beginning of Defun      (bound to C-M-a, C-M-[)  [Command]
     142End of Defun moves to the end of the current or next defun. Beginning
     143of Defun moves to the beginning of the current or previous defun. End
     144of Defun will not work if the parentheses are not balanced.
     147Mark Defun      (bound to C-M-h)         [Command]
     149This command puts the point at the beginning and the mark at the end
     150of the current or next defun.
     152== 8.5 Indentation ==
     154One of the most important features provided by Lisp mode is automatic
     155indentation of Lisp code. Since unindented Lisp is unreadable, poorly
     156indented Lisp is hard to manage, and inconsistently indented Lisp is
     157subtly misleading. See section 7.2 for a description of the
     158general-purpose indentation commands. Lisp mode uses these indentation
     161 * If in a semicolon (;) comment, then use the standard comment
     162   indentation rules. See page 7.1.
     164 * If in a quoted string, then indent to the column one greater than
     165   the column containing the opening double quote. This is exactly
     166   what you want in function documentation strings and wrapping error
     167   strings.
     169 * If there is no enclosing list, then use no indentation.
     171 * If enclosing list resembles a call to a known macro or
     172   special-form, then the first few arguments are given greater
     173   indentation and the first body form is indented two spaces. If the
     174   first special argument is on the same line as the beginning of the
     175   form, then following special arguments will be indented to the
     176   start of the first special argument, otherwise all special
     177   arguments are indented four spaces.
     179 * If the previous form starts on its own line, then the indentation
     180   is copied from that form. This rule allows the default indentation
     181   to be overridden: once a form has been manually indented to the
     182   user's satisfaction, subsequent forms will be indented in the same
     183   way.
     185 * If the enclosing list has some arguments on the same line as the
     186   form start, then subsequent arguments will be indented to the start
     187   of the first argument.
     189 * If the enclosing list has no argument on the same line as the form
     190   start, then arguments will be indented one space.
     192Indent Form     (bound to C-M-q)         [Command]
     194This command indents all the lines in the current form, leaving the
     195point unmoved. This is undo-able.
     199Fill Lisp Comment Paragraph              [Command]
     201Fill Lisp Comment Paragraph Confirm     (initial value t)        [Variable]
     203This fills a flushleft or indented Lisp comment. This also fills Lisp
     204string literals using the proper indentation as a filling prefix. When
     205invoked outside of a comment or string, this tries to fill all
     206contiguous lines beginning with the same initial, non-empty
     207blankspace. When filling a comment, the current line is used to
     208determine a fill prefix by taking all the initial whitespace on the
     209line, the semicolons, and any whitespace following the
     212When invoked outside of a comment or string, this command prompts for
     213confirmation before filling. It is useful to use this for filling long
     214export lists or other indented text or symbols, but since this is a
     215less common use, this command tries to make sure that is what you
     216wanted. Setting Fill Lisp Comment Paragraph Confirm to nil inhibits
     217the confirmation prompt.
     221Defindent       (bound to C-M-#)         [Command]
     223This command prompts for the number of special arguments to associate
     224with the symbol at the beginning of the current or containing
     229Indent Defanything      (initial value 2)        [Variable]
     231This is the number of special arguments implicitly assumed to be
     232supplied in calls to functions whose names begin with "def". If set to
     233nil, this feature is disabled.
     236Move Over )     (bound to M-))   [Command]
     238This command moves past the next close parenthesis and then does the
     239equivalent of Indent New Line.
     241== 8.6 Parenthesis Matching ==
     243Another very important facility provided by Lisp mode is parenthesis
     244matching. Two different styles of parenthesis matching are supported:
     245highlighting and pausing.
     247Highlight Open Parens   (initial value t)        [Variable]
     249Open Paren Highlighting Font    (initial value nil)      [Variable]
     251When Highlight Open Parens is true, and a close paren is immediately
     252before the point, then Hemlock displays the matching open paren in
     253Open Paren Highlighting Font.
     255Open Paren Highlighting Font is the string name of the font used for
     256paren highlighting. Only the "(" character is used in this font. If
     257null, then a reasonable default is chosen. The highlighting font is
     258read at initialization time, so this variable must be set before the
     259editor is first entered to have any effect.
     263Lisp Insert )            [Command]
     265Paren Pause Period      (initial value 0.5)      [Variable]
     267This command inserts a close parenthesis and then attempts to display
     268the matching open parenthesis by placing the cursor on top of it for
     269Paren Pause Period seconds. If there is no matching parenthesis then
     270beep. If the matching parenthesis is off the top of the screen, then
     271the line on which it appears is displayed in the echo area. Paren
     272pausing may be disabled by setting Paren Pause Period to
     276The initial values shown for Highlight Open Parens and Paren Pause
     277Period are only approximately correct. Since paren highlighting is
     278only meaningful in Lisp mode, Highlight Open Parens is false globally,
     279and has a mode-local value of t in Lisp mode. It it redundant to do
     280both kinds of paren matching, so there is also a binding of Paren
     281Pause Period to nil in Lisp mode.
     283Paren highlighting is only supported under X windows, so the above
     284defaults are conditional on the device type. If Hemlock is started on
     285a terminal, the initialization code makes Lisp mode bindings of nil
     286and 0.5 for Highlight Open Parens and Paren Pause Period. Since these
     287alternate default bindings are made at initialization time, the only
     288way to affect them is to use the after-editor-initializations
     291== 8.7 Parsing Lisp ==
     293Lisp mode has a fairly complete knowledge of Lisp syntax, but since it
     294does not use the reader, and must work incrementally, it can be
     295confused by legal constructs. Lisp mode totally ignores the
     296read-table, so user-defined read macros have no effect on the
     297editor. In some cases, the values the Lisp Syntax character attribute
     298can be changed to get a similar effect.
     300Lisp commands consistently treat semicolon (;) style comments as
     301whitespace when parsing, so a Lisp command used in a comment will
     302affect the next (or previous) form outside of the comment. Since #|
     303... |# comments are not recognized, they can used to comment out code,
     304while still allowing Lisp editing commands to be used.
     306Strings are parsed similarly to symbols. When within a string, the
     307next form is after the end of the string, and the previous form is the
     308beginning of the string.
     310Defun Parse Goal        (initial value 2)        [Variable]
     312Maximum Lines Parsed    (initial value 500)      [Variable]
     314Minimum Lines Parsed    (initial value 50)       [Variable]
     316In order to save time, Lisp mode does not parse the entire buffer
     317every time a Lisp command is used. Instead, it uses a heuristic to
     318guess the region of the buffer that is likely to be interesting. These
     319variables control the heuristic.
     321Normally, parsing begins and ends on defun boundaries (an open
     322parenthesis at the beginning of a line). Defun Parse Goal specifies
     323the number of defuns before and after the point to parse. If this
     324parses fewer lines than Minimum Lines Parsed, then parsing continues
     325until this lower limit is reached. If we cannot find enough defuns
     326within Maximum Lines Parsed lines then we stop on the farthest defun
     327found, or at the point where we stopped if no defuns were
     330When the heuristic fails, and does not parse enough of the buffer,
     331then commands usually act as though a syntax error was detected. If
     332the parse starts in a bad place (such as in the middle of a string),
     333then Lisp commands will be totally confused. Such problems can usually
     334be eliminated by increasing the values of some of these
     338Parse Start Function    (initial value start-of-parse-block)     [Variable]
     340Parse End Function      (initial value end-of-parse-block)       [Variable]
     342These variables determine the region of the buffer parsed. The values
     343are functions that take a mark and move it to the start or end of the
     344parse region. The default values implement the heuristic described