/* This file is properly part of the excellent DJGPP compiler/tools package

put out by DJ Delorie for use under DOS. Unfortunately, the module

as distributed in many versions of the DJGPP is buggy -- this copy

of gppconio.c fixes many of those bugs. I understand that these

changes have been sent back to the DJGPP maintainers -- hopefully

vile will not need to include this file in the future. -pgf 9/95

$Id: gppconio.c,v 1.5 2020/01/19 16:04:58 tom Exp $

*/

#if __DJGPP__ < 2

/**********************************************************************

*

* NAME: gppconio.c

*

* DESCRIPTION: simulate Borland text video funcs for GNU C++

*

* copyright (c) 1991 J. Alan Eldridge

*

* M O D I F I C A T I O N H I S T O R Y

*

* when who what

* -------------------------------------------------------------------

* 10/27/91 J. Alan Eldridge created

* 01/06/92 D. Buerssner make it work with extended characters

* (buers@dg1.chemie.uni-konstanz.de) speed-up of cputs

* some missing brackets in VIDADDR

* don't need scrollwindow anymore

* 07/15/93 D. Buerssner take care of cursor tracking

* txinfo.curx and txinfo.cury

* fill in missing functionality

* - textmode

* - cscanf

* - cgets

* - getch and ungetch

* - _setcursortype

* - kbhit

* (hpefully) proper initialization of

* txinfo.normattrib and txinfo.attribute

* gotoxy(1,1) in clrscr (bug introduced

* by my previous patches)

* gotoxy(1,1) in window

* take care of BELL and BACKSPACE

* in putch and cputs

* take care of blinking bit in textcolor

* and textbackground

* declare (and ignore) directvideo

* 10/09/93 DJ Delorie Switch to dosmem*() for DPMI

* 05/01/94 DJ Delorie Add _wscroll

*********************************************************************/

#include <stdlib.h>

#include <stdio.h>

#include <stdarg.h>

#include <dos.h>

#include <pc.h>

#include <go32.h>

#include "gppconio.h"

int _wscroll = 1;

int directvideo = 1; /* We ignore this */

static void setcursor(unsigned int shape);

static int getvideomode(void);

static void bell(void);

static int get_screenattrib(void);

static int isEGA(void);

static int _scan_getche(FILE *fp);

static int _scan_ungetch(int c, FILE *fp);

#define DBGGTINFO 0

static unsigned ScreenAddress = 0xb8000UL; /* initialize just in case */

static struct text_info txinfo;

static int ungot_char;

static int char_avail = 0;

#define VIDADDR(r,c) (ScreenAddress + 2*(((r) * txinfo.screenwidth) + (c)))

int

puttext(int c, int r, int c2, int r2, void *buf)

{

short *cbuf = (short *) buf;

/* we should check for valid parameters, and maybe return 0 */

r--, r2--, c--, c2--;

for (; r <= r2; r++) {

dosmemput(cbuf, (c2 - c + 1) * 2, VIDADDR(r, c));

cbuf += c2 - c + 1;

}

return 1;

}

int

gettext(int c, int r, int c2, int r2, void *buf)

{

short *cbuf = (short *) buf;

/* we should check for valid parameters, and maybe return 0 */

r--, r2--, c--, c2--;

for (; r <= r2; r++) {

dosmemget(VIDADDR(r, c), (c2 - c + 1) * 2, cbuf);

cbuf += c2 - c + 1;

}

return 1;

}

void

gotoxy(int col, int row)

{

ScreenSetCursor(row + txinfo.wintop - 2, col + txinfo.winleft - 2);

txinfo.curx = col;

txinfo.cury = row;

}

int

wherex(void)

{

int row, col;

ScreenGetCursor(&row, &col);

return col - txinfo.winleft + 2;

}

int

wherey(void)

{

int row, col;

ScreenGetCursor(&row, &col);

return row - txinfo.wintop + 2;

}

void

textmode(int mode)

{

union REGS regs;

int mode_to_set = mode;

if (mode == LASTMODE)

mode = mode_to_set = txinfo.currmode;

if (mode == C4350)

/*

* just set mode 3 and load 8x8 font, idea taken

* (and code translated from Assembler to C)

* form Csaba Biegels stdvga.asm

*/

mode_to_set = 0x03;

regs.h.ah = 0x00; /* set mode */

regs.h.al = mode_to_set;

int86(0x10, &regs, &regs);

if (mode == C80 || mode == BW80 || mode == C4350) {

if (isEGA()) {

/*

* enable cursor size emulation, see Ralf Browns

* interrupt list

*/

regs.h.ah = 0x12;

regs.h.bl = 0x34;

regs.h.al = 0x00; /* 0: enable (1: disable) */

int86(0x10, &regs, &regs);

}

}

if (mode == C4350) {

if (!isEGA())

return;

/* load 8x8 font */

regs.x.ax = 0x1112;

regs.x.bx = 0;

int86(0x10, &regs, &regs);

}

/* _setcursortype(_NORMALCURSOR); */

/* reinitialize txinfo structure to take into account new mode */

gppconio_init();

#if 0

/*

* For mode C4350 the screen is not cleared on my OAK-VGA.

* Should we clear it here? TURBOC doesn't so we don't bother either.

*/

clrscr();

#endif

}

void

textattr(int attr)

{

txinfo.attribute = ScreenAttrib = (unsigned char) attr;

}

void

textcolor(int color)

{

/* strip blinking (highest) bit and textcolor */

ScreenAttrib &= 0x70; /* strip blinking (highest) bit and textcolor */

txinfo.attribute = (ScreenAttrib |= (color & 0x8f));

}

void

textbackground(int color)

{

/* strip background color, keep blinking bit */

ScreenAttrib &= 0x8f;

/* high intensity background colors (>7) are not allowed

so we strip 0x08 bit (and higher bits) of color */

txinfo.attribute = (ScreenAttrib |= ((color & 0x07) << 4));

}

void

highvideo(void)

{

txinfo.attribute = (ScreenAttrib |= 0x08);

}

void

lowvideo(void)

{

txinfo.attribute = (ScreenAttrib &= 0x07);

}

void

normvideo(void)

{

txinfo.attribute = ScreenAttrib = txinfo.normattr;

}

void

_setcursortype(int type)

{

unsigned cursor_shape;

switch (type) {

case _NOCURSOR:

cursor_shape = 0x0700;

break;

case _SOLIDCURSOR:

cursor_shape = 0x0007;

break;

/* case _NORMALCURSOR: */

default:

cursor_shape = 0x0607;

break;

}

setcursor(cursor_shape);

}

static void

setcursor(unsigned int cursor_shape)

/* Sets the shape of the cursor */

{

union REGS reg;

reg.h.ah = 1;

reg.x.cx = cursor_shape;

int86(0x10, &reg, &reg);

} /* setcursor */

static void

getwincursor(int *row, int *col)

{

ScreenGetCursor(row, col);

}

void

clreol(void)

{

short image[256];

short val = ' ' | (ScreenAttrib << 8);

int c, row, col, ncols;

getwincursor(&row, &col);

ncols = txinfo.winright - col;

for (c = 0; c < ncols; c++)

image[c] = val;

puttext(col + 1, row + 1, txinfo.winright, row + 1, image);

}

static void

fillrow(int row, int left, int right, int fill)

{

int col;

short filler[right - left + 1];

for (col = left; col <= right; col++)

filler[col - left] = fill;

dosmemput(filler, (right - left + 1) * 2, VIDADDR(row, left));

}

void

clrscr(void)

{

short filler[txinfo.winright - txinfo.winleft + 1];

int row, col;

for (col = 0; col < txinfo.winright - txinfo.winleft + 1; col++)

filler[col] = ' ' | (ScreenAttrib << 8);

for (row = txinfo.wintop - 1; row < txinfo.winbottom; row++)

dosmemput(filler, (txinfo.winright - txinfo.winleft + 1) * 2,

VIDADDR(row, txinfo.winleft - 1));

gotoxy(1, 1);

}

int

putch(int c)

{

int row, col;

ScreenGetCursor(&row, &col);

/* first, handle the character */

if (c == '\n') {

row++;

} else if (c == '\r') {

col = txinfo.winleft - 1;

} else if (c == '\b') {

if (col > txinfo.winleft - 1)

col--;

else if (row > txinfo.wintop - 1) {

/*

* Turbo-C ignores this case; we are smarter.

*/

row--;

col = txinfo.winright - 1;

}

} else if (c == 0x07)

bell();

else {

/* short val = c | (ScreenAttrib << 8); */

/* puttext(col + 1, row + 1, col + 1, row + 1, &val); */

ScreenPutChar(c, ScreenAttrib, col, row);

col++;

}

/* now, readjust the window */

if (col >= txinfo.winright) {

col = txinfo.winleft - 1;

row++;

}

if (row >= txinfo.winbottom) {

/* scrollwin(0, txinfo.winbottom - txinfo.wintop, 1); */

if (_wscroll) {

ScreenSetCursor(txinfo.wintop - 1, 0);

delline();

}

row--;

}

ScreenSetCursor(row, col);

txinfo.cury = row - txinfo.wintop + 2;

txinfo.curx = col - txinfo.winleft + 2;

return c;

}

int

getche(void)

{

if (char_avail)

/*

* We don't know, whether the ungot char was already echoed

* we assume yes (for example in cscanf, probably the only

* place where ungetch is ever called.

* There is no way to check for this really, because

* ungetch could have been called with a character that

* hasn't been got by a conio function.

* We don't echo again.

*/

return (getch());

return (putch(getch()));

}

int

getch(void)

{

union REGS regs;

int c;

if (char_avail) {

c = ungot_char;

char_avail = 0;

} else {

regs.x.ax = 0x0700;

int86(0x21, &regs, &regs);

c = regs.h.al;

}

return (c);

}

int

ungetch(int c)

{

if (char_avail)

return (EOF);

ungot_char = c;

char_avail = 1;

return (c);

}

/*

* kbhit from libc in libsrc/c/dos/kbhit.s doesn't check

* for ungotten chars, so we have to provide a new one

* Don't call it kbhit, rather use a new name (_conio_kbhit)

* and do a #define kbhit _conio_kbhit in gppconio.h.

* The old kbhit still can be used if gppconio.h

* is not included of after #undef kbhit

* If you don't use ungetch (directly or indirectly by cscanf)

* both kbhit and _conio_kbhit are the same.

* So this shouldn't cause any trouble with previously written

* source, because ungetch wasn't available.

* The only problem might be, if anybody just included gppconio.h

* and has not linked with libpc, (I can't think of a good reason

* for this). This will result a link error (undefined symbol _conio_kbhit).

*/

#undef kbhit /* want to be able to call kbhit from libc */

/* The kbhit in libc doesn't work for the second byte of extended chars. */

int

kbhit(void)

{

union REGS regs;

regs.h.ah = 0x0b;

int86(0x21, &regs, &regs);

return regs.h.al ? -1 : 0;

}

int

_conio_kbhit(void)

{

if (char_avail)

return (1);

else

return (kbhit());

}

/*

* The next two functions are needed by cscanf

*/

static int

_scan_getche(FILE *fp)

{

return (getche());

}

static int

_scan_ungetch(int c, FILE *fp)

{

return (ungetch(c));

}

void

insline(void)

{

int row, col, left, right, nbytes, bot, fill;

ScreenGetCursor(&row, &col);

left = txinfo.winleft - 1;

right = txinfo.winright - 1;

nbytes = (right - left + 1) * 2;

bot = txinfo.winbottom - 1;

fill = ' ' | (ScreenAttrib << 8);

while (bot > row) {

movedata(_go32_conventional_mem_selector(), VIDADDR(bot - 1, left),

_go32_conventional_mem_selector(), VIDADDR(bot, left),

nbytes);

bot--;

}

if (row <= bot) {

fillrow(row, left, right, fill);

}

}

void

delline(void)

{

int row, col, left, right, nbytes, bot, fill;

ScreenGetCursor(&row, &col);

left = txinfo.winleft - 1;

right = txinfo.winright - 1;

nbytes = (right - left + 1) * 2;

bot = txinfo.winbottom - 1;

fill = ' ' | (ScreenAttrib << 8);

while (row < bot) {

movedata(_go32_conventional_mem_selector(), VIDADDR(row + 1, left),

_go32_conventional_mem_selector(), VIDADDR(row, left),

nbytes);

row++;

}

fillrow(bot, left, right, fill);

}

void

window(int left, int top, int right, int bottom)

{

if (top < 1 || left < 1 || right > txinfo.screenwidth ||

bottom > txinfo.screenheight)

return;

txinfo.wintop = top;

txinfo.winleft = left;

txinfo.winright = right;

txinfo.winbottom = bottom;

gotoxy(1, 1);

}

int

cputs(const char *s)

{

int row, col, c;

const unsigned char *ss = (const unsigned char *) s;

short *viaddr;

short sa = ScreenAttrib << 8;

ScreenGetCursor(&row, &col);

viaddr = (short *) VIDADDR(row, col);

/*

* Instead of just calling putch; we do everything by hand here,

* This is much faster. We don't move the cursor after each character,

* only after the whole string is written, because ScreenSetCursor

* needs to long because of switching to real mode needed with djgpp.

* You won't recognize the difference.

*/

while ((c = *ss++)) {

/* first, handle the character */

if (c == '\n') {

row++;

viaddr += txinfo.screenwidth;

} else if (c == '\r') {

col = txinfo.winleft - 1;

viaddr = (short *) VIDADDR(row, col);

} else if (c == '\b') {

if (col > txinfo.winleft - 1) {

col--;

viaddr--;

} else if (row > txinfo.wintop - 1) {

/*

* Turbo-C ignores this case. We want to be able to

* edit strings with backspace in gets after

* a linefeed, so we are smarter

*/

row--;

col = txinfo.winright - 1;

viaddr = (short *) VIDADDR(row, col);

}

} else if (c == 0x07)

bell();

else {

short q = c | sa;

dosmemput(&q, 2, (int) viaddr);

viaddr++;

col++;

}

/* now, readjust the window */

if (col >= txinfo.winright) {

col = txinfo.winleft - 1;

row++;

viaddr = (short *) VIDADDR(row, col);

}

if (row >= txinfo.winbottom) {

ScreenSetCursor(txinfo.wintop - 1, 0); /* goto first line in window */

delline(); /* and delete it */

row--;

viaddr -= txinfo.screenwidth;

}

}

ScreenSetCursor(row, col);

txinfo.cury = row - txinfo.wintop + 2;

txinfo.curx = col - txinfo.winleft + 2;

return (*(--ss));

}

int

cprintf(const char *fmt,...)

{

int cnt;

char buf[2048]; /* this is buggy, because buffer might be too small. */

va_list ap;

va_start(ap, fmt);

cnt = vsprintf(buf, fmt, ap);

va_end(ap);

cputs(buf);

return cnt;

}

char *

cgets(char *string)

{

unsigned len = 0;

unsigned int maxlen_wanted;

char *sp;

int c;

/*

* Be smart and check for NULL pointer.

* Don't know whether TURBOC does this.

*/

if (!string)

return (NULL);

maxlen_wanted = (unsigned int) ((unsigned char) string[0]);

sp = &(string[2]);

/*

* Should the string be shorter maxlen_wanted including or excluding

* the trailing '\0' ? We don't take any risk.

*/

while (len < maxlen_wanted - 1) {

c = getch();

/*

* should we check for backspace here?

* TURBOC does (just checked) but doesn't in cscanf (that's harder

* or even impossible). We do the same.

*/

if (c == '\b') {

if (len > 0) {

cputs("\b \b"); /* go back, clear char on screen with space

and go back again */

len--;

sp[len] = '\0'; /* clear the character in the string */

}

} else if (c == '\r') {

sp[len] = '\0';

break;

} else if (c == 0) {

/* special character ends input */

sp[len] = '\0';

ungetch(c); /* keep the char for later processing */

break;

} else {

sp[len] = putch(c);

len++;

}

}

sp[maxlen_wanted - 1] = '\0';

string[1] = (char) ((unsigned char) len);

return (sp);

}

int

cscanf(const char *fmt,...)

{

return (_doscan_low(NULL, _scan_getche, _scan_ungetch,

fmt, (void **) ((&fmt) + 1)));

}

int

movetext(int left, int top, int right, int bottom, int dleft, int dtop)

{

char *buf = malloc((right - left + 1) * (bottom - top + 1) * 2);

if (!buf)

return 0;

gettext(left, top, right, bottom, buf);

puttext(dleft, dtop, dleft + right - left, dtop + bottom - top, buf);

free(buf);

return 1;

}

static void

_gettextinfo(struct text_info *t)

{

int row, col;

t->winleft = t->wintop = 1;

t->winright = t->screenwidth = ScreenCols();

t->winbottom = t->screenheight = ScreenRows();

ScreenAttrib = t->attribute = t->normattr = get_screenattrib();

t->currmode = getvideomode();

ScreenGetCursor(&row, &col);

t->curx = col + 1;

t->cury = row + 1;

#if DBGGTINFO

printf("left=%2d,right=%2d,top=%2d,bottom=%2d\n", t->winleft,

t->winright, t->wintop, t->winbottom);

printf("scrht=%2d,scrwid=%2d,norm=%2x,mode=%2d,x=%2d,y=%2d\n",

t->screenheight, t->screenwidth, t->normattr, t->currmode,

t->curx, t->cury);

#endif

}

void

gettextinfo(struct text_info *t)

{

*t = txinfo;

#if DBGGTINFO

printf("left=%2d,right=%2d,top=%2d,bottom=%2d\n", t->winleft,

t->winright, t->wintop, t->winbottom);

printf("scrht=%2d,scrwid=%2d,norm=%2x,mode=%2d,x=%2d,y=%2d\n",

t->screenheight, t->screenwidth, t->normattr, t->currmode,

t->curx, t->cury);

#endif

}

static int

getvideomode(void)

{

int mode = ScreenMode();

/*

* in mode C80 we might have loaded a different font

*/

if (mode == C80)

if (ScreenRows() > 25)

mode = C4350;

return (mode);

}

static void

bell(void)

{

union REGS regs;

#if 0

/* use BIOS */

regs.h.ah = 0x0e; /* write */

regs.h.al = 0x07; /* bell */

int86(0x10, &regs, &regs);

#else

/* use DOS */

regs.h.ah = 0x06; /* write */

regs.h.dl = 0x07; /* bell */

int86(0x21, &regs, &regs);

#endif

}

static int

get_screenattrib(void)

{

union REGS regs;

regs.h.ah = 0x08; /* read character and attribute */

regs.h.bh = 0; /* video page 0 */

int86(0x10, &regs, &regs);

return (regs.h.ah & 0x7f); /* strip highest (BLINK) bit */

}

/* check if we have at least EGA (idea form Ralf Browns interrupt list) */

static int

isEGA(void)

{

union REGS regs;

regs.h.ah = 0x12;

regs.h.bl = 0x10;

regs.h.bh = 0xff;

int86(0x10, &regs, &regs);

return (regs.h.bh != 0xff);

}

extern int _gppconio_init;

void

gppconio_init(void)

{

static int oldattrib = -1;

if (oldattrib == -1)

oldattrib = get_screenattrib();

_gettextinfo(&txinfo);

if (txinfo.currmode == 7) /* MONO */

ScreenAddress = 0xb0000UL;

else

ScreenAddress = 0xb8000UL;

ScreenAttrib = txinfo.normattr = txinfo.attribute = oldattrib;

_gppconio_init = 1;

}

#endif /* __DJGPP__ < 2 */