/*
DEBUG.C - sample debugging BGI driver
Copyright (c) 1988,89 Borland International
*/
#include <stdlib.h>
#include <string.h>
#include <dos.h>
/* ----------------------------- DEBUG.C ------------------------------ */
/* */
/* Function Protoypes for the debug driver. */
/* */
void save_regs( void );
void banner( char *str );
void putnum( unsigned number );
void puthex( unsigned number );
void dputs( char far *str );
void crlf( void );
void far enter_graphics( void );
void far leave_graphics( void );
void far putpix( void );
void far getpix( void );
void far bits_per_pixel( void );
void far set_visual( void );
void far set_page( void );
void far set_write_mode( void );
typedef void far (*FRFPTR)( void ); /* Pointer to Void/Void Funct */
typedef void (*NRFPTR)( void ); /* Pointer to Void/Void Funct */
/* */
/* The following C structure defines a Device Status Block. */
/* */
typedef struct {
unsigned char stat; /* Current device status. */
unsigned char devtype; /* Device Type Identifier. */
unsigned int xres; /* Device Full Resolution in X */
unsigned int yres; /* Device Full Resolution in Y */
unsigned int xefres; /* Device Effective X Resolution*/
unsigned int yefres; /* Device Effective Y Resolution*/
unsigned int xinch; /* Device X Size in inches*1000 */
unsigned int yinch; /* Device Y Size in inches*1000 */
unsigned int aspec; /* Aspect Ratio * 10000 */
unsigned char chsizx; /* Standard char size X */
unsigned char chsizy; /* Standard char size Y */
unsigned char fcolors; /* Number of foreground colors */
unsigned char bcolors; /* Number of background colors */
} STATUS;
/* */
/* The following structure defines a palette record. */
/* */
typedef struct {
unsigned char length; /* # of color entries in palette*/
unsigned char color[16]; /* Up to 16 color entries */
} PALETTE;
/* */
/* The following structure defines a utility function table. */
/* */
typedef struct {
NRFPTR goto_graph; /* Enter graphics mode function */
NRFPTR exit_graph; /* Leave graphics mode function */
NRFPTR putpix; /* Write a pixel function */
NRFPTR getpix; /* Read a pixel function */
NRFPTR bits_per_pixel; /* Bits per pixel value */
NRFPTR set_page; /* Set the active drawing page */
NRFPTR set_visual; /* Set the active display page */
NRFPTR write_mode; /* Set the current write mode */
} UTILITIES;
/* */
/* This status block declares the debug driver to appear as an */
/* EGA card in high resolution mode. */
/* */
STATUS Stat_Block = { /* Status block to fake an EGA driver */
0, /* Current device status. */
0, /* Device Type Identifier. */
639, /* Device Full Resolution in X */
479, /* Device Full Resolution in Y */
639, /* Device Effective X Resolution */
479, /* Device Effective Y Resolution */
9000, /* Device X Size in inches*1000 */
7000, /* Device Y Size in inches*1000 */
10000, /* Aspect Ratio * 10000 */
8 + 0x80, /* Standard char size X */
8 + 0x80, /* Standard char size Y */
16 + 0x80, /* Number of foreground colors */
16 + 0x80 /* Number of background colors */
};
/* */
/* This palette declares the default EGA palette. */
/* */
PALETTE Default_Palette = { /* Define the palette for above EGA mode*/
16, { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x14, 0x07,
0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F }
};
/* */
/* The following structure defines the Bit Manipulation Utility */
/* function table. */
/* */
UTILITIES Utility_Table = { /* Bit Utilities Function Table */
(NRFPTR) enter_graphics, /* Enter graphics mode function */
(NRFPTR) leave_graphics, /* Leave graphics mode function */
(NRFPTR) putpix, /* Write a pixel function */
(NRFPTR) getpix, /* Read a pixel function */
(NRFPTR) bits_per_pixel, /* Bits per pixel function */
(NRFPTR) set_page, /* Set the active drawing page */
(NRFPTR) set_visual, /* Set the active display page */
(NRFPTR) set_write_mode /* Set the current write mode */
};
/* */
/* The following defines the name of the modes for Driver. */
/* NOTE: The string must start with a PASCAL style length. */
/* */
char Name[] = "\030Debug Driver (640 x 480)";
/* Driver Local Data Variables */
char Buffer[80] = { 0 }; /* String output buffer */
unsigned int CP_X = 0, CP_Y = 0; /* Current Drawing Pointer CP */
unsigned int ds = 0; /* DS on entry to the driver */
unsigned int ax = 0, bx = 0, cx = 0, dx = 0;
unsigned int ah = 0, bh = 0, ch = 0, dh = 0;
unsigned int al = 0, bl = 0, cl = 0, dl = 0;
/* ----------------------------- INSTALL ------------------------------- */
/* */
/* The Install function is used to prepare the driver to use. */
/* The calls to this function allow the kernal to inquire the */
/* mode information, and allow the kernal to install the mode */
/* infomation. */
/* */
void install( void )
{
save_regs(); /* Save a copy of current regs */
banner( "INSTALL" ); /* Announce the function type */
switch( al ){ /* Determine the command to use */
case 0: /* Install Device Command */
dputs( " Install Device: Mode Number: " );
putnum( cl );
dputs( " AutoDetect Maximum: " );
putnum( ch );
crlf();
_ES = _CS; /* Make ES:BX point to block */
_BX = (unsigned int) &Stat_Block; /* BX points to status block */
break;
case 1: /* Mode Query Command */
dputs( " Mode Query Request (1 Mode)\r\n" );
_CX = 1; /* Return only 1 mode supported */
break;
case 2: /* Mode Name Command */
dputs( " Mode Name Request: Mode " );
putnum( cx );
crlf();
_ES = _CS; /* Make ES:BX point to name */
_BX = (unsigned int) Name; /* BX points to name string */
break;
default: /* Unknown Install Call */
dputs( " ERROR: Unknown Install Command: " );
puthex( al );
crlf();
break;
} /* End of Install command case */
}
/* ----------------------------- INITIALIZE ---------------------------- */
/* */
/* The initialize function is uset to enter the graphics mode. */
/* Once the kernal has established the mode, the Initialize */
/* call is used to execute the entry to graphics mode. */
/* */
void init( void )
{
save_regs(); /* Save a copy of current regs */
banner( "INITIALIZE" );
dputs( " Device Status Table at " );
puthex( _ES );
dputs( ":" );
puthex( bx );
crlf();
}
/* ----------------------------- CLEAR DEVICE -------------------------- */
/* */
/* The Clear Device call is used to ready the device for new */
/* output. This would be a clear screen on graphics hardware, */
/* formfeed on a printer or plotter, and a flush for file I/O. */
/* */
void clear( void )
{
banner( "CLEAR DEVICE" );
}
/* ----------------------------- POST DEVICE --------------------------- */
/* */
/* The Post Device function is used to end the graphics output. */
/* This would be used to begin printing a page on a printer, */
/* set a graphics screen to visable, etc. */
/* */
void post( void )
{
banner( "POST DEVICE" );
}
/* ----------------------------- MOVE TO ------------------------------- */
/* */
/* This function is used to move the current pointer (CP). The */
/* Current pointer is the system graphics cursor. */
/* */
void move( void )
{
save_regs(); /* Save a copy of current regs */
banner( "MOVE" );
dputs( " Move to: X: " );
putnum( ax );
dputs( " Y: " );
putnum( bx );
crlf();
CP_X = ax; /* Update the current pointer */
CP_Y = bx;
}
/* ----------------------------- DRAW TO ------------------------------- */
/* */
/* Draw To is used to draw a line vector from the CP to the */
/* specified coordinate. */
/* */
void draw( void )
{
save_regs(); /* Save a copy of current regs */
banner( "DRAW" );
dputs( " Draw to: X: " );
putnum( ax );
dputs( " Y: " );
putnum( bx );
crlf();
CP_X = ax; /* Update the current pointer */
CP_Y = bx;
}
/* ----------------------------- VECT ---------------------------------- */
/* */
/* Vector is used to draw lines when the beginning and ending */
/* point are know. The parameters specify two vertices for */
/* drawing the desire line. */
/* */
void vect( void )
{
save_regs(); /* Save a copy of current regs */
banner( "VECT" );
dputs( " Vector From: X: " );
putnum( ax );
dputs( " Y: " );
putnum( bx );
dputs( " To: X: " );
putnum( cx );
dputs( " Y: " );
putnum( dx );
crlf();
}
/* ----------------------------- POLYGON ------------------------------ */
/* */
/* The polygon command is used to implement all of the possible */
/* polygon output syles. The parameters allow specifying a means */
/* to draw a polygon using a static array, or by accruing points */
/* through the moveto - lineto calls in a capture mode. */
/* */
void polygon( void )
{
int far *iptr = MK_FP( _ES, _BX );
int i;
save_regs();
banner( "POLYGON" );
switch( ax ){ /* Determine Polygon action */
case 0: /* Start polygon definition */
dputs( " Start Polygon Definition\r\n" );
break;
case 1: /* Close and trace polygon */
dputs( " Close and Trace Polygon\r\n" );
break;
case 2: /* Close and fill polygon */
dputs( " Close, Trace, and Fill Polygon\r\n" );
break;
case 3: /* Close and fill (no outline) */
dputs( " Close and Fill Polygon (No Outline)\r\n" );
break;
case 4: /* Draw points, but no capture */
dputs( " Draw Points without Capture\r\n" );
break;
case 5: /* End polygon capture mode */
dputs( " Turn Capture Off\r\n" );
break;
case 6: /* Draw polygon from data array */
dputs( " Draw Polygon: " );
putnum( cx );
dputs( " Vertices\n\r" );
for( i=0 ; i<cx ; ++i ){ /* Display the vertex list */
dputs( " " );
putnum( i );
dputs( ": X: " );
putnum( *iptr++ );
dputs( " Y: " );
putnum( *iptr++ );
}
break;
case 7: /* Fill polygon from data array */
dputs( " Fill Polygon: " );
putnum( cx );
dputs( " Vertices\n\r" );
for( i=0 ; i<cx ; ++i ){ /* Display the vertex list */
dputs( " " );
putnum( i );
dputs( ": X: " );
putnum( *iptr++ );
dputs( " Y: " );
putnum( *iptr++ );
}
break;
default: /* Unknown polygon command */
dputs( " ERROR: Unknown Polygon Command (" );
putnum( ax );
dputs( "\r\n" );
break;
}
}
/* ----------------------------- RECT ---------------------------------- */
/* */
/* This function is used to draw a filled rectangle to the output */
/* device. The parameters are the coordinates of opposite corners */
/* of the input rectangle. The rectangle call is also capable of */
/* producing 3D bars with an additional depth and cap parameter. */
/* */
void bar( void )
{
save_regs(); /* Save a copy of current regs */
banner( "RECT" );
dputs( " Upper Right: X: " );
putnum( ax );
dputs( " Y: " );
putnum( bx );
crlf();
dputs( " 3D Depth: " );
putnum( cx );
dputs( " Top Flag: (" );
putnum( dx );
dputs( ") " );
dputs( dx ? "Yes\r\n" : "No\r\n" );
}
/* ----------------------------- PATBAR -------------------------------- */
/* */
/* The patbar function is used to draw rectangles which are filled */
/* with the current drawing pattern. The parameters of PATBAR */
/* at the coordinates of the opposing corners of the bar. */
/* */
void patbar( void )
{
save_regs(); /* Save a copy of current regs */
banner( "PATBAR");
dputs( " Upper Left: X: " );
putnum( ax );
dputs( " Y: " );
putnum( bx );
dputs( " Lower Right: X: " );
putnum( cx );
dputs( " Y: " );
putnum( dx );
crlf();
}
/* ----------------------------- ARC ----------------------------------- */
/* */
/* The ARC command is used to output elliptical arcs. The input */
/* parameters of the arc are the coordinate of the ARC center, */
/* the X and Y radius, and the beginning and ending angle. */
/* */
void arc( void )
{
save_regs(); /* Save a copy of current regs */
banner( "ARC" );
dputs( " X Radius: " );
putnum( cx );
dputs( " Y Radius: " );
putnum( dx );
crlf();
dputs( " Start Angle: " );
putnum( ax );
dputs( " End Angle: " );
putnum( bx );
crlf();
}
/* ---------------------------- PIESLICE ------------------------------- */
/* */
/* The sector command is used to output setors. The input */
/* parameters of the sector are the coordinate of the center, */
/* the X and Y radius, and the beginning and ending angle. */
/* */
void pieslice( void )
{
save_regs(); /* Save a copy of current regs */
banner( "PIESLICE" );
dputs( " X Radius: " );
putnum( cx );
dputs( " Y Radius: " );
putnum( dx );
crlf();
dputs( " Start Angle: " );
putnum( ax );
dputs( " End Angle: " );
putnum( bx );
crlf();
}
/* -------------------------- FILLED ELLIPSE --------------------------- */
/* */
/* The input parameters of the elipse command is the coordinate */
/* of the center and the x and y radii. */
/* */
void filled_ellipse( void )
{
save_regs(); /* Save a copy of current regs */
banner( "FILLED ELLIPSE" );
dputs( " X Radius: " );
putnum( ax );
dputs( " Y Radius: " );
putnum( bx );
crlf();
}
/* ----------------------------- PALETTE ------------------------------- */
/* */
/* The palette command is the central command for loading the */
/* device palette. This function support several modes to allow */
/* for the varied palette and color systems. */
/* */
void palette( void )
{
int flags, index;
save_regs(); /* Save a copy of current regs */
banner( "PALETTE" );
flags = (ax >> 14) & 0x0003; /* Get flag bits from command */
index = ax & 0x3fff; /* Mask to get color index */
switch( flags ){ /* Act according to flags */
case 0: /* Set indexed color palette */
dputs( " Set Indexed Color: Index: " );
putnum( index );
dputs( " Color Value: " );
putnum( bx );
crlf();
break;
case 1: /* Undefine color command */
dputs( "ERROR: Undefined Set Color Command (01)\r\n" );
break;
case 2: /* RGB - Index color */
dputs( " Set RGB Color: Index: " );
putnum( index );
dputs( " R: " );
putnum( bx );
dputs( " G: " );
putnum( cx );
dputs( " B: " );
putnum( dx );
crlf();
break;
case 3: /* Background color */
dputs( " Set Background Color: Color Value: " );
putnum( bx );
crlf();
break;
}
}
/* ----------------------------- ALLPALETTE ---------------------------- */
/* */
/* The all palette command is used to load an entire palette in */
/* a single output command. The current BGI limits the size of */
/* the allpalette command to be the first 16 colors. */
/* */
void allpalette( void )
{
unsigned char far *pptr = MK_FP( _ES, _BX );
int i;
banner( "ALLPALETTE" );
i = *pptr++;
dputs( " Palette Size: " );
putnum( i );
crlf();
while( i-- ){
dputs( " " );
putnum( *pptr++ );
crlf();
}
}
/* ----------------------------- COLOR --------------------------------- */
/* */
/* The color function takes an index and sets the active fore */
/* and background colors for output devices. */
/* */
void color( void )
{
save_regs(); /* Save a copy of current regs */
banner( "COLOR" );
dputs( " Drawing Color: " );
putnum( al );
dputs( " Filling Color: " );
putnum( ah );
crlf();
}
/* ----------------------------- FILLSTYLE ----------------------------- */
/* */
/* The fill style function is used to set the interior style of */
/* the filled primatives. The input to the function is the */
/* filled pattern style number, or a flag and a pointer to load */
/* an 8x8 bit pattern tile. */
/* */
void fillstyle( void )
{
static char *fill_name[] = { /* Names of line styles */
"Empty",
"Solid",
"Line",
"Lt Slash",
"Slash",
"Bkslash",
"Ltbkslash",
"Hatch",
"Xhatch",
"Interleave",
"Wide dot",
"Close dot",
"User Defined"
};
int i;
unsigned char far *pptr;
save_regs(); /* Save a copy of current regs */
pptr = MK_FP( _ES, _BX );
banner( "FILLSTYLE" );
dputs( " Fill Style: (" );
putnum( al );
dputs( ") " );
dputs( (al == 0xff) ? "User Defined" : fill_name[al] );
dputs( " Fill\r\n" );
if( al == 0xff ){ /* User defined line style */
dputs( " User Defined Fill Pattern:\r\n" );
dputs( " " );
for( i=0 ; i<8 ; ++i ){
puthex( *pptr++ );
dputs( " " );
}
crlf();
}
}
/* ----------------------------- LINESTYLE ----------------------------- */
/* */
/* The line style command is used to set the style of the lines */
/* and borders of objects. The input to the fucntion is the line */
/* style number, of a flag and a 16 bit pattern for user defined */
/* line drawing styles. */
/* */
void linestyle( void )
{
static char *line_name[] = { /* Names of line styles */
"Solid",
"Dotted",
"Center",
"Dashed",
"User Defined"
};
save_regs(); /* Save a copy of current regs */
banner( "LINESTYLE" );
dputs( " Line Style: (" );
putnum( al );
dputs( ") " );
dputs( line_name[al] );
dputs( "Line Line Width: " );
putnum( cx );
crlf();
if( al == 4 ){ /* User defined line style */
dputs( " User Defined Line Pattern: " );
puthex( cx );
crlf();
}
}
/* ----------------------------- TEXTSTYLE ----------------------------- */
/* */
/* The text style command is used to define the output font, */
/* text path, and text direction for font rendering. */
/* */
void textstyle( void )
{
save_regs(); /* Save a copy of current regs */
banner( "TEXTSTYLE" );
dputs( " Font Number: " );
putnum( al );
dputs( " Font Path: " );
putnum( ah );
crlf();
dputs( " Character Size: X: " );
putnum( bx );
dputs( " Y: " );
putnum( cx );
crlf();
_BX = bx; /* Return the input as default */
_CX = cx;
}
/* ------------------------------ TEXT --------------------------------- */
/* */
/* The text output command takes a string and renders the string */
/* on the output device. The input to the function is the text */
/* and the string length. */
/* */
void text( void )
{
char far * cptr = MK_FP( _ES, _BX );
int i;
save_regs(); /* Save a copy of current regs */
banner( "TEXT" );
dputs( " Input Text: \"" );
/* Read sting from the far memory to local memory. */
for( i=0 ; i<cx ; ++i ) Buffer[i] = *cptr++;
Buffer[i] = '\0'; /* Null terminate string */
dputs( Buffer );
dputs( "\"\r\n" );
}
/* ---------------------------- FLOODFILL ------------------------------ */
/* */
/* This function is a standard floodfill command The input to */
/* the function is the seed point for the floodfill. The fill */
/* is done in the current drawing color and pattern. */
/* */
void floodfill( void )
{
save_regs(); /* Save a copy of current regs */
banner( "FLOOD FILL" );
dputs( " Seed Point: X: " );
putnum( ax );
dputs( " Y: " );
putnum( bx );
crlf();
}
/* ---------------------------- GETPIXEL ------------------------------ */
/* */
/* This function is used to read a pixel from the screen. */
/* The function input is the coordinates of the pixel to be */
/* read. The output from the function is the color of the */
/* pixel that was read. */
/* */
void getpixel( void )
{
save_regs(); /* Save a copy of current regs */
banner( "GET PIXEL" );
dputs( " Pixel Address: X: " );
putnum( ax );
dputs( " Y: " );
putnum( bx );
crlf();
}
/* ---------------------------- SETPIXEL ------------------------------ */
/* */
/* This function is used to plot a pixel on the screen. */
/* the function input is the coordinates of the pixel to be */
/* plotted and the color value of the pixel. */
/* */
void setpixel( void )
{
save_regs(); /* Save a copy of current regs */
banner( "SET PIXEL" );
dputs( " Pixel Address: X: " );
putnum( ax );
dputs( " Y: " );
putnum( bx );
dputs( " Value: " );
putnum( dl );
crlf();
}
/* ----------------------------- BITMAPUTIL --------------------------- */
/* */
/* This function returns the base of the bit manipulation utility */
/* table. The entry does not perform any function. */
/* */
void bitmaputil( void )
{
banner( "BITMAPUTIL" );
dputs( " Bit Map Utility Table Base: " );
puthex( _DS );
dputs( ":" );
puthex( (unsigned int) &Utility_Table );
crlf();
_ES = _DS; /* ES:BX = table address */
_BX = (unsigned int) &Utility_Table; /* Assign Base of table address */
}
/* -------------------------------------------------------------------- */
/* */
/* The following defines the bit map utilities. */
/* */
/* These functions are accessed directly from the calling code, */
/* and are not process via the normal BGI Interface. Therefore, */
/* these routines must preserve the input data, and must be FAR */
/* functions. */
/* */
void far enter_graphics( void ) /* Enter graphics mode function */
{
unsigned int orgds = _DS;
_DS = _CS; /* Point Data Seg to Code Seg */
banner( "Bit Map Function: Enter Pixel Graphics Mode" );
_DS = orgds; /* Restore the original DS */
}
void far leave_graphics( void ) /* Leave graphics mode function */
{
unsigned int orgds = _DS;
_DS = _CS; /* Point Data Seg to Code Seg */
banner( "Bit Map: Leave Pixel Graphics Mode" );
_DS = orgds; /* Restore the original DS */
}
void far putpix( void ) /* Write a pixel function */
{
unsigned int arg = _AX;
unsigned int orgds = _DS;
_DS = _CS; /* Point Data Seg to Code Seg */
save_regs(); /* Save a copy of current regs */
banner( "Bit Map Function: Put Pixel" );
dputs( " Pixel Address: X: " );
putnum( arg );
dputs( " Y: " );
putnum( bx );
dputs( " Value: " );
putnum( dl );
crlf();
_DS = orgds; /* Restore the original DS */
}
void far getpix( void ) /* Read a pixel function */
{
unsigned int arg = _AX;
unsigned int orgds = _DS;
_DS = _CS; /* Point Data Seg to Code Seg */
save_regs(); /* Save a copy of current regs */
banner( "Bit Map Function: Get Pixel" );
dputs( " Pixel Address: X: " );
putnum( arg );
dputs( " Y: " );
putnum( bx );
crlf();
_DS = orgds; /* Restore the original DS */
_DL = 5; /* Fake return value */
}
void far bits_per_pixel( void ) /* returns the bits per pixel */
{
#define PIXEL_BITS 4
save_regs(); /* Save a copy of current regs */
banner( "Bit Map Function: Bits Per Pixel" );
crlf();
_AX = PIXEL_BITS;
}
void far set_page( void ) /* Set the active drawing page */
{
unsigned int arg = _AL;
unsigned int orgds = _DS;
_DS = _CS; /* Point Data Seg to Code Seg */
save_regs(); /* Save a copy of current regs */
banner( "Bit Map Function: Set Active Page" );
dputs( " Page Number: " );
putnum( arg );
crlf();
_DS = orgds; /* Restore the original DS */
}
void far set_visual( void ) /* Set the active display page */
{
unsigned int arg = _AL;
unsigned int orgds = _DS;
_DS = _CS; /* Point Data Seg to Code Seg */
save_regs(); /* Save a copy of current regs */
banner( "Bit Map Function: Set Visual Page" );
dputs( " Page Number: " );
putnum( arg );
crlf();
_DS = orgds; /* Restore the original DS */
}
void far set_write_mode( void ) /* Set the current write mode */
{
unsigned int arg = _AX;
unsigned int orgds = _DS;
_DS = _CS; /* Point Data Seg to Code Seg */
save_regs(); /* Save a copy of current regs */
banner( "Bit Map Function: Set Write Mode" );
dputs( " XOR Write Mode: (" );
putnum( arg );
dputs( ") " );
dputs( arg ? "On\r\n" : "Off\r\n" );
_DS = orgds; /* Restore the original DS */
}
/* ---------------------------- RESTOREBITMAP -------------------------- */
/* */
/* The restore bit map function is used to load a retangular */
/* region from the host memory into the graphics memory. The */
/* input to the routine is the region to write, a pointer to */
/* the source in the host's memory, and the mode to use when */
/* writing the region. */
/* */
void restorebitmap( void )
{
unsigned int si = _SI;
unsigned int di = _DI;
save_regs(); /* Save a copy of current regs */
banner( "RESTOREBITMAP" );
dputs( " Restore Buffer at " );
puthex( _ES );
dputs( ":" );
puthex( bx );
crlf();
dputs( " Start X: " );
putnum( si );
dputs( " Y: " );
putnum( di );
dputs( " End X: " );
putnum( cx );
dputs( " Y: " );
putnum( dx );
crlf();
}
/* ---------------------------- SAVEBITMAP ----------------------------- */
/* */
/* The save bit map function is used to write a rectangular */
/* region from the graphics memory to the host memory. The input */
/* to the function is the region to be read, and a pointer to */
/* a save buffer in the host memory. */
/* */
void savebitmap( void )
{
unsigned int si = _SI;
unsigned int di = _DI;
save_regs(); /* Save a copy of current regs */
banner( "SAVEBITMAP" );
dputs( " Save Buffer at " );
puthex( _ES );
dputs( ":" );
puthex( bx );
crlf();
dputs( " Start X: " );
putnum( si );
dputs( " Y: " );
putnum( di );
dputs( " End X: " );
putnum( cx );
dputs( " Y: " );
putnum( dx );
crlf();
}
/* ---------------------------- SETCLIP -------------------------------- */
/* */
/* The setclip function defines a clipping rectangle on the */
/* output device. The input to the function defines the */
/* coordinated of the opposing corners of the clipping rectangle. */
/* */
/* */
void setclip( void )
{
save_regs(); /* Save a copy of current regs */
banner( "SETCLIP" );
dputs( " Upper Left: X: " );
putnum( ax );
dputs( " Y: " );
putnum( bx );
dputs( " Lower Right: X: " );
putnum( cx );
dputs( " Y: " );
putnum( dx );
crlf();
}
/* ---------------------------- GETPIXEL ------------------------------- */
/* */
/* The GetPixel function is used to read a specific pixel value */
/* from the graphics screen. The input is the coordinate of the */
/* pixel to be read. The output is the pixel value. */
/* */
void get_pixel( void )
{
save_regs(); /* Save a copy of current regs */
banner( "GET PIXEL" );
dputs( " Pixel Address: X: " );
putnum( ax );
dputs( " Y: " );
putnum( bx );
crlf();
_DL = 5; /* Return 5 as fake value */
}
/* ---------------------------- SETPIXEL ------------------------------- */
/* */
/* The SetPixel command is used to write a specific pixel to */
/* the graphics area. The input values are the coordinate of */
/* the pixel to write, and the pixel value to write. */
/* */
void set_pixel( void )
{
save_regs(); /* Save a copy of current regs */
banner( "SET PIXEL" );
dputs( " Pixel Address: X: " );
putnum( ax );
dputs( " Y: " );
putnum( bx );
dputs( " Value: " );
putnum( dl );
crlf();
}
/* ---------------------------- ESCAPE -------------------------------- */
void escape( void )
{
save_regs(); /* Save a copy of current regs */
banner( "ESCAPE" );
}
/* ---------------------------- TEXTSIZE ------------------------------- */
/* */
/* The textsize function allows the kernal to inquire the size */
/* of text strings. The input to the function is a pointer to */
/* text and the length of the string. The output is the horz */
/* and vert dimensions of the string in pixels. */
/* */
void textsiz( void )
{
char far * cptr;
int i;
save_regs(); /* Save a copy of current regs */
cptr = MK_FP( _ES, _BX ); /* Make a pointer to the text */
banner( "TEXT SIZE" );
dputs( " Input Text: \"" );
/* Read sting from the far memory to local memory. */
for( i=0 ; i<cx ; ++i ) Buffer[i] = *cptr++;
Buffer[i] = '\0'; /* Null terminate string */
dputs( Buffer );
dputs( "\"\r\n" );
_BX = cx * 8; /* Return default size info */
_CX = 8;
}
/* ---------------------------- COLOR_QUERY --------------------------- */
/* */
/* This function allows the kernal to inquire the size and base */
/* colors for the current device. */
/* */
void color_query( void )
{
int i;
save_regs(); /* Save a copy of current regs */
i = Stat_Block.fcolors & 0x7f; /* Get color info w/o flag bit */
banner( "QUERY COLOR" );
switch( al ){ /* Act on the input command */
case 0: /* Color palette size query */
dputs( " Color Table Size: (Size: " );
putnum( i );
dputs( " Maximum Color: " );
putnum( i-1 );
dputs( ")\r\n" );
_BX = i; /* Return the table size */
_CX = i - 1; /* Return the maximum color # */
break;
case 1: /* Default palette settings */
dputs( " Default Palette Query\r\n" );
_ES = _CS; /* Mask ES:BX point to default */
_BX = (unsigned int) &Default_Palette;
break;
default:
dputs( " ERROR: Unknown Color Query Command: " );
puthex( al );
crlf();
break;
}
}
/* ---------------------------- SETWINDOW ------------------------------ */
/* */
/* The setwindow function defines a VDC space on the output device */
/* The input to the function defines the VDC's to be set to the */
/* current clipping viewport. */
/* */
/* */
void setwindow( void )
{
save_regs(); /* Save a copy of current regs */
banner( "SETWINDOW" );
dputs( " Upper Left: X: " );
putnum( ax );
dputs( " Y: " );
putnum( bx );
dputs( " Lower Right: X: " );
putnum( cx );
dputs( " Y: " );
putnum( dx );
crlf();
}
/* ----------------------------- BANNER ------------------------------- */
/* */
/* This function sends a string to the console via a direct */
/* DOS Function 9. The string is place inside a standard banner */
/* before being sent to the console. */
/* */
void banner( char *string )
{
static char header[] = ">>> DEBUG: ";
dputs( header );
dputs( string );
crlf();
}
/* ----------------------------- PUTNUM ------------------------------- */
/* */
/* This function converts a number to a decimal ASCII string. */
/* The string is then sent to the console via a DPUTS command. */
/* */
void putnum( unsigned number ) /* Output Decimal Number */
{
static char numstr[10] = "XXXXXXXX"; /* String for conversion space */
itoa( number, numstr, 10 ); /* Convert to decimal string */
dputs( numstr ); /* Send number to console */
}
/* ----------------------------- PUTHEX ------------------------------- */
/* */
/* This function converts a number to a hexidecimal ASCII string. */
/* The string is then sent to the console via a DPUTS command. */
/* */
void puthex( unsigned number ) /* Output Hexidecimal Number */
{
static char hextbl[] = "0123456789ABCDEF";
static char numstr[] = "XXXX"; /* String space for conversion */
numstr[3] = hextbl[ number & 0x000f ];
number >>= 4;
numstr[2] = hextbl[ number & 0x000f ];
number >>= 4;
numstr[1] = hextbl[ number & 0x000f ];
number >>= 4;
numstr[0] = hextbl[ number & 0x000f ];
dputs( numstr ); /* Send number to console */
}
/* ----------------------------- DPUTS -------------------------------- */
/* */
/* This function send a string to the console using DOS. */
/* */
void dputs( char far *str ) /* Output string to console */
{
char far *cptr = str; /* Point at input string */
while( *cptr ){ /* Send NULL terminated string */
_AH = 2; /* DOS Charater output function */
_DL = *cptr++; /* Pick up character to send */
geninterrupt( 0x21 ); /* Enter DOS to send character */
}
}
/* ----------------------------- CRLF --------------------------------- */
/* */
/* This function send a Carrage Return and Line Feed to the */
/* console. */
/* */
void crlf( void ) /* goto new line on screen */
{
static char str[] = "\r\n"; /* New line string to DOS */
dputs( str ); /* Send string to console */
}
/* ----------------------------- SAVEREGS ----------------------------- */
/* */
/* This function saves a copy of all of the input registers. */
/* This function is needed because C does hidden things with */
/* registers, which would require constant PUSH's and POP's. */
/* */
void save_regs( void ) /* Save registers into memory */
{
ax = _AX; al = _AL; ah = _AH;
bx = _BX; bh = _BH; bl = _BL;
cx = _CX; ch = _CH; cl = _CL;
dx = _DX; dh = _DH; dl = _DL;
}
