Beijing Paradise BBS Backup/PARADISE.ISO/software/BBSDOORW/AAEMA95A.ZIP/HELP.BIG

INI File | 1995-08-01 | 16.7 KB | 376 lines

[NOTES ABOUT ABBREVIATIONS ETC IN LONG HELP]
N = numeric argument of call. If unset, treated as 1 unless stated otherwise.
D = 1 if N is set, else 0.
T1 = first  text argument (if any) that the subroutine or key asks for.
T2 = second text argument (if any) that the subroutine or key asks for.
K = key sequence argument (if any) that the subroutine or key asks for.
marks are numbered 1 2 etseq from the top of the mark stack,
  and also -1 -2 etseq from the bottom of the mark stack. Mark 0 means mark 1.
Mark 999 = where the cursor was before the last command call, so, after acciden-
  tally pressing `end', `esc 999 ctrlX ctrlX' goes back where you were before.
If an empty string is typed for a buffer name, the buffer menu is entered.
If a directory name is typed for a buffer name, the directory displays as a menu
If '=' is typed for a buffer name, it means 'current buffer'.
The kill ring has 16 positions.
End-of-line is treated as a character.
End of sentence is '.' or '!' or '?' with eol or space or tab after.
End of paragraph is blank line or line starting with space or tab.
e.g. {capitalize, 'altC'}: capitalize is subr name, altC is keysequence.
'$' = 'not from macro' = "fault-remark or does nothing when called from macro".
--------------------------------------------------------------------------------
{accentedletters}
  If N==0, stop  treating the PC accented letters as alphanumeric chars.
  If N!=0, start treating the PC accented letters as alphanumeric chars.
{backspace, 'ctrlH', 'backspace'}
  Delete N chars before cursor. If N<0, do nothing.
{beginmacro, 'ctrlX ('}
  Start recording new current macro. Not from macro.
{bindkeybuf, 'esc altK'}
  Bind buffer named T1 to key K.
{bindkeymacro, 'esc K'}
  Bind current macro to key K.
{bindkeysubr}
  Bind subroutine named T1 to key K.
{buffer}
  If N<0, as 'splitwindow -N'; if N>0, as 'openfile'; if N=0, as 'insertfile'.
{buffermenu, 'ctrlX ctrlB'}
  Choose buffer by menu. Show that buffer in this window. Not from macro.
{calldos, 'ctrlX ctrlE'}
  Call DOS command. Afterwards, press any key to get buffer display back.
{callsubr, 'altX'}
  Obey subroutine or macro named T1. Null string gets menu of subroutine names.
{capitalize, 'altC'}
  Change N words starting with this word to `first letters uppercase, rest
  lowercase'. If N<0, operate on -N words finishing with this word.
{casemode}
  Set buffer mode: If N>=1 recognise, else ignore, case when searching for text.
{cbrackets, 'ctrl2'}
  Check from mark N to cursor for C language bracket matching. Looks for ()[]{}"
  and /* */. Won't work properly if the region starts inside a C string.
{cccmode}
  If N>=1 set, else cancel, mode to counterchange at cursor, as laptop cursors
  are sometimes hard to see.
{cchrstr, 'ctrlX D'}
  Convert \sequence as in C string at pointer to literal char.
{char_from_menu}
  Call the character menu, insert the resulting character N times.
{checkhelp}
  Report any bound keys not listed in file HELP.
{checkspelling, 'altI'}
  Check spelling of next word. If N set and not 0, check spelling of all words
  in region. If N is set, puts unlisted words in the dictionary's appendix. The
  first time checkspelling is called, wait while AAEMACS reads its dictionary;
  you can tell it to read its dictionary from another file than the default.
{copydir}
  Put a copy of directory T1 (as arg of MSDOS command DIR) into the kill ring.
{copykill, 'altW'}
  Copy from mark N to cursor onto kill ring.
{copytext, 'esc C'}
  Copy to cursor text from mark N to mark (N+1).
{cstrchr, 'ctrlX ctrlD'}
  Convert control char or " or \ at pointer to \n or \xxx as in C string.
{delblanklines, 'ctrlX ctrlO'}
  Delete blank lines around cursor.
{delbuf}
  Remove current buffer from ring of buffers.
{delete, 'ctrlD', 'deletekey'}
  Delete N chars starting at the cursor. If N<0, insert -N spaces.
{deletewhite, 'esc \'}
  Delete all spaces and tabs round cursor.
{display}
  Display T1 on the mode line in cyan.
{displayhex, 'esc X'}
  Display from cursor as hexadecimal.
{emptyappendix}
  Empty the spelling checker's dictionary's appendix.
{endmacro, 'ctrlX )'}
  Stop recording new current macro. Not from macro.
{expandtabs, 'ctrlX ctrlT'}
  Expand all tabs to spaces in region.
{finalcr, 'altJ'}
  Add an assumed CR before the assumed LF at all end-of-lines in region.
{findb, 'ctrlR'}
  Search backwards for T1. If N set, stop at mark N.
{findf, 'ctrlS'}
  Search forwards for T1. If N set, stop at mark N.
{findwordb, 'esc ctrlR'}
  Search backwards for T1 as whole word. If N set, stop at mark N.
{findwordf, 'esc ctrlS'}
  Search forwards for T1 as whole word. If N set, stop at mark N.
{finish, 'ctrlX ctrlZ'}
  Exit from emacs.
{formatpara, 'altQ'}
  Reformat this paragraph to uniform line length.
{formatinsetregion, 'esc X esc Q'}
  Reformat between mark N and cursor to uniform line length, allowing old and
  new left margin characters.
{formatregion, 'esc Q'}
  Reformat between mark N and cursor to uniform line length.
{getappendix}
  Copy all new words in region into spelling checker's dictionary's appendix.
{godown, 'ctrlN', 'downarrow'}
  Go down N lines (-N up).
{godownpart, 'ctrldownarrow'}
  In fold-long-lines mode, go about N line-folds downwards (-N up).
{goleft, 'ctrlB', 'leftarrow'}
  Go left N chars. If N<0, go right -N chars.
{goright, 'ctrlF', 'rightarrow'}
  Go right N chars. If N<0, go left -N chars.
{goto}
  Jump to a label. See file MACROS.HLP . Only use in macros, not after alt-X
{gotobof, 'home'}
  Go to start of buffer.
{gotobol, 'ctrlA'}
  Go to start of line.
{gotocol, 'esc G'}
  Go to Nth char in line (leftmost char is 1st, not 0th).
{gotodir, 'altO'}
  Go to file selected by menu of current buffer's file's directory.
{gotoeof, 'end'}
  Go to last line of buffer.
{gotoeol, 'ctrlE'}
  Go to end of line.
{gotoline, 'altG'}
  Go to Nth line of buffer (top line of buffer is 1st, not 0th).
{gotonbuf, 'ctrlX X'}
  Go to next buffer in circle of buffers.
{goup, 'ctrlP', 'uparrow'}
  Go up N lines. If N<0, go down -N lines.
{gouppart, 'ctrluparrow'}
  In fold-long-lines mode, go about N line-folds up (-N down).
{help, 'ctrl_'}
  Say what key K does. If K = one of 'a i L l r s', other information
  (type 'ctrl_ ?' for more information).
{if}
  If N!=0, obey T1, else obey T2. Only use in macros, not after alt-X
  See file MACROS.HLP
{incrfindb, 'ctrlX R'}
  Incremental search backwards for T1. If N set, stop at mark N.
{incrfindf, 'ctrlX S'}
  Incremental search forwards for T1. If N set, stop at mark N.
{insert}
  Insert T1 into the buffer just before the pointer, N times.
{insertfile, 'ctrlX tab', 'ctrlX ctrlI'}
  Insert text of file T1 at cursor.
{insertspaces, 'insertkey'}
  Insert N spaces. If N<0, delete -N chars starting at cursor.
{kill_to_eol, 'ctrlK'}
  (if at EOL, kill the EOL, else kill to EOL) N times (-N times left if N<0)
  Put the killed text on the kill ring.
{killregion, 'ctrlW'}
  Remove text from mark N to cursor, and put it on the kill ring.
{killsent, 'altK'}
  Search forwards (-N times backwards if N<0) N times for end of sentence.
  Remove text from there to cursor, and put it on the kill ring.
{killwordb, 'altbksp', 'altH'}
  Search backwards (-N times forwards if N<0) N times for end of word.
  Remove text from there to cursor, and put it on the kill ring.
{killwordf, 'altD', 'altdelete'}
  Search forwards (-N times backwards if N<0) N times for end of word.
  Remove text from there to cursor, and put it on the kill ring.
{leaveonewhite, 'esc /'}
  Delete all spaces and tabs round cursor, then insert a space there.
{linefeed}
  Insert N linefeeds, all with their 'no CR before LF here' bits set.
{literalchar, 'ctrlQ'}
  Put next char into buffer even if it is control char. Not from macro.
  'ctrlQ alt0' puts ASCII-zero char into buffer.
  'ctrlQ ctrltab' selects char by menu ('end' key exits menu without inserting).
  'ctrlQ ctrlM' or 'ctrlQ ret' inserts ctrlM (CR) by itself.
{longlinesmode}
  Set buffer mode: if N=0, slide display left-right if necessary to get cursor
  on screen. If N=1, fold long lines on screen.
{lwcaseregion, 'ctrlX ctrlL'}
  Change all uppercase letters to lowercase between mark N and cursor.
{lwcasewords, 'altL'}
  Change all uppercase letters to lowercase in this and N-1 following words.
  (If N<0, this and (-N)-1 preceding words).
{macromenu, 'altsharp'}
  Menu of currently defined macros.
{maketabs, 'ctrlX ctrlY'}
  Convert spaces to tabs in region.
{markbof, 'althome'}
  Set mark N at start of buffer.
{markeof, 'altend'}
  Set mark N at end of buffer.
{menu, 'altequals', 'rightbutton', 'middlebutton'}
  Menu of AAEMACS commands. Arrows move pointer. RET calls selected subroutine.
  END backs out of menu or submenu. ctrl_ gets help for selected subroutine.
  After RET, asks you for numeric argument `N' of the call: + and - change sign,
  backspace removes last digit, END backs out of subroutine call, PAGEDOWN
  enters arg (if no digits, call has no arg) and calls the subroutine.
{mergefile}
  Merge file T1 into region in ascii order. Both should be in ascii order
  before. If in ignore-case-on-search mode, treat A-Z as a-z when merging.
{modemenu, 'altM'}
  Set this buffer's modes by menu. Not from macro.
{mouse_mode, 'leftbutton'}
  Mouse operations. They are not recorded individually by "record a macro".
    Moving the mouse about moves the cursor.
    `esc', or clicking the left button, exits to ordinary mode.
    Dragging the left button sets the mousing region (mark 1 to mark 2).
    `del' deletes that region.
    `M' moves that region to where the cursor is.
    `C' copies that region to where the cursor is.
{mouse_move, 'mousemove'}
  Move the cursor.
{movetext, 'esc M'}
  Move to cursor text from mark N to mark (N+1).
{namemacro, 'esc ctrlN'}
  Give macro bound to K the name T1. Remove name if T1 is empty string. Else T1
  must be alphanumeric. Current macro if K is bound to subroutine 'obey'.
{newline, 'ctrlJ', 'ret'}
  Insert eol into buffer, i.e. split this line here.
{nextwindow, 'esc N'}
  Go to next window in circle of windows.
{nofinalcr, 'esc J'}
  Remove an assumed CR before the assumed LF at all end-of-lines in region.
{nomove}
  Write the last character of T1 into the buffer. Overwrite the character that
  was there before, unless the pointer is at end of line. Do not move pointer.
{obey, 'ctrlX E'}
  Obey current macro N times. If N<=0, do nothing.
{onewindow, 'ctrlX 1'}
  Remove all windows except this window.
{openfile, 'ctrlX ctrlF'}
  Go to buffer open on file named T1. If necessary, create and read new buffer.
{openline, 'altinsert', 'ctrlO'}
  Same as 'newline' then 'backspace'.
{overlay}
  Write T1 into the buffer N times, overwriting until end of line, then
  inserting. Leave the pointer after the last character written.
{overlaymode}
  Set buffer mode for what typed chars do: N=0 inserted; N=1 overlay and cursor
  moves; N=2 overlay and cursor stays still.
{page_down, 'ctrlV', 'pagedown'}
  Go down (window height - 2) lines, N times. (Up if N<0).
{page_up, 'altV', 'pageup'}
  Go up (window height - 2) lines, N times. (Down if N<0).
{popmark, 'esc ,'}
  Move cursor to mark on top of mark stack. Remove that mark from mark stack.
{prbindings}
  In current buffer list current key bindings.
{prbuffers}
  In current buffer list buffers with bindings, in form obeyable by readmacros.
{prevwindow, 'esc P'}
  Go to previous window in ring of windows.
{prkeynames}
  In current buffer list names of all alt keys and special keys.
{prkeys}
  In current buffer list all current key bindings.
{prmacros}
  In current buffer list all macros, in form obeyable by readmacros.
{prmacro}
  In current buffer list current macro, in form obeyable by readmacros.
{prsubrnames}
  In current buffer list all subroutine names.
{pushmark, 'esc .'}
  Add a mark to top of mark stack, set it at current cursor.
{putappendix}
  Copy the spelling checker's dictionary's appendix into the current buffer.
  Unless N<1, only list words that have been listed as "vocabulary".
  If N<0, put '/#1' after vocabulary words and '/#0' after other words.
{readmacros}
  Read buffer T1 (read file if no such buffer). Translate it into macros and
  buffer bindings. Read the buffers. Obey the macro bindings & buffer bindings.
{refresh_display, 'ctrlL'}
  Move display so this line becomes Nth line in window.
  If N not defined, N = middle line of screen and refresh screen.
{remmark, 'esc #'}
  Take N marks off top of stack. Do not move cursor.
{renamebuffer, 'ctrlX N'}
  Rename this buffer as filename T1.
{repeat, 'ctrlZ'}
  Obey last instruction (not 'repeat's) N times.
{repl, 'altR'}
  From cursor to mark N, replace all T1 by T2.
{replask, 'altS'}
  From cursor to mark N, replace all T1 by T2, asking each time.
{replword, 'esc altR'}
  From cursor to mark N, replace all T1 by T2, whole word only.
{replwordask, 'esc altS'}
  From cursor to mark N, replace all T1 by T2, whole word only, asking each time
{replyank, 'altY'}
  If previous command was yank or replyank, replace yanked text by text N steps
  back (N<0 = forwards) in kill ring; else as 'yank with N not defined'.
{restorebuf, 'esc ctrlF'}
  Re-read this buffer from its file.
{savebuffer, 'ctrlX ctrlS'}
  Write this buffer to its file.
{setmark, 'esc space'}
  Set mark N to cursor.
  If N-1 marks in stack, pushes a new mark onto the <bottom> of the stack.
{setolddot, 'leftbuttondown'}
  Set that buffer's 'old dot' to set the start of the mousing region.
{setrightmargin, 'ctrlX F'}
  If N not set, find right margin setting. Else, set right margin setting to N
  (N<10 means 71). N<0 means "-N 'n'-widths proportionate for Epson printer".
{setsortcol}
  If N not set, find how many characters at the start of each line for sortlines
  to ignore, else set it = N.
{showinfo, 'ctrlX ='}
  Display various info re current cursor and the char at cursor.
{showregion, 'altZ'}
  From cursor to mark N, magenta background at next screen display.
  If N=0, show from mark 1 to mark 2 (see 'copytext' & 'movetext').
{skipafterwordmode}
  Set buffer mode: If N=i+j:-
  When counting words forwards, do/don't(as i=0/1)skip nonword chars after word.
  When counting words backwards,do/don't(as j=0/2)skip nonword chars after word.
{skipparab, 'altP'}
  Search backwards N times for end-of-paragraph (-N times forwards if N<0).
{skipparaf, 'altF'}
  Search forwards N times for end-of-paragraph (-N times backwards if N<0).
{skipsentb, 'altA', 'altuparrow'}
  Search backwards N times for end-of-sentence (-N times forwards if N<0).
{skipsentf, 'altE', 'altdownarrow'}
  Search forwards N times for end-of-sentence (-N times backwards if N<0).
{skipwordb, 'altB', 'altleftarrow'}
  Search backwards N times for end-of-word (-N times forwards if N<0).
{skipwordf, 'altF', 'altrightarrow'}
  Search forwards N times for end-of-word (backwards if N<0).
{sortlines}
  Sort lines that end in region, into ascii order. If in ignore-case-on-search
  mode, treat uppercase A-Z as lowercase when sorting.
{splitwindow, 'ctrlX 2'}
  Split this window into 2 windows. Upper window keeps N lines (half the lines
  if N not set), and shows same buffer. Lower window shows buffer T1.
{swopmark, 'ctrlX ctrlX'}
  Set cursor and mark N to each other's values.
{tabmode}
  Set buffer mode: N=0 show tab as one char; N=1 obey tab as tabulate to next
  tab position (set every 8 chars in line); N=2 do both.
{tabulate, 'tab'}
  Put a tab char into buffer.
{times4, 'ctrlU'}
  Set N to N*4. Not from macro.
{twiddle, 'ctrlT'}
  Move this character N chars forwards (N<0 = backwards), but not past eol.
{twiddlelines, 'esc T'}
  Move this line N lines down (N<0 = upwards).
{twiddlewords, 'altT'}
  Move this word N words forwards (N<0 = backwards).
{twodmode}
  Set buffer mode: start/stop as N=1/0, appending spaces when cursor goes off
  end of line, rather than going onto next line.
{unbindkey, 'esc ctrlK'}
  Unbind key K.
{upcaseregion, 'ctrlX ctrlU'}
  Change to uppercase all letters between mark N and cursor.
{upcaseword, 'altU'}
  Change to uppercase all letters in this and N-1 following words.
  (if N<0, this and (-N)-1 preceding words).
{version}
  Display the version date of the version of AAEMACS that you are using.
{whoa, 'ctrlG'}
  Complain about illegal keypunch.
{wrapmode}
  Set buffer mode: stop/start (as N=0/1) inserting newline before last word(s)
  in this line if you type a char on or to right of the current right margin.
{writebuffer, 'ctrlX ctrlW'}
  Copy this buffer to new buffer named T1. (Fault if buffer already exists.)
  If N!=0, write that new buffer to its file.
{yank, 'ctrlY'}
  Insert at cursor a copy of current member of kill ring. Leave cursor at end of
  insertion. If N set, leave mark N at start of insertion.