Programmer 7500/MAX_PROGRAMMERS.iso/EDITORES/VEDT.ZIP/DEMO2.TXT

Text File | 1990-10-07 | 10.8 KB | 227 lines

FEATURES COMMON TO ALL VEDIT FAMILY EDITORS ---

*   Edit ANY file of ANY size - automatic (virtual) file buffering handles
    files larger than what will fit into memory.  Edit binary, i.e. database
    files.  Even insert (paste) a 1 Megabyte file in the middle of another
    huge file.  VEDIT is the only editor that lets you edit really large files
    of up to 8000 characters/line and up to 8,000,000 lines in length.

*   Pull-down menu system.  A modern user interface allows easy access to most
    editing functions.  Editing functions can also be quickly accessed with
    single keystrokes ("hot keys") which bypass the menu system - the menus do
    not slow down proficient users.

*   Context sensitive help.  Pressing the Help key gives you precisely the
    information you need at the moment.  The help text is user changeable and
    expandable.  Add your own help prompts and messages, even create on-line
    help for other programs you use.

*   Integrated mouse support.  You can quickly navigate and select from the
    menu system, access help, scroll to other parts of the file, highlight,
    copy/move blocks and switch between windows with a mouse.

*   "Point and shoot" file selection.  Use the cursor keys or mouse to
    highlight the desired files.  Easily change drive, directory and the file
    selection "filter".

*   Unlimited keystroke macros.  Any combination of keystrokes can be assigned
    to a single key.  Allows single key access to menu functions and creation
    of custom editing functions.  Record mode learns new keystroke macros
    while you edit.  Keystroke macros may be built into VEDIT, saved to/loaded
    from disk.

*   Multi-level Undo.  Up to 1000 of the most recent edit changes can be
    reversed keystroke by keystroke or line by line.  Deleted text can be
    re-inserted in its original position or anywhere else.

*   Flexible block operations.  Process blocks of text on a character, line,
    file, or column basis.  Blocks may be moved or copied directly or saved
    in a scratchpad buffer.  Search/replace within blocks.  Converts letters
    to upper case, lower case or switch case.

*   Automatic indenting simplifies editing of structured programs; block
    indent/undent permits quick restructuring.  Check for proper nesting of
    parentheses, e.g.~"{" and "}", aids C programming.

*   Execute single DOS commands (DIR, compilers, V-SPELL, etc.) or enter DOS
    and return later.  With V-SWAP loaded, you can have more memory available
    when you enter DOS from within VEDIT than before to ran VEDIT!

*   Powerful search and replace.  Supports sophisticated pattern matching,
    reverse searching, selective and global replace.  Recall and editing of
    search/replace strings and most other prompts.

*   Flexible printing with variable margins and page size.  Print a block of
    text or the entire file with single, double or triple spacing.

*   ASCII table.  Pop up the ASCII table or insert any desired control,
    printer or graphic character into the text.  IBM PC box drawing characters
    are easily accessed.

*   Horizontal scrolling for editing long lines - spreadsheets, program
    listings.  Optionally, long lines can be wrapped onto multiple screen
    lines so that you can see the entire line at once.

*   Fully adjustable tab positions.  The <Tab> key can enter a tab character
    or, optionally, spaces to the next tab position.

*   Word processing.  Word wrap, paragraph formatting between adjustable
    margins, optional justification, printing.  (Does NOT enter any "special"
    control character into the text.)  Can read/write WordStar compatible
    files.

*   Word Processor emulation.  VEDIT can closely emulate other editors and
    word processors.  Contains options for emulating common cursor positioning
    modes, other block operations, various styles of searching, functions
    performed by the <Tab> and <Enter> keys, and much more.

*   V-SPELL, an exceptionally fast and flexible spelling corrector is
    available and can be run with a single keystroke.  A fully functional
    demo disk of V-SPELL is also available.

*   Speed.  Completely written in assembly language the VEDIT Family editors
    offer stunning speed.  (3 to 30 times faster than the competition on
    large files where speed really counts.)

*   Small size.  VEDIT Jr. is only 50K in size and VEDIT and VEDIT PLUS are
    only 70K.  There are no overlays - VEDIT.EXE is all you need.  (The
    on-line help files are optional.)

*   Totally configurable.  The keyboard layout is completely configurable -
    assign any key to any function.  Any desired number of keystroke macros
    can be built in.  Default settings of all switches and parameters, screen
    colors can be configured.  Optional tab-fill and line-ending characters.
    Selectable hardware/software cursor, cursor blink rate (or no blink) and
    much more.

*   Easy installation.  The automated installation takes only a few minutes.
    It places VEDIT, its help file(s) and macro files into a selected
    directory, e.g. "C:\VEDIT".

    You can also copy VEDIT.EXE to a floppy disk and immediately run it on
    another computer - no directories to create, no environmental variables
    to fiddle with.

*   The VEDIT Family editors are available for the PCDOS/MSDOS, XENIX/UNIX,
    FlexOS, and IBM 4680 operating systems.  Support for OS/2 and QNX is
    planned.

VEDIT has these additional features:

*   Multiple file editing.  Simultaneously edit two, three, four or more files
    (up to 37), each of unlimited size.  Blocks of text can easily be copied
    from one file to another.

*   Flexible windowing.  Display each file you are editing in its own variable
    sized window or toggle between files using just one window.  Set the color
    for each window.  Different parts of one file can be displayed in separate
    windows.  Windows can be zoomed to full screen and de-zoomed.

*   Regular expressions for even more powerful search and replace operations.

*   36 text registers may be used as scratch-pad buffers for extensive "cut
    and paste" operations.

*   All "macros" written in the VEDIT PLUS programming language can be run
    by VEDIT.  This includes the supplied Compiler Support, a simple print
    formatter, split-screen file comparison macro, sort macro and a "grep-
    like" multiple file processing macro.

*   Integrated, menu-driven Compiler Support.  Popular compilers, assemblers,
    linkers, debuggers and Make programs can be run from within VEDIT.  If any
    compilations errors are reported, it automatically loads the correct
    source file and positions the cursor on the error.  You can then make
    corrections and press a key to move to the next error, or recompile.

*   The Compiler Support automatically adjusts to the needs of different
    programs in different directories, e.g. one program may be compiled as
    "large model" while another is compiled as "small model".  Compiler and
    other options can also be changed easily via menus.  Includes on-line help
    for compiler options.

*   The Compiler Support works with Make programs and "makefiles" to further
    automate program development.  It even tracks compilation errors reported
    by different compilers run within one Make script.  Requires no changes
    to your existing "makefiles".

*   The following Make programs are supported:

    Microsoft NMAKE

    Borland MAKE

    Avocet MAKE

    Other UNIX style Make programs will also work with the Compile Support

*   VEDIT and VEDIT PLUS support these compilers:

    Microsoft - C, Quick C, Quick Basic, Fortran, Cobol, MASM Assembler
    Borland - Turbo C, Turbo Assembler, Turbo Pascal,
    Avocet - All Compilers, Assemblers and Cross-compilers
    Lahey - Fortran 77, Personal Fortran 77
    Metaware - High C
    Micro Focus - Cobol
    Microrim - Rbase Compiler
    Nantucket - Clipper Compiler
    Phoenix - PASM Assembler
    Realia - Cobol
    Zortech - C++

    Users can add support for other compilers themselves.  We will add
    support for almost any requested compiler.

VEDIT PLUS adds a powerful, interactive macro programming language.

*   Macro language is accessed via "Command Mode" - just a keystroke away.
    Any command line entered is immediately executed - there is no tedious
    compiling.  Permits creating and running macros "off the cuff".

*   Commands can be combined to create powerful "macros" which save time by
    automating complex editing operations.  Macros can be saved to disk and
    loaded from disk.  Macros can be assigned to function keys or can be
    loaded into any of the 36 "text registers"; macros can then be revised
    and/or run directly from the text register.

*   Source level debugging.  Complex macros can be debugged by setting
    breakpoints and tracing.  By running the Command Mode in its own window
    the effect of each command (typed in or traced) can be observed on the
    file(s) in the remaining window(s).

*   On-line calculator.  Any algebraic expression entered on the command line
    is immediately calculated and displayed.

*   Complete numerical capability with 24 bit resolution (+/- 8,388,607).
    100 "variables", expression evaluation with numerical, logical and
    relational functions.

*   Auto-execution.  A file containing "macro" commands can be specified for
    automatic execution when VEDIT PLUS is invoked.

*   Program flow control with looping, "REPEAT UNTIL", "IF THEN", "IF THEN
    ELSE", "CASE" and conditional "JUMP".  Numeric, character and string
    testing.

*   36 text registers may hold filenames, search strings, blocks of text or
    entire files.  They can be directly edited.  Single command comparison of
    two files or two text registers.

*   Extensive file handling.  Multiple file editing.  Files can be split and
    merged.  Blocks of text can be copied between files.  Access/log-into any
    drive and sub-directory.  Easy recovery from running out of disk space -
    delete files or insert another disk.

*   Interactive input and output.  Messages and prompts can be displayed on
    the screen.  Input can be in the form of single characters, character
    strings, numbers, or numerical expressions.

*   Screen control (Forms entry).  Address, write and erase the screen (or
    individual windows) - write application programs (macros) with windows,
    menu prompts and forms entry.

*   Flexible window control.  Creating, deleting, size, position and color of
    windows is fully programmable.

*   Hardware access.  Macros can peek/poke memory and I/O ports, access system
    and BIOS functions, even call assembly language programs.