(dabbrev) ^W

Dynamic abbreviation facility. See extension dabbrev

(debug) ESC-^D

Enters the MLisp debugger. When in the debugger type h to get help on the debugger's key bindings.

(debug-emacs)

The function is used by the Emacs developers for debugging.

When you using the OpenVMS operating system debug-emacs resets the terminal characteristics are reset, and control is passed to VMS DEBUG so that you can examine Emacs' data structures.

(declare-buffer-specific variable-name...)

Declares and allocates storage for each named variable that is not already declared. Buffer-specific bindings outlive all extended command calls. Each buffer will have its own copy of a buffer-specific variable.

See also:

(declare-global variable-name ...)

Globally declares and allocates storage for each named variable that is not already declared. Global bindings outlive all extended command calls.

See also:

(decompile-current-line)

Returns the currently executing line decompiled into an MLisp expression. If called interactively, it returns a null string. If called non-interactively, it returns the decompiled MLisp for the line about to be traced.

See also:

(decompile-mlisp-function function-name)

Decompiles the MLisp function whose name is supplied, and puts the output into the current buffer at dot.

(default-emacs-init user-interface-style-list)

Add this function to your emacsinit.ml to setup the default emacs key bindings, mouse behaviour, variable settings and autoloads.

The User Guide assumes the Emacs configuration setup by default-emacs-init in its discussion.

The user-interface-style-list parameter allows default-emacs-init to setup the user interface in a particular style.

At the moment user-interface-style supports styles:

The "windows" style will configure Barry's Emacs to operate in a style like other Microsoft Windows Applications.

Further windows like configuration is done when "windows-extended" is added.

In detail (default-emacs-init "windows") does the following:

In addition (default-emacs-init "windows,windows-extended") adds the following:

Add "ere-searching" style sets up all search and replace keybinding to use the extended regular expression functions:

Example:

Windows compatible initialisation:

;
; emacsinit.ml
; load the default emacs settings
;
(default-emacs-init "windows,windows-extended")
;
; now for my customisations
;

Windows compatible initialisation withe extended regular expression saerching:

;
; emacsinit.ml
; load the default emacs settings
;
(default-emacs-init "windows,windows-extended,ere-searching")
;
; now for my customisations
;

(default-global-keymap)

Returns the global keymap in which Emacs starts. The bindings are those wired into Emacs, as well as any bindings created by the user with bind-to-key.

See also:

(define-buffer-macro)

Takes the contents of the current buffer and defines it as a macro whose name is associated with the buffer. This is how you redefine a macro that has been edited using edit-macro.

See also:

(define-global-abbrev "abbreviation" "expansion")

Defines or redefines an abbreviation with the given name for the given phrase in the global abbreviation table. When you type the abbreviation and then enter a word-completion character, Emacs changes the abbreviation into the expanded form. This is similar to the AutoCorrect feature in Microsoft Word.

Example: Make Emacs convert "adn" into "and"

(define-global-abbrev "adn" "and")

See also:

(define-hooked-global-abbrev "abbrev" "phrase" "procedure")

Defines or redefines an abbreviation with the given name for the given phrase in the global abbreviation table and associates a function with the abbreviation.

When the abbreviation is typed the procedure is called. The variable abbrev-expansion holds the expanded phrase and dot will be at the end of the word.

See also:

(define-hooked-local-abbrev "abbrev" "phrase" "procedure")

Defines or redefines an abbreviation with the given name for the given phrase in the local abbreviation table and associates a procedure with the abbreviation.

When the abbreviation is typed the procedure is called. The variable abbrev-expansion holds the expanded phrase and dot will be at the end of the word.

See also:

(define-keyboard-macro macro-name)

Gives a name to the current keyboard macro. A keyboard macro is defined by using the start-remembering and stop-remembering commands. define-keyboard-macro takes the current keyboard macro, makes a copy of it in a safe place, gives it a name, and erases the keyboard macro.

See also:

(define-keymap keymap)

Defines a new, empty, keymap with the given name.

(define-local-abbrev abbrevexpansion)

Defines or redefines an abbreviation with the given name for the given phrase in the local abbreviation table. A local abbreviation table must have already been set up with use-abbrev-table.

See also:

(define-string-macro macro-name body)

Defines a macro given a name and a body as a string entered in the mini-buffer.

See also:

(defun (function-name local... body))

Defines a new MLisp function with the given name and a body composed of the given expressions. The value of the function is the value of the last expression executed.

(defun function-name (arg...) local-variables... body)
(defun function-name (parameter-list) local-variables body)

Defines a new MLisp function with the given name and a body composed of the given expressions. The value of the function is the value of the last expression executed.

An alternative form of defun has a parameter list. The parameters may have default values, see examples for details.

The advantage of the second form is that the arguments are bound to the parameters before the context of the function is setup. With the first form of defun the arguments are evaluated in the context of the function.

An example of the difference should make things clearer. The first form of defun causes an error for the following:

    (defun
        (function-print
            num
            (message "Number is " num)
        )
    )
    (defun
        (call-print
            num
            (setq num 12)
            (function-print num)
        )
    )

    (call-print) => "Number is 0"

And the same problem solved using the second form of defun:

    (defun
        function-print (num)
        (message "Number is " num)
    )
    (defun
        (call-print
            num
            (setq num 12)
            (function-print num)
        )
    )

    (call-print) => "Number is 12"

(delete-buffer buffer-name)

Removes a buffer from the list of buffers, and discards any text the buffer contains. The function takes one argument, which is the name of the buffer to be deleted.

If you use the delete-buffer command interactive and the target buffer is modified, delete-buffer will ask you if you really want to delete the specified buffer. There is no prompt if delete-buffer is executed from an MLisp program.

Examples:

(delete-buffer "fred")
(delete-buffer (current-buffer-name))

See also:

(delete-next-character repeat-count) ^D

Deletes the next repeat-count characters immediately following dot. If repeat-count is omitted, 1 is assumed. A line break counts as one character.

Examples:

(delete-next-character)       ;delete one character
(delete-next-character 8)     ;delete next 8 characters

;delete next 8 characters
(provide-prefix-argument 8    
    (delete-next-character))

;delete white space
(while (looking-at "[ \t]")   ;while next character is space or tab
    (delete-next-character)
)


(delete-next-word repeat-count) ESC-d

Deletes the next repeat-count words starting with the word that dot is currently in. It does not delete backwards to the start of the word. If repeat-count is omitted, 1 is assumed. If dot is not in a word, all punctuation up to the beginning of the next word is deleted as well as the word itself.

Examples:

(delete-next-word) ;delete 1 word (delete-next-word 2) ;delete 2 words ;delete 4 words (provide-prefix-argument 4 (delete-next-word) )

(delete-other-windows) ^X-1

Deletes all windows on the screen except for the window containing dot.

See also:

(delete-previous-character) Backspace

Deletes prefix-argument characters backwards starting immediately preceding dot; that is, starting with the character to the left of the cursor.

See also:

(delete-previous-word repeat-count) ESC-h

Deletes prefix-argument times repeat-count words backwards starting with the word that dot is in. If repeat-count is omitted, 1 is assumed.

If dot is not in a word, the function deletes all the white-space up to the previous word as well.

The function does not delete any characters in front of dot, not even if dot is in a word.

See also:

(delete-region-to-buffer buffer-name)

Deletes all characters between dot and the mark. The deleted text is saved in the specified buffer. The buffer is emptied before the characters are inserted.

See also:

(delete-to-killbuffer) ^W

Deletes all characters between dot and the mark. The deleted text is moved to the buffer Kill buffer, which is emptied first.

See also:

(delete-white-space)

Deletes all white space characters on the current line on both sides dot. The definition of white-space is derived from the current syntax table.

See also:

(delete-window) ^X-d

Removes the current window from the screen and gives its space to the window below (or above if the current window is the bottom window). The new current window and buffer are those that just gained the extra space.

This function does not delete any text. You can still go the buffer by various methods. For example, you can select it from the list of buffers (on the menu, click Buffer and then Switch Buffer.)

See also:

(describe-bindings)

Places in the Help window a list of all the keys and the names of the extended commands that they are bound to. This listing is a good start if you want to create a quick-reference card for your own, customised version of Emacs.

(describe-command command-name)

Describes the specified extended command.

(describe-key keys)

Prints out a line of information describing the function that the sequence keys is bound to.

See also:

(describe-variable variable-name)

Describes the named variable.

(describe-word-in-buffer) ^X-^D

Takes the word nearest dot and looks it up in a database and displays the information found. This database contains one-line descriptions of all of the C standard functions, VMS System Services, DCL lexical functions and Bliss string operations.

If you supply a prefix-argument, describe-word-in-buffer allows you to edit the selected entry.

(digit)

This function is bound to the digit keys after a call to the argument-prefix command and until a non-digit function is executed. This means that the bindings for the digits changes during prefix argument collection, so that the prefix argument is correctly evaluated.

(dot)

Returns the number of characters to the left of dot plus 1.

(dot-is-visible)

Returns 1 if dot is in a window. Note that this is not the same as asking whether dot is visible to the user.

(down-window repeat-count)

Moves the cursor into the window that is below the current window. This is different to the next-window function, which moves the cursor without regard to the physical position of the windows on the screen.

If the repeat-count is given then the command is repeated that number of times.

down-window reports an error if there is not a window below the current window.

See also:

(dump-abbreviation-tables)

Dumps a readable listing of an abbreviation table into the buffer Abbreviation table and makes the buffer visible.

The listing includes the abbreviation, its expansion and the name of any MLisp hook function associated with the abbreviation.

If there is more than one abbreviation table, the function prompts for the table name.

See also:

(dump-memory-statistics)

This function is used by the Emacs developers to determine the memory usage of Emacs.

(dump-stack-trace)

Dumps an MLisp stack trace to the buffer Stack trace. This can be used to debug MLisp functions. The stack trace consists of an indication of what was executing when the trace occurred, and a line for each function that was active.

See also:

(dump-syntax-table)

Dumps a readable listing of a syntax table into a buffer and makes that buffer visible: