Dec 102017
Allows you to hook into the QRIP/TSR to show RIP graphics.

Full Description of File

RIP.CPP: C++ source code for an interface
to QRIP/TSR. Put complete RIPscrip in
your terminal program! Full documentation
and an example included. Version 1.0,
created July 1994. Public domain.

File RIPCPP10.ZIP from The Programmer’s Corner in
Category Recently Uploaded Files
Allows you to hook into the QRIP/TSR to show RIP graphics.
File Name File Size Zip Size Zip Type
FILES.LST 481 282 deflated
FILE_ID.DIZ 203 160 deflated
KEYS.H 956 310 deflated
ORDER.FRM 1596 552 deflated
QRIPTECH.TXT 44802 12832 deflated
RIP.COM 12818 8434 deflated
RIP.CPP 7913 2464 deflated
RIP.H 8705 2638 deflated
RIP.OBJ 7461 3716 deflated
RIPCPP.DOC 15288 4906 deflated
TPCREAD.ME 199 165 deflated

Download File RIPCPP10.ZIP Here

Contents of the QRIPTECH.TXT file

/* file QRIPTECH.TXT **

/// \\\
<<< QRIP TSR Technical specifications >>>


The QRIP TSR is an interface which can act as an 'overlay' for a terminal
program that needs RIP emulation. 1stReader 2.0 loads it just before
calling a RIP BBS, and then transfers control of its output to QRIP,
creating a seamless appearance of RIP emulation. WWIVRIP uses it
only if it's installed before WWIV is run - but it makes for perfect
local RIP graphics.

Using QRIP for RIP emulation has some definate advantages over using
Telegrafix's RIPscrip libraries. First, QRIP restricts itself to
a small chunk of memory, making your terminal free to act as it always
has in the past. Second, your terminal could be upgraded to new
versions of RIPscrip simply by upgrading your version of QRIP. QRIP
also gives you powerful functions such as the pop-up mode and
text screen switching.

For a better understanding of the way QRIP/TSR operates, take a look
at its operation in 1stReader 2.0 by Sparkware.

Strategy for the API

This is a basic method for making a QRIP-compatible application. I
have described it before the actual spec so that programmers will know
what to look for as they read over the next section.

A QRIP-compatible application should first detect the presence of
QRIP (function F0). If QRIP reports that it can't takeover DOS,
the application should ignore QRIP's presence and possibly report
and error message stating that QRIP is corrupted in some way.

The app should check the flags (returned by the emulation check) and
change them *only as necessary* (function 01). Many applications won't
even need to bother with this.

For each output string, the application should call one of the API
string output routines (functions 04, 05, 09, or 0AH). Then it should
call function 06, to receive any characters pending from QRIP.
If BX returns with a value of 1, the terminal should call function
0CH to receive a whole string.

If you decide to use functions 09 or 0AH to accomplish your purposes,
QRIP will automatically call function 06 before returning, and instead
of using two calls, you only need to do one. Functions 04 and 05, on the
other hand, require constant polling of 06. You should use whichever
one is more convenient, but be aware that each call to QRIP requires
a complete switch-over of DOS control, a process which can take a few

When in 'hotkey' mode, your terminal should send all keystrokes to
QRIP through function 18H. Anything it doesn't accept will be piped
back through to function 06, so it will be sent directly to the BBS.
Hotkey mode is a necessary feature for your terminal.

When connecting to a BBS, the terminal should set the icons directory
with the string pointer returned by function 08. When carrier is lost,
call function 19H so the user can recover control completely.

To do a general reset of QRIP, you can simply turn off graphics and
turn them back on. Note that if you use this method, QRIP has built-in
monitor protection that doesn't allow the screen to change modes faster
than once per second.

Before exiting, your app ought to return the flags to their original,
saved state. Use function 02 to do this.

When you're all done with QRIP, the author recommends you call function
FFh to deinstall, rather than doing a QRIP /u. It's much safer.

All of the functions mentioned above are essential for a QRIP-compatible
terminal. Most of the rest are additional features that aren't
necessary for all applications.


Conventions in the API specs:

For all flags, 1 means 'set', 'true', 'on', or 'yes', and 0 means
'reset', 'false', 'off', or 'no'. Just so we have no discrepancies.

All numbers are in decimal unless they have an 'H' or 'h' at the
end to signify hexadeciaml, or unless they have a hexadecimal digit
in them (A-F).

Interrupt 2F (DOS Multiplex interrupt)
This interrupt is used for interface with DOS TSR's like ASSIGN and PRINT
and some shareware/freeware TSR's. QRIP uses this interrupt for
external control by applications. The AX, BX, CX, and DX registers are
used for all parameters and returns. All registers not used by QRIP
will be restored to their original values before return from the

To access QRIP, call int 2F with:

AH = ACh ; QRIP multiplex interrupt ID number
DI = 1092h ; Secondary verification of a QRIP call

Then load AL with the QRIP function number:

AL = 0: Give QRIP a time slice.

This is used to update the music and flashing timers.
Whenever there's no activity whatsoever, the terminal
might simply call this as often as it wants.
It is usually a short routine. This function is
always called internally through the other functions,
so you usually don't have to bother with this one.

No return.

AL = 1: Change internal flags.

This call uses the BX and CX registers to change bit-coded
flags. Each bit set to a 1 in BX will turn ON a flag, and
each bit set to a 1 in CX will turn OFF a flag. The flags

bit 0 (0001h): ANSI emulation. Defaults on.

bit 1 (0002h): RIP emulation. Defaults on.

bit 2 (0004h): Graphical commands allowed. QRIP turns this
off when the set_viewport RIP command is
called with parameters of zero. Defaults
to on.

bit 3 (0008h): TTY text allowed. This isn't like the text
suppression flag - RIP graphics turn this
flag on and off all the time. Defaults to

bit 4 (0010h): Disable @ variable recognition. QRIP
defaults to disabling when in TSR mode,
but someone out there might have reason
to put the @ variables back in.

bit 5 (0020h): Wait for key at RIP_END_SCENE (|#) commands.
Defaults off.

bit 6 (0040h): Anti-stripping. The /# parameter. Defaults
to off in TSR mode.

bit 7 (0080h): Sound. The /s parm. Defaults on.

bit 8 (0100h): Automatic message filter. The /m parm.
Defaults off in TSR mode. You are warned
that the author has never tried the message
filter while in TSR mode, nor did he expect
that it would ever have much purpose for
the TSR.

bit 9 (0200h): Display-only mode. The /y parameter.
If this flag is off, QRIP will wait
for the local user to answer certain
prompts. If it's on, QRIP will flash
windows on the screen but won't give the
local user time to answer. This is most
useful when QRIP is used as a local
RIP display for BBS programs.

bit 10 (0400h): TTY text suppression. The /x parm.
Defaults off in TSR mode.

bits 11-15: Reserved.

The return is the same as the QRIP installation check
(see AL = F0H). Note that CX will return the new status of
all of the flags.

AL = 2: Turn off graphics screen.

QRIP will turn off the graphics screen by itself unless
the RIP_NO_MORE auto-finish flag is off. The screen will be
restored to its pre-graphics state.

No return.

AL = 3: Turn on graphics screen.

Every time a RIP sequence is encountered, the screen is
switched to graphics mode anyway. This is just provided for
apps that need manual control. It can also be used as
a manual reset: it does precisely the same thing as "!|*"
(which means the graphics are NOT restored - see functions
14H and 15H.)

No return.

AL = 4: Send a string to QRIP.

- - -
All TTY, ANSI, RIP, VT102, etc. enters QRIP through functions
4, 5, 9, or 10. Your terminal will probably only use
one of the four. There are only slight differences
between them.
- - -

DX = segment address of the string
BX = offset of the string
CX = length of string

The string doesn't need to be null-terminated, but CX must
contain the length. If CX is 0, nothing will be output.

No return.

AL = 5: Output a null-terminated string to QRIP.

Same as AL = 4, but the string must be null-terminated and
CX is disregarded.

DX = segment
BX = offset

No return.

AL = 6: Receive characters from QRIP.

QRIP will return any characters that should be sent
back to the BBS. This is for terminals that can't
take in strings immediately after sending them.
Using function 4 or 5, with 6, requires two calls
for every update, while using 9 or 0AH (6 not
required) requires only one.


AX = character to send to BBS or special message.
BX = 1 if an entire string is waiting to be sent.
(0 if not.)
CX, DX = The same as AX. If your program has trouble
receiving the special codes, try using these
returns instead.

If AX = 1 through FFH, the character should be sent to the
BBS. If AX = 0, no characters. Special codes also exist:

AX = 100H The terminal should wait for the user to press
a key before sending any more data. When the
key is pressed, the host terminal *must*
call function 16H with BL = 0 (see AL = 16H)
or function 18H.

AX = 101H QRIP has detected both mouse buttons or the
middle button pressed. 1stReader uses this
function to call up the virtual keyboard.

RIPscrip has the ability to auto-start any
kind of standard upload/download protocol.
The terminal should call function 1AH to
find out the filename, the protocol, etc.
that was communicated by a RIP command.
It should then start up/downloading.

AX = 103H Right mouse button pressed.

NOTE on codes 104H - 10DH:
The terminal can respond any way it likes to these
switches, but whenever any modes are switched on
or off, the mode change should be reported to QRIP
through function 16H. QRIP will assume no change
was made unless told otherwise (in other words,
if one of these codes is sent by QRIP to your terminal,
QRIP will still think nothing has changed until you
report that something has changed, through 16H). All
of these switches are all initialized to OFF when loading

AX = 104H The BBS requested that the terminal should turn
ON the status bar at the bottom of the
screen. In QRIP, the status bar is usually
the protected area. QRIP won't turn it off
automatically; the host terminal should
decide what to do with this code.

It might be a good idea to respond to the user
pressing Alt-SPACE by toggling the status
bar. Just remember to report any status
change to QRIP.

AX = 105H The BBS requested the status bar OFF.

AX = 106H BBS requested VT-102 user-terminal emulation
mode. This means that certain keys on the
user's terminal should change a little bit.
From the RIPSCRIP 1.54 document:

F1 - ESC [ M
F2 - ESC [ N
F3 - ESC [ O
F4 - ESC [ P
F5 - ESC [ Q
F6 - ESC [ R
F7 - ESC [ S
F8 - ESC [ T
F9 - ESC [ U
F10 - ESC [ V

QRIP currently supports most of VT-102.
Full emulation is coming soon.

AX = 107H The BBS requested VT-102 mode off.

AX = 108H The BBS requested Doorway mode on. If your
terminal doesn't support it yet, what it
does is send the pure IBM ASCII/keyboard
scancode values directly to the BBS. For
normal ASCII keys, your terminal should send
the ASCII value to the BBS, but for extended
keys, send a zero followed by the scancode
of the key pressed. You should also use the
standard "Alt-=" combination to toggle
doorway mode.

AX = 109H Doorway mode off.

AX = 10AH Hotkeys mode on. This allows the user to
press keys on the keyboard to activate
mouse buttons that have the hotkey flag
enabled. When this mode is on, the
host terminal should send QRIP all of the
keys pressed by the user to function 18H.
Of course, the terminal doesn't have to
send *all* of the keys - keys like F5
(shell to DOS in 1stReader) might be

AX = 10BH Hotkeys mode off.

AX = 10CH BBS requested Tab-key button-changing on.
This basically means that anytime the user
presses or , the host terminal
should send that key to QRIP through
function 18H.

AX = 10DH Tab-key mode off.

AX = 10EH XOFF. QRIP has entered a pop-up mode, and has
activated a 4k buffer that will store
anything that's coming in for when it's
ready to process it. If the terminal has
hardware or software flow control, it
should be activated so QRIP's buffer doesn't

NOTE: This code is sent anytime popup mode
is activated, even by function 12H below.
Therefore, when the host terminal calls 12H,
it can ignore this special code.

AX = 10FH XON. Pop-up mode just turned off.
NOTE: Function 13H will automatically generate
this code and it can be ignored just like
code 10E.

AX = 110H
119H In RIPterm, there is a setup screen in which
you can set up applications that can
automatically be run with request from the
BBS. Up to 10 (#0-9) applications are allowed.
These codes are generated whenever these
requests are made. Your terminal may
choose to ignore these, as they are pretty
much nonstandard in the author's opinion.
However, application #0 is supposed to be
a standard text editor; if your application
has a built-in editor (like 1stReader does),
code 110H ought to be able to execute it.

Unfortunately, there is currently no way
to pass command-line parameters from the
BBS to the application.

AX = 1FFH The terminal should send an ASCII 0
character to the BBS.

(And back to the rest of function 6...)

If BX returns 1, there is an entire string waiting to be sent.
It can be sent back to the terminal through function 12.
The terminal may choose to ignore this, and it can receive
all characters through this function, but there is a
speed penalty in doing so.

AL = 7: Return the absolute address of the font directory string.

If a program has the capability to set up QRIP, it may
do so with functions 7 and 8. Each string buffer has
a length of 80 characters and MUST be nul-terminated.

DX = segment
BX = offset

Simply write in the new full pathname at the address,
making sure the 80-char limit is imposed. The new path
won't take effect until the graphics screen is
re-initialized (by turning it off and then on). It isn't
required to have a backslash at the end.

AL = 8: Return the absolute address of the icons directory string.

See AL = 7. Same thing but for the icons directory. The
new path takes effect immediately.

The icons directory is used to store icon files and 'callable'
RIP files for use by the BBS. Your host terminal should
somehow organize a directory structure so that each BBS
has a different icons directory, and whenever a connection
is made, your terminal should set the QRIP icons directory
to the BBS's directory.

This string MUST end with a backslash (followed by a nul),
unlike the fonts directory.

AL = 9: Same as AL = 4, but it will automatically return any
characters waiting, the same way as AL = 6.

AL = 0AH: Same as AL = 5, but it will automatically return any
characters waiting, the same way as AL = 6.

AL = 0BH: Execute a RIP_END_SCENE.

Just like sending "!|#" on a new line. QRIP will
activate all mouse buttons and cancel the RIP

No return.

AL = 0CH: Get an entire string to send back to the BBS.

For terminal programs, sometimes a button executed by
the user will require automatic response through QRIP. A
terminal program using QRIP should therefore call this
function when function 6, 9, or 10 has directed it here.
Remember that the string *CAN* contain ASCII 0 characters!


AX = 0 if there's nothing to send (whatcha callin' here for?)
1 if everything's OK, and DX:BX has the string to send.
2 if there's a special code waiting in function 4, 5,
or 6 (shoulda looked back there first!)

If AX returns 1,
DX = segment address of string.
BX = offset.
CX = length.

AL = 0DH: Set protected area at bottom of graphics screen.

QRIP will allow you to put your terminal's status bar
and other information at the bottom of the screen in
such a way that whatever you write in the protected
area will not be affected by the BBS.

BL = attribute to fill area. The background color, if bit
7 is set, will be high-intensity instead of blinking.
CL = number of text lines (0 to turn off protected mode.)

No return.

AL = 0EH: Write a nul-terminated string in the protected area.

DX = segment
BX = offset
CL = x offset from upper-left corner of protected area
to place the string (starting at 0).
CH = y offset (also starting at 0).

Note: The string will be chopped on the right edge.

No return.

AL = 0FH: Scroll a portion of protected area.

BL = upper-left x offset
BH = upper-left y offset
DL = lower-right x offset
DH = lower-right y offset
CL = number of lines to scroll the window upward
(downward not permitted.)

No return.

AL = 10H: Set the color of strings written to the protected area.

BL = attribute - if bit 7 is set, bkg will be high-intensity
instead of blinking.

No return.

AL = 11H: Convert the protected area to the whole screen.

By doing this, the host terminal will be able to write
anywhere on the screen in 8x8 font (80x43) through
the protected-area functions. This shouldn't be used
except where necessary; the pop-up window mode and the
normal protected area should serve much better for most
purposes, although there are fewer restrictions with this
mode. Just remember, it won't be a protected mode
anymore, and the BBS will be able to write all over it.

On entry:
BX = 1: Allow writing to full screen.
BX = 0: Normal protection.

No return.

AL = 12H: Turn on pop-up window mode.

If pop-up mode is turned on, the host terminal will be able
to write on the screen, and restore the screen very quickly
when it's done. The writing on the screen can be done
by simply sending QRIP a RIP file through function 4 or 5.
Any buttons sent will be made active, so QRIP can respond
to buttons through the usual functions 6 and 0CH.

The picklists, the variable queries, and the green
info-boxes all use pop-up mode.

An example of the use of pop-up window mode:

1stReader calls function 12H.
1st sends a RIP file that puts a window on the screen
like this:

|Thanks for calling, Mark! |
| |
|Minutes used: 10 |
| |
|@$% +--------------------------+ |
|NO C|+---+ Exit Terminal? +---+| |
| ||Yes| |No || |
| |+---+ +---+| |
| +--------------------------+ |
| |
| |
| |
| |
| |
| |
+14400 | RIP | 57600N81,2 | Offline+

1stReader then calls function 6 repeatedly, waiting
for the user to press one of the buttons.
The user presses "No".
The button responds to 1st with a single character,
"N", according to the button definition in the RIP.
1st receives the "N" and calls function 13H.
The pop-up window disappears, and everything
returns to exactly the way it was.

This mode has some specific restrictions. While in
pop-up mode, the host terminal should *-NOT-* (even
though QRIP allows it):

- Reset the screen with |* or $RESET$. QRIP will
automatically turn off popup mode if the terminal
tries to do so.
- Use the clipboard. (Icons are okay.)
- Have more than 64 mouse fields and buttons total,
even though QRIP allows 128. Buttons numbered
64 through 127 will corrupt QRIP's saved mouse
- Change the EGA palette.
- Save the graphics screen, the mouse fields,
or the clipboard to disk with the corresponding
RIP variables.
- Use pop-up pick lists, unless it's okay that that the
pick list automatically takes QRIP out of pop-up mode.

The pick lists might be especially useful for compact
Yes/No choices. An example:

!|10000((Exit Terminal Mode?::[email protected],[email protected]))

This is a pick list definition that will send back
"Y" if the user clicks "Yes" or "N" if the
user clicks "No". The pick lists are also
kind of aesthetic, so you might try them.

- Use the RIP variable definition command (|1D), *-unless-*
it's a non-interactive definition and the variable
is known to be already defined. Nor should you
use standard variable queries to have the user
input data, *unless* it's okay that pop-up mode
will be automatically canceled.
- Use templates. This means you can use regular
buttons, but if you use radio or checkbox
buttons, you stand in danger of destroying the
BBS's template definitions. The author of QRIP is
considering changing this so it saves the templates
for pop-up mode, and thereby allows host terminals
to use radio/checkbox buttons.

+ Writing to the protected area is okay, but the 'picture'
of the area will be restored when pop-up mode is
turned off. The viewport will also be incorrect
if the number of protected lines is changed. The
protection itself is also ignored while in popup
mode, that is, a RIP designed for pop-up mode will
be able to write right over the protected area.

These restrictions aren't permanent, and except for $RESET$,
the author will lift specific restrictions if anyone has
a need for it.

One more general restriction: avoid starting pop-up
mode if there is RIP coming in at the time. QRIP makes
its best attempt to make pop-up mode available anywhere,
but the RIP processing section of QRIP (especially
dealing with variable queries and definitions) is far
too complex to account for every scenario. If this
restriction causes difficulty, you might try making
a very simple RIP monitor that watches for CR/LF pairs
and checks whether a ctrl-A, ctrl-B, or ! follows. When
CR/LF is followed by anything other than ctrl-A, ctrl-B,
or '!', it's perfectly safe at that time to start
pop-up mode.

Other than that, the pop-up window mode is very powerful
for making an especially compact and very friendly user

No return.

AL = 13H: Turn off pop-up window mode. The screen will be completely
restored very quickly and seamlessly.

No return.

AL = 14H: Save the graphics screen and go to text mode.

This is a way to switch to text mode and back.
The graphics screen is stored on disk and the screen
is switched to text mode, clearing the screen. When
you call this, it is IMPERATIVE that you don't call
any other functions but 15H when you're through.

No return.

AL = 15H: Restore the graphics screen saved with function 14H.

Remember that the host terminal must *not* call the regular
functions 2 or 3 to turn on/off graphics while QRIP is
in "screen saving" mode (initiated by function 14H).

No return.

AL = 16H: Report a mode change to QRIP.

All modes default to OFF when QRIP is first installed as a TSR.

On entry:
BL = 00H: A key was pressed to signify the end of the key
wait initiated through special code 100H.
QRIP will flush its buffer and return to

BL = 01H: status bar on
BL = 02H: status bar off

BL = 03H: VT-102 mode on
BL = 04H: VT-102 mode off

BL = 05H: doorway mode on
BL = 06H: doorway mode off

BL = 07H: hotkeys mode on
BL = 08H: hotkeys mode off

BL = 09H: tabkey mode on
BL = 0AH: tabkey mode off

Only the VT-102 mode changes will actually affect QRIP's
operation. The rest are intended for simply reporting
the status to the BBS when it's requested.

No return.

AL = 17H: Call a RIP file.

On entry:
DX:BX = pointer to nul-terminated string containing filename
of RIP file to call. The file can be in the current
icons directory (checked first), the QRIP.EXE
directory (checked second), or the current
directory. The .RIP extension isn't necessary.
Path specifications (with backslashes or colons)
are NOT allowed and will be obliterated.

This is mostly useful in pop-up mode. It will call the file
exactly as if the "|1R" RIP command were executed.

No return.

AL = 18H: Send a user key to QRIP.

On entry:
BX = key that was pushed. For normal ASCII keys,
send the ASCII value. For extended keys, send
the scancode in BH, with 0 in BL.

No return.

AL = 19H: Hangup (NO CARRIER).

This will disengage any popped-up windows and enable the
text cursor, if it's not already on. Call here when
carrier is lost. QRIP may sometimes generate a few
pop-up 'flashes' to get itself unraveled while
doing this.

No return.

AL = 1AH: return RIP_ENTER_BLOCK_MODE information.

RIPscrip has the ability to auto-start any kind of
standard block transfer. When the host terminal
receives special code 102H, it should call this
function (when it's ready to do so) to get
the transfer information, then it should start
transferring immediately.

returns: AH = protocol number requested, from chart:

Value Protocol Filename Required?


0 Xmodem (checksum) Yes
1 Xmodem (CRC) Yes
2 Xmodem-1K Yes
3 Xmodem-1K (G) Yes
4 Kermit Yes
5 Ymodem (batch) No
6 Ymodem-G No
7 Zmodem (crash recovery) No


8-15 The same as #0-7, but for uploading instead.

AL returns the file type being transferred.
Modified from the RIPscrip 1.54 doc:

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

The parameter determines what type of files are to be
received during the block transfer. These are the valid parameters:

Value Description of Block Transfer Contents
0 RIP file sequence (display it, don't store)
1 RIP file sequence (store them in ICONS subdirectory)
2 ICN file sequence (store them in ICONS subdirectory)
3 HLP file sequence (store it, and auto-load if needed)
4 COMPOSITE DYNAMIC file sequence (batch protocols only)
5 ACTIVE DYNAMIC file sequence (batch protocols only)

The special of 4 & 5 (COMPOSITE DYNAMIC file sequences)
is somewhat different than the non-batch transfer methods. This
allows each file uploaded to be individually processed based on their
file extensions. If you use extensions other than .RIP or .ICN, then
this mode is not available to you as the necessary files will not be
able to be processed. Any RIP/ICN files that are "downloaded" from the
Host in DYNAMIC mode are placed into the ICONS sub-directory and
no further processing is performed. .RIP files that are received are
"stored" and are not played back in COMPOSITE DYNAMIC mode. In
ACTIVE DYNAMIC mode, they are stored and played back simultaneously.
ICN files are only stored.

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

So basically, block mode, when downloading, is like a
normal transfer but .RIP, .ICN, .HIC, and .MSK files
go into the icons directory when downloading. Block
mode can also automatically activate .RIP files when
they are received. QRIP won't take care of the
automatic playback.

Most of the time, RIP auto-display isn't possible since
most terminal programs use external protocols.
In these cases, file types 0 and 5 should simply
create temporary files, then ask QRIP to display
them through function 17H. The author recommends
you don't use any temporary files that fit the wildcard

Mode 3 is probably for RIPterm only. It should be treated
as a standard non-batch transfer (but I may be wrong).

DX:BX points to a string containing the filename. CX
contains the length of this nul-terminated string.
(If no transfer has been requested by the BBS, DX and
BX will both be zero.)

AL = 1BH: Set system font size.
This call is provided so the host terminal can change the
font size manually. Set BX to one of the following:

Size Font Size X Range Y Range
0 8x8 0-79 0-42
1 7x8 0-90 0-42
2 8x14 0-79 0-24
3 7x14 0-90 0-24
4 16x14 0-39 0-24

No return.

AL = F0H: Detect the presence of QRIP.
If QRIP is present, this call will return:

AX = 9142H
DX = flag indicating whether QRIP is able to takeover DOS.
(0 = no, nonzero = yes).

If QRIP is able to takeover DOS, it will report in addition
to the above:

BX = version information. BH = major version number in
hex, not BCD coding; BL = minor version in the same
format. Example: if the version is 3.12, BX will be

CX = current flags. See AH = 1, Change internal flags,
for the list of these flags. They will appear in
exactly the same bit positions.

AL = FFH: deinstall QRIP. It will return:

AX = 0: Can't deinstall. Another TSR or program (possibly
the application calling QRIP) has taken over one of
QRIP's interrupts, and it can't deinstall without
crashing the system.

AX = 1: Successful deinstallation.

AX = 2: QRIP can't currently take over DOS. The application
might try again a couple of times. If it still
doesn't work, QRIP has probably been corrupted, and

the application should try to exit as gracefully
as possible.

QRIP interrupt hooks

QRIP hooks the following interrupts for its own maintenance:

Int 2F: The multiplex interrupt. Perhaps this isn't the best way to go,
but it is the fastest. The problem is that if any other TSR's
happen to use function AC also, they must be loaded before QRIP
or QRIP won't get any calls from applications. If they are
loaded before QRIP, QRIP will be able to recognize based on
the DI register whether the calls are intended for it or for
another TSR. Maybe I should've used Ralf Brown's AMIS (Alternate
Multiplex Interrupt Specification) instead, but it's too late now.

Int 30 (hex): The graphics library takes this interrupt. In some
sources it's labeled as "Interface for CP/M calls". As yet, I
don't know why the library needs it, but it doesn't seem to mess up
anything nonetheless.

Int 24 (hex): Critical error handler
Int 23 (hex): Ctrl-C handler
Int 1B : Ctrl-Break handler
These three are only trapped while QRIP has DOS control. They
simply return (with a fail code for the critical error handler).
This is done for smooth operation of QRIP. Their vectors are
returned to their original values when QRIP is finished with

Bug Reports

If you're sure there's something wrong and you've checked everything else,
please don't hesitate to report the problem to me. You can reach me
on ILink and RIME through the RIPscrip and ANSI conferences, or
by calling The Graphics Connection at (801)264-1191. You will be able
to leave a (C)omment for the sysop after going through registration, and
the sysops will forward your comment to me. If you prefer the 29-cent,
slower variety of communication, snail-mail me at:

Shane Hathaway
7771 W 3455 So
Magna, UT 84044 (USA)


Many thanks to the many who have made this project possible! It was
on ILink that I first discovered RIP. Thanks to all the administrators for
creating an efficient, well-balanced, and well-moderated mail network.
Thanks to The Graphics Connection BBS (801)264-1191 for providing me access
to ILink, and thanks to Glenda, Michael, and Kay (the sysops) for running
TGC so well. Thanks to Sparky, who provided me with a goal to attain: a
RIPscrip TSR! Thanks to Glenda for her dedication to the project, and for
a gigabillion other things. Thanks to Michael Leavitt for tips on a few
things and for the assembly-code optimization of the bezier curve routine.
Thanks to John Friel for posting a bezier curve routine on ILink that made
my lightning-speed bezier possible. Thanks to the RIP artists around the
world, especially Michael Arnett, Annie Mendetta, John Kwasnik, Wayne
Thomas, and a whole lotta others who helped me debug QRIP without them even
knowing it (grin). Thanks to the 1stReader beta team, especially Matthew
Waldron, Joe Malacria (the Ansi_Phreak), and Sparky, for reporting bugs I
couldn't possibly have guessed would exist. Thanks to TeleGrafix for
inventing this wonderful protocol! Thanks again to Joe Malacria, who came
up with the idea for the strip-resistant protocol! Last but not least,
thanks to my family which lets me use the computer all day.

Copyrights and Trademarks

QRIP and WWIVRIP are Copyright (c)1994 by Shane Hathaway.
All Rights Reserved.
RIPscrip is a trademark of TeleGrafix Communications, inc.
1stReader is a trademark of Sparkware.
WWIV is a trademark of Wayne Bell.


 December 10, 2017  Add comments

Leave a Reply