Thompson Toolkit

Professional Quality Tools for Programmers

by Thompson Automation Software

The Thompson Toolkit includes over 100 general purpose programmer's utility programs, as well as a UNIX compatible Shell (command processor) that gives you simultaneous use of high-level programming features and access to all native (DOS, OS/2, Windows, Windows/NT or Windows/95) commands. The Thompson Toolkit is used both by PC programmers wanting to upgrade to the more powerful UNIX-type capabilities, and by UNIX programmers forced to program in the PC environment.

The Toolkit Shell is a command processor that combines the best features of both UNIX and PC-based operating systems. You can use this instead of, or in conjunction with, the native command interpreter. The superior command editing features alone will start you using the Shell, and you will soon realize the ability to write Shell Scripts to automate repetitive tasks is invaluable.

Benefits For PC Users

More powerful commands than are provided with PC operating systems for moving, copying, searching, sorting, comparing, cutting and pasting ASCII files. Very high speed search utilities.
Bypass the limits on command line length, PATH length, and environment size.
User defined functions and shell scripts let you create your own commands.
The best command line recall and editing available anywhere.
Unlike other "UNIX" systems, does not interfere with your ability to run native commands.

Benefits for UNIX Users

Use familiar UNIX commands like ls, pwd, grep, sort and diff.
Full Korn-Shell compatibility for script portability.
All UNIX command line features supported: UNIX style filename patterns, I/O redirection, quoting, command history and more.
Network ready: individual "login" accounts for each network user.
Ease the pain of switching between UNIX and PC-based systems; use either / or \ interchangeably as the directory separator in all commands.

Why is the Thompson Toolkit Better?

Supports two types of shell scripts: Both UNIX (Korn Shell) compatible and a more DOS-friendly script syntax that provides better support for DOS commands.
Shell and Commands are large model programs to handle large shell scripts, command lines, and files.
Extensive configurability: Customize command line processing for special needs or for your personal preferences.
Runs all native commands (even internal ones like dir) without modifying command.com.
Pop-up window display of previous command history for easiest command selection.
Instant pop-up help for both Toolkit and native commands.
DOS version of shell uses just 3K bytes when running other commands. (Uses EMS/XMS memory.)
Really easy installation. No kidding.

What are Shell Scripts?

Toolkit shell scripts are like turbo-charged batch files. Use them to create new commands to automate and simplify your work. Features not found in batch files include powerful loops and case statements, user defined functions, formatted output, ability to get responses from the user, arithmetic evaluation, string operations and tests for files and directories. All these features allow commonly repeated tasks to be quickly and easily automated. Many of our industrial customers use the Thompson Toolkit for specific embedded applications where it is imperative to automate a process, and shell scripts are the best and quickest method available.

Here are a few simple example shell scripts. Just try to do some of the following tasks using DOS!

Find all files on disk modified in the last 3 days.
```
        find  /  -mtime  -3  -print
```
Search for pattern in all *.c files in any sub-directories
```
        grep  pattern   */*.c
```
Move all files from drive C: to drive D:
```
        mv -r  c:/*   d:/
```
Sort filename (any size file) on column 5 in reverse.
```
        sort  +5  -r  filename
```

Integer arithmetic can be combined with any command. This example prints 100 random numbers.

        integer i=0
        while  [  i  -lt  100  ];  do
                echo $RANDOM
                i = i + 1
        done

And What is a "Korn-Shell"?

The Thompson Toolkit Shell is fully compatible with the "Korn Shell" which is the latest UNIX shell. The name is derived from the original author: D. G. Korn. The Korn-Shell is backward compatible with the original UNIX "Bourne Shell" but with extensive additions. The "C Shell" is another older UNIX shell with a different syntax. The Thompson Toolkit Shell supports many user interface features of the "C" shell (directory stack, command history, etc.) but will not run "C" shell scripts.

Typical Shell Script Applications

Automated Product Testing:
A shell script runs your program with a specified input sequence and captures the resulting output, which is compared to expected output using diff and cmp.
Building Program Release Disks:
Shell scripts contain a list of the needed files and their paths, and build the disks.
Automated Program Maintenance:
Shell scripts execute "make" or version control check-in or check-out on lists of files and check for errors.
Wrappers around other Programs:
When it is essential that the environment be set correctly for a specified program.

Command Entry Features

Users love our command editor, and many sites have standardized on the Toolkit for this reason alone. Command recall and editing of typed commands uses a popup window or keypad keys. Command and filename completion: type part of a command and press key to complete. Filename expansion preview: match filename patterns (like *.c) before you execute the command, then you can edit the list of filenames. Maximum command line length is over 30,000 bytes. Command history is saved and restored between sessions.

Commands Included

External commands include: apply, awktags, basename, cat, chmod, cksum, cmp, col, comm, cp, ctags, cut, date, df, diff, diff3, dirname, dos2unix, du, egrep, ex, expr, fgrep, find, grep, hd, head, ls, mf, mkdir, mkuser, more, mv, nawk, paste, pathext, pr, printenv, ps(win32 only), pwd, restrict, rm, rmdir, rs, sed, sh, sleep, sort, split, strings, sum, tail, tee, test, touch, tr, uniq, unix2dos, uudecode, uuencode, vi, view, wc, whereis.

In addition, the sh, which is an implementation of ksh with csh extensions, includes a number of internal commands as follows: ((, [, [[, alias, break, cd, chdir, continue, dirs, echo, eval, exec, exit, export, false, fc, fixbs, freemenus, fullpath, getopts, history, jobs(win32 or os2 version), kill(win32 or os2 versions), let, man, newwindow(win32 or os2 version), nice(win32 or os2 version), noconsole(win32 or os2 version), pathof, popd, pushd, read, readonly, return, rotd, set, setenv, shift, source, timex, trap, true, typeset, unalias, unexport, unset, unsetenv, wait(win32 or os2 version), whence, which, xxfhandles, xxversion.

System Requirements

Version for Microsoft Windows: Requires any modern version of Microsoft Windows (Windows XP, Windows ME, Windows 2000, Windows NT, Windows 98 or Windows 95. The ancient Windows version 3 or older is not supported.) All programs are full 32-bit executables and support long filenames on both FAT and NTFS disk partitions.
Version for DOS: Requires DOS version 3.3 or higher with 256K free memory (recommended), or Microsoft Windows version 3.1. The Toolkit Shell uses as little as 3K when executing other commands. The keybuf, keypush, reboot and cu programs require interrupt-level IBM compatibility. (Almost all computers are interrupt-level compatible now.)

Return to Thompson Automation Software Home Page