/*
* linemode.c
*
* Linemode Specific functions
*
* Quincey Koziol
*
* Date Notes
* --------------------------------------------
* 2/92 Started
*/
/*
* Includes
*/
#ifdef __TURBOC__
#include "turboc.h"
#endif
#ifdef MOUSE
#include "mouse.h"
#endif
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <fcntl.h>
#include <ctype.h>
#include <direct.h>
#include <time.h>
#include <conio.h>
#include <process.h>
#include <stdarg.h>
#include <bios.h>
#ifdef MSC
#include <malloc.h>
#endif
#ifdef CHECKNULL
#include <dos.h>
#endif
#include "whatami.h"
#include "nkeys.h"
#include "windat.h"
#include "hostform.h"
#include "protocol.h"
#include "data.h"
#include "confile.h"
#include "telopts.h"
#include "externs.h"
/*
* Macro definitions
*/
#define MAX_LINE_LEN 79
/*
* Static function declarations
*/
static int LMissep(int );
/*
* Static variable declarations
*/
static char bk[]={8,' ',8};
/**********************************************************************
* Function : LMissep()
* Purpose : Checks if a character is a word seperator for line mode
* word checking.
* Parameters :
* c - the character to check
* Returns : (1) for the character is a word seperator, (0) for false
* Calls : none
* Called by : LMgets()
**********************************************************************/
static int LMissep(int c)
{
if(isspace(c) || c=='_' || c=='*' || c=='!')
return(1);
return(0);
}
/**********************************************************************
* Function : LMgets()
* Purpose : Non-blocking gets(), This routine will continually add
* to a string that is re-submitted until a special
* character is hit. It never block the network from
* being serviced.
* This routine is structurally similar to RSgets() (in rspc.c)
* except that it uses the currently defined line mode
* editting characters instead of hard-wiring backspace,etc.
* Parameters :
* t - the telnet window structure
* Returns : none
* Calls :
* Called by : newkey()
**********************************************************************/
int LMgets(struct twin *t)
{
int lm_char, /* whether the character was handled by a linemode special character */
echo, /* whether to echo the characters typed */
vs, /* the virtual screen this telnet session is attached to */
c, /* the character typed */
count, /* the length of the line */
line_len, /* length of the line before we start erasing words */
found_sep, /* flag for end of word movements when editting line mode stuff */
found_nonsep; /* flag for word movements when editting line mode stuff */
char *save,
*s; /* pointer to the end of the line */
int i; /* local counting variable */
vs=t->vs; /* get the virtual screen */
echo=!t->echo; /* get the echo status */
count=strlen(t->linemode); /* set up the string variables */
save=t->linemode;
s=save+count;
while(0<(c=n_chkchar())) {
lm_char=0;
if(t->litflag) { /* check if the "literal character" flag is on */
if(c>31 && c<127) { /* check for printable ASCII */
if(echo)
VSwrite(vs,(char *)&c,1);
} /* end if */
else {
if(c>0 && c<27) { /* print ASCII control char */
if(echo) {
if(t->litecho) /* check for a literal echo of the character */
VSwrite(vs,(char *)&c,1);
else {
c+=64;
VSwrite(vs,"^",1);
VSwrite(vs,(char *)&c,1);
c-=64;
} /* end if */
} /* end if */
} /* end if */
} /* end else */
*s++=(char)c; /* add to string */
count++; /* length of string */
t->litflag=0; /* reset the literal flag */
continue; /* don't try to do anything else with the character */
} /* end if */
if(c==BACKSPACE || c==t->slc[SLC_EC]) { /* check for an "erase character" character */
#ifdef QAK
tprintf(console->vs,"erasing a character\r\n");
#endif
if(count) {
if(echo)
VSwrite(vs,bk,3);
count--; /* one less character */
s--; /* move pointer backward */
} /* end if */
lm_char=1; /* set the flag so we avoid the large switch */
} /* end if */
if(c==t->slc[SLC_EL]) { /* check for an "erase line" character */
if(echo)
for(i=0; i<s-save; i++)
VSwrite(vs,bk,3);
s=save;
lm_char=1; /* set the flag so we avoid the large switch */
} /* end if */
if(c==t->slc[SLC_EW]) { /* check for an "erase word" character */
#ifdef QAK
tprintf(console->vs,"erasing a word, s=%p\r\n",s);
#endif
if(count) {
found_sep=0; /* set the flag to indicate that we found another word seperator */
found_nonsep=0; /* set the flag to indicate we haven't found any non-seperators yet */
line_len=s-save;
s--; /* back to to the previous character */
for(i=0; i<line_len; i++) {
if(LMissep(*s)) { /* this is a line mode seperator */
if(found_nonsep) { /* if we've actually erased part of a word, stop now */
found_sep=1; /* indicate we found another word seperator */
s++; /* move to the character after the seperator */
break;
} /* end if */
} /* end if */
else {
if(!found_nonsep) /* check if we've previous found a word seperator */
found_nonsep=1;
} /* end if */
if(echo)
VSwrite(vs,bk,3);
count--; /* one less character */
s--; /* move pointer backward */
} /* end for */
} /* end if */
if(!found_sep) /* check for a word seperator found */
s=save;
#ifdef QAK
tprintf(console->vs,"done erasing a word, s=%p\r\n",s);
#endif
lm_char=1; /* set the flag so we avoid the large switch */
} /* end if */
if(!lm_char) { /* check if this character was already handled by a line mode special character */
switch(c) { /* allow certain editing chars */
#ifndef OLD_WAY
case 13:
case 9:
case TAB:
*s='\0'; /* terminate the string */
return(c);
#else
case TAB: /* check if we are doing local tab expansion */
case 9:
if(t->softtab) { /* check whether we are supposed to expand this tab */
} /* end if */
else {
} /* end else */
break;
case 13:
*s='\0'; /* terminate the string */
return(c);
#endif
default:
if(count==MAX_LINE_LEN) { /* to length limit */
RSbell(vs);
*s='\0'; /* terminate */
return(0);
} /* end if */
if(c>31 && c<127) { /* check for printable ASCII */
if(echo)
VSwrite(vs,(char *)&c,1);
*s++=(char)c; /* add to string */
count++; /* length of string */
} /* end if */
else {
if(c>0 && c<27) { /* print ASCII control char */
if(echo) {
if(t->litecho) /* check if we are supposed to echo this echo literally */
VSwrite(vs,(char *)&c,1);
else {
c+=64;
VSwrite(vs,"^",1);
VSwrite(vs,(char *)&c,1);
c-=64;
} /* end else */
} /* end if */
} /* end if */
*s='\0'; /* terminate the string */
return(c);
} /* end else */
break;
} /* end switch */
} /* end if */
} /* end while */
*s='\0'; /* terminate the string */
return(c);
} /* end LMgets() */
/**********************************************************************
* Function : LMinterp_char()
* Purpose : Interpret a character according to the current settings
* for the line mode special characters
* Parameters :
* t - the telnet window structure
* c - the character to interpret
* Returns : (1) - for no further process on the character being
* necessary, (0) for further processing allowed
* Calls :
* Called by : newkey()
**********************************************************************/
int LMinterp_char(struct twin *t,int c)
{
int char_handled=0; /* flag to indicate that no further processing is need for the character */
if(t->litflag) { /* transmit this character with no processing */
t->litflag=0; /* reset the literal flag */
strchar(t->linemode,(char)c);
char_handled=1; /* set the flag to indicate to further processing is not needed for this character */
} /* end if */
else { /* interpret this character */
if(c==13) {
#ifdef QAK
tprintf(console->vs,"c=%d, t->linemode=%s\r\n",(int)c,t->linemode);
#endif
parse(t,"\r\n",2); /* echo the return */
strcat(t->linemode,"\n");
netpush(t->pnum);
netwrite(t->pnum,t->linemode,strlen(t->linemode));
t->linemode[0]='\0';
char_handled=1; /* set the flag to indicate to further processing is not needed for this character */
} /* end if */
if(t->trapsig) { /* check if we are supposed to trap telnet signals */
if(c==t->slc[SLC_BRK]) { /* send telnet BRK command */
netprintf(t->pnum,"%c%c",IAC,BREAK);
tprintf(console->vs,"SEND: IAC BREAK\r\n");
char_handled=1; /* set the flag to indicate to further processing is not needed for this character */
} /* end if */
if(c==t->slc[SLC_IP]) { /* send telnet interrupt process command */
netprintf(t->pnum,"%c%c",IAC,IP);
tprintf(console->vs,"SEND: IAC IP\r\n");
char_handled=1; /* set the flag to indicate to further processing is not needed for this character */
} /* end if */
if(c==t->slc[SLC_AO]) { /* send telnet about output command */
netprintf(t->pnum,"%c%c",IAC,AO);
tprintf(console->vs,"SEND: IAC AO\r\n");
char_handled=1; /* set the flag to indicate to further processing is not needed for this character */
} /* end if */
if(c==t->slc[SLC_AYT]) { /* send telnet AYT command */
netprintf(t->pnum,"%c%c",IAC,AYT);
tprintf(console->vs,"SEND: IAC AYT\r\n");
char_handled=1; /* set the flag to indicate to further processing is not needed for this character */
} /* end if */
if(c==t->slc[SLC_ABORT]) { /* send telnet abort process command */
netprintf(t->pnum,"%c%c",IAC,ABORT);
tprintf(console->vs,"SEND: IAC ABORT\r\n");
char_handled=1; /* set the flag to indicate to further processing is not needed for this character */
} /* end if */
if(c==t->slc[SLC_EOF]) { /* send telnet EOF command */
netprintf(t->pnum,"%c%c",IAC,TEL_EOF);
tprintf(console->vs,"SEND: IAC EOF\r\n");
char_handled=1; /* set the flag to indicate to further processing is not needed for this character */
} /* end if */
if(c==t->slc[SLC_SUSP]) { /* send telnet suspend command */
netprintf(t->pnum,"%c%c",IAC,SUSP);
tprintf(console->vs,"SEND: IAC SUSP\r\n");
char_handled=1; /* set the flag to indicate to further processing is not needed for this character */
} /* end if */
} /* end if */
if(c==t->slc[SLC_FORW1] || c==t->slc[SLC_FORW2]) { /* pass the current string and the "forward" character immediately */
strchar(t->linemode,(char)c);
netpush(t->pnum);
netwrite(t->pnum,t->linemode,strlen(t->linemode));
t->linemode[0]='\0';
char_handled=1; /* set the flag to indicate to further processing is not needed for this character */
} /* end if */
if(c==t->slc[SLC_LNEXT]) { /* check for sending a literal character */
t->litflag=1; /* set the literal character flag */
char_handled=1; /* set the flag to indicate to further processing is not needed for this character */
} /* end if */
if(c==t->slc[SLC_XON]) { /* check for XON character */
strchar(t->linemode,(char)c); /* we don't support flow of control right now, so just append the character to the line */
char_handled=1; /* set the flag to indicate to further processing is not needed for this character */
} /* end if */
if(c==t->slc[SLC_XOFF]) { /* check for XOFF character */
strchar(t->linemode,(char)c); /* we don't support flow of control right now, so just append the character to the line */
char_handled=1; /* set the flag to indicate to further processing is not needed for this character */
} /* end if */
if(c==t->slc[SLC_RP]) { /* check for RP character */
VSredraw(t->vs,0,0,79,numline); /* kinda a kludge, instead of just re-displaying the line, we re-display the entire screen */
char_handled=1; /* set the flag to indicate to further processing is not needed for this character */
} /* end if */
} /* end else */
return(char_handled); /* return whether we handled the character */
} /* end LMinterp_char() */
