diff options
Diffstat (limited to 'tecterm.c')
| -rw-r--r-- | tecterm.c | 1579 |
1 files changed, 1579 insertions, 0 deletions
diff --git a/tecterm.c b/tecterm.c new file mode 100644 index 0000000..23b506f --- /dev/null +++ b/tecterm.c @@ -0,0 +1,1579 @@ +char *tecterm_c_version = "tecterm.c: $Revision: 1.1 $"; + +/* + * $Date: 2007/12/10 21:59:21 $ + * $Source: /cvsroot/videoteco/videoteco/tecterm.c,v $ + * $Revision: 1.1 $ + * $Locker: $ + */ + +/* tecterm.c + * Terminal Escape Sequence Subroutines (termcap/terminfo et all) + * + * COPYRIGHT (c) 1985-2003 BY + * PAUL CANTRELL & J. M. NISHINAGA + * SUDBURY, MA 01776 + * ALL RIGHTS RESERVED + * + * This software is furnished in it's current state free of charge. + * The authors reserve all rights to the software. Further + * distribution of the software is not authorized. Modifications to + * the software may be made locally, but shall not be distributed + * without the consent of the authors. This software or any other + * copies thereof, may not be provided or otherwise made available + * to anyone without express permission of the authors. Title to and + * ownership of this software remains with the authors. + * + */ + +#include "teco.h" +#include "tecparse.h" + +#ifdef TERMINFO +#include <curses.h> +#include <term.h> +#endif + +/* + * Global Storage is defined here for lack of a better place. + */ + +/* + * Global Variables + */ + extern int curx; + extern int cury; + extern int term_columns; + extern int term_lines; + char scr_outbuf[SCREEN_OUTPUT_BUFFER_SIZE]; + char *scr_outbuf_ptr; + int scr_outbuf_left; + char insert_delete_line_capability; + + void term_insert_line(); + void term_delete_line(); + void term_puts(); + int term_putc(int); + void term_flush(); + +#ifdef TERMCAP + char *tgetstr(); +#endif + +#ifdef TERMCAP + int termcap_co; + int termcap_li; + int termcap_sg; + char *termcap_cm; + char *termcap_ti; + char *termcap_te; + char *termcap_pc; + char *termcap_so; + char *termcap_se; + char *termcap_cd; + char *termcap_ce; + char *termcap_cs; + char *termcap_sf; + char *termcap_sr; + char *termcap_al; + char *termcap_dl; + char *termcap_AL_arg; + char *termcap_DL_arg; +#endif + +#ifdef TERMINFO + int terminfo_co; + int terminfo_li; + int terminfo_magic_cookie_glitch; +#endif + +/* + * External Routines, etc. + */ + + extern int term_speed; + extern char teco_startup; + extern int tty_input_chan; + extern int tty_output_chan; + +/* + * The following array gives the number of tens of milliseconds per + * character for each speed as returned by gtty. Thus since 300 + * baud returns a 7, there are 33.3 milliseconds per char at 300 baud. + */ +#ifdef TERMCAP +static +short tmspc10[] = { + 0, 2000, 1333, 909, 743, 666, 500, 333, 166, 83, 55, 41, 20, 10 +}; +#endif + +/* TERM_INIT - Initialize the terminal for cursor operations + * + * Function: + * + * This entry point gives the terminal package a chance to initialize + * the terminal for cursor type operations. + */ +void +term_init() +{ +/* + * Initialize our output buffer. + */ + scr_outbuf_ptr = scr_outbuf; + scr_outbuf_left = SCREEN_OUTPUT_BUFFER_SIZE; + +#ifdef TERMCAP +/* + * "TI - String to begin programs that use cm" + */ + term_puts(termcap_ti,1); + +/* + * Set a fast flag which says whether or not terminal is capable of insert and + * delete line functions. + */ + insert_delete_line_capability = 1; + + if(termcap_dl == NULL && termcap_DL_arg == NULL){ + insert_delete_line_capability = 0; + }/* End IF */ + + if(termcap_al == NULL && termcap_AL_arg == NULL){ + insert_delete_line_capability = 0; + }/* End IF */ + + if(termcap_cs && termcap_sf && termcap_sr){ + insert_delete_line_capability = 1; + }/* End IF */ +#endif + +#ifdef TERMINFO +/* + * Initialize terminfo package + */ + setupterm((char *)0, 1, (int*)0); + + insert_delete_line_capability = 1; + + if(parm_insert_line == NULL && insert_line == NULL){ + insert_delete_line_capability = 0; + }/* End IF */ + + if(parm_delete_line == NULL && delete_line == NULL){ + insert_delete_line_capability = 0; + }/* End IF */ + + if(change_scroll_region && scroll_forward && scroll_reverse){ + insert_delete_line_capability = 1; + }/* End IF */ + + terminfo_magic_cookie_glitch = magic_cookie_glitch > 0 ? + magic_cookie_glitch : 0; + +#endif + +}/* End Routine */ + + + +/* TERM_FINISH - Here when we are exiting the editor + * + * Function: + * + * This routine is called when TECO is being exited to give us a chance + * to cleanly leave the screen package. We put the cursor at the bottom + * of the screen, send any termination escape sequences that are required + * and flush it all out. + */ +void +term_finish() +{ + +/* + * We want to leave the cursor at the bottom of the screen + */ + term_goto(0,term_lines-1); + +#ifdef TERMCAP + +/* + * Output any termination escape sequences + */ + term_puts(termcap_te,1); + +#endif + +/* + * Now flush that all out + */ + term_flush(); + +}/* End Routine */ + + + +/* TERM_STANDOUT - Set standout mode on the terminal + * + * Function: + * + * This routine is called to set the highlighting standout + * mode. All characters output from now on will typically + * be reverse video, or whatever attribute the terminal uses. + */ +void +term_standout() +{ + +#ifdef TERMCAP + + if(!termcap_sg) term_puts(termcap_so,1); + +#endif + +#ifdef TERMINFO + + if(terminfo_magic_cookie_glitch <= 0){ + tputs(enter_standout_mode,1,term_putc); + } + +#endif + +}/* End Routine */ + +/* TERM_STANDEND - Clear standout mode on the terminal + * + * Function: + * + * This routine is called to reset the highlighting standout + * mode. All characters output from now on will be in the + * normal rendition mode. + */ +void +term_standend() +{ + +#ifdef TERMCAP + + if(!termcap_sg) term_puts(termcap_se,1); + +#endif + +#ifdef TERMINFO + + if(terminfo_magic_cookie_glitch <= 0){ + tputs(exit_standout_mode,1,term_putc); + } + +#endif + +}/* End Routine */ + +/* TERM_CLRTOEOL - Clear to End Of Line + * + * Function: + * + * This routine sends the ESCape sequence to clear all characters + * from the present position until the end of the line. + */ +void +term_clrtoeol() +{ +#ifdef TERMCAP + + term_puts(termcap_ce,1); + +#endif + +#ifdef TERMINFO + + tputs(clr_eol,1,term_putc); + +#endif + +}/* End Routine */ + +/* TERM_CLRTOBOT - Clear to End Of Screen + * + * Function: + * + * This routine sends the ESCape sequence to clear all characters + * from the present position until the end of the terminal screen. + */ +void +term_clrtobot() +{ + +#ifdef TERMCAP + + term_puts(termcap_cd,1); + + +#endif + +#ifdef TERMINFO + + tputs(clr_eos,1,term_putc); + +#endif + +}/* End Routine */ + + + +/* TERM_INSERT_LINE - Perform an insert-line terminal function + * + * Function: + * + * This routine is called to output the insert-line escape sequence. + * It checks to see what insert-line capabilities the terminal has, + * and tries to use the optimum one. + */ +void +term_insert_line(position,count) +int position; +register int count; +{ +/* + * Test whether the terminal supports an insert line escape sequence which + * takes an argument + */ +#ifdef TERMCAP + if(count > 1 && termcap_AL_arg){ + term_goto(0,position); + term_putnum(termcap_AL_arg,count,term_lines-position); + return; + }/* End IF */ +#endif + +#ifdef TERMINFO + if(count > 1 && parm_insert_line){ + term_goto(0,position); + tputs( + tparm(parm_insert_line,count), + term_lines-position, + term_putc + ); + return; + }/* End IF */ +#endif + +/* + * Ok, here if either the terminal does not support insert line with an + * argument, or if count happens to be 1 + */ +#ifdef TERMCAP + if(termcap_al){ + term_goto(0,position); + while(count--){ + term_puts(termcap_al,term_lines-position); + }/* End While */ + return; + }/* End IF */ +#endif + +#ifdef TERMINFO + if(insert_line){ + term_goto(0,position); + while(count--){ + tputs(insert_line,term_lines-position,term_putc); + }/* End While */ + return; + }/* End IF */ +#endif + + +/* + * Hmm, termcap_al must be undefined. That must mean that cs is defined and + * that we have to do this by using scroll regions. + */ + if(position) term_scroll_region(position,term_lines-1); + if(curx != 0 || cury != position) term_goto(0,position); + while(count--){ + +#ifdef TERMCAP + term_puts(termcap_sr,term_lines-position); +#endif + +#ifdef TERMINFO + tputs(scroll_reverse,term_lines-position,term_putc); +#endif + + }/* End While */ + if(position) term_scroll_region(0,term_lines-1); + +#ifdef TERMCAP + if(curx != 0 || cury != position) term_goto(0,term_lines-1); +#endif +#ifdef TERMINFO + curx = cury = -1; /* Unsure of present position... */ +#endif + +}/* End Routine */ + + + +/* TERM_DELETE_LINE - Perform an delete-line terminal function + * + * Function: + * + * This routine is called to output the delete-line escape sequence. + * It checks to see what delete-line capabilities the terminal has, + * and tries to use the optimum one. + */ +void +term_delete_line(position,count) +int position; +register int count; +{ + term_goto(0,position); + +/* + * Test whether the terminal supports an delete line escape sequence which + * takes an argument + */ +#ifdef TERMCAP + if(count > 1 && termcap_DL_arg){ + term_putnum(termcap_DL_arg,count,term_lines-position); + return; + }/* End IF */ +#endif + +#ifdef TERMINFO + if(count > 1 && parm_delete_line){ + term_goto(0,position); + tputs( + tparm(parm_delete_line,count), + term_lines-position, + term_putc + ); + return; + }/* End IF */ +#endif + +/* + * Ok, here if either the terminal does not support delete line with an + * argument, or if count happens to be 1 + */ +#ifdef TERMCAP + if(termcap_dl){ + while(count--){ + term_puts(termcap_dl,term_lines-position); + }/* End While */ + return; + }/* End IF */ +#endif + +#ifdef TERMINFO + if(delete_line){ + term_goto(0,position); + while(count--){ + tputs(delete_line,term_lines-position,term_putc); + }/* End While */ + return; + }/* End IF */ +#endif + +/* + * Hmm, termcap_dl must be undefined. That must mean that cs is defined and + * that we have to do this by using scroll regions. + */ + if(position) term_scroll_region(position,term_lines-1); + if(curx != 0 || cury != (term_lines-1)) term_goto(0,term_lines-1); + while(count--){ + +#ifdef TERMCAP + term_puts(termcap_sf,term_lines-position); +#endif + +#ifdef TERMINFO + tputs(scroll_forward,term_lines-position,term_putc); +#endif + + }/* End While */ + if(position) term_scroll_region(0,term_lines-1); + +#ifdef TERMCAP + if(curx != 0 || cury != (term_lines-1)) term_goto(0,term_lines-1); +#endif +#ifdef TERMINFO + curx = cury = -1; /* Unsure of present position... */ +#endif + + +}/* End Routine */ + + + +#ifdef TERMCAP + +/* TERM_PUTNUM - Output a termcap string which takes a single argument + * + * Function: + * + * This routine is called to output a termcap string which has an + * imbedded %d to be replaced with the single argument. + */ +int +term_putnum(termcap_string,argument,affected) +char *termcap_string; +int argument; +int affected; +{ +register char *cp; +register char *dp; +register int c; +static char result[40]; + + cp = termcap_string; + if(cp == NULL) return(FAIL); + dp = result; + +/* + * Loop until we hit the end of the string + */ + while((c = *cp++)){ + if(c != '%'){ + *dp++ = c; + continue; + }/* End IF */ + + switch(c = *cp++){ + case 'd': + if(argument < 10) goto one; + if(argument < 100) goto two; + /* fall through */ + case '3': + *dp++ = (argument / 100) + '0'; + argument %= 100; + /* fall through */ + case '2': +two: + *dp++ = argument / 10 | '0'; +one: + *dp++ = argument % 10 | '0'; + continue; + case '%': + *dp++ = c; + continue; + + case 'B': + argument = (argument/10 << 4) + argument%10; + continue; + + case 'D': + argument = argument - 2 * (argument%16); + continue; + case 'p': + cp++; /* eat p1, p2 type stuff */ + continue; + + default: + return(FAIL); + }/* End Switch */ + }/* End While */ + + *dp++ = '\0'; + term_puts(result,affected); + return(SUCCESS); + +}/* End Routine */ + +#endif + + + +#ifdef TERMCAP + +/* TERM_PUTS - Output a termcap string with padding + * + * Function: + * + * This routine is called to output a termcap string with padding added. + */ +void +term_puts(termcap_string,lines_affected) +register char *termcap_string; +int lines_affected; +{ +register int delay; +register int mspc10; + +/* + * If this termcap string is undefined, we can't do much for him. + */ + if(termcap_string == NULL) return; + +/* + * Convert the number representing the delay + */ + delay = 0; + while(isdigit((int)*termcap_string)){ + delay = delay * 10 + *termcap_string++ - '0'; + }/* End While */ + +/* + * If there is a decimal place, read up to one decimal and then + * eat all remaining decimal places. + */ + delay *= 10; + if(*termcap_string == '.'){ + termcap_string++; + if(isdigit((int)*termcap_string)) delay += *termcap_string - '0'; + while(isdigit((int)*termcap_string)) termcap_string++; + }/* End IF */ + +/* + * If the delay is followed by a `*', then multiply by the affected + * lines count. + */ + if(*termcap_string == '*'){ + termcap_string++; + delay *= lines_affected; + }/* End IF */ + +/* + * Output all the rest of the string + */ + while(*termcap_string){ + *scr_outbuf_ptr++ = *termcap_string++; + scr_outbuf_left -= 1; + if(scr_outbuf_left <= 0){ + term_flush(); + }/* End IF */ + }/* End While */ + +/* + * If no delay is needed, or we can't figure out what the output + * speed is, then we just give up on the delay. + */ + if(delay == 0) return; + if(term_speed <= 0) return; + if(term_speed >= (sizeof(tmspc10)/sizeof(tmspc10[0]))) return; + +/* + * Round up by half a character frame, and then do the delay. + */ + mspc10 = tmspc10[term_speed]; + delay += mspc10 / 2; + delay /= mspc10; + while(delay > 0){ + delay -= 1; + *scr_outbuf_ptr++ = *termcap_pc; + scr_outbuf_left -= 1; + if(scr_outbuf_left <= 0){ + term_flush(); + }/* End IF */ + }/* End While */ + +}/* End Routine */ + +#endif + + + +/* TERM_GOTO - Send sequence to position the terminal cursor + * + * Function: + * + * This routine provides direct cursoring capability by using the + * CM termcap/terminfo string. This string looks like a printf which + * must be interpreted by this code. This allows pretty much + * arbitrary terminal escape sequences to be supported. The meaning + * of the special characters in the string are: + * + * %d - Same as in printf + * %2 - like %2d + * %3 - like %3d + * %. - gives %c hacking special case characters + * %+x - like %c but adding x first + * + * The following codes affect the state but don't use up a value + * + * %>xy if value > x add y + * %r reverses row column + * %i increments row column (for one origin indexing) + * %% gives % + * %B BCD (2 decimal digits encoded in one byte) + * %D Delta Data (backwards bcd) + * + * all other characters simply get output + */ +int +term_goto(dest_x,dest_y) +int dest_x; +int dest_y; +{ +#ifdef TERMCAP +register char *cp; +register char *dp; +register int c; +register int which; +static char result[40]; +static char added[10]; +char *UP = NULL; +char *BC = NULL; +#endif /* TERMCAP */ + +#ifdef TERMCAP +int oncol = 0; +#endif /* TERMCAP */ + +#ifdef TERMINFO + if(cursor_address == NULL) return(FAIL); + tputs(tparm(cursor_address,dest_y,dest_x),1,term_putc); + curx = dest_x; + cury = dest_y; + return(SUCCESS); +#endif + +#ifdef TERMCAP + cp = termcap_cm; + + if(cp == NULL) return(FAIL); + dp = result; + which = dest_y; + + added[0] = '\0'; + + curx = dest_x; + cury = dest_y; + +/* + * Loop until we hit the end of the string + */ + while((c = *cp++)){ + if(c != '%'){ + *dp++ = c; + continue; + }/* End IF */ + + switch(c = *cp++){ + case 'p': + cp++; /* for p1, p2, or p<n>, eat the digit, because I don't understand what it means yet */ + continue; + case 'n': + dest_x ^= 0140; + dest_y ^= 0140; + goto setwhich; + case 'd': + if(which < 10) goto one; + if(which < 100) goto two; + /* fall through */ + case '3': + *dp++ = (which / 100) + '0'; + which %= 100; + /* fall through */ + case '2': + two: + *dp++ = which / 10 | '0'; + one: + *dp++ = which % 10 | '0'; + swap: + oncol = 1 - oncol; + setwhich: + which = oncol ? dest_x : dest_y; + continue; + + case '>': + if (which > *cp++) which += *cp++; + else cp++; + continue; + + case '+': + which += *cp++; + /* fall into... */ + + case '.': + if( + which == 0 || + which == CNTRL_D || + which == '\t' || + which == '\n' + ){ + if (oncol || UP){ + do { + (void) strcat( + added, + oncol ? (BC ? BC : "\b") : UP + ); + which++; + } while (which == '\n'); + }/* End IF */ + }/* End IF */ + + *dp++ = which; + goto swap; + + case 'r': + oncol = 1; + goto setwhich; + + case 'i': + dest_x++; + dest_y++; + which++; + continue; + + case '%': + *dp++ = c; + continue; + + case 'B': + which = (which/10 << 4) + which%10; + continue; + + case 'D': + which = which - 2 * (which%16); + continue; + + default: +fprintf(stderr,"\n\r\n\rBad char in TGOTO string: %c\n",c); +sleep(5); + return(FAIL); + }/* End Switch */ + }/* End While */ + + (void) strcpy(dp,added); + term_puts(result,1); + return(SUCCESS); + +#else + return(SUCCESS); +#endif + + +}/* End Routine */ + + + +#ifdef TERMCAP + +/* TERM_SCROLL_REGION - Send sequence to set up a scroll region ala VT100 + * + * Function: + * + * This routine is identical to term_goto in most respects, except that + * it is sending the 'set scroll region' escape sequence instead of the + * cursor position sequence. The following escapes are defined for + * substituting row and column: + * + * %d - Same as in printf + * %2 - like %2d + * %3 - like %3d + * %. - gives %c hacking special case characters + * %+x - like %c but adding x first + * + * The following codes affect the state but don't use up a value + * + * %>xy if value > x add y + * %r reverses row column + * %i increments row column (for one origin indexing) + * %% gives % + * %B BCD (2 decimal digits encoded in one byte) + * %D Delta Data (backwards bcd) + * + * all other characters simply get output + */ +int +term_scroll_region(top,bottom) +int top; +int bottom; +{ +register char *cp; +register char *dp; +register int c; +register int which; +int onbottom = 0; +static char result[40]; +static char added[10]; + +char *UP = NULL; +char *BC = NULL; + + cp = termcap_cs; + if(cp == NULL) return(FAIL); + dp = result; + which = top; + + added[0] = '\0'; + + curx = -1; + cury = -1; + +/* + * Loop until we hit the end of the string + */ + while((c = *cp++)){ + if(c != '%'){ + *dp++ = c; + continue; + }/* End IF */ + + switch(c = *cp++){ + case 'n': + top ^= 0140; + bottom ^= 0140; + goto setwhich; + case 'd': + if(which < 10) goto one; + if(which < 100) goto two; + /* fall through */ + case '3': + *dp++ = (which / 100) + '0'; + which %= 100; + /* fall through */ + case '2': +two: + *dp++ = which / 10 | '0'; +one: + *dp++ = which % 10 | '0'; +swap: + onbottom = 1 - onbottom; +setwhich: + which = onbottom ? bottom : top; + continue; + + case '>': + if (which > *cp++) which += *cp++; + else cp++; + continue; + + case '+': + which += *cp++; + /* fall into... */ + + case '.': + if( + which == 0 || + which == CNTRL_D || + which == '\t' || + which == '\n' + ){ + if (onbottom || UP){ + do { + (void) strcat( + added, + onbottom ? (BC ? BC : "\b") : UP + ); + which++; + } while (which == '\n'); + }/* End IF */ + }/* End IF */ + + *dp++ = which; + goto swap; + + case 'r': + onbottom = 1; + goto setwhich; + + case 'i': + top++; + bottom++; + which++; + continue; + + case '%': + *dp++ = c; + continue; + + case 'B': + which = (which/10 << 4) + which%10; + continue; + + case 'D': + which = which - 2 * (which%16); + continue; + + default: + return(FAIL); + }/* End Switch */ + }/* End While */ + + (void) strcpy(dp,added); + term_puts(result,1); + return(SUCCESS); + +}/* End Routine */ + +#endif + +#ifdef TERMINFO + +/* TERM_SCROLL_REGION - Set up a scroll region + * + * Function: + * + * This routine is called to set up a scrolling region on the + * terminal. This is typically being used to emulate insert/delete + * line. + */ +int +term_scroll_region(top,bottom) +int top; +int bottom; +{ + if(change_scroll_region == NULL) return(FAIL); + + tputs(tparm(change_scroll_region,top,bottom),1,term_putc); + return(SUCCESS); + +}/* End Routine */ + +#endif + + + +/* TERM_PUTC - Output a single character + * + * Function: + * + * This routine is called to output a single character to the screen + * output buffer. If this fills the output buffer, flush the buffer. + */ +int +term_putc(data) +//char data; +int data; +{ + *scr_outbuf_ptr++ = data; + scr_outbuf_left -= 1; + + if(scr_outbuf_left <= 0){ + term_flush(); + }/* End IF */ + + return( data ); + +}/* End Routine */ + +/* TERM_FLUSH - Flush any data in the output buffer + * + * Function: + * + * This routine flushes any bytes sitting in the screen output + * buffer to the terminal. + */ +void +term_flush() +{ + register int i; + + i = SCREEN_OUTPUT_BUFFER_SIZE - scr_outbuf_left; + +#ifdef UNIX + if(i) write(tty_output_chan,scr_outbuf,(unsigned)i); +#endif + +#ifdef VMS + if(i){ + i = sys$qiow(0,tty_output_chan,IO$_WRITEVBLK|IO$M_NOFORMAT,0,0,0, + scr_outbuf,i,0,0,0,0); + if(!(i & STS$M_SUCCESS)) exit(i); + }/* End IF*/ +#endif + + scr_outbuf_left = SCREEN_OUTPUT_BUFFER_SIZE; + scr_outbuf_ptr = scr_outbuf; + +}/* End Routine */ + + + +/* INIT_TERMCAP - Read in the termcap description of the tty + * + * Function: + * + * This routine looks up the terminal description in the termcap file, and + * sets up the stuff for the screen package. It also checks that the tty + * has certain basic capabilities that we require. + */ +int +init_term_description() +{ + char termcap_description_buffer[TERMCAP_BUFFER_SIZE]; + char *terminal_name; +#ifdef TERMCAP + char *cp; +#endif + char temp_string[256]; + register int status; + + if(teco_startup == NO) return( SUCCESS ); + + if((terminal_name = getenv("TECO_TERM")) == NULL){ + if((terminal_name = getenv("TERM")) == NULL){ + tec_error(ENOENT,"Environment variable TERM not found"); + }/* End IF */ + }/* End IF */ + + status = tgetent(termcap_description_buffer,terminal_name); + if(status == -1) tec_error(EIO,"Cannot read termcap file"); + if(status == 0){ + sprintf(temp_string,"No termcap entry for terminal type %s", + terminal_name); + tec_error(ESRCH,temp_string); + }/* End IF */ + +/* + * Determine how many rows and columns this terminal has. If either number + * is already non-zero, then it has been set up by some previous code that + * really knows the size of the terminal window, and in this case, we will + * leave it alone. + */ +#ifdef TERMCAP + if(!term_columns) term_columns = tgetnum("co"); + if(!term_lines) term_lines = tgetnum("li"); +#endif + +#ifdef TERMINFO + if(!term_columns) term_columns = tgetnum("columns"); + if(!term_lines) term_lines = tgetnum("lines"); +#endif + +#ifdef TERMCAP +/* + * Now we read the escape sequence description strings for termcap + */ + +/* + * CM is the basic cursor movement string. This allows you to position the + * cursor to any line,column on the terminal. + */ + cp = &temp_string[0]; + termcap_cm = NULL; + if(tgetstr("cm",&cp)){ + termcap_cm = tec_alloc(TYPE_C_CPERM,strlen(temp_string)+1); + if(termcap_cm == NULL) return(FAIL); + (void) strcpy(termcap_cm,temp_string); + }/* End IF */ + else { + tec_error(ENOTTY,"?TECO: Terminal does not support cursor addressing"); + }/* End Else */ + +/* + * TI is a string which needs to be output at init time by programs + * which are going to use CM + */ + cp = &temp_string[0]; + termcap_ti = NULL; + if(tgetstr("ti",&cp)){ + termcap_ti = tec_alloc(TYPE_C_CPERM,strlen(temp_string)+1); + if(termcap_ti == NULL) return(FAIL); + (void) strcpy(termcap_ti,temp_string); + }/* End IF */ + +/* + * TE is a string which needs to be output before exit time by programs + * which have been using CM + */ + cp = &temp_string[0]; + termcap_te = NULL; + if(tgetstr("te",&cp)){ + termcap_te = tec_alloc(TYPE_C_CPERM,strlen(temp_string)+1); + if(termcap_te == NULL) return(FAIL); + (void) strcpy(termcap_te,temp_string); + }/* End IF */ + +/* + * PC is the padd character which is used to fill for terminals which + * require some time after certain sequences. + */ + cp = &temp_string[0]; + termcap_pc = NULL; + if(tgetstr("pc",&cp)){ + termcap_pc = tec_alloc(TYPE_C_CPERM,strlen(temp_string)+1); + if(termcap_pc == NULL) return(FAIL); + (void) strcpy(termcap_pc,temp_string); + }/* End IF */ + else termcap_pc = ""; + +/* + * SG is the number of screen locations it takes to set or clear + * standout mode. It alerts us to brain damaged magic cookie ttys + */ + termcap_sg = tgetnum("sg"); + if(termcap_sg < 0) termcap_sg = 0; + +/* + * SO is the string which will cause the terminal to enter reverse + * video (stand-out) mode. + */ + cp = &temp_string[0]; + termcap_so = NULL; + if(tgetstr("so",&cp)){ + termcap_so = tec_alloc(TYPE_C_CPERM,strlen(temp_string)+1); + if(termcap_so == NULL) return(FAIL); + (void) strcpy(termcap_so,temp_string); + }/* End IF */ + +/* + * SE is the string which will cause the terminal to leave reverse + * video (stand-out) mode and re-enter normal drawing mode. + */ + cp = &temp_string[0]; + termcap_se = NULL; + if(tgetstr("se",&cp)){ + termcap_se = tec_alloc(TYPE_C_CPERM,strlen(temp_string)+1); + if(termcap_se == NULL) return(FAIL); + (void) strcpy(termcap_se,temp_string); + }/* End IF */ + +/* + * CD is the string which will cause the terminal to clear from + * the present cursor location to the end of the screen + */ + cp = &temp_string[0]; + termcap_cd = NULL; + if(tgetstr("cd",&cp)){ + termcap_cd = tec_alloc(TYPE_C_CPERM,strlen(temp_string)+1); + if(termcap_cd == NULL) return(FAIL); + (void) strcpy(termcap_cd,temp_string); + }/* End IF */ + +/* + * CE is the string which will cause the terminal to clear from + * the present cursor location to the end of the current line + */ + cp = &temp_string[0]; + termcap_ce = NULL; + if(tgetstr("ce",&cp)){ + termcap_ce = tec_alloc(TYPE_C_CPERM,strlen(temp_string)+1); + if(termcap_ce == NULL) return(FAIL); + (void) strcpy(termcap_ce,temp_string); + }/* End IF */ + +/* + * cs is the string which will cause the terminal to change the scroll region + * This is mostly useful in emulating insert / delete line on vt100 terminals + */ + cp = &temp_string[0]; + termcap_cs = NULL; + if(tgetstr("cs",&cp)){ + termcap_cs = tec_alloc(TYPE_C_CPERM,strlen(temp_string)+1); + if(termcap_cs == NULL) return(FAIL); + (void) strcpy(termcap_cs,temp_string); + }/* End IF */ + +/* + * sf is the string which will cause the terminal to scroll forward. This is + * used in conjunction with scroll regions for delete line. + */ + cp = &temp_string[0]; + termcap_sf = NULL; + if(tgetstr("sf",&cp)){ + termcap_sf = tec_alloc(TYPE_C_CPERM,strlen(temp_string)+1); + if(termcap_sf == NULL) return(FAIL); + (void) strcpy(termcap_sf,temp_string); + }/* End IF */ + +/* + * sr is the string which will cause the terminal to scroll in reverse. This + * is used in conjunction with scroll regions for insert line. + */ + cp = &temp_string[0]; + termcap_sr = NULL; + if(tgetstr("sr",&cp)){ + termcap_sr = tec_alloc(TYPE_C_CPERM,strlen(temp_string)+1); + if(termcap_sr == NULL) return(FAIL); + (void) strcpy(termcap_sr,temp_string); + }/* End IF */ + +/* + * al is the string which will cause the terminal to insert a blank line at the + * present cursor location. + */ + cp = &temp_string[0]; + termcap_al = NULL; + if(tgetstr("al",&cp)){ + termcap_al = tec_alloc(TYPE_C_CPERM,strlen(temp_string)+1); + if(termcap_al == NULL) return(FAIL); + (void) strcpy(termcap_al,temp_string); + }/* End IF */ + +/* + * dl is the string which will cause the terminal to delete the current line. + * The following lines will all scroll up. + */ + cp = &temp_string[0]; + termcap_dl = NULL; + if(tgetstr("dl",&cp)){ + termcap_dl = tec_alloc(TYPE_C_CPERM,strlen(temp_string)+1); + if(termcap_dl == NULL) return(FAIL); + (void) strcpy(termcap_dl,temp_string); + }/* End IF */ + +/* + * AL is the string which will cause the terminal to insert a blank line at the + * present cursor location. + */ + cp = &temp_string[0]; + termcap_AL_arg = NULL; + if(tgetstr("AL",&cp)){ + termcap_AL_arg = tec_alloc(TYPE_C_CPERM,strlen(temp_string)+1); + if(termcap_AL_arg == NULL) return(FAIL); + (void) strcpy(termcap_AL_arg,temp_string); + }/* End IF */ + +/* + * DL is the string which will cause the terminal to delete the current line. + * The following lines will all scroll up. + */ + cp = &temp_string[0]; + termcap_DL_arg = NULL; + if(tgetstr("DL",&cp)){ + termcap_DL_arg = tec_alloc(TYPE_C_CPERM,strlen(temp_string)+1); + if(termcap_DL_arg == NULL) return(FAIL); + (void) strcpy(termcap_DL_arg,temp_string); + }/* End IF */ + +#endif + + return(SUCCESS); + +}/* End Routine */ + + + +#ifdef VMS +char *current_termcap_description; +char *termcap = +"d1|vt100-80|vt-100|dec vt100:\ +:co#80:li#24:cl=50\\E[;H\\E[2J:bs:am:cm=5\\E[%i%2;%2H:nd=2\\E[C:up=2\\E[A:\ +:ce=3\\E[K:cd=50\\E[J:so=2\\E[7m:se=2\\E[m:us=2\\E[4m:ue=2\\E[m:\ +:is=\\E>\\E[?3l\\E[?4l\\E[?5l\\E[?7h\\E[?8h:ks=\\E[?1h\\E=:ke=\\E[?1l\\E>:\ +:ku=\\E[A:kd=\\E[B:kr=\\E[C:kl=\\E[D:\ +:cs=\\E[%i%d;%dr:sf=5\\ED:\ +:kh=\\E[H:k1=\\EOP:k2=\\EOQ:k3=\\EOR:k4=\\EOS:pt:sr=5\\EM:xn:xv:"; + + +/* TGETENT - Version of TGETENT for Non-UNIX systems + * + * Function: + * + * This routine is used on non-UNIX systems to return a termcap + * description into the specified buffer. + */ +int +tgetent(buffer,term_name) +char *buffer; +char *term_name; +{ +register char *cp = NULL; +register char *dp; +char *temp_buffer = NULL; +char *termcap_filename; +FILE *fd; + +/* + * If current_termcap_description isn't set up yet, check for a logical + * name which points to a termcap file, and see if we can find the entry + * in there. + */ + if(current_termcap_description == NULL){ + termcap_filename = getenv("TERMCAP"); + if(termcap_filename != NULL){ + fd = fopen(termcap_filename,"r"); + if(fd != NULL){ + temp_buffer = malloc(TERMCAP_BUFFER_SIZE); + if(temp_buffer == NULL) return(FAIL); + if(scan_termcap(fd,temp_buffer,term_name)){ + cp = temp_buffer; + }/* End IF */ + fclose(fd); + }/* End IF */ + }/* End IF */ + }/* End IF */ + + if(cp == NULL) cp = termcap; + dp = current_termcap_description = buffer; + + while(*cp != NULL){ + if(cp[0] == '\\'){ + if(cp[1] == 'E' || cp[1] == 'e'){ + *dp++ = ESCAPE; + cp += 2; + continue; + }/* End IF */ + }/* End IF */ + + *dp++ = *cp++; + + }/* End While */ + + if(temp_buffer){ + free(temp_buffer); + temp_buffer = NULL; + }/* End IF */ + + return(1); + +}/* End Routine */ + +/* SCAN_TERMCAP - Attempt to find a terminal description in the termcap file + * + * Function: + * + * This routine scans the termcap file for an entry which matches our + * terminal, and returns non-zero if it finds it. + */ +scan_termcap(fd,temp_buffer,term_name) +FILE *fd; +char *temp_buffer; +char *term_name; +{ +register char *cp; +char *temp_name; +char status; + +/* + * Loop reading terminal descriptions into the buffer + */ + while(1){ + cp = temp_buffer; + bzero(cp,TERMCAP_BUFFER_SIZE); + if(fgets(cp,TERMCAP_BUFFER_SIZE,fd) == NULL) return(0); + if(*cp == '#') continue; +/* + * Ok, we have the start of an entry. Check for continuation. + */ + while(cp[0]){ + if(cp[0] == '\n'){ + cp[1] = '\0'; + break; + }/* End IF */ + if(cp[0] == '\\' && cp[1] == '\n'){ + if(fgets(cp,TERMCAP_BUFFER_SIZE-(cp-temp_buffer),fd) == NULL){ + cp[0] = '\n'; cp[1] = '\0'; + }/* End IF */ + }/* End IF */ + cp++; + }/* End While */ + + cp = temp_name = temp_buffer; + + while(*cp){ + if(*cp == '|'){ + *cp = '\0'; + status = strcmp(temp_name,term_name); + *cp = '|'; + if(status == 0) return(1); + cp++; + temp_name = cp; + continue; + }/* End IF */ + if(*cp == ':'){ + *cp = '\0'; + status = strcmp(temp_name,term_name); + *cp = ':'; + if(status == 0) return(1); + break; + }/* End IF */ + cp++; + }/* End While */ + + }/* End While */ + + return(0); + +}/* End Routine */ + + + +/* TGETNUM - Version of TGETNUM for Non-UNIX systems + * + * Function: + * + * This routine is used on non-UNIX systems to return a specific + * termcap number from the termcap description of our terminal. + */ +int +tgetnum(num_name) +char *num_name; +{ +register char *cp; +int temp; +char minus_seen = 0; + + cp = current_termcap_description; + if(strlen(num_name) != 2){ + fprintf(stderr,"TGETNUM: capability name %s should be 2 bytes long\n", + num_name); + exit(1); + }/* End IF */ + + for(cp = current_termcap_description; *cp != NULL; cp++){ + if(cp[0] != ':') continue; + if(cp[1] != num_name[0]) continue; + if(cp[2] != num_name[1]) continue; + + cp += 3; + if(*cp == '#') cp++; + temp = 0; + if(*cp == '-'){ + minus_seen = 1; + cp++; + }/* End IF */ + + while(isdigit(*cp)){ + temp = temp * 10 + *cp++ - '0'; + }/* End While */ + + if(minus_seen) temp = 0 - temp; + return(temp); + + }/* End FOR */ + + return(0); + +}/* End Routine */ + +/* TGETSTR - Version of TGETSTR for Non-UNIX systems + * + * Function: + * + * This routine is used on non-UNIX systems to return a specific + * termcap string from the termcap description of our terminal. + */ +char * +tgetstr(str_name,buffer_ptr) +char *str_name; +char **buffer_ptr; +{ +register char *cp; +register char *dp; +char *buffer; + + buffer = *buffer_ptr; + cp = current_termcap_description; + dp = buffer; + if(strlen(str_name) != 2){ + fprintf(stderr,"TGETSTR: capability name %s should be 2 bytes long\n", + str_name); + exit(1); + }/* End IF */ + + for(cp = current_termcap_description; *cp != NULL; cp++){ + if(cp[0] != ':') continue; + if(cp[1] != str_name[0]) continue; + if(cp[2] != str_name[1]) continue; + + cp += 3; + if(*cp == '=') cp += 1; + while(*cp != ':' && *cp != NULL){ + *dp++ = *cp++; + }/* End While */ + *dp++ = '\0'; + + return(buffer); + + }/* End FOR */ + + return(NULL); +} + +/* END OF VMS CONDITIONAL CODE */ + +#endif |