home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 5 Edit / 05-Edit.zip / ME22-OS2.ZIP / CHANGES.DOC < prev    next >
Text File  |  1988-10-11  |  28KB  |  750 lines
  1.                       CHANGES TO ME VERSION 2.1
  2.  
  3. Virtual/EMS memory support!!!
  4.   The really big news for this release is that ME now supports virtual 
  5. memory and expanded memory (if you have an expanded memory driver in
  6. your system). This means that you can edit files as large as the free
  7. space on your disk!!!
  8.  
  9.   ME still relies on the memory management routines found in the
  10. Microsoft C run-time library (ie - malloc()) to allocate blocks to
  11. hold the lines in. When malloc() returns a NULL to ME, signifying that 
  12. DOS no longert has any free memory to give away, ME will try to
  13. allocate pages from expanded memory. When expanded memory runs out, ME 
  14. will start swapping to disk. ME creates a temporary swap file with the 
  15. name VMxxxxxx. ME will delete this file when you exit back to DOS.
  16.  
  17.   The METEMP environment variable controls where the swap file will
  18. be stored. By default, ME puts the swap file in your current
  19. directory. If you want the swap file to be placed in another
  20. directory, or on a RAM disk (for faster access), then you can set the
  21. METEMP environment variable to the full DOS path name that you want to 
  22. use. For instance, if you have a RAM disk on drive E:, then you can
  23. have the following line in your autoexec.bat file :
  24.  
  25.   set METEMP=e:\
  26.  
  27.  
  28. Real Tabs now supported!
  29.   Thanks to user John Palmer, ME now supports real variable-length
  30. tabs. The cursor will now jump over the virtual space represented by a
  31. tab character. Using real tabs will probably save you some space on
  32. your disk, especially if you tend to use a lot of blanks for padding. 
  33.  
  34.   You can control whether ME will use real tabs or not by altering the 
  35. 'rt' parameter in the CONFIG.ME file.
  36.  
  37.  
  38. Customizable word delimiters
  39.   Three commands need to know what constitutes a word; these commands
  40. are <NEXTWORD>, <PREVWORD>, and <DELWORD>. By default, ME considers a
  41. word to be a series of alpha-numeric characters. Through the macro
  42. language, you can tell ME what it thinks a word should consist of. See
  43. the section below on the macro language additions for more in-
  44. formation. 
  45.  
  46.  
  47. New option for Block Indent
  48.     The amount of space a block moves when you indent/undent is now con-
  49. trolled by the 'sh' parameter in the options menu (and CONFIG.ME file). 
  50.  
  51.  
  52. Support for enhanced keyboard.
  53.   ME now supports the extended keyboard. Previously, ME did not
  54. recognize the keys on the separate cursor keypads. Now, those keys
  55. invoke the same functions as their counterparts on the numeric keypad.
  56.  
  57.  
  58. New arguments for the DOS command line
  59.   You can now give wildcards on command line. ME will find all
  60. matching files and will attempt to load in as many files as it can
  61. before it runs out of window space. (Unfortunately, ME will not load
  62. the remaining files into "invisible" buffers. Let us know if you want
  63. this capability.)
  64.  
  65.   If ME is started with a command line argument of -g<n> where <n> is
  66. a number, then upon loading the first file on the command line, ME
  67. will jump to line <n> in that file. This is useful for programs which
  68. analyze the error messages generated by a compiler, and wish to invoke
  69. the editor and bring it immediately to the error line. As an example,
  70. the command line "me -g25 ed.c" will load file ed.c and immediately
  71. jump to line 25.
  72.  
  73.     Two new command line arguments, -c<num> and -r<num>, tell ME how
  74. many rows and columns are supported on the video display. Some video
  75. adapters are able to display more than 80 columns and more than 25
  76. rows in normal operation. If ME is invoked with these options, then it 
  77. will start up assuming that your display is already set at the
  78. specified number of rows and/or columns.
  79.  
  80.     For instance, the Everex enhanced EGA board is capable of
  81. displaying 132 columns of text on one row. If your display is already
  82. set up in this mode, then you must put the argument "-c132" on the ME
  83. command line. It is probably easiest to do this within a BAT file.
  84.  
  85.  
  86. Support for Video Boards
  87.     In the paragraph above, we mentioned that the -c and -r options will
  88. work only if you are in the alternate video mode when you enter ME. Many
  89. people would also like to use alternate video modes in conjunction with the
  90. <TOGGLE EGA> command (CTRL-E).
  91.  
  92.     In version 2.0 and below, the <TOGGLE EGA> command would simply toggle
  93. between the normal 25 line mode and the 43 line mode produced by the EGA
  94. when you load in the EGA's 8X8 font. Now, we offer video drivers which ME
  95. can load in when it starts up. The video driver contains information about
  96. the alternate video mode, such as the number of rows and columns it
  97. supports, the code to turn the alternate mode on, and the code to turn it
  98. off.
  99.  
  100.     A video driver is loaded into ME by specifying the "-v<drivername>"
  101. option on the ME command line. ME will perform its normal searching
  102. algorithm to find the driver (first search the current directory, then the
  103. paths specified by the ME environment variable, then search through the DOS
  104. path). 
  105.  
  106.     If you have a need for a video driver, or information on ow to write
  107. your own, please contact us.
  108.  
  109.  
  110. Command-line history using up and down keys
  111.     We have enhanced the prompting mechanism by allowing you to recall 
  112. previously entered responses. Responses are saved in a circular queue 
  113. in a last-in-first-out fashion. When ME prompts you for a response
  114. (such as when you invoke the <SEARCH> command), you can use the up and 
  115. down arrow keys to scroll backwards and forwards through the previous
  116. responses. You can press <ENTER> to accept that response, or you can
  117. use the editing keys to modify the response before accepting it.
  118.  
  119.     The maximum number of responses which are saved is 16. When the
  120. response queue gets full, the oldest response is discarded to make
  121. room for the new response.
  122.  
  123.  
  124. Current pick buffer displayed
  125.     The number of the current pick buffer is now displayed on the status
  126. line, right next to the "modified" indicator.
  127.  
  128.  
  129. Desqview compatibility.
  130.     ME now detects if DESQVIEW is loaded, and if it is, uses
  131. DESQVIEW's alternate screen buffer when video accesses are done. This
  132. enables you to use ME in a DESQVIEW window along side other processes. 
  133. In addition, if DESQVIEW is loaded, ME will not continuously poll the
  134. keyboard for the shift status. This will let other processes run
  135. smoothly under DESQVIEW.
  136. (DESQVIEW is a trademark of Quarterdeck Office Systems.)
  137.  
  138.  
  139. Keyboard push/pop fixed
  140.   The keyboard_push() and keyboard_pop() functions now work correctly. 
  141. Thanks to Kirk Wyatt for pointing out some glitches.
  142.  
  143.  
  144.  
  145.                     MACROS LANGUAGE ENHANCEMENTS
  146.                     ----------------------------
  147.  
  148. **************************************************************************
  149. *         IMPORTANT     ATTENTION     ACHTUNG      ATTENZIONE            *
  150. **************************************************************************
  151.  
  152.     You must recompile all of your existing macros with the new 2.1 macro
  153. compiler!!! They will not work otherwise!!!
  154.  
  155.     In addition, we now recognize the difference between a carriage return
  156. ('\n', ascii 10) and a line feed ('\r', ascii 13). An ASCII 13 ('\r') is
  157. generated when the user presses the ENTER key. An ASCII 10 ('\n') is
  158. generated when the user presses the CTRL ENTER key combination. If any of
  159. your macros test the keyboard for an ENTER key, you will need to change the 
  160. test from a '\n' to a '\r'.
  161.  
  162.  
  163.     We have added several new datatypes to the ME macro language which 
  164. should help with calling external C functions. The new data types are
  165.   unsigned        values range from 0 to +65,335
  166.   long            values range from -2,147,483,647 to +2,147,483,647
  167.   unsigned long   values range from 0 to +4,294,967,295
  168.  
  169.     You can now take get address of a variable and assign it to
  170. another variable or pass it as an argument to an external C function.
  171. Just like with the C language, an ampersand ('&') before a variable
  172. will give you the address of the variable. 
  173.  
  174.     We added a new event (event number 9) which can be "hooked" into.
  175. This new event occurs just after a command is processed. Event number
  176. 8 still occurs just before a command is processed. The new event will
  177. let you perform any post-command processing that you need to do.
  178.  
  179.  
  180.     We added new functions to let you access the delimiter table.
  181. These functions are :
  182.  
  183.   void reset_word_delimiter()
  184.     Resets the word-delimiter table to its default state.
  185.  
  186.   void set_word_delimiter(string delimiters, int value)
  187.     For each character is the string 'delimiters', sets the
  188. corresponding entry in the word-delimiters table to 'value' (usually 0
  189. or 1). If entry 'i' has a value of 0, then it is *not* a word
  190. delimiter. 
  191.  
  192.   void clr_word_delimiter(int value)
  193.     Sets the entire word-delimiter table to the specified value
  194. (usually 0 or 1). If entry 'i' has a value of 0, then it is *not* a
  195. word delimiter.
  196.  
  197.  
  198. New C functions added
  199.     The following C functions can be accessed through the macro lan-
  200. guage :
  201.  
  202.   void vidsetcursor(int start, int end)
  203.     Sets the starting and ending scan lines for the cursor to 'start'
  204. and 'end' respectively. This is useful for macros where you would like 
  205. to hide the cursor (start=32,end=0) or change it from the default scan
  206. lines for insert and overstrike modes.
  207.  
  208.   int get_window_color()
  209.     Gets the color of the current window. The color returned has the
  210. value of (background * 16 + foreground).
  211.  
  212.  
  213.  
  214. Mouse Support (DOS only)
  215.  
  216.     ME now supports the use of any mouse which has a Microsoft mouse
  217. compatible driver.
  218.  
  219.     In the macro language, we have set up some new events which let
  220. you trap mouse button presses. Event 11 is generated when you press
  221. the left mouse button, event 12 is generated when you press the right
  222. button, and event 13 is for the middle button. If the editor finds
  223. that there is a hook defined on any one of these event, it will call
  224. the hook macro. Otherwise, the default actions that it takes are :
  225.  
  226.   Left button click   - mark the current line
  227.   Right button click  - set the cursor position to the clicked
  228.                         coordinates
  229.   Middle button click - no action
  230.  
  231.     If the mouse is moved while the left button is held down, then the 
  232. marking of the lines which the mouse passes over will be toggled.
  233.  
  234.  
  235.                CHANGES TO VERSION 2.0 OF THE ME TEXT EDITOR
  236.  
  237. Windows
  238. -------
  239.  
  240.     The biggest change to ME's windowing is the addition of vertical
  241. windows. When you press <ALT> 2 to open another window, ME will read the
  242. specified file and then ask you if you want to split the file horizontally
  243. or vertically. The default is a horizontal split; if you press 'v', the
  244. window will be split vertically.
  245.  
  246.     In previous versions of ME, each window was approximately the same
  247. size. So, if you had three windows open, then each window would take up 7
  248. lines. Starting with version 2.0, when you open a window, the current
  249. window will be divided in half.
  250.  
  251.     The addition of vertical windows also meant some difficulties for EGA
  252. mode. Starting with version 2.0, you can only toggle in and out of 43-line
  253. mode if there is one window open. It gets extremely difficult to determine
  254. how a user wants windows resized when the characteristics of the screen
  255. changes, so we took the easy way out.
  256.  
  257.     Windows now have window identifiers associated with them. A window
  258. identifier is just an integer. This id can be used in the new window
  259. oriented macro functions which are detailed below.
  260.  
  261.  
  262. New Keyboard Handling
  263. ---------------------
  264.  
  265.     The entire method of handling the keyboard was changed. As much as we
  266. have tried to avoid the EMACS model of editing, there are just some things
  267. that Richard Stallman did that we can't ignore. The concept of "keymaps"
  268. fits the concept of "extensibility" perfectly. Therefore, ME now supports
  269. keymaps.
  270.  
  271.     A keystroke can be bound to an editor function, a user-defined macro, a 
  272. keyboard macro, or another keymap. A keymap is just an array of 256
  273. keystrokes, and can be referred to by an integer identifier (much the same
  274. way that buffers and windows have ids). There is also a "current keymap"
  275. which is active at any time. When a keystroke is pressed, the command
  276. associated with the bindings of the current keymap will be executed.
  277.  
  278.     There are several new primitives in the macro language which allow you
  279. to manipulate keymaps. You can push and pop keymaps from a stack. You can
  280. create new keymaps and assign them default value. These new primitive are
  281. outlined in the section below. 
  282.  
  283.     By using keymaps, we have been able to remedy some deficiencies that
  284. were present with the macro language, as well as making the command
  285. structure and keyboard handling more consistent.
  286.  
  287.     Some of the things we were able to fix/enhance are :
  288.  
  289.  - The repetition factor now works for all commands
  290.  - A macro function can now be bound to more than one keystroke sequence
  291.    (For instance, both F1 and ALT F1 can now invoke the same macro).
  292.  - Assign_key() can now bind a macro or editor function to a keystroke
  293.    sequence consisting of multiple keystrokes. For instance,
  294.  
  295.     #define CTRL_Q      17
  296.     #define CTRL_G      7
  297.      ......
  298.     assign_key("goline", CTRL_Q, CTRL_G);
  299.  
  300. will assign to <GOTO LINE> function to the two-keystroke sequence <CTRL> Q, 
  301. <CTRL> G. This will make it much easier to emulate other editors' keystroke 
  302. bindings.
  303.  
  304.     In previous versions of ME, you could capture a sequence of keystrokes
  305. using the F4 key and replay them using the F3 key. This meant that you
  306. could only have one keyboard macro defined at one time. Starting with this
  307. version, you can assign a keyboard macro to any key using the SHIFT-F4 key.
  308.  
  309.  
  310. Macro Language
  311. --------------
  312.  
  313.     Several enhancements to the syntax of the macro language were made.
  314. Switch/case statements can now take strings. This means that you can have
  315. the following switch statement :
  316.  
  317.   string s;
  318.   ...
  319.   switch (s)
  320.   {
  321.     case "HELLO" : ......
  322.                    break;
  323.     case "BYE"   : ......
  324.                    break;
  325.     default      : ......
  326.                    break;
  327.   }
  328.  
  329.     We have added labels and gotos to the macro language. These are exactly 
  330. the same as the corresponding ones in C. The format of a label is
  331.  
  332.   label-name:
  333.  
  334. The format of a goto is
  335.  
  336.   goto label-name;
  337.  
  338. Of course, the label name must exist in the same function as the goto. An
  339. example of a goto statement is the following :
  340.  
  341.   a: ......
  342.      ......
  343.      goto b;
  344.      ......
  345.      goto a;
  346.      ......
  347.   b: ......
  348.  
  349. A goto may backward or forward reference a label.
  350.  
  351.  
  352.     Hexidecimal constants are now allowed in the macro language. These
  353. constants have the same format as hex constants in C. The format is
  354.  
  355.     0x followed by a series of hex digits
  356.     
  357. For example, 0x10 is hexidecimal 16, and 0xFFF is hexidecimal 4095.
  358.  
  359.  
  360. Keyboard Speedup
  361. ----------------
  362.  
  363.     If you have an AT-class machine, then you can take advantage of the
  364. machines programmable typeamatic rate. There are two new parameters in the
  365. options menu (and in the CONFIG.ME file as well). These parameters are :
  366.  
  367.   kr - keyboard typeamatic rate when a key is held down
  368.   kd - delay until typeamatic takes effect
  369.  
  370.     In a normal computing environment, the rate is 12 and the delay is 1.
  371. To get maximum keyboard speedup, set both of these values to 0.
  372.  
  373.  
  374. New Macro Primitives
  375. --------------------
  376.  
  377.     We have added a bunch of new primitives to the macro language.
  378.  
  379. id = create_window(r1,c1,r2,c2[,color])
  380.   int  id;
  381.   int  r1, c1, r2, c2;          /* coordinates of the window */
  382.   int  color;
  383.  
  384.   Creates a "popup" window at the coordinates <r1,c1,r2,c2>. You may optionally 
  385. specify a color as the last parameter. The color value should be :
  386.  
  387.    (background color * 8) + foreground color
  388.  
  389.     A window created with this function is considered to be a temporary
  390. popup window for doing things like menus, messages, etc. One distinction
  391. between this kind of window and a regular window is that a popup window
  392. will not be replaced with another window when the popup window is killed.
  393.  
  394.     When the window is created, there is no buffer attached to it, so
  395. nothing will be displayed. You must use attach_buffer() and show_buffer()
  396. to display the buffer in the window.
  397.  
  398.     The value returned is the identifier of the created window. The
  399. identifier can be used in various other window-related macro functions to
  400. address that particular window.
  401.  
  402.  
  403. window_id = attach_window(window_id, buffer_id)
  404.   int window_id, buffer_id;
  405.  
  406.  
  407.     Attaches the buffer whose id is 'buffer_id' to the window whose id is
  408. 'window_id'. If this function is successful, then the window_id is
  409. returned, or else -1 is returned.
  410.  
  411.     This function is typically used to connect a buffer to a popup window
  412. before displaying the buffer.
  413.  
  414.     Here is an example of its usage :
  415.  
  416.  int win_id, new_buf;
  417.  
  418.  new_buf = setcurrbuf(create_buffer("HELP.MNU"));
  419.  win_id = create_window(MenuRow1+1,MenuCol1+1,MenuRow2-1,MenuCol2-1,MenuColor);
  420.  attach_window(win_id, new_buf);
  421.  show_buffer(new_buf);
  422.  
  423.  
  424. Keymap macros ----
  425.  
  426. id = keyboard_push()
  427.   int  id;
  428.  
  429.     Keyboard_push() will push the current keymap on the keymap stack. A
  430. copy of the current keymap is created and is made the current keymap. The
  431. id returned from this function is the identifier of the new keymap.
  432.  
  433. id = keyboard_pop(destroy_old)
  434.   int  id;
  435.   int  destroy_old;
  436.  
  437.     Keyboard_pop() will pop the top keymap on the keymap stack and will
  438. make it the current keymap. The id returned is the id of the new keymap. In 
  439. addition, the current keymap will be destroyed if the parameter 'destroy_old' 
  440. is non-zero. If the current keymap is not destroyed, it can be recalled at
  441. any time by the function keyboard_set().
  442.  
  443. id = keyboard_id()
  444.   int  id;
  445.  
  446.     Keyboard_id() returns the id of the current keymap.
  447.  
  448. id = keyboard_set(id)
  449.   int  id;
  450.  
  451.     Keyboard_set() sets the current keymap to the keymap whose identifier
  452. is id. If this is successful, then the id will be echoed as a return value. 
  453. If not successful (ie - the keymap with the specified id does not exist),
  454. then -1 is returned.
  455.  
  456. keyboard_defaults()
  457.  
  458.     Keyboard_defaults() will bind all of the keys of the current keymap to
  459. the default values. The default values are the keystroke bindings that
  460. comes preset when you obtain ME.
  461.  
  462.  
  463. change_option(option, value)
  464.   string option;        /* the two-letter option name to alter */
  465.   int    value;         /* the new value */
  466.  
  467.     Change_option() allows you to alter the value of any of the editor
  468. parameters which you find in the options menu and in the CONFIG.ME file.
  469. The first parameter is the two-letter code for the option and the second
  470. parameter in the new value.
  471.  
  472.     Here are two examples :
  473.  
  474.   change_option("in", 'Y');     /* turns insert-mode on */
  475.   change_option("sv", 200);     /* sets autosave to every 200 keystrokes */
  476.   
  477. pos = search_string(str, pattern)
  478.   int    pos;           /* 0-based position that the pattern occured in */
  479.   string str,           /* the string to search through */
  480.          pattern;       /* the pattern to look for */
  481.  
  482.  
  483.     Search_string searches through the string specified by the first argu-
  484. ment for the regular expression specified by the second argument.
  485.  
  486.   if ((pos = search_string(currline(), "[0-9]")) >= 0)
  487.     message("The current line contains a digit");
  488.   else
  489.     message("No digit present in the current line");
  490.  
  491.  
  492. Miscellaneous changes
  493. ---------------------
  494.  
  495.     The "-4" option on the command line will start ME in 43 line mode if
  496. you have an EGA. For example, the command line :
  497.  
  498.   me -4 ed.c
  499.  
  500. will edit the file ed.c starting in 43 line mode.
  501.  
  502.  
  503. BUGS FIXED
  504. ----------
  505. - Macro functions can now have names consisting of upper and lower case
  506. letters.
  507. - A bad EXM format on initial load will not cause a lockup.
  508. - Entab won't compress blanks embedded in double-quoted strings. This
  509. should make blank compression a little more reliable.
  510.  
  511.  
  512. 17) added tonum(str) in macro lang
  513.  
  514.  
  515. Ability to link in external C functions
  516. ---------------------------------------
  517.  
  518.     If you have the source and/or object code for ME, you have the ability
  519. to link in external large model C functions, or functions written in any
  520. language which obey the conventions of the C large model calling sequence.
  521.  
  522.     There are only two kinds of parameters which you can pass to these
  523. linked functions - integers and strings. You can only receive an integer
  524. back as a return value (or any data item which fits in 16 bits).
  525.  
  526.     To link an external C function in, you must make an entry in the table
  527. in file CFUNCTBL.C. Each entry in This table has two elements - the name of 
  528. the function and a pointer to the function. You will use this name in the
  529. macro language to refer to your function.
  530.  
  531.     After your entry has been inserted in the table, you must recompile
  532. CFUNCTBL.C, and relink the editor modules.
  533.  
  534.     So far, the following C functions are available for use in the macro
  535. language :
  536.  
  537.    display(row, col, maxcol, color, str)
  538.      int  row, col, maxcol;
  539.      int  color;
  540.      string str;
  541.    Displays a string on the screen in the specified color. Row and Col are
  542.    0-based coordinates to display string at. Maxcol specifies the last
  543.    column that a character from the string can be displayed. An example is:
  544.   
  545.   display(10, 20, 60, 0x2E, greeting);
  546.  
  547.  
  548.    clear_screen()
  549.    erases the entire screen.
  550.  
  551.    move_cursor(row, col) 
  552.      int  row, col;
  553.    moves the cursor to position <row,col> on the screen. Both row and col 
  554.    are 0 based, so the top left corner is at <0,0>.
  555.    
  556. --------------------------------------------------------------------------
  557.  
  558. Argument processing for do_macro()
  559. ----------------------------------
  560. Do_macro()  can  now  take  arguments.  This  allows  you  to build a macro
  561. command line dynamically and invoke the macro with  the  passed  arguments.
  562. Also,  a macro name entered by ALT P can take args. An arg beginning with a
  563. digit is considered to be an integer, otherwise it's  considered  to  be  a
  564. string.  Look  at  the  macro  called  'menu' to see how a command line for
  565. do_macro() is built at run-time.
  566.  
  567.     Each argument can be separated by spaces or a comma.
  568.  
  569.     As an example :
  570.  
  571.   string macname, arg1, arg2;
  572.   int    tab_amt, maxcol;
  573.  
  574.   macname = "shift_line";
  575.   arg1    = tab_amt;
  576.   arg2    = maxcol;
  577.   .......
  578.   do_macro(sprintf("%s %d %d", macname, arg1, arg2));
  579.  
  580.  
  581. Enhanced formatting for message() and get_tty_str()
  582. ---------------------------------------------------
  583.     Message()  and  get_tty_str() can now take sprintf()-type formats and a
  584. variable number of arguments. This will make the debugging of macros a lit-
  585. tle easier. For example : 
  586.  
  587.   message("Hello %s", username);
  588.   foo = get_tty_str("Variable i is [%d]", i);
  589.  
  590. Hooks
  591. -----
  592.     A  "hook" is a user-defined macro which is executed when certain events
  593. occur in the editor. The purpose of a hook is to allow the user  to  modify
  594. or  "filter" the processing which the editor does when these events happen.
  595. The following events are supported :
  596.  
  597.   Event Number          Event Type
  598.   ------------          ----------
  599.    0                    The user inserted a character into the text
  600.    1                    The editor is terminating
  601.    2                    An illegal command was pressed
  602.    3                    The CTRL BREAK key was pressed
  603.  
  604.     We will add other event numbers as the need comes up  -  send  us  your
  605. suggestions!
  606.  
  607.     There are two primitives which manipulate hooks - one for adding a hook
  608. and the other for removing a hook.
  609.  
  610. add_hook(eventnum, macro)
  611.   int  eventnum;
  612.   string macro;
  613.  
  614. DESCRIPTION
  615.  
  616.     Add_hook()  will  cause  the user-defined 'macro' to be called whenever
  617. the event 'eventnum' occurs. The macro should NOT expect any  arguments  to
  618. be passed.
  619.  
  620. PARAMETERS
  621.  
  622.     'Eventnum'  is a number from 0 through 3. The event numbers are defined
  623. as follows :
  624.  
  625.   Event Number          Event Type
  626.   ------------          ----------
  627.    0                    The user inserted a character into the text.
  628.                         The hook will be called before the cursor is
  629.                         advanced to the next column.
  630.    1                    The editor is terminating
  631.    2                    An illegal command was pressed
  632.    3                    The CTRL BREAK key was pressed
  633.  
  634.     'Macro' is the name of a macro which should be called  when  the  event
  635. occurs. 
  636.  
  637. RETURNS
  638.  
  639.     Nothing.
  640.  
  641. EXAMPLE
  642.  
  643.   init()
  644.   {
  645.      ......
  646.      add_hook(0, "charhook");   /* called whenever a char is inserted */
  647.      .......
  648.   }
  649.  
  650.   charhook()
  651.   {
  652.     /* Map all lower case letters to upper case */
  653.     if ((c = currchar()) >= 'a' && c <= 'z')    /* lower case letter */
  654.     {
  655.       c = 'A' + c - 'a';                        /* xlate to upper-case */
  656.       delchar();                                /* remove the bad char */
  657.       insert(chr(c));                           /* & insert the good one */
  658.     }
  659.   }
  660.  
  661.  
  662. delete_hook(eventnum)
  663.   int  eventnum;
  664.  
  665. DESCRIPTION
  666.  
  667.     Delete_hook() will remove the hook associated with event 'eventnum'.
  668.  
  669. PARAMETERS
  670.  
  671.     'Eventnum' is an integer defined in the table above.
  672.     
  673. RETURNS
  674.  
  675.     Nothing
  676.     
  677. EXAMPLE
  678.  
  679.   delete_hook(0);
  680.  
  681.  
  682. File Searching
  683. --------------
  684.   rc = set_filespec(file_spec)
  685.     string file_spec;
  686.     
  687. RETURNS
  688.  
  689.   If at least one file is found which matches the filespec, the number 
  690. 1 is returned or else 0 is returned.
  691.  
  692.   fname = next_filespec()
  693.   string fname;
  694.  
  695. RETURNS
  696.  
  697.   If another file matching the filespec is found, the name of the file
  698. is returned, or else the 0-length string is returned.
  699.  
  700. Example
  701. -------
  702.   /* Prompt for a file specification, and insert each file name matching */
  703.   /* the filespec into the file                                          */
  704.  
  705.   if (set_filespec(get_tty_str("Input the filespec : ")))
  706.   {
  707.     while ((fname = next_filespec()) != "")
  708.     {
  709.       insert(fname);
  710.       insert("\n");
  711.     }
  712.   }
  713.  
  714.  
  715. timestr = time()
  716.   string timestr;
  717.  
  718.   The time() function returns a string which has the system time in the
  719. form hh:mm:ss. 
  720.  
  721.  
  722. datestr = date()
  723.   string datestr;
  724.  
  725.   The date() function returns a string which has the system date of the form
  726. mm/dd/yy.
  727.  
  728. --------------------------------------------------------------------------
  729. The TAGS function <CTRL T> is now implemented as a macro. To use this
  730. facility, you must load the TAGS macro into the editor. If you do this
  731. from the DOS command line, you would use the command :
  732.  
  733.    ME -lTAGS <filename>
  734.    
  735. When you invoke the TAGS macro, you will be asked for the name of the function
  736. to look up. If you press <ENTER>, you will be presented with a menu of
  737. functions in a full-screen window. You can use the UP and DOWN arrow keys to
  738. move through the menu. Position the highlight over the desired function and
  739. press <ENTER> to select that function.
  740. --------------------------------------------------------------------------
  741.  
  742. ALT 4 now splits the window vertically
  743.  
  744. Pressing <ALT F7> at a marked line will now unmark it.
  745. -----------------------------------------------------
  746. i = get_option(param)
  747. c = get_lastkey()
  748. Hook number 8
  749.  
  750.