CCL
-
- CCL
+
+ require and
provide, access to foreign interface
- information (see The
+ information (see The
Interface Database) and the Lisp build process (see
Building Clozure CL from its Source
@@ -1531,5 +1625,5 @@
--set-lisp-heap-gc-threshold
n). Sets the Lisp gc threshold to
- n. (see Section 15.3, âGC Page reclamation policyâ
+ n. (see Section 16.3, âGC Page reclamation policyâ
--heap-reserve). Reserves
n bytes for heap expansion. The
- default is 549755813888. (see Section 15.1, âHeap space allocationâ)
+ default is 549755813888. (see Section 16.1, âHeap space allocationâ)
-S n (or
--stack-size n). Sets the size of the
- initial control stack to n. (see Section 6.3.1, âThread Stack Sizesâ)
n. (see Section 7.3.1, âThread Stack Sizesâ)
--thread-stack-size
n). Sets the size of the first
- thread's stack to n. (see Section 6.3.1, âThread Stack Sizesâ)
+ thread's stack to n. (see Section 7.3.1, âThread Stack Sizesâ)
The following terms are used in subsequent sections; it may be helpful to refer to these definitions.
-fasl
+ fasl
files are the object files produced
by The Lisp
+ The Lisp
kernel is a C program with a fair amount of
platform-specific assembly language code. Its basic job is to
@@ -1772,5 +1866,5 @@
files on different platforms; see
Table 3.1, âPlatform-specific filename conventionsâ. A heap
+ A heap
image is a file that can be quickly mapped into a
process's address space. Conceptually, it's not too different
@@ -1783,5 +1877,5 @@
standard full heap image files on different platforms; see
Table 3.1, âPlatform-specific filename conventionsâ. A bootstrapping image is a minimal
+ A bootstrapping image is a minimal
heap image used in the process of building Clozure CL itself. The
bootstrapping image contains just enough code to load the rest
@@ -1795,5 +1889,5 @@
as-yet-unsupported ones) has a uniquely named subdirectory of
-
+
TRACE {
-
+
CCL:*TRACE-LEVEL* [Variable]
Variable bound to the current nesting level during execution of before and after trace actions. The default printing actions use it to determine the amount of indentation.
-
+
CCL:*TRACE-MAX-INDENT* [Variable]
The default before and after print actions will not indent by more than the value of ccl:*trace-max-indent* regardless of the current trace level.
-
+
CCL:TRACE-FUNCTION compile-file. fasl files store the
@@ -1762,5 +1856,5 @@
see
Table 3.1, âPlatform-specific filename conventionsâ ccl/lisp-kernel/; each such
-
+
contains a Makefile and may contain some auxiliary files (linker
scripts, etc.) that are used to build the lisp kernel on a
@@ -2580,5 +2674,10 @@
keyword
global-value}* {spec |
@@ -3068,15 +3167,15 @@
spec &key {keyword value}* [Function]
- + CCL:*TRACE-BAR-FREQUENCY* [Variable]
@@ -3151,5 +3250,5 @@@@ -3231,5 +3330,5 @@
@@ -3270,5 +3369,5 @@
@@ -3442,5 +3541,5 @@
The value of this variable is used when :EXTERNAL-FORMAT is @@ -3468,5 +3567,5 @@
The value of this variable is used when an external-format @@ -3500,5 +3599,5 @@
domain---This is used to indicate where the external @@ -3534,5 +3633,5 @@
Despite the function's name, it doesn't necessarily create a @@ -3707,5 +3806,5 @@
@@ -3723,5 +3822,5 @@ @@ -3751,5 +3850,5 @@ @@ -3773,5 +3872,5 @@@@ -4269,5 +4368,5 @@
@@ -4318,5 +4417,5 @@
@@ -4371,5 +4470,5 @@
Clozure CL sets up logical pathname translations for logical hosts: ccl and home
The CCL logical host should point to the
ccl directory. It is used for a variety of
@@ -4480,5 +4579,5 @@
@@ -4530,5 +4629,5 @@
@@ -4653,5 +4752,5 @@ platforms.
-
+
CCL:MAP-FILE-TO-IVECTOR
pathname
@@ -4713,5 +4812,5 @@
a memory error.
-
+
CCL:UNMAP-IVECTOR
displaced-array
@@ -4725,5 +4824,5 @@
target is an empty vector (of length zero).
-
+
CCL:MAP-FILE-TO-OCTET-VECTOR
pathname
@@ -4735,5 +4834,5 @@
bytes.
-
+
CCL:UNMAP-OCTET-VECTOR
displaced-array
@@ -4774,5 +4873,5 @@
static.
Clozure CL provides the
function CCL:SAVE-APPLICATION, which creates a file
@@ -4908,5 +5007,5 @@
converted, because address 0 can always be relied upon to refer to
the same thing.
As of Clozure CL 1.2, the constant CCL:+NULL-PTR+
refers to a MACPTR object that points to address 0.
ccl64 script.
-
+
SAVE-APPLICATION
@@ -5194,5 +5293,5 @@
@@ -5241,5 +5340,5 @@
@@ -5299,5 +5398,5 @@
@@ -5473,5 +5572,5 @@
@@ -5507,5 +5606,5 @@
@@ -5593,5 +5692,5 @@
do:
@@ -5783,7 +5881,7 @@
(do-this)
(setq that ...) ...)
-(init-this-and-that)
-
+(init-this-and-that)
+
Then you can see the coverage information in the definition of
- When you execute function loaded from instrumented fasl files, they
- will record coverage information every time they are executed. The
- system keeps track of which instrumented files have been loaded.
+ When you execute functions loaded from instrumented fasl files, they
+ will record coverage information every time they are executed.
+ You can examine that information by calling
+ While recording coverage, you can collect incremental coverage deltas between any two points
+ in time. You might do this while running a test suite, to record the coverage for
+ each test, for example:
+ creates a hash table mapping a test to a representation of all coverage recorded while running the
+ test. This hash table can then be passed to
The following functions can be used to manage the coverage data:
@@ -5837,5 +5960,5 @@
@@ -5895,5 +6018,5 @@
@@ -5917,10 +6040,10 @@
Gets rid of the information about which instrumented files have
- been loaded, so ccl:report-coverage will not report any files,
- and ccl:save-coverage-in-file will not save any info, until more
+ been loaded, so
@@ -5949,5 +6072,5 @@
coverage state later. This allows you to combine multiple runs
or continue in a later session. Equivalent to
- (ccl:write-coverage-to-file (ccl:save-coverage) pathname).
+
@@ -5977,9 +6100,9 @@
info is only restored for files that have been loaded in this
session. For example if in a previous session you had loaded
- "foo.lx86fsl" and then saved the coverage info, in this session
- you must load the same "foo.lx86fsl" before calling
- restore-coverage-from-file in order to retrieve the stored
- coverage info for "foo". Equivalent to (ccl:restore-coverage
- (ccl:read-coverage-from-file pathname)).
+
Returns a snapshot of the current coverage data. A snapshot is a
copy of the current coverage state. It can be saved in a file
- with ccl:write-coverage-to-file, reinstated back as the current
- state with ccl:restore-coverage, or combined with other
- snapshots with ccl:combine-coverage.
+ with
@@ -6050,5 +6173,5 @@
@@ -6074,10 +6197,10 @@
Saves the coverage snapshot in a file. The snapshot can be
- loaded back with ccl:read-coverage-from-file or loaded and
- restored with ccl:restore-coverage-from-file. Note that the file
+ loaded back with
Returns the snapshot saved in pathname. Doesn't affect the
current coverage state. pathname can be the file previously
- created with ccl:write-coverage-to-file or
- ccl:save-coverage-in-file, or it can be the name of the fasl
+ created with
- Returns a sequence ccl:coverage-statistics objects, one for each
+ Returns a sequence of
+
+
+
+ Returns the delta of coverage since the last reset of incremental coverage.
+ If
+ Incremental coverage deltas are represented differently than the full coverage snapshots
+ returned by functions such as
+
+ collection---
+ A hash table mapping arbitrary keys to incremental coverage deltas, or a sequence of
+ incremental coverage deltas.
+ sources---
+ A list of pathnames and/or source-notes, the latter representing a range within a file.
+
+ Given a hash table
+ For example if the deltas represent tests, then the returned value is a list of all tests
+ that cover some part of the source regions.
+
+
+
+ collection---
+ A hash table mapping arbitrary keys to incremental coverage deltas, or a sequence of
+ incremental coverage deltas.
+ directory---
+ The pathname of a subversion working directory.
+ revision---
+ The revision to compare to the working directory, an integer or another
+ value whose printed representation is suitable for passing as the
+
+ Given a hash table
+ For example if the deltas represent tests, then the returned value is a list of all tests
+ that might be affected by the changes.
+
+
+
@@ -6320,10 +6599,10 @@
This macro arranges so that body doesn't record internal details
of code coverage. It will be considered totally covered if it's
- entered at all. The Common Lisp macros ASSERT and CHECK-TYPE use
+ entered at all. The Common Lisp macros
@@ -6396,5 +6675,5 @@
@@ -6431,5 +6710,5 @@
@@ -6462,5 +6741,5 @@
@@ -6692,5 +6971,5 @@
-
+
BUILD-APPLICATION &key
(
+Hemlock is the text editor used in Clozure CL. It was originally based on the CMU Hemlock editor, but has since diverged from it in various ways. We continue to call the editor part of our IDE
+Like the code, this documentation is based on the original Hemlock documentation, modified as necessary.
+
+Hemlock follows in the tradition of Emacs-compatible editors, with a rich set of extensible commands. This document describes the API for implementing new commands. The basic editor consists of a set of Lisp utility functions for manipulating buffers and the other data structures of the editor. All user level commands are written in terms of these
+functions. To find out how to define commands see Commands.
+
+In Hemlock, text is represented as a sequence of lines. Newline characters
+are never stored but are implicit between lines. The
+implicit newline character is treated as the single character
+Text is broken into lines when it is first introduced into Hemlock. Text enters
+Hemlock from the outside world in two ways: reading a file, or pasting text
+from the system clipboard. Hemlock uses heuristics (which should be documented here!)
+to decide what newline convention to use to convert the incoming text into its internal
+representation as a sequence of lines. Similarly it uses heuristics
+(which should be documented here!) to convert the internal representation into
+a string with embedded newlines in order to write a file or paste a region into
+the clipboard.
+
+A
+
+
+
+
+Given a line, this function returns as a simple string the characters
+in the line. This is setf'able to set the line-string to any string
+that does not contain newline characters. It is an error to
+destructively modify the result of line-string or to destructively
+modify any string after the line-string of some line has been set to
+that string.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+This function returns an object that serves as a signature for a
+line's contents. It is guaranteed that any modification of text on the
+line will result in the signature changing so that it is not eql to
+any previous value. The signature may change even when the text
+remains unmodified, but this does not happen often.
+
+A
+This section discusses the very basic operations involving marks, but
+a lot of Hemlock programming is built on altering some text at a mark.
+For more extended uses of marks see Altering And Searching Text.
+
+A mark may have one of two lifetimes: temporary or permanent. Permanent
+marks remain valid after arbitrary operations on the text; temporary
+marks do not. Temporary marks are used because less bookkeeping
+overhead is involved in their creation and use. If a temporary mark
+is used after the text it points to has been modified results will be
+unpredictable. Permanent marks continue to point between the same two
+characters regardless of insertions and deletions made before or after
+them.
+
+There are two different kinds of permanent marks which differ only in
+their behavior when text is inserted at the position of the mark; text
+is inserted to the left of a left-inserting mark and to the right of
+right-inserting mark.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+This function returns the character immediately before (after) the
+position of the mark, or nil if there is no previous (next) character.
+These characters may be set with setf when they exist; the setf
+methods for these forms signal errors when there is no previous or
+next character.
+
+
+
+
+
+
+
+
+
+These functions destructively modify marks to point to new positions.
+Other sections of this document describe mark moving routines specific
+to higher level text forms than characters and lines, such as words,
+sentences, paragraphs, Lisp forms, etc.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+This function changes mark to point n lines after (n before if n is
+negative) the current position. The character position of the
+resulting mark is (min (line-length resulting-line) (mark-charpos
+mark)) if charpos is unspecified, or (min (line-length resulting-line)
+charpos) if it is. As with character-offset, if there are not n lines
+then nil is returned and mark is not modified.
+
+A
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+This function returns the number of lines in the region, first and
+last lines inclusive. A newline is associated with the line it
+follows, thus a region containing some number of non-newline
+characters followed by one newline is one line, but if a newline were
+added at the beginning, it would be two lines.
+
+
+
+A buffer is an object consisting of:
+
+A name.
+
+A piece of text.
+
+The insertion point.
+
+An associated file (optional).
+
+A write protect flag.
+
+Some variables.
+
+Some key bindings.
+
+A collection of modes.
+10. A list of modeline fields (optional).
+ Because of the way Hemlock is currently integrated in Cocoa, all modifications
+to buffer contents must take place in the GUI thread. Hemlock commands always
+run in the GUI thread, so most of the time you do not need to worry about it.
+If you are running code in another thread that needs to modify a buffer, you
+should perform that action using
+There are no intrinsic limitations on examining buffers from any thread,
+however, Hemlock currently does no locking, so you risk seeing the buffer
+in an inconsistent state if you look at it outside the GUI thread.
+
+Hemlock has the concept of the "current buffer". The current buffer
+is defined during Hemlock commands as the buffer of the hemlock view
+that received the key events that invoked the command. Many hemlock
+function operate on the current buffer rather than taking an explicit
+buffer argument. In effect, the current buffer is an implicit argument
+to many text manipulation functions.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+This function pops the current buffer's mark stack, returning the
+mark. If the stack becomes empty, this pushes a new mark on the stack
+pointing to the buffer's start. This always deactivates the current
+region (see Active Regions).
+
+
+
+This function pushes mark into the current buffer's mark stack,
+ensuring that the mark is right-inserting. If mark does not point into
+the current buffer, this signals an error. Optionally, the current
+region is made active, but this never deactivates the current region
+(see Active Regions).
+Mark is returned.
+
+
+
+
+
+
+
+This variable holds a string-table
+mapping the name of a buffer to the corresponding buffer object.
+
+
+
+
+
+
+
+make-buffer creates and returns a buffer with the given name. If a
+buffer named name already exists, nil is returned. Modes is a list of
+modes which should be in effect in the buffer, major mode first,
+followed by any minor modes. If this is omitted then the buffer is
+created with the list of modes contained in Default Modes (page
+35). Modeline-fields is a list of modeline-field objects (see section
+3.3) which may be nil. delete-hook is a list of delete hooks specific
+to this buffer, and delete-buffer invokes these along with Delete
+Buffer Hook.
+
+Buffers created with make-buffer are entered into the list
+(all-buffers), and their names are inserted into the string-table
+*buffer-names*. When a buffer is created the hook Make Buffer Hook is
+invoked with the new buffer.
+
+
+
+
+
+
+
+buffer-name returns the name, which is a string, of the given buffer.
+The corresponding setf method invokes Buffer Name Hook with buffer
+and the new name and then sets the buffer's name. When the user
+supplies a name for which a buffer already exists, the setf method
+signals an error.
+
+
+
+
+
+
+
+buffer-pathname returns the pathname of the file associated with the
+given buffer, or nil if it has no associated file. This is the
+truename of the file as of the most recent time it was read or
+written. There is a setf form to change the pathname. When the
+pathname is changed the hook Buffer Pathname Hook is invoked with the
+buffer and new value.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+This function returns t if you can modify the buffer, nil if you
+cannot. If a buffer is not writable, then any attempt to alter text
+in the buffer results in an error. There is a setf method to change
+this value. The setf method invokes the functions in Buffer Writable
+Hook on the buffer and new value before storing the new value.
+
+
+
+
+
+buffer-modified returns t if the buffer has been modified, nil if it
+hasn't. This attribute is set whenever a text-altering operation is
+performed on a buffer. There is a setf method to change this value.
+The setf method invokes the functions in Buffer Modified Hook with the
+buffer whenever the value of the modified flag changes.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+delete-buffer removes buffer from (all-buffers) (page 10) and its name
+from *buffer-names* (page 10). Before buffer is deleted, this invokes
+the functions on buffer returned by buffer-delete-hook and those found
+in Delete Buffer Hook. If buffer is the current-buffer, or if it is
+displayed in any view, then this function signals an error.
+
+A Buffer may specify a modeline, a line of text which is displayed
+across the bottom of a view to indicate status information.
+Modelines are described by a list of modeline-field objects which have
+individual update functions and are optionally fixed-width. These have
+an eql name for convenience in referencing and updating, but the name
+must be unique for all created modeline-field objects. All modeline-field
+functions must take a buffer as an
+argument and return a string. When displaying
+a modeline-field with a specified width, the result of the update
+function is either truncated or padded on the right to meet the
+constraint.
+
+Whenever one of the following changes occurs, all of a buffer's
+modeline fields are updated:
+
+A buffer's major mode is set.
+
+One of a buffer's minor modes is turned on or off.
+
+A buffer is renamed.
+
+A buffer's pathname changes.
+
+A buffer's modified status changes.
+
+The policy is that whenever one of these changes occurs, it is
+guaranteed that the modeline will be updated before the next trip
+through redisplay. Furthermore, since the system cannot know what
+modeline-field objects the user has added whose update functions rely
+on these values, or how he has changed Default Modeline Fields, we must
+update all the fields.
+
+The user should note that modelines can be updated at any time, so
+update functions should be careful to avoid needless delays (for
+example, waiting for a local area network to determine information).
+
+
+
+This function returns a modeline-field object with name, width,
+and function. Width defaults to nil meaning that the field is variable
+width; otherwise, the programmer must supply this as a positive
+integer. Function must take a buffer as an arguments and
+return a string. If name already names a modeline-field object,
+then this signals an error.
+
+
+
+
+
+
+
+
+
+Returns the function called when updating the modeline-field. When this
+is set with setf, the setf method updates modeline-field for all views
+on all buffers that contain the given field, so the next trip through
+redisplay will reflect the change. All modeline-field functions must
+take a buffer as an argument and return a string.
+
+
+
+Returns the width to which modeline-field is constrained, or nil
+indicating that it is variable width. When this is set with setf, the
+setf method updates all modeline-fields for all views on all buffers
+that contain the given field, so the next trip through redisplay will
+reflect the change.
+
+
+
+Returns a copy of the list of buffer's modeline-field objects. This
+list can be destructively modified without affecting display of
+buffer's modeline, but modifying any particular field's components
+(for example, width or function) causes the changes to be reflected
+the next trip through redisplay in every modeline display that uses
+the modified modeline-field. When this is set with setf, the setf
+method method updates all modeline-fields on all views on the buffer,
+so next trip through the redisplay will reflect the change.
+
+
+
+
+
+A note on marks and text alteration: :temporary marks are invalid
+after any change has been made to the buffer the mark points to; it is
+an error to use a temporary mark after such a change has been made.
+
+If text is deleted which has permanent marks pointing into it then
+they are left pointing to the position where the text was.
+
+
+
+
+
+
+
+
+
+Like
+
+
+This deletes n characters after the mark (or -n before if n is
+negative). If n characters after (or -n before) the mark do not
+exist, then this returns nil; otherwise, it returns t. If n is zero,
+and mark is in some buffer, then Hemlock leaves buffer-modified of
+mark's buffer unaffected.
+
+
+
+
+
+
+
+Destructively modifies region by replacing the text of each line with
+the result of the application of function to a string containing that
+text. Function must obey the following restrictions:
+
+The argument may not be destructively modified.
+
+The return value may not contain newline characters.
+
+The return value may not be destructively modified after it is returned from function.
+
+The strings are passed in order.
+
+Using this function, a region could be uppercased by doing:
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+These predicates test the relative ordering of two marks in a piece of
+text, that is a mark is mark> another if it points to a position after
+it. An error is signalled if the marks do not point into the same buffer,
+except that for such marks mark= is always false and mark/= is always true.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+There is a global ring (see section 16.2) of regions deleted from buffers.
+Some commands save affected regions on the kill ring before performing
+modifications. You should consider making the command undoable (see
+section 16.3), but this is a simple way of achieving a less
+satisfactory means for the user to recover.
+
+
+
+This kills region saving it in the kill ring. Current-type is either
+:kill-forward or :kill-backward. When the last-command-type (page 31)
+is one of these, this adds region to the beginning or end,
+respectively, of the top of the kill ring. The result of calling this is
+undoable using the command Undo (see the Hemlock User's Manual). This
+sets last-command-type to current-type, and it interacts with
+kill-characters.
+
+
+
+
+
+kill-characters kills count characters after mark if count is
+positive, otherwise before mark if count is negative. When count is
+greater than or equal to Character Deletion Threshold, the killed
+characters are saved on the kill ring. This may be called multiple times
+contiguously (that is, without last-command-type (page 31) being set)
+to accumulate an effective count for purposes of comparison with the
+threshold.
+
+This sets last-command-type, and it interacts with kill-region. When
+this adds a new region to the kill ring, it sets last-command-type to
+:kill-forward (if count is positive) or :kill-backward (if count is
+negative). When last-command-type is :kill-forward or :kill-backward,
+this adds the killed characters to the beginning (if count is
+negative) or the end (if count is positive) of the top of the kill ring,
+and it sets last-command-type as if it added a new region to the
+kill ring. When the kill ring is unaffected, this sets
+last-command-type to :char-kill-forward or :char-kill-backward
+depending on whether count is positive or negative, respectively.
+
+This returns mark if it deletes characters. If there are not count
+characters in the appropriate direction, this returns nil.
+
+Every buffer has a mark stack (page 9) and a mark known as the point
+where most text altering nominally occurs. Between the top of the
+mark stack, the current-mark, and the current-buffer's point, the
+current-point, is what is known as the current-region . Certain
+commands signal errors when the user tries to operate on the
+current-region without its having been activated. If the user turns
+off this feature, then the current-region is effectively always
+active.
+
+When writing a command that marks a region of text, the programmer
+should make sure to activate the region. This typically occurs
+naturally from the primitives that you use to mark regions, but
+sometimes you must explicitly activate the region. These commands
+should be written this way, so they do not require the user to
+separately mark an area and then activate it. Commands that modify
+regions do not have to worry about deactivating the region since
+modifying a buffer automatically deactivates the region. Commands
+that insert text often activate the region ephemerally; that is, the
+region is active for the immediately following command, allowing the
+user wants to delete the region inserted, fill it, or whatever.
+
+Once a marking command makes the region active, it remains active until:
+
+a command uses the region,
+
+a command modifies the buffer,
+
+a command changes the current window or buffer,
+
+a command signals an editor-error,
+
+or the user types C-g.
+
+
+
+
+
+This is a list of command types (see section 7.3), and its initial
+value is the list of :ephemerally-active and :unkill. When the
+previous command's type is one of these, the current-region is active
+for the currently executing command only, regardless of whether it
+does something to deactivate the region. However, the current command
+may activate the region for future commands. :ephemerally-active is a
+default command type that may be used to ephemerally activate the
+region, and:unkill is the type used by two commands, Un-kill and
+Rotate Kill Ring (what users typically think of as C-y and M-y).
+
+
+
+
+
+
+
+
+
+
+
+This returns a region formed with current-mark and current-point,
+optionally signaling an editor-error if the current region is not
+active. Error-if-not-active defaults to t. Each call returns a
+distinct region object. Depending on deactivate-region (defaults to
+t), fetching the current region deactivates it. Hemlock primitives
+are free to modify text regardless of whether the region is active, so
+a command that checks for this can deactivate the region whenever it
+is convenient.
+
+Before using any of these functions to do a character search, look at
+character attributes (page 37). They provide a facility similar to
+the syntax table in real Emacs. Syntax tables are a powerful,
+general, and efficient mechanism for assigning meanings to characters
+in various modes.
+
+
+
+Returns a search-pattern object which can be given to the find-pattern
+and replace-pattern functions. A search-pattern is a specification of
+a particular sort of search to do. direction is either :forward or
+:backward, indicating the direction to search in. kind specifies the
+kind of search pattern to make, and pattern is a thing which specifies
+what to search for. The interpretation of pattern depends on the kind
+of pattern being made. Currently defined kinds of search pattern are:
+ :string-insensitive---
+Does a case-insensitive string search for pattern
+ :string-sensitive---
+Does a case-sensitive string search for pattern.
+ :character---
+Finds an occurrence of the character pattern. This is case sensitive.
+ :not-character---
+Find a character which is not the character pattern.
+ :test---
+Finds a character which satisfies the function pattern. This function may not be applied an any particular fashion, so it should depend only on what its argument is, and should have no side-effects.
+ :test-not---
+Similar to :test, except it finds a character that fails the test.
+ :any---
+Finds a character that is in the string pattern.
+ :not-any---
+Finds a character that is not in the string pattern.
+
+result-search-pattern, if supplied, is a search-pattern to
+destructively modify to produce the new pattern. Where reasonable
+this should be supplied, since some kinds of search patterns may
+involve large data structures.
+
+
+
+
+
+get-search-pattern interfaces to a default search string and pattern
+that search and replacing commands can use. These commands then share
+a default when prompting for what to search or replace, and save on
+consing a search pattern each time they execute. This uses Default
+Search Kind (see the Hemlock User's Manual) when updating the pattern
+object.
+
+
+
+
+
+
+
+In Hemlock the "current" values of variables,
+key bindings and
+character-attributes
+depend on the current buffer
+and the modes active in it. There are three possible scopes for
+Hemlock values:
+
+The value is present only if the buffer it is local to is the current buffer.
+
+The value is present only when the mode it is local to is active in the current buffer.
+
+The value is always present unless shadowed by a buffer or mode local value.
+
+It is possible that there are different values for the same thing in
+in different scopes. For example, there be might a global binding for a given
+variable and also a local binding in the current buffer. Whenever there is a
+conflict, shadowing occurs, permitting only one of the values to be visible in
+the current environment.
+
+The process of resolving such a conflict can be described as a search
+down a list of places where the value might be defined, returning the
+first value found. The order for the search is as follows:
+
+Local values in the current buffer.
+
+Mode local values in the minor modes of the current buffer, in order from the highest precedence mode to the lowest precedence mode. The order of minor modes with equal precedences is undefined.
+
+Mode local values in the current buffer's major mode.
+
+Global values.
+
+Hemlock implements a system of variables separate from normal Lisp
+variables for the following reasons:
+
+Hemlock has different scoping rules which are useful in an editor. Hemlock variables can be local to a buffer (page 9) or a mode (page 35).
+
+Hemlock variables have hooks (page 25), lists of functions called when someone sets the variable. See variable-value for the arguments Hemlock passes to these hook functions.
+
+There is a database of variable names and documentation which makes it easier to find out what variables exist and what their values mean.
+
+To the user, a variable name is a case insensitive string. This
+string is referred to as the string name of the variable. A string
+name is conventionally composed of words separated by spaces.
+
+In Lisp code a variable name is a symbol. The name of this symbol is
+created by replacing any spaces in the string name with hyphens. This
+symbol name is always interned in the Hemlock package.
+
+
+
+
+
+In the following descriptions name is the symbol name of the variable.
+
+
+
+This function defines a Hemlock variable. Functions that take a
+variable name signal an error when the variable is undefined.
+ string-name---
+The string name of the variable to define.
+ documentation---
+The documentation string for the variable.
+ :mode, :buffer---
+If buffer is supplied, the variable is local to that buffer. If mode is supplied, it is local to that mode. If neither is supplied, it is global.
+ :value---
+This is the initial value for the variable, which defaults to nil.
+ :hooks---
+This is the initial list of functions to call when someone sets the variable's value. These functions execute before Hemlock establishes the new value. See variable-value for the arguments passed to the hook functions.
+
+If a variable with the same name already exists in the same place,
+then defhvar sets its hooks and value from hooks and value if the user
+supplies these keywords.
+
+
+
+This function returns the value of a Hemlock variable in some place. The following values for kind are defined:
+ :current---
+Return the value present in the current environment, taking into consideration any mode or buffer local variables. This is the default.
+ :global---
+Return the global value.
+ :mode---
+Return the value in the mode named where.
+ :buffer---
+Return the value in the buffer where.
+
+When set with setf, Hemlock sets the value of the specified variable
+and invokes the functions in its hook list with name, kind, where, and
+the new value.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+This macro is very similar to let in effect; within its scope each of
+the Hemlock variables var have the respective values, but after the
+scope is exited by any means the binding is removed. This does not
+cause any hooks to be invoked. The value of the last form is
+returned.
+
+
+
+
+
+
+
+delete-variable makes the Hemlock variable name no longer defined in
+the specified place. Kind and where have the same meanings as they do
+for variable-value, except that :current is not available, and the
+default for kind is :global
+
+An error will be signaled if no such variable exists. The hook,
+Delete Variable Hook is invoked with the same arguments before the
+variable is deleted.
+
+Hemlock actions such as setting variables, changing buffers, changing
+windows, turning modes on and off, etc., often have hooks associated
+with them. A hook is a list of functions called before the system
+performs the action. The manual describes the object specific hooks
+with the rest of the operations defined on these objects.
+
+Often hooks are stored in Hemlock variables, Delete Buffer Hook and
+Set Window Hook for example. This leads to a minor point of confusion
+because these variables have hooks that the system executes when
+someone changes their values. These hook functions Hemlock invokes
+when someone sets a variable are an example of a hook stored in an
+object instead of a Hemlock variable. These are all hooks for editor
+activity, but Hemlock keeps them in different kinds of locations.
+This is why some of the routines in this section have a special
+interpretation of the hook place argument.
+
+
+
+
+
+These macros add or remove a hook function in some place. If hook-fun
+already exists in place, this call has no effect. If place is a
+symbol, then it is a Hemlock variable; otherwise, it is a generalized
+variable or storage location. Here are two examples:
+
+
+
+The way that the user tells Hemlock to do something is by invoking a
+command. Commands have three attributes:
+
+A command's name provides a way to refer to it. Command names are
+usually capitalized words separated by spaces, such as Forward Word.
+
+The documentation for a command is used by on-line help facilities.
+
+A command is implemented by a Lisp function, which is callable from Lisp.
+
+
+
+The command interpreter is the functionality invoked by the event
+handler to process key-events from the keyboard and dispatch to
+different commands on the basis of what the user types. When the
+command interpreter executes a command, we say it invokes the command. The
+command interpreter also provides facilities for communication between
+contiguously running commands, such as a last command type register.
+It also takes care of resetting communication mechanisms, clearing the
+echo area, displaying partial keys typed slowly by the user, etc.
+
+
+
+In many editors the behavior of a command depends on the kind of
+command invoked before it. Hemlock provides a mechanism to support
+this known as
+
+
+This returns the command type of the last command invoked. If this is
+set with setf, the supplied value becomes the value of
+last-command-type until the next command completes. If the previous
+command did not set last-command-type, then its value is nil. Normally
+a command type is a keyword. The command type is not cleared after a
+command is invoked due to a transparent key binding.
+
+There are three ways in which a command may be invoked: It may be
+bound to a key which has been typed, it may be invoked as an extended
+command, or it may be called as a Lisp function. Ideally commands
+should be written in such a way that they will behave sensibly no
+matter which way they are invoked. The functions which implement
+commands must obey certain conventions about argument passing if the
+command is to function properly.
+
+Whenever a command is invoked it is passed as its first argument what
+is known as the prefix argument. The prefix argument is always either
+an integer or nil. When a command uses this value it is usually as a
+repeat count, or some conceptually similar function.
+
+
+
+This function returns the current value of the prefix argument. When
+set with setf, the new value becomes the prefix argument for the next
+command. If the prefix argument is not set by the previous command
+then the prefix argument for a command is nil. The prefix argument is
+not cleared after a command is invoked due to a transparent key
+binding.
+
+A mode is a collection of Hemlock values which may be present in the
+current environment (page 21) depending on the editing task at hand.
+An example of a typical mode is Lisp, for editing Lisp code.
+
+When a mode is added to or removed from a buffer, its mode hook is
+invoked. The hook functions take two arguments, the buffer involved
+and t if the mode is being added or nil if it is being removed. Mode
+hooks are typically used to make a mode do something additional to
+what it usually does. One might, for example, make a Text mode hook
+that turned on auto-fill mode when you entered.
+
+There are two kinds of modes, major modes and minor modes. A buffer
+always has exactly one major mode, but it may have any number of minor
+modes. Major modes may have mode character attributes while minor
+modes may not.
+
+A major mode is usually used to change the environment in some major
+way, such as to install special commands for editing some language.
+Minor modes generally change some small attribute of the environment,
+such as whether lines are automatically broken when they get too long.
+A minor mode should work regardless of what major mode and minor modes
+are in effect.
+
+
+
+
+
+
+
+
+
+This function defines a new mode named name, and enters it in
+*mode-names* (page 35). If major-p is supplied and is not nil then
+the mode is a major mode; otherwise it is a minor mode.
+
+Setup-function and cleanup-function are functions which are invoked
+with the buffer affected, after the mode is turned on, and before it
+is turned off, respectively. These functions typically are used to
+make buffer-local key or variable bindings and to remove them when the
+mode is turned off.
+
+Precedence is only meaningful for a minor mode. The precedence of a
+minor mode determines the order in which it in a buffer's list of
+modes. When searching for values in the current environment, minor
+modes are searched in order, so the precedence of a minor mode
+determines which value is found when there are several definitions.
+
+Transparent-p determines whether key bindings local to the defined mode
+are transparent. Transparent key bindings are invoked in addition to
+the first normal key binding found rather than shadowing less local
+key bindings.
+
+Documentation is some introductory text about the mode. Commands such
+as Describe Mode use this.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Character attributes provide a global database of information about
+characters. This facility is similar to, but more general than, the
+syntax tables of other editors such as Emacs. For example, you should
+use character attributes for commands that need information regarding
+whether a character is whitespace or not. Use character attributes
+for these reasons:
+
+If this information is all in one place, then it is easy the
+change the behavior of the editor by changing the syntax table,
+much easier than it would be if character constants were wired
+into commands.
+
+This centralization of information avoids needless duplication of effort.
+
+The syntax table primitives are probably faster than anything that
+can be written above the primitive level.
+
+Note that an essential part of the character attribute scheme is that
+character attributes are global and are there for the user to
+change. Information about characters which is internal to some set of
+commands (and which the user should not know about) should not be
+maintained as a character attribute. For such uses various character
+searching abilities are provided by the function find-pattern (page
+20).
+
+As for Hemlock variables, character attributes have a user visible
+string name, but are referred to in Lisp code as a symbol. The string
+name, which is typically composed of capitalized words separated by
+spaces, is translated into a keyword by replacing all spaces with
+hyphens and interning this string in the keyword package. The
+attribute named "Ada Syntax" would thus become :ada-syntax.
+
+
+
+
+
+This function defines a new character attribute with name, a
+string. Character attribute operations take attribute
+arguments as a keyword whose name is name uppercased with spaces
+replaced by hyphens.
+
+Documentation describes the uses of the character attribute.
+
+Type, which defaults to (mod 2), specifies what type the values of the
+character attribute are. Values of a character attribute may be of
+any type which may be specified to make-array. Initial-value (default
+0) is the value which all characters will initially have for this
+attribute.
+
+
+
+
+
+
+
+
+
+character-attribute returns the value of attribute for character. This
+signals an error if attribute is undefined.
+
+setf will set a character's attributes. This setf method invokes the
+functions in Character Attribute Hook on the attribute and character
+before it makes the change.
+
+If character is nil, then the value of the attribute for the beginning
+or end of the buffer can be accessed or set. The buffer beginning and
+end thus become a sort of fictitious character, which simplifies the
+use of character attributes in many cases.
+
+
+
+
+
+
+
+This function establishes value as the value of character's attribute
+attribute when in the mode mode. Mode must be the name of a major
+mode. Shadow Attribute Hook is invoked with the same arguments when
+this function is called. If the value for an attribute is set while
+the value is shadowed, then only the shadowed value is affected, not
+the global one.
+
+
+
+
+
+
+
+
+
+These functions find the next (or previous) character with some value
+for the character attribute attribute starting at mark. They pass test
+one argument, the value of attribute for the character tested. If the
+test succeeds, then these routines modify mark to point before (after
+for reverse-find-attribute) the character which satisfied the test.
+If no characters satisfy the test, then these return nil, and mark
+remains unmodified. Test defaults to
+
+
+
+
+It is often useful to use the character attribute mechanism as an
+abstract interface to other information about characters which in fact
+is stored elsewhere. For example, some implementation of Hemlock
+might decide to define a Print Representation attribute which controls
+how a character is displayed on an output device.
+
+To make this easy to do, each attribute has a list of hook functions
+which are invoked with the attribute, character and new value whenever
+the current value changes for any reason.
+
+
+
+These are predefined in Hemlock:
+
+A value of 1 indicates the character is whitespace.
+
+A value of 1 indicates the character separates words (see section 15.3).
+
+This is like Whitespace, but it should not include Newline. Hemlock
+uses this primarily for handling indentation on a line.
+
+A value of 1 indicates these characters terminate sentences (see section 15.3).
+
+A value of 1 indicates these delimiting characters, such as " or ),
+may follow a Sentence Terminator (see section 15.3).
+
+A value of 1 indicates these characters delimit paragraphs when they
+begin a line (see section 15.3).
+
+A value of 1 indicates this character separates logical pages (see
+section 15.4) when it begins a line.
+
+This uses symbol values from the following:
+
+nil These characters have no interesting properties.
+
+:space These characters act like whitespace and should not include Newline.
+
+:newline This is the Newline character.
+
+:open-paren This is ( character.
+
+:close-paren This is ) character.
+
+:prefix This is a character that is a part of any form it precedes for example, the single quote, '.
+
+:string-quote This is the character that quotes a string literal, ".
+
+:char-quote This is the character that escapes a single character, \.
+
+:comment This is the character that makes a comment with the rest of the line,;.
+
+:constituent These characters are constitute symbol names.
+
+A
+The API for working with hemlock-views is not fully
+defined yet. If you need to work with views beyond what's listed
+here, you will probably need to get in the sources and find some
+internal functions to call.
+
+
+
+
+
+
+
+
+
+
+
+This function is analogous to move-to-position (page 5), except that
+it moves mark to the position on line which corresponds to the
+specified column. If the line would not reach to the specified column, then nil is
+returned and mark is not modified. Note that since a character may be
+displayed on more than one column on the screen, several different
+values of column may cause mark to be moved to the same position.
+
+The display of the buffer contents on the screen is updated at the
+end of each command. The following function can be used to control
+the scroll position of the buffer in the view.
+
+
+
+Normally, after a command that changes the contents of the buffer
+or the selection (i.e. the active region), the event handler repositions
+the view so that the selection is visible, scrolling the buffer as
+necessary. Calling this function tells the system to not do that,
+and instead to position the buffer in a particular way. :center-selection---
+This causes the selection (or the point) to be centered in the visible area. :page-up---
+This causes the previous page of the buffer to be shown :page-down---
+This causes the next page of the buffer to be shown. :lines-up---
+ This causes :lines-down---
+This causes :line---
+ This causes the line containing
+Some primitives such as prompt-for-key (page 50) and commands such as
+Emacs query replace read key-events directly from the keyboard instead
+of using the command interpreter. To encourage consistency between
+these commands and to make them portable and easy to customize, there
+is a mechanism for defininglogical key-events. A logical key-event is
+a keyword which stands for some set of key-events. The system
+globally interprets these key-events as indicators a particular
+action. For example, the :help logical key-event represents the set of
+key-events that request help in a given Hemlock implementation. This
+mapping is a many-to-many mapping, not one-to-one, so a given logical
+key-event may have multiple corresponding actual key-events. Also,
+any key-event may represent different logical key-events.
+
+
+
+
+
+This function defines a new logical key-event with name string-name.
+Logical key-event operations take logical key-events
+arguments as a keyword whose name is string-name uppercased with
+spaces replaced by hyphens.
+
+Documentation describes the action indicated by the logical key-event.
+
+
+
+
+
+
+
+
+
+There are many default logical key-events, some of which are used by
+functions documented in this manual. If a command wants to read a
+single key-event command that fits one of these descriptions then the
+key-event read should be compared to the corresponding logical
+key-event instead of explicitly mentioning the particular key-event in
+the code. In many cases you can use the command-case (page 48) macro.
+It makes logical key-events easy to use and takes care of prompting
+and displaying help messages.
+
+:abort Indicates the prompter should terminate its activity without performing any closing actions of convenience, for example.
+
+:yes Indicates the prompter should take the action under consideration.
+
+:no Indicates the prompter should NOT take the action under consideration.
+
+:do-all Indicates the prompter should repeat the action under consideration as many times as possible.
+
+:do-once Indicates the prompter should execute the action under consideration once and then exit.
+
+:help Indicates the prompter should display some help information.
+
+:confirm Indicates the prompter should take any input provided or use the default if the user entered nothing.
+
+:quote Indicates the prompter should take the following key-event as itself without any sort of command interpretation.
+
+:keep Indicates the prompter should preserve something.
+
+:y Indicates a short positive response
+
+:n Indicates a short negative response
+
+Define a new logical key-event whenever:
+
+The key-event concerned represents a general class of actions, and
+several commands may want to take a similar action of this type.
+
+The exact key-event a command implementor chooses may generate
+violent taste disputes among users, and then the users can trivially
+change the command in their init files.
+
+You are using
+Hemlock provides a number of facilities for displaying information and
+prompting the user for it. Most of these work through a small area
+displayed at the bottom of the screen, called the Echo Area.
+
+
+
+
+
+
+
+
+
+Prompting functions can be used to obtain short one-line input from the user.
+
+Cocoa note: Because of implementation restrictions, only one buffer at
+a time is allowed to read prompted input. If a prompting function is
+invoked while a prompting operation is already in effect in another
+buffer, the attempt fails, telling the user "Buffer xxx is already
+waiting for input".
+
+Most of the prompting functions accept the following keyword arguments:
+
+If :must-exist has a non-nil value then the user is
+prompted until a valid response is obtained. If :must-exist is nil
+then return as a string whatever is input. The default is t.
+
+If null input is given when the user is prompted then this
+value is returned. If no default is given then some input must be
+given before anything interesting will happen.
+
+If a :default is given then this is a string to be
+printed to indicate what the default is. The default is some
+representation of the value for :default, for example for a buffer it
+is the name of the buffer.
+
+This is the prompt string to display.
+
+This is similar to :prompt, except that it is displayed when the help
+command is typed during input.
+ This may also be a function. When called with no arguments, it
+should either return a string which is the help text or perform some
+action to help the user, returning nil.
+
+
+
+Prompts with completion for a buffer name and returns the
+corresponding buffer. If must-exist is nil, then it returns the input
+string if it is not a buffer name. This refuses to accept the empty
+string as input when :default and :default-string are
+nil. :default-string may be used to supply a default buffer name
+when:default is nil, but when :must-exist is non-nil, it must name an
+already existing buffer.
+
+
+
+
+
+This function prompts for a key, a vector of key-events, suitable for
+passing to any of the functions that manipulate key bindings (page
+29). If must-exist is true, then the key must be bound in the current
+environment, and the command currently bound is returned as the second
+value.
+
+
+
+This function prompts for an acceptable filename. "Acceptable" means
+that it is a legal filename, and it exists if must-exist is
+non-nil. prompt-for-file returns a Common Lisp pathname. If the file
+exists as entered, then this returns it, otherwise it is merged with
+default as by merge-pathnames.
+
+
+
+
+
+This function prompts for a keyword with completion, using the string
+tables in the list string-tables. If must-exist is non-nil, then the
+result must be an unambiguous prefix of a string in one of the
+string-tables, and the returns the complete string even if only a
+prefix of the full string was typed. In addition, this returns the
+value of the corresponding entry in the string table as the second
+value.
+
+If must-exist is nil, then this function returns the string exactly as
+entered. The difference between prompt-for-keyword with must-exist
+nil, and prompt-for-string, is the user may complete the input using
+the Complete Parse and Complete Field commands.
+
+
+
+
+
+
+
+
+
+This prompts for logical key events :Y or :N, returning t or nil without waiting for
+confirmation. When the user types a confirmation key, this returns
+default if it is supplied. If must-exist is nil, this returns
+whatever key-event the user first types; however, if the user types
+one of the above key-events, this returns t or nil. This is analogous to
+the Common Lisp function y-or-n-p.
+
+
+
+
+
+This macro is analogous to the Common Lisp case macro. Commands such
+as Help use this to get a key-event, translate it to a
+character, and then to dispatch on the character to some case. In
+addition to character dispatching, this supports logical key-events
+(page 45) by using the input key-event directly without translating it
+to a character. Since the description of this macro is rather
+complex, first consider the following example:
+
+
+command-case prompts for a key-event and then executes the code in the
+first branch with a logical key-event or a character (called tags)
+matching the input. Each character must be a standard-character, one
+that satisfies the Common Lisp standard-char-p predicate, and the
+dispatching mechanism compares the input key-event to any character
+tags by mapping the key-event to a character with
+ext:key-event-char. If the tag is a logical key-event, then the search
+for an appropriate case compares the key-event read with the tag
+using logical-key-event-p.
+
+All uses of command-case have two default cases, :help and :abort. You
+can override these easily by specifying your own branches that include
+these logical key-event tags. The :help branch displays in a pop-up
+window the a description of the valid responses using the variously
+specified help strings. The :abort branch signals an editor-error.
+
+The key/value arguments control the prompting. The following are valid values:
+ :help---
+The default :help case displays this string in a pop-up window. In
+addition it formats a description of the valid input including each
+case's help string.
+ :prompt---
+This is the prompt used when reading the key-event.
+ :bind---
+This specifies a variable to which the prompting mechanism binds the
+input key-event. Any case may reference this variable. If you wish
+to know what character corresponds to the key-event, use
+key-event-char.
+
+Instead of specifying a tag or list of tags, you may use t. This
+becomes the default branch, and its forms execute if no other branch
+is taken, including the default :help and :abort cases. This option has
+no helpstring, and the default :help case does not describe the default
+branch. Every command-case has a default branch; if none is specified,
+the macro includes one that beep's and reprompt's (see below).
+
+Within the body of command-case, there is a defined reprompt macro. It
+causes the prompting mechanism and dispatching mechanism to
+immediately repeat without further execution in the current branch.
+
+
+
+Prompting functionality is implemented by the function parse-for-something
+in cooperation with commands defined in "Echo Area" mode on the buffer associated
+with the echo area. You can implement new prompting functions by invoking
+parse-for-something with appropriate arguments.
+
+
+
+This function enters a mode reading input from the user and echoing it in the echo area, and
+returns a value when done. The input is managed by commands bound in "Echo Area" mode on the
+buffer associated with the echo area. The following keyword arguments are accepted:
+
+These are some of the Echo Area commands that coordinate with the
+prompting routines. Hemlock binds other commands specific to the Echo
+Area, but they are uninteresting to mention here, such as deleting to
+the beginning of the line or deleting backwards a word.
+
+
+
+
+
+
+
+Similar to
+
+
+This chapter discusses ways to read and write files at various
+levels---at marks, into regions, and into buffers. This also treats
+automatic mechanisms that affect the state of buffers in which files
+are read.
+
+The user specifies file options with a special syntax on the first
+line of a file. If the first line contains the string "-*-",
+then Hemlock interprets the text between the first such occurrence and
+the second, which must be contained in one line , as a list of
+"option: value" pairs separated by semicolons. The following is a
+typical example:
+ See the Hemlock User's Manual for more details and predefined options.
+
+File type hooks are executed when Hemlock reads a file into a buffer
+based on the type of the pathname. When the user specifies a Mode
+file option that turns on a major mode, Hemlock ignores type hooks.
+This mechanism is mostly used as a simple means for turning on some
+appropriate default major mode.
+
+
+
+
+
+
+
+This checks for file options in buffer and invokes handlers if there
+are any. Pathname defaults to buffer's pathname but may be nil. If
+there is no Mode file option that specifies a major mode, and pathname
+has a type, then this tries to invoke the appropriate file type
+hook. read-buffer-file calls this.
+
+There is no good way to uniquely identify buffer names and pathnames.
+However, Hemlock has one way of mapping pathnames to buffer names that
+should be used for consistency among customizations and primitives.
+Independent of this, Hemlock provides a means for consistently
+generating prompting defaults when asking the user for pathnames.
+
+
+
+
+
+
+
+
+
+
+
+This returns Buffer Pathname if it is bound. If it is not bound, and
+buffer's name is composed solely of alphnumeric characters, then
+return a pathname formed from buffer's name. If buffer's name has
+other characters in it, then return the value of Last Resort Pathname
+Defaults Function called on buffer.
+
+Common Lisp pathnames are used by the file primitives. For probing,
+checking write dates, and so forth, all of the Common Lisp file
+functions are available.
+
+
+
+
+
+
+
+This function writes the contents of region to the file named by
+pathname. This writes region using a stream as if it were opened with
+:if-exists supplied as :rename-and-delete.
+
+When keep-backup, which defaults to the value of Keep Backup Files, is
+non-nil, this opens the stream as if :if-exists were :rename. If
+append is non-nil, this writes the file as if it were opened
+with:if-exists supplied as :append.
+
+This signals an error if both append and keep-backup are supplied as non-nil.
+
+
+
+
+
+
+
+write-buffer-file writes buffer to the file named by pathname
+including the following:
+
+It assumes pathname is somehow related to buffer's pathname: if
+the buffer's write date is not the same as pathname's, then this
+prompts the user for confirmation before overwriting the file.
+
+It consults Add Newline at EOF on Writing File (see Hemlock User's
+Manual for possible values) and interacts with the user if
+necessary.
+
+It sets Pathname Defaults, and after using write-file,
+marks buffer unmodified.
+
+It updates Buffer's pathname and write date.
+
+It renames the buffer according to the new pathname if possible.
+
+It invokes Write File Hook.
+
+Write File Hook is a list of functions that take the newly written buffer as an argument.
+
+
+
+
+
+read-buffer-file deletes buffer's region and uses read-file to read
+pathname into it, including the following:
+
+It sets buffer's write date to the file's write date if the file
+exists; otherwise, it messages that this is a new file and sets
+buffer's write date to nil.
+
+It moves buffer's point to the beginning.
+
+It sets buffer's unmodified status.
+
+It sets buffer's pathname to the result of probing pathname if the
+file exists; otherwise, this function sets buffer's pathname to the
+result of merging pathname with default-directory.
+
+It sets Pathname Defaults to the result of the previous item.
+
+It processes the file options.
+
+It invokes Read File Hook.
+
+Read File Hook is a list functions that take two arguments---the
+buffer read into and whether the file existed, t if so.
+
+This chapter is sort of a catch all for any functions and variables
+which concern Hemlock's interaction with the outside world.
+
+
+
+This a standard Common Lisp function. If x is supplied and is a
+string or pathname, the file specified by x is visited in a hemlock
+view (opening a new window if necessary, otherwise bringing an
+existing window with the file to the front), and the hemlock view
+object is the return value from the function.
+
+If x is null, a new empty hemlock view is created and returned.
+
+If x is a symbol or a setf function name, it attempts to
+edit the definition of the name. In this last case, the
+function returns without waiting for the operation to complete
+(for example, it might put up a non-modal dialog asking the
+user to select one of multiple definitions) and hence the
+return value is always NIL.
+
+
+
+
+
+
+
+It is possible to create streams which output to or get input from a
+buffer. This mechanism is quite powerful and permits easy interfacing
+of Hemlock to Lisp.
+
+Note that operations on these streams operate directly on buffers,
+therefore they have the same restrictions as described here
+for interacting with buffers from outside of the GUI thread.
+
+
+
+This function returns a stream that inserts at mark all
+output directed to it. It works best if mark is a left-inserting mark.
+Buffered controls whether the stream is buffered or not, and its valid values
+are the following keywords:
+ :none---
+No buffering is done. This is the default.
+ :line---
+The buffer is flushed whenever a newline is written or when it is
+explicitly done with force-output.
+ :full---
+The stream is only brought up to date when it is explicitly
+done with force-output
+
+
+
+
+
+
+
+
+
+
+
+
+
+This macro executes forms in a context with var bound to a
+stream. Hemlock collects output to this stream and tries to pop up a
+display of the appropriate height containing all the output. When
+height is supplied, Hemlock creates the pop-up display immediately,
+forcing output on line breaks. This is useful for displaying information
+of temporary interest.
+
+Hemlock commands are executed from an event handler in the initial
+Cocoa thread. They are executed within a
+ccl::with-standard-abort-handling form, which means cl:abort,
+ccl:abort-break, ccl:throw-cancel will abort the current command only
+and exit the event handler in an orderly fashion.
+
+In addition, for now, lisp errors during command execution dump a
+backtrace in the system console and are otherwise handled as if by
+
+
+
+This function is called to report minor errors to the user. These are
+errors that a normal user could encounter in the course of editing,
+such as a search failing or an attempt to delete past the end of the
+buffer. This function simply aborts the current command. Any args
+specified are used to format an error message to be placed in the echo
+area. This function never returns.
+
+
+
+Within the body of this macro any Lisp errors that occur are handled
+by displaying an error message in a dialog and aborting the current
+command, leaving the error text in the echo area. This macro should
+be wrapped around code which may get an error due to some action of
+the user --- for example, evaluating code fragments on the behalf of
+and supplied by the user.
+
+Hemlock provides commands for finding the definition of a function
+or variable and placing the user at the definition in a buffer. A
+function is provided to allow invoking this functionality outside
+of Hemlock. Note that this function is unusual in that it is
+it is safe to call outside of the command interpreter, and in fact
+it can be called from any thread.
+
+
+
+This function tries to find the definition of
+No Event Scheduling functionality is provided at this time.
+
+
+
+
+
+This iterates over alphabetic characters in Common Lisp binding var to
+each character in order as specified under character relations in
+Common Lisp the Language. Kind is one of:lower, :upper, or :both. When
+the user supplies :both, lowercase characters are processed first.
+
+This chapter discusses primitives that operate on higher level text
+forms than characters and words. For English text, there are functions
+that know about sentence and paragraph structures, and for Lisp
+sources, there are functions that understand this language. This
+chapter also describes mechanisms for organizing file sections into
+logical pages and for formatting text forms.
+
+
+
+The value of this variable determines how indentation is done, and it
+is a function which is passed a mark as its argument. The function
+should indent the line that the mark points to. The function may move
+the mark around on the line. The mark will be :left-inserting. The
+default simply inserts a tab character at the mark. A function for
+Lisp mode probably moves the mark to the beginning of the line,
+deletes horizontal whitespace, and computes some appropriate
+indentation for Lisp code.
+
+
+
+
+
+
+
+
+
+
+
+Hemlock bases its Lisp primitives on parsing a block of the buffer and
+annotating lines as to what kind of Lisp syntax occurs on the line or
+what kind of form a mark might be in (for example, string, comment,
+list, etc.). These do not work well if the block of parsed forms is
+exceeded when moving marks around these forms, but the block that gets
+parsed is somewhat programmable.
+
+There is also a notion of a top level form which this documentation
+often uses synonymously with defun, meaning a Lisp form occurring in a
+source file delimited by parentheses with the opening parenthesis at
+the beginning of some line. The names of the functions include this
+inconsistency.
+
+
+
+
+
+
+
+
+
+
+
+
+
+pre-command-parse-check calls Parse Start Function and Parse End
+Function on mark to get two marks. It then parses all the lines
+between the marks including the complete lines they point into. When
+for-sure is non-nil, this parses the area regardless of any cached
+information about the lines. Every command that uses the following
+routines calls this before doing so.
+
+The default values of the start and end variables use Minimum Lines
+Parsed, Maximum Lines Parsed, and Defun Parse Goal to determine how
+big a region to parse. These two functions always include at least the
+minimum number of lines before and after the mark passed to them. They
+try to include Defun Parse Goal number of top level forms before and
+after the mark passed them, but these functions never return marks
+that include more than the maximum number of lines before or after the
+mark passed to them.
+
+
+
+
+
+
+
+This moves mark1 and mark2 to the beginning and end, respectively, of
+the current or next top level form. Mark1 is used as a reference to
+start looking. The marks may be altered even if unsuccessful. If
+successful, return mark2, else nil. Mark2 is left at the beginning of
+the line following the top level form if possible, but if the last
+line has text after the closing parenthesis, this leaves the mark
+immediately after the form.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+This defines the function with name to have count special
+arguments. indent-for-lisp, the value of Indent Function (see section
+15.1) in Lisp mode, uses this to specially indent these arguments. For
+example, do has two, with-open-file has one, etc. There are many of
+these defined by the system including definitions for special Hemlock
+forms. Name is a simple-string, case insensitive and purely textual
+(that is, not read by the Lisp reader); therefore, "with-a-mumble" is
+distinct from "mumble:with-a-mumble".
+
+This section describes some routines that understand basic English
+language forms.
+
+
+
+This moves mark count words forward (if positive) or backwards (if
+negative). If mark is in the middle of a word, that counts as one. If
+there were count (-count if negative) words in the appropriate
+direction, this returns mark, otherwise nil. This always moves mark. A
+word lies between two characters whose Word Delimiter attribute value
+is 1 (see section 9.5).
+
+
+
+This moves mark count sentences forward (if positive) or backwards (if negative). If mark is in the middle of a sentence, that counts as one. If there were count (-count if negative) sentences in the appropriate direction, this returns mark, otherwise nil. This always moves mark.
+
+A sentence ends with a character whose Sentence Terminator attribute
+is 1 followed by two spaces, a newline, or the end of the buffer. The
+terminating character is optionally followed by any number of
+characters whose Sentence Closing Char attribute is 1. A sentence
+begins after a previous sentence ends, at the beginning of a
+paragraph, or at the beginning of the buffer.
+
+
+
+
+
+This moves mark count paragraphs forward (if positive) or backwards
+(if negative). If mark is in the middle of a paragraph, that counts as
+one. If there were count (-count if negative) paragraphs in the
+appropriate direction, this returns mark, otherwise nil. This only
+moves mark if there were enough paragraphs.
+
+Paragraph Delimiter Function holds a function that takes a mark,
+typically at the beginning of a line, and returns whether or not the
+current line should break the paragraph. default-para-delim-function
+returns t if the next character, the first on the line, has a
+Paragraph Delimiter attribute value of 1. This is typically a space,
+for an indented paragraph, or a newline, for a block style. Some modes
+require a more complicated determinant; for example, Scribe modes adds
+some characters to the set and special cases certain formatting
+commands.
+
+Prefix defaults to Fill Prefix (see section 15.5), and the right
+prefix is necessary to correctly skip paragraphs. If prefix is
+non-nil, and a line begins with prefix, then the scanning process
+skips the prefix before invoking the Paragraph Delimiter
+Function. Note, when scanning for paragraph bounds, and prefix is
+non-nil, lines are potentially part of the paragraph regardless of
+whether they contain the prefix; only the result of invoking the
+delimiter function matters.
+
+The programmer should be aware of an idiom for finding the end of the
+current paragraph. Assume paragraphp is the result of moving mark one
+paragraph, then the following correctly determines whether there
+actually is a current paragraph:
+
+
+In this example mark is at the end of the last paragraph in the
+buffer, and there is no last newline character in the
+buffer. paragraph-offset would have returned nil since it could not
+skip any paragraphs since mark was at the end of the current and last
+paragraph. However, you still have found a current paragraph on which
+to operate. mark-paragraph understands this problem.
+
+
+
+This marks the next or current paragraph, setting mark1 to the
+beginning and mark2 to the end. This uses Fill Prefix (see section
+15.5). Mark1 is always on the first line of the paragraph, regardless
+of whether the previous line is blank. Mark2 is typically at the
+beginning of the line after the line the paragraph ends on, this
+returns mark2 on success. If this cannot find a paragraph, then the
+marks are left unmoved, and nil is returned.
+
+Filling is an operation on text that breaks long lines at word
+boundaries before a given column and merges shorter lines together in
+an attempt to make each line roughly the specified length. This is
+different from justification which tries to add whitespace in awkward
+places to make each line exactly the same length. Hemlock's filling
+optionally inserts a specified string at the beginning of each
+line. Also, it eliminates extra whitespace between lines and words,
+but it knows two spaces follow sentences (see section 15.3).
+
+
+
+
+
+
+
+
+
+This chapter describes a number of utilities for manipulating some
+types of objects Hemlock uses to record information. String-tables are
+used to store names of variables, commands, modes, and buffers. Ring
+lists can be used to provide a kill ring, recent command history, or
+other user-visible features.
+
+String tables are similar to Common Lisp hash tables in that they
+associate a value with an object. There are a few useful differences:
+in a string table the key is always a case insensitive string, and
+primitives are provided to facilitate keyword completion and
+recognition. Any type of string may be added to a string table, but
+the string table functions always return simple-string's.
+
+A string entry in one of these tables may be thought of as being
+separated into fields or keywords. The interface provides keyword
+completion and recognition which is primarily used to implement some
+Echo Area commands. These routines perform a prefix match on a
+field-by-field basis allowing the ambiguous specification of earlier
+fields while going on to enter later fields. While string tables may
+use any string-char as a separator, the use of characters other than
+space may make the Echo Area commands fail or work unexpectedly.
+
+
+
+This function creates an empty string table that uses separator as the
+character, which must be a string-char, that distinguishes
+fields. Initial-contents specifies an initial set of strings and their
+values in the form of a dotted a-list, for example:
+
+
+
+
+
+
+
+
+
+
+
+
+This function returns as multiple values, first the value
+corresponding to the string if it is found and nil if it isn't, and
+second t if it is found and nil if it isn't.
+
+This may be set with setf to add a new entry or to store a new value
+for a string. It is an error to try to insert a string with more than
+one field separator character occurring contiguously.
+
+
+
+This function completes string as far as possible over the list of
+tables, returning five values. It is an error for tables to have
+different separator characters. The five return values are as follows:
+
+The maximal completion of the string or nil if there is none.
+
+An indication of the usefulness of the returned string:
+ :none---
+There is no completion of string.
+ :complete---
+The completion is a valid entry, but other valid
+completions exist too. This occurs when the supplied string is an
+entry as well as initial substring of another entry.
+ :unique---
+The completion is a valid entry and unique.
+ :ambiguous---
+The completion is invalid; get-string would return nil
+and nil if given the returned string.
+
+The value of the string when the completion is :unique or
+:complete, otherwise nil.
+
+An index, or nil, into the completion returned, indicating where
+the addition of a single field to string ends. The command Complete
+Field uses this when the completion contains the addition to string
+of more than one field.
+
+An index to the separator following the first ambiguous field when
+the completion is :ambiguous or :complete, otherwise nil.
+
+
+
+
+
+find-ambiguous returns a list in alphabetical order of all the strings
+in table matching string. This considers an entry as matching if each
+field in string, taken in order, is an initial substring of the
+entry's fields; entry may have fields remaining.
+
+find-containing is similar, but it ignores the order of the fields in
+string, returning all strings in table matching any permutation of the
+fields in string.
+
+
+
+There are various purposes in an editor for which a ring of values can
+be used, so Hemlock provides a general ring buffer type. It is used
+for maintaining a ring of killed regions (see section 4.3), a ring of
+marks (see section 3.1), or a ring of command strings which various
+modes and commands maintain as a history mechanism.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+This chapter is somewhat of a catch-all for comments and features that
+don't fit well anywhere else.
+
+The canonical representation of editor input is a key-event
+structure. Users can bind commands to keys (see section 1.3.1), which
+are non-empty sequences of key-events. A key-event consists of
+an identifying token known as a keysym and a field of bits
+representing modifiers. Users define keysyms by supplying names
+that reflect the legends on their keyboard's keys.
+Users define modifier names similarly, but the system chooses the
+bit and mask for recognizing the modifier. You can
+use keysym and modifier names to textually specify key-events and
+Hemlock keys in a #k syntax. The following are some examples:
+
+
+This is convenient for use within code and in init files containing
+bind-key calls.
+
+The #k syntax is delimited by double quotes, but the system parses the
+contents rather than reading it as a Common Lisp string. Within the
+double quotes, spaces separate multiple key-events. A single key-event
+optionally starts with modifier names terminated by hyphens. Modifier
+names are alphabetic sequences of characters which the system uses
+case-insensitively. Following modifiers is a keysym name, which is
+case-insensitive if it consists of multiple characters, but if the
+name consists of only a single character, then it is case-sensitive.
+
+You can escape special characters --- hyphen, double quote, open angle
+bracket, close angle bracket, and space --- with a backslash, and you
+can specify a backslash by using two contiguously. You can use angle
+brackets to enclose a keysym name with many special characters in
+it. Between angle brackets appearing in a keysym name position, there
+are only two special characters, the closing angle bracket and
+backslash.
+
+
+
+This function establishes a mapping from preferred-name to keysym for
+purposes of #k syntax. Other-names also map to keysym, but the system
+uses preferred-name when printing key-events. The names are
+case-insensitive simple-strings; however, if the string contains a
+single character, then it is used case-sensitively. Redefining a
+keysym or re-using names has undefined effects.
+
+Keysym can be any object, but generally it is either an integer
+representing the window-system code for the event, or a keyword
+which allows the mapping of the keysym to its code to be defined
+separately.
+
+
+
+
+
+
+
+
+
+
+
+
+
+This establishes long-name and short-name as modifier names for
+purposes of specifying key-events in #k syntax. The names are
+case-insensitive strings. If either name is already defined,
+this signals an error.
+
+The system defines the following default modifiers (first the long
+name, then the short name):
+
+"Hyper", "H"
+
+"Super", "S"
+
+"Meta", "M"
+
+"Control", "C"
+
+"Shift", "Shift"
+
+"Lock", "Lock"
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+This function returns the character associated with key-event. You can
+associate a character with a key-event by setf'ing this form. The
+system defaultly translates key-events in some implementation
+dependent way for text insertion; for example, under an ASCII system,
+the key-event #k"C-h", as well as #k"backspace" would map to the
+Common Lisp character that causes a backspace.
+
+
+
+
+
+
+ process-suspend was previously called
@@ -8019,5 +18833,5 @@
@@ -8072,5 +18886,5 @@
It would be nice to have more discussion of what it means
@@ -8216,5 +19030,5 @@
It would probably be better for result
@@ -8355,10 +19169,10 @@
This should arguably be SETFable, but doesn't seem to
@@ -8647,5 +19461,5 @@
Advises the OS scheduler that the current thread has nothing
@@ -8656,10 +19470,10 @@
This is a holdover from the days of cooperative
@@ -8684,5 +19498,5 @@
Executes body
@@ -8865,5 +19679,5 @@
Creates and returns an object of type CCL::READ-WRITE-LOCK.
@@ -9071,10 +19885,10 @@
There probably should be some way to
@@ -9099,5 +19913,5 @@
result should probably be interpreted
@@ -9262,5 +20076,5 @@
result should probably be interpreted
@@ -9306,5 +20120,5 @@
fd---a file descriptor, which is a non-negative integer
@@ -9356,5 +20170,5 @@
@@ -9402,5 +20216,5 @@
fd---a file descriptor, which is a non-negative integer
@@ -9410,5 +20224,5 @@
@@ -9453,5 +20267,5 @@
process---a process, typically created by process-run-function or by make-process Waits for the specified process to terminate. If the
@@ -9601,5 +20415,5 @@
address-family---The address/protocol family of this socket. Currently
@@ -9793,5 +20607,5 @@
specified number of seconds, an
output-timeout---The number of seconds before an output operation
times out. Must be a real number between zero and one
@@ -9799,5 +20613,5 @@
specified number of seconds, an
connect-timeout---The number of seconds before a connection
attempt times out. [TODO: what are acceptable values?]
@@ -9817,8 +20631,8 @@
Creates and returns a new socket Extracts the first connection on the queue of pending
@@ -9873,5 +20687,5 @@
dotted---A string representing an IP address in the
@@ -9881,5 +20695,5 @@
Converts a dotted-string representation of a host address to
@@ -9901,5 +20715,5 @@
ipaddr---A 32-bit integer representing an internet host address Converts a 32-bit unsigned IP address into octets. ipaddr---a 32-bit integer representing an internet host address Converts a 32-bit unsigned IP address into a host name
@@ -9956,5 +20770,5 @@
host---Specifies the host. It can be either a host name
@@ -9964,5 +20778,5 @@
Converts a host spec in any of the acceptable formats into a
@@ -9984,5 +20798,5 @@
port---Specifies the port. It can be either a string, such as
@@ -9993,5 +20807,5 @@
Finds the port number for the specified port and protocol Reads a UDP packet from a socket. If no packets are
@@ -10067,5 +20881,5 @@
Send a UDP packet over a socket. socket---The socket to shut down (typically a tcp-stream) Shuts down part of a bidirectional connection. This is
@@ -10129,10 +20943,10 @@
Returns the native OS's representation of the socket, or
@@ -10159,10 +20973,10 @@
Returns the 32-bit unsigned IP address of the remote host,
@@ -10184,10 +20998,10 @@
Returns the remote port number, or NIL if the socket is not
@@ -10209,10 +21023,10 @@
Returns 32-bit unsigned IP address of the local host. Returns the local port number Returns :internet or :file, as appropriate. Returns :active for tcp-stream, :passive for
@@ -10306,10 +21120,10 @@
Returns the socket format as specified by the :format
@@ -10331,10 +21145,10 @@
returns :stream for tcp-stream and listener-socket, and
@@ -10355,10 +21169,10 @@
simple-error The OS error code of the error A symbol representing the error code in a more
@@ -10432,10 +21246,10 @@
A string describing the context where the error happened. On
@@ -10458,5 +21272,5 @@
The close generic function can be applied to sockets. It
@@ -10490,5 +21304,5 @@
executes body with var bound to the result of applying
@@ -10510,5 +21324,5 @@
program---A string or pathname which denotes an executable file.
@@ -10680,5 +21494,5 @@
Runs the specified program in an external (Unix) process,
@@ -10700,5 +21514,5 @@
proc---An EXTERNAL-PROCESS, as returned by RUN-PROGRAM. Sends the specified "signal" to the specified
@@ -10729,10 +21543,10 @@
Returns the process id assigned to
@@ -10756,10 +21570,10 @@
Returns the stream created when the input argument to
@@ -10782,10 +21596,10 @@
Returns the stream created when the output argument to
@@ -10809,10 +21623,10 @@
Returns the stream created when the error argument to
@@ -10836,10 +21650,10 @@
Returns, as multiple values, a keyword denoting the status
@@ -10856,5 +21670,5 @@
Gray streams (see Section 9.2, âCreating Your Own Stream Classes with Gray Streamsâ)
+ Gray streams (see Section 10.2, âCreating Your Own Stream Classes with Gray Streamsâ)
all inherit from A stream that is associated with a file descriptor has
attributes and accessors:
@@ -11132,5 +21946,5 @@
stream---a stream, presumably a fundamental-input-stream. Should try to read up to count elements from stream into the
@@ -11711,5 +22525,5 @@
stream---a stream, presumably a fundamental-output-stream. should try to write the first count elements of list to
@@ -11742,5 +22556,5 @@
stream---a stream, presumably a fundamental-input-stream should try to read successive elements from stream into
@@ -11781,5 +22595,5 @@
stream---a stream, presumably a fundamental-output-stream should try to write successive elements of vector to stream,
@@ -11819,5 +22633,5 @@
Returns the file descriptor associated with
@@ -11860,5 +22674,5 @@
stream---An input stream. The method defined on
@@ -11892,5 +22706,5 @@
Writes max-octets octets to stream from ivector, starting at
@@ -11898,5 +22712,5 @@
CHUD:*SHARK-CONFIG-FILE*
[Variable] CHUD:METER form &key (reset nil)
+ CHUD:METER form &key (reset nil)
(debug-output nil) [Macro] Executes FORM (an arbitrary lisp form) and returns whatever
@@ -13135,5 +23949,5 @@
The argument/return values
- is a MACPTR. For information about building the database files,
- see Section 12.7, âThe Interface Translatorâ. Refer to Section 12.7, âThe Interface Translatorâ for
+ Refer to Section 13.7, âThe Interface Translatorâ for
information about running the interface translator and .ffi
parser. Reads a symbol from the current input stream, with *PACKAGE*
bound to the "OS" package and with readtable-case preserved. Does a lookup on that symbol in the Does a lookup on that symbol in the Notes the foreign function information, including the foreign
@@ -16279,5 +27093,5 @@
In In In In If completely is T, sets the
@@ -16553,9 +27367,9 @@
name---A symbol which can be made into a special variable arg-type-specifer---One of the foreign argument-type keywords,
- described above, or an equivalent foreign
+ described above, or an equivalent foreign
type specifier. In addition, if the keyword
:WITHOUT-INTERRUPTS is specified, the callback will be
@@ -16570,5 +27384,5 @@
Proclaims name
@@ -16606,13 +27420,13 @@
name---NIL or a keyword; the keyword may contain
- escaping constructs. foreign-type-spec---A foreign type specifier, whose syntax is (loosely)
defined above. If name is non-NIL, defines name to be an alias for the
@@ -16648,5 +27462,5 @@
If there is already an EXTERNAL-ENTRY-POINT for
@@ -16689,18 +27503,18 @@
name---A lisp string. See external, above. arg-type-specifer---One of the foreign argument-type keywords, described
- above, or an equivalent foreign
+ above, or an equivalent foreign
type specifier. arg---A lisp value of type indicated by the corresponding
arg-type-specifier result-type-specifier---One of the foreign argument-type keywords, described
- above, or an equivalent foreign
+ above, or an equivalent foreign
type specifier.filename
@@ -5120,5 +5219,5 @@
init-this-and-that.
@@ -5807,6 +5905,5 @@
(setq ccl:*compile-code-coverage* t)
-(recompile-all-your-files)
-
+(recompile-all-your-files)
ccl:report-coverage
+ or ccl:coverage-statistics.
+(ccl:reset-incremental-coverage)
+(loop with coverage = (make-hash-table)
+ for test in (tests-to-run)
+ do (run-test test)
+ do (setf (gethash test coverage) (ccl:get-incremental-coverage))
+ finally (return coverage))
+ ccl:incremental-coverage-svn-matches
+ or ccl:incremental-coverage-source-matches.
+ccl:report-coverage will not report any files,
+ and ccl:save-coverage-in-file will not save any info, until more
instrumented files are loaded.
(ccl:write-coverage-to-file (ccl:get-coverage) pathname).
"foo.lx86fsl" and then saved the coverage info, in this session
+ you must load the same "foo.lx86fsl" before calling
+ restore-coverage-from-file in order to retrieve the stored
+ coverage info for "foo". Equivalent to (ccl:restore-coverage
+ (ccl:read-coverage-from-file pathname)).
ccl:write-coverage-to-file, reinstated back as the current
+ state with ccl:restore-coverage, or combined with other
+ snapshots with ccl:combine-coverage.
ccl:read-coverage-from-file or loaded and
+ restored with ccl:restore-coverage-from-file. Note that the file
created is actually a lisp source file and can be compiled for
faster loading.
@@ -6101,11 +6224,11 @@
ccl:write-coverage-to-file or
+ ccl:save-coverage-in-file, or it can be the name of the fasl
created from compiling such a file.
ccl:coverage-statistics objects, one for each
source file, containing the same information as that written to
- the statistics file by ccl:report-coverage. The following
- accessors are defined for ccl:coverage-statistics objects:
+ the statistics file by ccl:report-coverage. The following
+ accessors are defined for ccl:coverage-statistics objects:
reset is true (the default), it also resets incremental coverage
+ now, so that the next call to get-incremental-coverage will return
+ the delta from this point.
+ ccl:get-coverage. Incremental
+ coverage uses an abbreviated format
+ and is missing some of the information in a full snapshot, and therefore cannot be passed to
+ functions documented to accept a <variable>snapshot</variable>, only to functions
+ specifically documented to accept incremental coverage deltas.
+ collection whose values are incremental coverage
+ deltas, return a list of all keys corresponding to those deltas that intersect any region
+ in sources.
+ collection can also be a sequence of deltas, in which case a subsequence
+ of matching deltas is returned. In particular you can test whether any particular delta
+ intersects the sources by passing it in as a single-element list.
+
+ incremental-coverage-svn-matches collection &key (directory (current-directory)) (revision :base)
+
+ --revision argument
+ to svn.
+ collection whose values are incremental coverage
+ deltas, return a list of all keys corresponding to those deltas that intersect any changed
+ source in directory since revision revision in subversion.
+ collection can also be a sequence of deltas, in which case a subsequence
+ of matching deltas is returned. In particular you can test whether any particular delta
+ is affected by the changes by passing it in as a single-element list.
+ ASSERT and CHECK-TYPE use
this macro.
name "MyApplication")
@@ -7094,5 +7373,5 @@
@@ -7102,15 +7381,10 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Hemlock to give credit where credit is due, but we make no attempt at source or API compatibility with the original Hemlock.
+ #\Newline by the
+text primitives.
+ line is an object representing a sequence of characters with no line breaks.
+ mark indicates a specific position within the text represented by a
+line and a character position within that line. Although a mark is
+sometimes loosely referred to as pointing to some character, it in
+fact points between characters. If the charpos is zero, the previous
+character is the newline character separating the previous line from
+the mark's line. If the charpos is equal to the number of characters
+in the line, the next character is the newline character separating
+the current line from the next. If the mark's line has no previous
+line, a mark with charpos of zero has no previous character; if the
+mark's line has no next line, a mark with charpos equal to the length of
+the line has no next character.
+ region is simply a pair of marks: a starting mark and an ending
+mark. The text in a region consists of the characters following the
+starting mark and preceding the ending mark (keep in mind that a mark
+points between characters on a line, not at them). By modifying the
+starting or ending mark in a region it is possible to produce regions
+with a start and end which are out of order or even in different
+buffers. The use of such regions is undefined and may result in
+arbitrarily bad behavior.
+
+
+ gui::execute-in-gui or gui::queue-for-gui.
+
+
+ insert-region, inserts the region at the mark's position,
+destroying the source region. This must be used with caution, since
+if anyone else can refer to the source region bad things will
+happen. In particular, one should make sure the region is not linked
+into any existing buffer. If region is empty, and mark is in some
+buffer, then Hemlock leaves buffer-modified of mark's buffer unaffected.
+
+
+ (filter-region #'string-upcase region)
+
+
+
+
+
+
+
+
+
+
+(add-hook delete-buffer-hook 'remove-buffer-from-menu)
+(add-hook (variable-hooks 'check-mail-interval)
+ 'reschedule-mail-check)
+
+
+
+
+ command type.
+
+
+ defmode name &key :setup-function :cleanup-function :major-p :precedence :transparent-p :documentation
+
+
+
+
+
+
+
+ #'not-zerop. There is no guarantee
+that the test is applied in any particular fashion, so it should have
+no side effects and depend only on its argument.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ hemlock-view represents the GUI object(s) used to display the contents
+of a buffer. Conceptually it consists of a text buffer, a
+modeline for semi-permanent status info, an echo area for transient
+status info, and a text input area for reading prompted
+input. (Currently the last two are conflated, i.e. text input happens
+in the echo area).
+ how can
+be one of the following:
+ what is ignored.
+
+ what is ignored.
+ what is ignored.
+ what previous lines to be scrolled in at the top. what must be an integer.
+ what next lines to be scrolled in at the bottom. what must be an integer.
+ what to be scrolled to the top of the view. what must be a mark.
+
+
+
+
+
+
+
+
+ command-case which prevents implementors from
+specifying non-standard characters for dispatching in otherwise
+possibly portable code, and you can define and set the logical
+key-event in a site dependent file where you can mention
+implementation dependent characters.
+
+
+
+
+
+
+ prompt-for-keyword string-tables &key :prompt :help :must-exist :default :default-string
+
+
+
+ prompt-for-expression &key :prompt :help :must-exist :default :default-string
+
+
+
+ prompt-for-variable &key :prompt :help :must-exist :default :default-string
+
+
+
+ prompt-for-yes-or-no &key :prompt :help :must-exist :default :default-string
+
+
+
+(defcommand "Save All Buffers" (p)
+ "Give the User a chance to save each modified buffer."
+ (dolist (b *buffer-list*)
+ (select-buffer-command () b)
+ (when (buffer-modified b)
+ (command-case (:prompt "Save this buffer: [Y] "
+ :help "Save buffer, or do something else:")
+ ((:yes :confirm)
+ "Save this buffer and go on to the next."
+ (save-file-command () b))
+ (:no "Skip saving this buffer, and go on to the next.")
+ ((:exit #\p) "Punt this silly loop."
+ (return nil))))))
+
+
+ :verification-function---
+This is invoked by the Confirm Parse command (page 52). It does most of
+the work when parsing prompted input. Confirm Parse (page 52) calls it
+with one argument, which is the string that the user typed so far.
+The function should return a list of values which are to be the result
+of the recursive edit, or nil indicating that the parse failed. In order
+to return zero values, a non-nil second value may be returned along with
+a nil first value.
+ :string-tables---
+This is the list of string-tables, if any, that pertain to this parse.
+ :value-must-exist---
+This is referred to by the verification function, and possibly some of the
+commands.
+ :default---
+The string representing the default object when prompting the user.
+Confirm Parse supplies this to the parse verification function when the
+user input is empty.
+ :default-string---
+When prompting the user, if :default is not specified, Hemlock displays
+this string as a representation of the default object; for example,
+when prompting for a buffer, this argument would be a default buffer name.
+ :type---
+The kind of parse, e.g. :file, :keyword, :string. This tells the completion
+commands how to do completion, with :string disabling completion.
+ :prompt---
+The prompt to display to the user.
+ :help---
+The help string or function being used for the current parse.
+ Complete Keyword, but only attempts to complete up to and
+including the first character in the keyword with a non-zero
+:parse-field-separator attribute. If there is no field separator then
+attempt to complete the entire keyword. If it is not a keyword parse
+then just self-insert.
+
+
+;;; -*- Mode: Lisp, Editor; Package: Hemlock -*-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ handle-lisp-errors below, which means it is not possible to debug
+errors at the point of the error. Once Clozure CL has better support
+for debugging errors in the initial Cocoa thread, better Hemlock error
+handling will be provided that will allow for some way to debug.
+ name, create
+or activate the window containing it, and scroll the view
+to show the definition. If there are multiple definitions
+available, the user is given a choice of which one to
+use. This function may return before the operation is complete.
+
+
+(or paragraphp
+ (and (last-line-p mark)
+ (end-line-p mark)
+ (not (blank-line-p (mark-line mark)))))
+
+
+
+
+'(("Global" . t) ("Mode" . t) ("Buffer" . t))
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#k"C-u"
+#k"Control-u"
+#k"c-m-z"
+#k"control-x meta-d"
+#k"a"
+#k"A"
+#k"Linefeed"
+
+
+
+
+
+
+
+
+
+ input-timeout error is signalled.
- (see Section 9.1.4, âStream Timeouts and Deadlinesâ)output-timeout error is signalled.
- (see Section 9.1.4, âStream Timeouts and Deadlinesâ)COMMUNICATION-DEADLINE-EXPIRED
error is signalled. A deadline takes precedence over
- any input/output timeouts that may be set. (see Section 9.1.4, âStream Timeouts and Deadlinesâ)FUNDAMENTAL-STREAM or
- CCL::BASIC-STREAM(see Section 9.1.3, âBasic Versus Fundamental Streamsâ). Defaults to
+ CCL::BASIC-STREAM(see Section 10.1.3, âBasic Versus Fundamental Streamsâ). Defaults to
T.
@@ -11057,9 +21871,9 @@
- 10.1.3. Basic Versus Fundamental Streams
+ FUNDAMENTAL-STREAM whereas
basic streams inherit from CCL::BASIC-STREAM.
@@ -11098,14 +21912,14 @@
10.1.4. Stream Timeouts and Deadlines
+
@@ -11951,5 +22765,5 @@
@@ -11959,15 +22773,15 @@
12.2.5. Reference
+ CCL
+ 13.8. Case-sensitivity of foreign names in CCL
CCL now preserves the case of external symbols in
its database
- files. See Case-sensitivity
+ files. See Case-sensitivity
of foreign names in CCL for information about
case in foreign symbol names.CCL interface
+ CCL interface
database, signalling an error if no foreign function
- information can be found for the symbol in any active interface
+ information can be found for the symbol in any active interface
directory.CCL 1.2 and later, the #& reader macro can be used to
@@ -16338,5 +27152,5 @@
CCL 0.14.2 and later, the #? reader macro can be used
@@ -16385,5 +27199,5 @@
CCL 1.2 and later, the #/ reader macro can be used to
@@ -16488,5 +27302,5 @@
CCL 1.2 and later, the #> reader macro reads
@@ -16517,5 +27331,5 @@