System Booster/System Booster.iso/Texteditors/Mg1b/Source/functions

Text File | 1996-09-27 | 13.1 KB | 336 lines

Format:
#!function-name            [default binding]
    Description
!    How it differs from GNU.

The '!' in the function name is optional.  If present, it means that the
function does not exist in GNU.

To get a function list with bindings, do
    "grep ^# this_file | sed -e 's/^#//' -e 's/^#!//' > your_file"
Other interesting things can be extracted as you see fit.

-------------------------------------------------------------------------------

#auto-fill-mode
    Toggles word-wrap at fill-column, after space is typed.
!    Modes are global across all buffers.
#!auto-indent-mode
    Toggles indenting to first whitespace after a newline.
#backward-char            [C-b]
    Move point left ARG characters (right if ARG negative).
    On reaching end of buffer, stop and signal error.
#backward-delete-char        [DEL]
    Delete characters backwards. Delete ARG chars, and save in
    kill buffer if ARG was specified
#backward-kill-word        [ESC DEL]
    Kill characters backward until encountering the end of a word.
    With argument, do this that many times.
!    When deleting backwards across line boundaries onto non-null
!    kill buffers, things get put in the kill buffer in the wrong
!    order.
#backward-paragraph        [ESC [ ]
    Move backward to start of paragraph.  With arg, do it arg times.
!    Definition of paragraph isn't quite the same as with GNU, need
!    to fill it in.
#backward-word            [ESC b]
    Move backward until encountering the end of a word.
    With argument, do this that many times.
#beginning-of-buffer        [ESC < ]
    Move point to the beginning of the buffer; leave mark at
    previous position.
!    Doesn't understand arguments.
#beginning-of-line        [C-a]
    Move point to beginning of current line.
#!bsmap-mode
    Toggles a mode that maps ^H to del and del to ^H, where the
    editor can't see it.
#call-last-kbd-macro        [C-x e]
    Call the last keyboard macro that you defined with C-x (.
!    Not as fancy as GNU version.
#capitalize-word        [ESC c]
    Convert following word (or ARG words) to upper case, moving over.
!    Doesn't handle negative arguments.
#copy-region-as-kill        [ESC w]
    Save the region as if killed, but don't kill it.
#!ctrlx-four-hack
    Exists to support the Ctl-x 4 <things> code.
#delete-blank-lines        [C-x C-o]
    On blank line, delete all surrounding blank lines, leaving just one.
!    Always behaves that way, doesn't do the isolated blank and non-blank
!    lines as does GNU.
#delete-char            [C-d]
    Delete the following ARG characters (previous, with negative arg).
    If ARG is specified, appends deleted characters to the kill buffer.
#delete-horizontal-space    [ESC \]
    Delete all spaces and tabs around point.
#delete-other-windows        [C-x 1]
    Make current window fill the screen.
#delete-window            [C-x 0]
    Remove current window from the display.
#describe-bindings        [C-h b]
    Show a list of all defined keys, and their definitions.
    The list is put in a buffer, which is displayed.
!    No heading on columns in output buffer
#describe-key-briefly        [C-h c]
    Print the name of the function KEY invokes.
#downcase-region        [C-x C-l]
    Convert the region to lower case.
#downcase-word            [ESC l]
    Convert following word (or ARG words) to lower case, moving over.
!    Doesn't handle negative arguments.
#emacs-version
    Print string describing the version of Emacs that is running.
#end-kbd-macro            [C-x ) ]
    Finish defining a keyboard macro.
    The definition was started by C-x (.
    The macro is now available for use via C-x e,
!    Can't use end-kbd-macro to execute macro.
#end-of-buffer            [ESC > ]
    Move point to the end of the buffer; leave mark at previous position.
!    Doesn't understand arguments
#end-of-line            [C-e]
    Move point to end of current line.
!    Doesn't understand arguments.
#enlarge-window            [C-x ^]
    Make current window ARG lines bigger.
!    Won't make other windows vanish to make room for enlarging window.
#eval-current-buffer
    Execute the current buffer as an Emacs command file.
!    Doesn't exist in the MICRO version.
#eval-expression
    Get Emacs command and evaluate.
!    Doesn't exist in MICRO version. No autocompletion.
#exchange-point-and-mark    [C-x C-x]
    Put the mark where point is now, and point where the mark is now.
#execute-extended-command
    Read function name, then read its arguments and call it.
#fill-paragraph            [ESC q]
    Fill paragraph at or after point.
!    Leaves point at end of paragraph, instead of where it started.
!    Other differences, such as paragraph definition and what
!    characters to doublespace after also exist.
#find-file            [C-x C-f]
    Edit file FILENAME.
    Switch to a buffer visiting file FILENAME,
    creating one if none already exists.
!    MicroGnuEmacs will put a newline at the end of the last line
!    if there is not one there already.
#find-file-other-window        [C-x 4 f] [C-x 4 C-f]
    Edit file FILENAME, in another window.
    May create a new window, or reuse an existing one;
!    See find-file.
#!flow-mode
    Toggles a mode that maps ^\ to ^S and ^^ to ^Q and silently
    eats ^S and ^Q at a level where the editor can't see it.
#forward-char            [C-f]
    Move point right ARG characters (left if ARG negative).
    On reaching end of buffer, stop and signal error.
#forward-paragraph        [ESC ] ]
    Move forward to end of paragraph.  With arg, do it arg times.
!    See backward-paragraph
#forward-word            [ESC f]
    Move point forward ARG words (backward if ARG is negative).
#global-set-key
    Give KEY a definition of COMMAND.
#global-unset-key
    Remove global definition of KEY.
#goto-line
    goto LINE in the current buffer.
!    Want to leave mark at old position, but....
#help                [C-h]
    Prompt user to find out what kind of help to supply
!    Only b (describe-bindings), c (describe-key-briefly) and ^H
!    (help) work.
#insert-file            [C-x i]
    Insert contents of file FILENAME into buffer after point.
    Set mark after the inserted text.
!    File not found handling differs from GNU Emacs.
!    see find-file.
#!insert-newline        [RET]
    Bound to newline so that it does the right things.  Usually
    ignorable.
#!insert-with-wrap
    Bound to space in auto-fill-mode. Check current column, and adds
    a newline if past it.
#isearch-backward        [C-r]
    Do incremental search backward.
    See isearch-forward for more information.
!    Not as fancy as the GNU version.
#isearch-forward        [C-s]
    Do incremental search forward.
    As you type characters, they add to the search string and are found.
    Type Delete to cancel characters from end of search string.
    Type ESC to exit, leaving point at location found.
    Type C-S to search again forward, C-R to search again backward.
    Type C-Q to quote control character to search for it.
    C-G while searching or when search has failed
    cancels input back to what has been found successfully.
    C-G when search is successful aborts and moves point to starting point.
    Other control and meta characters terminate the search
     and are then executed normally.
!    See isearch-backward.
#just-one-space            [ESC SPC]
#keyboard-quit            [C-g]
    Terminate the current function with an quit condition.
#kill-buffer            [C-x k]
    Get rid of the specified buffer.
!    Has minor problems: if buffer being killed is open in any windows,
!    those windows must have valid alternate buffers.  Leaves point and
!    mark at end of buffer if alternate buffer is open on another window.
#kill-line            [C-k]
    Kill the rest of the current line; before a newline, kill the newline.
    With prefix argument, kill that many lines from point.
    Negative arguments kill lines backward.
!    When killing backwards across line boundaries (args of < 0) onto a
!    non-empty kill buffer, it appends things in the wrong order.
#kill-paragraph
    Kill current paragraph.
!    NEEDS TO BE CHANGED TO KILL TO END OF CURRENT PARAGRAPH!!!
#kill-region            [C-w]
    Kill between point and mark.
    The text is deleted but saved in the kill buffer.
    The command C-y can retrieve it from there.
#kill-word            [ESC d]
    Kill characters forward until encountering the end of a word.
    With argument, do this that many times.
#list-buffers
    Display a list of names of existing buffers.
    Inserts it in buffer *Buffer List* and displays that.
!    Note that buffers with names starting with spaces are listed, where
!    GNU omits them. Less information listed.
#load
    Execute a file of Emacs commands.
!    Mucho different; any of '();' comments outside of strings; only
!    one-line "S-expressions" work; only present if compilation option
!    specified.
#newline-and-indent        [C-j]
    Insert a newline, then indent.
#next-line            [C-n]
    Move cursor vertically down ARG lines.
!    Not like GNU, not sure of the differences.
#!next-window
    Move to the next window down the screen.
!    Named other-window in GNU. Done this way for GOSLING freaks
!    who want next and previous window.
#!no-tab-mode
!    Toggles a mode that treat tabs like most other control characters,
!    and rebinds tab to space-to-tabstop.
#not-modified            [ESC ~]
    Clear buffer modified flag.
#open-line            [C-o]
    Insert a newline and leave point before it.
    With arg, inserts that many newlines.
#!prefix-region
    Prepend a string (set by set-prefix-string) to each line
    in the curernt region.  If given an argument, prompts
    you for the string to use.
!    Probably available in GNU under a different name or through a
!    different functionality.  Intended purpose is mail quoting and
!    bar comments in C code.  Compilation option.
previous-line            [C-p]
    Move cursor vertically up ARG lines.
!    See next-line.
#!previous-window
    Move to the next window up the screen.
!    previous-window is there for GOSLING freaks (like me).
#query-replace            [ESC % ]
    Replace some occurrences of FROM-STRING with TO-STRING.
    As each match is found, the user must type a character saying
    what to do with it.
    Type Help char within query-replace for directions.
!    Not quite as sharp as GNU version
#quoted-insert            [C-q]
    Read next input character and insert it.
    Useful for inserting control characters.
!    Doesn't handle the 3 octal digits case.
#recenter            [C-l]
    Center point in window and redisplay screen.  With ARG, put point
    on line ARG.  The desired position of point is always relative
    to the current window.  Also forces full screen refresh.
#save-buffer            [C-x C-s]
    Save current buffer in visited file.
!    Always saves buffer, even if it isn't modified.
#save-buffers-kill-emacs    [C-x C-c]
    Offer to save each buffer, then kill this Emacs.
#save-some-buffers        [C-x s]
    Save some modified file-visiting buffers.  Asks user about each one.
    With argument, saves all with no questions.
#scroll-down            [ESC v]
    Scroll text of current window downward ARG lines; or near full
    screen if no ARG.
#scroll-other-window        [ESC C-v]
    Scroll text of next window upward ARG lines; or near full screen
    if no ARG. The next window is the one below the current one; or
    the one at the top if the current one is at the bottom.
#scroll-up            [C-v]
    Scroll text of current window upward ARG lines; or near full
    screen if no ARG.
#!search-again
    Handy to have around for function keys/menus, etc.
#search-backward        [ESC r]
    Search backward from point for STRING.
!    Last search pattern is remembered, including isearches
!    Bound to C-s in uemacs, not bound in GNU
#search-forward            [ESC s]
    Search forward from point for STRING.
    see search-backward
#self-insert-command        [All printing characters and tab]
    Insert this character.
#set-fill-column        [C-x f]
    Set fill-column to current column, or to argument if given.
!    Global, not buffer-local (no buffer-local stuff in uemacs)
#set-mark-command        [C-@]
    Set mark to where point is.
!    No mark ring, so args don't make sense.
#!set-prefix-string
!    Set string used by prefix-region to put in front of each line text.
!    Probably available in GNU in some other form, but this specific
!    form suits a number of situations.  Compilation option.
#shrink-window
    Make the current window ARG lines smaller.
!    Will not make the current window vanish if you try and make it
!    to small; won't shrink window if you only have one window.
#!space-to-tabstop
!    Insert spaces to the next tabstop.  With a positive argument,
!    insert spaces to the n'th tab stop.  Bound to tab in notab mode.
#split-window-vertically    [C-x 2]
    Split current window into two windows, one above the other.
!    Behaves differently about which is going to be current window,
!    Doesn't use ARG to decide how many lines to use.
#start-kbd-macro        [C-x ( ]
    Record subsequent keyboard input, defining a keyboard macro.
    The commands are recorded even as they are executed.
#suspend-emacs            [C-z] [C-x C-z]
    Get a shell.  Exactly what shell depends on the system you
    are on.
#switch-to-buffer        [C-x b]
    Select the specified buffer in the current window.
!    Memory of old buffer names doesn't work quite as well.
#switch-to-buffer-other-window    [C-x 4 b]
    Switch to specified buffer in another window.
!    See switch-to-buffer
#transpose-chars        [C-t]
    Interchange characters around point, moving forward one character.
!    Doesn't work across newlines, ignores args
#upcase-region            [C-x C-u]
    Convert the region to upper case.
#upcase-word            [ESC u]
    Convert the following word (or ARG words) to upper case, moving over.
!    Doesn't handle negative arguments.
#what-cursor-position        [C-x =]
    Print info on cursor position.
!    slightly more information in output.
#write-file            [C-x C-w]
    Write current buffer into file FILENAME. Makes FILENAME the file for
    the current buffer.
#yank
    Reinsert the last stretch of killed text.
!    Doesn't keep a kill ring, so no yanks of stuff older than
!    last delete, and arg-yank does yank arg times, instead of
!    getting the arg'th thing off the kill ring.