www.pudn.com > Îļþ»Ö¸´¼°ÐÞ²¹ C ÓïÑÔÔ´³ÌÐò.zip > MISC.C
#define F10 68
#include "stdio.h"
#include "b:header.c"
clrstf() /* clear s/f line pointers */
{
extern char *sfl1[], *sfl2[], *sfl3[], blnk9[], blnk16[],
constat[], fctkys[], discon[], conn[], hngup[], cparams[],
partmp[];
extern int connect, directry;
int i;
*(sfl1 + 1) = blnk16;
if ((modstat() & 0x80) == 0)
{
connect = 0;
*(sfl2) = discon;
*(sfl3) = blnk16;
if (directry)
{ /* restore parameters */
directry = 0;
for (i = 0; i < 49; i++) cparams[i] = partmp[i];
}
}
else{
connect = 1;
*(sfl2) = conn;
*(sfl3) = hngup;
}
*(sfl2 + 1) = blnk16;
*(sfl3 + 1) = blnk16;
for (i = 2; i < 7; i++)
{
*(sfl2 + i) = blnk9;
*(sfl3 + i) = blnk9;
}
}
getkey() /* get key from keyboard */
{
extern int uomode;
int c;
if (uomode) return(1);
printc((c = getkee()));
return(c);
}
entrsel(line, col) /* put ENTER SELECTION on line,col */
int line, col;
{
extern char ensel[];
poscur(line, col);
printxt(ensel);
}
poscur(row, col) /* cursor positioning routine */
int row, col;
{
struct regval srv, rrv;
srv.bx = 0;
srv.ax = 0x0200;
srv.dx = ((row - 1) << 8) + (col - 1);
sysint(16, &srv, &rrv);
}
clrwndw(r1, c1, r2, c2) /* clear window r1,c1 to r2,c2 */
int r1, c1, r2, c2;
{
struct regval srv, rrv;
srv.cx = ((r1 - 1) << 8) + (c1 - 1);
srv.dx = ((r2 - 1) << 8) + (c2 - 1);
srv.bx = 0x0700;
srv.ax = 0x0600;
sysint(16, &srv, &rrv);
poscur(r1, c1);
}
initm() /* initialize modem - do nothing for now */
{
return;
}
clrscr() /* clear screen */
{
struct regval srv, rrv;
srv.ax = 0x0600;
srv.cx = 0;
srv.dx = 0x184f;
srv.bx = 0x0700;
sysint(16, &srv, &rrv);
poscur(22, 1);
srv.bx = 0;
srv.cx = 79;
srv.ax = 0x0ACD;
sysint(16, &srv, &rrv); /* draw line */
}
space(i) /* space cursor over */
int i;
{
int row, col;
curpos(&row, &col);
poscur(row, col + i);
}
sfdispl() /* display status/function lines */
{
extern char *sfl1[], *sfl2[], *sfl3[];
int i, row, col;
curpos(&row, &col);
poscur(23, 1);
for (i = 0; i < 3; i++) printxt(sfl1[i]);
putchar('\n');
for (i = 0; i < 7; i++) printxt(sfl2[i]);
putchar('\n');
for (i = 0; i < 7; i++) printxt(sfl3[i]);
poscur(row, col);
}
top(tspace, mspace, lines, text)
int tspace, mspace, lines;
char *text[];
{
int i;
extern int connect;
extern char *sfl2[], conn[], discon[];
clrwndw(1, 1, 21, 80); /* clear upper screen */
space(tspace); /* space over for title */
printxt(text[0]); /* menu title */
for (i = 1; i < lines; i++)
{ /* output menu */
space(mspace);
printxt(text[i]);
}
clrstf(); /* clear s/f line */
}
printxt(txtptr) /* txtptr is pointer to text string. if in normal
mode prints to screen; if in remote mode
prints to comm port */
char *txtptr;
{
printf("%s", txtptr); /* put remote test & call here later */
}
printc(c)
char c;
{
putchar(c); /* put remote test and call here later */
}
getline(lineb, len) /* getline from console */
char *lineb;
int len;
{
char key;
int k, i;
k = 0;
for (i = 0; i < len; i++) *(lineb + i) = 0; /* clear lnbuf */
while ((key = toupper(getkee())) != CR)
{ /* get console int5: */
if (key == ESC) return 0;
if ((key != BCKSP) && (k < (len-1)))
{*(lineb + (k++)) = key; printc(key); }
else if (key == BCKSP) { k--; printc(key); }
if (k < 0) k = 0;
}
*(lineb + k) = '\0'; /* mark end of string */
return (OK);
}
char *ldfile(name, mode, bufsiz) /* load file into buffer */
char *name, *mode;
int bufsiz;
{
extern char *edbuf;
char *ptr;
int *fd, i;
if ((fd = fopen(name, mode)) == 0) return 0;
i = 0;
zero(edbuf, bufsiz);
ptr = edbuf;
while(((*(ptr + i) = fgetc(fd)) != -1) && i < bufsiz) i++;
fclose(fd);
return(ptr);
}
svfile(name, mode, bufptr, bufsiz) /* save a file */
char *name, *mode, *bufptr;
int bufsiz;
{
int *fd, i;
if ((fd = fopen(name, mode)) == 0) return 0;
i = 0;
while((fputc(*(bufptr + i), fd) != EOF) && (i < bufsiz)) i++;
fclose(fd);
if (i < bufsiz) return 0;
return (OK);
}
match(xdir, xkw) /* find best match on key word */
char *xdir, *xkw;
{
int i, value, valu[24], best, shift, m, n, pass;
char *tdir, *dir, *kw;
for (i = 0; i < 24; i++) valu[i] = 0;
for (shift = 0; shift < 2; shift++) /* shift both directions */
{
for (i = 0; i < 24; i++)
{ /* compare on all 24 entries */
tdir = xdir + (i * 128); /* next entry */
if (*tdir == 0) continue; /* skip if entry is null */
for (m = 0; m < 10; m++)
{ /* shift up to 10 char positions */
pass = value = n = 0;
if (shift == 0)
{ /* shifting right */
dir = tdir + m;
kw = xkw;
}
else{ /* shifting left */
dir = tdir;
kw = xkw + m;
}
while ((*dir != 0) && (*kw != 0) && (pass < 20-m))
{
if ((*dir == *kw)&&(*dir!=' ')) n++;/* the test! */
else n = 0;
value += n*n; /* bump value */
dir++;
kw++'Q pass++;
}
valu[i] += value; /* accumulate values */
if(n==pass && *dir==0 && *kw==0)
{
valu[i] += 20; /* bonus */
if (m == 0) valu[i] += 100; /* extra bonus */
}
}
}
}
value = 0;
best = 0;
for (i = 0; i < 24; i++)
if (valu[i] > value)
{
value = valu[i];
best = i;
}
return (xdir + (best * 128));
}
sort(bufptr, ellen, numel) /* sort in alpha/num order */
char *bufptr;
int ellen, numel;
{
extern char *lnbuf;
int i, j, k;
char *tptr, *temp, *bottom;
zero(lnbuf, ellen+1);
temp = lnbuf;
tptr = bufptr;
for (k = 0; k < numel-1; k++)
{
for (j = 0; j < (numel-k-1); j++)
{
for (i = 0; i < ellen; i++)
{
if (*(tptr+i) > *(tptr+i+ellen))
{
movmem(tptr, temp, ellen);
movmem(tptr+ellen, tptr, ellen);
movmem(temp, tptr+ellen, ellen);
break;
}
if (*(tptr+i) != *(tptr+i+ellen)) break;
if (*(tptr+i) == 0) break;
}
tptr += ellen;
}
tptr = bufptr;
}
}
displn(ptr) /* display line on screen starting at beginning of
line. Cursor left at same position + 1 */
char *ptr;
{
char c;
extern char *start;
int brt, ul, row, col, i, j;
brt = ul = 0;
curpos(&row, &col);
while (*ptr < 3) ptr++;
c = *ptr; /* get actual character */
while(*(ptr-1) < 3) ptr--; /* include attr. */
i = col;
while (fwrdtst(ptr))
{ /* while not at end of line */
if (*ptr == BRTCODE) brt = 1;
else if (*ptr == ULCODE) ul = 1;
else if (*ptr == TAB)
{
printxt(" ");
i += 5;
brt = ul = 0;
}
else{
printce(*ptr, brt, ul);
brt = ul = 0;
if (i > 78) i = 78;
poscur(row, ++i);
}
ptr++;
}
brt = ul = 0;
j = 0;
while ((i++) < 80 && (j++ < 5)) /* this is for DELETE function */
printc(' ');
if (col == 80) col--;
if (c =} TAB) poscur(row, col+5);
else poscur(row, col+1);
if (*ptr == CTLZ) return 0;
return(OK);
}
char *nxtlast(dir, ptr) /* if dir = 1, moves pointer
forward 1 line else moves back 1 line */
int dir;
char *ptr;
{
extern char *start;
if (dir == NEXT)
{
while (fwrdtst(ptr)) ptr++;
if (*ptr == LF || *ptr == SLF) ptr++;
}
else{
if ((*ptr == LF || *ptr == SLF) && (ptr != start)) ptr--;
while ((*ptr != LF) && (ptr != start) && (*ptr != SLF)) ptr--;
if (ptr != start) ptr--;
else return(ptr);
while ((*ptr != LF) && (ptr != start) && (*ptr != SLF)) ptr--;
if (*ptr == LF || *ptr == SLF) ptr++;
}
return(ptr);
}
printce(c, b, u) /* print character with attribute */
char c;
int b, u;
{
int row, col;
struct regval srv, rrv;
srv.ax = 0x0900 + c;
srv.bx = 7; /* default - no attribute */
srv.cx = 1;
if (b == 1) srv.bx = 0x0F;
if (u == 1) srv.bx = srv.bx & 0x09;
sysint(16, &srv, &rrv);
}
getkee() /* used by editor - non-echoing */
{
long offset;
extern char *macbuf, *macptr, *sfl2[], *sfl3[], discon[], blnk16[],
source;
char c, *tptr, end;
extern int strtmac, defmac, usemac, lfunct, mtemp, blokvid, connect,
err;
int *fd, i, row, col;
end = 0xFF;
if (err) { drline(); err = 0; }
while(1)
{
if (usemac)
{
c = *(macptr++);
if (c != end)
{
if (*macptr == end) usemac = 0;
return(c);
}
usemac = 0;
}
if (lfunct)
{
lfunct = 0;
c = mtemp;
}
else c = bdos(7) & 0xFF;
if (c != 0)
{
if ((defmac) && (*macptr != end)) *(macptr++) = c;
return(c);
}
mtemp = bdos(7) & 0xFF; /* it was a 0, get next kek */
if ((mtemp < 16) || (mtemp > 50))
{ /* not alt-alpha */
if (mtemp == F10)
{ /* hang-up */
connect = 0;
modcon(0);
*(sfl2) = discon;
*(sfl3) = blnk16;
sfdispl();
return(bdos(7) & 0xFF);
}
lfunct = 1;
if ((defmac) && (*macptr != end)) *(macptr++) = 0;
return(c);
}
/* it is alt-alpha */
if (strtmac)
{ /* start mac is active */
if (mtemp == *(macbuf + 1))
{ /* its the right code */
defmac = 1;
strtmac = 0;
curpos(&row, &col);
poscur(22, 55); /* change message */
printc(*macbuf);
printxt(" KEY PROG IN PROCESS ");
*(macbuf + 22) = source;
poscur(row, col);
continue; /* get next key */
}
}
if (!defmac)
{ /* check to see if programmed key */
if ((fd = fopen("PROGKEYS.RVC", "rb")) != 0)
{ /* a macro file does exist */
fgetc(fd); /* ignore alpha */
offset = 127;
for (i = 0; i < 26; i++)
{
if (fgetc(fd) == mtemp) break; /* look for altcode */
fseek(fd, offset, 1);
}
if (i != 26)
{ /* programmed key! */
fseek(fd, -2L, 1); /* back-up */
fgets(macbuf, 128, fd); /* get macro */
if (source == *(macbuf + 22))
{
usemac = 1;
macptr = macbuf + 23;
}
else { wrongscr(*(macbuf+22)); err = 1; }
fclose(fd);
continue;
}
fclose(fd);
}
lfunct = 1; /* not programmed key */
return(0);
}
/* defmac is active */
if (mtemp == *(macbuf + 1))
{ /* terminate macro definition */
fd = fopen("PROGKEYS.RVC", "rwb");
offset = (*macbuf - 0x41) * 128;
fseek(fd, offset, 0);
*macptr = end;
macptr = macbuf;
for (i = 0; i < 128; i++)
fputc(*(macptr++), fd);
fclose(fd);
defmac = 0;
drline(); /* clear message */
}
}
}
curpos(row, col) /* 2e}urns row & col position of cursor */
int *row, *col;
{
struct regval srv, rrv;
srv.ax = 0x0300;
srv.bx = 0;
sysint(16, &srv, &rrv);
*row = (rrv.dx >> 8) +1;
*col = (rrv.dx & 0xFF) + 1;
}
opencl(type, ptr, bytes, count) /* type = 0; close buffer
= 1; open buffer
ptr = start of source address
bytes = # of bytes to open/close by
count = total # of bytes to move */
int type, bytes, count;
char *ptr;
{
if (type == 1)
movmem(ptr, (ptr + bytes), count+1);
else movmem(ptr, (ptr-bytes), count+1);
return;
}
scrolup(tline, bline) /* scroll edit window up 1 line */
int tline, bline;
{
struct regval srv, rrv;
srv.ax = 0x0601;
srv.cx = (tline-1) << 8;
srv.dx = ((bline-1) << 8) + 0x4F;
srv.bx = 0x0700;
sysint(16, &srv, &rrv);
}
char *lnend(ptr) /* finds end of line */
char *ptr;
{
while(fwrdtst(ptr)) ptr++;
return(ptr);
}
char *lnstrt(ptr) /* finds start of line */
char *ptr;
{
extern char *start;
if (ptr == start) return(ptr);
if(*ptr == LF || *ptr == SLF) ptr--;
while((*ptr != LF) && (ptr != start) && (*ptr != SLF)) ptr--;
if (*ptr == LF || *ptr == SLF) ptr++;
return(ptr);
}
getattr() /* returns attribute at cur. pos. */
{
struct regval srv, rrv;
srv.ax = 0x0800;
srv.bx = 0;
sysint(16, &srv, &rrv);
return(rrv.ax >> 8);
}
dispscr(ptr) /* displays screen */
char *ptr;
{
int i;
i = 0;
while((i < 21) && (displn(ptr) == OK))
{
ptr = nxtlast(NEXT, ptr);
i++;
printc('\n');
}
return(i+1); /* returns # of lines displayed */
}
scroldn(tline, bline) /* scroll down 1 line */
int tline, bline;
{
struct regval srv, rrv;
srv.ax = 0x0701;
srv.cx = (tline-1) << 8;
srv.dx = ((bline-1) << 8) + 0x4F;
srv.bx = 0x0700;
sysint(16, &srv, &rrv);
}
attribut() /* inserts attribute codes for new kbd input */
{
extern brtattr, ulattr;
extern char *fend, *bend, *mptr;
if(brtattr != 0)
{ /* insert bright code */
opencl(1, mptr, 1, (fend-mptr+1));
fend++;
*mptr = BRTCODE;
mptr++;
}
if (ulattr != 0)
{ /* insert underline code */
opencl(1, mptr, 1, (fend-mptr+1));
fend++;
*mptr = ULCODE;
mptr++;
}
if (fend >= bend) return 0;
return (OK);
}
zero(ptr, bytes)
char *ptr;
unsigned int bytes;
{
for ( ; bytes > 0; bytes--) *(ptr++) = 0;
}
bkuptst(ptr) /* back-up test */
char *ptr;
{
extern char *start;
if ((ptr != start) && (*(ptr-1) != LF) && (*(ptr-1) != SLF))
return(1);
return(0);
}
fwrdtst(ptr) /* forward test */
char *ptr;
{
if ((*ptr != LF) && (*ptr != CTLZ)
&& (*ptr != SLF) && (*ptr != INSMARK))
return(1);
return(0);
}
instst() /* insert mode test */
{
extern int insrt;
if (insrt == 1)
{
printc(7);
return(1);
}
return(0);
}
wrap(ptr) /* word wrap - ptr points to start of line */
char *ptr;
{
int i;
char *tptr;
i = 1;
while(*ptr != LF && *ptr != CTLZ)
{
if (*ptr > 8) i++;
if (*ptr == SLF) *ptr = SPACE;
if (*ptr == TAB) i += 4;
if (i > 76)
{
tptr = ptr;
while((*tptr != SPACE) && (bkuptst(tptr))) tptr--;
if (*tptr != SPACE)
{
tptr = ptr;
opencl(1, tptr, 1, (fend-tptr+1));
fend++;
}
*tptr = SLF;
i = 1;
ptr = tptr;
}
ptr++;
}
}
char lcntrl() /* RETURNS LINE CONTROL BYTE FOR UART */
{
extern char cparams[];
char x;
x = 0;
x = x + (cparams[0] - 0x30) - 5; /* word length */
x = x + (((cparams[1] - 0x30) - 1) << 2); /* stop bits */
x = x + ((cparams[2] - 0x30) << 3); /* parity enable */
x = x + ((cparams[3] - 0x30) << 4); /* parity sense */
return(x);
}
chkfile(fname) /* checks to see if file exists */
char *fname;
{
char *fcb;
fcb = makefcb(fname);
if (bdos(0x11, fcb) & 0xFF)
{
free(fcb);
return(OK);
}
clrwndw(17, 1, 21, 80);
space(10);
printxt("A file already exists by this name. If you wish to cancel\n");
space(10);
printxt("this command press . If you wish to erase the existing\n");
space(10);
printxt("file and create a new one with the same name, press any other\n");
space(10);
printxt("key. ");
if (getkee() == ESC)
{
free(fcb);
return(0);
}
clrwndw(17, 1, 21, 80);
bdos(0x13, fcb); /* erase file */
free(fcb);
return(OK);
}
edfield(len, fptr) /* edit field; len = field length */
/* fptr = pointer to start of field */
int len;
char *fptr;
{
int row, col, col1, insrt;
char *dptr, *tptr, c;
curpos(&row, &col);
col1 = col; /* left column */
dptr = tptr = fptr;
while (*dptr != '\0') printc(*dptr++);
poscur(row, col);
insrt = 0;
while ((c = toupper(getkee())) != CR)
{
curpos(&row, &col);
if (c =} 0)
{ /* edit key */
c = getkee();
if (c == RTAROW)
{
col++;
if (col >= col1 + len - 1) col--;
else{
tptr++;
poscur(row, col);
}
}
else if (c == LTAROW)
{
col--;
if (col < col1) col++;
else{
tptr--;
poscur(row, col);
}
}
else if (c == DELETE)
{
dptr = tptr;
while (*dptr++ != '\0') *(dptr-1) = *dptr;
dptr = tptr;
while (*dptr != '\0') pr{ntc(*dptr++);
printc(' ');
poscur(row, col);
}
else if (c == INSERT) insrt = !insrt;
}
else if (c == BCKSP)
{
col--;
if (col < col1) col++;
else{
tptr--;
poscur(row, col);
}
}
else if (insrt == 1)
{
dptr = fptr + len -2;
while (dptr-- != tptr) *(dptr+1) = *dptr;
*tptr = c;
dptr = tptr;
while (*dptr != '\0') printc(*dptr++);
if (tptr != (fptr + len - 2))
{
tptr++;
col++;
}
poscur(row, col);
}
else{
if (tptr == fptr + len -2)
{
*tptr = c;
printc(c);
poscur(row, col);
}
else{
*tptr++ = c;
printc(c);
}
}
}
}
wrongscr(c) /* wrong source messages for macros */
char c;
{
int row, col;
static char *wsrctxt[] = {
"FROM MAIN MENU", /* 0 */
"FROM TERMINAL CONNECTION MENU", /* 1 */
"FROM DIAL SEQUENCE MENU", /* 2 */
"IN TERMINAL EMULATION MODE", /* 3 */
"FROM FILE MAINTENANCE MENU", /* 4 */
"WHEN SPECIFYING A FILE NAME", /* 5 */
"FROM ANSWER TELEPHONE MENU", /* 6 */
"FROM HELP MENU", /* 7 */
"FROM REMOTE CONSOLE MENU", /* 8 */
"FROM TELEPHONE DIRECTORY MENU", /* 9 */
"WHEN ADDING A TEL. DIR. ENTRY", /* 10 */
"WHEN EDITING A FILE", /* 11 */
"WHEN SPECIFYING A KEYWORD", /* 12 */
"WHEN SPECIFYING A TELEPHONE NO.", /* 13 */
"WHEN SPECIFYING A LOG-ON SEQ.", /* 14 */
"WHEN SPECIFYING A FORMAT FIELD", /* 15 */
"FROM THE OPTIONS MENU", /* 16 */
"WHEN SPECIFYING OPTIONS", /* 17 */
"FROM PROGRAM KEYS MENU" }; /* 18 */
curpos(&row, &col);
poscur(22, 5);
printxt("THIS PROGRAMMED KEY MAY ONLY BE INITIATED ");
printxt(wsrctxt[c]);
poscur(row, col);
}
drline() /* draw line */
{
struct regval srv, rrv;
int row, col;
curpos(&row, &col);
posc](22, 1);
srv.bx = 0;
srv.cx = 79;
srv.ax = 0x0ACD;
sysint(16, &srv, &rrv);
poscur(row, col);
}
vde(n) /* VIEW DIRECTORY ENTRIES */
int n; /* 0 = keywords; 1 = all fields */
{
extern char *ppaktc, *ntdeoyd, *labels[], *edbuf, *teledir;
char *dirptr, *tptr, *start, *ldfile();
extern int fldlen[];
int i, j, k, row, col;
if (n == 0) i = 13;
else
{
i = 1;
clrstf();
sfdispl();
}
clrwndw(i, 1, 21, 80); /* clear lower display */
if (ldst(edbuf, teledir, 24, 0) == 0)
{
if (n == 0) return;
poscur(10, 5);
printxt(ntdeoyd); /* no telephone directory */
space(10);
printxt(ppaktc); /* press any key to continue */
getkey();
return(RDISMEN);
}
dirptr = edbuf;
i = k = 0;
while(*dirptr == 0)
{
k++;
dirptr += 128;
if (k == 24) break;
}
if (n == 0)
{
row = 15;
col = 8;
space(7);
printxt("Telephone Directory Keywords:");
for ( ; k < 24; k++)
{
poscur(row, col);
j = 0;
while((*(dirptr + j) != 0) && (j < 15))
printc(*(dirptr + (j++)));
if (++row == 21)
{
row = 15;
col += 17;
}
dirptr += 128;
}
}
else{
j = 0;
for ( ; k < 24; k++)
{
tptr = dirptr;
for (i = 0; i < 4; i++)
{
space(10);
printxt(labels[i]);
while(*tptr != '\0') printc(*tptr++);
printc('\n');
dirptr += fldlen[i];
tptr = dirptr;
}
printc('\n');
if ((++j == 4) && (k != 23))
{
j = 0;
space(20);
printxt(ppaktc);
if (getkee() == ESC) return(RDISMEN);
clrwndw(1, 1, 21, 80);
}
}
space(20);
printxt(ppaktc);
getkey();
}
return (RDISMEN);
}
ldst(ptr, file, recs, ls) /* fast load/store file routine */
char *ptr, *file; /* ls, 0 = load; 1 = store */
int recs, ls;
{
char *fcb;
struct segval sval;
struct regval srv, rrv;
if ((fcb = makefcb(file)) == 0) return 0;
if (bdos(0x0F, fcb) & 0xFF)
{
free(fcb);
return 0;
}
bdos(0x1A, ptr); /* set dta */
bdos(0x24, fcb); /* set random record field */
segread(&sval); /* get segment values */
if (ls == 0) srv.ax = 0x2700;
else srv.ax = 0x2800;
srv.xds = sval.ds; /* set data seg */
srv.dx = fcb;
srv.cx = recs;
sysint(0x21, &srv, &rrv);
if (ls == 1) bdos(0x10, fcb);
free(fcb);
return(OK);
}
char *exact(entry, dir) /* looks for exact directory match */
char *entry, *dir;
{
int i, j;
for (j = 0; j < 24; j++)
{
for (i = 0; i < 20; i++)
{
if (*(entry+i) != *(dir+i)) break;
}
if (i == 20) return (dir); /* exact match */
dir += 128;
}
return (0);
}