# This is a shell archive. Remove anything before this line, # then unpack it by saving it in a file and typing "sh file". # # Wrapped by tralfaz!ove on Mon Nov 14 21:38:50 EST 1988 # Contents: tcap.c termio.c tipc.c vmsvt.c vt52.c window.c README.NeWS echo x - tcap.c sed 's/^@//' > "tcap.c" <<'@//E*O*F tcap.c//' /* tcap: Unix V5, V7 and BS4.2 Termcap video driver for MicroEMACS */ #define termdef 1 /* don't define "term" external */ #include #include "estruct.h" #include "edef.h" #if TERMCAP #define MARGIN 8 #define SCRSIZ 64 #define NPAUSE 10 /* # times thru update to pause */ #define BEL 0x07 #define ESC 0x1B extern int ttopen(); extern int ttgetc(); extern int ttputc(); extern int tgetnum(); extern int ttflush(); extern int ttclose(); extern int tcapkopen(); extern int tcapkclose(); extern int tcapmove(); extern int tcapeeol(); extern int tcapeeop(); extern int tcapbeep(); extern int tcaprev(); extern int tcapcres(); extern int tcapopen(); extern int tput(); extern char *tgoto(); #if COLOR extern int tcapfcol(); extern int tcapbcol(); #endif #define TCAPSLEN 315 char tcapbuf[TCAPSLEN]; char *UP, PC, *CM, *CE, *CL, *SO, *SE; TERM term = { NULL, /* these four values are set dynamically at open time */ NULL, NULL, NULL, MARGIN, SCRSIZ, NPAUSE, tcapopen, ttclose, tcapkopen, tcapkclose, ttgetc, ttputc, ttflush, tcapmove, tcapeeol, tcapeeop, tcapbeep, tcaprev, tcapcres #if COLOR , tcapfcol, tcapbcol #endif }; tcapopen() { char *getenv(); char *t, *p, *tgetstr(); char tcbuf[1024]; char *tv_stype; char err_str[72]; if ((tv_stype = getenv("TERM")) == NULL) { puts("Environment variable TERM not defined!"); exit(1); } if ((tgetent(tcbuf, tv_stype)) != 1) { sprintf(err_str, "Unknown terminal type %s!", tv_stype); puts(err_str); exit(1); } if ((term.t_nrow=(short)tgetnum("li")-1) == -1){ puts("termcap entry incomplete (lines)"); exit(1); } term.t_mrow = term.t_nrow; if ((term.t_ncol=(short)tgetnum("co")) == -1){ puts("Termcap entry incomplete (columns)"); exit(1); } term.t_mcol = term.t_ncol; p = tcapbuf; t = tgetstr("pc", &p); if(t) PC = *t; CL = tgetstr("cl", &p); CM = tgetstr("cm", &p); CE = tgetstr("ce", &p); UP = tgetstr("up", &p); SE = tgetstr("se", &p); SO = tgetstr("so", &p); if (SO != NULL) revexist = TRUE; if(CL == NULL || CM == NULL || UP == NULL) { puts("Incomplete termcap entry\n"); exit(1); } if (CE == NULL) /* will we be able to use clear to EOL? */ eolexist = FALSE; if (p >= &tcapbuf[TCAPSLEN]) { puts("Terminal description too big!\n"); exit(1); } ttopen(); } tcapkopen() { strcpy(sres, "NORMAL"); } tcapkclose() { } tcapmove(row, col) register int row, col; { putpad(tgoto(CM, col, row)); } tcapeeol() { putpad(CE); } tcapeeop() { putpad(CL); } tcaprev(state) /* change reverse video status */ int state; /* FALSE = normal video, TRUE = reverse video */ { static int revstate = FALSE; if (state) { if (SO != NULL) putpad(SO); } else if (SE != NULL) putpad(SE); } tcapcres() /* change screen resolution */ { return(TRUE); } spal(dummy) /* change palette string */ { /* Does nothing here */ } #if COLOR tcapfcol() /* no colors here, ignore this */ { } tcapbcol() /* no colors here, ignore this */ { } #endif tcapbeep() { ttputc(BEL); } putpad(str) char *str; { tputs(str, 1, ttputc); } putnpad(str, n) char *str; { tputs(str, n, ttputc); } #if FLABEL fnclabel(f, n) /* label a function key */ int f,n; /* default flag, numeric argument [unused] */ { /* on machines with no function keys...don't bother */ return(TRUE); } #endif #else hello() { } #endif @//E*O*F tcap.c// chmod u=rw,g=r,o=r tcap.c echo x - termio.c sed 's/^@//' > "termio.c" <<'@//E*O*F termio.c//' /* * The functions in this file negotiate with the operating system for * characters, and write characters in a barely buffered fashion on the display. * All operating systems. */ #include #include "estruct.h" #include "edef.h" #if MSDOS & TURBO #include #endif #if AMIGA #define NEW 1006L #define AMG_MAXBUF 1024L static long terminal; static char scrn_tmp[AMG_MAXBUF+1]; static long scrn_tmp_p = 0; #endif #if ST520 & MEGAMAX #include int STscancode = 0; #endif #if VMS #include #include #include #include #include #include #define NIBUF 128 /* Input buffer size */ #define NOBUF 1024 /* MM says bug buffers win! */ #define EFN 0 /* Event flag */ char obuf[NOBUF]; /* Output buffer */ int nobuf; /* # of bytes in above */ char ibuf[NIBUF]; /* Input buffer */ int nibuf; /* # of bytes in above */ int ibufi; /* Read index */ int oldmode[3]; /* Old TTY mode bits */ int newmode[3]; /* New TTY mode bits */ short iochan; /* TTY I/O channel */ #endif #if CPM #include #endif #if MSDOS & (LATTICE | MSC | TURBO | AZTEC | MWC86) union REGS rg; /* cpu register for use of DOS calls */ int nxtchar = -1; /* character held from type ahead */ #endif #if RAINBOW #include "rainbow.h" #endif #if USG /* System V */ #include #include #include int kbdflgs; /* saved keyboard fd flags */ int kbdpoll; /* in O_NDELAY mode */ int kbdqp; /* there is a char in kbdq */ char kbdq; /* char we've already read */ struct termio otermio; /* original terminal characteristics */ struct termio ntermio; /* charactoristics to use inside */ #endif #if V7 | BSD #undef CTRL #include /* for stty/gtty functions */ #include struct sgttyb ostate; /* saved tty state */ struct sgttyb nstate; /* values for editor mode */ struct tchars otchars; /* Saved terminal special character set */ struct tchars ntchars = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; /* A lot of nothing */ #if BSD #include /* to get at the typeahead */ extern int rtfrmshell(); /* return from suspended shell */ #define TBUFSIZ 128 char tobuf[TBUFSIZ]; /* terminal output buffer */ #endif #endif /* * This function is called once to set up the terminal device streams. * On VMS, it translates TT until it finds the terminal, then assigns * a channel to it and sets it raw. On CPM it is a no-op. */ ttopen() { #if AMIGA char oline[NSTRING]; #if AZTEC extern Enable_Abort; /* Turn off ctrl-C interrupt */ Enable_Abort = 0; /* for the Manx compiler */ #endif strcpy(oline, "RAW:0/0/640/200/"); strcat(oline, PROGNAME); strcat(oline, " "); strcat(oline, VERSION); strcat(oline, "/Amiga"); terminal = Open(oline, NEW); #endif #if VMS struct dsc$descriptor idsc; struct dsc$descriptor odsc; char oname[40]; int iosb[2]; int status; odsc.dsc$a_pointer = "TT"; odsc.dsc$w_length = strlen(odsc.dsc$a_pointer); odsc.dsc$b_dtype = DSC$K_DTYPE_T; odsc.dsc$b_class = DSC$K_CLASS_S; idsc.dsc$b_dtype = DSC$K_DTYPE_T; idsc.dsc$b_class = DSC$K_CLASS_S; do { idsc.dsc$a_pointer = odsc.dsc$a_pointer; idsc.dsc$w_length = odsc.dsc$w_length; odsc.dsc$a_pointer = &oname[0]; odsc.dsc$w_length = sizeof(oname); status = LIB$SYS_TRNLOG(&idsc, &odsc.dsc$w_length, &odsc); if (status!=SS$_NORMAL && status!=SS$_NOTRAN) exit(status); if (oname[0] == 0x1B) { odsc.dsc$a_pointer += 4; odsc.dsc$w_length -= 4; } } while (status == SS$_NORMAL); status = SYS$ASSIGN(&odsc, &iochan, 0, 0); if (status != SS$_NORMAL) exit(status); status = SYS$QIOW(EFN, iochan, IO$_SENSEMODE, iosb, 0, 0, oldmode, sizeof(oldmode), 0, 0, 0, 0); if (status!=SS$_NORMAL || (iosb[0]&0xFFFF)!=SS$_NORMAL) exit(status); newmode[0] = oldmode[0]; newmode[1] = oldmode[1] | TT$M_NOECHO; newmode[1] &= ~(TT$M_TTSYNC|TT$M_HOSTSYNC); newmode[2] = oldmode[2] | TT2$M_PASTHRU; status = SYS$QIOW(EFN, iochan, IO$_SETMODE, iosb, 0, 0, newmode, sizeof(newmode), 0, 0, 0, 0); if (status!=SS$_NORMAL || (iosb[0]&0xFFFF)!=SS$_NORMAL) exit(status); term.t_nrow = (newmode[1]>>24) - 1; term.t_ncol = newmode[0]>>16; #endif #if CPM #endif #if MSDOS & (HP150 == 0) & LATTICE /* kill the ctrl-break interupt */ rg.h.ah = 0x33; /* control-break check dos call */ rg.h.al = 1; /* set the current state */ rg.h.dl = 0; /* set it OFF */ intdos(&rg, &rg); /* go for it! */ #endif #if USG ioctl(0, TCGETA, &otermio); /* save old settings */ ntermio.c_iflag = 0; /* setup new settings */ ntermio.c_oflag = 0; ntermio.c_cflag = otermio.c_cflag; ntermio.c_lflag = 0; ntermio.c_line = otermio.c_line; ntermio.c_cc[VMIN] = 1; ntermio.c_cc[VTIME] = 0; ioctl(0, TCSETA, &ntermio); /* and activate them */ kbdflgs = fcntl( 0, F_GETFL, 0 ); kbdpoll = FALSE; #endif #if V7 | BSD gtty(0, &ostate); /* save old state */ gtty(0, &nstate); /* get base of new state */ nstate.sg_flags |= RAW; nstate.sg_flags &= ~(ECHO|CRMOD); /* no echo for now... */ stty(0, &nstate); /* set mode */ ioctl(0, TIOCGETC, &otchars); /* Save old characters */ ioctl(0, TIOCSETC, &ntchars); /* Place new character into K */ #if BSD /* provide a smaller terminal output buffer so that the type ahead detection works better (more often) */ setbuffer(stdout, &tobuf[0], TBUFSIZ); signal(SIGTSTP,SIG_DFL); /* set signals so that we can */ signal(SIGCONT,rtfrmshell); /* suspend & restart emacs */ #endif #endif /* on all screens we are not sure of the initial position of the cursor */ ttrow = 999; ttcol = 999; } /* * This function gets called just before we go back home to the command * interpreter. On VMS it puts the terminal back in a reasonable state. * Another no-operation on CPM. */ ttclose() { #if AMIGA #if LATTICE amg_flush(); Close(terminal); #endif #if AZTEC amg_flush(); Enable_Abort = 1; /* Fix for Manx */ Close(terminal); #endif #endif #if VMS int status; int iosb[1]; ttflush(); status = SYS$QIOW(EFN, iochan, IO$_SETMODE, iosb, 0, 0, oldmode, sizeof(oldmode), 0, 0, 0, 0); if (status!=SS$_NORMAL || (iosb[0]&0xFFFF)!=SS$_NORMAL) exit(status); status = SYS$DASSGN(iochan); if (status != SS$_NORMAL) exit(status); #endif #if CPM #endif #if MSDOS & (HP150 == 0) & LATTICE /* restore the ctrl-break interupt */ rg.h.ah = 0x33; /* control-break check dos call */ rg.h.al = 1; /* set the current state */ rg.h.dl = 1; /* set it ON */ intdos(&rg, &rg); /* go for it! */ #endif #if USG ioctl(0, TCSETA, &otermio); /* restore terminal settings */ fcntl(0, F_SETFL, kbdflgs); #endif #if V7 | BSD stty(0, &ostate); ioctl(0, TIOCSETC, &otchars); /* Place old character into K */ #endif } /* * Write a character to the display. On VMS, terminal output is buffered, and * we just put the characters in the big array, after checking for overflow. * On CPM terminal I/O unbuffered, so we just write the byte out. Ditto on * MS-DOS (use the very very raw console output routine). */ ttputc(c) #if AMIGA | (ST520 & MEGAMAX) char c; #endif { #if AMIGA scrn_tmp[scrn_tmp_p++] = c; if(scrn_tmp_p>=AMG_MAXBUF) amg_flush(); #endif #if ST520 & MEGAMAX Bconout(2,c); #endif #if VMS if (nobuf >= NOBUF) ttflush(); obuf[nobuf++] = c; #endif #if CPM bios(BCONOUT, c, 0); #endif #if MSDOS & MWC86 putcnb(c); #endif #if MSDOS & (LATTICE | AZTEC) & ~IBMPC bdos(6, c, 0); #endif #if RAINBOW Put_Char(c); /* fast video */ #endif #if V7 | USG | BSD fputc(c, stdout); #endif } #if AMIGA amg_flush() { if(scrn_tmp_p) Write(terminal,scrn_tmp,scrn_tmp_p); scrn_tmp_p = 0; } #endif /* * Flush terminal buffer. Does real work where the terminal output is buffered * up. A no-operation on systems where byte at a time terminal I/O is done. */ ttflush() { #if AMIGA amg_flush(); #endif #if VMS int status; int iosb[2]; status = SS$_NORMAL; if (nobuf != 0) { status = SYS$QIOW(EFN, iochan, IO$_WRITELBLK|IO$M_NOFORMAT, iosb, 0, 0, obuf, nobuf, 0, 0, 0, 0); if (status == SS$_NORMAL) status = iosb[0] & 0xFFFF; nobuf = 0; } return (status); #endif #if CPM #endif #if MSDOS #endif #if V7 | USG | BSD fflush(stdout); #endif } /* * Read a character from the terminal, performing no editing and doing no echo * at all. More complex in VMS that almost anyplace else, which figures. Very * simple on CPM, because the system can do exactly what you want. */ ttgetc() { #if AMIGA char ch; amg_flush(); Read(terminal, &ch, 1L); return(255 & (int)ch); #endif #if ST520 & MEGAMAX long ch; /* * blink the cursor only if nothing is happening, this keeps the * cursor on steadily during movement making it easier to track */ STcurblink(TRUE); /* the cursor blinks while we wait */ ch = Bconin(2); STcurblink(FALSE); /* the cursor is steady while we work */ STscancode = (ch >> 16) & 0xff; return(255 & (int)ch); #endif #if VMS int status; int iosb[2]; int term[2]; while (ibufi >= nibuf) { ibufi = 0; term[0] = 0; term[1] = 0; status = SYS$QIOW(EFN, iochan, IO$_READLBLK|IO$M_TIMED, iosb, 0, 0, ibuf, NIBUF, 0, term, 0, 0); if (status != SS$_NORMAL) exit(status); status = iosb[0] & 0xFFFF; if (status!=SS$_NORMAL && status!=SS$_TIMEOUT) exit(status); nibuf = (iosb[0]>>16) + (iosb[1]>>16); if (nibuf == 0) { status = SYS$QIOW(EFN, iochan, IO$_READLBLK, iosb, 0, 0, ibuf, 1, 0, term, 0, 0); if (status != SS$_NORMAL || (status = (iosb[0]&0xFFFF)) != SS$_NORMAL) exit(status); nibuf = (iosb[0]>>16) + (iosb[1]>>16); } } return (ibuf[ibufi++] & 0xFF); /* Allow multinational */ #endif #if CPM return (biosb(BCONIN, 0, 0)); #endif #if RAINBOW int Ch; while ((Ch = Read_Keyboard()) < 0); if ((Ch & Function_Key) == 0) if (!((Ch & 0xFF) == 015 || (Ch & 0xFF) == 0177)) Ch &= 0xFF; return Ch; #endif #if MSDOS & MWC86 return (getcnb()); #endif #if MSDOS & (LATTICE | MSC | TURBO | AZTEC) int c; /* character read */ /* if a char already is ready, return it */ if (nxtchar >= 0) { c = nxtchar; nxtchar = -1; return(c); } /* call the dos to get a char */ rg.h.ah = 7; /* dos Direct Console Input call */ intdos(&rg, &rg); c = rg.h.al; /* grab the char */ return(c & 255); #endif #if V7 | BSD return(127 & fgetc(stdin)); #endif #if USG if( kbdqp ) kbdqp = FALSE; else { if( kbdpoll && fcntl( 0, F_SETFL, kbdflgs ) < 0 ) return FALSE; kbdpoll = FALSE; while (read(0, &kbdq, 1) != 1) ; } return ( kbdq & 127 ); #endif } #if NeWS /* typahead: Check to see if any characters are already in the keyboard buffer */ typahead() { return(inhibit_update) ; } #endif #if TYPEAH & (~ST520 | ~LATTICE ) & ~NeWS /* typahead: Check to see if any characters are already in the keyboard buffer */ typahead() { #if MSDOS & (MSC | TURBO) if (kbhit() != 0) return(TRUE); else return(FALSE); #endif #if MSDOS & (LATTICE | AZTEC | MWC86) int c; /* character read */ int flags; /* cpu flags from dos call */ if (nxtchar >= 0) return(TRUE); rg.h.ah = 6; /* Direct Console I/O call */ rg.h.dl = 255; /* does console input */ #if LATTICE | AZTEC flags = intdos(&rg, &rg); #else intcall(&rg, &rg, 0x21); flags = rg.x.flags; #endif c = rg.h.al; /* grab the character */ /* no character pending */ if ((flags & 64) != 0) return(FALSE); /* save the character and return true */ nxtchar = c; return(TRUE); #endif #if BSD int x; /* holds # of pending chars */ return((ioctl(0,FIONREAD,&x) < 0) ? 0 : x); #endif #if USG if( !kbdqp ) { if( !kbdpoll && fcntl( 0, F_SETFL, kbdflgs | O_NDELAY ) < 0 ) return(FALSE); kbdqp = (1 == read( 0, &kbdq, 1 )); } return ( kbdqp ); #endif return(FALSE); } #endif @//E*O*F termio.c// chmod u=rw,g=r,o=r termio.c echo x - tipc.c sed 's/^@//' > "tipc.c" <<'@//E*O*F tipc.c//' /* * The routines in this file provide support for the TI-PC and other * compatible terminals. It goes directly to the graphics RAM to do * screen output. It compiles into nothing if not a TI-PC driver */ #define termdef 1 /* don't define "term" external */ #include #include "estruct.h" #include "edef.h" #if TIPC #define NROW 25 /* Screen size. */ #define NCOL 80 /* Edit if you want to. */ #define MARGIN 8 /* size of minimim margin and */ #define SCRSIZ 64 /* scroll size for extended lines */ #define NPAUSE 200 /* # times thru update to pause */ #define BEL 0x07 /* BEL character. */ #define ESC 0x1B /* ESC character. */ #define SPACE 32 /* space character */ #define SCADD 0xDE000L /* address of screen RAM */ #define CHAR_ENABLE 0x08 /* TI attribute to show char */ #define TI_REVERSE 0x10 /* TI attribute to reverse char */ #define BLACK 0+CHAR_ENABLE /* TI attribute for Black */ #define BLUE 1+CHAR_ENABLE /* TI attribute for Blue */ #define RED 2+CHAR_ENABLE /* TI attribute for Red */ #define MAGENTA 3+CHAR_ENABLE /* TI attribute for Magenta */ #define GREEN 4+CHAR_ENABLE /* TI attribute for Green */ #define CYAN 5+CHAR_ENABLE /* TI attribute for Cyan */ #define YELLOW 6+CHAR_ENABLE /* TI attribute for Yellow */ #define WHITE 7+CHAR_ENABLE /* TI attribute for White */ extern int ttopen(); /* Forward references. */ extern int ttgetc(); extern int ttputc(); extern int ttflush(); extern int ttclose(); extern int timove(); extern int tieeol(); extern int tieeop(); extern int tibeep(); extern int tiopen(); extern int tirev(); extern int ticres(); extern int ticlose(); extern int tiputc(); #if COLOR extern int tifcol(); extern int tibcol(); int cfcolor = -1; /* current forground color */ int cbcolor = -1; /* current background color */ int ctrans[] = /* ansi to ti color translation table */ {BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE}; #endif /* * Standard terminal interface dispatch table. Most of the fields point into * "termio" code. */ TERM term = { NROW-1, NROW-1, NCOL, NCOL, MARGIN, SCRSIZ, NPAUSE, tiopen, ticlose, ttgetc, tiputc, ttflush, timove, tieeol, tieeop, tibeep, tirev, ticres #if COLOR , tifcol, tibcol #endif }; extern union REGS rg; #if COLOR setatt( attr ) int attr; { rg.h.ah = 0x16; /* set the forground character attribute */ rg.h.bl = attr; int86( 0x49, &rg, &rg ); } tifcol(color) /* set the current output color */ int color; /* color to set */ { cfcolor = ctrans[color]; setatt ( cfcolor ); } tibcol(color) /* set the current background color */ int color; /* color to set */ { cbcolor = ctrans[color]; } #endif timove(row, col) { rg.h.ah = 2; /* set cursor position function code */ rg.h.dh = col; rg.h.dl = row; int86(0x49, &rg, &rg); } tieeol() /* erase to the end of the line */ { int ccol; /* current column cursor lives */ int crow; /* row */ /* find the current cursor position */ rg.h.ah = 3; /* read cursor position function code */ int86(0x49, &rg, &rg); ccol = rg.h.dh; /* record current column */ crow = rg.h.dl; /* and row */ rg.h.ah = 0x09; /* Write character at cursor position */ rg.h.al = ' '; /* Space */ rg.h.bl = cfcolor; rg.x.cx = NCOL-ccol; /* Number of characters to write */ int86(0x49, &rg, &rg); } tiputc(ch) /* put a character at the current position in the current colors */ int ch; { rg.h.ah = 0x0E; /* write char to screen with current attrs */ rg.h.al = ch; int86(0x49, &rg, &rg); } tieeop() /* Actually a clear screen */ { rg.h.ah = 0x13; /* Clear Text Screen and Home Cursor */ int86(0x49, &rg, &rg); } tirev(state) /* change reverse video state */ int state; /* TRUE = reverse, FALSE = normal */ { setatt( state ? cbcolor : cfcolor ); } ticres() /* change screen resolution */ { return(TRUE); } spal() /* change palette string */ { /* Does nothing here */ } tibeep() { bdos(6, BEL, 0); } tiopen() { strcpy(sres, "NORMAL"); revexist = TRUE; ttopen(); } ticlose() { #if COLOR tifcol(7); tibcol(0); #endif ttclose(); } #else tihello() { } #endif @//E*O*F tipc.c// chmod u=rw,g=r,o=r tipc.c echo x - vmsvt.c sed 's/^@//' > "vmsvt.c" <<'@//E*O*F vmsvt.c//' /* * Advanced VMS terminal driver * * Knows about any terminal defined in SMGTERMS.TXT and TERMTABLE.TXT * located in SYS$SYSTEM. * * Author: Curtis Smith * Last Updated: 07/14/87 */ #include /* Standard I/O package */ #include "estruct.h" /* Emacs' structures */ #include "edef.h" /* Emacs' definitions */ #if VMSVT #include /* Descriptor definitions */ /* These would normally come from iodef.h and ttdef.h */ #define IO$_SENSEMODE 0x27 /* Sense mode of terminal */ #define TT$_UNKNOWN 0x00 /* Unknown terminal */ /** Forward references **/ int vmsopen(), ttclose(), vmskopen(), vmskclose(), ttgetc(), ttputc(); int ttflush(), vmsmove(), vmseeol(), vmseeop(), vmsbeep(), vmsrev(); int vmscres(); extern int eolexist, revexist; extern char sres[]; #if COLOR int vmsfcol(), vmsbcol(); #endif /** SMG stuff **/ static char * begin_reverse, * end_reverse, * erase_to_end_line; static char * erase_whole_display; static int termtype; #define SMG$K_BEGIN_REVERSE 0x1bf #define SMG$K_END_REVERSE 0x1d6 #define SMG$K_SET_CURSOR_ABS 0x23a #define SMG$K_ERASE_WHOLE_DISPLAY 0x1da #define SMG$K_ERASE_TO_END_LINE 0x1d9 /* Dispatch table. All hard fields just point into the terminal I/O code. */ TERM term = { 24 - 1, /* Max number of rows allowable */ /* Filled in */ - 1, /* Current number of rows used */ 132, /* Max number of columns */ /* Filled in */ 0, /* Current number of columns */ 64, /* Min margin for extended lines*/ 8, /* Size of scroll region */ 100, /* # times thru update to pause */ vmsopen, /* Open terminal at the start */ ttclose, /* Close terminal at end */ vmskopen, /* Open keyboard */ vmskclose, /* Close keyboard */ ttgetc, /* Get character from keyboard */ ttputc, /* Put character to display */ ttflush, /* Flush output buffers */ vmsmove, /* Move cursor, origin 0 */ vmseeol, /* Erase to end of line */ vmseeop, /* Erase to end of page */ vmsbeep, /* Beep */ vmsrev, /* Set reverse video state */ vmscres /* Change screen resolution */ #if COLOR , vmsfcol, /* Set forground color */ vmsbcol /* Set background color */ #endif }; /*** * ttputs - Send a string to ttputc * * Nothing returned ***/ ttputs(string) char * string; /* String to write */ { if (string) while (*string != '\0') ttputc(*string++); } /*** * vmsmove - Move the cursor (0 origin) * * Nothing returned ***/ vmsmove(row, col) int row; /* Row position */ int col; /* Column position */ { char buffer[32]; int ret_length; static int request_code = SMG$K_SET_CURSOR_ABS; static int max_buffer_length = sizeof(buffer); static int arg_list[3] = { 2 }; register char * cp; register int i; /* Set the arguments into the arg_list array * SMG assumes the row/column positions are 1 based (boo!) */ arg_list[1] = row + 1; arg_list[2] = col + 1; if ((smg$get_term_data( /* Get terminal data */ &termtype, /* Terminal table address */ &request_code, /* Request code */ &max_buffer_length, /* Maximum buffer length */ &ret_length, /* Return length */ buffer, /* Capability data buffer */ arg_list) /* Argument list array */ /* We'll know soon enough if this doesn't work */ & 1) == 0) { ttputs("OOPS"); return; } /* Send out resulting sequence */ i = ret_length; cp = buffer; while (i-- > 0) ttputc(*cp++); } /*** * vmsrev - Set the reverse video status * * Nothing returned ***/ vmsrev(status) int status; /* TRUE if setting reverse */ { if (status) ttputs(begin_reverse); else ttputs(end_reverse); } /*** * vmscres - Change screen resolution (which it doesn't) * * Nothing returned ***/ vmscres() { /* But it could. For vt100/vt200s, one could switch from 80 and 132 columns modes */ } #if COLOR /*** * vmsfcol - Set the forground color (not implimented) * * Nothing returned ***/ vmsfcol() { } /*** * vmsbcol - Set the background color (not implimented) * * Nothing returned ***/ vmsbcol() { } #endif /*** * vmseeol - Erase to end of line * * Nothing returned ***/ vmseeol() { ttputs(erase_to_end_line); } /*** * vmseeop - Erase to end of page (clear screen) * * Nothing returned ***/ vmseeop() { ttputs(erase_whole_display); } /*** * vmsbeep - Ring the bell * * Nothing returned ***/ vmsbeep() { ttputc('\007'); } /*** * vmsgetstr - Get an SMG string capability by name * * Returns: Escape sequence * NULL No escape sequence available ***/ char * vmsgetstr(request_code) int request_code; /* Request code */ { register char * result; static char seq_storage[1024]; static char * buffer = seq_storage; static int arg_list[2] = { 1, 1 }; int max_buffer_length, ret_length; /* Precompute buffer length */ max_buffer_length = (seq_storage + sizeof(seq_storage)) - buffer; /* Get terminal commands sequence from master table */ if ((smg$get_term_data( /* Get terminal data */ &termtype, /* Terminal table address */ &request_code, /* Request code */ &max_buffer_length,/* Maximum buffer length */ &ret_length, /* Return length */ buffer, /* Capability data buffer */ arg_list) /* Argument list array */ /* If this doesn't work, try again with no arguments */ & 1) == 0 && (smg$get_term_data( /* Get terminal data */ &termtype, /* Terminal table address */ &request_code, /* Request code */ &max_buffer_length,/* Maximum buffer length */ &ret_length, /* Return length */ buffer) /* Capability data buffer */ /* Return NULL pointer if capability is not available */ & 1) == 0) return NULL; /* Check for empty result */ if (ret_length == 0) return NULL; /* Save current position so we can return it to caller */ result = buffer; /* NIL terminate the sequence for return */ buffer[ret_length] = 0; /* Advance buffer */ buffer += ret_length + 1; /* Return capability to user */ return result; } /** I/O information block definitions **/ struct iosb { /* I/O status block */ short i_cond; /* Condition value */ short i_xfer; /* Transfer count */ long i_info; /* Device information */ }; struct termchar { /* Terminal characteristics */ char t_class; /* Terminal class */ char t_type; /* Terminal type */ short t_width; /* Terminal width in characters */ long t_mandl; /* Terminal's mode and length */ long t_extend; /* Extended terminal characteristics */ }; static struct termchar tc; /* Terminal characteristics */ /*** * vmsgtty - Get terminal type from system control block * * Nothing returned ***/ vmsgtty() { short fd; int status; struct iosb iostatus; $DESCRIPTOR(devnam, "SYS$INPUT"); /* Assign input to a channel */ status = sys$assign(&devnam, &fd, 0, 0); if ((status & 1) == 0) exit (status); /* Get terminal characteristics */ status = sys$qiow( /* Queue and wait */ 0, /* Wait on event flag zero */ fd, /* Channel to input terminal */ IO$_SENSEMODE, /* Get current characteristic */ &iostatus, /* Status after operation */ 0, 0, /* No AST service */ &tc, /* Terminal characteristics buf */ sizeof(tc), /* Size of the buffer */ 0, 0, 0, 0); /* P3-P6 unused */ /* De-assign the input device */ if ((sys$dassgn(fd) & 1) == 0) exit(status); /* Jump out if bad status */ if ((status & 1) == 0) exit(status); if ((iostatus.i_cond & 1) == 0) exit(iostatus.i_cond); } /*** * vmsopen - Get terminal type and open terminal * * Nothing returned ***/ vmsopen() { /* Get terminal type */ vmsgtty(); if (tc.t_type == TT$_UNKNOWN) { printf("Terminal type is unknown!\n"); printf("Try set your terminal type with SET TERMINAL/INQUIRE\n"); printf("Or get help on SET TERMINAL/DEVICE_TYPE\n"); exit(3); } /* Access the system terminal definition table for the */ /* information of the terminal type returned by IO$_SENSEMODE */ if ((smg$init_term_table_by_type(&tc.t_type, &termtype) & 1) == 0) return -1; /* Set sizes */ term.t_nrow = ((unsigned int) tc.t_mandl >> 24) - 1; term.t_ncol = tc.t_width; /* Get some capabilities */ begin_reverse = vmsgetstr(SMG$K_BEGIN_REVERSE); end_reverse = vmsgetstr(SMG$K_END_REVERSE); revexist = begin_reverse != NULL && end_reverse != NULL; erase_to_end_line = vmsgetstr(SMG$K_ERASE_TO_END_LINE); eolexist = erase_whole_display != NULL; erase_whole_display = vmsgetstr(SMG$K_ERASE_WHOLE_DISPLAY); /* Set resolution */ strcpy(sres, "NORMAL"); /* Open terminal I/O drivers */ ttopen(); } /*** * vmskopen - Open keyboard (not used) * * Nothing returned ***/ vmskopen() { } /*** * vmskclose - Close keyboard (not used) * * Nothing returned ***/ vmskclose() { } /*** * fnclabel - Label function keys (not used) * * Nothing returned ***/ #if FLABEL fnclabel(f, n) /* label a function key */ int f,n; /* default flag, numeric argument [unused] */ { /* on machines with no function keys...don't bother */ return(TRUE); } #endif /*** * spal - Set palette type (Are you kidding?) * * Nothing returned ***/ spal() { } #else /*** * hellovms - Avoid error because of empty module * * Nothing returned ***/ hellovms() { } #endif @//E*O*F vmsvt.c// chmod u=rw,g=r,o=r vmsvt.c echo x - vt52.c sed 's/^@//' > "vt52.c" <<'@//E*O*F vt52.c//' /* * The routines in this file * provide support for VT52 style terminals * over a serial line. The serial I/O services are * provided by routines in "termio.c". It compiles * into nothing if not a VT52 style device. The * bell on the VT52 is terrible, so the "beep" * routine is conditionalized on defining BEL. */ #define termdef 1 /* don't define "term" external */ #include #include "estruct.h" #include "edef.h" #if VT52 #define NROW 24 /* Screen size. */ #define NCOL 80 /* Edit if you want to. */ #define MARGIN 8 /* size of minimim margin and */ #define SCRSIZ 64 /* scroll size for extended lines */ #define NPAUSE 100 /* # times thru update to pause */ #define BIAS 0x20 /* Origin 0 coordinate bias. */ #define ESC 0x1B /* ESC character. */ #define BEL 0x07 /* ascii bell character */ extern int ttopen(); /* Forward references. */ extern int ttgetc(); extern int ttputc(); extern int ttflush(); extern int ttclose(); extern int vt52move(); extern int vt52eeol(); extern int vt52eeop(); extern int vt52beep(); extern int vt52open(); extern int vt52rev(); extern int vt52cres(); extern int vt52kopen(); extern int vt52kclose(); #if COLOR extern int vt52fcol(); extern int vt52bcol(); #endif /* * Dispatch table. All the * hard fields just point into the * terminal I/O code. */ TERM term = { NROW-1, NROW-1, NCOL, NCOL, MARGIN, SCRSIZ, NPAUSE, &vt52open, &ttclose, &vt52kopen, &vt52kclose, &ttgetc, &ttputc, &ttflush, &vt52move, &vt52eeol, &vt52eeop, &vt52beep, &vt52rev, &vt52cres #if COLOR , &vt52fcol, &vt52bcol #endif }; vt52move(row, col) { ttputc(ESC); ttputc('Y'); ttputc(row+BIAS); ttputc(col+BIAS); } vt52eeol() { ttputc(ESC); ttputc('K'); } vt52eeop() { ttputc(ESC); ttputc('J'); } vt52rev(status) /* set the reverse video state */ int status; /* TRUE = reverse video, FALSE = normal video */ { /* can't do this here, so we won't */ } vt52cres() /* change screen resolution - (not here though) */ { return(TRUE); } spal() /* change palette string */ { /* Does nothing here */ } #if COLOR vt52fcol() /* set the forground color [NOT IMPLIMENTED] */ { } vt52bcol() /* set the background color [NOT IMPLIMENTED] */ { } #endif vt52beep() { #ifdef BEL ttputc(BEL); ttflush(); #endif } vt52open() { #if V7 | BSD register char *cp; char *getenv(); if ((cp = getenv("TERM")) == NULL) { puts("Shell variable TERM not defined!"); exit(1); } if (strcmp(cp, "vt52") != 0 && strcmp(cp, "z19") != 0) { puts("Terminal type not 'vt52'or 'z19' !"); exit(1); } #endif ttopen(); } vt52kopen() { } vt52kclose() { } #if FLABEL fnclabel(f, n) /* label a function key */ int f,n; /* default flag, numeric argument [unused] */ { /* on machines with no function keys...don't bother */ return(TRUE); } #endif #else vt52hello() { } #endif @//E*O*F vt52.c// chmod u=rw,g=r,o=r vt52.c echo x - window.c sed 's/^@//' > "window.c" <<'@//E*O*F window.c//' /* * Window management. Some of the functions are internal, and some are * attached to keys that the user actually types. */ #include #include "estruct.h" #include "edef.h" #if MEGAMAX & ST520 overlay "window" #endif /* * Reposition dot in the current window to line "n". If the argument is * positive, it is that line. If it is negative it is that line from the * bottom. If it is 0 the window is centered (this is what the standard * redisplay code does). With no argument it defaults to 0. Bound to M-!. */ reposition(f, n) { if (f == FALSE) /* default to 0 to center screen */ n = 0; curwp->w_force = n; curwp->w_flag |= WFFORCE; return (TRUE); } /* * Refresh the screen. With no argument, it just does the refresh. With an * argument it recenters "." in the current window. Bound to "C-L". */ refresh(f, n) { #if NeWS /* see if the window has changed size */ newsrefresh() ; #endif if (f == FALSE) sgarbf = TRUE; else { curwp->w_force = 0; /* Center dot. */ curwp->w_flag |= WFFORCE; } #if NeWS newsreportmodes() ; #endif return (TRUE); } /* * The command make the next window (next => down the screen) the current * window. There are no real errors, although the command does nothing if * there is only 1 window on the screen. Bound to "C-X C-N". * * with an argument this command finds the th window from the top * */ nextwind(f, n) int f, n; /* default flag and numeric argument */ { register WINDOW *wp; register int nwindows; /* total number of windows */ if (f) { /* first count the # of windows */ wp = wheadp; nwindows = 1; while (wp->w_wndp != NULL) { nwindows++; wp = wp->w_wndp; } /* if the argument is negative, it is the nth window from the bottom of the screen */ if (n < 0) n = nwindows + n + 1; /* if an argument, give them that window from the top */ if (n > 0 && n <= nwindows) { wp = wheadp; while (--n) wp = wp->w_wndp; } else { mlwrite("Window number out of range"); return(FALSE); } } else if ((wp = curwp->w_wndp) == NULL) wp = wheadp; curwp = wp; curbp = wp->w_bufp; upmode(); return (TRUE); } /* * This command makes the previous window (previous => up the screen) the * current window. There arn't any errors, although the command does not do a * lot if there is 1 window. */ prevwind(f, n) { register WINDOW *wp1; register WINDOW *wp2; /* if we have an argument, we mean the nth window from the bottom */ if (f) return(nextwind(f, -n)); wp1 = wheadp; wp2 = curwp; if (wp1 == wp2) wp2 = NULL; while (wp1->w_wndp != wp2) wp1 = wp1->w_wndp; curwp = wp1; curbp = wp1->w_bufp; upmode(); return (TRUE); } /* * This command moves the current window down by "arg" lines. Recompute the * top line in the window. The move up and move down code is almost completely * the same; most of the work has to do with reframing the window, and picking * a new dot. We share the code by having "move down" just be an interface to * "move up". Magic. Bound to "C-X C-N". */ mvdnwind(f, n) int n; { return (mvupwind(f, -n)); } /* * Move the current window up by "arg" lines. Recompute the new top line of * the window. Look to see if "." is still on the screen. If it is, you win. * If it isn't, then move "." to center it in the new framing of the window * (this command does not really move "."; it moves the frame). Bound to * "C-X C-P". */ mvupwind(f, n) int n; { register LINE *lp; register int i; lp = curwp->w_linep; if (n < 0) { while (n++ && lp!=curbp->b_linep) lp = lforw(lp); } else { while (n-- && lback(lp)!=curbp->b_linep) lp = lback(lp); } curwp->w_linep = lp; curwp->w_flag |= WFHARD; /* Mode line is OK. */ for (i = 0; i < curwp->w_ntrows; ++i) { if (lp == curwp->w_dotp) return (TRUE); if (lp == curbp->b_linep) break; lp = lforw(lp); } lp = curwp->w_linep; i = curwp->w_ntrows/2; while (i-- && lp != curbp->b_linep) lp = lforw(lp); curwp->w_dotp = lp; curwp->w_doto = 0; return (TRUE); } /* * This command makes the current window the only window on the screen. Bound * to "C-X 1". Try to set the framing so that "." does not have to move on the * display. Some care has to be taken to keep the values of dot and mark in * the buffer structures right if the distruction of a window makes a buffer * become undisplayed. */ onlywind(f, n) { register WINDOW *wp; register LINE *lp; register int i; while (wheadp != curwp) { wp = wheadp; wheadp = wp->w_wndp; if (--wp->w_bufp->b_nwnd == 0) { wp->w_bufp->b_dotp = wp->w_dotp; wp->w_bufp->b_doto = wp->w_doto; wp->w_bufp->b_markp = wp->w_markp; wp->w_bufp->b_marko = wp->w_marko; } free((char *) wp); } while (curwp->w_wndp != NULL) { wp = curwp->w_wndp; curwp->w_wndp = wp->w_wndp; if (--wp->w_bufp->b_nwnd == 0) { wp->w_bufp->b_dotp = wp->w_dotp; wp->w_bufp->b_doto = wp->w_doto; wp->w_bufp->b_markp = wp->w_markp; wp->w_bufp->b_marko = wp->w_marko; } free((char *) wp); } lp = curwp->w_linep; i = curwp->w_toprow; while (i!=0 && lback(lp)!=curbp->b_linep) { --i; lp = lback(lp); } curwp->w_toprow = 0; curwp->w_ntrows = term.t_nrow-1; curwp->w_linep = lp; curwp->w_flag |= WFMODE|WFHARD; return (TRUE); } /* * Delete the current window, placing its space in the window above, * or, if it is the top window, the window below. Bound to C-X 0. */ delwind(f,n) int f, n; /* arguments are ignored for this command */ { register WINDOW *wp; /* window to recieve deleted space */ register WINDOW *lwp; /* ptr window before curwp */ register int target; /* target line to search for */ /* if there is only one window, don't delete it */ if (wheadp->w_wndp == NULL) { mlwrite("Can not delete this window"); return(FALSE); } /* find window before curwp in linked list */ wp = wheadp; lwp = NULL; while (wp != NULL) { if (wp == curwp) break; lwp = wp; wp = wp->w_wndp; } /* find recieving window and give up our space */ wp = wheadp; if (curwp->w_toprow == 0) { /* find the next window down */ target = curwp->w_ntrows + 1; while (wp != NULL) { if (wp->w_toprow == target) break; wp = wp->w_wndp; } if (wp == NULL) return(FALSE); wp->w_toprow = 0; wp->w_ntrows += target; } else { /* find the next window up */ target = curwp->w_toprow - 1; while (wp != NULL) { if ((wp->w_toprow + wp->w_ntrows) == target) break; wp = wp->w_wndp; } if (wp == NULL) return(FALSE); wp->w_ntrows += 1 + curwp->w_ntrows; } /* get rid of the current window */ if (--curwp->w_bufp->b_nwnd == 0) { curwp->w_bufp->b_dotp = curwp->w_dotp; curwp->w_bufp->b_doto = curwp->w_doto; curwp->w_bufp->b_markp = curwp->w_markp; curwp->w_bufp->b_marko = curwp->w_marko; } if (lwp == NULL) wheadp = curwp->w_wndp; else lwp->w_wndp = curwp->w_wndp; free((char *)curwp); curwp = wp; wp->w_flag |= WFHARD; curbp = wp->w_bufp; upmode(); return(TRUE); } /* Split the current window. A window smaller than 3 lines cannot be split. An argument of 1 forces the cursor into the upper window, an argument of two forces the cursor to the lower window. The only other error that is possible is a "malloc" failure allocating the structure for the new window. Bound to "C-X 2". */ splitwind(f, n) int f, n; /* default flag and numeric argument */ { register WINDOW *wp; register LINE *lp; register int ntru; register int ntrl; register int ntrd; register WINDOW *wp1; register WINDOW *wp2; char *malloc(); if (curwp->w_ntrows < 3) { mlwrite("Cannot split a %d line window", curwp->w_ntrows); return (FALSE); } if ((wp = (WINDOW *) malloc(sizeof(WINDOW))) == NULL) { mlwrite("[OUT OF MEMORY]"); return (FALSE); } ++curbp->b_nwnd; /* Displayed twice. */ wp->w_bufp = curbp; wp->w_dotp = curwp->w_dotp; wp->w_doto = curwp->w_doto; wp->w_markp = curwp->w_markp; wp->w_marko = curwp->w_marko; wp->w_flag = 0; wp->w_force = 0; #if COLOR /* set the colors of the new window */ wp->w_fcolor = gfcolor; wp->w_bcolor = gbcolor; #endif ntru = (curwp->w_ntrows-1) / 2; /* Upper size */ ntrl = (curwp->w_ntrows-1) - ntru; /* Lower size */ lp = curwp->w_linep; ntrd = 0; while (lp != curwp->w_dotp) { ++ntrd; lp = lforw(lp); } lp = curwp->w_linep; if (((f == FALSE) && (ntrd <= ntru)) || ((f == TRUE) && (n == 1))) { /* Old is upper window. */ if (ntrd == ntru) /* Hit mode line. */ lp = lforw(lp); curwp->w_ntrows = ntru; wp->w_wndp = curwp->w_wndp; curwp->w_wndp = wp; wp->w_toprow = curwp->w_toprow+ntru+1; wp->w_ntrows = ntrl; } else { /* Old is lower window */ wp1 = NULL; wp2 = wheadp; while (wp2 != curwp) { wp1 = wp2; wp2 = wp2->w_wndp; } if (wp1 == NULL) wheadp = wp; else wp1->w_wndp = wp; wp->w_wndp = curwp; wp->w_toprow = curwp->w_toprow; wp->w_ntrows = ntru; ++ntru; /* Mode line. */ curwp->w_toprow += ntru; curwp->w_ntrows = ntrl; while (ntru--) lp = lforw(lp); } curwp->w_linep = lp; /* Adjust the top lines */ wp->w_linep = lp; /* if necessary. */ curwp->w_flag |= WFMODE|WFHARD; wp->w_flag |= WFMODE|WFHARD; return (TRUE); } /* * Enlarge the current window. Find the window that loses space. Make sure it * is big enough. If so, hack the window descriptions, and ask redisplay to do * all the hard work. You don't just set "force reframe" because dot would * move. Bound to "C-X Z". */ enlargewind(f, n) { register WINDOW *adjwp; register LINE *lp; register int i; if (n < 0) return (shrinkwind(f, -n)); if (wheadp->w_wndp == NULL) { mlwrite("Only one window"); return (FALSE); } if ((adjwp=curwp->w_wndp) == NULL) { adjwp = wheadp; while (adjwp->w_wndp != curwp) adjwp = adjwp->w_wndp; } if (adjwp->w_ntrows <= n) { mlwrite("Impossible change"); return (FALSE); } if (curwp->w_wndp == adjwp) { /* Shrink below. */ lp = adjwp->w_linep; for (i=0; iw_bufp->b_linep; ++i) lp = lforw(lp); adjwp->w_linep = lp; adjwp->w_toprow += n; } else { /* Shrink above. */ lp = curwp->w_linep; for (i=0; ib_linep; ++i) lp = lback(lp); curwp->w_linep = lp; curwp->w_toprow -= n; } curwp->w_ntrows += n; adjwp->w_ntrows -= n; curwp->w_flag |= WFMODE|WFHARD; adjwp->w_flag |= WFMODE|WFHARD; return (TRUE); } /* * Shrink the current window. Find the window that gains space. Hack at the * window descriptions. Ask the redisplay to do all the hard work. Bound to * "C-X C-Z". */ shrinkwind(f, n) { register WINDOW *adjwp; register LINE *lp; register int i; if (n < 0) return (enlargewind(f, -n)); if (wheadp->w_wndp == NULL) { mlwrite("Only one window"); return (FALSE); } if ((adjwp=curwp->w_wndp) == NULL) { adjwp = wheadp; while (adjwp->w_wndp != curwp) adjwp = adjwp->w_wndp; } if (curwp->w_ntrows <= n) { mlwrite("Impossible change"); return (FALSE); } if (curwp->w_wndp == adjwp) { /* Grow below. */ lp = adjwp->w_linep; for (i=0; iw_bufp->b_linep; ++i) lp = lback(lp); adjwp->w_linep = lp; adjwp->w_toprow -= n; } else { /* Grow above. */ lp = curwp->w_linep; for (i=0; ib_linep; ++i) lp = lforw(lp); curwp->w_linep = lp; curwp->w_toprow += n; } curwp->w_ntrows -= n; adjwp->w_ntrows += n; curwp->w_flag |= WFMODE|WFHARD; adjwp->w_flag |= WFMODE|WFHARD; return (TRUE); } /* Resize the current window to the requested size */ resize(f, n) int f, n; /* default flag and numeric argument */ { int clines; /* current # of lines in window */ /* must have a non-default argument, else ignore call */ if (f == FALSE) return(TRUE); /* find out what to do */ clines = curwp->w_ntrows; /* already the right size? */ if (clines == n) return(TRUE); return(enlargewind(TRUE, n - clines)); } /* * Pick a window for a pop-up. Split the screen if there is only one window. * Pick the uppermost window that isn't the current window. An LRU algorithm * might be better. Return a pointer, or NULL on error. */ WINDOW * wpopup() { register WINDOW *wp; if (wheadp->w_wndp == NULL /* Only 1 window */ && splitwind(FALSE, 0) == FALSE) /* and it won't split */ return (NULL); wp = wheadp; /* Find window to use */ while (wp!=NULL && wp==curwp) wp = wp->w_wndp; return (wp); } scrnextup(f, n) /* scroll the next window up (back) a page */ { nextwind(FALSE, 1); backpage(f, n); prevwind(FALSE, 1); } scrnextdw(f, n) /* scroll the next window down (forward) a page */ { nextwind(FALSE, 1); forwpage(f, n); prevwind(FALSE, 1); } savewnd(f, n) /* save ptr to current window */ { swindow = curwp; return(TRUE); } restwnd(f, n) /* restore the saved screen */ { register WINDOW *wp; /* find the window */ wp = wheadp; while (wp != NULL) { if (wp == swindow) { curwp = wp; curbp = wp->w_bufp; upmode(); return (TRUE); } wp = wp->w_wndp; } mlwrite("[No such window exists]"); return(FALSE); } newsize(f, n) /* resize the screen, re-writing the screen */ int f; /* default flag */ int n; /* numeric argument */ { WINDOW *wp; /* current window being examined */ WINDOW *nextwp; /* next window to scan */ WINDOW *lastwp; /* last window scanned */ int lastline; /* screen line of last line of current window */ /* if the command defaults, assume the largest */ if (f == FALSE) n = term.t_mrow + 1; /* make sure it's in range */ if (n < 3 || n > term.t_mrow + 1) { mlwrite("%%Screen size out of range"); return(FALSE); } if (term.t_nrow == n - 1) return(TRUE); else if (term.t_nrow < n - 1) { /* go to the last window */ wp = wheadp; while (wp->w_wndp != NULL) wp = wp->w_wndp; /* and enlarge it as needed */ wp->w_ntrows = n - wp->w_toprow - 2; wp->w_flag |= WFHARD|WFMODE; } else { /* rebuild the window structure */ nextwp = wheadp; wp = NULL; lastwp = NULL; while (nextwp != NULL) { wp = nextwp; nextwp = wp->w_wndp; /* get rid of it if it is too low */ if (wp->w_toprow > n - 2) { /* save the point/mark if needed */ if (--wp->w_bufp->b_nwnd == 0) { wp->w_bufp->b_dotp = wp->w_dotp; wp->w_bufp->b_doto = wp->w_doto; wp->w_bufp->b_markp = wp->w_markp; wp->w_bufp->b_marko = wp->w_marko; } /* update curwp and lastwp if needed */ if (wp == curwp) curwp = wheadp; curbp = curwp->w_bufp; if (lastwp != NULL) lastwp->w_wndp = NULL; /* free the structure */ free((char *)wp); wp = NULL; } else { /* need to change this window size? */ lastline = wp->w_toprow + wp->w_ntrows - 1; if (lastline >= n - 2) { wp->w_ntrows = n - wp->w_toprow - 2; wp->w_flag |= WFHARD|WFMODE; } } lastwp = wp; } } /* screen is garbage */ term.t_nrow = n - 1; sgarbf = TRUE; return(TRUE); } newwidth(f, n) /* resize the screen, re-writing the screen */ int f; /* default flag */ int n; /* numeric argument */ { register WINDOW *wp; /* if the command defaults, assume the largest */ if (f == FALSE) n = term.t_mcol; /* make sure it's in range */ if (n < 10 || n > term.t_mcol) { #if NeWS /* serious error for NeWS, halt */ fprintf(stderr, "Screen width out of range\n") ; newsclose() ; exit(1) ; #else mlwrite("%%Screen width out of range"); return(FALSE); #endif } /* otherwise, just re-width it (no big deal) */ term.t_ncol = n; term.t_margin = n / 10; term.t_scrsiz = n - (term.t_margin * 2); /* florce all windows to redraw */ wp = wheadp; while (wp) { wp->w_flag |= WFHARD | WFMOVE | WFMODE; wp = wp->w_wndp; } sgarbf = TRUE; return(TRUE); } int getwpos() /* get screen offset of current line in current window */ { register int sline; /* screen line from top of window */ register LINE *lp; /* scannile line pointer */ /* search down the line we want */ lp = curwp->w_linep; sline = 1; while (lp != curwp->w_dotp) { ++sline; lp = lforw(lp); } /* and return the value */ return(sline); } @//E*O*F window.c// chmod u=rw,g=r,o=r window.c echo x - README.NeWS sed 's/^@//' > "README.NeWS" <<'@//E*O*F README.NeWS//' NeWS Distributed EMACS Roger Ove Introduction This distributed version of MicroEMACS is designed primarily for operation on machines where excessive keyboard interrupts are to be avoided, such as Cray supercomputers running UNICOS. It reduces the interrupt load to the level of a line editor, while providing some additional features over typical resident full-screen editors. It will function equally well on other unix machines, and as it also optimizes screen updates and reduces network packets it may be of use in some low bandwidth situations. MicroEMACS was originally written by Dave Conroy, and includes contributions from many people. Most notable among the contributors is Daniel Lawrence, who also maintains the source. This noncommercial implementation is derived from Lawrence's v3.9, to which he holds the copyright. Operation Some of the features of this distributed version include: Efficient i/o handling while remaining completely seamless. Mouse support (for cutting/pasting text and cursor movement). Menu support for most of the features of emacs. Usable on any workstation running the NeWS server without the need for the user to obtain the front end module. The front end is automatically downloaded to the workstation when the editor is invoked. All features of MicroEMACS 3.9 are supported, including multiple buffers, windows, and files. The number of lines may be selected by the user when the editor is invoked (-L40 for 40 lines), and the font size and the number of columns is then set by the size of the window the user chooses from the NeWS interface. The primary distribution mechanism used to offload i/o is selective time buffering. Printable text is displayed locally as it is issued by the user, being flushed to the remote machine (where the actual editor is running) after a suitable period has elapsed during which no input is received. For normal text this period is 2 seconds. Commands (control characters and escape sequences) are also buffered in time, with a period of .4 seconds. Certain prefixes are also defined (^X and escape), so that these characters are assigned long timeouts and the following character a short timeout. The editor controls this timing data, and has the capability to throw the system into "immediate" mode, where every character is treated as a command. This is done temporarily to support the incremental search and query replace functions of emacs. The protocol puts an absolute upper bound on the number of packets that can be transmitted per second, which would be 1 every .4 seconds if the user entered commands at exactly that rate. Issuing commands at a faster or slower rate will improve the performance (reduce the packet load). As local printable text is inserted, a different font is used to indicate that the remote machine has yet to confirm the entry. After a timeout has occurred and a packet of text and commands sent to the remote machine, the screen update will be done with the normal font. Screen updates are optimized so that an update is done only when absolutely necessary. To help with apparent performance in low bandwidth situations, the remote display driver will search for and optimize out any scrolls or reverse scrolls. Essentially what has been implemented here (in a limited fashion) is a NeWS distributed implementation of curses, although as yet no attempt has been made to obey the syntax of curses. The Mouse The mouse is used to position the cursor and for cutting and pasting text. It should be used in preference to the motion keys because it is much more efficient, sending far fewer packets to the remote machine. It should not be used in keyboard macros however, as it's movement commands are not relative. Text is entered at the block cursor, NOT the mouse cursor. To move the block cursor, move the mouse cursor to the desired position. After the mouse has been motionless for 1/5 second, the remote machine will adjust the block cursor to match the mouse position. While waiting for the remote machine to respond the mouse cursor takes the form of an hourglass, to indicate to the user that it is not safe to type. The alignment of cursors is not exact, since the text cursor positioning must take tabs into account and can't be placed past the end of a line. This is a feature, not a bug The left mouse button is used for cutting out text. To cut out a block of text, move the mouse cursor to the starting location, press the left button and move the mouse to the ending location (keeping the button depressed). When the button is released the text will be wiped out (moved to the kill buffer). The middle mouse button will yank text from the kill buffer and insert it at the current (mouse cursor) location. The right mouse button invokes a walking menu. This mouse behavior is not in the standard Sunview style, and as a result it is not (yet) possible to exchange information between the editor and other NeWS applications. Function Keys The user is free to bind the function keys to various emacs commands. If this is done, it is recommended that the definitions be kept in a file named .emacsrc to avoid retyping them (the file ..emacsrc is automatically read when the editor is invoked). The function keys can also be redefined on the fly using the menu. The shift and control keys have no effect when used with the function keys. Altering the definitions is only necessary if the default definitions are not satisfactory. The default definitions for the function keys are: top right 1) find file page up 2) read file top of file 3) insert file reverse incremental search 4) view file page down 5) save file end of file 6) write file incremental search 7) rename file beginning of line 8) copy region cursor up 9) get argument end of line 10) cursor left 11) set mark 12) cursor right 13) previous word 14) cursor down 15) next word "Bugs" and Limitations At present the distribution mechanism is ignorant of key rebindings, that is, the emacs rebinding function does not alter the timing information. Care should be taken when binding characters to keys. In particular, be careful not to rebind the emacs prefix keys ^X or ESC. Also, since the menu entries send "normal" emacs sequences, rebinding these sequences should be avoided. Function keys are available for binding. If for some reason the editing process on the remote machine is killed by methods other than emacs commands, the window may not be eliminated (and NeWS might have to be restarted to get rid of it). Currently the only "correct" ways of terminating are with the window menu "quit" or "save & exit" choices, or with their equivalent emacs sequences (^X C and ESC Z). The frame or icon menu "Zap" function will also terminate the editor, but will not prompt the user for confirmation if changes have not been saved to files. Do not ^C or otherwise kill the remote editor. @//E*O*F README.NeWS// chmod u=rw,g=r,o=r README.NeWS exit 0