OS/2 Shareware BBS: 5 Edit/05-Edit.zip/UE3112.ZIP/mehelp1.txt

Text File | 1991-12-16 | 38KB | 1,224 lines

    [ENTER]    Picks a topic      [PG UP] Last Screen        Cursor keys
      [F10]    Exit Help    [PG DOWN] Next Screen        are active
       [F6]    Index           [HOME] Main Menu
< >
[ENTER]    Picks a topic     [PG UP] Last Screen   [I] Index       Cursor keys
  [F10]    Exit Help      [PG DOWN] Next Screen   [HOME] Main Menu       are active
< >
=>Main Menu
NEXT[The Basics] PREV[Main Menu]


    < > The Basics            < > Keystrokes

    < > Getting at Files        < > Issuing Commands

    < > Searching and Replacing    < > Command List

    < > Regions            < > Customizing Command Keys

    < > Cutting and Pasting        < > Using the Mouse

    < > Buffers            < > Modes of Operation

    < > Windows            < > The Outside World

    < > Screens            < > Advanced Text Editing



=>Commands
=Command List
=>Macros
=Creating New Commands
=>Bindings
=Customizing Command Keys
=>Keyboard Macros
=Repetitive Tasks
=>Pages
=Creating New Commands
=>The Basics
NEXT[Alternative Basic Keys] PREV[Main Menu]

    MicroEMACS is a very powerful tool to use for editing text files.
    It has MANY MANY commands, options and features to let you do just
    about anything you can imagine with text. But don't let this
    apparent complexity keep you from using it.... MicroEMACS can also
    be very simple.

    To start editing files, all the keys you really need to know are:

          [CSR UP]        These keys let you move
             |            around in the your file
     [CSR <-]  <--->  [CSR ->]
             |
         [CSR DOWN]

           [F9]         This saves your file

           [F10]        This leaves MicroEMACS

                        [PG DOWN] for other basic keys
=>Alternative Basic Keys
NEXT[Glossary of Terms] PREV[The Basics]

    On systems that do not have special function and cursor keys,
    MicroEMACS works by using control keys. On such a system these
    keys perform basic functions:

        ^P        Move upward
    ^B            Move backward
            ^F    Move forward
        ^N        Move downward

        ^X^S        Saves your file

        ^X^C        Exits MicroEMACS

    An up arrow before the key means to hold the CTRL key down and
    press the next character. For example, to exit MicroEMACS, hold
    down the CTRL key and strike X and then C.

    Press [PG DOWN] to learn about the terms used within MicroEMACS

=>Glossary of Terms
NEXT[Glossary 2] PREV[Alternative Basic Keys]

    MicroEMACS uses a number of defined terms which will help you
    understand the rest of this help document.

    < > COMMANDS    These are built in functions that represent
            basic things that MicroEMACS does. For example,
            the cursor up key activates the "previous-line"
            command which moves the cursor up to the line
            of text immediately before the current line.

    < > BINDINGS    A binding is a link between a sequence of keys
            and a command. The command previous-line is bound
            to the cursor up key, and to the ^P key. Pressing
            a key sequence causes the command to which it is
            bound to execute.



                    [PG DOWN] for more terms
                        Select term for more info
=>Glossary 2
NEXT[Glossary 3] PREV[Glossary of Terms]

        META KEY    is the key used to start many commands. On most
            keyboards this is the [ESC] key, but many times
            it is rebound/changed to the key in the upper
            left corner of the keyboard. This is often the
            grave accent symbol.

    < > BUFFERS        These are areas of memory set aside to hold text.
            Each buffer has a buffer name which is used to
            refer to it, and a file name from which it has
            been read or where it will be written.

    < > WINDOWS        Sections of the current screen which display a
            portion of a buffer. More than one window may be
            visible at a time. Multiple windows split the
            screen horizontally.


                    [PG DOWN] for more terms
                        Select term for more info
=>Glossary 3
NEXT[Glossary 4] PREV[Glossary 2]

    < > SCREENS        are collection of windows. On a older text style
            system, one screen is displayed at a time. On
            a newer window based system, like OS/2, the
            Macintosh or MicroSoft Windows, each operating
            system window can display a different MicroEMACS
            screen.

        MODE LINE    is the line at the bottom of each window naming
            the buffer being displayed, along with its file
            name. Also the active modes of the window are shown.

        COMMAND LINE    is the line at the bottom of the each screen
            where you give more information to some commands.




                    [PG DOWN] for more terms
                        Select term for more info
=>Glossary 4
NEXT[Glossary 5] PREV[Glossary 3]

    < > MACROS        are programs written in the MicroEMACS language
            which let you automate repetitive editing tasks.
            These help pages are being run by a relatively
            simple, but powerful MicroEMACS macro.

    < > KEYBOARD MACROS

            These are remembered sequences of keystrokes which
            can be used to greatly speed quick and dirty
            repetitive editing.

    < > PAGES        These are groups of macros which have been written
            to handle a particular editing task, and which have
            been packaged to be available from the MicroEMACS
            startup file. These macros are bound to shifted
            function keys.

                    [PG DOWN] for more terms
                        Select term for more info
=>Glossary 5
NEXT[Main Menu] PREV[Glossary 4]

    < > POINT        The position in the text of the current window
            of the cursor. The point is considered between
            the character the cursor rests on and the one
            immediately behind it.

    < > MARK        Position in the current buffer which delimits
            the beginning of a region. Various commands
            operate on text from the MARK to the POINT,
            or move the current point to the MARK.








                    [PG DOWN] to return to Main Menu
                        Select term for more info
=>Modes of Operation
NEXT[Main Menu] PREV[Main Menu]

    Modes determine how MicroEMACS will treat text. Modes effect the
    contents of a buffer. Global modes determine the modes of newly
    created buffers.

    ^X-M (add-mode)            Adds a mode to the current buffer
    ^X-^M (delete-mode)        Removes a mode from the current buffer
    M-M (add-global-mode)        Adds a global mode
    M-^M (delete-global-mode)    Removes a global mode

    These are some of MicroEMACS's modes:

    < >  ASAVE mode        < >  EXACT mode        < >  REP mode

    < >  CMODE mode        < >  MAGIC Mode        < >  VIEW mode

    < >  CRYPT mode        < >  OVER mode        < >  WRAP mode



=>ASAVE Mode
NEXT[Modes of Operation] PREV[Modes of Operation]

    ASAVE mode            Automatically Save

    When this mode is on, MicroEMACS automatically saves the contents
    of your current buffer to disk every time you have typed 256
    characters. The buffer is saved to the file named on the mode line
    of the buffer. This mode assures you that you will loose very
    little text should your computer crash while you are editing. Be
    sure you are willing to have your original file replaced
    automatically before you add this mode.

    The frequency of saving can be altered by changing the contents of
    the $asave environment variable. Use the set command like this:

    ^X-A $asave 2048

        to change MicroEMACS to automatically save the current
    buffer after every 2048 characters are typed.



=>CMODE Mode
NEXT[Modes of Operation] PREV[Modes of Operation]

    CMODE mode            Editing C programs

    This mode is specifically for editing programs written in the C
    language. When CMODE is active, MicroEMACS will try to anticipate
    what indentation is needed when the <NL> key is used. It will
    always bring a pound sign (#) with only leading white space back
    to the left margin. It will attempt to flash the proper character
    matching any close symbol as the close symbol is typed.

    The standard startup files for MicroEMACS will install a macro
    which checks any file being read into MicroEMACS and sets CMODE if
    the file ends with a .c or .h extension.

    M-^F    (goto-matching-fence)

    Place the point on any brace, bracket, or parenthesis and use
    this command, MicroEMACS will jump to the matching character. If
    there is none, a beep will sound.


=>CRYPT Mode
NEXT[Modes of Operation] PREV[Modes of Operation]

    CRYPT mode            Encryption

    For files of a sensitive nature, MicroEMACS can encrypt text as it
    is written or read. When you write out text, if CRYPT mode is
    active and there is no encryption key, emacs will ask:

    Encryption String:

    Type in a word or phrase of at least five characters or more for
    the encryption to use. If you look at the file which is then
    written out, all the printing characters have been scrambled. To
    read such a file back in, call up MicroEMACS like this:

    emacs -k <filename>

        and you will be asked the encryption key before the file is
    read. The encryption algorithm is a Beaufort Cipher with a
    variant key. This is reasonably difficult to decrypt.


=>EXACT Mode
NEXT[Modes of Operation] PREV[Modes of Operation]

    EXACT mode            Character Case during Searches

    Normally, when using search or replace commands, MicroEMACS
    ignores the case of letters for comparisons. With EXACT mode set,
    the case of the characters must be the same for a match to occur.














=>MAGIC Mode
NEXT[More MAGIC] PREV[Modes of Operation]

    MAGIC mode            Regular Expression Pattern Matching

    Normally, MicroEMACS uses the string you type in response to a
    search or replace command as the string to find.  When magic mode
    is enabled, MicroEMACS considers the string you type as a pattern
    or template to use in finding a string to match.  Many characters
    in this template have special meaning:

    .        any single character, except newline.
    [<set>]        any single character from the bracketed set.
    ^        beginning of a line.
    $        end of a line.
    \        the next character has no special meaning,
               take the next character literally
               (unless it is a parenthesis)


                    Press [PG DOWN] for more magic

=>More MAGIC
NEXT[Modes of Operation] PREV[MAGIC Mode]

    Here are some more special characters in MAGIC mode:

    ?        the preceding character (or . or [<set>]) is optional.
    *        the preceding character (or . or [<set>]) matches
            zero to many times.
    +        the preceding character (or . or [<set>]) matches
            one to many times.
    \(<group>\)    define a group for the replacement string, or for
            the &GROUP function.

    Some characters in the replacement string can have special meanings:

    &        insert all of the text matched by the search.
    \        the next character has no special meaning (but
            see groups...)
    \1 to \9    insert the text defined by the nth group in the
            search string.


=>OVER Mode
NEXT[Modes of Operation] PREV[Modes of Operation]

    OVER mode            Overstrike Mode

    MicroEMACS is normally in what many other editors consider
    "insert" mode. This means when you strike a character, MicroEMACS
    makes room for that character in the current line, inserting it
    between the existing characters. In OVER mode, MicroEMACS instead
    overwrites characters, replacing the existing character under the
    point with the character you type. OVER mode will maintain the
    position of text lined up using tabs while replacing existing
    text.

    Be wary editing Japanese KANJI characters while in this mode, it
    is possible to overwrite the first byte of the character, leaving
    the second byte meaningless and alone.







=>WRAP Mode
NEXT[Modes of Operation] PREV[Modes of Operation]

    WRAP mode            Wrap entered text

    This mode causes the point and the previous word to jump down to
    the next line when you type a space and are beyond the current
    fill column. This is normally set to column 72, allowing you to
    enter text non-stop on a standard screen without bothering to use
    the return key.

    To change the column that text is wrapped past, use the set
    command to change the value of the $fillcol environment variable,
    like this:

    ^X-A $fillcol <new value>

    MicroEMACS will then wrap words past column <new value>.





=>VIEW Mode
NEXT[Modes of Operation] PREV[Modes of Operation]

    VIEW mode            No Changes Permitted

    When in VIEW mode, no command which would change the text is
    allowed. If you attempt any such command, or try to type in any
    text, MicroEMACS responds with:

    [Key Illegal in View Mode]

    This mode is very useful when you want to just look at some
    existing text, as it will prevent you from changing that text.
    Also MicroEMACS will not attempt a file lock if a file is read in
    VIEW mode, allowing you to view files which you don't have write
    access to, or other people have locked. To read a file in view
    mode from the command line, type:

    emacs -v <filename>





=>REP Mode
NEXT[Modes of Operation] PREV[Modes of Operation]

    REP mode            Replace Mode

    MicroEMACS is normally in what many other editors consider
    "insert" mode. This means when you strike a character, MicroEMACS
    makes room for that character in the current line, inserting it
    between the existing characters. In REP mode, MicroEMACS instead
    replaces the existing character under the point with the
    character you type. REP mode will not maintain the position of
    text which takes up multiple columns using tabs since it will
    replace a single tab character with the typed character which will
    not take up the same space on screen.

    However, Japanese KANJI characters will correctly replace and be
    replaced in this mode as the two bytes will be considered together
    when either style character is used.





=>Keystrokes
NEXT[Main Menu] PREV[Main Menu]

    All the MicroEMACS documentation talks about commands and the
    keystrokes needed to use them. Each MicroEMACS command has a name,
    and most of them are bound to a sequence of keys. Whenever we
    refer to a command we will display it's binding (the keys needed
    to activate the command) and the name of the command in
    parenthesis.

    Keystrokes for commands include one of several prefixes, and a
    command character. Command keystrokes look like these:

        ^A    hold down <Ctrl>, press 'A'
        M-A    press the META key, release it and press 'A'
        ^X-A    Hold <Ctrl>, press 'X', release, press 'A'
        ^X-^A    hold <Ctrl>, press 'X', release, hold <Ctrl>, press 'A'
        S-FN1    hold down <SHIFT>, press function key 1
        A-A    hold down <Alt>, press 'a'
        FN^1    hold down <Ctrl>, press function key 1


=>Searching and Replacing
NEXT[Other Searches] PREV[Main Menu]

    Commands for searching for and replacing strings come in a number
    of different flavors. The simplest commands is:

    ^S (search-forward)

    Typing this command results in a prompt like this:

    Search []<META>:

    Any text shown in the square brackets will be searched for if you
    don't type in any string. This is called the default search
    string. The key shown in the angle brackets is the key you type to
    end the search string, which is called the search terminator key.
    Normally, it is the META, or ESCape key. This lets you to use the
    return key (<NL>) in a search string. So if you want to find the
    string "mystic", you would type the word, and then ESCape key. The
    point would jump to the end of the next occurrence of "mystic",
    or, if there are none, MicroEMACS displays "not found".

=>Other Searches
NEXT[Replacements] PREV[Searching and Replacing]

    ^R (search-reverse)

    This works like ^S except that it searches backwards through the
    text for the last occurrence of the string. It leaves the point at
    beginning of the string found.

    A-S (hunt-forward)

    This command searches for the next occurrence of the last search
    string entered, without prompting for another string. To use this
    command, hold down the ALT key and type 's'. This keystroke may
    not be available on all keyboards.

    A-R (hunt-backwards)

    This searches backwards for the last occurrence of the last search
    string entered. This also is only available on some keyboards.


=>Replacements
NEXT[Main Menu] PREV[Other Searches]

    M-R (replace-string)

    This will prompt for two strings. The first string is replaced
    with the second from the current position to the end. Both strings
    may have defaults. If you want to replace a string with nothing,
    and there is a default on the replacement string, striking ^K will
    override the default and enter a blank string.

    M-^R (query-replace-string)

    Otherwise like replace-string, this command prompts at each
    string. Typing 'Y' replaces the current string, 'N' skips the
    current string, '!' replaces the current and all following strings
    without asking, 'U' skips to the previous replacement and undoes
    it, '^G' aborts the command, leaving the point at the current
    word, '.' aborts and moves the point back to where the command
    was originally given, '?' lists the available options.



=>Regions
NEXT[Main Menu] PREV[Main Menu]

    Regions are used in MicroEMACS to specify what text is acted on by
    many commands. A region is defined as all the text between the
    point, and the last placed MARKed. To define a region:


    1) Move the point to the beginning of the text you
       want to effect

    2) Use the M-<space> (set-mark) command to position
       the MARK at the current point

    3) Move the point to the end of the text you want to effect

    At this time, the text between the MARK and the POINT is the
    current region which will be effected by many commands. Regions
    can be defined backwards as well as forwards, and can include the
    entire text, or as little as one character.




=>Cutting and Pasting
NEXT[Copying Text] PREV[Main Menu]

    To move text from one place to another:

    1) Move to the beginning of the text you want to move.

    2) Set the mark here with the M-<space> (set-mark) command.

    3) Move the point to the end of the text.

    4) Use the ^W (kill-region) command to delete the region you just
       defined. The text will be saved in the "kill buffer".

    5) Move the point to the place you want the text to appear.

    6) Use the ^Y (yank) command to copy the text from the kill buffer
       to the current point.

    Repeat steps 5 and 6 to place more copies of the same text.

                    [PG DOWN] for more info

=>Copying Text
NEXT[Main Menu] PREV[Cutting and Pasting]

    Copying text, without deleting the original is just like cutting
    and pasting it, except that in place of the ^W (kill-region)
    command, you use the M-W (copy-region) command which copies the
    current region into the kill buffer without deleting it.

    The kill buffer accumulates and text which is deleted by ^W, M-W
    or a number of other delete commands. If more than one delete
    command is used in a row, all the text from all the commands will
    be in the kill buffer. Using any command between deletes causes
    the kill buffer to discard earlier deletes and just hold the most
    recent deletions.

    Since there is only one kill buffer, you can switch between
    windows, screens and files to copy text from one file to another.
    There is no limit to the amount of text that can be stored in the
    kill buffer except that of the memory of the computer running
    MicroEMACS. Extremely large kills will take a few seconds.



=>Buffers
NEXT[Buffer Commands] PREV[Main Menu]

    A buffer is where MicroEMACS stores text. Normally that text is
    read from a file, and is visible in a editing window. But text stored
    in buffers can also be MicroEMACS macros, temporary storage for
    macros, or lists of screens, files, buffers, variables, functions
    or bindings created by MicroEMACS commands. Buffer commands include:

    ^X-B    (select-buffer)

    This prompt for a buffer name, and then makes that buffer the one
    visible in the active window. If the buffer does not yet exist, it
    will create it.

    ^X-K    (delete-buffer)

    MicroEMACS attempts to discard the named buffer, reclaiming the
    memory it occupied. It will not allow the destruction of a buffer
    which is currently visible through any window on any screen.

                    [PG DOWN] for more buffer commands
=>Buffer Commands
NEXT[Memory Usage] PREV[Buffers]

    ^X-^B    (list-buffers)

    This pops up a list of all the buffer names, the file the buffer was
    read from, the size, and the active modes for each buffer. Using a
    numeric argument (M-<n>) with the command will list hidden buffers
    used by MicroEMACS and its macros.

    A '@' in column one shows that a file has already been read into a
    buffer. A '*' in column two means that the buffer has been changed
    since the last time it was written to disk. A '#' in column three
    indicates the file was to large to read into memory and was truncated.

    ^X-X    (next-buffer)

    This command causes MicroEMACS to switch the active window to
    display the next buffer in the buffer list. This can be used to
    easily step through all the buffers.

                [PG DOWN] for info on buffers memory usage
=>Memory Usage
NEXT[Main Menu] PREV[Buffer Commands]

    The only limit to the number of buffers is the memory of your
    computer. All the buffers, text, screens and windows use memory
    for storage. On UNIX and other machines with virtual memory there
    is no limit to the number and size of files you edit. Under MSDOS,
    the AMIGA, the Atari ST, the HP150 and other microcomputers you
    can estimate the memory used by adding up the size of all the
    files you want to edit simultaneously, multiply by 1.4, and add
    170K for the size of MicroEMACS. This results in the amount of
    free memory needed to edit these files.

    Under a MSDOS machine with 574K free from dos, you can edit files
    totaling 288K in size.







=>Windows
NEXT[Window Commands] PREV[Main Menu]

    MicroEMACS uses windows to display and allow you to edit the
    contents of buffers. A single screen will show one or more
    windows, separated by a modeline which describes the contents of
    the window above it. Here are some window commands:

    ^X-2    (split-current-window)

    This command splits the current window into two windows. Both
    windows view the current buffer at the current POINT.

    ^X-O    (next-window)    ^X-P    (previous-window)

    These commands make the next window down, or the previous window
    upward the current window. MicroEMACS highlights the mode line of
    the currently active window, and places the machine's cursor at
    the POINT.

                    [PG DOWN] for more window commands


=>Window Commands
NEXT[More Window Commands] PREV[Windows]

    ^X-1    (delete-other-windows)

    This command deletes all other windows but the active window.

    ^X-0    (delete-window)

    This removes the active window from the screen, giving its space
    to one of the adjacent windows. It does not discard or destroy any
    text, just stops looking at that buffer. You can not delete the
    last window on the screen.

    ^X-^N    (move-window-down)    ^X-^P    (move-window-up)

    These commands moves the windows view into it's buffer up or down
    by one line. Preceding the command with M-<n> will move the
    window's view up or down by <n> lines.

                [PAGE DN] for even more window commands

=>More Window Commands
NEXT[Main Menu] PREV[Window Commands]

    M-<n> ^X-W    (resize-window)

    Type META, followed by a number, and then the resize-window
    command, ^X-W. This attempts to change the length of the current
    window (and it's mode line) to the number of lines you typed.
    This may not always be possible depending on the size of the
    other windows.

    ^X-^    (grow-window)        ^X-^Z    (shrink window)

    These commands attempt to change the size of the active window by
    one line.







=>Screens
NEXT[Screen Commands] PREV[Main Menu]

    A Screen is a collection of windows and a command line which are
    displayed together. On some non-graphically oriented systems, such
    as UNIX, only one screen is displayed at one time. Under other
    graphical oriented operating systems like WINDOWS 3, X-WINDOWS,
    the Macintosh or the Amiga, each screen is displayed in an
    operating system "window". Notice that the MicroEMACS usage of the
    word window is different from the meaning used in these graphical
    systems.

        MicroEMACS term        OS term

            Window    ==    Pane
            Screen    ==    Window

    Each screen has its own set of windows and its own command line.
    Switching from one screen to another will preserve the window
    setup, the colors and the buffers being displayed.

                    [PG DOWN] for screen commands
=>Screen Commands
NEXT[More Screen Commands] PREV[Screens]

    Under MSDOS, MicroEMACS uses a simple windowing system which
    can display more than one screen at once. Look at the section
    on using the mouse to learn how these screens can be manipulated.

    A-F    (find-screen)

    This prompts you for a screen name. If it does not exist, it is
    created. On text systems, this screen is displayed. On graphic
    systems, the OS window containing this screen is brought to front.
    Clicking on an existing window will also switch to that screen.

    A-C    (cycle-screen)

    This command takes the rearmost screen, the last screen in
    the screen list, and moves it to the front.


                [PG DOWN] for more screen commands

=>More Screen Commands
NEXT[Main Menu] PREV[Screen Commands]

    A-D    (delete-screen)

    This command deletes any screen which is not the active screen.
    Buffers being displayed on that screen are not discarded. On
    graphic systems, the screen's OS window is closed. Clicking on
    a close gadget will activate this command.

    A-B    (list-screens)

    A pop up buffer containing a list of all current named screens
    and the names of the buffers visible in the windows on that screen





                [PG DOWN] to return to Main Menu


=>Getting at Files
NEXT[More File Commands] PREV[Main Menu]

    ^X-^F    (find-file)

    This command causes MicroEMACS to prompt you for the name of a
    file you want to edit. If that file is already somewhere in the
    editor, it brings it up in the current window. If it is not, it
    searches for it on disk. If it exists, it creates a new buffer
    and reads the contents of the file into it. If it does not yet
    exist, it simply creates a new buffer. In any case the buffer
    is brought up in the current window. If you press a space or ESC
    while typing in the filename, MicroEMACS will attempt to complete
    the name for you.

    ^X-^S    (save-file)    [also F9 on some systems]

    If the text in the current buffer has been changed since it has
    been read, MicroEMACS will write the changed text back to the
    disk file it came from.

                    [PG DOWN] for more file commands
=>More File Commands
NEXT[Yet More File Commands] PREV[Getting at Files]

    ^X-^R    (read-file)

    Use this command to read a file into the current buffer, replacing
    its original text with that from the file. MicroEMACS' concept of
    the current file name will not change, so make sure that replacing
    the text in the original file with that from the read one is what
    you are intending when you use this command.

    ^X-^W    (write-file)

    This writes the text in the current buffer to a file with a name
    different from what MicroEMACS thought it was originally. This
    does change MicroEMACS concept of the current buffer's file name.

    M-Z    (quick-exit)

    This special exit command leaves MicroEMACS, but only after
    writing out all changed buffers.
                        [PG DOWN] for yet more
=>Yet More File Commands
NEXT[Main Menu] PREV[More File Commands]

    ^X-^I    (insert-file)

    This will ask you for the name of a file to insert into the
    current buffer, at the point.

    ^X-^A    (append-file)

    Similar to write-file, this command writes out the current buffer
    to the named file. But rather than replacing its contents, it
    appends it to the end of the existing text in the file. This does
    not change the filename of the current buffer. This is handy for
    building log files.

    ^X-N    (change-file-name)

    This command lets you directly change the filename associated
    with the current buffer.
                    [PG DOWN] to return to main menu

=>Issuing Commands
NEXT[Numeric Arguments] PREV[Main Menu]

    Commands within MicroEMACS have descriptive names which you can
    use to invoke them, or bind them to a keystroke. To execute one
    of these commands, use the execute-named-command (M-X) command.
    A colon (:) will appear on the command line. Type in the name of
    the command and strike <enter>. The command will execute. If you
    type a <space> or the META key while typing, MicroEMACS will
    attempt to complete the name for you.

    To get a list of ALL the commands in your current MicroEMACS, type:

        M-X describe-bindings

    This will display a paged list of all legal commands and the
    keystrokes to use to invoke them.



                [PG DOWN] for more info on commands

=>Numeric Arguments
NEXT[Command Lines] PREV[Issuing Commands]

    Some commands take a number as an argument. For example, to move
    to a particular line within a file, you use the goto-line (M-G)
    command. To go to a particular line, precede the command with
    a number by striking the META key, typing a number, and then
    the keys bound to the command. To go to the 123rd line of a file:

        <META>123<META>g

    If a command does not need a numeric argument, it is taken as
    a repeat count. This also works when typing any character!
    To make a line of 50 dashes type:

        <META>50-

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


                [PG DOWN] for more info on using commands

=>Command Lines
NEXT[Macros] PREV[Numeric Arguments]

    Execute-command-line (M-^X) lets you type in a MicroEMACS
    command line. MicroEMACS macros are made from sequences of
    these command lines. A command line has three parts:

        <numeric argument> <command> <arguments>

    To insert the string <*><*><*> at the point, type M-^X and then:

        3 insert-string "<*>"

    or to set the current fill column to 64, type M-^X and then:

        64 set-fill-column




                [PG DOWN] to learn more about using macros

=>Customizing Command Keys
NEXT[Unbinding Keys] PREV[Main Menu]

    MicroEMACS lets you decide what keys activate what command!

    M-K    (bind-to-key)

    prompts you for a command name, and a keystroke to bind to that
    command. A keystroke can be bound only to one command at a time,
    so when you bind it, its old definition is forgotten. This command
    can be used to permanently change your key bindings by placing it
    at the end of your emacs.rc (.emacsrc under UNIX) file. For example,
    if you have one of those nasty keyboards with a tilde (~) in the
    upper left corner, where ESC should be, and you want the tilde
    to become the META key, add this line to the end of emacs.rc:

        bind-to-key meta-prefix ~

    You can use this command to make MicroEMACS feel similar to any
    other editor by changing what keys activate which commands.

                [PG DOWN] for more binding commands
=>Unbinding Keys
NEXT[Main Menu] PREV[Customizing Command Keys]

    M-^K    (unbind-key)

    This prompts you for a key, and then disconnects if from
    executing any command. Useful if you have a function key you
    keep tripping over, or if you are trying to make MicroEMACS look
    like a much more minimalistic editor.

    (describe-bindings)

    Executed with the M-X command, this command pops up a list of
    all MicroEMACS commands, each with all the keys which are currently
    bound to it.






                [PG DOWN] to return to Main Menu

=>Advanced Text Editing
NEXT[Main Menu] PREV[Main Menu]

    Learn About


        < >    Paragraphs

        < >    Words

        < >    Case Control

        < >    Controlling Tabs

        < >    Repetitive Tasks

        < >    Narrowing Your Scope

        < >    Creating New Commands

                [PG UP] to return to Main Menu

=>The Outside World
NEXT[More External Commands] PREV[Main Menu]

    These commands let you interact with the Operating System

    ^X-^C    (exit-emacs)

    Most important of commands, you use this the exit MicroEMACS.
    If you have any buffers with text that has been changed, you
    will be asked if you are sure you want to leave.

    ^X-!    (shell-command)

    Call up the operating system shell to execute a line which
    MicroEMACS will prompt you for. If this is used interactively,
    the editor will politely wait for you to press a key on the way
    back in so you can view the results of your command.


                [PG DOWN] for more external commands


=>More External Commands
NEXT[Main Menu] PREV[The Outside World]

    ^X-$    (execute-program)

    This attempts to call up an external program directly, not through an
    intervening shell. Without the shell, the call is faster and uses less
    memory, but it can not be used to execute internal shell commands. (You
    can not use it for the "DIR" command under MSDOS!)

    ^X-@    (pipe-command)

    This command uses the shell to execute a program, but rather than
    displaying what the program prints, it attempts to place it in a
    buffer to let you edit or save it.

    ^X-#    (filter-buffer)

    The contents of the current window are fed to a filter program
    (like SORT) and the results replace the original.

                [PG DOWN] to return to the main menu
=>Paragraphs
NEXT[More Paragraph Commands] PREV[Advanced Text Editing]

    MicroEMACS defines a paragraph as any lines of text surrounded
    by blank lines. A line starting with a tab or one of the characters
    in the $fmtlead variable is considered the first line of a paragraph.

    If you are editing text destined for use by a text formatter, set
    $fmtlead to the command character for that formatter. That will
    prevent MicroEMACS from formatting what should be lines of commands
    meant for the formatter. If, for example, you are editing SCRIBE
    source, use the ^X-A (set) command to set $fmtlead to "@".

    Commands that manipulate paragraphs include:

    M-N    (next-paragraph)

    This command moves the point just past the last character of the
    current paragraph. If already at the end, it will move to the end
    of the next paragraph.

                [PG DOWN] for more paragraph commands
=>More Paragraph Commands
NEXT[Advanced Text Editing] PREV[Paragraphs]

    M-P    (previous-paragraph)

    The point is moved to the first character of the current paragraph.
    If already at the beginning, it will move back to the previous one.

    M-^W    (kill-paragraph)

    This deletes the current paragraph, leaving a copy in the kill
    buffer.

    M-Q    (fill-paragraph)

    This all important commands re-formats the current paragraph,
    causing all of its text to be filled out to the current fill column
    (Which is 72 by default and is set with $fillcol).


            [PG DOWN] to return to the Advanced Editing Menu

=>Words
NEXT[More Word Commands] PREV[Advanced Text Editing]

    Words are defined, by default, as a string of characters consisting
    of alphabetics, numbers and the underscore(_) character. You can
    change this be setting the $wchars variable to a list of all the
    characters you want considered as part of a word.

    Commands to manipulate words include:

    M-F    (next-word)    [<CTRL> -> on PC keyboards]

    This positions the point at the beginning of the next word.

    M-B    (previous-word)    [<CTRL> <- on PC keyboards]

    This positions the point at the beginning of the previous word.



                [PG DOWN] for more word commands]

=>More Word Commands
NEXT[Advanced Text Editing] PREV[Words]

    M-D    (delete-next-word)

    Delete from the current position to the beginning of the next word.

    M-^H    (delete-previous-word)

    Dete the word before the point.

    M-^C    (count-words)

    Show the number of words in the current region, along with the
    number of characters, lines and the average number of characters
    per word.




                [PG DOWN] to return to Advanced Editing Menu

=>Case Control
NEXT[Advanced Text Editing] PREV[Advanced Text Editing]

    M-C    (case-word-capitalize)
    M-L    (case-word-lower)
    M-U    (case-word-upper)

    These three commands let you change the case of the word at or
    following the point.

    ^X-^L    (case-region-lower)
    ^X-^U    (case-region-upper)

    Setting a mark (with M-<space>), moving to the other end of a region
    and using one of these commands will change the case of all the words
    in the selected region.




            [PG DOWN] to return to Advanced Editing Menu

=>Narrowing Your Scope
NEXT[Advanced Text Editing] PREV[Advanced Text Editing]

    Many times you will want to do something to a part of the text
    when the command works on all the text. Also it is helpful to
    see or edit just a portion of the text.

    ^X-<    (narrow-to-region)

    All the text in current buffer disappears except what is in the
    currently defined region. The modeline displays "<>" to indicate
    the current window looks into a narrowed buffer.

    ^X->    (widen-from-region)

    All the invisible text is restored.




            [PG DOWN] to return to Advanced Editing Menu

=>Repetitive Tasks
NEXT[More Keyboard Macros] PREV[Advanced Text Editing]

    Computers excel at performing the same task multiple times. You
    should never have to perform the same edit more than once. These
    commands show how:

    ^X-(    (begin-macro)

    This commands tells MicroEMACS to begin memorizing any keystrokes,
    commands or mouse clicks.

    ^X-)    (end-macro)

    MicroEMACS stops recording when this command is given.

    ^X-E    (execute-macro)

    This command replays everything recorded last.

        [PG DOWN] to learn more about keyboard macros

=>More Keyboard Macros
NEXT[Advanced Text Editing] PREV[Repetitive Tasks]

    To perform any repetitive task, where you have a list of things
    that need to be changed, one per line, follow these steps:

    1) Position the point to the beginning of the line to change

    2) Strike ^X-( to start recording

    3) make the change, staying on that line

    4) move to the beginning of the next line

    5) Strike ^X-) to stop recording

    Now hit ^X-E once to test your change on the next line. Did it
    work? If so count how many lines need to yet be changed, strike
    the META key followed by that number and ^X-E. Voila! Your change
    has been made on all the lines.

            [PG DOWN] to return to Advanced Editing Menu
=>ENDOFFILE
< >