hemlock

API Reference

hemlock.base

HEMLOCK-INTERFACE

  • Function ADD-XWINDOW-OBJECT (window object object-set)
  • Function REMOVE-XWINDOW-OBJECT (window)
  • Class MARK
    A Hemlock mark object. See Hemlock Command Implementor's Manual for details.
    LINE   Accessor: MARK-LINE
    pointer to line
    CHARPOS   Accessor: MARK-CHARPOS
    The character position of a Hemlock mark. A mark's character position is the index within the line of the character following the mark.
    %KIND   Accessor: MARK-%KIND
    type of mark
  • Function MARKP (object)
    Returns true if its argument is a Hemlock mark object, false otherwise.
  • Struct REGION
    A Hemlock region object. See Hemlock Command Implementor's Manual for details.
    START
    END
  • Function REGIONP (object)
  • Function REGION-START (instance)
  • Function (setf REGION-START) (value instance)
  • Function REGION-END (instance)
  • Function (setf REGION-END) (value instance)
  • Function BUFFERP (object)
  • Function BUFFER-MODES (instance)
  • Function (setf BUFFER-MODES) (value instance)
  • Function BUFFER-POINT (instance)
  • Function (setf BUFFER-POINT) (value instance)
  • Function BUFFER-WINDOWS (instance)
  • Function (setf BUFFER-WINDOWS) (value instance)
  • Function BUFFER-VARIABLES (instance)
  • Function (setf BUFFER-VARIABLES) (value instance)
  • Function BUFFER-WRITE-DATE (instance)
  • Function (setf BUFFER-WRITE-DATE) (value instance)
  • Function BUFFER-ACTIVE-REGION-P (instance)
  • Function (setf BUFFER-ACTIVE-REGION-P) (value instance)
  • Function BUFFER-DELETE-HOOK (instance)
  • Function (setf BUFFER-DELETE-HOOK) (value instance)
  • Function BUFFER-UNDO-P (instance)
  • Function (setf BUFFER-UNDO-P) (value instance)
  • Struct MODELINE-FIELD
    This is one item displayed in a Hemlock window's modeline.
    %NAME
    %FUNCTION
    %WIDTH
  • Function MODELINE-FIELD-P (object)
  • Struct WINDOW
    This structure implements a Hemlock window.
    TICK
    %BUFFER
    HEIGHT
    WIDTH
    OLD-START
    FIRST-LINE
    LAST-LINE
    FIRST-CHANGED
    LAST-CHANGED
    SPARE-LINES
    OLD-LINES
    HUNK
    DISPLAY-START
    DISPLAY-END
    POINT
    MODELINE-DIS-LINE
    MODELINE-BUFFER
    MODELINE-BUFFER-LEN
    DISPLAY-RECENTERING
  • Function WINDOWP (object)
  • Function WINDOW-TICK (instance)
  • Function (setf WINDOW-TICK) (value instance)
  • Function WINDOW-%BUFFER (instance)
  • Function (setf WINDOW-%BUFFER) (value instance)
  • Function WINDOW-HEIGHT (instance)
  • Function (setf WINDOW-HEIGHT) (value instance)
  • Function WINDOW-WIDTH (instance)
  • Function (setf WINDOW-WIDTH) (value instance)
  • Function WINDOW-OLD-START (instance)
  • Function (setf WINDOW-OLD-START) (value instance)
  • Function WINDOW-FIRST-LINE (instance)
  • Function (setf WINDOW-FIRST-LINE) (value instance)
  • Function WINDOW-LAST-LINE (instance)
  • Function (setf WINDOW-LAST-LINE) (value instance)
  • Function WINDOW-FIRST-CHANGED (instance)
  • Function (setf WINDOW-FIRST-CHANGED) (value instance)
  • Function WINDOW-LAST-CHANGED (instance)
  • Function (setf WINDOW-LAST-CHANGED) (value instance)
  • Function WINDOW-SPARE-LINES (instance)
  • Function (setf WINDOW-SPARE-LINES) (value instance)
  • Function WINDOW-OLD-LINES (instance)
  • Function (setf WINDOW-OLD-LINES) (value instance)
  • Function WINDOW-HUNK (instance)
  • Function (setf WINDOW-HUNK) (value instance)
  • Function WINDOW-DISPLAY-START (instance)
  • Function (setf WINDOW-DISPLAY-START) (value instance)
  • Function WINDOW-DISPLAY-END (instance)
  • Function (setf WINDOW-DISPLAY-END) (value instance)
  • Function WINDOW-POINT (instance)
  • Function (setf WINDOW-POINT) (value instance)
  • Function WINDOW-MODELINE-DIS-LINE (instance)
  • Function (setf WINDOW-MODELINE-DIS-LINE) (value instance)
  • Function WINDOW-MODELINE-BUFFER (instance)
  • Function (setf WINDOW-MODELINE-BUFFER) (value instance)
  • Function WINDOW-MODELINE-BUFFER-LEN (instance)
  • Function (setf WINDOW-MODELINE-BUFFER-LEN) (value instance)
  • Function WINDOW-DISPLAY-RECENTERING (instance)
  • Function (setf WINDOW-DISPLAY-RECENTERING) (value instance)
  • Function INTERNAL-MAKE-WINDOW (&key ((tick tick) common-lisp:nil) ((%buffer %buffer) common-lisp:nil) ((height height) common-lisp:nil) ((width width) common-lisp:nil) ((old-start old-start) common-lisp:nil) ((first-line first-line) common-lisp:nil) ((last-line last-line) common-lisp:nil) ((first-changed first-changed) common-lisp:nil) ((last-changed last-changed) common-lisp:nil) ((spare-lines spare-lines) common-lisp:nil) ((old-lines old-lines) 0) ((hunk hunk) common-lisp:nil) ((display-start display-start) common-lisp:nil) ((display-end display-end) common-lisp:nil) ((point point) common-lisp:nil) ((modeline-dis-line modeline-dis-line) common-lisp:nil) ((modeline-buffer modeline-buffer) common-lisp:nil) ((modeline-buffer-len modeline-buffer-len) common-lisp:nil) ((display-recentering display-recentering) common-lisp:nil))
  • Function DIS-LINE-CHARS (instance)
  • Function (setf DIS-LINE-CHARS) (value instance)
  • Function DIS-LINE-LENGTH (instance)
  • Function (setf DIS-LINE-LENGTH) (value instance)
  • Function DIS-LINE-FONT-CHANGES (instance)
  • Function (setf DIS-LINE-FONT-CHANGES) (value instance)
  • Function DIS-LINE-OLD-CHARS (instance)
  • Function (setf DIS-LINE-OLD-CHARS) (value instance)
  • Function DIS-LINE-FLAGS (instance)
  • Function (setf DIS-LINE-FLAGS) (value instance)
  • Function DIS-LINE-DELTA (instance)
  • Function (setf DIS-LINE-DELTA) (value instance)
  • Function DIS-LINE-POSITION (instance)
  • Function (setf DIS-LINE-POSITION) (value instance)
  • Function MAKE-WINDOW-DIS-LINE (chars)
  • Function FONT-CHANGE-X (instance)
  • Function (setf FONT-CHANGE-X) (value instance)
  • Function FONT-CHANGE-FONT (instance)
  • Function (setf FONT-CHANGE-FONT) (value instance)
  • Function FONT-CHANGE-NEXT (instance)
  • Function (setf FONT-CHANGE-NEXT) (value instance)
  • Function FONT-FAMILY-MAP (instance)
  • Function (setf FONT-FAMILY-MAP) (value instance)
  • Function FONT-FAMILY-HEIGHT (instance)
  • Function (setf FONT-FAMILY-HEIGHT) (value instance)
  • Function FONT-FAMILY-WIDTH (instance)
  • Function (setf FONT-FAMILY-WIDTH) (value instance)
  • Function FONT-FAMILY-BASELINE (instance)
  • Function (setf FONT-FAMILY-BASELINE) (value instance)
  • Function FONT-FAMILY-CURSOR-WIDTH (instance)
  • Function (setf FONT-FAMILY-CURSOR-WIDTH) (value instance)
  • Function FONT-FAMILY-CURSOR-HEIGHT (instance)
  • Function (setf FONT-FAMILY-CURSOR-HEIGHT) (value instance)
  • Function FONT-FAMILY-CURSOR-X-OFFSET (instance)
  • Function (setf FONT-FAMILY-CURSOR-X-OFFSET) (value instance)
  • Function FONT-FAMILY-CURSOR-Y-OFFSET (instance)
  • Function (setf FONT-FAMILY-CURSOR-Y-OFFSET) (value instance)
  • Function COMMANDP (object)
  • Function COMMAND-DOCUMENTATION (instance)
  • Function (setf COMMAND-DOCUMENTATION) (value instance)
  • Function COMMAND-FUNCTION (instance)
  • Function (setf COMMAND-FUNCTION) (value instance)
  • Class RANDOM-TYPEOUT-STREAM  (FUNDAMENTAL-CHARACTER-OUTPUT-STREAM)
    MARK   Accessor: RANDOM-TYPEOUT-STREAM-MARK
    The buffer point of the associated buffer.
    WINDOW   Accessor: RANDOM-TYPEOUT-STREAM-WINDOW
    The hemlock window all this shit is in.
    MORE-MARK   Accessor: RANDOM-TYPEOUT-STREAM-MORE-MARK
    The mark that is not displayed when we need to more.
    NO-PROMPT   Accessor: RANDOM-TYPEOUT-STREAM-NO-PROMPT
    T when we want to exit, still collecting output.
    FIRST-MORE-P   Accessor: RANDOM-TYPEOUT-STREAM-FIRST-MORE-P
    T until the first time we more. Nil after.
    LINE-BUFFERED-P
    whether line buffered
  • Generic-Function DEVICE-INIT (device)
    called whenever going into the editor.
  • Generic-Function DEVICE-MAKE-WINDOW (device start modelinep window font-family ask-user x y width-arg height-arg proportion)
  • Generic-Function DEVICE-EXIT (device)
  • Generic-Function DEVICE-SMART-REDISPLAY (device window)
    redisplay a window on this device.
  • Generic-Function DEVICE-DUMB-REDISPLAY (device window)
    fun to redisplay a window on this device.
  • Generic-Function DEVICE-AFTER-REDISPLAY (device)
    call at the end of redisplay entry points.
  • Generic-Function DEVICE-CLEAR (device)
    clear the entire display.
  • Generic-Function DEVICE-NOTE-READ-WAIT (device on-off)
    somehow note on display that input is expected.
  • Generic-Function DEVICE-FORCE-OUTPUT (device)
    force any output possibly buffered.
  • Generic-Function DEVICE-FINISH-OUTPUT (device window)
    force output and hand until done.
  • Generic-Function DEVICE-PUT-CURSOR (device hunk x y)
    put the cursor at (x,y) or (column,line).
  • Generic-Function DEVICE-SHOW-MARK (device window x y time)
    display the screens cursor at a certain mark.
  • Generic-Function DEVICE-NEXT-WINDOW (device window)
    return the next window
  • Generic-Function DEVICE-PREVIOUS-WINDOW (device window)
    return the previous window
  • Generic-Function DEVICE-DELETE-WINDOW (device window)
    remove a window from the screen.
  • Generic-Function DEVICE-RANDOM-TYPEOUT-FULL-MORE (device stream)
    do full-buffered more-prompting.
  • Generic-Function DEVICE-RANDOM-TYPEOUT-LINE-MORE (device stream n)
    keep line-buffered streams up to date.
  • Generic-Function DEVICE-RANDOM-TYPEOUT-SETUP (device stream n)
    prepare for random typeout.
  • Generic-Function DEVICE-RANDOM-TYPEOUT-CLEANUP (device stream degree)
    clean up after random typeout.
  • Generic-Function DEVICE-BEEP (device stream)
    beep or flash the screen.
  • Method DEVICE-BEEP ((device t) stream)
  • Class DEVICE
    NAME   Accessor: DEVICE-NAME
    simple-string such as "concept" or "lnz"
    BOTTOM-WINDOW-BASE   Accessor: DEVICE-BOTTOM-WINDOW-BASE
    bottom text line of bottom window.
    HUNKS   Accessor: DEVICE-HUNKS
    list of hunks on the screen.
  • Method DEVICE-CLEAR ((device device))
  • Method DEVICE-AFTER-REDISPLAY ((device device))
  • Method DEVICE-NOTE-READ-WAIT ((device device) on-off)
  • Method DEVICE-FORCE-OUTPUT ((device device))
  • Method DEVICE-FINISH-OUTPUT ((device device) window)
  • Struct WINDOW-GROUP
    XPARENT
    WIDTH
    HEIGHT
  • Function WINDOW-GROUP-P (object)
  • Function WINDOW-GROUP-XPARENT (instance)
  • Function (setf WINDOW-GROUP-XPARENT) (value instance)
  • Function WINDOW-GROUP-WIDTH (instance)
  • Function (setf WINDOW-GROUP-WIDTH) (value instance)
  • Function WINDOW-GROUP-HEIGHT (instance)
  • Function (setf WINDOW-GROUP-HEIGHT) (value instance)
  • Function MAKE-WINDOW-GROUP (xparent width height)
  • Class DEVICE-HUNK
    This structure is used internally by Hemlock's screen management system.
    WINDOW   Accessor: DEVICE-HUNK-WINDOW
    Window displayed in this hunk.
    POSITION   Accessor: DEVICE-HUNK-POSITION
    Bottom Y position of hunk.
    HEIGHT   Accessor: DEVICE-HUNK-HEIGHT
    Height of hunk in pixels or lines.
    NEXT   Accessor: DEVICE-HUNK-NEXT
    Next hunks.
    PREVIOUS   Accessor: DEVICE-HUNK-PREVIOUS
    Previous hunks
    DEVICE   Accessor: DEVICE-HUNK-DEVICE
    Display device hunk is on.
  • Macro DO-ALPHA-CHARS ((var kind &optional result) &rest forms)
    (do-alpha-chars (var kind [result]) . body). Kind is one of :lower, :upper, or :both, and var is bound to each character in order as specified under character relations in the manual. When :both is specified, lowercase letters are processed first.
  • Function SCHEDULE-EVENT (time function &optional (repeat common-lisp:t))
    This causes function to be called after time seconds have passed, optionally repeating every time seconds. This is a rough mechanism since commands can take an arbitrary amount of time to run; the function will be called at the first possible moment after time has elapsed. Function takes the time that has elapsed since the last time it was called (or since it was scheduled for the first invocation).
  • Function REMOVE-SCHEDULED-EVENT (function)
    Removes function queued with SCHEDULE-EVENT.
  • Function SHOW-MARK (mark window time)
    Highlights the position of Mark within Window for Time seconds, possibly by moving the cursor there. If Mark is not displayed within Window return NIL. The wait may be aborted if there is pending input.
  • Function WINDOWED-MONITOR-P
    This returns whether the monitor is being used with a window system. It returns the console's CLX display structure.
  • Variable *EDITOR-INPUT*
    nil
    A structure used to do various operations on terminal input.
  • Class EDITOR-INPUT
    HEAD   Accessor: EDITOR-INPUT-HEAD
    TAIL   Accessor: EDITOR-INPUT-TAIL
  • Generic-Function GET-KEY-EVENT (editor-input &optional ignore-abort-attempts-p)
    This function returns a key-event as soon as it is available on editor-input. Editor-input is either *editor-input* or *real-editor-input*. Ignore-abort-attempts-p indicates whether #k"C-g" and #k"C-G" throw to the editor's top-level command loop; when this is non-nil, this function returns those key-events when the user types them. Otherwise, it aborts the editor's current state, returning to the command loop.
  • Generic-Function UNGET-KEY-EVENT (key-event editor-input)
    This function returns the key-event to editor-input, so the next invocation of GET-KEY-EVENT will return the key-event. If the key-event is #k"C-g" or #k"C-G", then whether GET-KEY-EVENT returns it depends on its second argument. Editor-input is either *editor-input* or *real-editor-input*.
  • Generic-Function CLEAR-EDITOR-INPUT (editor-input)
    This function flushes any pending input on editor-input. Editor-input is either *editor-input* or *real-editor-input*.
  • Generic-Function LISTEN-EDITOR-INPUT (editor-input)
    This function returns whether there is any input available on editor-input. Editor-input is either *editor-input* or *real-editor-input*.
  • Function LAST-KEY-EVENT-CURSORPOS
    Return as values, the (X, Y) character position and window where the last key event happened. If this cannot be determined, Nil is returned. If in the modeline, return a Y position of NIL and the correct X and window. Returns nil for terminal input.
  • Function WINDOW-INPUT-HANDLER (hunk char x y)
  • Macro INVOKE-HOOK (place &rest args)
    Call the functions in place with args. If place is a symbol, then this interprets it as a Hemlock variable rather than a Lisp variable, using its current value as the list of functions.
  • Macro VALUE (name)
    Return the current value of the Hemlock variable name.
  • Macro SETV (name new-value)
    Set the current value of the Hemlock variable name, calling any hook functions with new-value before setting the value.
  • Macro HLET (binds &rest forms)
    Hlet ({Var Value}*) {Form}* Similar to Let, only it creates temporary Hemlock variable bindings. Each of the vars have the corresponding value during the evaluation of the forms.
  • Function STRING-TO-VARIABLE (string)
    Returns the symbol name of a Hemlock variable from the corresponding string name.
  • Macro ADD-HOOK (place hook-fun)
    Add-Hook Place Hook-Fun Add Hook-Fun to the list stored in Place. If place is a symbol then it it is interpreted as a Hemlock variable rather than a Lisp variable.
  • Macro REMOVE-HOOK (place hook-fun)
    Remove-Hook Place Hook-Fun Remove Hook-Fun from the list in Place. If place is a symbol then it it is interpreted as a Hemlock variable rather than a Lisp variable.
  • Macro DEFCOMMAND (name lambda-list command-doc function-doc &body forms)
    Defcommand Name Lambda-List Command-Doc Function-Doc {Declaration}* {Form}* Define a new Hemlock command named Name. Lambda-List becomes the lambda-list, Function-Doc the documentation, and the Forms the body of the function which implements the command. The first argument, which must be present, is the prefix argument. The name of this function is derived by replacing all spaces in the name with hyphens and appending "-COMMAND". Command-Doc becomes the documentation for the command. See the command implementor's manual for further details. An example: (defcommand "Forward Character" (p) "Move the point forward one character. With prefix argument move that many characters, with negative argument go backwards." "Move the point of the current buffer forward p characters." (unless (character-offset (buffer-point (current-buffer)) (or p 1)) (editor-error)))
  • Macro WITH-MARK (mark-bindings &rest forms)
    With-Mark ({(Mark Pos [Kind])}*) {declaration}* {form}* With-Mark binds a variable named Mark to a mark specified by Pos. This mark is :temporary, or of kind Kind. The forms are then evaluated.
  • Macro USE-BUFFER (buffer &body forms)
    Use-Buffer Buffer {Form}* Has The effect of making Buffer the current buffer during the evaluation of the Forms. For restrictions see the manual.
  • Condition EDITOR-ERROR  (ERROR)
  • Function EDITOR-ERROR (&rest args)
    This function is called to signal minor errors within Hemlock; 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 SIGNAL's an editor-error condition formed from args. Hemlock invokes commands in a dynamic context with an editor-error condition handler bound. This default handler beeps or flashes (or both) the display. If args were supplied, it also invokes MESSAGE on them. The command in progress is always aborted, and this function never returns.
  • Macro DO-STRINGS ((string-var value-var table &optional result) &body forms)
    Do-Strings (String-Var Value-Var Table [Result]) {declaration}* {form}* Iterate over the strings in a String Table. String-Var and Value-Var are bound to the string and value respectively of each successive entry in the string-table Table in alphabetical order. If supplied, Result is a form to evaluate to get the return value.
  • Macro COMMAND-CASE ((&key (change-window common-lisp:t) (prompt "command character: ") (help "choose one of the following characters:") (bind (common-lisp:gensym))) &body forms)
    This is analogous to the Common Lisp CASE macro. Commands such as "Query Replace" use this to get a key-event, translate it to a character, and then to dispatch on the character to the specified case. The syntax is as follows: (COMMAND-CASE ( {key value}* ) {( {( {tag}* ) | tag} help {form}* )}* ) Each tag is either a character or a logical key-event. The user's typed key-event is compared using either 'ext:logical-key-event-p or 'char= of 'ext:key-event-char. The legal keys of the key/value pairs are :help, :prompt, :change-window, and :bind. See the manual for details.
  • Macro WITH-OUTPUT-TO-MARK ((var mark &optional (buffered ':line)) &body gorms)
    With-Output-To-Mark (Var Mark [Buffered]) {Declaration}* {Form}* During the evaluation of Forms, Var is bound to a stream which inserts output at the permanent mark Mark. Buffered is the same as for Make-Hemlock-Output-Stream.
  • Macro WITH-INPUT-FROM-REGION ((var region) &body gorms)
    With-Input-From-Region (Var Region) {Declaration}* {Form}* During the evaluation of Forms, Var is bound to a stream which returns input from Region.
  • Macro WITH-POP-UP-DISPLAY ((var &key height (buffer-name "random typeout")) &body body)
    Execute body in a context with var bound to a stream. Output to the stream appears in the buffer named buffer-name. The pop-up display appears after the body completes, but if you supply :height, the output is line buffered, displaying any current output after each line.
  • Macro HANDLE-LISP-ERRORS (&body body)
    Handle-Lisp-Errors {Form}* If a Lisp error happens during the evaluation of the body, then it is handled in some fashion. This should be used by commands which may get a Lisp error due to some action of the user.
  • Method LINEP ((object t))
  • Function LINE-SIGNATURE (line)
    This function returns an object which 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. Note that the signature may change even when the text hasn't been modified, but this probably won't happen often.
  • Function RINGP (object)
  • Function MAKE-RING (size &optional (delete-function #'common-lisp:identity))
    Make a ring-buffer which can hold up to Size objects. Delete-Function is a function which is called with each object that falls off the end.
  • Function RING-PUSH (object ring)
    Push an object into a ring, deleting an element if necessary.
  • Function RING-POP (ring)
    Pop an object from a ring and return it.
  • Function RING-LENGTH (ring)
    Return as values the current and maximum size of a ring.
  • Function RING-REF (ring index)
  • Function (setf RING-REF) (value ring index)
    Set an element in a ring.
  • Function ROTATE-RING (ring offset)
    Rotate a ring forward, i.e. second -> first, with positive offset, or backwards with negative offset.
  • Macro TICK
    Increments the ``now'' tick.
  • Function LINE-LENGTH (line)
    Returns the number of characters on the line.
  • Function LINE-BUFFER (line)
    Returns the buffer with which the Line is associated. If the line is not in any buffer then Nil is returned.
  • Function LINE-STRING (line)
    Returns the characters in the line as a string. The resulting string must not be destructively modified. This may be set with Setf.
  • Function (setf LINE-STRING) (string line)
    Replace the contents of a line.
  • Function LINE-CHARACTER (line index)
    Return the Index'th character in Line. If the index is the length of the line then #newline is returned.
  • Function MARK (line charpos &optional (kind :temporary))
    Returns a mark to the Charpos'th character of the Line. Kind is the kind of mark to make, one of :temporary (the default), :left-inserting or :right-inserting.
  • Function MARK-KIND (mark)
    Returns the kind of the given Mark, :Temporary, :Left-Inserting, or :Right-Inserting. This may be set with Setf.
  • Function (setf MARK-KIND) (kind mark)
    Used to set the kind of a mark.
  • Function COPY-MARK (mark &optional (kind (hemlock-internals::mark-%kind mark)))
    Returns a new mark pointing to the same position as Mark. The kind of mark created may be specified by Kind, which defaults to the kind of the copied mark.
  • Function DELETE-MARK (mark)
    Deletes the Mark. This should be done to any mark that may not be temporary which is no longer needed.
  • Function MOVE-TO-POSITION (mark charpos &optional (line (mark-line mark)))
    Changes the Mark to point to the given character position on the Line, which defaults to the line the mark is currently on.
  • Function REGION (start end)
    Returns a region constructed from the marks Start and End.
  • Function MAKE-EMPTY-REGION
    Returns a region with start and end marks pointing to the start of one empty line. The start mark is right-inserting and the end mark is left-inserting.
  • Function BUFFER-SIGNATURE (buffer)
    Returns an arbitrary number which reflects the buffers current "signature." The value returned by buffer-signature is guaranteed to be eql to the value returned by a previous call of buffer-signature iff the buffer has not been modified between the calls.
  • Function START-LINE-P (mark)
    Returns T if the Mark points before the first character in a line, Nil otherwise.
  • Function END-LINE-P (mark)
    Returns T if the Mark points after the last character in a line, Nil otherwise.
  • Function EMPTY-LINE-P (mark)
    Returns T if the line pointer to by Mark contains no characters, Nil or otherwise.
  • Function BLANK-LINE-P (line)
    True if line contains only characters with a :whitespace attribute of 1.
  • Function BLANK-BEFORE-P (mark)
    True is all of the characters before Mark on the line it is on have a :whitespace attribute of 1.
  • Function BLANK-AFTER-P (mark)
    True if all characters on the part part of the line after Mark have a :whitespace attribute of 1.
  • Function SAME-LINE-P (mark1 mark2)
    Returns T if Mark1 and Mark2 point to the same line, Nil otherwise.
  • Function MARK< (mark1 mark2)
    Returns T if Mark1 points to a character before Mark2, Nil otherwise.
  • Function MARK<= (mark1 mark2)
    Returns T if Mark1 points to a character at or before Mark2, Nil otherwise.
  • Function MARK> (mark1 mark2)
    Returns T if Mark1 points to a character after Mark2, Nil otherwise.
  • Function MARK>= (mark1 mark2)
    Returns T if Mark1 points to a character at or after Mark2, Nil otherwise.
  • Function MARK= (mark1 mark2)
    Returns T if both marks point to the same position, Nil otherwise.
  • Function MARK/= (mark1 mark2)
    Returns T if both marks point to different positions, Nil otherwise.
  • Function LINE< (line1 line2)
    Returns T if Line1 comes before Line2, NIL otherwise.
  • Function LINE<= (line1 line2)
    Returns T if Line1 comes before or is the same as Line2, NIL otherwise.
  • Function LINE>= (line1 line2)
    Returns T if Line1 comes after or is the same as Line2, NIL otherwise.
  • Function LINE> (line1 line2)
    Returns T if Line1 comes after Line2, NIL otherwise.
  • Function LINES-RELATED (line1 line2)
    Returns T if an order relation exists between Line1 and Line2.
  • Function FIRST-LINE-P (mark)
    Returns T if the line pointed to by mark has no previous line, Nil otherwise.
  • Function LAST-LINE-P (mark)
    Returns T if the line pointed to by mark has no next line, Nil otherwise.
  • Function BUFFER-WRITABLE (buffer)
    Returns whether buffer may be modified.
  • Function (setf BUFFER-WRITABLE) (value buffer)
    Sets whether the buffer is writable and invokes the Buffer Writable Hook.
  • Function BUFFER-MODIFIED (buffer)
    Return T if Buffer has been modified, NIL otherwise. Can be set with Setf.
  • Function (setf BUFFER-MODIFIED) (sense buffer)
    If true make the buffer modified, if NIL unmodified.
  • Function BUFFER-REGION (buffer)
    Return the region which contains Buffer's text.
  • Function (setf BUFFER-REGION) (new-region buffer)
    Set a buffer's region.
  • Function BUFFER-NAME (buffer)
    Return Buffer's string name.
  • Function (setf BUFFER-NAME) (name buffer)
    Sets the name of a specified buffer, invoking the Buffer Name Hook.
  • Function BUFFER-PATHNAME (buffer)
    Return a pathname for the file in Buffer. This is the truename of the file as of the last time it was read or written.
  • Function (setf BUFFER-PATHNAME) (pathname buffer)
    Sets the pathname of a buffer, invoking the Buffer Pathname Hook.
  • Function BUFFER-MODELINE-FIELDS (window)
    Return a copy of the buffer's modeline fields list.
  • Function (setf BUFFER-MODELINE-FIELDS) (fields buffer)
    Sets the buffer's list of modeline fields causing all windows into buffer to be updated for the next redisplay.
  • Function BUFFER-MODELINE-FIELD-P (buffer field)
    If field, a modeline-field or the name of one, is in buffer's list of modeline-fields, it is returned; otherwise, nil.
  • Function BUFFER-MAJOR-MODE (buffer)
    Return the name of Buffer's major mode. To change tha major mode use Setf.
  • Function (setf BUFFER-MAJOR-MODE) (name buffer)
    Set the major mode of some buffer to the Name'd mode.
  • Function BUFFER-MINOR-MODE (buffer name)
    Return true if the minor mode named Name is active in Buffer. A minor mode can be turned on or off with Setf.
  • Function (setf BUFFER-MINOR-MODE) (new-value buffer name)
    Turn a buffer minor mode on or off.
  • Function CURRENT-BUFFER
    Return the current buffer object.
  • Function CURRENT-POINT
    Return the Buffer-Point of the current buffer.
  • Function (setf CURRENT-BUFFER) (buffer)
    Set the current buffer, doing necessary stuff.
  • Function IN-RECURSIVE-EDIT
    Returns whether the calling point is dynamically within a recursive edit context.
  • Function RECURSIVE-EDIT (&optional (handle-abort common-lisp:t))
    Call the command interpreter recursively. If Handle-Abort is true then an abort caused by a control-g or a lisp error does not cause the recursive edit to be aborted.
  • Function EXIT-RECURSIVE-EDIT (&optional values)
    Exit from a recursive edit. Values is a list of things which are to be the return values from Recursive-Edit.
  • Function ABORT-RECURSIVE-EDIT (&rest args)
    Abort a recursive edit, causing an Editor-Error with the args given in the calling context.
  • Macro WITH-WRITABLE-BUFFER ((buffer) &body body)
    Executes body in a scope where buffer is writable. After body executes, this sets the buffer's modified and writable status to nil.
  • Function DEFMODE (name &key (setup-function #'common-lisp:identity) (cleanup-function #'common-lisp:identity) major-p transparent-p precedence documentation)
    Define a new mode, specifying whether it is a major mode, and what the setup and cleanup functions are. Precedence, which defaults to 0.0, and is any integer or float, determines the order of the minor modes in a buffer. A minor mode having a greater precedence is always considered before a mode with lesser precedence when searching for key-bindings and variable values. If Transparent-p is true, then all key-bindings local to the defined mode are transparent, meaning that they do not shadow other bindings, but rather are executed in addition to them. Documentation is used as introductory text for mode describing commands.
  • Function MODE-MAJOR-P (name)
    Returns T if Name is the name of a major mode, or NIL if is the name of a minor mode.
  • Function MODE-VARIABLES (name)
    Return the string-table that contains the names of the modes variables.
  • Function MODE-DOCUMENTATION (name)
    Returns the documentation for mode with name.
  • Variable *CURRENT-BUFFER*
    nil
    Internal variable which might contain the current buffer.
  • Function MAKE-BUFFER (name &key (modes (value hemlock::default-modes)) (modeline-fields (value hemlock::default-modeline-fields)) delete-hook)
    Creates and returns a buffer with the given Name if a buffer with Name does not already exist, otherwise returns nil. Modes is a list of mode names, and Modeline-fields is a list of modeline field objects. Delete-hook is a list of functions that take a buffer as the argument.
  • Function DELETE-BUFFER (buffer)
    Deletes a buffer. If buffer is current, or if it is displayed in any windows, an error is signaled.
  • Function BUFFER-START-MARK (buffer)
    Returns the buffer-region's start mark.
  • Function BUFFER-END-MARK (buffer)
    Returns the buffer-region's end mark.
  • Function VARIABLE-VALUE (name &optional (kind :current) where)
    Return the value of the Hemlock variable given.
  • Function VARIABLE-HOOKS (name &optional (kind :current) where)
    Return the list of hook functions for the Hemlock variable given.
  • Function VARIABLE-DOCUMENTATION (name &optional (kind :current) where)
    Return the documentation for the Hemlock variable given.
  • Function VARIABLE-NAME (name &optional (kind :current) where)
    Return the string name of a Hemlock variable.
  • Function HEMLOCK-BOUND-P (name &optional (kind :current) where)
    Returns T Name is a Hemlock variable defined in the specifed place, or NIL otherwise.
  • Function DEFHVAR (name documentation &key mode buffer (hooks common-lisp:nil hook-p) (value common-lisp:nil value-p))
  • Function DELETE-VARIABLE (name &optional (kind :global) where)
    Delete a Hemlock variable somewhere.
  • Function KEY-TRANSLATION (key)
    Return the key translation for Key, or NIL if there is none. If Key is a prefix of a translation, then :Prefix is returned. Whenever Key appears as a subsequence of a key argument to the binding manipulation functions, that portion will be replaced with the translation. A key translation may also be a list (:Bits {Bit-Name}*). In this case, the named bits will be set in the next character in the key being translated.
  • Function (setf KEY-TRANSLATION) (new-value key)
    Set the key translation for a key. If set to null, deletes any translation.
  • Function BIND-KEY (name key &optional (kind :global) where)
    Bind a Hemlock command to some key somewhere. Name is the string name of a Hemlock command, Key is either a key-event or a vector of key-events. Kind is one of :Global, :Mode or :Buffer, and where is the mode name or buffer concerned. Kind defaults to :Global.
  • Function DELETE-KEY-BINDING (key &optional (kind :global) where)
    Remove a Hemlock key binding somewhere. Key is either a key-event or a vector of key-events. Kind is one of :Global, :Mode or :Buffer, andl where is the mode name or buffer concerned. Kind defaults to :Global.
  • Function GET-COMMAND (key &optional (kind :global) where)
    Return the command object for the command bound to key somewhere. If key is not bound, return nil. Key is either a key-event or a vector of key-events. If key is a prefix of a key-binding, then return :prefix. Kind is one of :global, :mode or :buffer, and where is the mode name or buffer concerned. Kind defaults to :Global.
  • Function MAP-BINDINGS (function kind &optional where)
    Map function over the bindings in some place. The function is passed the key and the command to which it is bound.
  • Function MAKE-COMMAND (name documentation function)
    Create a new Hemlock command with Name and Documentation which is implemented by calling the function-value of the symbol Function
  • Function COMMAND-NAME (command)
    Returns the string which is the name of Command.
  • Function (setf COMMAND-NAME) (new-name command)
    Change a Hemlock command's name.
  • Function COMMAND-BINDINGS (command)
    Return a list of lists of the form (key kind where) describing all the places where Command is bound.
  • Function LAST-COMMAND-TYPE
    Return the command-type of the last command invoked. If no command-type has been set then return NIL. Setting this with Setf sets the value for the next command.
  • Function (setf LAST-COMMAND-TYPE) (type)
    Set the Last-Command-Type for use by the next command.
  • Function PREFIX-ARGUMENT
    Return the current value of prefix argument. This can be set with SETF.
  • Function (setf PREFIX-ARGUMENT) (argument)
    Set the prefix argument for the next command to Argument.
  • Function EXIT-HEMLOCK (&optional (value common-lisp:t))
    Exit from ED, returning the specified value.
  • Function DEFATTRIBUTE (name documentation &optional (type '(common-lisp:mod 2)) (initial-value 0))
    Define a new Hemlock character attribute with named Name with the supplied Documentation, Type and Initial-Value. Type defaults to (mod 2) and Initial-Value defaults to 0.
  • Function CHARACTER-ATTRIBUTE-NAME (attribute)
    Return the string-name of the character-attribute Attribute.
  • Function CHARACTER-ATTRIBUTE-DOCUMENTATION (attribute)
    Return the documentation for the character-attribute Attribute.
  • Function CHARACTER-ATTRIBUTE-HOOKS (attribute)
    Return the hook-list for the character-attribute Attribute. This can be set with Setf.
  • Function (setf CHARACTER-ATTRIBUTE-HOOKS) (new-value attribute)
    Set the hook list for a Hemlock character attribute.
  • Function CHARACTER-ATTRIBUTE (attribute character)
    Return the value of the the character-attribute Attribute for Character. If Character is Nil then return the end-value.
  • Function CHARACTER-ATTRIBUTE-P (symbol)
    Return true if Symbol is the symbol-name of a character-attribute, Nil otherwise.
  • Function (setf CHARACTER-ATTRIBUTE) (new-value attribute character)
    Set the value for a character attribute.
  • Function SHADOW-ATTRIBUTE (attribute character value mode)
    Make a mode specific character attribute value. The value of Attribute for Character when we are in Mode will be Value.
  • Function UNSHADOW-ATTRIBUTE (attribute character mode)
    Make the value of Attribte for Character no longer shadowed in Mode.
  • Function FIND-ATTRIBUTE (mark attribute &optional (test #'hemlock-internals::not-zerop))
    Find the next character whose attribute value satisfies test.
  • Function REVERSE-FIND-ATTRIBUTE (mark attribute &optional (test #'hemlock-internals::not-zerop))
    Find the previous character whose attribute value satisfies test.
  • Function REGION-TO-STRING (region)
    Returns a string containing the characters in the given Region.
  • Function STRING-TO-REGION (string)
    Returns a region containing the characters in the given String.
  • Function LINE-TO-REGION (line)
    Returns a region containing the specified line.
  • Function PREVIOUS-CHARACTER (mark)
    Returns the character immediately before the given Mark.
  • Function NEXT-CHARACTER (mark)
    Returns the character immediately after the given Mark.
  • Function (setf NEXT-CHARACTER) (character mark)
    Sets the characters to the right of the given Mark.
  • Function (setf PREVIOUS-CHARACTER) (character mark)
    Sets the character to the left of the given Mark.
  • Function COUNT-LINES (region)
    Returns the number of lines in the region, first and last lines inclusive.
  • Function COUNT-CHARACTERS (region)
    Returns the number of characters in the region.
  • Function LINE-START (mark &optional line)
    Changes the Mark to point to the beginning of the Line and returns it. Line defaults to the line Mark is on.
  • Function LINE-END (mark &optional line)
    Changes the Mark to point to the end of the line and returns it. Line defaults to the line Mark is on.
  • Function BUFFER-START (mark &optional (buffer (line-buffer (mark-line mark))))
    Change Mark to point to the beginning of Buffer, which defaults to the buffer Mark is currently in.
  • Function BUFFER-END (mark &optional (buffer (line-buffer (mark-line mark))))
    Change Mark to point to the end of Buffer, which defaults to the buffer Mark is currently in.
  • Function MOVE-MARK (mark new-position)
    Changes the Mark to point to the same position as New-Position.
  • Function MARK-BEFORE (mark)
    Changes the Mark to point one character before where it currently points. NIL is returned if there is no previous character.
  • Function MARK-AFTER (mark)
    Changes the Mark to point one character after where it currently points. NIL is returned if there is no previous character.
  • Function CHARACTER-OFFSET (mark n)
    Changes the Mark to point N characters after (or -N before if N is negative) where it currently points. If there aren't N characters before (or after) the mark, Nil is returned.
  • Function LINE-OFFSET (mark n &optional charpos)
    Changes to Mark to point N lines after (-N before if N is negative) where it currently points. If there aren't N lines after (or before) the Mark, Nil is returned.
  • Function REGION-BOUNDS (region)
    Return as multiple-value the start and end of Region.
  • Function SET-REGION-BOUNDS (region start end)
    Set the start and end of Region to the marks Start and End.
  • Method INSERT-CHARACTER (mark character)
    Inserts the Character at the specified Mark.
  • Method INSERT-STRING (mark string &optional (start 0) (end (common-lisp:length common-lisp:string)))
    Inserts the String at the Mark. Do not use Start and End unless you know what you're doing!
  • Method INSERT-REGION (mark region)
    Inserts the given Region at the Mark.
  • Method NINSERT-REGION (mark region)
    Inserts the given Region at the Mark, possibly destroying the Region. Region may not be a part of any buffer's region.
  • Method DELETE-CHARACTERS (mark &optional (n 1))
    Deletes N characters after the mark (or -N before if N is negative).
  • Method DELETE-REGION (region)
    Deletes the Region.
  • Method DELETE-AND-SAVE-REGION (region)
    Deletes Region and returns a region containing the deleted characters.
  • Function COPY-REGION (region)
    Returns a region containing a copy of the text within Region.
  • Function FILTER-REGION (function region)
    This function filters the text in a region though a Lisp function. The argument function must map from a string to a string. It is passed each line string from region in order, and each resulting string replaces the original. The function must neither destructively modify its argument nor modify the result string after it is returned. The argument will always be a simple-string. It is an error for any string returned to contain newlines.
  • Function READ-FILE (pathname mark)
    Inserts the contents of the file named by Pathname at the Mark.
  • Function WRITE-FILE (region pathname &key append (keep-backup (value hemlock::keep-backup-files)) access)
    Writes the characters in region to the file named by pathname. This writes region using a stream opened with :if-exists :rename-and-delete, unless either append or keep-backup is supplied. If append is supplied, this writes the file opened with :if-exists :append. If keep-backup is supplied, this writes the file opened with :if-exists :rename. This signals an error if both append and keep-backup are supplied. Access is an implementation dependent value that is suitable for setting pathname's access or protection bits.
  • Function SEARCH-PATTERN-P (object)
  • Function NEW-SEARCH-PATTERN (kind direction pattern &optional result-search-pattern)
    Makes a new Hemlock search pattern of kind Kind to search direction using Pattern. Direction is either :backward or :forward. If supplied, result-search-pattern is a pattern to destroy to make the new one. The variable *search-pattern-documentation* contains documentation for each kind.
  • Function FIND-PATTERN (mark search-pattern)
    Find a match of Search-Pattern starting at Mark. Mark is moved to point before the match and the number of characters matched is returned. If there is no match for the pattern then Mark is not modified and NIL is returned.
  • Function REPLACE-PATTERN (mark search-pattern replacement &optional n)
    Replaces N occurrences of the Search-Pattern with the Replacement string in the text starting at the given Mark. If N is Nil, all occurrences following the Mark are replaced.
  • Function STRING-TABLE-P (object)
  • Function STRING-TABLE-SEPARATOR (instance)
  • Function (setf STRING-TABLE-SEPARATOR) (value instance)
  • Function MAKE-STRING-TABLE (&key (separator #\ ) initial-contents)
    Creates and returns a Hemlock string-table. If Intitial-Contents is supplied in the form of an A-list of string-value pairs, these pairs will be used to initialize the table. If Separator, which must be a base-char, is specified then it will be used to distinguish word boundaries.
  • Function GETSTRING (string string-table)
    Looks up String in String-Table. Returns two values: the first is the value of String or NIL if it does not exist; the second is a boolean flag indicating whether or not String was found in String-Table.
  • Function (setf GETSTRING) (value string table)
    Sets the value of String in Table to Value. If necessary, creates a new entry in the string table.
  • Function FIND-AMBIGUOUS (string string-table)
    Returns a list, in alphabetical order, of all the strings in String-Table which String matches.
  • Function FIND-CONTAINING (string string-table)
    Return a list in alphabetical order of all the strings in Table which contain String as a substring.
  • Function COMPLETE-STRING (string tables)
    Attempts to complete the string String against the string tables in the list Tables. Tables must all use the same separator character. See the manual for details on return values.
  • Function CLRSTRING (string-table)
    Delete all the entries in String-Table.
  • Function DELETE-STRING (string string-table)
  • Variable THE-SENTINEL
    (list (hemlock-interface:make-window-dis-line ""))
    This dis-line, which has several interesting properties, is used to end lists of dis-lines.
  • Variable UNALTERED-BITS
    0
    This is the value of the dis-line-flags when a line is neither moved nor changed nor new.
  • Variable CHANGED-BIT
    1
    This bit is set in the dis-line-flags when a line is found to be changed.
  • Variable MOVED-BIT
    2
    This bit is set in the dis-line-flags when a line is found to be moved.
  • Function UPDATE-WINDOW-IMAGE (window)
  • Variable HUNK-WIDTH-LIMIT
    200
    Maximum possible width for any hunk.
  • Variable *CURRENT-WINDOW*
    nil
    The current window object.
  • Variable *WINDOW-LIST*
    nil
    A list of all window objects.
  • Function CURRENT-WINDOW
    Return the current window. The current window is specially treated by redisplay in several ways, the most important of which is that is does recentering, ensuring that the Buffer-Point of the current window's Window-Buffer is always displayed. This may be set with Setf.
  • Function (setf CURRENT-WINDOW) (new-window)
    Set the current window.
  • Function WINDOW-BUFFER (window)
    Return the buffer which is displayed in Window.
  • Function (setf WINDOW-BUFFER) (new-buffer window)
    Change the buffer a window is mapped to.
  • Function MAKE-MODELINE-FIELD (&key name width function)
    Returns a modeline-field object.
  • Function MODELINE-FIELD (name)
    Returns the modeline-field object named name. If none exists, return nil.
  • Function MODELINE-FIELD-NAME (ml-field)
    Returns the name of a modeline field object.
  • Function (setf MODELINE-FIELD-NAME) (name ml-field)
    Sets a modeline-field's name. If one already exists with that name, an error is signaled.
  • Function MODELINE-FIELD-WIDTH (ml-field)
    Returns the width of a modeline field.
  • Function (setf MODELINE-FIELD-WIDTH) (width ml-field)
    Sets a modeline-field's width and updates all the fields for all windows in any buffer whose fields list contains the field.
  • Function MODELINE-FIELD-FUNCTION (ml-field)
    Returns the function of a modeline field object. It returns a string.
  • Function (setf MODELINE-FIELD-FUNCTION) (function ml-field)
    Sets a modeline-field's function and updates this field for all windows in any buffer whose fields list contains the field.
  • Function UPDATE-MODELINE-FIELDS (buffer window)
    Recompute all the fields of buffer's modeline for window, so the next redisplay will reflect changes.
  • Function UPDATE-MODELINE-FIELD (buffer window field)
    Recompute the field of the buffer's modeline for window, so the next redisplay will reflect the change. Field is either a modeline-field object or the name of one for buffer.
  • Variable DUMMY-LINE
    (hemlock-interface:make-window-dis-line "")
    Dummy dis-line that we put at the head of window's dis-lines
  • Function SETUP-MODELINE-IMAGE (buffer window)
  • Function EDITOR-FINISH-OUTPUT (window)
  • Function MAKE-WINDOW (start &key (modelinep common-lisp:t) (device common-lisp:nil) window (proportion 0.5) (font-family *default-font-family*) (ask-user common-lisp:nil) x y (width (value hemlock::default-window-width)) (height (value hemlock::default-window-height)))
    Make a window that displays text starting at the mark start. The default action is to make the new window a proportion of the current window's height to make room for the new window. Proportion determines what proportion of the current window's height the new window will use. The current window retains whatever space left after accommodating the new one. The default is to split the current window in half. Modelinep specifies whether the window should display buffer modelines. Device is the Hemlock device to make the window on. If it is nil, then the window is made on the same device as CURRENT-WINDOW. Window is an X window to be used with the Hemlock window. The supplied window becomes the parent window for a new group of windows that behave in a stack orientation as windows do on the terminal. Font-Family is the font-family used for displaying text in the window. If Ask-User is non-nil, Hemlock prompts the user for missing X, Y, Width, and Height arguments to make a new group of windows that behave in a stack orientation as windows do on the terminal. This occurs by invoking hi::*create-window-hook*. X and Y are supplied as pixels, but Width and Height are supplied in characters.
  • Function DELETE-WINDOW (window)
    Make Window go away, removing it from the screen. This uses hi::*delete-window-hook* to get rid of parent windows on a bitmap device when you delete the last Hemlock window in a group.
  • Function NEXT-WINDOW (window)
    Return the next window after Window, wrapping around if Window is the bottom window.
  • Function PREVIOUS-WINDOW (window)
    Return the previous window after Window, wrapping around if Window is the top window.
  • Variable *MORE-PROMPT-ACTION*
    :normal
  • Variable *RANDOM-TYPEOUT-ML-FIELDS*
    (list
     (hemlock-interface:make-modeline-field :name :more-prompt :function
                                            #'(lambda
                                                  (hemlock-internals:buffer
                                                   hemlock-interface:window)
                                                (declare
                                                 (ignore hemlock-interface:window))
                                                (ecase
                                                    hemlock-interface:*more-prompt-action*
                                                  (:more "--more--")
                                                  (:flush "--flush--")
                                                  (:empty "")
                                                  (:normal
                                                   (concatenate 'simple-string
                                                                "random typeout buffer          ["
                                                                (hemlock-interface:buffer-name
                                                                 hemlock-internals:buffer)
                                                                "]"))))))
  • Function MARK-TO-CURSORPOS (mark window)
    Return the (x, y) position of mark within window, or NIL if not displayed.
  • Function MAYBE-RECENTER-WINDOW (window)
  • Function CENTER-WINDOW (window mark)
    Adjust the start of Window so that Mark is displayed on the center line.
  • Function DISPLAYED-P (mark window)
    Return true if Mark is displayed on Window, false otherwise.
  • Function SCROLL-WINDOW (window n)
    Scroll Window down N lines, up if negative.
  • Function MARK-COLUMN (mark)
    Find the X position at which Mark would be displayed if it were on an infinitely wide screen. This takes into account tabs and control characters.
  • Function CURSORPOS-TO-MARK (x y window)
  • Function MOVE-TO-COLUMN (mark column &optional (line (mark-line mark)))
    Move Mark to the specified Column on Line. This function is analogous to Move-To-Position, but it deals with the physical screen position as returned by Mark-Column; the mark is moved to before the character which would be displayed in Column if the line were displayed on an infinitely wide screen. If the column specified is greater than the column of the last character, then Nil is returned and the mark is not modified.
  • Function GOTO-BUFFER-START
    Moves the point to the start of the current buffer.
  • Function GOTO-BUFFER-END
    Moves the point to the end of the current buffer.
  • Function REDISPLAY
    The main entry into redisplay; updates any windows that seem to need it.
  • Function REDISPLAY-ALL
    An entry into redisplay; causes all windows to be fully refreshed.
  • Function RANDOM-TYPEOUT-REDISPLAY (window)
  • Function PREPARE-WINDOW-FOR-REDISPLAY (window)
  • Function LIST-ALL-CONNECTIONS
  • Class CONNECTION
    NAME   Accessor: CONNECTION-NAME
    BUFFER   Accessor: CONNECTION-BUFFER
    STREAM   Accessor: CONNECTION-STREAM
    CONNECTION-SENTINEL   Accessor: CONNECTION-SENTINEL
  • Method DELETE-CONNECTION ((connection connection))
  • Function MAKE-PROCESS-CONNECTION (command &rest args &key name buffer stream filter sentinel slave-pty-name directory)
  • Function MAKE-TCP-CONNECTION (name host port &rest args &key buffer stream filter sentinel)
  • Function MAKE-PROCESS-WITH-PTY-CONNECTION (command &key name (buffer common-lisp:nil bufferp) stream)
  • Method CONNECTION-COMMAND ((connection process-with-pty-connection-mixin))
  • Method CONNECTION-EXIT-CODE ((connection process-with-pty-connection-mixin))
  • Method CONNECTION-EXIT-STATUS ((connection process-with-pty-connection-mixin))
  • Method DELETE-CONNECTION ((connection process-with-pty-connection-mixin))
  • Function MAKE-PIPELIKE-CONNECTION (read-fd write-fd &rest args &key name buffer stream filter sentinel process-connection encoding)
  • Class LISTENING-CONNECTION  (CONNECTION)
    SERVER   Accessor: CONNECTION-SERVER
    ACCEPTOR   Accessor: CONNECTION-ACCEPTOR
    INITARGS   Accessor: CONNECTION-INITARGS
  • Function MAKE-TCP-LISTENER (name host port &rest args &key buffer stream acceptor sentinel initargs)
  • Function MAKE-CONNECTION-DEVICE (connection)
  • Function UPDATE-TTY-LINE-BUFFERED-STREAM (stream newline-count)
  • Function DO-TTY-FULL-MORE (stream)
  • Variable *DEFAULT-FONT-FAMILY*
    (hemlock-internals::make-font-family)
  • Function DEFAULT-FONT (font)
    Returns the font id for font out of the default font family.
  • Function (setf DEFAULT-FONT) (font-object font)
    Change the font-object associated with a font-number in new windows.
  • Function HEMLOCK-OUTPUT-STREAM-P (x)
  • Function MAKE-HEMLOCK-OUTPUT-STREAM (mark &optional (buffered :line))
    Returns an output stream whose output will be inserted at the Mark. Buffered, which indicates to what extent the stream may be buffered is one of the following: :None -- The screen is brought up to date after each stream operation. :Line -- The screen is brought up to date when a newline is written. :Full -- The screen is not updated except explicitly via Force-Output.
  • Function MAKE-HEMLOCK-REGION-STREAM (region)
    Returns an input stream that will return successive characters from the given Region when asked for input.
  • Method GET-KEY-EVENT ((stream kbdmac-stream) &optional ignore-abort-attempts-p)
  • Method UNGET-KEY-EVENT (ignore (stream kbdmac-stream))
  • Variable *ECHO-AREA-BUFFER*
    (hemlock-interface:make-buffer "echo area" :modes '("echo area"))
    Buffer used to hack text for the echo area.
  • Variable *ECHO-AREA-WINDOW*
    nil
    Window used to display stuff in the echo area.
  • Function CLEAR-ECHO-AREA
    You guessed it.
  • Function MESSAGE (string &rest args)
    Nicely display a message in the echo-area. Put the message on a fresh line and wait for "Message Pause" seconds to give the luser a chance to see it. String and Args are a format control string and format arguments, respectively.
  • Function LOUD-MESSAGE (&rest args)
    This is the same as MESSAGE, but it beeps and clears the echo area before doing anything else.
  • Function PROMPT-FOR-BUFFER (&key ((must-exist *parse-value-must-exist*) common-lisp:t) default ((default-string *parse-default-string*)) ((prompt *parse-prompt*) "buffer: ") ((help *parse-help*) "type a buffer name."))
    Prompts for a buffer name and returns the corresponding buffer. If :must-exist is nil, then return the input string. This refuses to accept the empty string as input when no default is supplied. :default-string may be used to supply a default buffer name even when :default is nil, but when :must-exist is non-nil, :default-string must be the name of an existing buffer.
  • Function PROMPT-FOR-FILE (&key ((must-exist *parse-value-must-exist*) common-lisp:t) default ((default-string *parse-default-string*)) ((prompt *parse-prompt*) "filename: ") ((help *parse-help*) "type a file name."))
    Prompts for a filename.
  • Function PROMPT-FOR-KEYWORD (*parse-string-tables* &key ((must-exist *parse-value-must-exist*) common-lisp:t) ((default *parse-default*)) ((default-string *parse-default-string*)) ((prompt *parse-prompt*) "keyword: ") ((help *parse-help*) "type a keyword."))
    Prompts for a keyword using the String Tables.
  • Function PROMPT-FOR-VARIABLE (&key ((must-exist *parse-value-must-exist*) common-lisp:t) ((default *parse-default*)) ((default-string *parse-default-string*)) ((prompt *parse-prompt*) "variable: ") ((help *parse-help*) "type the name of a variable."))
    Prompts for a variable defined in the current scheme of things.
  • Function CURRENT-VARIABLE-TABLES
    Returns a list of all the variable tables currently established globally, by the current buffer, and by any modes for the current buffer.
  • Function PROMPT-FOR-INTEGER (&key ((must-exist *parse-value-must-exist*) common-lisp:t) default ((default-string *parse-default-string*)) ((prompt *parse-prompt*) "integer: ") ((help *parse-help*) "type an integer."))
    Prompt for an integer. If :must-exist is Nil, then we return as a string whatever was input if it is not a valid integer.
  • Function PROMPT-FOR-EXPRESSION (&key ((must-exist *parse-value-must-exist*) common-lisp:t) (default common-lisp:nil defaultp) ((default-string *parse-default-string*)) ((prompt *parse-prompt*) "expression: ") ((help *parse-help*) "type a lisp expression."))
    Prompts for a Lisp expression.
  • Function PROMPT-FOR-STRING (&key ((default *parse-default*)) ((default-string *parse-default-string*)) (trim common-lisp:nil) ((prompt *parse-prompt*) "string: ") ((help *parse-help*) "type a string."))
    Prompts for a string. If :trim is t, then leading and trailing whitespace is removed from input, otherwise it is interpreted as a Char-Bag argument to String-Trim.
  • Function PROMPT-FOR-YES-OR-NO (&key ((must-exist *parse-value-must-exist*) common-lisp:t) (default common-lisp:nil defaultp) ((default-string *parse-default-string*)) ((prompt *parse-prompt*) "yes or no? ") ((help *parse-help*) "type yes or no."))
    Prompts for Yes or No.
  • Function PROMPT-FOR-Y-OR-N (&key ((must-exist must-exist) common-lisp:t) (default common-lisp:nil defaultp) default-string ((prompt prompt) "y or n? ") ((help *parse-help*) "type y or n."))
    Prompts for Y or N.
  • Function PROMPT-FOR-KEY-EVENT (&key (prompt "key-event: ") (change-window common-lisp:t))
    Prompts for a key-event.
  • Function PROMPT-FOR-KEY (&key ((must-exist must-exist) common-lisp:t) default default-string (prompt "key: ") ((help *parse-help*) "type a key."))
  • Function LOGICAL-KEY-EVENT-P (key-event keyword)
    Return true if key-event has been defined to have Keyword as its logical key-event. The relation between logical and real key-events is defined by using SETF on LOGICAL-KEY-EVENT-P. If it is set to true then calling LOGICAL-KEY-EVENT-P with the same key-event and Keyword, will result in truth. Setting to false produces the opposite result. See DEFINE-LOGICAL-KEY-EVENT and COMMAND-CASE.
  • Function (setf LOGICAL-KEY-EVENT-P) (new-value key-event keyword)
    Change what Logical-Char= returns for the specified arguments.
  • Function LOGICAL-KEY-EVENT-KEY-EVENTS (keyword)
    Return the list of key-events for which Keyword is the logical key-event.
  • Function DEFINE-LOGICAL-KEY-EVENT (name documentation)
    Define a logical key-event having the specified Name and Documentation. See LOGICAL-KEY-EVENT-P and COMMAND-CASE.
  • Method INSERT-CHARACTER (mark character)
  • Method INSERT-STRING (mark string &optional (start 0) (end (common-lisp:length common-lisp:string)))
  • Method INSERT-REGION (mark region)
  • Method NINSERT-REGION (mark region)
  • Method DELETE-CHARACTERS (mark &optional (n 1))
  • Method DELETE-REGION (region)
  • Method DELETE-AND-SAVE-REGION (region)
  • Variable *RANDOM-TYPEOUT-BUFFERS*
    nil
    A list of random-typeout buffers.
  • Function WORD-OFFSET (mark offset)
    Move Mark by Offset words.
  • Function INTERACTIVE
    Return true if we are in a command invoked by the user. This is primarily useful for commands which want to know whether do something when an error happens, or just signal an Editor-Error.
  • Function SAVE-FOR-UNDO (name method &optional cleanup method-undo (buffer (current-buffer)))
    Stashes information for next "Undo" command invocation. If there is an undo-info object, it is cleaned up first.
  • Function MAKE-REGION-UNDO (kind name region &optional mark-or-region)
  • Function ACTIVATE-REGION (&optional buffer)
    Make the current region active.
  • Function DEACTIVATE-REGION (&optional buffer)
    Make the current region not active.
  • Function REGION-ACTIVE-P (&optional buffer)
    Returns t or nil, depending on whether the current region is active.
  • Function CHECK-REGION-ACTIVE (&optional buffer)
    Signals an error when active regions are enabled and the current region is not active.
  • Function CURRENT-REGION (&optional (error-if-not-active common-lisp:t) (deactivate-region common-lisp:t))
    Returns a region formed by CURRENT-MARK and CURRENT-POINT, optionally signalling an editor error if the current region is not active. A new region is cons'ed on each call. This optionally deactivates the region.
  • Function CURRENT-MARK
    Returns the top of the current buffer's mark stack.
  • Function BUFFER-MARK (buffer)
    Returns the top of buffer's mark stack.
  • Function POP-BUFFER-MARK
    Pops the current buffer's mark stack, returning the mark. If the stack becomes empty, a mark is push on the stack pointing to the buffer's start. This always makes the current region not active.
  • Function PUSH-BUFFER-MARK (mark &optional (activate-region common-lisp:nil))
    Pushes mark into buffer's mark ring, ensuring that the mark is in the right buffer and :right-inserting. Optionally, the current region is made active. This never deactivates the current region. Mark is returned.
  • Function KILL-REGION (region current-type)
    Kills the region saving it in *kill-ring*. Current-type is either :kill-forward or :kill-backward. When LAST-COMMAND-TYPE is one of these, region is appended or prepended, respectively, to the top of *kill-ring*. The killing of the region is undo-able with "Undo". LAST-COMMAND-TYPE is set to current-type. This interacts with KILL-CHARACTERS.
  • Function KILL-CHARACTERS (mark count)
    Kills count characters after mark if positive, before mark if negative. If called multiple times contiguously such that the sum of the count values equals "Character Deletion Threshold", then the characters are saved on *kill-ring*. This relies on setting LAST-COMMAND-TYPE, and it interacts with KILL-REGION. If there are not count characters in the appropriate direction, no characters are deleted, and nil is returned; otherwise, mark is returned.
  • Function INDENT-REGION-FOR-COMMANDS (region)
    Indents region undoably with INDENT-REGION.
  • Function INDENT-REGION (region)
    Invokes function held by Hemlock variable "Indent Function" on every line of region.
  • Function DELETE-HORIZONTAL-SPACE (mark)
    Deletes all :space characters on either side of mark.
  • Function GET-SEARCH-PATTERN (string direction)
  • Function PROCESS-FILE-OPTIONS (buffer &optional (pathname (buffer-pathname hemlock-internals:buffer)))
    Checks for file options and invokes handlers if there are any. If no "Mode" mode option is specified, then this tries to invoke the appropriate file type hook.
  • Macro DEFINE-FILE-OPTION (name lambda-list &body body)
    Define-File-Option Name (Buffer Value) {Form}* Defines a new file option to be user in the -*- line at the top of a file. The body is evaluated with Buffer bound to the buffer the file has been read into and Value to the string argument to the option.
  • Macro DEFINE-FILE-TYPE-HOOK (type-list (buffer type) &body body)
    Define-File-Type-Hook ({Type}*) (Buffer Type) {Form}* Define some code to be evaluated when a file having one of the specified Types is read by a file command. Buffer is bound to the buffer the file is in, and Type is the actual type read.
  • Function BUFFER-DEFAULT-PATHNAME (buffer)
    Returns "Buffer Pathname" if it is bound. If it is not, and buffer's name is composed solely of alphnumeric characters, then return a pathname formed from the buffer's name. If the buffer's name has other characters in it, then return the value of "Last Resort Pathname Defaults Function" called on buffer.
  • Function PATHNAME-TO-BUFFER-NAME (pathname)
    Returns a simple-string using components from pathname.
  • Function FIND-FILE-BUFFER (pathname)
    Return a buffer assoicated with the file Pathname, reading the file into a new buffer if necessary. The second value is T if we created a buffer, NIL otherwise. If the file has already been read, we check to see if the file has been modified on disk since it was read, giving the user various recovery options.
  • Function READ-BUFFER-FILE (pathname buffer)
    Delete the buffer's region, and uses READ-FILE to read pathname into it. If the file exists, set the buffer's write date to the file's; otherwise, MESSAGE that this is a new file and set the buffer's write date to nil. Move buffer's point to the beginning, set the buffer unmodified. If the file exists, set the buffer's pathname to the probed pathname; else, set it to pathname merged with DEFAULT-DIRECTORY. Set "Pathname Defaults" to the same thing. Process the file options, and then invoke "Read File Hook".
  • Function WRITE-BUFFER-FILE (buffer pathname)
    Write's buffer to pathname. This assumes pathname is somehow related to the buffer's pathname, and if the buffer's write date is not the same as pathname's, then this prompts the user for confirmation before overwriting the file. This consults "Add Newline at EOF on Writing File" and interacts with the user if necessary. This sets "Pathname Defaults", and the buffer is marked unmodified. The buffer's pathname and write date are updated, and the buffer is renamed according to the new pathname if possible. This invokes "Write File Hook".
  • Function PREVIOUS-BUFFER
    Returns some previously selected buffer that is not the current buffer. Returns nil if no such buffer exists.
  • Function CHANGE-TO-BUFFER (buffer)
    Switches to buffer in the current window maintaining *buffer-history*.
  • Function DELETE-BUFFER-IF-POSSIBLE (buffer)
    Deletes a buffer if at all possible. If buffer is the only buffer, other than the echo area, signals an error. Otherwise, find some recently current buffer, and make all of buffer's windows display this recent buffer. If buffer is current, set the current buffer to be this recently current buffer.
  • Function CHECK-REGION-QUERY-SIZE (region)
    Checks the number of lines in region against "Region Query Size" and asks the user if the region crosses this threshold. If the user responds negatively, then an editor error is signaled.
  • Function SUPPLY-GENERIC-POINTER-UP-FUNCTION (fun)
    This provides the action "Generic Pointer Up" command performs.
  • Function GOTO-PAGE (mark i)
  • Function DISPLAY-PAGE-DIRECTORY (stream directory)
    This writes the list of strings, directory, to stream, enumerating them in a field of three characters. The number and string are separated by two spaces, and the first line contains headings for the numbers and strings columns.
  • Function PAGE-DIRECTORY (buffer)
    Return a list of strings where each is the first non-blank line following a :page-delimiter in buffer.
  • Function PAGE-OFFSET (mark n)
    Move mark past n :page-delimiters that are in the zero'th line position. If a :page-delimiter is the immediately next character after mark in the appropriate direction, then skip it before starting.
  • Macro DO-ACTIVE-GROUP (&rest forms)
    This iterates over the active file group executing forms once for each file. When forms are executed, the file will be in the current buffer, and the point will be at the start of the file.
  • Function FILL-REGION-BY-PARAGRAPHS (region &optional (prefix (value hemlock::fill-prefix)) (column (value hemlock::fill-column)))
    Finds paragraphs in region and fills them as distinct regions using FILL-REGION.
  • Function FILL-REGION (region &optional (prefix (value hemlock::fill-prefix)) (column (value hemlock::fill-column)))
    Fills a region using the given prefix and column.
  • Function MARK-PARAGRAPH (mark1 mark2)
    Mark the next or current paragraph, setting mark1 to the beginning and mark2 to the end. This uses "Fill Prefix", and mark1 is always on the first line of the paragraph. If no paragraph is found, then the marks are not moved, and nil is returned.
  • Function PARAGRAPH-OFFSET (mark number &optional (prefix (value hemlock::fill-prefix)))
    moves mark past the specified number of paragraph, forward if the number is positive and vice versa. If the specified number of paragraphs do not exist in the direction indicated by the sign of the number, then nil is returned, otherwise the mark is returned.
  • Function SENTENCE-OFFSET (mark number)
  • Function PRE-COMMAND-PARSE-CHECK (mark &optional (fer-sure-parse common-lisp:nil))
    Parse the area before the command is actually executed.
  • Function VALID-SPOT (mark forwardp)
    Return true if the character pointed to by Mark is not in a quoted context, false otherwise. If Forwardp is true, we use the next character, otherwise we use the previous.
  • Function FORWARD-UP-LIST (mark)
    Moves mark just past the closing paren of the immediately containing list.
  • Function BACKWARD-UP-LIST (mark)
    Moves mark just before the opening paren of the immediately containing list.
  • Function TOP-LEVEL-OFFSET (mark offset)
    Go forward or backward offset number of top level forms. Mark is returned if offset forms exists, otherwise nil.
  • Function MARK-TOP-LEVEL-FORM (mark1 mark2)
    Moves mark1 and mark2 to the beginning and end of the current or next defun. Mark1 one is used as a reference. The marks may be altered even if unsuccessful. if successful, return mark2, else nil.
  • Function INSIDE-DEFUN-P (mark)
    T if the current point is (supposedly) in a top level form.
  • Function START-DEFUN-P (mark)
    Returns t if mark is sitting before an :open-paren at the beginning of a line.
  • Function FORM-OFFSET (mark offset)
    Move mark offset number of forms, after if positive, before if negative. Mark is always moved. If there weren't enough forms, returns nil instead of mark.
  • Function DEFINDENT (fname args)
    Define Fname to have Args special arguments. If args is null then remove any special arguments information.
  • Macro IN-LISP (&body body)
    Evaluates body inside HANDLE-LISP-ERRORS. *package* is bound to the package named by "Current Package" if it is non-nil.
  • Function DEFUN-REGION (mark)
    This returns a region around the current or next defun with respect to mark. Mark is not used to form the region. If there is no appropriate top level form, this signals an editor-error. This calls PRE-COMMAND-PARSE-CHECK.
  • Function ADD-DEFINITION-DIR-TRANSLATION (dir1 dir2)
    Takes two directory namestrings and causes the first to be mapped to the second. This is used in commands like "Edit Definition". Successive uses of this push into a list of translations that will be tried in order of traversing the list.
  • Function DELETE-DEFINITION-DIR-TRANSLATION (directory)
    Deletes the mapping of directory to all other directories for definition editing commands.

Also exports

  • HEMLOCK.WIRE:DISPATCH-EVENTS
  • HEMLOCK.WIRE:DISPATCH-EVENTS-NO-HANG

HEMLOCK-EXT

  • Function GETENV (name)
  • Macro WITHOUT-INTERRUPTS (&body body)
  • Macro FIXNUMP (object)
  • Function FILE-WRITABLE (pathname)
    File-writable accepts a pathname and returns T if the current process can write it, and NIL otherwise. Also if the file does not exist return T.
  • Macro WITHOUT-GCING (&body body)
  • Function QUIT
  • Function DEFAULT-DIRECTORY
  • Function MAKE-OBJECT-SET (name &optional (default-handler nil))
  • Macro WITH-CLX-EVENT-HANDLING ((display handler) &rest body)
    Evaluates body in a context where events are handled for the display by calling handler on the display. This destroys any previously established handler for display.
  • Function SERVE-KEY-PRESS (object-set fun)
    Associate a method in the object-set with :key-press events. The method is called on the object the event occurred, event key, event window, root, child, same-screen-p, x, y, root-x, root-y, state, time, code, and send-event-p.
  • Function SERVE-BUTTON-PRESS (object-set fun)
    Associate a method in the object-set with :button-press events. The method is called on the object the event occurred, event key, event window, root, child, same-screen-p, x, y, root-x, root-y, state, time, code, and send-event-p.
  • Function SERVE-BUTTON-RELEASE (object-set fun)
    Associate a method in the object-set with :button-release events. The method is called on the object the event occurred, event key, event window, root, child, same-screen-p, x, y, root-x, root-y, state, time, code, and send-event-p.
  • Function SERVE-ENTER-NOTIFY (object-set fun)
    Associate a method in the object-set with :enter-notify events. The method is called on the object the event occurred, event key, event window, root, child, same-screen-p, x, y, root-x, root-y, state, time, mode, kind, and send-event-p.
  • Function SERVE-LEAVE-NOTIFY (object-set fun)
    Associate a method in the object-set with :leave-notify events. The method is called on the object the event occurred, event key, event window, root, child, same-screen-p, x, y, root-x, root-y, state, time, mode, kind, and send-event-p.
  • Function SERVE-EXPOSURE (object-set fun)
    Associate a method in the object-set with :exposure events. The method is called on the object the event occurred, event key, event window, x, y, width, height, count, and send-event-p.
  • Function SERVE-GRAPHICS-EXPOSURE (object-set fun)
    Associate a method in the object-set with :graphics-exposure events. The method is called on the object the event occurred, event key, event window, x, y, width, height, count, major, minor, and send-event-p.
  • Function SERVE-NO-EXPOSURE (object-set fun)
    Associate a method in the object-set with :no-exposure events. The method is called on the object the event occurred, event key, event window, major, minor, and send-event-p.
  • Function SERVE-DESTROY-NOTIFY (object-set fun)
    Associate a method in the object-set with :destroy-notify events. The method is called on the object the event occurred, event key, event window, window, and send-event-p.
  • Function SERVE-UNMAP-NOTIFY (object-set fun)
    Associate a method in the object-set with :unmap-notify events. The method is called on the object the event occurred, event key, event window, window, configure-p, and send-event-p.
  • Function SERVE-MAP-NOTIFY (object-set fun)
    Associate a method in the object-set with :map-notify events. The method is called on the object the event occurred, event key, event window, window, override-redirect-p, and send-event-p.
  • Function SERVE-REPARENT-NOTIFY (object-set fun)
    Associate a method in the object-set with :reparent-notify events. The method is called on the object the event occurred, event key, event window, window, parent, x, y, override-redirect-p, and send-event-p.
  • Function SERVE-CONFIGURE-NOTIFY (object-set fun)
    Associate a method in the object-set with :configure-notify events. The method is called on the object the event occurred, event key, event window, window, x, y, width, height, border-width, above-sibling, override-redirect-p, and send-event-p.
  • Function SERVE-GRAVITY-NOTIFY (object-set fun)
    Associate a method in the object-set with :gravity-notify events. The method is called on the object the event occurred, event key, event window, window, x, y, and send-event-p.
  • Function SERVE-CIRCULATE-NOTIFY (object-set fun)
    Associate a method in the object-set with :circulate-notify events. The method is called on the object the event occurred, event key, event window, window, place, and send-event-p.
  • Function SERVE-CLIENT-MESSAGE (object-set fun)
    Associate a method in the object-set with :client-message events. The method is called on the object the event occurred, event key, event window, format, data, and send-event-p.
  • Function DELQ (item list)
  • Function MEMQ (item list)
  • Function ASSQ (item alist)
  • Function CONCAT (&rest args)
  • Function COMPLETE-FILE (pathname &key (defaults *default-pathname-defaults*) ignore-types)
  • Function AMBIGUOUS-FILES (pathname &optional (defaults *default-pathname-defaults*))
    Return a list of all files which are possible completions of Pathname. We look in the directory specified by Defaults as well as looking down the search list.
  • Function SET-FILE-PERMISSIONS (pathname access)
  • Function NAME-KEYSYM (name)
    This returns the keysym named name. If name is unknown, this returns nil.
  • Function KEYSYM-NAMES (keysym)
    This returns the list of all names for keysym. If keysym is undefined, this returns nil.
  • Function KEYSYM-PREFERRED-NAME (keysym)
    This returns the preferred name for keysym, how it is typically printed. If keysym is undefined, this returns nil.
  • Function DEFINE-KEYSYM (keysym preferred-name &rest other-names)
    This establishes a mapping from preferred-name to keysym for purposes of specifying key-events in #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. Redefining a keysym or re-using names has undefined effects.
  • Function DEFINE-MOUSE-KEYSYM (button keysym name shifted-bit event-key)
    This defines keysym named name for the X button cross the X event-key. Shifted-bit is a defined modifier name that TRANSLATE-MOUSE-KEY-EVENT sets in the key-event it returns whenever the X shift bit is on.
  • Function TRANSLATE-MOUSE-KEY-EVENT (scan-code bits event-key)
    This translates the X button code, scan-code, and modifier bits, bits, for the X event-key into a key-event. See DEFINE-MOUSE-KEYSYM.
  • Struct KEY-EVENT
    BITS
    KEYSYM
  • Function KEY-EVENT-P (object)
  • Function KEY-EVENT-BITS (instance)
  • Function (setf KEY-EVENT-BITS) (value instance)
  • Function KEY-EVENT-KEYSYM (instance)
  • Function (setf KEY-EVENT-KEYSYM) (value instance)
  • Variable *ALL-MODIFIER-NAMES*
    nil
    A list of all the names of defined modifiers.
  • Function DEFINE-KEY-EVENT-MODIFIER (long-name short-name)
    This establishes long-name and short-name as modifier names for purposes of specifying key-events in #k syntax. The names are case-insensitive and must be strings. If either name is already defined, this signals an error.
  • Function DEFINE-CLX-MODIFIER (clx-mask modifier-name)
    This establishes a mapping from clx-mask to a define key-event modifier-name. TRANSLATE-KEY-EVENT and TRANSLATE-MOUSE-KEY-EVENT can only return key-events with bits defined by this routine.
  • Function MAKE-KEY-EVENT-BITS (&rest modifier-names)
    This returns bits suitable for MAKE-KEY-EVENT from the supplied modifier names. If any name is undefined, this signals an error.
  • Function KEY-EVENT-BITS-MODIFIERS (bits)
    This returns a list of key-event modifier names, one for each modifier set in bits.
  • Function KEY-EVENT-MODIFIER-MASK (modifier-name)
    This function returns a mask for modifier-name. This mask is suitable for use with KEY-EVENT-BITS. If modifier-name is undefined, this signals an error.
  • Function MAKE-KEY-EVENT (object &optional (bits 0))
    This returns a key-event described by object with bits. Object is one of keysym, string, or key-event. When object is a key-event, this uses KEY-EVENT-KEYSYM. You can form bits with MAKE-KEY-EVENT-BITS or KEY-EVENT-MODIFIER-MASK.
  • Function KEY-EVENT-BIT-P (key-event bit-name)
    This returns whether key-event has the bit set named by bit-name. This signals an error if bit-name is undefined.
  • Function KEY-EVENT-CHAR (key-event)
    Returns the character associated with key-event. This is SETF'able.
  • Function (setf KEY-EVENT-CHAR) (character key-event)
  • Function CHAR-KEY-EVENT (char)
    Returns the key-event associated with char. This is SETF'able.
  • Function (setf CHAR-KEY-EVENT) (key-event char)
  • Macro DO-ALPHA-KEY-EVENTS ((var kind &optional result) &rest forms)
    (DO-ALPHA-KEY-EVENTS (var kind [result]) {form}*) This macro evaluates each form with var bound to a key-event representing an alphabetic character. Kind is one of :lower, :upper, or :both, and this binds var to each key-event in order as specified in the X11 protocol specification. When :both is specified, this processes lowercase letters first.
  • Function PRINT-PRETTY-KEY (key &optional (stream *standard-output*) long-names-p)
    This prints key, a key-event or vector of key-events, to stream in a user-expected fashion. Long-names-p indicates whether modifiers should print with their long or short name.
  • Function PRINT-PRETTY-KEY-EVENT (key-event &optional (stream *standard-output*) long-names-p)
    This prints key-event to stream. Long-names-p indicates whether modifier names should appear using the long name or short name.
  • Function PRINT-DIRECTORY (pathname stream &key all verbose return-list)
    Like Directory, but prints a terse, multi-column directory listing instead of returning a list of pathnames. When :all is supplied and non-nil, then Unix dot files are included too (as ls -a). When :verbose is supplied and non-nil, then a long listing of miscellaneous information is output one file per line.

HEMLOCK-INTERNALS

  • Variable *FAST*
    '(declare (optimize speed))
  • Variable *FAST*
    '(declare)
  • Class FONT-MARK  (MARK)
    FONT   Accessor: FONT-MARK-FONT
  • Struct BUFFER
    A Hemlock buffer object. See Hemlock Command Implementor's Manual for details.
    %NAME
    %REGION
    %PATHNAME
    MODES
    MODE-OBJECTS
    BINDINGS
    POINT
    %WRITABLE
    MODIFIED-TICK
    UNMODIFIED-TICK
    WINDOWS
    VAR-VALUES
    VARIABLES
    WRITE-DATE
    ACTIVE-REGION-P
    DISPLAY-START
    %MODELINE-FIELDS
    DELETE-HOOK
    WIDGET
    TAG-LINE-NUMBER
    UNDO-P
    UNDO-LIST
  • Struct COMMAND
    %NAME
    DOCUMENTATION
    FUNCTION
    %BINDINGS
  • Function MERGE-RELATIVE-PATHNAMES (pathname default-directory)
    Merges pathname with default-directory. If pathname is not absolute, it is assumed to be relative to default-directory. The result is always a directory.
  • Function DIRECTORYP (pathname)
    Returns whether pathname names a directory, that is whether it has no name and no type components.
  • Variable *BEEP-FUNCTION*
    #'(lambda (&optional stream)
        (declare (ignorable stream))
        (print "beep!" *trace-output*)
        (finish-output *trace-output*))
  • Function BEEP (&optional (stream *terminal-io*))
  • Function FUN-DEFINED-FROM-PATHNAME (function)
    Takes a symbol or function and returns the pathname for the file the function was defined in. If it was not defined in some file, nil is returned.
  • Function EDITOR-DESCRIBE-FUNCTION (fun sym)
    Calls DESCRIBE on fun. If fun is compiled, and its original name is not sym, then this also outputs any 'function documentation for sym to *standard-output*.
  • Variable *REAL-EDITOR-INPUT*
    nil
    Useful when we want to read from the terminal when *editor-input* is rebound.
  • Variable *LAST-KEY-EVENT-TYPED*
    nil
    This variable contains the last key-event typed by the user and read as input.
  • Variable *KEY-EVENT-HISTORY*
    nil
    This ring holds the last 60 key-events read by the command interpreter.
  • Variable *INPUT-TRANSCRIPT*
    nil
    If this variable is non-null then it should contain an adjustable vector with a fill pointer into which all keyboard input will be pushed.
  • Function INPUT-WAITING
    Returns true if there is a key-event which has been unread-key-event'ed on *editor-input*. Used by the keyboard macro stuff.
  • Function CANONICAL-CASE (string)
  • Class LINE
    A Hemlock line object. See Hemlock design document for details.
    CHARS   Accessor: LINE-CHARS
    Something that represents the contents of the line. This is guaranteed to change (as compared by EQL) whenver the contents of the line changes, but might at arbitarary other times. There are currently about two different cases: Normal: A simple string holding the contents of the line. A cached line: The line is eq to Open-Line, and the actual contents are in the line cache. The %Chars may be either the original contents or a negative fixnum.
    PREVIOUS   Accessor: LINE-PREVIOUS
    Pointer to the previous line in the doubly linked list of line instances.
    NEXT   Accessor: LINE-NEXT
    Pointer to the next line in the doubly linked list of line instances.
    MARKS   Accessor: LINE-MARKS
    A list of all the permanent marks pointing into this line.
    %BUFFER   Accessor: LINE-%BUFFER
    The buffer to which this line belongs, or a *disembodied-buffer-count* if the line is not in any buffer.
    NUMBER   Accessor: LINE-NUMBER
    A non-negative integer (fixnum) that represents the ordering of lines within continguous range of lines (a buffer or disembuffered region). The number of the Line-Next is guaranteed to be strictly greater than our number, and the Line-Previous is guaranteed to be strictly less.
    PLIST   Accessor: LINE-PLIST
    The line property list, used by user code to annotate the text.
    TAG   Accessor: %LINE-TAG
    Line tag, which records information available only if all preceding lines have been analyzed yet.
  • Struct RING
    Used with Ring-Push and friends to implement ring buffers.
    FIRST
    BOUND
    DELETE-FUNCTION
    VECTOR
  • Variable *BUFFER-LIST*
    nil
    A list of all the buffer objects.
  • Variable *INVOKE-HOOK*
    #'(lambda (hemlock-internals:command hemlock-internals::p)
        (funcall (hemlock-interface:command-function hemlock-internals:command)
                 hemlock-internals::p))
    This function is called by the command interpreter when it wants to invoke a command. The arguments are the command to invoke and the prefix argument. The default value just calls the Command-Function with the prefix argument.
  • Variable *PRINT-REGION*
    10
    The number of lines to print out of a region, or NIL if none.
  • Struct SEARCH-PATTERN
    KIND
    DIRECTION
    PATTERN
    SEARCH-FUNCTION
    RECLAIM-FUNCTION
  • Struct STRING-TABLE
    This structure is used to implement the Hemlock string-table type.
    SEPARATOR
    NUM-NODES
    VALUE-NODES
    FIRST-WORD-TABLE
  • Function FONT-MARK (line charpos font &optional (kind :right-inserting))
    Returns a font on line at charpos with font. Font marks must be permanent marks.
  • Function DELETE-FONT-MARK (font-mark)
    Deletes a font mark.
  • Function DELETE-LINE-FONT-MARKS (line)
    Deletes all font marks on line.
  • Function MOVE-FONT-MARK (font-mark new-position)
    Moves font mark font-mark to location of mark new-position.
  • Function WINDOW-FONT (window font)
    Returns a font id for window and font.
  • Function (setf WINDOW-FONT) (font-object window font)
    Change the font-object associated with a font-number in a window.
  • Class HEMLOCK-OUTPUT-STREAM  (TRIVIAL-GRAY-STREAM-MIXIN, FUNDAMENTAL-CHARACTER-OUTPUT-STREAM, FUNDAMENTAL-CHARACTER-INPUT-STREAM)
    MARK   Accessor: HEMLOCK-OUTPUT-STREAM-MARK
    The mark we insert at.
    INPUT-STRING
    INPUT-POS
    OUT   Accessor: OLD-LISP-STREAM-OUT
    SOUT   Accessor: OLD-LISP-STREAM-SOUT
  • Class HEMLOCK-REGION-STREAM  (FUNDAMENTAL-CHARACTER-INPUT-STREAM)
    REGION   Accessor: HEMLOCK-REGION-STREAM-REGION
    MARK   Accessor: HEMLOCK-REGION-STREAM-MARK
  • Function MAKE-KBDMAC-STREAM
  • Function MODIFY-KBDMAC-STREAM (stream input)
  • Variable *GLOBAL-VARIABLE-NAMES*
    (hemlock-interface:make-string-table)
    A String Table of global variable names, the values are the symbol names.
  • Variable *MODE-NAMES*
    (hemlock-interface:make-string-table)
    A String Table of Mode names.
  • Variable *BUFFER-NAMES*
    (hemlock-interface:make-string-table)
    A String Table of Buffer names and their corresponding objects.
  • Variable *COMMAND-NAMES*
    (hemlock-interface:make-string-table)
    String table of command names.
  • Variable *CHARACTER-ATTRIBUTE-NAMES*
    (hemlock-interface:make-string-table)
    String Table of character attribute names and their corresponding keywords.
  • Variable *BACKGROUND-IMAGE*
    :auto
    Path to a background image in SVG format, or one of :AUTO, NIL. Possible values indicate: - STRING or PATHNAME -- Open this file name. - The symbol :AUTO -- Try to open ~/.hemlock/background.svg, then background.svg in Hemlock's installation directory (in this order). - The symbol NIL -- No background image. (Not using a background image is faster, especially with remote X.) Currently supported only in the Qt backend.
  • Macro AFTER-EDITOR-INITIALIZATIONS (&rest forms)
    Causes forms to be executed after the editor has been initialized. Forms supplied with successive uses of this macro will be executed after forms supplied with previous uses.
  • Function MAIN (&optional (arg-list (get-command-line-arguments)))
  • Macro WITH-EDITOR ((&key (load-user-init t) backend-type display) &body body)
  • Function HEMLOCK (&optional x &key (load-user-init t) backend-type (display (iolib/syscalls:getenv "display")))
    Invokes the editor, Hemlock. If X is supplied and is a symbol, the definition of X is put into a buffer, and that buffer is selected. If X is a pathname, the file specified by X is visited in a new buffer. If X is not supplied or Nil, the editor is entered in the same state as when last exited. When :init is supplied as t (the default), the file "hemlock-init.lisp", or ".hemlock-init.lisp" is loaded from the home directory, but the Lisp command line switch -hinit can be used to specify a different name. Any compiled version of the source is preferred when choosing the file to load. If the argument is non-nil and not t, then it should be a pathname that will be merged with the home directory.
  • Function CALL-WITH-EDITOR (fun &key (load-user-init t) backend-type (display (iolib/syscalls:getenv "display")))
  • Variable *ECHO-AREA-STREAM*
    (hemlock-interface:make-hemlock-output-stream
     (hemlock-interface:region-end hemlock-internals::*echo-area-region*) :full)
    Buffered stream that prints into the echo area.
  • Variable *PARSE-STARTING-MARK*
    (hemlock-interface:copy-mark
     (hemlock-interface:buffer-point hemlock-interface:*echo-area-buffer*)
     :right-inserting)
    Mark that points to the beginning of the text that'll be parsed.
  • Variable *PARSE-INPUT-REGION*
    (hemlock-interface:region hemlock-internals:*parse-starting-mark*
                              (hemlock-interface:region-end
                               hemlock-internals::*echo-area-region*))
    Region that contains the text typed in.
  • Variable *PARSE-VERIFICATION-FUNCTION*
    'hemlock-internals::%not-inside-a-parse
    Function that verifies what's being parsed.
  • Variable *PARSE-STRING-TABLES*
    nil
    String tables being used in the current parse.
  • Variable *PARSE-VALUE-MUST-EXIST*
    nil
    You know.
  • Variable *PARSE-DEFAULT*
    nil
    When the user attempts to default a parse, we call the verification function on this string. This is not the :Default argument to the prompting function, but rather a string representation of it.
  • Variable *PARSE-DEFAULT-STRING*
    nil
    String that we show the user to inform him of the default. If this is NIL then we just use *Parse-Default*.
  • Variable *PARSE-PROMPT*
    nil
    Prompt for the current parse.
  • Variable *PARSE-HELP*
    nil
    Help string for the current parse.
  • Variable *PARSE-TYPE*
    :string
    A hack. :String, :File or :Keyword.
  • Variable *INVOKE-HOOK*
    #'(lambda (hemlock-internals:command hemlock-internals::p)
        (hemlock-internals::new-undo-invoke-hook hemlock-internals:command
                                                 hemlock-internals::p)
        (funcall (hemlock-interface:command-function hemlock-internals:command)
                 hemlock-internals::p)
        (setf hemlock-internals::last-was-undo-p hemlock-internals::this-is-undo-p))
    This function is called by the command interpreter when it wants to invoke a command. The arguments are the command to invoke and the prefix argument. The default value just calls the Command-Function with the prefix argument.

Also exports

  • HEMLOCK-INTERFACE:BUFFERP
  • HEMLOCK-INTERFACE:FIND-AMBIGUOUS
  • HEMLOCK-INTERFACE:EDITOR-FINISH-OUTPUT
  • HEMLOCK-INTERFACE:BUFFER-POINT
  • HEMLOCK-INTERFACE:WINDOW-DISPLAY-START
  • HEMLOCK-INTERFACE:DELETE-KEY-BINDING
  • HEMLOCK-INTERFACE:LAST-KEY-EVENT-CURSORPOS
  • HEMLOCK-INTERFACE:MOVE-MARK
  • HEMLOCK-INTERFACE:MAKE-HEMLOCK-REGION-STREAM
  • HEMLOCK-INTERFACE:LOGICAL-KEY-EVENT-KEY-EVENTS
  • HEMLOCK-INTERFACE:IN-RECURSIVE-EDIT
  • HEMLOCK-INTERFACE:BUFFER-SIGNATURE
  • HEMLOCK-INTERFACE:WINDOW-HEIGHT
  • HEMLOCK-INTERFACE:*ECHO-AREA-WINDOW*
  • HEMLOCK-INTERFACE:SEARCH-PATTERN-P
  • HEMLOCK-INTERFACE:RINGP
  • HEMLOCK-INTERFACE:COPY-REGION
  • HEMLOCK-INTERFACE:MARK-TO-CURSORPOS
  • HEMLOCK-INTERFACE:STORE-CUT-STRING
  • HEMLOCK-INTERFACE:DEFAULT-FONT
  • HEMLOCK-INTERFACE:DEFATTRIBUTE
  • HEMLOCK-INTERFACE:LINE-OFFSET
  • HEMLOCK-INTERFACE:LINE-LENGTH
  • HEMLOCK-INTERFACE:FIND-PATTERN
  • HEMLOCK-INTERFACE:UPDATE-MODELINE-FIELDS
  • HEMLOCK-INTERFACE:FIND-ATTRIBUTE
  • HEMLOCK-INTERFACE:DEFCOMMAND
  • HEMLOCK-INTERFACE:PROMPT-FOR-EXPRESSION
  • HEMLOCK-INTERFACE:UNGET-KEY-EVENT
  • HEMLOCK-INTERFACE:BLANK-BEFORE-P
  • HEMLOCK-INTERFACE:REMOVE-SCHEDULED-EVENT
  • HEMLOCK-INTERFACE:CLEAR-ECHO-AREA
  • HEMLOCK-INTERFACE:LINE>=
  • HEMLOCK-INTERFACE:NEXT-WINDOW
  • HEMLOCK-INTERFACE:LINE-NEXT
  • HEMLOCK-INTERFACE:STRING-TO-REGION
  • HEMLOCK-INTERFACE:BUFFER-NAME
  • HEMLOCK-EXT:CONCAT
  • HEMLOCK-INTERFACE:ROTATE-RING
  • HEMLOCK-INTERFACE:REGION-END
  • HEMLOCK-INTERFACE:MODELINE-FIELD-P
  • HEMLOCK-INTERFACE:PREVIOUS-WINDOW
  • HEMLOCK-INTERFACE:LINE-START
  • HEMLOCK-INTERFACE:GET-KEY-EVENT
  • HEMLOCK-INTERFACE:PROMPT-FOR-YES-OR-NO
  • HEMLOCK-INTERFACE:WRITE-FILE
  • HEMLOCK-INTERFACE:STRING-TABLE-P
  • HEMLOCK-INTERFACE:MARKP
  • HEMLOCK-INTERFACE:CURSORPOS-TO-MARK
  • HEMLOCK-INTERFACE:BUFFER-MODES
  • HEMLOCK-INTERFACE:DO-ALPHA-CHARS
  • HEMLOCK-INTERFACE:SETV
  • HEMLOCK-INTERFACE:BUFFER-END
  • HEMLOCK-INTERFACE:LINE-END
  • HEMLOCK-INTERFACE:LOUD-MESSAGE
  • HEMLOCK-INTERFACE:EXIT-RECURSIVE-EDIT
  • HEMLOCK-INTERFACE:EMPTY-LINE-P
  • HEMLOCK-INTERFACE:MODELINE-FIELD
  • HEMLOCK-INTERFACE:CHARACTER-ATTRIBUTE-P
  • HEMLOCK-INTERFACE:LINE-PREVIOUS
  • HEMLOCK-INTERFACE:*CREATE-INITIAL-WINDOWS-HOOK*
  • HEMLOCK-INTERFACE:WINDOW
  • HEMLOCK-INTERFACE:DELETE-STRING
  • HEMLOCK-INTERFACE:HANDLE-LISP-ERRORS
  • HEMLOCK-INTERFACE:COUNT-CHARACTERS
  • HEMLOCK-INTERFACE:NEW-SEARCH-PATTERN
  • HEMLOCK-INTERFACE:BUFFER-DELETE-HOOK
  • HEMLOCK-INTERFACE:DELETE-AND-SAVE-REGION
  • HEMLOCK-INTERFACE:LAST-LINE-P
  • HEMLOCK-INTERFACE:CLEAR-EDITOR-INPUT
  • HEMLOCK-INTERFACE:MARK-BEFORE
  • HEMLOCK-INTERFACE:SAME-LINE-P
  • HEMLOCK-INTERFACE:PROMPT-FOR-INTEGER
  • HEMLOCK-INTERFACE:WINDOWP
  • HEMLOCK-INTERFACE:DISPLAYED-P
  • HEMLOCK-INTERFACE:REGION-BOUNDS
  • HEMLOCK-INTERFACE:ADD-HOOK
  • HEMLOCK-INTERFACE:INSERT-CHARACTER
  • HEMLOCK-INTERFACE:MAKE-HEMLOCK-OUTPUT-STREAM
  • HEMLOCK-INTERFACE:MODELINE-FIELD-NAME
  • HEMLOCK-INTERFACE:WITH-WRITABLE-BUFFER
  • HEMLOCK-INTERFACE:REGION-TO-STRING
  • HEMLOCK-INTERFACE:RECURSIVE-EDIT
  • HEMLOCK-INTERFACE:GETSTRING
  • HEMLOCK-INTERFACE:PREVIOUS-CHARACTER
  • HEMLOCK-INTERFACE:FETCH-CUT-STRING
  • HEMLOCK-INTERFACE:PROMPT-FOR-VARIABLE
  • HEMLOCK-INTERFACE:START-LINE-P
  • HEMLOCK-INTERFACE:DELETE-VARIABLE
  • HEMLOCK-INTERFACE:DEFINE-LOGICAL-KEY-EVENT
  • HEMLOCK-INTERFACE:CHARACTER-ATTRIBUTE-HOOKS
  • HEMLOCK-INTERFACE:END-LINE-P
  • HEMLOCK-INTERFACE:HEMLOCK-BOUND-P
  • HEMLOCK-INTERFACE:HEMLOCK-OUTPUT-STREAM-P
  • HEMLOCK-INTERFACE:COMMAND-CASE
  • HEMLOCK-INTERFACE:CENTER-WINDOW
  • HEMLOCK-INTERFACE:BUFFER-VARIABLES
  • HEMLOCK-INTERFACE:LINE-TO-REGION
  • HEMLOCK-INTERFACE:BUFFER-MINOR-MODE
  • HEMLOCK-INTERFACE:WINDOW-BUFFER
  • HEMLOCK-INTERFACE:FIRST-LINE-P
  • HEMLOCK-INTERFACE:MARK-AFTER
  • HEMLOCK-INTERFACE:HLET
  • HEMLOCK-INTERFACE:DEFHVAR
  • HEMLOCK-INTERFACE:REPLACE-PATTERN
  • HEMLOCK-INTERFACE:PROMPT-FOR-BUFFER
  • HEMLOCK-INTERFACE:BUFFER-WRITE-DATE
  • HEMLOCK-INTERFACE:REGION-START
  • HEMLOCK-INTERFACE:INVOKE-HOOK
  • HEMLOCK-INTERFACE:WITH-MARK
  • HEMLOCK-INTERFACE:*WINDOW-LIST*
  • HEMLOCK-INTERFACE:PROMPT-FOR-KEY-EVENT
  • HEMLOCK-INTERFACE:MAKE-STRING-TABLE
  • HEMLOCK-INTERFACE:MODE-VARIABLES
  • HEMLOCK-INTERFACE:BUFFER-MAJOR-MODE
  • HEMLOCK-INTERFACE:REGIONP
  • HEMLOCK-INTERFACE:DELETE-CHARACTERS
  • HEMLOCK-INTERFACE:MODELINE-FIELD-WIDTH
  • HEMLOCK-INTERFACE:FILTER-REGION
  • HEMLOCK-INTERFACE:PROMPT-FOR-Y-OR-N
  • HEMLOCK-INTERFACE:COMMAND-DOCUMENTATION
  • HEMLOCK-INTERFACE:CHARACTER-ATTRIBUTE-NAME
  • HEMLOCK-INTERFACE:ABORT-RECURSIVE-EDIT
  • HEMLOCK-INTERFACE:MARK-LINE
  • HEMLOCK-INTERFACE:VARIABLE-DOCUMENTATION
  • HEMLOCK-INTERFACE:RING-PUSH
  • HEMLOCK-INTERFACE:MAKE-BUFFER
  • HEMLOCK-INTERFACE:VARIABLE-HOOKS
  • HEMLOCK-INTERFACE:STRING-TO-VARIABLE
  • HEMLOCK-INTERFACE:COMMAND-BINDINGS
  • HEMLOCK-INTERFACE:KEY-TRANSLATION
  • HEMLOCK-INTERFACE:WITH-OUTPUT-TO-MARK
  • HEMLOCK-INTERFACE:SCHEDULE-EVENT
  • HEMLOCK-INTERFACE:UNSHADOW-ATTRIBUTE
  • HEMLOCK-INTERFACE:MAKE-EMPTY-REGION
  • HEMLOCK-INTERFACE:WITH-POP-UP-DISPLAY
  • HEMLOCK-INTERFACE:CLRSTRING
  • HEMLOCK-INTERFACE:*EDITOR-INPUT*
  • HEMLOCK-INTERFACE:CHARACTER-ATTRIBUTE-DOCUMENTATION
  • HEMLOCK-INTERFACE:WINDOW-POINT
  • HEMLOCK-INTERFACE:MARK=
  • HEMLOCK-INTERFACE:REVERSE-FIND-ATTRIBUTE
  • HEMLOCK-INTERFACE:PROMPT-FOR-KEYWORD
  • HEMLOCK-INTERFACE:CURRENT-BUFFER
  • HEMLOCK-INTERFACE:BUFFER-MODIFIED
  • HEMLOCK-INTERFACE:MARK-KIND
  • HEMLOCK-INTERFACE:CURRENT-VARIABLE-TABLES
  • HEMLOCK-INTERFACE:LOGICAL-KEY-EVENT-P
  • HEMLOCK-INTERFACE:MAKE-COMMAND
  • HEMLOCK-INTERFACE:HEMLOCK-REGION-STREAM-P
  • HEMLOCK-INTERFACE:LINE-STRING
  • HEMLOCK-INTERFACE:BIND-KEY
  • HEMLOCK-INTERFACE:MODELINE-FIELD-FUNCTION
  • HEMLOCK-INTERFACE:USE-BUFFER
  • HEMLOCK-INTERFACE:REGION
  • HEMLOCK-INTERFACE:*ECHO-AREA-BUFFER*
  • HEMLOCK-INTERFACE:SHADOW-ATTRIBUTE
  • HEMLOCK-INTERFACE:BUFFER-START
  • HEMLOCK-INTERFACE:MARK-COLUMN
  • HEMLOCK-INTERFACE:INSERT-REGION
  • HEMLOCK-INTERFACE:MOVE-TO-COLUMN
  • HEMLOCK-INTERFACE:READ-FILE
  • HEMLOCK-INTERFACE:BUFFER-REGION
  • HEMLOCK-INTERFACE:DELETE-MARK
  • HEMLOCK-INTERFACE:WINDOW-DISPLAY-RECENTERING
  • HEMLOCK-INTERFACE:REDISPLAY
  • HEMLOCK-INTERFACE:WITH-INPUT-FROM-REGION
  • HEMLOCK-INTERFACE:RING-REF
  • HEMLOCK-INTERFACE:MARK<
  • HEMLOCK-INTERFACE:MODE-DOCUMENTATION
  • HEMLOCK-INTERFACE:GET-COMMAND
  • HEMLOCK-INTERFACE:NINSERT-REGION
  • HEMLOCK-INTERFACE:FIND-CONTAINING
  • HEMLOCK-INTERFACE:EXIT-HEMLOCK
  • HEMLOCK-INTERFACE:WINDOW-WIDTH
  • HEMLOCK-INTERFACE:BLANK-LINE-P
  • HEMLOCK-INTERFACE:INSERT-STRING
  • HEMLOCK-INTERFACE:SHOW-MARK
  • HEMLOCK-INTERFACE:CURRENT-POINT
  • HEMLOCK-INTERFACE:MAKE-RING
  • HEMLOCK-INTERFACE:MOVE-TO-POSITION
  • HEMLOCK-INTERFACE:*CREATE-WINDOW-HOOK*
  • HEMLOCK-INTERFACE:*RANDOM-TYPEOUT-BUFFERS*
  • HEMLOCK-INTERFACE:SCROLL-WINDOW
  • HEMLOCK-INTERFACE:COMPLETE-STRING
  • HEMLOCK-INTERFACE:DEFMODE
  • HEMLOCK-INTERFACE:LINE>
  • HEMLOCK-INTERFACE:BUFFER-PATHNAME
  • HEMLOCK-INTERFACE:COMMANDP
  • HEMLOCK-INTERFACE:MAKE-WINDOW
  • HEMLOCK-INTERFACE:NEXT-CHARACTER
  • HEMLOCK-INTERFACE:RING-POP
  • HEMLOCK-INTERFACE:LINE<=
  • HEMLOCK-INTERFACE:COMMAND-FUNCTION
  • HEMLOCK-INTERFACE:EDITOR-ERROR-FORMAT-ARGUMENTS
  • HEMLOCK-INTERFACE:DELETE-REGION
  • HEMLOCK-INTERFACE:REDISPLAY-ALL
  • HEMLOCK-INTERFACE:DO-STRINGS
  • HEMLOCK-INTERFACE:MAKE-MODELINE-FIELD
  • HEMLOCK-INTERFACE:RING-LENGTH
  • HEMLOCK-INTERFACE:MARK<=
  • HEMLOCK-INTERFACE:*RANDOM-TYPEOUT-HOOK*
  • HEMLOCK-INTERFACE:REMOVE-HOOK
  • HEMLOCK-INTERFACE:MAKE-XWINDOW-LIKE-HWINDOW
  • HEMLOCK-INTERFACE:MODE-MAJOR-P
  • HEMLOCK-INTERFACE:CURRENT-WINDOW
  • HEMLOCK-INTERFACE:LINE-CHARACTER
  • HEMLOCK-INTERFACE:PROMPT-FOR-KEY
  • HEMLOCK-INTERFACE:MESSAGE
  • HEMLOCK-INTERFACE:BLANK-AFTER-P
  • HEMLOCK-INTERFACE:BUFFER-END-MARK
  • HEMLOCK-INTERFACE:LINE-PLIST
  • HEMLOCK-INTERFACE:PROMPT-FOR-FILE
  • HEMLOCK-INTERFACE:BUFFER-MODELINE-FIELDS
  • HEMLOCK-INTERFACE:LISTEN-EDITOR-INPUT
  • HEMLOCK-INTERFACE:MARK>=
  • HEMLOCK-INTERFACE:BUFFER-START-MARK
  • HEMLOCK-INTERFACE:LINES-RELATED
  • HEMLOCK-INTERFACE:EDITOR-ERROR
  • HEMLOCK-INTERFACE:COPY-MARK
  • HEMLOCK-INTERFACE:MARK>
  • HEMLOCK-INTERFACE:WINDOW-DISPLAY-END
  • HEMLOCK-INTERFACE:DELETE-WINDOW
  • HEMLOCK-INTERFACE:CHARACTER-OFFSET
  • HEMLOCK-INTERFACE:PROMPT-FOR-STRING
  • HEMLOCK-INTERFACE:COMMAND-NAME
  • HEMLOCK-INTERFACE:VARIABLE-NAME
  • HEMLOCK-INTERFACE:LAST-COMMAND-TYPE
  • HEMLOCK-INTERFACE:DELETE-BUFFER
  • HEMLOCK-INTERFACE:BUFFER-MODELINE-FIELD-P
  • HEMLOCK-INTERFACE:VARIABLE-VALUE
  • HEMLOCK-INTERFACE:UPDATE-MODELINE-FIELD
  • HEMLOCK-INTERFACE:BUFFER-WINDOWS
  • HEMLOCK-INTERFACE:BUFFER-WRITABLE
  • HEMLOCK-INTERFACE:LINE<
  • HEMLOCK-INTERFACE:MARK
  • HEMLOCK-INTERFACE:*DELETE-WINDOW-HOOK*
  • HEMLOCK-INTERFACE:CHARACTER-ATTRIBUTE
  • HEMLOCK-INTERFACE:MARK/=
  • HEMLOCK-INTERFACE:PAUSE-HEMLOCK
  • HEMLOCK-INTERFACE:MAP-BINDINGS
  • HEMLOCK-INTERFACE:MARK-CHARPOS
  • HEMLOCK-INTERFACE:STRING-TABLE-SEPARATOR
  • HEMLOCK-INTERFACE:EDITOR-ERROR-FORMAT-STRING
  • HEMLOCK-INTERFACE:LINE-SIGNATURE
  • HEMLOCK-INTERFACE:PREFIX-ARGUMENT
  • HEMLOCK-INTERFACE:SET-REGION-BOUNDS
  • HEMLOCK-INTERFACE:VALUE
  • HEMLOCK-INTERFACE:COUNT-LINES
  • HEMLOCK-INTERFACE:LINEP
  • HEMLOCK-INTERFACE:LINE-BUFFER

HEMLOCK

  • Function START-SLAVE (&rest args)

Also exports

  • HEMLOCK-INTERNALS:MAIN
  • HEMLOCK-INTERNALS:REPL
  • HEMLOCK-INTERNALS:LINEDIT
  • HEMLOCK-INTERNALS:HEMLOCK
  • HEMLOCK-INTERNALS:WITH-EDITOR
  • HEMLOCK-INTERNALS:CALL-WITH-EDITOR
  • HEMLOCK-INTERNALS:*BACKGROUND-IMAGE*
  • HEMLOCK-INTERNALS:FORMEDIT

HEMLOCK.X11

No exported symbols.

HEMLOCK-USER

No exported symbols.

HEMLOCK.TERMINFO

No exported symbols.

HEMLOCK.WIRE

  • Variable *CURRENT-WIRE*
    nil
    The wire the form we are currently evaluating came across.
  • Struct DEVICE
    WIRE
  • Function DEVICE-WIRE (instance)
  • Function (setf DEVICE-WIRE) (value instance)
  • Struct STREAM-DEVICE
    STREAM
  • Function MAKE-STREAM-DEVICE (stream)
  • Function WIRE-P (object)
  • Function MAKE-WIRE (device)
  • Struct REMOTE-OBJECT
    HOST
    PID
    ID
  • Function REMOTE-OBJECT-P (object)
  • Condition WIRE-ERROR  (ERROR)
  • Condition WIRE-EOF  (WIRE-ERROR)
  • Condition WIRE-IO-ERROR  (WIRE-ERROR)
  • Function REMOTE-OBJECT-LOCAL-P (remote)
    Returns T iff the given remote object is defined locally.
  • Function REMOTE-OBJECT-EQ (remote1 remote2)
    Returns T iff the two objects refer to the same (eq) object in the same process.
  • Function REMOTE-OBJECT-VALUE (remote)
    Return the associated value for the given remote object. It is an error if the remote object was not created in this process or if FORGET-REMOTE-TRANSLATION has been called on this remote object.
  • Function MAKE-REMOTE-OBJECT (local)
    Convert the given local object to a remote object.
  • Function FORGET-REMOTE-TRANSLATION (local)
    Forget the translation from the given local to the corresponding remote object. Passing that remote object to remote-object-value will new return NIL.
  • Generic-Function DEVICE-LISTEN (device)
  • Function WIRE-LISTEN (wire)
    Return T iff anything is in the input buffer or available on the socket.
  • Method DEVICE-LISTEN ((device stream-device))
  • Function WIRE-GET-BYTE (wire)
    Return the next byte from the wire.
  • Method DEVICE-READ ((device stream-device) buffer)
  • Function DEVICE-APPEND-TO-INPUT-BUFFER (device bytes)
  • Function WIRE-GET-NUMBER (wire &optional (signed t))
    Read a number off the wire. Numbers are 4 bytes in network order. The optional argument controls weather or not the number should be considered signed (defaults to T).
  • Function WIRE-GET-BIGNUM (wire)
    Reads an arbitrary integer sent by WIRE-OUTPUT-BIGNUM from the wire and return it.
  • Function WIRE-GET-STRING (wire)
    Reads a string from the wire. The first four bytes spec the size in bytes.
  • Function WIRE-GET-OBJECT (wire)
    Reads the next object from the wire and returns it.
  • Function WIRE-FORCE-OUTPUT (wire)
    Send any info still in the output buffer down the wire and clear it. Nothing harmfull will happen if called when the output buffer is empty.
  • Method DEVICE-WRITE ((device stream-device) buffer &optional (end (length buffer)))
  • Function WIRE-OUTPUT-BYTE (wire byte)
    Output the given (8-bit) byte on the wire.
  • Function WIRE-OUTPUT-NUMBER (wire number)
    Output the given (32-bit) number on the wire.
  • Function WIRE-OUTPUT-BIGNUM (wire number)
    Outputs an arbitrary integer, but less effeciently than WIRE-OUTPUT-NUMBER.
  • Function WIRE-OUTPUT-STRING (wire string)
    Output the given string. First output the length using WIRE-OUTPUT-NUMBER, then output the bytes.
  • Macro WIRE-OUTPUT-FUNCALL (wire-form function &rest args)
    Send the function and args down the wire as a funcall.
  • Function WIRE-OUTPUT-OBJECT (wire object &optional (cache-it (symbolp object)))
    Output the given object on the given wire. If cache-it is T, enter this object in the cache for future reference.
  • Macro REMOTE (wire-form &body forms)
    Evaluates the given forms remotly. No values are returned, as the remote evaluation is asyncronous.
  • Macro REMOTE-VALUE-BIND (wire-form vars form &rest body)
    Bind VARS to the multiple values of FORM (which is executed remotely). The forms in BODY are only executed if the remote function returned (as apposed to aborting due to a throw).
  • Macro REMOTE-VALUE (wire-form form &optional on-server-unwind)
    Execute the single form remotely. The value of the form is returned. The optional form on-server-unwind is only evaluated if the server unwinds instead of returning.
  • Function DEVICE-SERVE-REQUESTS (device &optional force)

SPELL

  • Variable MAX-ENTRY-LENGTH
    (sb-impl::%defconstant-eqx-value 'spell:max-entry-length 31 #'equal)
    This the maximum number of characters an entry may have.
  • Function CORRECT-SPELLING (word)
    Check/correct the spelling of word. Output is done to *standard-output*.
  • Function MAYBE-READ-SPELL-DICTIONARY
    Read the spelling dictionary if it has not be read already.
  • Function SPELL-ROOT-WORD (index)
    Return the root word corresponding to a dictionary entry at index.
  • Function SPELL-COLLECT-CLOSE-WORDS (word)
    Returns a list of all "close" correctly spelled words. This has the same contraints as SPELL-TRY-WORD, which you have probably already called if you are calling this.
  • Function SPELL-TRY-WORD (word word-len)
    See if the word or an appropriate root is in the spelling dicitionary. Word-len must be inclusively in the range 2..max-entry-length.
  • Function SPELL-READ-DICTIONARY (filename)
    Add entries to dictionary from lines in the file filename.
  • Function SPELL-ADD-ENTRY (line &optional (word-end (or (position #\/ line :test #'char=) (length line))))
    Line is of the form "entry/flag1/flag2" or "entry". It is parsed and added to the spelling dictionary. Line is desstructively modified.
  • Function SPELL-REMOVE-ENTRY (entry)
    Removes entry from the dictionary, so it will be an unknown word. Entry is a simple string and is destructively modified. If entry is a root word, then all words derived with entry and its flags will also be deleted.
  • Function SPELL-ROOT-FLAGS (index)
    Return the flags associated with the root word corresponding to a dictionary entry at index.

DIRED

  • Variable *UPDATE-DEFAULT*
    nil
    Update arguments to utilities default to this value.
  • Variable *CLOBBER-DEFAULT*
    t
    Clobber arguments to utilities default to this value.
  • Variable *RECURSIVE-DEFAULT*
    nil
    Recursive arguments to utilities default to this value.
  • Variable *ERROR-FUNCTION*
    #'dired::default-error-function
    This function is called when an error is encountered in dired code.
  • Variable *REPORT-FUNCTION*
    #'dired::default-report-function
    This function is called when the user needs to be informed of something.
  • Variable *YESP-FUNCTION*
    #'dired::default-yesp-function
    Function to query the user about clobbering an already existent file.
  • Function COPY-FILE (spec1 spec2 &key (update *update-default*) (clobber *clobber-default*) (directory nil directoryp))
    Copy file spec1 to spec2. A single wildcard is acceptable, and directory names may be used. If spec1 and spec2 are both directories, then a recursive copy is done of the files and subdirectory structure of spec1; if spec2 is in the subdirectory structure of spec1, the recursion will not descend into it. Use spec1/* to copy only the files in spec1 to directory spec2. If spec2 is a directory, and spec1 is a file, then spec1 is copied into spec2 with the same pathname-name. Files are copied maintaining the source's write date. If :update is non-nil, then files are only copied if the source is newer than the destination, still maintaining the source's write date; the user is not warned if the destination is newer (not the same write date) than the source. If :clobber and :update are nil, then if any file spec2 already exists, the user will be asked whether it should be overwritten or not.
  • Function RENAME-FILE (spec1 spec2 &key (clobber *clobber-default*) (directory nil directoryp))
    Rename file spec1 to spec2. A single wildcard is acceptable, and spec2 may be a directory with the result spec being the merging of spec2 with spec1. If clobber is nil and spec2 exists, then the user will be asked to confirm the renaming. As with Unix mv, if you are renaming a directory, don't specify the trailing slash.
  • Function FIND-FILE (file-name &optional (directory "") (find-all-p nil find-all-suppliedp))
    Find the file with file-namestring file recursively looking in directory. If find-all-p is non-nil, then do not stop searching upon finding the first occurance of file. File may contain a single wildcard, which causes find-all-p to default to t instead of nil.
  • Function DELETE-FILE (spec &key (recursive *recursive-default*) (clobber *clobber-default*))
    Delete spec asking confirmation on each file if clobber is nil. A single wildcard is acceptable. If recursive is non-nil, then a directory spec may be given to recursively delete the entirety of the directory and its subdirectory structure. An empty directory may be specified without recursive being non-nil. When specifying a directory, the trailing slash must be included.
  • Function PATHNAMES-FROM-PATTERN (pattern files)
    Return a list of pathnames from files whose file-namestrings match pattern. Pattern must be a non-empty string and contains only one asterisk. Files contains no directories.
  • Function MAKE-DIRECTORY (name)
    Creates directory name. If name exists, then an error is signaled.

hemlock.clx

No packages.

hemlock.qt

No packages.

hemlock.tty

No packages.