Dec 142017
Windows debugging utility that allows tracking debug messages.
File DBSLATE.ZIP from The Programmer’s Corner in
Category Windows 3.X Files
Windows debugging utility that allows tracking debug messages.
File Name File Size Zip Size Zip Type
DBSLATE.EXE 167424 54797 deflated
DBSLATE.H 587 292 deflated
DBSLIB.OBJ 2831 1638 deflated
DBSTEST.C 486 298 deflated
README.TXT 8594 3311 deflated

Download File DBSLATE.ZIP Here

Contents of the README.TXT file

Copyright 1993 Larry R. Miller, Miller Consulting Group, Foster City CA

DBSLATE is shareware. You may make copies of DBSLATE for others to use.
However, you may not modify the DBSLATE.EXE file or the DBSLIB.OBJ file.
You may use DBSLATE for 30 days without obligation. However, if you wish to
use DBSLATE after this trial period, you must register.

To become a registered user, send us a check for $20.00 drawn on
a United States bank, or to register and also get DBSLATE PRO, which gives
you up to a 4 Megabyte text buffer and also the ability to watch variables
and their changes, send us a check for $49.00 drawn on a United States bank.
As an alternative, or if you do not have a US bank account, if you have a
CompuServe account, you can use GO SWREG to register.

A) A much faster and larger message logging buffer than
Winsight or Spy, and
B) A buffer that you send text lines to from an application
using printf-like function calls.
C) The buffer can be displayed and scrolled on the main display
and/or on a separate monochrome adapter/monitor.
D) Additionally, you can send "status" lines that are always
displayed rather than scrolled.

The logging buffer for DBSLATE holds 200 KBytes of text. If you need
more space, you can obtain DBSLATE PRO by registering. The logging
buffer of DBSLATE PRO holds up to 4 Megabytes of text. See the end of
this file for details on registering.

DBSLATE works with the retail or debugging Windows 3.1 binaries,
in Standard or Enhanced mode. (It may work with Win 3.0 also if you
supply ToolHelp).
Its buffer can hold up to 4 Megabytes of text !

DBSLATE sets up a direct communication between your application being
debugged and DBSLATE. This almost always bypasses the Windows API entirely,
so DBSLATE will not interfere with an API interaction that you are trying
to be debug.

The DBSLATE package is two things:

1) A stand alone application program DBSLATE.EXE

This program contains the logging buffer. It logs Windows messages and
their return values and also messages that an application sends to it.

You can inhibit logging of text by turning off the Txt option.

You select windows to log messages and their return values from by using
the Activate menu item:
Activate brings up a small window that tells you to press G to select
windows. You can press Esc at this point to clear all previous activations.
When you press G, the cursor becomes a cross, and the Activate
window shows the caption, window class, and window handle of the window that
the cross is over. Be aware that invisible windows are shown as well as
visible ones. Place the cursor over a window you wish to "activate" (i.e.
log messages to). Then click the right mouse button to activate it, or
press the left mouse button to activate it and its descendants. You can
repeat this process as desired. Click in the Activate window to
stop the process. Then press Esc to erase all activations, or press
Enter to accept them all.

To actually log window messages the Msg option must be on "Msg" or "Some".
If it is on "Msg" then all messages to the selected windows are logged.
If the Msg option is on "Some", then the messages WM_SETCURSOR, WM_MOUSEMOVE,
WM_ENTERIDLE, WM_NCHITTEST and WM_NCMOUSEMOVE are inhibited. This greatly
reduces message clutter. Message numbers are decoded into mnemonics for
messages of number < WM_USER, and the parameters are usually decoded also.
(Control messages and control notifications are not decoded)

Nesting of messages is shown by indentation.
If a window message is immediately followed by its return, the return value
is simply given as Ret = ; otherwise, information about the message
is added to the line giving the return value, so you can tell which message
is returning.

The logged information is stored as text
in a buffer. The buffer normally holds 512K bytes of ASCII characters,
but you can increase or decrease this by specifying the size in kilobytes
on the command line. For example, the command line


executes DBSLATE with a 1024 Kilobyte loging buffer. The buffer may be up to
4 Megabytes in length.

The buffer can be displayed on the
standard Windows screen (we call this the VGA mode) and it can also be
displayed on a monochrome adapter and monitor (we call this the Hercules

The buffer can be copied to the disk in its entirety.

All or part of the buffer can be printed, using the File | Print menu
selection. The part of the buffer that is printed is the part
currently displayed through the end.

If Herc mode is on, all messages and text are immediately displayed on the
Monochrome adapter. This is useful if your program
trashes the main Windows screen or if it hangs or crashes and you want
to see the last message sent.

The display of the log on the Windows screen is updated periodically
and when when the system is idle. This keeps DBSLATE from slowing down
the system when messages are being logged, as Spy and Winsight do. But bear
in mind that if the system hangs the last message may not appear on the
Windows screen's DBSLATE window, whereas it will appear on the monochrome
monitor if Herc mode is on.

You can turn off the refreshing of the log display in the Windows screen
by turning off the Vga option. This is rarely needed, however.

2) An object file DBSLIB.OBJ containing a few functions, and a header file
DBSLATE.H declaring these functions.

To give your C or C++ program the ability to send strings to the DBSLATE log,
you must link in DBSLIB.OBJ into your executable, and include DBSLATE.H
in source files that call the functions. The functions are:

int dbstr (char far *str) Sends the ascii string to the DBSLATE log.
Embedded \n's may be used to make more than 1 line.

int dbpr (char far *fmt, ...) Sends formatted output to the DBSLATE
log. Formatting is similar to printf \n's may
be used to make more than one line.

int dblpr (__LINE__,__FILE__,fmt, ...) Sends formatted output to
the DBSLATE log, preceded by the source file name
and line number. Your code must look like the

int dbclear () Clears the log

int dbstat (int stat_line_number, char far *fmt, ...)
Sends formatted output to a status line as well as
to the log.
There are 5 status lines (numbered 1 to 5).
These are not part of the log, but appear at the
top of the log display.

Of course, DBSLATE must be running while your program executes, or the
information will be lost.

DBSTEST.C is the source code for a sample application program that
shows how to use these functions. As usual, you must be sure to link
DBSLIB.EXE in when you build this example.

The macro DBLPR is provided for your convenience. You can use the

DBLPR "number %d", 44); /* Note there is no open paren */

in place of

dblpr (__LINE__,__FILE__,"number %d", 44);

To send a string to DBSLATE that just indicates the source line number
and file, you can use

dblpr (__LINE__,__FILE__,"");

DBLPR "");

Miller Consulting Group
755 Bounty Drive Suite 201
Foster City CA 94404

CompuServe: 71045,2056
Internet: [email protected]

Miller Consulting Group provides short and long-term consulting on
Windows software development:
C, C++, and assembly
OLE 1 and 2
Device drivers
NT porting and development
and provides training in developing WIndows applications in C++, both
for the public in conjunction with the University of California Berkeley and
the University of California, Santa Cruz, and at customers' sites.
Call our consulting office at 415 578-0709 for your consulting and/or
training needs.

 December 14, 2017  Add comments

Leave a Reply