@Comment[LastEditDate=28-JUN-1989 14:29:30.98, By: FLEMING ] @LibraryFile[MultiLevelIndex] @Libraryfile[TwoColumnIndex] @LibraryFile(Stable) @MAKE[manual] @STYLE[WidowAction=FORCE] @DEVICE[Imagen300] @STYLE[INDENT=5] @modify[Appendix,titleenv HD2,Contentsenv TC2] @modify[Appendix, numbered [@A], Referenced [@A] ] @style[FontFamily ComputerModernSansSerif12] @define[StepEnum = Enumerate,numbered] @Pageheading{Even,Right "@c[EVE User's Guide]", Left "@c[@value(page)]" } @Pageheading{Odd,Left "@c[@title(chapter)]", Right "@c[@value(page)]" } @Pagefooting{Center "@b[EVEplus Editor]"} @SpecialFont[F0="CMSSBX10R36"] @BEGIN(TITLEPAGE) @BEGIN(TITLEBOX) @F0[The EVE User's Manual] @Majorheading[EVEplus Editor] @END(TITLEBOX) @BEGIN[QUOTATION] @begin[i] This manual describes the local customization of the EVE editing interface provided by Digital Equipment Corporation under the VMS Operating System on the VAX. @end[i] @END[QUOTATION] @END(TITLEPAGE) @modify[page,numbered {@i} ] @set[page=0] @NewPage(1) @Modify[text, font SmallBodyFont] @blankspace(5) @begin[text,centered] Published by GE Microelectronics Center, PO Box 13049, @* Research Triangle Park, NC 27709-3049 @* Revision : June, 1989. Second Edition: November, 1988. First Printing: October, 1986 "GE" is a registered trademark of General Electric Company. @End[text] @blankspace(3) @begin[text] @tabset(6) @SubHeading(Notice of Distribution and Copyright) The "EVE User's Manual" is distributed free to the general public in the hope that it will serve as a reference resource for use with the EVEplus software developed at this site. The EVEplus software may be found on the public domain DECUS tapes. Everyone is hereby given permission to copy, modify, and redistribute this publication. Distribution by any party to another shall be free or at cost, for producing and distributing said materials contained herein. @* @\Although great detail has been paid to accuracy, GE Company accepts no liability or responsibility to any other party for damages or loss of monies resulting from usage of material presented in this publication, be it supplied directly by GE Company or a third party. @* @\The copyright for this documentation is non-transferable, and this copyright notice must be included in all copies, regardless if they are original or modified. Any party using this documentation contrary to the conditions described in this Distribution and Copyright notice forfeits all of their rights for usage. @end [text] @blankspace(2) @center{@CopyrightNotice[ GE Company. ]} @begin[ResearchCredit, font SmallBodyFont] @blankspace(4) The following are trademarks of the Digital Equipment Corporation, Maynard, MA: ALL-IN-ONE, DTR, EDT, EVE, SOS, TPU, VAX, VMS, and WPSplus. @End[ResearchCredit] @NewPage(1) @Counter(ContentsPage, Numbered <@1>) @Set(ContentsPage=Page) @set[page=0] @modify[page,numbered {@1} ] @chapter[EVEplus Version 2.0 Release Notes] @section[New Features of the TPU/EVE editor] This release of EVEplus constitutes a major release of the editor, compatible with VMS Version 5.0 operating system on the VAX. A succinct presentation of the many new features and enhancements for TPU/EVE Version 2.0 may be found in the @i[VMS Version 5.0 New Features Manual], and the @i[EVE/TPU Editor Manual]. We will now briefly describe the most important new features as they relate to EVEplus. Probably the most important enhancement made by DEC to TPU was a complete rewrite of the @i[garbage collector]. Under EVE Version 1.0, memory was never reclaimed. As memory utilization approached the process memory quotas (i.e. editing large files, subprocesses), it was possible to exhaust process memory quotas, resulting in a stackdump out of the editing session. This @i[bug] has been fixed, with the side effect of improving overall speed and efficiency of the TPU code underlying EVE. Starting with Version 2.0, DEC will no longer support or supply an EDT section file. This means DEC is once again affirming its' desire to allow EDT as an entity to go the same route as the SOS editor (i.e. extinction). However, the DEC EVE development team will continue to provide support for EDT-ish functions. EVE now provides emulation of the EDT keypad with the new command @i[set keypad EDT]. This command may be placed in the EVE$INIT file. For information on @i[Init] files see the section on @i[Section files and extending EVE]. In addition EVE supports the All-in-One editor WPSplus with the command @i[set keypad wps]. We intend to provide support locally for EVEplus with EDT functionality, but not for WPSplus at this current time. @section[New Features of EVEplus]. Since our initial release of EVEplus, we have attempted to keep the keypad @i[frozen]. The exception in Version 1.0 was the replacement of @i[message up/down] on RED-KP4/5 to @i[Shrink/Grow window]. We have made one major change to the keypad for Version 2.0. EVE now offers a new function @i[split window] which we felt deserved a place on the keypad. This function will split the current window ((n/2)-1) lines, until it can no longer split due to size limitations. Thus one can now have up to eight windows on the standard VT terminal screen. The logical place for this function was KP-3 with the other window related commands. Specifically it was placed on RED- KP3. The @i[get_file] function previously on RED-KP3 was moved to RED-KP2. The RED-KP2 @i[center line] was moved to BLUE-KP2, and the seldom used (we hope) @i[transpose characters] was eliminated from the keypad. As previously announced, unlike the keypad the VT200 function keys are @i[volatile] in nature and indeed the functionality of the F16-F19 keys have been changed. We have eliminated the redundant @i[select/cut/paste rectangle] keys to make room for new functions @i[ erase buffer, unmap window]. Other functions for F16-F19 have been rearranged. See the section on VT200 key binding @index(VT200_Keys)for more information. The only change on the keyboard is a change for ctrl-R. Due to user demand, ctrl-R is bound once again to @i[remember], instead of @i[repeat]. This was the original binding for this key. The user may now choose to toggle the tab-key between insert and @i[movement] mode by pressing @i[ctrl-@@]. When in @i[movement] mode the tab-key will behave like a tab-stop on a type writer(i.e. it will not insert tabs into the text). The reader is referred to the section describing the tab-key binding for more information. @index(Tab_toggle) Another toggle function involves the find key. You may toggle between the generic and the wildcard find functions by pressing @i[ctrl-%]. The most useful function of the wildcard find, is that it will enable you to find a given control character in the buffer (e.g. form feeds). Again for more information the reader is referred to the section describing the find key. @index(Wildcard_toggle) Many new enhancements have been made to the @i[get_file] function. @index(get_file)During Version 1.0 development we added the functionality that allowed a user to position the cursor over a filename, do a get_file/select, and the file was retrieved into the editing session. We have added capabilities which allow a user to @i[set default] to @index(set_default)another directory, and also to @i[delete] a file @index(delete_file)from within the editor. This functionality was added via the @i[call_user] @index(call_user) primitive which allows one to call an executable image outside of the editor. For more information on our call_user interface and some of its' additional capabilities, the user to referred to the section on @i[The Call_user interface]. The other enhancement made for Version 2.0 was the ability for the user to turn off insertion of the comment line into a file upon exit. Normally this line indicates the last user to edit the file, and the time-date this was performed. The user can now define a symbol @i[TPU$COMMENT]. @index(TPU$COMMENT) The default value of @i[YES] for TPU$COMMENT allows the insertion of the comment date-time stamp to be placed at the begining of a file. You can override the system logical by defining a job or process logical TPU$COMMENT with a value of @i[NO]. If the TPU$COMMENT logical is undefined, calluser will return an error status of "%000001BC", and any exit or file activity will fail. TPU$COMMENT must be defined on the system by the system manager, or at the local process level by the user. @section[DTR-TPU bug note] @index(DTR) At our site when we brought up VMS Version 5.0, DTR was not able to use the EVEplus section file, pointed to by DTR$EDIT. It turns out that unless the section filename is named @i[TPUSECINI.TPU$SECTION], DTR will complain about it being an inappropriate editor. The workaround for this @i[bug] is to make a copy of the EVEplus section file to TPUSECINI.TPU$SECTION. @Chapter(EVE -- @i[Extensible Easy Efficient] VAX Editor) @label(Overview) @section[What is EVE?] EVE is an editing interface to the TPU (text processing utility) Editor. The TPU editor utility contains primitive function calls which can be tailored into an custom editing environment. The EVE interface consists of a @i[section file] of TPU complied code. This code is interpreted at startup or runtime. EVE as provided by DEC under Version 1.0, was a @i[bare bones] interface to TPU. This situation has improved under Version 2.0 with the inclusion of EDT emulation. The user may come across documentation for EVE in @i[Guide to Text Processing], but should note this documentation is discussing the DEC-EVE, and not our local implementation of EVE. In an attempt to show the user community how to expand the EVE interface, DEC provided @i[EVEplus] on the Spring 86 DECUS tape. Contained on this tape were useful functions, many of which have been incorporated into Version 2.0. The main ingredient missing was a key binding scheme which would allow easy access to the functions provided. This became the starting point for the local customization of EVE. Since then we have enhanced, and made minor bug fixes to the original code, in our implementation of EVEplus. As the abbreviation implies, EVE can be modified easily and extended in functionality by the user. The complete source code for EVE may be found in @i(util_root:[eveplus]eveplus.bck) as a backup save-set. @section[How to Use EVE] At our site we have the following symbol and logicals defined: "EVE" == "EDIT/TPU" "TPU$CALLUSER" = "SYS$SHARE:CALLUSER.EXE" "TPU$COMMENT" = "YES" "TPU$SECTION" = "SYS$SHARE:EVEPLUS.GBL" When typed, the symbol EVE will invoke TPU using the section file pointed to by TPU$SECTION. The syntax of the EVE command is: $ eve filespec Next make sure your terminal setting is either @i[eight-bit no parity], or if you are using a 7-bit setting type in (or place in your login.com)- @i[$set term/noeightbit].@index[Terminal] Failure to set a 7-bit terminal to noeightbit will cause the characters to be scrambled on the screen. EVE Version 1.0 was benchmarked by DEC as approx. 35% faster than EDT (DECUS Symposium communication). The bugfix to the garbage collector in EVE Version 2.0 will increase editing speed. Upon entry into EVE you will be automatically placed in screen mode editing. After the file comes up you will see an inverse status line @index(status_line)on the bottom of the screen. It will indicate the name of the buffer, which initially is the name of the file being edited. Next to the buffer name will be @i[WHITE_MAP]. This field will always indicate the current keymap or level in the keypad you are on. The next field indicates whether you are in insert or overstrike mode. This field can be altered with the F14 key (VT200), or ctrl-V (all terminals). The last field indicates the direction of editing, forward or reverse. This can be altered with the F11 key (VT200), or the KP4 advance (white) and KP5 backup (white) keys. @section[EVE keypad] The EVE keypad has 4 layers. The first two layers @index(Keypad_layers) (white-yellow) are very simular to the standard EDT keypad. The other two layers (red-blue) contain additional EVE functions. At anytime if you press the PF2 (help) key, it will display the current keymap (as a layer is called in EVE). For example if you are in the yellow keymap, and press PF2 the yellow keymap is displayed. How do you get from one keymap to another? Press the PF1 @index(Shift_key) key and EVE will toggle you down to the next keymap. If you are in the white keymap and press the PF1 key 4 times the following conceptual events would occur: white->yellow->red->blue->white. Each time the PF1 key is pressed the map field in the status line will update and indicate the new keymap. After toggling to the keymap desired, upon pressing a keypad will execute a command, and the user to returned the white keymap. If you wish to stay in the keymap and not be automatically returned to the white map, then before entering a keypad key, enter @i[shift-ctrl-?]. This will prevent EVE from returning you to the white keymap. Instead you will remain in the current map. You can use the PF1 to toggle to other maps, but as long as the lock feature is on EVE is prevented from returning you to the white keymap automatically. You can reactivate the automatic return to the white keymap, by entering @i[shift-ctrl-?]. This will toggle the auto return @index(Auto_return)feature on. This function works only for VT200 terminals. If you are on a VT100 terminal, and wish to have the toggling feature, then you will need to bind the function: @i(eve_lock_map) to a different key of your choice. We have attempted to arrange the key layout such that the less used functions are in the bottom keymaps. Complementary functions are at the same level, and simular function groupings are on the same key (e.g. KP3; windows). The individual keys are described in the section- @i[EVE Keypad Commands]. A color diagram of the EVE keypad is available to all users, reflecting the first 4 levels in the keypad. @index(Keypad_diagram) @section[Accessing Non-keypad EVE and TPU commands] You can access any @index(TPU_Command) EVE or TPU function through the @i[Do] key. @index(Do_key) If you hit the @i[Do] key you will receive the prompt at the bottom of the screen- @i[Command]. At this level you can enter the name of any EVE function. To enter a TPU command (i.e. by command we actually mean a TPU @i[primitive] or function found in the TPU manual), enter @i[TPU]. You will now receive the prompt- @i[TPU command]. At this level enter the TPU command. Note many TPU commands require parameters. TPU commands which return values must be given with a variable on the left-hand side of the statement. Example: command: tpu x:= get_info(current_buffer,"name") Alternatively such functions may be combined with others requiring no return variables: command: tpu message(fao("Buffername is: !AS", get_info(current_buffer,"name"))) The @i[Do] key also has a couple of other neat functions. If you hit the @i[Do] key twice it will repeat the last command. You can also toggle through the command buffer. Hit the @i[Do] and thereafter the up and down arrows. This allows the user to go up and down in the command buffer, to execute a given command in the command buffer just hit . This mimics the command recall at DCL level. @section[Concept of EVE keymaps] Before discussing how the user can define his/her own keys, let's first discuss the exact meaning of the word @i[keymap]. @index(Keymaps) Starting with VMS4.4, TPU was released with the concept of keymaps and keymap lists. Consider the TPU function define_key. It takes 4 parameters: function, keyname, comment, and keymap. A key can be bound to any existing function and keymap. In turn the keymap can be bound to any existing keymap list. @index(Keymap_lists)The keymap list behaves analogous to a link list. When EVE goes to lookup a key definition it starts in the current keymap in the list, and proceeds to traverse the list until it finds a binding. A buffer can have any one existing keymap list bound to it at a given time. A keymap may contain as many definitions as there are keys on the terminal keyboard, except for a few special keys such as ctrl-Y, ctrl-Q etc. The number of keymaps which can be created is limited as is EVE by the process working set in memory. If the reader is interested in seeing the EVE keymap list, try giving the tpu command: @i[tpu show(key maps)]. Likewise to show the available keymap lists, give the command: @i[tpu show(key map list)] There are two ways a user can define a key: @index(Defining Keys)eve_user_define_key (PF3-yellow), or the tpu command define_key. Both will behave differently. On the assumption the user wants his/her definition to supercede the present definition, eve_user_define_key will attempt to make sure the key is placed in the proper keymap. The TPU define_key will place the key definition in the eve$user_keys keymap if the keymap is not explicitly given in the define_key command. It is @i[recommended] the eve_user_define_key function be used. @section[How to extend EVE] If you define a key, the definition will go into @index(Extending_EVE) effect immediately. If you write a function it will remain unknown to EVE until you @i[extend] the current EVE session. Extending EVE places the definition for the function in the internal tables of EVE. You may extend EVE by using KP-7 (Red), or directly using the @i[Do] key and typing in the command @i[Extend]. Either method will prompt you for a function name. Type in the function name to extend a particular function, else type in "*" to extend every function in the current buffer. EVE will flash at light speed several messages at the bottom of the screen. If everything is correct EVE will display a message that the function was extended and TPU detected no errors. If there are errors, then it will inform you there were errors and that TPU was not extended. If there are errors you may wish to view the message buffer to see where they occurred. @index(Message_Buffer)EVE will point to the syntax errors where they occurred. Using the @i[goto line number (Yellow KP-0)] will aid locating the line numbers for the errors. After correcting the errors, try the extension again. The new key binding and function extensions will not be present in the next editing session unless they are @i[saved]. When you use KP-7 (Blue), or the command @i[save], the extended EVE session is saved in a @index(Global_section_file)@i[global section file]. A global section file can be thought of as a snapshot or copy of a section of memory saved as a binary disk file. In this case it is the modified copy of EVE. For a more theoretical discussion of global section files the reader is referred to the @i[System Services] Manual. The @i[Save] command will prompt for a file to save the EVE environment in. You should give a complete file specification (device, disk) to avoid ambiguities. Also by convention all EVE global section files have the file extension of @i[TPU$SECTION]. At our site we use the shorter file extension of @i[gbl]. EVE should come back after a save telling you the number of functions, and keys saved. The next time you wish to use EVE, you can access your new EVE global section file by two different methods. Either redefine the EVE symbol so that the section file named is your section file or explicitly type in: @i(eve/sec=dev:[dir]myfile.gbl). Commands which need to be executed each time when you edit, may be placed in an initialization file. You then need to define the logical EVE$INIT @index(EVE$INIT)to point to this file. For example suppose you wish to change the scrolling area of the screen so that scrolling starts when the cursor is seven lines from the top or bottom of the screen (e.g. Due to a vote of 2-1 or 3 votes total the system EVE$INIT sets it to one line of scrolling from the top and bottom -- anyone for another vote?). Create a file of a given name (e.g. myinit.eve) and place the desired EVE command in it: @i[set scroll margins 7 7] Now define the logical EVE$INIT to point to the file: @i($ define/job eve$init disk:[directory]myinit.eve) Where disk, and directory are your default disk and directory for your account. The logical definition should be placed in your login.com file. EVE when starting up will look for the logical EVE$INIT. If defined it will execute the EVE commands in the file the logical points at. Note these commands are EVE commands not TPU function primitive calls. Suppose there are TPU procedures which you use rarely (e.g. special key binding), and would like to avoid having them around most of time so as to optimize the startup time of EVE. EVE can interpret TPU functions at runtime via the @i[/com] qualifier. Whenever you decide that these functions are needed for a given EVE session, type in the command: @index(Command_file) @i(eve/command=my_device:[my_directory]my_function_file.ext filename) where the file specification given after the command equals contains the TPU code (and/or primitive calls). An alternative way to call up your command (TPU code) file every time the editor is invoked is to define the logical TPU$COMMAND:@index(TPU$COMMAND) @i($ define tpu$command my_device:[my_directory]my_function_file.ext) Of course interpretation is expensive, so if you plan to use functions often it is better to save them in the global section file. @section[EVE and DCL] We have supplied three different keys accessing DCL @index(DCL) while in EVE. The Spawn [KP-9 White] @index(Spawn)allows the user to spawn out of EVE to DCL. While in the subprocess you can give any DCL command. You can even edit the same file you were editing when you spawned! Of course it will be the file as it appears on disk since the other editing changes haven't taken effect yet. Logging out will return you to the editing session. The Spawn/Mail [KP-9 Yellow] @index(Spawn_mail)will spawn and invoke mail. This is useful in those cases where you wish to check incoming mail without leaving your current editing environment. Upon exiting from mail, you are returned to the edit session. The Spawn/DCL [KP-9 Red] @index(Spawn_DCL) allows one to give a DCL command from within EVE. The output from any given DCL command is trapped into a buffer named @i[DCL]. Suppose you wanted to include all the names of the files in a given directory into the file you were editing. After the Spawn/DCL directory command was given you could easily merge [KP-Enter Red] the DCL buffer into the current buffer. @i[Warning]: do not use Spawn/DCL for DCL commands which generate non- terminating output. An example of such as command would be @i[monitor process/topcpu]. The reason for this is that a spawn passes control of the terminal to the subprocess. If the subprocess never ends control will never return to the main process, and anything typed in (including ctrl-Y) is never picked up by the terminal driver. @section[Recovering an EVE edit session] EVE like other editors has the capability to journal and recover @index(Recovering_session)a lost edit session due to system crashes, ctrl-Y, and process termination or suspension. To recover an edit session type in : @i[$eve/recover filename.ext] If you leave off the extension EVE will tell you that such a file doesn't exist, prompt you to continue recovery. If you answer @i[yes], the recovery is done in a buffer without the extension. An EVE journal file @index(Journal_file) has the following name : @i[filename.tjl]. If you attempt to recover specifying the journal file, EVE will attempt to recover the journal file using the journal file, discover the mistake and ask you if it's ok to continue trying. If you answer yes, EVE will create a new buffer with the name of the file given without an extension and recover the journal file into it resulting in a mess. Again, specify the filename to be recovered, not the journal filename extension. EVE like EDT will journal your entire editing session transparently without any interruptions. You can vary the rate of journaling in EVE with the Set Journal command [KP-9 Blue]. Thus if the system is erratic and you fear losing part of your edit session, you may wish to increase the rate at which the buffer to the journal file is flushed. Of course this will degrade the overall turnaround time for the editor the faster you journal. For more information see the section on the Blue keypad. There might be times when during a long edit session with many changes you would like to divide your edit session into several sessions, and later decide which changes were really needed. You can use the @i[Open Journal], @index(Journaling) and @i[Close Journal] commands. Closing the journal file effectively @i[flushes] the terminal type-ahead buffer. When you close a journal file, your session is no longer recoverable from that point forward until you reopen another journal file. When you open a journal file EVE will prompt you for a name to use for the new journal file. @section[Advanced Commands and Interfaces] Eve has several commands which were never available in the standard EDT. There are misc. buffer and window commands manipulations you can perform. You can even @i[print] the current buffer or screen without ever leaving EVE. There are misc. column editing routines which allows one to select, cut, and paste columns in a file, shift columns, and interchange columns. For more information the user is referred to the @i[EVE Keypad Commands], and @i(EVE Auxiliary Commands). There is a hook from EVE into LSE, allowing one to toggle between EVE and LSE (Language Sensitive Editor). LSE is a DEC product which allows one to compile, review, and correct syntax errors. Thus one could type in some program lines in EVE, enter LSE to eliminate syntax errors, return to EVE and type in the next routine or module. For more information on LSE contact the systems group. You can interface with EVE from the mail @index(Mail)facility, and from the debugger. In order to setup EVEplus as your default mail editor define the following logical: @i[$define mail$edit TPU] @index(MAIL$EDIT) While in mail you can invoke the editor to send messages with the : MAIL>send/edit or reply/edit command. These commands will invoke the EVE editor. Upon exiting from EVE (ctrl-Z), the mail is sent and you are returned to the mail level prompt. In EVEplus Version 1.0 there was an undocumented command @i[mailx] @index[Mailx]which is now supported in Version 2.0. This command allows one to mail a buffer to another user, without having to use the DCL-Mail command. It basically writes the buffer to a file, and then uses the TPU @i[Send] command, to interface with the mail utility. It also has the capability to use the %NM foreign mail utility. In order to invoke EVE from the debugger you must first define the following logical: @index(DBG$INIT) @i[$define dbg$init util_root:[eveplus]debug.com] Where @i[debug.com] is a debug initialization file defining the editor with the command: @i[set editor/callable_tpu tpu/sec=sys$Library:eveplus.gbl] This initialization file will setup the debugger so that when you enter: DBG> edit , you will automatically be placed inside the EVE editor using the source code for the program being executed (i.e. EVE assumes the source file has the same filename as the file being executed). This feature allows one to execute a program in the debugger, correct a mistake in the source code via EVE and then returning to the debugger to continue execution. @section[EVE Futures] Since EVE through TPU is DEC supported, we will provide local support for our version of EVE. If the user discovers errors, in the functionality of EVE they should report it to the systems group. Also if they would like to see a function included in the next version of our EVE, and interest in such a function is widespread they should submit the suggestion. For that matter if the user has written a function which he/she may feel would be of value to others, please submit it and it will be considered for incorporation into the next version. New functions as they become available will be placed in: @i(util_root: [eveplus]). These functions if not already incorporated into EVE may be used to extend EVE as explained above. Also in this directory is the file: @i[evenotes.txt] which contains the latest information and bug fixes to EVE. An experimental version will be available under the global section name of @i[eveplusx]. This experimental version may have interesting new functions being added or considered, but it will be as it name implies @i[experimental]. @section[Summary] The EVE editing interface described herein provides the user with a more powerful and elegant editing environment than previously available through other editors. Since the top two levels or keymaps are very simular to EDT, most EDT users should find the learning curve to be short. EVE can be easily modified or extended by the user to their own style. @chapter(EVE Keypad Commands) @label(Key Bindings) @section(White Keypad) @begin(itemize) @index(Shift_key) @b(Shift Key [PF-1]). Shift or toggle to the next or previous keymap. The keymap name appears in the status line at the bottom of the screen. By default EVE will return to the @i[white_map] after a command is executed. If the user is on a VT200 terminal, and wishes to remain in a given map, then they should enter @i[ctrl-?]. @index(Lock_keymap) This key will toggle the user between lock and unlock in a given keymap. Pressing this key again will unlock the current map feature. When a map is locked the user remains in the current map level after a subsequent key is pressed, instead of returning to the white map. You can still toggle to another map using the PF-1 key while in the locked state. Example: Toggle to the blue_map using the PF-1 key, and enter @i[ctrl-?]. Strike a key on the keypad. You remain in the blue map. Toggle to another map, using the PF-1 key. Press any key, and once again you remain in the current map. Press @i[ctrl-?] (unlock), and then a keypad key. EVE will now return you as before to the white_map. Those VT100 users wishing to have this functionality may bind the function @i(eve_lock_map) to the key of their choice. When you toggle to another keymap, the status line @index(Status_line) is updated. If there are multiple windows on the screen only the buffer you are currently in is updated. The status line for the other window will be updated when you toggle or return to that window. @b(White Help [PF-2]). Display the keypad diagram for the White keymap. @b(Find Next [PF-3]). Find the occurrence of a string. Prompts @index(Find_next) for string. EVE will search in the current direction and if the string is not found, it will then reverse the direction of search. If you press the key again instead of entering a string, it will search for the next occurrence of the previous search string entered for this command. You can also recall the string entered for the find command by pressing PF-3, and then the up arrow. This enables one to recover from spelling errors. If you wish to take advantage of EVE wildcard search routines, these can be toggled on by pressing @index(Wildcard_toggle) ctrl-%. Suppose you wish to search for all form feeds in a given buffer. After pressing the find key, enter @i[\^L]. The next form feed would be found. Note that in order to find the character string @i[\^L], you would first have to toggle back to the normal find mode, by again pressing ctrl-%. For more help on wildcard search capabilities, the reader is referred to the online help. @b(Delete Line [PF-4]). Delete the current line.@index(Delete_line) @b(Page [KP-7]). Find and goto the next page or form feed in the buffer. @index(Page) @b(Section [KP-8]). Advance or backup one screen of text.@index(Section) @b(Spawn [KP-9]). Spawn into a subprocess outside of the editor. While in the subprocess any valid DCL commands may be given. Upon logging out control of the process is returned to EVE.@index(Spawn) @b(Delete Word [KP-Minus]). Delete current word.@index(Delete_Word) @b(Advance [KP-4]). Set current direction to Forward.@index(Advance) @b(Backup [KP-5]). Set current direction to Reverse.@index(Backup) @b(Cut [KP-6]). Cut the selected range into the @i(insert here) buffer. @index(cut)If no select is active in the current buffer, EVEplus will attempt to find one in another buffer. The first buffer encountered with an active select will be used for the cut. @b(Delete Character [KP-Comma]). Delete current character. @index(Delete_character) @b(Next_word [KP-1]). Advance or backup one word.@index(Next_word) @b(EOLN [KP-2]). Goto the end of the current line.@index(EOLN) @b(Other Window [KP-3]). Position cursor to the other window on the screen. If only one window is present a warning is given by EVE and the command is aborted.@index(Other_window) @b(Next_line [KP-0]). Advance or backup one line positioning the cursor at the beginning of the line.@index(Next_line) @b(Select [KP-Period]). Select the beginning of a range in the current buffer. @index(Select) @b(Get Buffer [KP-Enter]). Prompts for a buffer name and places it in the current window, unmapping the current buffer from the window. @index(Get_buffer) @end(itemize) @section(Yellow Keymap) @begin(itemize) @b(Yellow Help [PF-2]). Display a diagram of the EVE Yellow keypad. @b(Define Key [PF-3]). Define a key for this edit session. The key not be saved for next EVE session unless EVE is extended and saved. It will prompt for the EVE command and ask for a @i[keymap]. By default if the key to be entered is a keypad key the function will assign the key to the current keymap you are on. If you are defining a non-keypad key, it will default to the @i[eve$user_keys] keymap. If a non-keypad key has a binding in the White, Yellow, Red, or Blue keymaps the user will be informed that the key has a previous binding, and asked if it's ok to proceed. If the answer is @i[yes] then all previous bindings are wiped out and the users' function is bound to the key. Without this mechanism the user definition would never be press if it were to be placed in the default @i[eve$user_keys] keymap. After deciding where it should go, eve_define_key will prompt for a key stroke, function to be bound, and a short description of the key-function. @index(Define_key) @b(Undelete Line [PF-4]). Restore last line deleted.@index(Undelete_line) @b(Command [KP-7]). Prompt for an EVE command. If you use to enter a TPU command enter @i(TPU). It will then prompt for a TPU command. @index(Command) @b(Fill [KP-8]). Fill or pad paragraph with blanks, even up right margin. @index(Fill) @b(Spawn_Mail [KP-9]). Spawn into the Mail facility. Upon exiting mail with a ctrl-Z control is returned to EVE.@index(Spawn_Mail) @b(Undelete Word [KP-Minus]). Restore the last word deleted.@index(Undelete_word) @b(Bottom [KP-4]). Goto the bottom of the current buffer.@index(Bottom) @b(Top [KP5]). Goto the top of the current buffer.@index(Top) @b(Paste [KP6]). Paste the @i[insert here] buffer before the current cursor position.@index(Paste) @b(Undelete Character [KP-Minus]). Restore the last character deleted.@index(Undelete_Character) @b(Change case [KP-1]). Change the case of the current character, or if the @i[select] is active in the current buffer, then the case of all characters in that range is changed.@index(Change_case) @b(Delete EOLN [KP-2]). Delete the EOLN character.@index(Delete_EOLN) @b(Two Windows [KP-3]). Create two windows on the screen. The current buffer is duplicated into the second window. If two or more windows are present the screen is toggled to one window displaying the current buffer in the one window. The other buffer(s) is unmapped with the other window(s) from the screen. @index(Two_windows) @b(Goto Line Number [KP-0]). Prompts for a line number and positions the cursor to that line in the buffer.@index(Goto_Line) @b(Print Buffer [KP-Period]). Print the current buffer. This key will write the current buffer to a file with the same name, spawn with a DCL command to print the filename just created.@index(Print_buffer) @b(Write Buffer [KP-Enter]). Write the current buffer to a file. If the buffer was created during the edit session, as opposed to being a file brought in, then EVE will prompt for a filename. If you enter a then EVE will write out the file using the default buffer name as the filename. If a select region is active in the current buffer, EVE will attempt to write out the select region. You will be prompted for a filename to associate with the select region. If no filename is given the operation is aborted. As with all commands in EVE, to abort this command press ctrl-C, followed by a . If the file @i[type] is known (e.g. for, c, com, mss, mar, pas, tpu) then a comment @index(Comment)line is inserted at the top of the file. Contained in the comment line will be a date-time stamp and the current username. If you wish to turn off this feature, then give the following command at DCL level: $ define/job TPU$COMMENT "NO" @index(TPU$COMMENT) You can turn it back on by resetting the logical value to the default of "YES". @end(itemize) @section(Red Keymap) @begin(itemize) @b(Red Help [PF-2]). Display the keypad diagram for the Red keymap. @b(Set Mark [PF-3]). Set a place marker in the current buffer. After going elsewhere in the buffer you can give the @i[Goto Mark] command to return to the place marker. EVE will prompt for a marker name, thus you can have several markers active at the same time. If you enter a marker name which already exists then the current cursor locationname is associated with the marker, wiping out the old association. @index(Set_mark) @b(Number Lines [PF-4]). Number the current buffer with line numbers. This is a permanent change to the buffer if the @i[un-number] command is not used.@index(Number_Lines) @b(Extend TPU [KP-7]). Extend the current session with the changes made to the EVE image.@index(Extend) @b(List Commands [KP-8]). List the EVE commands available to the user. It will sort the list before displaying them. Pressing the @i[Do] key unmaps the commands from the screen.@index(List_commands) @b(Spawn_DCL [KP-9]). Prompts for a DCL command and spawns with it. @i[Warning]-- do not give a command which creates a loop like output activity (e.g. Monitor). When the process is created the terminal is disconnected from the editor session until the subprocess terminates. Thus if the subprocess never terminates the terminal is never reconnected to the editing session. You must use the straight @i[Spawn] command described in the white keymap for non-self terminating subprocesses. @index(Spawn_DCL) @b(Close Journal [KP-Minus]). Close the current EVE-journaling file. After closure the journal or recovery file is no longer updated for the editing session. This command in conjuncture with the @i[Open Journal] command is useful when the user wishes to have several journal files for a long edit session.@index(Close_Journal) @b(Shrink_Window [KP-4]). Shrink the current window by one line. @index(Shrink_window) @b(Grow_Window [KP-5]). Grow the current window by one line. @index(Grow_window) @b(Cut Rectangle [KP-6]). Excise the rectangular section of text previously selected into the @i[insert here] buffer. Blanks are used to fill in the section removed in the buffer. A rewrite of this code was done for Version 2.0. It was optimized for finding and replacing tabs in lines. Therefore the more tabs a line contains the faster it will execute, relative to Version 1.0.@index(Cut_Rectangle) @b(Translate Non-Printable Ascii Characters [KP-Comma]). Translate @index(Translate_ASCII)all non-printable ascii characters in the current buffer. The translated buffer is mapped to a second buffer. This command can be used to see which non-printable characters are present. This translated buffer can be written out to a file and printed.@index(Translate_buffer) @b(Substitute [KP-1]). Substitute new string for old string. Prompts for both strings. If an occurrence is found it will prompt @i[Replace? Type yes, no, all, last, quit]. @i[All] will replace all strings in the buffer, while @i[quit] will abort the substitution. A is the same as answering @I[yes]. For either a or @i[yes], the substitution is made and the next old string is found in the file. EVE will then ask if you wish to substitute for this string, and so forth until all of the old strings have been found. If the old string is not found in the current direction, EVE will look in the reverse direction. If it is found in the reverse of the current direction you will be asked if you wish to go to that occurrence in the buffer.@index(Substitute) @begin(multiple) @b(Get File [KP-2]). Prompts and retrieves a file into the current window. The current buffer is unmapped from the window and a new buffer is created and mapped to the window. The new buffer will have the same name as the filename. @index(Get_file) If you position your cursor over a filename specification in a buffer, and press @i[select] in response to the prompt for filename, Get_file will attempt to retrieve that filename into the current buffer. If the cursor is on a whitespace character (tab, blank, etc), then the next filename to the right of the cursor is selected. If a device, and directory is missing from the filename the cursor is on, a backward search is performed in an attempt to find one. If a device-directory specification is found it is concatinated onto the filename to yield the complete file specification. This is especially applicable after the user has given a @i[DCL-directory] command. @index(Interactive_get_file) You can also set default to a different directory from the one you were in when you entered the editor. Position the cursor over a device-directory specification. The actual filename must be missing. For example:@index(Set_default) @i(rtp$user55:[userdir.subdir]) would set default to the appropriate directory. An invalid choice would be: @i(rtp$user55:[userdir.subdir]userstuff.txt) Since a filename is present, a retrieval of that file would be attempted. We intend in the @i[future] to allow filenames in the string, and also be able to set default to strings of the format: @i[subdir.dir] where subdir is a given directory filename in the current directory. Also a user may delete a file @index(Delete_file) from within the editor using the Get_file function. Position the cursor over a filename (i.e. in all of the Get_file functions the cursor can be located anywhere on the filename), and in response to the file prompt, instead of pressing select, press @i[remove], or on a VT100 terminal @i[KP-6].@index[Delete_file] As a safeguard you will then be prompted, "Do you really want to delete this file ?". Thus if you ever get into a situation within the editor, where your account is out of diskquota, this function would allow you to recover needed space. @end(multiple) @b(Split Screen [KP-3]). Split the current window into two windows.@index(Split_screen) @b(Trim Line [KP-0]). @index(Trim_Line) Trim the current line. Get rid of all trailing @i[whitespaces] (i.e. blanks, tabs, etc). After trimming a line, the cursor is placed at the end of the line. @b(Select Rectangle [KP-Period]). Select a rectangular cut. After pressing this key, move the cursor horizontally with the (->) arrow key. After reaching some column N, then move the cursor in the current direction usually vertically downward to row M. Upon pressing the rectangular cut key (RED KP-6), you will have deleted a rectangle with the area of NM. For example to delete one column in a table: Press RED KP-Period, move horizontal 1, and down to the bottom of the file. Press RED KP-6 and the column is removed.@index(Select_rectangle) @b(Merge Buffer [KP-Enter]). Prompts for a buffer. If the buffer does not exist it will attempt to find a file by that name in the current default directory. If either is found it is merged or included before the current cursor position in the current buffer. If @i[] is entered and a select range is active, then the first select range found in the internal buffer list is merged into the current buffer, else no action is taken. Note: if you are in overstrike mode the text being placed in the buffer will overwrite previous text.@index(Merge_buffer) @end(itemize) @section(Blue Keymap) @begin(itemize) @b(Blue Help [PF2]). Display the keypad diagram for the Blue Keymap. @b(Goto Mark [PF-3]). Goto the place marker indicated in the current buffer.@index(Goto_mark) @b(Un-number Lines [PF-4]). Strips off line numbers previously placed in the buffer by @i[Number lines] (RED PF-4). @i[Warning]: If you un-number a buffer which is not numbered, and the buffer contains numeric text, unpredictable results may occur, and the numeric text will be lost.@index(Un_number_lines) @b(Save TPU [KP-7]). Save the extended EVE session in a global section file. It will prompt for the name of the file to be created. Standard convention is to create the file with the extension of @i[.gbl].@index(Save) @b(List Buffers [KP-8]). List all available buffers for the current EVE @index(List_buffers) session. The @i(select) key is temporary bound to @i[select buffer],@index(Select_buffer) and the @i(remove) or @i(cut KP-6) key is temporary bound to @i[destroy buffer]. @index(Destroy_buffer)This allows one to select or destroy buffers by positioning the cursor to the beginning of the buffer name and striking either the @i[select] or @i[remove] key. Example: position the cursor at a buffer name, press the VT200 select, and that buffer is mapped to the window. After exiting the list_buffers buffer, the original definitions for the @i(select), and @i(remove) key will be restored. @b(Set Journal [KP-9]). EVE will request a number in the range of 1-10. By default the journal file has a value of approx. 10 which causes a record to be written to the journal buffer every 125-400 keystrokes. A value of 1 causes a record to be written every 10-35 keystrokes. These values are approx. and can differ depending on the type of editing being performed. The lower the value the safer you become in restoring more of your EVE session in case of catastrophic events, but it will also slow down your turnaround time inside EVE due to the I/O.@index(Set_journal) @b(Open Journal [KP-Minus]). Open a new journal file. If one is already open EVE will give an error message. It will prompt for a journal file name, with the default name given @i[tpu.tjl]. @index(Open_journal) @b(Left Margin [KP-4]). Set left margin in buffer at the current cursor position.@index(Left_margin) @b(Right Margin [KP-5]). Set right margin in buffer at the current cursor position.@index(Right_margin) @b(Paste Rectangle [KP-6]). Paste the rectangular area previously selected and cut to the current cursor position. Any text present at this location is destroyed after the paste.@index(Paste_rectangle) @b(Display Ascii [KP-Comma]). Display the ascii value for the current character in the buffer (e.g. the character the cursor is positioned on). By default EVE displays all non-printable ascii characters as an upside down inverted question mark for VT200 terminals and a checkered square for VT100 terminals.@index(Display_ascii) @b(Draw Box [KP-1]). Draw an outline for a box in the area selected. Example: press the rectangular select key (RED KP-Period), move the cursor over and down to create a select area. Upon pressing KP-1 a box appears outlining the area selected.@index(Draw_box) @b(Center Line [KP-2]). Center the current line in the buffer. @index(Center_line) @b(Set Screen Width [KP-8]). Set screen width will prompt for a screen width number. The number entered must be in the range 1-132. If a number outside this range is entered, the function returns an error message. If a instead of a number is entered the screen will toggle between 80-132 depending on the current screen width. If the current screen width is 80 a will toggle the screen to 132. Any other current screen width toggles the screen to 80. Although the screen width may change the current window(s) will not change. Therefore if the screen width is changed from 80 to 40 the last 40 columns of the current window will not be displayed. This command is most useful in changing the screen width to view compiler listing files (132).@index(Set_screen_width) @b(Trim Buffer [KP-0]). Remove trailing whitespaces through out the current buffer.@index(Trim_buffer) @b(Specins [KP-Period]). Prompts for Decimal Ascii value in the DEC Multinational character set to be entered into the text.@index(Specins) @b(Destroy Buffer [KP-Enter]). This command will prompt and destroy the buffer indicated. Memory inside EVE is freed for other use. Once a buffer is destroyed it can not be restored.@index(Destroy_buffer) @end(itemize) @section(Main Keyboard Keys)@index(Main_Keyboard) EVE defines several main keyboard keys so as to allow line edit mode emulation. The following is a list of the keys defined. It is recommended that the user read page 4.84-4.89 in the TPU manual before defining keys. It is also recommended for key definition convention that all user defined keys be explicitly placed in the keymap @i[eve$user_keys]. @begin(itemize) @b(Control-A). Quit current EVE session.@index(Quit) @b(Control-B). Recall last TPU/EVE command.@index(Recall) @b(Control-E). Position cursor to EOLN.@index(EOLN) @b(Control-F). Forward/Reverse.@index(Change_direction) @b(Control-H). Position cursor to beginning of line.@index(BOLN) @b(Control-M). Return. @b(Control-R). Remember the key sequence just @i[learned].@index(Remember) @b(Control-@@). Toggle tab between movement and insert mode.@index(Tab_toggle) The default mode is insert. Each time the tab key is pressed, a tab is inserted into the text. Toggling into movement mode allows one to use the tab key to move to the next tab in the text, much like a standard type writer. @b(Control-%). Toggle find or search mode from normal (default) to wildcard. See discussion above on the find function keypad key.@index(Wildcard_toggle) @b(Control-V). Change mode between insert and overstrike.@index(Insert_mode) @index(Overstrike_mode) @b(Control-W). Refresh screen.@index(Refresh_screen) @b(Control-X). Erase from cursor to beginning of line.@index(Erase_to_BOLN) @b(Control-Z). Exit and save EVE edit for current buffer.@index(Exit) @b(Control-shift-?). Lock or Unlock the current keymap. See PF-1 key above. @index(Lock_keymap) @b(DO-up_arrow). Toggle back through command buffer.@index(Command_buffer) @b(DO-down_arrow). Toggle forward through command buffer. @end(itemize) @section(VT200 Auxiliary-Keypad Keys) These keys are located on VT200 terminals between the main keyboard keys and the main keypad keys. They are labeled: @i(find), @i(select), @i(Prev Screen), etc. Their functions are as they are labeled, except under the special conditions of the @i(Get_file) and @i[list buffers] commands as discussed above. @section(VT200 Function Keys) Various function keys on the keyboard have been defined which gives the VT200 user convenient usage of some common functions, and also additional functions not available on the keypad. @begin(itemize) @b(Control-Y [F6]). Interrupts edit session. @b(Spawn [F8]). Spawn to DCL level. @b(Spawn/Mail [F8-Yellow_map]). Spawn into mail. @b(Spawn/DCL [F8-Red_map]). Spawn with a DCL command. @b(LSE [F9-White_map]). Invoke LSE from within EVE. The current buffer is written out. The process is spawned and LSE is invoked using the buffer name as the filename. Upon exiting from LSE a new copy of the buffer is brought into EVE. @b(Spell [F9-Yellow_map]). Invoke the Vasar speller correction program on the current buffer.@index(Spell) @b(Describe Key [F10]). Describe a key, return the keys' comment field.@index(Describe_key) @b(Change Direction [F11]). Change direction of edit forward/reverse.@index(Change_direction) @b(Move by Line [F12]). Move line by line.@index(Move_by_line) @b(Erase Previous Word [F13]). Delete the previous word before the cursor.@index(Erase_previous_word) @b(Change Modes [F14]). Toggle between insert and overstrike.@index(Insert) @index(Overstrike) @b(Copy_buffer [F17-White_map]). Copy buffer A to buffer B.@index(Copy_buffer) @b(Erase_current_buffer [F17-Yellow_map]). Erase the current buffer. Contents of current buffer are destroyed.@index(Erase_current_buffer) @b(Next_buffer [F17-Red_map]). Goto the next buffer in the buffer list. @index(Next_buffer) @b(Move_Columns [F18-White_map]). Switch or move two columns in a buffer. @index(Move_columns) @b(Rectangular-Pad [F18-Yellow_map]). Pad or place blanks before a given column in a file, causing it to shift to the right.@index(Rectangular_pad) @b(Print_screen [F18-Red_map]). Print the current contents of the screen to a line printer.@index(Print_screen) @b(Ruler [F19-White_map]). Place a ruler at the top of the current buffer. If a ruler is already present then it's removed.@index(Ruler) @b(Remove_window [F19-Yellow_map]). Remove or unmap the current window from the screen.@index(Remove_window) @b(Two Windows [F20]). See two_windows [KP-3 Yellow_map].@index(Two_windows) @end(itemize) @chapter(EVE Auxiliary Commands) @label(New Commands) @blankspace[0.2inch] @b(EVE_function_name. [filename function is located in]) @blankspace[0.5inch] @b(EVE_append_buffer). [APPEND.TPU] Append a select range (if present) or buffer to another buffer. If a select range is not active it is assumed another buffer is to be appended and is prompted for. If the buffer to append doesn't exist then an error is returned. If the buffer to be appended to doesn't exist then it's created. This function uses the help function EVE_exist_buffer which requires 3 args: loop_buffer (a buffer variable), found_buffer (integer), and this_file (a string specifying the filename). Returns a "1" in found_buffer if the buffer exists, else a "0" is returned.@index(Append_buffer) @b(EVE_copy_buffer). [COPYBUFF.TPU] Copies one buffer to another. Prompts for the two buffer names, and then calls the help function eve$copy_buffer (oldbuff,newbuff), where both args are strings. If the origin buffer doesn't exist then an error is returned. If the destination buffer exists it is erased and the origin buffer is copied to it. If it doesn't exist then it is created before the copy.@index(Copy_buffer) @b(EVE_lse). [LSE.TPU] Hook function into LSE. Spawns into LSE with the current buffer (file) name. Both ends (EVE and LSE) write out the file so as to ensure the corrected version is being used.@index(LSE) @b(EVE_move_column.) [MOVECOLUMN.TPU] Prompts for two column numbers M and N. It then switches columns M and N in the file. It will handle irregular alignment on the right hand side of columns. If the left hand side is irregular data sticking out from the starting column (of the column) is truncated or lost. Example. If the first item in a column is 5 chars, and the next is 15 and the next is 8 then for the 3 lines length would be: 5 chars, 5th-15th char (or 10 chars) , 5th-8th char (3 chars). Help functions in this file include : eve_traverse_column, eve_skip_column, eve_skip_white_space, eve$find_column.@index(Move_column) @b(EVE_next_buffer). [NEXTBUFFER.TPU] Find the next buffer in the internal buffer list and map it to the current window. This function does not differentiate between user and system buffers.@index(Next_buffer) @b(EVE_pscreen). [PRINTSCREEN.TPU] Print the current screen to a line printer. It selects and copies the screen lines to printscreen.scr. If this buffer doesn't exist then it's created. The function then calls eve_print_buffer. @index(Print_screen) @b(EVE_rectangular_pad). [RECPAD.TPU] Insert Y blanks before a column for X lines. Activate the rectangular select function. Move the cursor Y spaces to the right and X lines down creating the typical area. EVE_rectangular_pad will compute the number of blanks to be inserted is equal to the end_column- start_column. This many blanks will be inserted before the start position. @index(Rectangular_pad) @b(EVE_ruler). [RULER.TPU] Places a column ruler at the top of the current window. If the ruler is already present, then it's removed. The ruler length will adjust so that it corresponds to the current screen width.@index(Ruler) @b(EVE_searchctrl). [SEARCHCTRL.TPU] Prompts for a decimal ascii value, and finds that ascii character in the file. This enables one to search for ctrl- characters.@index(Search_ctrl) @b(EVE_sort_by_col). [EVE_RECTANGULAR.TPU] Sorts a given column by alfa- numeric key.@index(Sort_by_column) @chapter[Kept Editor] In EVEplus Version 2.0, we now support the concept of a @i[kept editor]. @index(Kept_editor)A @i[kept editor] is a process devoted to the task of editing. One may attach to this process to edit, and then detach from it and reattach to your main process in order to perform other tasks. The advantage of a kept edit session is that each time you need to use the editor, you do not need to wait for EVEplus to startup or create its' environment. The response time to attach to and from the editor is instantaneous. The disadvantage is that it does use up a process slot on the system, and does create some overhead for the VMS operating system. It is recommended that you consider using the kept edit feature if you have a need to enter and exit the editor many times in a given work period. In order to setup the kept editor you will need to bind a key to the function @i[rlb_return_to_main], in your TPU$COMMAND file.@index[TPU$COMMAND] An example of such a comfile would be: procedure tpu_local_init @index(tpu_local_init) define_key("rlb_return_to_main;eve_toggle_white_map",ctrl_g_key, "Return to main","white_map"); !define a key endprocedure; tpu_local_init; !invoke the procedure The above define_key binds the function rtp_return_to_main, to the Ctrl-g-key in the white map. The function eve_toggle_white_map is the function which will reset the map to the white_map whenever the function completes. As discussed previously in the section for extending EVEplus, you would define the logical TPU$COMMAND to point to this file. This takes care of attaching to the main process, now one needs to define a key at DCL level to attach to the @i[Kept_editor] process. This is accomplished by defining the key to point to the comfile utl:kept_edit.com. Thus in order to point to this comfile and setup the logical for TPU$COMMAND, place the following lines in your login.com file: $ define/job TPU$COMMAND my_device:[my_directory]myini_file.tpu $ ! where my_device, my_directory are your device and directory and $ ! myini_file is again the filename to equate TPU$COMMAND with. $ define/key/if_state=default/erase f17 "@@utl:kept_edit"/terminate/noecho Note at our site kept_edit.com is located in the device-directory pointed to by @i[utl]. If you are at another site, then ask your contact on the EVEplus editor where this comfile may be found. After performing the steps listed above re-execute your login.com file: $@@login You can now spawn a kept editor by pressing the F17 key. This will place you in an EVEplus editing session. Upon starting your editing session, you should see a message flash by that the buffer $local_ini @index(local_ini) is being executed. If not then the logical TPU$COMMAND has not been defined correctly. After the editing session has started, you may leave it by pressing the Ctrl-g-key. This will attach you back to your main process. Upon pressing F17 (it's not nice to strike or hit poor little keys) again, you are attached back to the prior Kept_edit session. If you wish to terminate your Kept_editor, then instead of pressing Ctrl-g, exit from the editor as you normally would with Ctrl-z, or Ctrl-a. @chapter[EVE CALL_USER Interface] EVE provides a mechanism to call an executable file to perform a function. The logical TPU$CALLUSER must be defined to point to the executable file. The executable can be written or based on any high level language. @index(TPU$CALLUSER) Our calluser code is presently written in Pascal, and at present has the capability to: get a symbol value, translate a logical name, obtain various items with a getjpi @index(Getjpi)call (i.e. If you are unfamiliar with the term getjpi try giving the command $help lex getjpi item, at DCL level to get a flavor of what this system call can return), set default to another directory, and delete a file. Those users wishing to write their own TPU code and needing a function of our calluser code, may access it with the following tpu statement: @i[result := call_user(casecode,input_string);] The current valid casecodes @index(Calluser_casecodes)are : @itemize( RTP$CALLUSER_GET_SYMBOL, RTP$CALLUSER_TRNLNM, RTP$CALLUSER_GETJPI, RTP$CALLUSER_SET_DEFAULT, RTP$CALLUSER_DELETE_FILE.) Note the casecodes in the TPU code are uppercase by convention. The current valid input_string values are dependent on the casecode. For get_symbol @index(Get_symbol)or trnlnm @index(Trnlnm), the input_string is the symbol or logical name whose value you wish to obtain. For set_default @index(Set_default)it is the directory spec., you wish to set default to, and for delete_file it's the file spec. you wish to delete. The getjpi casecode may have the following associated values for its' input string: @begin(itemize,columns 2,boxed,columnbalance) IMAGNAME, MASTER_PID, MODE, OWNER, PID, PRCCNT, PROC_INDEX, STATE, TERMINAL, USERNAME. @end(itemize) Please note these values must be enclosed in quotes since they are meant to be strings, and also they must be in uppercase. An example call to call_user which would return the username for the current process is: @i[loc$username := call_user(rtp$calluser_getjpi,"USERNAME");] In the future as the need arises we will add to the calluser code other functions. @NewPage() @Appendix[VT200 Function Keys] @label [VT200 Function Keys] @index(VT200_Keys) @StandardTable(Name function1,columns 5, TopHeading FlushLeft, ColumnHeadings FlushLeft, FlushTop, Boxed) @Begin(function1) @TableID(function1) @TableHeading(Immediate, RowFormat function1ColumnHeadings, Line 'F6@\F7@\F8@\F9@\F10') Control-Y (White Map)@\Blank Key (White Map)@\Spawn (White Map)@\LSE (White Map)@\Describe Key (White Map) Control-Y (Yellow Map)@\Blank Key (Yellow Map)@\Spawn-Mail (Yellow Map)@\Spell (Yellow Map)@\Describe Key (Yellow Map) Control-Y (Red Map)@\Blank Key (Red Map)@\Spawn-DCL (Red Map)@\Fix-crlfs (Red Map)@\Describe Key (Red Map) @end(function1) @blankspace(0.75 inches) @StandardTable(Name function2,columns 4, TopHeading FlushLeft, ColumnHeadings FlushLeft, FlushTop, Boxed) @Begin(function2) @TableID(function2) @TableHeading(Immediate, RowFormat function2ColumnHeadings, Line 'F11@\F12@\F13@\F14') Change Directions (White Map)@\Move By Line (White Map)@\Erase Previous Word (White Map)@\Change Mode (White Map) @end(function2) @blankspace(0.75 inches) @StandardTable(Name function3,columns 4, TopHeading FlushLeft, ColumnHeadings FlushLeft, FlushTop, Boxed) @Begin(function3) @TableID(function3) @TableHeading(Immediate, RowFormat function3ColumnHeadings, Line 'F17@\F18@\F19@\F20') Copy Buffer (White Map)@\Move Column (White Map)@\Unmap Window (White Map)@\Two Windows (White Map) Erase Buffer (Yellow Map)@\Rectangular Pad (Yellow Map)@\Blank Key (Yellow Map)@\Two Windows (Yellow Map) Next Buffer (Red Map)@\Print Screen (Red Map)@\Blank Key (Red Map)@\Two Windows (Red Map) @end(function3) @NewPage() @Appendix[EVE Keypad Diagram] @label [EVE Keypad Diagram] @index(Keypad_diagram)