tomw@orac.esd.sgi.com (Tom Weinstein) (09/14/90)
Submitted-by: Tom Weinstein <tomw@orac.esd.sgi.com>
Posting-number: Volume 9, Issue 36
Archive-name: colxterm/part06
#! /bin/sh
# This is a shell archive. Remove anything before this line, then feed it
# into a shell via "sh file" or similar. To overwrite existing files,
# type "sh file -c".
# The tool that generated this appeared in the comp.sources.unix newsgroup;
# send mail to comp-sources-unix@uunet.uu.net if you want that tool.
# If this archive is complete, you will see the following message at the end:
# "End of archive 6 (of 14)."
# Contents: xterm/charproc.c.ab xterm/main.c.aa xterm/termcap
# Wrapped by argv@turnpike on Thu Sep 13 20:42:22 1990
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f 'xterm/charproc.c.ab' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'xterm/charproc.c.ab'\"
else
echo shar: Extracting \"'xterm/charproc.c.ab'\" \(22359 characters\)
sed "s/^X//" >'xterm/charproc.c.ab' <<'END_OF_FILE'
X parsestate = groundtable;
X break;
X
X case CASE_DECKPNM:
X /* DECKPNM */
X term->keyboard.flags &= ~KYPD_APL;
X update_appkeypad();
X parsestate = groundtable;
X break;
X
X case CASE_IND:
X /* IND */
X Index(screen, 1);
X if (screen->display->qlen > 0 ||
X GetBytesAvailable (screen->display->fd) > 0)
X xevents();
X parsestate = groundtable;
X break;
X
X case CASE_NEL:
X /* NEL */
X Index(screen, 1);
X CarriageReturn(screen);
X
X if (screen->display->qlen > 0 ||
X GetBytesAvailable (screen->display->fd) > 0)
X xevents();
X parsestate = groundtable;
X break;
X
X case CASE_HTS:
X /* HTS */
X TabSet(term->tabs, screen->cur_col);
X parsestate = groundtable;
X break;
X
X case CASE_RI:
X /* RI */
X RevIndex(screen, 1);
X parsestate = groundtable;
X break;
X
X case CASE_SS2:
X /* SS2 */
X screen->curss = 2;
X parsestate = groundtable;
X break;
X
X case CASE_SS3:
X /* SS3 */
X screen->curss = 3;
X parsestate = groundtable;
X break;
X
X case CASE_CSI_STATE:
X /* enter csi state */
X nparam = 1;
X param[0] = DEFAULT;
X parsestate = csitable;
X break;
X
X case CASE_OSC:
X /* do osc escapes */
X do_osc(finput);
X parsestate = groundtable;
X break;
X
X case CASE_RIS:
X /* RIS */
X VTReset(TRUE);
X parsestate = groundtable;
X break;
X
X case CASE_LS2:
X /* LS2 */
X screen->curgl = 2;
X parsestate = groundtable;
X break;
X
X case CASE_LS3:
X /* LS3 */
X screen->curgl = 3;
X parsestate = groundtable;
X break;
X
X case CASE_LS3R:
X /* LS3R */
X screen->curgr = 3;
X parsestate = groundtable;
X break;
X
X case CASE_LS2R:
X /* LS2R */
X screen->curgr = 2;
X parsestate = groundtable;
X break;
X
X case CASE_LS1R:
X /* LS1R */
X screen->curgr = 1;
X parsestate = groundtable;
X break;
X
X case CASE_XTERM_SAVE:
X savemodes(term);
X parsestate = groundtable;
X break;
X
X case CASE_XTERM_RESTORE:
X restoremodes(term);
X parsestate = groundtable;
X break;
X }
X }
X}
X
Xfinput()
X{
X return(doinput());
X}
X
Xstatic int select_mask;
Xstatic int write_mask;
X
Xstatic char v_buffer[4096];
Xstatic char *v_bufstr;
Xstatic char *v_bufptr;
Xstatic char *v_bufend;
X#define ptymask() (v_bufptr > v_bufstr ? pty_mask : 0)
X
Xv_write(f, d, l)
Xint f;
Xchar *d;
Xint l;
X{
X int r;
X int c = l;
X
X if (!v_bufstr) {
X v_bufstr = v_buffer;
X v_bufptr = v_buffer;
X v_bufend = &v_buffer[4096];
X }
X
X
X if ((1 << f) != pty_mask)
X return(write(f, d, l));
X
X if (v_bufptr > v_bufstr) {
X if (l) {
X if (v_bufend > v_bufptr + l) {
X bcopy(d, v_bufptr, l);
X v_bufptr += l;
X } else {
X if (v_bufstr != v_buffer) {
X bcopy(v_bufstr, v_buffer,
X v_bufptr - v_bufstr);
X v_bufptr -= v_bufstr - v_buffer;
X v_bufstr = v_buffer;
X }
X if (v_bufend > v_bufptr + l) {
X bcopy(d, v_bufptr, l);
X v_bufptr += l;
X } else if (v_bufptr < v_bufend) {
X fprintf(stderr, "Out of buffer space\n");
X c = v_bufend - v_bufptr;
X bcopy(d, v_bufptr, c);
X v_bufptr = v_bufend;
X } else {
X fprintf(stderr, "Out of buffer space\n");
X c = 0;
X }
X }
X }
X if (v_bufptr > v_bufstr) {
X if ((r = write(f, v_bufstr, v_bufptr - v_bufstr)) <= 0)
X return(r);
X if ((v_bufstr += r) >= v_bufptr)
X v_bufstr = v_bufptr = v_buffer;
X }
X } else if (l) {
X if ((r = write(f, d, l)) < 0) {
X if (errno == EWOULDBLOCK)
X r = 0;
X else if (errno == EINTR)
X r = 0;
X else
X return(r);
X }
X if (l - r) {
X if (l - r > v_bufend - v_buffer) {
X fprintf(stderr, "Truncating to %d\n",
X v_bufend - v_buffer);
X l = (v_bufend - v_buffer) + r;
X }
X bcopy(d + r, v_buffer, l - r);
X v_bufstr = v_buffer;
X v_bufptr = v_buffer + (l - r);
X }
X }
X return(c);
X}
X
Xin_put()
X{
X register TScreen *screen = &term->screen;
X register int i;
X static struct timeval trackTimeOut;
X
X select_mask = pty_mask; /* force initial read */
X for( ; ; ) {
X#ifdef CRAY
X trackTimeOut.tv_sec = 0;
X trackTimeOut.tv_usec = 0;
X (void) select(max_plus1, &select_mask, (int *) NULL,
X (int *)NULL, &trackTimeOut);
X#endif /* CRAY */
X
X if((select_mask & pty_mask) && (eventMode == NORMAL)) {
X if(screen->logging)
X FlushLog(screen);
X if((bcnt = read(screen->respond, bptr = buffer,
X BUF_SIZE)) < 0) {
X if(errno == EIO)
X Cleanup (0);
X else if(errno != EWOULDBLOCK)
X Panic(
X "input: read returned unexpected error (%d)\n",
X errno);
X } else if(bcnt == 0)
X Panic("input: read returned zero\n", 0);
X else {
X if (!screen->output_eight_bits) {
X register int bc = bcnt;
X register Char *b = bptr;
X
X for (; bc > 0; bc--, b++) {
X *b &= (Char) 0x7f;
X }
X }
X if(screen->scrollWidget && screen->scrollttyoutput &&
X screen->topline < 0)
X /* Scroll to bottom */
X WindowScroll(screen, 0);
X break;
X }
X }
X if(screen->scroll_amt)
X FlushScroll(screen);
X if(screen->cursor_set && (screen->cursor_col != screen->cur_col
X || screen->cursor_row != screen->cur_row)) {
X if(screen->cursor_state)
X HideCursor();
X ShowCursor();
X } else if(screen->cursor_set != screen->cursor_state) {
X if(screen->cursor_set)
X ShowCursor();
X else
X HideCursor();
X }
X
X if (waitingForTrackInfo) {
X trackTimeOut.tv_sec = TRACKTIMESEC;
X trackTimeOut.tv_usec = TRACKTIMEUSEC;
X select_mask = pty_mask;
X if ((i = select(max_plus1, &select_mask, (int *)NULL, (int *)NULL,
X &trackTimeOut)) < 0) {
X if (errno != EINTR)
X SysError(ERROR_SELECT);
X continue;
X } else if (i == 0) {
X /* emacs just isn't replying, go on */
X waitingForTrackInfo = 0;
X Bell();
X select_mask = Select_mask;
X }
X } else if (QLength(screen->display))
X select_mask = X_mask;
X else {
X write_mask = ptymask();
X XFlush(screen->display);
X select_mask = Select_mask;
X if (eventMode != NORMAL)
X select_mask = X_mask;
X if(select(max_plus1, &select_mask, &write_mask,
X (int *)NULL, (struct timeval *) NULL) < 0){
X if (errno != EINTR)
X SysError(ERROR_SELECT);
X continue;
X }
X }
X if (write_mask & ptymask())
X v_write(screen->respond, 0, 0); /* flush buffer */
X if(select_mask & X_mask) {
X if (bcnt <= 0) {
X bcnt = 0;
X bptr = buffer;
X }
X xevents();
X if (bcnt > 0)
X break;
X }
X }
X bcnt--;
X return(*bptr++);
X}
X
X/*
X * process a string of characters according to the character set indicated
X * by charset. worry about end of line conditions (wraparound if selected).
X */
Xdotext(screen, flags, fg, bg, charset, buf, ptr)
Xregister TScreen *screen;
Xunsigned flags;
Xunsigned fg, bg;
Xchar charset;
Xchar *buf;
Xchar *ptr;
X{
X register char *s;
X register int len;
X register int n;
X register int next_col;
X
X switch (charset) {
X case 'A': /* United Kingdom set */
X for (s=buf; s<ptr; ++s)
X if (*s == '#')
X *s = '\036'; /* UK pound sign*/
X break;
X
X case 'B': /* ASCII set */
X break;
X
X case '0': /* special graphics (line drawing) */
X for (s=buf; s<ptr; ++s)
X if (*s>=0x5f && *s<=0x7e)
X *s = *s == 0x5f ? 0x7f : *s - 0x5f;
X break;
X
X default: /* any character sets we don't recognize*/
X return;
X }
X
X len = ptr - buf;
X ptr = buf;
X while (len > 0) {
X n = screen->max_col-screen->cur_col+1;
X if (n <= 1) {
X if (screen->do_wrap && (flags&WRAPAROUND)) {
X Index(screen, 1);
X screen->cur_col = 0;
X screen->do_wrap = 0;
X n = screen->max_col+1;
X } else
X n = 1;
X }
X if (len < n)
X n = len;
X next_col = screen->cur_col + n;
X WriteText(screen, ptr, n, flags, fg, bg);
X /*
X * the call to WriteText updates screen->cur_col.
X * If screen->cur_col != next_col, we must have
X * hit the right margin, so set the do_wrap flag.
X */
X screen->do_wrap = (screen->cur_col < next_col);
X len -= n;
X ptr += n;
X }
X}
X
X/*
X * write a string str of length len onto the screen at
X * the current cursor position. update cursor position.
X */
XWriteText(screen, str, len, flags, fg, bg)
Xregister TScreen *screen;
Xregister char *str;
Xregister int len;
Xunsigned flags;
Xunsigned fg, bg;
X{
X register int cx, cy;
X register unsigned fgs = flags;
X register Pixel fg_pix, bg_pix;
X GC currentGC;
X extern XtermWidget term;
X
X fg_pix = (fgs&FG_COLOR) ? screen->colors[fg] : screen->foreground;
X bg_pix = (fgs&BG_COLOR) ? screen->colors[bg] : term->core.background_pixel;
X
X if(screen->cur_row - screen->topline <= screen->max_row) {
X /*
X if(screen->cur_row == screen->cursor_row && screen->cur_col <=
X screen->cursor_col && screen->cursor_col <= screen->cur_col + len - 1)
X screen->cursor_state = OFF;
X */
X if(screen->cursor_state)
X HideCursor();
X
X /*
X * make sure that the correct GC is current
X */
X
X if (fgs & INVERSE) {
X if (fgs & BOLD)
X currentGC = screen->reverseboldGC;
X else currentGC = screen->reverseGC;
X
X XSetForeground(screen->display, currentGC, bg_pix);
X XSetBackground(screen->display, currentGC, fg_pix);
X
X } else { /* not inverse */
X if (fgs & BOLD)
X currentGC = screen->normalboldGC;
X else currentGC = screen->normalGC;
X
X XSetForeground(screen->display, currentGC, fg_pix);
X XSetBackground(screen->display, currentGC, bg_pix);
X
X }
X
X if (fgs & INSERT)
X InsertChar(screen, len);
X if (!(AddToRefresh(screen))) {
X if(screen->scroll_amt)
X FlushScroll(screen);
X cx = CursorX(screen, screen->cur_col);
X cy = CursorY(screen, screen->cur_row)+screen->fnt_norm->ascent;
X
X
X XDrawImageString(screen->display, TextWindow(screen), currentGC,
X cx, cy, str, len);
X
X if((fgs & BOLD) && screen->enbolden)
X if (currentGC == screen->normalGC || screen->reverseGC)
X XDrawString(screen->display, TextWindow(screen),
X currentGC,cx + 1, cy, str, len);
X
X if(fgs & UNDERLINE)
X XDrawLine(screen->display, TextWindow(screen), currentGC,
X cx, cy+1,
X cx + len * FontWidth(screen), cy+1);
X /*
X * the following statements compile data to compute the average
X * number of characters written on each call to XText. The data
X * may be examined via the use of a "hidden" escape sequence.
X */
X ctotal += len;
X ++ntotal;
X }
X }
X ScreenWrite(screen, str, flags, fg, bg, len);
X CursorForward(screen, len);
X}
X
X/*
X * process ANSI modes set, reset
X */
Xmodes(term, func)
XXtermWidget term;
Xint (*func)();
X{
X register int i;
X
X for (i=0; i<nparam; ++i) {
X switch (param[i]) {
X case 4: /* IRM */
X (*func)(&term->flags, INSERT);
X break;
X
X case 20: /* LNM */
X (*func)(&term->flags, LINEFEED);
X update_autolinefeed();
X break;
X }
X }
X}
X
X/*
X * process DEC private modes set, reset
X */
Xdpmodes(term, func)
XXtermWidget term;
Xint (*func)();
X{
X register TScreen *screen = &term->screen;
X register int i, j;
X extern int bitset();
X
X for (i=0; i<nparam; ++i) {
X switch (param[i]) {
X case 1: /* DECCKM */
X (*func)(&term->keyboard.flags, CURSOR_APL);
X break;
X case 2: /* ANSI/VT52 mode */
X if (func == bitset) {
X screen->gsets[0] =
X screen->gsets[1] =
X screen->gsets[2] =
X screen->gsets[3] = 'B';
X screen->curgl = 0;
X screen->curgr = 2;
X }
X break;
X case 3: /* DECCOLM */
X if(screen->c132) {
X ClearScreen(screen);
X CursorSet(screen, 0, 0, term->flags);
X if((j = func == bitset ? 132 : 80) !=
X ((term->flags & IN132COLUMNS) ? 132 : 80) ||
X j != screen->max_col + 1) {
X Dimension replyWidth, replyHeight;
X XtGeometryResult status;
X
X status = XtMakeResizeRequest (
X (Widget) term,
X (Dimension) FontWidth(screen) * j
X + 2*screen->border
X + screen->scrollbar,
X (Dimension) FontHeight(screen)
X * (screen->max_row + 1)
X + 2 * screen->border,
X &replyWidth, &replyHeight);
X
X if (status == XtGeometryYes ||
X status == XtGeometryDone) {
X ScreenResize (&term->screen,
X replyWidth,
X replyHeight,
X &term->flags);
X }
X }
X (*func)(&term->flags, IN132COLUMNS);
X }
X break;
X case 4: /* DECSCLM (slow scroll) */
X if (func == bitset) {
X screen->jumpscroll = 0;
X if (screen->scroll_amt)
X FlushScroll(screen);
X } else
X screen->jumpscroll = 1;
X (*func)(&term->flags, SMOOTHSCROLL);
X update_jumpscroll();
X break;
X case 5: /* DECSCNM */
X j = term->flags;
X (*func)(&term->flags, REVERSE_VIDEO);
X if ((term->flags ^ j) & REVERSE_VIDEO)
X ReverseVideo(term);
X /* update_reversevideo done in RevVid */
X break;
X
X case 6: /* DECOM */
X (*func)(&term->flags, ORIGIN);
X CursorSet(screen, 0, 0, term->flags);
X break;
X
X case 7: /* DECAWM */
X (*func)(&term->flags, WRAPAROUND);
X update_autowrap();
X break;
X case 8: /* DECARM */
X /* ignore autorepeat */
X break;
X case 9: /* MIT bogus sequence */
X if(func == bitset)
X screen->send_mouse_pos = 1;
X else
X screen->send_mouse_pos = 0;
X break;
X case 38: /* DECTEK */
X if(func == bitset & !(screen->inhibit & I_TEK)) {
X if(screen->logging) {
X FlushLog(screen);
X screen->logstart = Tbuffer;
X }
X screen->TekEmu = TRUE;
X }
X break;
X case 40: /* 132 column mode */
X screen->c132 = (func == bitset);
X update_allow132();
X break;
X case 41: /* curses hack */
X screen->curses = (func == bitset);
X update_cursesemul();
X break;
X case 44: /* margin bell */
X screen->marginbell = (func == bitset);
X if(!screen->marginbell)
X screen->bellarmed = -1;
X update_marginbell();
X break;
X case 45: /* reverse wraparound */
X (*func)(&term->flags, REVERSEWRAP);
X update_reversewrap();
X break;
X case 46: /* logging */
X#ifdef ALLOWLOGFILEONOFF
X /*
X * if this feature is enabled, logging may be
X * enabled and disabled via escape sequences.
X */
X if(func == bitset)
X StartLog(screen);
X else
X CloseLog(screen);
X#else
X Bell();
X Bell();
X#endif /* ALLOWLOGFILEONOFF */
X break;
X case 47: /* alternate buffer */
X if(func == bitset)
X ToAlternate(screen);
X else
X FromAlternate(screen);
X break;
X case 1000: /* xtem bogus sequence */
X if(func == bitset)
X screen->send_mouse_pos = 2;
X else
X screen->send_mouse_pos = 0;
X break;
X case 1001: /* xtem sequence w/hilite tracking */
X if(func == bitset)
X screen->send_mouse_pos = 3;
X else
X screen->send_mouse_pos = 0;
X break;
X }
X }
X}
X
X/*
X * process xterm private modes save
X */
Xsavemodes(term)
XXtermWidget term;
X{
X register TScreen *screen = &term->screen;
X register int i;
X
X for (i = 0; i < nparam; i++) {
X switch (param[i]) {
X case 1: /* DECCKM */
X screen->save_modes[0] = term->keyboard.flags &
X CURSOR_APL;
X break;
X case 3: /* DECCOLM */
X if(screen->c132)
X screen->save_modes[1] = term->flags &
X IN132COLUMNS;
X break;
X case 4: /* DECSCLM (slow scroll) */
X screen->save_modes[2] = term->flags & SMOOTHSCROLL;
X break;
X case 5: /* DECSCNM */
X screen->save_modes[3] = term->flags & REVERSE_VIDEO;
X break;
X case 6: /* DECOM */
X screen->save_modes[4] = term->flags & ORIGIN;
X break;
X
X case 7: /* DECAWM */
X screen->save_modes[5] = term->flags & WRAPAROUND;
X break;
X case 8: /* DECARM */
X /* ignore autorepeat */
X break;
X case 9: /* mouse bogus sequence */
X screen->save_modes[7] = screen->send_mouse_pos;
X break;
X case 40: /* 132 column mode */
X screen->save_modes[8] = screen->c132;
X break;
X case 41: /* curses hack */
X screen->save_modes[9] = screen->curses;
X break;
X case 44: /* margin bell */
X screen->save_modes[12] = screen->marginbell;
X break;
X case 45: /* reverse wraparound */
X screen->save_modes[13] = term->flags & REVERSEWRAP;
X break;
X case 46: /* logging */
X screen->save_modes[14] = screen->logging;
X break;
X case 47: /* alternate buffer */
X screen->save_modes[15] = screen->alternate;
X break;
X case 1000: /* mouse bogus sequence */
X case 1001:
X screen->save_modes[7] = screen->send_mouse_pos;
X break;
X }
X }
X}
X
X/*
X * process xterm private modes restore
X */
Xrestoremodes(term)
XXtermWidget term;
X{
X register TScreen *screen = &term->screen;
X register int i, j;
X
X for (i = 0; i < nparam; i++) {
X switch (param[i]) {
X case 1: /* DECCKM */
X term->keyboard.flags &= ~CURSOR_APL;
X term->keyboard.flags |= screen->save_modes[0] &
X CURSOR_APL;
X update_appcursor();
X break;
X case 3: /* DECCOLM */
X if(screen->c132) {
X ClearScreen(screen);
X CursorSet(screen, 0, 0, term->flags);
X if((j = (screen->save_modes[1] & IN132COLUMNS)
X ? 132 : 80) != ((term->flags & IN132COLUMNS)
X ? 132 : 80) || j != screen->max_col + 1) {
X Dimension replyWidth, replyHeight;
X XtGeometryResult status;
X status = XtMakeResizeRequest (
X (Widget) term,
X (Dimension) FontWidth(screen) * j
X + 2*screen->border
X + screen->scrollbar,
X (Dimension) FontHeight(screen)
X * (screen->max_row + 1)
X + 2*screen->border,
X &replyWidth, &replyHeight);
X
X if (status == XtGeometryYes ||
X status == XtGeometryDone) {
X ScreenResize (&term->screen,
X replyWidth,
X replyHeight,
X &term->flags);
X }
X }
X term->flags &= ~IN132COLUMNS;
X term->flags |= screen->save_modes[1] &
X IN132COLUMNS;
X }
X break;
X case 4: /* DECSCLM (slow scroll) */
X if (screen->save_modes[2] & SMOOTHSCROLL) {
X screen->jumpscroll = 0;
X if (screen->scroll_amt)
X FlushScroll(screen);
X } else
X screen->jumpscroll = 1;
X term->flags &= ~SMOOTHSCROLL;
X term->flags |= screen->save_modes[2] & SMOOTHSCROLL;
X update_jumpscroll();
X break;
X case 5: /* DECSCNM */
X if((screen->save_modes[3] ^ term->flags) &
X REVERSE_VIDEO) {
X term->flags &= ~REVERSE_VIDEO;
X term->flags |= screen->save_modes[3] &
X REVERSE_VIDEO;
X ReverseVideo(term);
X /* update_reversevideo done in RevVid */
X }
X break;
X case 6: /* DECOM */
X term->flags &= ~ORIGIN;
X term->flags |= screen->save_modes[4] & ORIGIN;
X CursorSet(screen, 0, 0, term->flags);
X break;
X
X case 7: /* DECAWM */
X term->flags &= ~WRAPAROUND;
X term->flags |= screen->save_modes[5] & WRAPAROUND;
X update_autowrap();
X break;
X case 8: /* DECARM */
X /* ignore autorepeat */
X break;
X case 9: /* MIT bogus sequence */
X screen->send_mouse_pos = screen->save_modes[7];
X break;
X case 40: /* 132 column mode */
X screen->c132 = screen->save_modes[8];
X update_allow132();
X break;
X case 41: /* curses hack */
X screen->curses = screen->save_modes[9];
X update_cursesemul();
X break;
X case 44: /* margin bell */
X if(!(screen->marginbell = screen->save_modes[12]))
X screen->bellarmed = -1;
X update_visualbell();
X break;
X case 45: /* reverse wraparound */
X term->flags &= ~REVERSEWRAP;
X term->flags |= screen->save_modes[13] & REVERSEWRAP;
X update_reversewrap();
X break;
X case 46: /* logging */
X#ifdef ALLOWLOGFILEONOFF
X if(screen->save_modes[14])
X StartLog(screen);
X else
X CloseLog(screen);
X#endif /* ALLOWLOGFILEONOFF */
X /* update_logging done by StartLog and CloseLog */
X break;
X case 47: /* alternate buffer */
X if(screen->save_modes[15])
X ToAlternate(screen);
X else
X FromAlternate(screen);
X /* update_altscreen done by ToAlt and FromAlt */
X break;
X case 1000: /* mouse bogus sequence */
X case 1001:
X screen->send_mouse_pos = screen->save_modes[7];
X break;
X }
X }
X}
X
X/*
X * set a bit in a word given a pointer to the word and a mask.
X */
Xbitset(p, mask)
Xint *p;
X{
X *p |= mask;
X}
X
X/*
X * clear a bit in a word given a pointer to the word and a mask.
X */
Xbitclr(p, mask)
Xint *p;
X{
X *p &= ~mask;
X}
X
Xunparseseq(ap, fd)
Xregister ANSI *ap;
X{
X register int c;
X register int i;
X register int inters;
X
X c = ap->a_type;
X if (c>=0x80 && c<=0x9F) {
X unparseputc(ESC, fd);
X c -= 0x40;
X }
X unparseputc(c, fd);
X c = ap->a_type;
X if (c==ESC || c==DCS || c==CSI || c==OSC || c==PM || c==APC) {
X if (ap->a_pintro != 0)
X unparseputc((char) ap->a_pintro, fd);
X for (i=0; i<ap->a_nparam; ++i) {
X if (i != 0)
X unparseputc(';', fd);
X unparseputn((unsigned int) ap->a_param[i], fd);
X }
X inters = ap->a_inters;
X for (i=3; i>=0; --i) {
X c = (inters >> (8*i)) & 0xff;
X if (c != 0)
X unparseputc(c, fd);
X }
X unparseputc((char) ap->a_final, fd);
X }
X}
X
Xunparseputn(n, fd)
Xunsigned int n;
Xint fd;
X{
X unsigned int q;
X
X q = n/10;
X if (q != 0)
X unparseputn(q, fd);
X unparseputc((char) ('0' + (n%10)), fd);
X}
X
Xunparseputc(c, fd)
Xchar c;
Xint fd;
X{
X char buf[2];
X register i = 1;
X extern XtermWidget term;
X
X if((buf[0] = c) == '\r' && (term->flags & LINEFEED)) {
X buf[1] = '\n';
X i++;
X }
X if (write(fd, buf, i) != i)
X Panic("unparseputc: error writing character\n", 0);
X}
X
Xunparsefputs (s, fd)
X register char *s;
X int fd;
X{
X if (s) {
X while (*s) unparseputc (*s++, fd);
X }
X}
X
X
XToAlternate(screen)
Xregister TScreen *screen;
X{
X extern ScrnBuf Allocate();
X
X if(screen->alternate)
X return;
X if(!screen->altbuf)
X screen->altbuf = Allocate(screen->max_row + 1, screen->max_col
X + 1, &screen->abuf_address);
X SwitchBufs(screen);
X screen->alternate = TRUE;
X update_altscreen();
X}
X
XFromAlternate(screen)
Xregister TScreen *screen;
X{
X if(!screen->alternate)
X return;
X screen->alternate = FALSE;
X SwitchBufs(screen);
X update_altscreen();
X}
X
XSwitchBufs(screen)
Xregister TScreen *screen;
X{
X register int rows, top;
X char *save [4 * MAX_ROWS];
X
X if(screen->cursor_state)
X HideCursor();
X rows = screen->max_row + 1;
X bcopy((char *)screen->buf, (char *)save, 4 * sizeof(char *) * rows);
X bcopy((char *)screen->altbuf, (char *)screen->buf, 4 * sizeof(char *) *
X rows);
X bcopy((char *)save, (char *)screen->altbuf, 4 * sizeof(char *) * rows);
X
X if((top = -screen->topline) <= screen->max_row) {
X if(screen->scroll_amt)
X FlushScroll(screen);
X if(top == 0)
X XClearWindow(screen->display, TextWindow(screen));
X else
X XClearArea(
X screen->display,
X TextWindow(screen),
X (int) screen->border + screen->scrollbar,
X (int) top * FontHeight(screen) + screen->border,
X (unsigned) Width(screen),
X (unsigned) (screen->max_row - top + 1)
X * FontHeight(screen),
X FALSE);
X }
X ScrnRefresh(screen, 0, 0, rows, screen->max_col + 1, False);
X}
X
XVTRun()
X{
X register TScreen *screen = &term->screen;
X register int i;
X
X if (!screen->Vshow) {
X XtRealizeWidget (term->core.parent);
X set_vt_visibility (TRUE);
X }
X update_vttekmode();
X update_vtshow();
X update_tekshow();
X set_vthide_sensitivity();
X
X if (screen->allbuf == NULL) VTallocbuf ();
X
X screen->cursor_state = OFF;
X screen->cursor_set = ON;
X
X bcnt = 0;
X bptr = buffer;
X while(Tpushb > Tpushback) {
X *bptr++ = *--Tpushb;
END_OF_FILE
if test 22359 -ne `wc -c <'xterm/charproc.c.ab'`; then
echo shar: \"'xterm/charproc.c.ab'\" unpacked with wrong size!
fi
# end of 'xterm/charproc.c.ab'
fi
if test -f 'xterm/main.c.aa' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'xterm/main.c.aa'\"
else
echo shar: Extracting \"'xterm/main.c.aa'\" \(29484 characters\)
sed "s/^X//" >'xterm/main.c.aa' <<'END_OF_FILE'
X#ifndef lint
Xstatic char rcs_id[] = "$XConsortium: main.c,v 1.154 90/06/08 14:23:46 jim Exp $";
X#endif /* lint */
X
X/*
X * W A R N I N G
X *
X * If you think you know what all of this code is doing, you are probably
X * very mistaken. There be serious and nasty dragons here.
X *
X * This client is *not* to be taken as an example of how to write X Toolkit
X * applications. It is in need of a substantial rewrite, ideally to create
X * a generic tty widget with several different parsing widgets so that you
X * can plug 'em together any way you want. Don't hold your breath, though....
X */
X
X#include <X11/copyright.h>
X
X/***********************************************************
XCopyright 1987, 1988 by Digital Equipment Corporation, Maynard, Massachusetts,
Xand the Massachusetts Institute of Technology, Cambridge, Massachusetts.
X
X All Rights Reserved
X
XPermission to use, copy, modify, and distribute this software and its
Xdocumentation for any purpose and without fee is hereby granted,
Xprovided that the above copyright notice appear in all copies and that
Xboth that copyright notice and this permission notice appear in
Xsupporting documentation, and that the names of Digital or MIT not be
Xused in advertising or publicity pertaining to distribution of the
Xsoftware without specific, written prior permission.
X
XDIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
XALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
XDIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
XANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
XWHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
XARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
XSOFTWARE.
X
X******************************************************************/
X
X
X/* main.c */
X
X#include <X11/Xos.h>
X#include <X11/Xlib.h>
X#include <X11/cursorfont.h>
X#include <pwd.h>
X#include <ctype.h>
X
X#ifdef att
X#define USE_USG_PTYS
X#endif
X
X#ifndef att
X#define USE_HANDSHAKE
X#endif
X
X#include <sys/ioctl.h>
X
X#define USE_TERMCAP
X
X#ifdef SYSV
X#include <sys/termio.h>
X#ifdef USE_USG_PTYS /* AT&T SYSV has no ptyio.h */
X#include <sys/stream.h> /* get typedef used in ptem.h */
X#include <sys/ptem.h> /* get struct winsize */
X#include <sys/stropts.h> /* for I_PUSH */
X#include <poll.h> /* for POLLIN */
X#endif
X#include <sys/stat.h>
X#define USE_SYSV_TERMIO
X#define USE_SYSV_SIGNALS
X#define USE_SYSV_PGRP
X#undef USE_TERMCAP
X#define USE_SYSV_ENVVARS /* COLUMNS/LINES vs. TERMCAP */
X/*
X * now get system-specific includes
X */
X#ifdef CRAY
X#define HAS_UTMP_UT_HOST
X#define HAS_BSD_GROUPS
X#endif
X#ifdef macII
X#define HAS_UTMP_UT_HOST
X#define HAS_BSD_GROUPS
X#include <sys/ttychars.h>
X#undef USE_SYSV_ENVVARS
X#undef FIOCLEX
X#undef FIONCLEX
X#define setpgrp2 setpgrp
X#include <sgtty.h>
X#include <sys/resource.h>
X#endif
X#ifdef hpux
X#define HAS_BSD_GROUPS
X#include <sys/ptyio.h>
X#endif
X#ifdef sgi
X#undef USE_SYSV_ENVVARS
X#undef USE_SYSV_PGRP
X#define setpgrp BSDsetpgrp
X#include <sgtty.h>
X#include <sys/resource.h>
X#include <sys/sysmacros.h>
X#define HAS_BSD_GROUPS
X#define USE_SYSV_UTMP
X#define HAS_POSIX_SESSIONS
X#endif
X#endif /* SYSV */
X
X#ifndef SYSV /* BSD systems */
X#include <sgtty.h>
X#include <sys/resource.h>
X#define HAS_UTMP_UT_HOST
X#define HAS_BSD_GROUPS
X#define USE_TERMCAP
X#endif /* !SYSV */
X
X#include <stdio.h>
X#include <errno.h>
X#include <setjmp.h>
X
X#ifdef hpux
X#include <sys/utsname.h>
X#endif /* hpux */
X
X#ifdef apollo
X#define ttyslot() 1
X#endif /* apollo */
X
X#include <utmp.h>
X#ifdef LASTLOG
X#include <lastlog.h>
X#endif
X#include <sys/param.h> /* for NOFILE */
X
X#ifdef PUCC_PTYD
X#include <local/openpty.h>
Xint Ptyfd;
X#endif /* PUCC_PTYD */
X
X#ifdef sequent
X#define USE_GET_PSEUDOTTY
X#endif
X
X#ifndef UTMP_FILENAME
X#define UTMP_FILENAME "/etc/utmp"
X#endif
X#ifndef LASTLOG_FILENAME
X#define LASTLOG_FILENAME "/usr/adm/lastlog" /* only on BSD systems */
X#endif
X#ifndef WTMP_FILENAME
X#if defined(SYSV)
X#define WTMP_FILENAME "/etc/wtmp"
X#else
X#define WTMP_FILENAME "/usr/adm/wtmp"
X#endif
X#endif
X
X#include "ptyx.h"
X#include "data.h"
X#include "error.h"
X#include "main.h"
X#include "menu.h"
X#include <X11/StringDefs.h>
X#include <X11/Shell.h>
X#ifdef SIGTSTP
X#include <sys/wait.h>
X#ifdef hpux
X#include <sys/bsdtty.h>
X#endif
X#endif
X
X#ifdef SIGNALRETURNSINT
X#define SIGNAL_T int
X#define SIGNAL_RETURN return 0
X#else
X#define SIGNAL_T void
X#define SIGNAL_RETURN return
X#endif
X
XSIGNAL_T Exit();
Xextern char *malloc();
Xextern char *calloc();
Xextern char *realloc();
Xextern char *ttyname();
Xextern char *getenv();
Xextern char *strindex ();
Xextern void exit();
Xextern void sleep();
Xextern void bcopy();
Xextern long lseek();
Xextern void HandlePopupMenu();
X
Xint switchfb[] = {0, 2, 1, 3};
X
Xstatic SIGNAL_T reapchild ();
X
Xstatic Bool added_utmp_entry = False;
X
Xstatic char **command_to_exec;
X
X#ifdef USE_SYSV_TERMIO
X/* The following structures are initialized in main() in order
X** to eliminate any assumptions about the internal order of their
X** contents.
X*/
Xstatic struct termio d_tio;
X#ifdef TIOCSLTC
Xstatic struct ltchars d_ltc;
X#endif /* TIOCSLTC */
X#ifdef TIOCLSET
Xstatic unsigned int d_lmode;
X#endif /* TIOCLSET */
X#else /* not USE_SYSV_TERMIO */
Xstatic struct sgttyb d_sg = {
X 0, 0, 0177, CKILL, EVENP|ODDP|ECHO|XTABS|CRMOD
X};
Xstatic struct tchars d_tc = {
X CINTR, CQUIT, CSTART,
X CSTOP, CEOF, CBRK,
X};
Xstatic struct ltchars d_ltc = {
X CSUSP, CDSUSP, CRPRNT,
X CFLUSH, CWERASE, CLNEXT
X};
Xstatic int d_disipline = NTTYDISC;
Xstatic long int d_lmode = LCRTBS|LCRTERA|LCRTKIL|LCTLECH;
X#endif /* USE_SYSV_TERMIO */
X
Xstatic int parse_tty_modes ();
X/*
X * SYSV has the termio.c_cc[V] and ltchars; BSD has tchars and ltchars
X */
Xstatic int override_tty_modes = 0;
Xstruct _xttymodes {
X char *name;
X int len;
X int set;
X char value;
X} ttymodelist[] = {
X{ "intr", 4, 0, '\0' }, /* tchars.t_intrc ; VINTR */
X#define XTTYMODE_intr 0
X{ "quit", 4, 0, '\0' }, /* tchars.t_quitc ; VQUIT */
X#define XTTYMODE_quit 1
X{ "erase", 5, 0, '\0' }, /* sgttyb.sg_erase ; VERASE */
X#define XTTYMODE_erase 2
X{ "kill", 4, 0, '\0' }, /* sgttyb.sg_kill ; VKILL */
X#define XTTYMODE_kill 3
X{ "eof", 3, 0, '\0' }, /* tchars.t_eofc ; VEOF */
X#define XTTYMODE_eof 4
X{ "eol", 3, 0, '\0' }, /* VEOL */
X#define XTTYMODE_eol 5
X{ "swtch", 5, 0, '\0' }, /* VSWTCH */
X#define XTTYMODE_swtch 6
X{ "start", 5, 0, '\0' }, /* tchars.t_startc */
X#define XTTYMODE_start 7
X{ "stop", 4, 0, '\0' }, /* tchars.t_stopc */
X#define XTTYMODE_stop 8
X{ "brk", 3, 0, '\0' }, /* tchars.t_brkc */
X#define XTTYMODE_brk 9
X{ "susp", 4, 0, '\0' }, /* ltchars.t_suspc */
X#define XTTYMODE_susp 10
X{ "dsusp", 5, 0, '\0' }, /* ltchars.t_dsuspc */
X#define XTTYMODE_dsusp 11
X{ "rprnt", 5, 0, '\0' }, /* ltchars.t_rprntc */
X#define XTTYMODE_rprnt 12
X{ "flush", 5, 0, '\0' }, /* ltchars.t_flushc */
X#define XTTYMODE_flush 13
X{ "weras", 5, 0, '\0' }, /* ltchars.t_werasc */
X#define XTTYMODE_weras 14
X{ "lnext", 5, 0, '\0' }, /* ltchars.t_lnextc */
X#define XTTYMODE_lnext 15
X{ NULL, 0, 0, '\0' }, /* end of data */
X};
X
X#ifdef USE_SYSV_UTMP
X#ifndef sgi
Xextern struct utmp *getutent();
Xextern struct utmp *getutid();
Xextern struct utmp *getutline();
Xextern void pututline();
Xextern void setutent();
Xextern void endutent();
Xextern void utmpname();
X
Xextern struct passwd *getpwent();
Xextern struct passwd *getpwuid();
Xextern struct passwd *getpwnam();
Xextern void setpwent();
Xextern void endpwent();
Xextern struct passwd *fgetpwent();
X#endif /* sgi */
X#else /* not USE_SYSV_UTMP */
Xstatic char etc_utmp[] = UTMP_FILENAME;
X#endif /* USE_SYSV_UTMP */
X
X#ifdef LASTLOG
Xstatic char etc_lastlog[] = LASTLOG_FILENAME;
X#endif
X#ifdef WTMP
Xstatic char etc_wtmp[] = WTMP_FILENAME;
X#endif
X
X/*
X * Some people with 4.3bsd /bin/login seem to like to use login -p -f user
X * to implement xterm -ls. They can turn on USE_LOGIN_DASH_P and turn off
X * WTMP and LASTLOG.
X */
X#ifdef USE_LOGIN_DASH_P
X#ifndef LOGIN_FILENAME
X#define LOGIN_FILENAME "/bin/login"
X#endif
Xstatic char bin_login[] = LOGIN_FILENAME;
X#endif
X
Xstatic int inhibit;
Xstatic char passedPty[2]; /* name if pty if slave */
X
X#ifdef TIOCCONS
Xstatic int Console;
X#endif /* TIOCCONS */
X#ifndef USE_SYSV_UTMP
Xstatic int tslot;
X#endif /* USE_SYSV_UTMP */
Xstatic jmp_buf env;
X
Xchar *ProgramName;
XBoolean sunFunctionKeys;
X
Xstatic struct _resource {
X char *xterm_name;
X char *icon_geometry;
X char *title;
X char *icon_name;
X char *term_name;
X char *tty_modes;
X Boolean utmpInhibit;
X Boolean
sunFunctionKeys; /* %%% should be widget resource? */
X Boolean wait_for_map;
X Boolean useInsertMode;
X} resource;
X
X/* used by VT (charproc.c) */
X
X#define offset(field) XtOffset(struct _resource *, field)
X
Xstatic XtResource application_resources[] = {
X {"name", "Name", XtRString, sizeof(char *),
X offset(xterm_name), XtRString, "xterm"},
X {"iconGeometry", "IconGeometry", XtRString, sizeof(char *),
X offset(icon_geometry), XtRString, (caddr_t) NULL},
X {XtNtitle, XtCTitle, XtRString, sizeof(char *),
X offset(title), XtRString, (caddr_t) NULL},
X {XtNiconName, XtCIconName, XtRString, sizeof(char *),
X offset(icon_name), XtRString, (caddr_t) NULL},
X {"termName", "TermName", XtRString, sizeof(char *),
X offset(term_name), XtRString, (caddr_t) NULL},
X {"ttyModes", "TtyModes", XtRString, sizeof(char *),
X offset(tty_modes), XtRString, (caddr_t) NULL},
X {"utmpInhibit", "UtmpInhibit", XtRBoolean, sizeof (Boolean),
X offset(utmpInhibit), XtRString, "false"},
X {"sunFunctionKeys", "SunFunctionKeys", XtRBoolean, sizeof (Boolean),
X offset(sunFunctionKeys), XtRString, "false"},
X {"waitForMap", "WaitForMap", XtRBoolean, sizeof (Boolean),
X offset(wait_for_map), XtRString, "false"},
X {"useInsertMode", "UseInsertMode", XtRBoolean, sizeof (Boolean),
X offset(useInsertMode), XtRString, "false"},
X};
X#undef offset
X
X/* Command line options table. Only resources are entered here...there is a
X pass over the remaining options after XtParseCommand is let loose. */
X
Xstatic char *fallback_resources[] = {
X "XTerm*SimpleMenu*menuLabel.vertSpace: 100",
X "XTerm*SimpleMenu*HorizontalMargins: 16",
X "XTerm*SimpleMenu*Sme.height: 16",
X "XTerm*SimpleMenu*Cursor: left_ptr",
X "XTerm*mainMenu.Label: Main Options (no app-defaults)",
X "XTerm*vtMenu.Label: VT Options (no app-defaults)",
X "XTerm*fontMenu.Label: VT Fonts (no app-defaults)",
X "XTerm*tekMenu.Label: Tek Options (no app-defaults)",
X NULL
X};
X
Xstatic XrmOptionDescRec optionDescList[] = {
X{"-geometry", "*vt100.geometry",XrmoptionSepArg, (caddr_t) NULL},
X{"-132", "*c132", XrmoptionNoArg, (caddr_t) "on"},
X{"+132", "*c132", XrmoptionNoArg, (caddr_t) "off"},
X{"-ah", "*alwaysHighlight", XrmoptionNoArg, (caddr_t) "on"},
X{"+ah", "*alwaysHighlight", XrmoptionNoArg, (caddr_t) "off"},
X{"-b", "*internalBorder",XrmoptionSepArg, (caddr_t) NULL},
X{"-cb", "*cutToBeginningOfLine", XrmoptionNoArg, (caddr_t) "off"},
X{"+cb", "*cutToBeginningOfLine", XrmoptionNoArg, (caddr_t) "on"},
X{"-cc", "*charClass", XrmoptionSepArg, (caddr_t) NULL},
X{"-cn", "*cutNewline", XrmoptionNoArg, (caddr_t) "off"},
X{"+cn", "*cutNewline", XrmoptionNoArg, (caddr_t) "on"},
X{"-cr", "*cursorColor", XrmoptionSepArg, (caddr_t) NULL},
X{"-cu", "*curses", XrmoptionNoArg, (caddr_t) "on"},
X{"+cu", "*curses", XrmoptionNoArg, (caddr_t) "off"},
X{"-dc", "*dynamicColors",XrmoptionNoArg, (caddr_t) "off"},
X{"+dc", "*dynamicColors",XrmoptionNoArg, (caddr_t) "on"},
X{"-e", NULL, XrmoptionSkipLine, (caddr_t) NULL},
X{"-fb", "*boldFont", XrmoptionSepArg, (caddr_t) NULL},
X{"-j", "*jumpScroll", XrmoptionNoArg, (caddr_t) "on"},
X{"+j", "*jumpScroll", XrmoptionNoArg, (caddr_t) "off"},
X{"-blt", "*bltScroll", XrmoptionNoArg, (caddr_t) "on"},
X{"+blt", "*bltScroll", XrmoptionNoArg, (caddr_t) "off"},
X{"-l", "*logging", XrmoptionNoArg, (caddr_t) "on"},
X{"+l", "*logging", XrmoptionNoArg, (caddr_t) "off"},
X{"-lf", "*logFile", XrmoptionSepArg, (caddr_t) NULL},
X{"-ls", "*loginShell", XrmoptionNoArg, (caddr_t) "on"},
X{"+ls", "*loginShell", XrmoptionNoArg, (caddr_t) "off"},
X{"-mb", "*marginBell", XrmoptionNoArg, (caddr_t) "on"},
X{"+mb", "*marginBell", XrmoptionNoArg, (caddr_t) "off"},
X{"-mc", "*multiClickTime", XrmoptionSepArg, (caddr_t) NULL},
X{"-ms", "*pointerColor",XrmoptionSepArg, (caddr_t) NULL},
X{"-nb", "*nMarginBell", XrmoptionSepArg, (caddr_t) NULL},
X{"-rw", "*reverseWrap", XrmoptionNoArg, (caddr_t) "on"},
X{"+rw", "*reverseWrap", XrmoptionNoArg, (caddr_t) "off"},
X{"-aw", "*autoWrap", XrmoptionNoArg, (caddr_t) "on"},
X{"+aw", "*autoWrap", XrmoptionNoArg, (caddr_t) "off"},
X{"-s", "*multiScroll", XrmoptionNoArg, (caddr_t) "on"},
X{"+s", "*multiScroll", XrmoptionNoArg, (caddr_t) "off"},
X{"-sb", "*scrollBar", XrmoptionNoArg, (caddr_t) "on"},
X{"+sb", "*scrollBar", XrmoptionNoArg, (caddr_t) "off"},
X{"-sf", "*sunFunctionKeys", XrmoptionNoArg, (caddr_t) "on"},
X{"+sf", "*sunFunctionKeys", XrmoptionNoArg, (caddr_t) "off"},
X{"-si", "*scrollTtyOutput", XrmoptionNoArg, (caddr_t) "off"},
X{"+si", "*scrollTtyOutput", XrmoptionNoArg, (caddr_t) "on"},
X{"-sk", "*scrollKey", XrmoptionNoArg, (caddr_t) "on"},
X{"+sk", "*scrollKey", XrmoptionNoArg, (caddr_t) "off"},
X{"-sl", "*saveLines", XrmoptionSepArg, (caddr_t) NULL},
X{"-t", "*tekStartup", XrmoptionNoArg, (caddr_t) "on"},
X{"+t", "*tekStartup", XrmoptionNoArg, (caddr_t) "off"},
X{"-tm", "*ttyModes", XrmoptionSepArg, (caddr_t) NULL},
X{"-tn", "*termName", XrmoptionSepArg, (caddr_t) NULL},
X{"-ut", "*utmpInhibit", XrmoptionNoArg, (caddr_t) "on"},
X{"+ut", "*utmpInhibit", XrmoptionNoArg, (caddr_t) "off"},
X{"-im", "*useInsertMode", XrmoptionNoArg, (caddr_t) "on"},
X{"+im", "*useInsertMode", XrmoptionNoArg, (caddr_t) "off"},
X{"-vb", "*visualBell", XrmoptionNoArg, (caddr_t) "on"},
X{"+vb", "*visualBell", XrmoptionNoArg, (caddr_t) "off"},
X{"-wf", "*waitForMap", XrmoptionNoArg, (caddr_t) "on"},
X{"+wf", "*waitForMap", XrmoptionNoArg, (caddr_t) "off"},
X/* bogus old compatibility stuff for which there are
X standard XtInitialize options now */
X{"%", "*tekGeometry", XrmoptionStickyArg, (caddr_t) NULL},
X{"#", ".iconGeometry",XrmoptionStickyArg, (caddr_t) NULL},
X{"-T", "*title", XrmoptionSepArg, (caddr_t) NULL},
X{"-n", "*iconName", XrmoptionSepArg, (caddr_t) NULL},
X{"-r", "*reverseVideo",XrmoptionNoArg, (caddr_t) "on"},
X{"+r", "*reverseVideo",XrmoptionNoArg, (caddr_t) "off"},
X{"-rv", "*reverseVideo",XrmoptionNoArg, (caddr_t) "on"},
X{"+rv", "*reverseVideo",XrmoptionNoArg, (caddr_t) "off"},
X{"-w", ".borderWidth", XrmoptionSepArg, (caddr_t) NULL},
X};
X
Xstatic struct _options {
X char *opt;
X char *desc;
X} options[] = {
X{ "-help", "print out this message" },
X{ "-display displayname", "X server to contact" },
X{ "-geometry geom", "size (in characters) and position" },
X{ "-/+rv", "turn on/off reverse video" },
X{ "-bg color", "background color" },
X{ "-fg color", "foreground color" },
X{ "-bd color", "border color" },
X{ "-bw number", "border width in pixels" },
X{ "-fn fontname", "normal text font" },
X{ "-iconic", "start iconic" },
X{ "-name string", "client instance, icon, and title strings" },
X{ "-title string", "title string" },
X{ "-xrm resourcestring", "additional resource specifications" },
X{ "-/+132", "turn on/off column switch inhibiting" },
X{ "-/+ah", "turn on/off always highlight" },
X{ "-b number", "internal border in pixels" },
X{ "-/+cb", "turn on/off cut-to-beginning-of-line inhibit" },
X{ "-cc classrange", "specify additional character classes" },
X{ "-/+cn", "turn on/off cut newline inhibit" },
X{ "-cr color", "text cursor color" },
X{ "-/+cu", "turn on/off curses emulation" },
X{ "-fb fontname", "bold text font" },
X{ "-/+im", "use insert mode for TERMCAP" },
X{ "-/+j", "turn on/off jump scroll" },
X{ "-/+blt", "turn on/off blt scroll" },
X{ "-/+l", "turn on/off logging" },
X{ "-lf filename", "logging filename" },
X{ "-/+ls", "turn on/off login shell" },
X{ "-/+mb", "turn on/off margin bell" },
X{ "-mc milliseconds", "multiclick time in milliseconds" },
X{ "-ms color", "pointer color" },
X{ "-nb number", "margin bell in characters from right end" },
X{ "-/+rw", "turn on/off reverse wraparound" },
X{ "-/+s", "turn on/off multiscroll" },
X{ "-/+sb", "turn on/off scrollbar" },
X{ "-/+sf", "turn on/off Sun Function Key escape codes" },
X{ "-/+si", "turn on/off scroll-on-tty-output inhibit" },
X{ "-/+sk", "turn on/off scroll-on-keypress" },
X{ "-sl number", "number of scrolled lines to save" },
X{ "-/+t", "turn on/off Tek emulation window" },
X{ "-tm string", "terminal mode keywords and characters" },
X{ "-tn name", "TERM environment variable name" },
X{ "-/+ut", "turn on/off utmp inhibit" },
X{ "-/+vb", "turn on/off visual bell" },
X{ "-e command args", "command to execute" },
X{ "%geom", "Tek window geometry" },
X{ "#geom", "icon window geometry" },
X{ "-T string", "title name for window" },
X{ "-n string", "icon name for window" },
X{ "-C", "intercept console messages, if supported" },
X{ "-Sxxd", "slave mode on \"ttyxx\", file descriptor \"d\"" },
X{ "-/+dc", "turn off/on dynamic color selection" },
X{ NULL, NULL }};
X
Xstatic char *message[] = {
X"Fonts must be fixed width and, if both normal and bold are specified, must",
X"have the same size. If only a normal font is specified, it will be used for",
X"both normal and bold text (by doing overstriking). The -e option, if given,",
X"must be appear at the end of the command line, otherwise the user's default",
X"shell will be started. Options that start with a plus sign (+) restore the",
X"default.",
XNULL};
X
Xstatic void Syntax (badOption)
X char *badOption;
X{
X struct _options *opt;
X int col;
X
X fprintf (stderr, "%s: bad command line option \"%s\"\r\n\n",
X ProgramName, badOption);
X
X fprintf (stderr, "usage: %s", ProgramName);
X col = 8 + strlen(ProgramName);
X for (opt = options; opt->opt; opt++) {
X int len = 3 + strlen(opt->opt); /* space [ string ] */
X if (col + len > 79) {
X fprintf (stderr, "\r\n "); /* 3 spaces */
X col = 3;
X }
X fprintf (stderr, " [%s]", opt->opt);
X col += len;
X }
X
X fprintf (stderr, "\r\n\nType %s -help for a full description.\r\n\n",
X ProgramName);
X exit (1);
X}
X
Xstatic void Help ()
X{
X struct _options *opt;
X char **cpp;
X
X fprintf (stderr, "usage:\n %s [-options ...] [-e command args]\n\n",
X ProgramName);
X fprintf (stderr, "where options include:\n");
X for (opt = options; opt->opt; opt++) {
X fprintf (stderr, " %-28s %s\n", opt->opt, opt->desc);
X }
X
X putc ('\n', stderr);
X for (cpp = message; *cpp; cpp++) {
X fputs (*cpp, stderr);
X putc ('\n', stderr);
X }
X putc ('\n', stderr);
X
X exit (0);
X}
X
X
Xextern WidgetClass xtermWidgetClass;
X
XArg ourTopLevelShellArgs[] = {
X { XtNallowShellResize, (XtArgVal) TRUE },
X { XtNinput, (XtArgVal) TRUE },
X};
Xint number_ourTopLevelShellArgs = 2;
X
XXtAppContext app_con;
XWidget toplevel;
XBool waiting_for_initial_map;
X
Xmain (argc, argv)
Xint argc;
Xchar **argv;
X{
X register TScreen *screen;
X register int i, pty;
X int Xsocket, mode;
X char *basename();
X int xerror(), xioerror();
X
X ProgramName = argv[0];
X
X ttydev = (char *) malloc (strlen (TTYDEV) + 1);
X ptydev = (char *) malloc (strlen (PTYDEV) + 1);
X if (!ttydev || !ptydev) {
X fprintf (stderr,
X "%s: unable to allocate memory for ttydev or ptydev\n",
X ProgramName);
X exit (1);
X }
X strcpy (ttydev, TTYDEV);
X strcpy (ptydev, PTYDEV);
X
X#ifdef USE_SYSV_TERMIO
X /* Initialization is done here rather than above in order
X ** to prevent any assumptions about the order of the contents
X ** of the various terminal structures (which may change from
X ** implementation to implementation).
X */
X d_tio.c_iflag = ICRNL|IXON;
X d_tio.c_oflag = OPOST|ONLCR|TAB3;
X d_tio.c_cflag = CS8|CREAD|PARENB|HUPCL;
X#if defined att || defined macII || !defined BAUD_0
X#ifdef B38400
X d_tio.c_cflag |= B38400;
X#else /* !B38400 */
X#ifdef B19200
X d_tio.c_cflag |= B19200;
X#else /* !B19200 */
X d_tio.c_cflag |= B9600;
X#endif /* !B19200 */
X#endif /* !B38400 */
X#endif /* defined att || defined macII || !defined BAUD_0 */
X d_tio.c_lflag = ISIG|ICANON|ECHO|ECHOE|ECHOK;
X#ifdef NTTYDISC
X d_tio.c_cflag &= ~(HUPCL|PARENB);
X d_tio.c_iflag |= BRKINT|ISTRIP|IGNPAR;
X d_tio.c_line = NTTYDISC;
X#else
X d_tio.c_line = 0;
X#endif /* NTTYDISC */
X
X#ifdef CINTR
X d_tio.c_cc[VINTR] = CINTR; /* DEL */
X#else
X d_tio.c_cc[VINTR] = 0x7f; /* DEL */
X#endif /* CINTR */
X#ifdef CQUIT
X d_tio.c_cc[VQUIT] = CQUIT;
X#else
X d_tio.c_cc[VQUIT] = '\\' & 0x3f; /* '^\' */
X#endif /* CQUIT */
X#ifdef CERASE
X d_tio.c_cc[VERASE] = CERASE;
X#else
X d_tio.c_cc[VERASE] = '#'; /* '#' */
X#endif /* CERASE */
X#ifdef CKILL
X d_tio.c_cc[VKILL] = CKILL;
X#else
X d_tio.c_cc[VKILL] = '@'; /* '@' */
X#endif /* CKILL */
X#ifdef CEOF
X d_tio.c_cc[VEOF] = CEOF;
X#else
X d_tio.c_cc[VEOF] = 'D' & 0x3f; /* '^D' */
X#endif /* CEOF */
X#ifdef CNUL
X d_tio.c_cc[VEOL] = CNUL;
X#else
X d_tio.c_cc[VEOL] = '@' & 0x3f; /* '^@' */
X#endif /* CNUL */
X#ifdef VSWTCH
X#ifdef CSWTCH
X d_tio.c_cc[VSWTCH] = CSWTCH; /* usually '^Z' */
X#else
X#if defined(macII) || defined(att)
X d_tio.c_cc[VSWTCH] = CNUL;
X#else
X d_tio.c_cc[VSWTCH] = '@' & 0x3f; /* '^@' */
X#endif /* defined(macII) || defined(att) */
X#endif /* CSWTCH */
X#endif /* VSWTCH */
X#ifdef VEOL2
X d_tio.c_cc[VEOL2] = CNUL;
X#endif
X#ifdef VLNEXT
X d_tio.c_cc[VLNEXT] = CLNEXT ;
X#endif
X#ifdef VWERASE
X d_tio.c_cc[VWERASE] = CWERASE ;
X#endif
X#ifdef VRPRNT
X d_tio.c_cc[VRPRNT] = CRPRNT ;
X#endif
X#ifdef VFLUSHO
X d_tio.c_cc[VFLUSHO] = CFLUSH ;
X#endif
X#ifdef VSTOP
X d_tio.c_cc[VSTOP] = CSTOP ;
X#endif
X#ifdef VSTART
X d_tio.c_cc[VSTART] = CSTART ;
X#endif
X /* now, try to inherit tty settings */
X {
X int i;
X
X for (i = 0; i <= 2; i++) {
X struct termio deftio;
X if (ioctl (i, TCGETA, &deftio) == 0) {
X d_tio.c_cc[VINTR] = deftio.c_cc[VINTR];
X d_tio.c_cc[VQUIT] = deftio.c_cc[VQUIT];
X d_tio.c_cc[VERASE] = deftio.c_cc[VERASE];
X d_tio.c_cc[VKILL] = deftio.c_cc[VKILL];
X d_tio.c_cc[VEOF] = deftio.c_cc[VEOF];
X d_tio.c_cc[VEOL] = deftio.c_cc[VEOL];
X#ifdef VSWTCH
X d_tio.c_cc[VSWTCH] = deftio.c_cc[VSWTCH];
X#endif /* VSWTCH */
X#ifdef VEOL2
X d_tio.c_cc[VEOL2] = deftio.c_cc[VEOL2];
X#endif
X#ifdef VLNEXT
X d_tio.c_cc[VLNEXT] = deftio.c_cc[VLNEXT];
X#endif
X#ifdef VWERASE
X d_tio.c_cc[VWERASE] = deftio.c_cc[VWERASE];
X#endif
X#ifdef VRPRNT
X d_tio.c_cc[VRPRNT] = deftio.c_cc[VRPRNT];
X#endif
X#ifdef VFLUSHO
X d_tio.c_cc[VFLUSHO] = deftio.c_cc[VFLUSHO];
X#endif
X#ifdef VSTOP
X d_tio.c_cc[VSTOP] = deftio.c_cc[VSTOP];
X#endif
X#ifdef VSTART
X d_tio.c_cc[VSTART] = deftio.c_cc[VSTART];
X#endif
X break;
X }
X }
X }
X#ifdef TIOCSLTC
X#ifdef CSUSP
X d_ltc.t_suspc = CSUSP; /* t_suspc */
X#else
X d_ltc.t_suspc = '\000'; /* t_suspc */
X#endif /* CSUSP */
X#ifdef CDSUSP
X d_ltc.t_dsuspc = CDSUSP; /* t_dsuspc */
X#else
X d_ltc.t_dsuspc = '\000'; /* t_dsuspc */
X#endif /* CDSUSP */
X#if defined macII || defined att
X d_ltc.t_rprntc = 0; /* reserved...*/
X d_ltc.t_flushc = 0;
X d_ltc.t_werasc = 0;
X d_ltc.t_lnextc = 0;
X#else /* !defined macII && !defined att */
X#ifdef CRPRNT
X d_ltc.t_rprntc = CRPRNT; /* reserved...*/
X#else
X d_ltc.t_rprntc = '\377'; /* reserved...*/
X#endif /* CRPRNT */
X#ifdef CFLUSH
X d_ltc.t_flushc = CFLUSH;
X#else
X d_ltc.t_flushc = '\377';
X#endif /* CFLUSH */
X#ifdef CWERASE
X d_ltc.t_werasc = CWERASE;
X#else
X d_ltc.t_werasc = '\377';
X#endif /* CWERASE */
X#ifdef CLNEXT
X d_ltc.t_lnextc = CLNEXT;
X#else
X d_ltc.t_lnextc = '\377';
X#endif
X#endif /* !defined macII && !defined att */
X#endif /* TIOCSLTC */
X#ifdef TIOCLSET
X d_lmode = 0;
X#endif /* TIOCLSET */
X#endif /* USE_SYSV_TERMIO */
X
X /* Init the Toolkit. */
X toplevel = XtAppInitialize (&app_con, "XTerm",
X optionDescList, XtNumber(optionDescList),
X (Cardinal *) &argc, argv,
X fallback_resources, NULL, 0);
X
X XtGetApplicationResources( toplevel, (XtPointer) &resource,
X application_resources,
X XtNumber(application_resources), NULL, 0 );
X
X waiting_for_initial_map = resource.wait_for_map;
X
X /*
X * fill in terminal modes
X */
X if (resource.tty_modes) {
X int n = parse_tty_modes (resource.tty_modes, ttymodelist);
X if (n < 0) {
X fprintf (stderr, "%s: bad tty modes \"%s\"\n",
X ProgramName, resource.tty_modes);
X } else if (n > 0) {
X override_tty_modes = 1;
X }
X }
X
X xterm_name = resource.xterm_name;
X sunFunctionKeys = resource.sunFunctionKeys;
X if (strcmp(xterm_name, "-") == 0) xterm_name = "xterm";
X if (resource.icon_geometry != NULL) {
X int scr, junk;
X int ix, iy;
X Arg args[2];
X
X for(scr = 0; /* yyuucchh */
X XtScreen(toplevel) != ScreenOfDisplay(XtDisplay(toplevel),scr);
X scr++);
X
X args[0].name = XtNiconX;
X args[1].name = XtNiconY;
X XGeometry(XtDisplay(toplevel), scr, resource.icon_geometry, "",
X 0, 0, 0, 0, 0, &ix, &iy, &junk, &junk);
X args[0].value = (XtArgVal) ix;
X args[1].value = (XtArgVal) iy;
X XtSetValues( toplevel, args, 2);
X }
X
X XtSetValues (toplevel, ourTopLevelShellArgs,
X number_ourTopLevelShellArgs);
X
X
X /* Parse the rest of the command line */
X for (argc--, argv++ ; argc > 0 ; argc--, argv++) {
X if(**argv != '-') Syntax (*argv);
X
X switch(argv[0][1]) {
X case 'h':
X Help ();
X /* NOTREACHED */
X case 'C':
X#ifdef TIOCCONS
X Console = TRUE;
X#else
X (void) fprintf(stderr, "%s: console function unavailable\n",
X xterm_name);
X#endif /* TIOCCONS */
X continue;
X case 'S':
X if (sscanf(*argv + 2, "%c%c%d", passedPty, passedPty+1,
X &am_slave) != 3)
X Syntax(*argv);
X continue;
X#ifdef DEBUG
X case 'D':
X debug = TRUE;
X continue;
X#endif /* DEBUG */
X case 'e':
X if (argc <= 1) Syntax (*argv);
X command_to_exec = ++argv;
X break;
X default:
X Syntax (*argv);
X }
X break;
X }
X
X XawSimpleMenuAddGlobalActions (XtWidgetToApplicationContext(toplevel));
X XtRegisterGrabAction (HandlePopupMenu, True,
X (ButtonPressMask|ButtonReleaseMask),
X GrabModeAsync, GrabModeAsync);
X
X term = (XtermWidget) XtCreateManagedWidget(
X "vt100", xtermWidgetClass, toplevel, NULL, 0);
X /* this causes the initialize method to be called */
X
X screen = &term->screen;
X
X if (screen->savelines < 0) screen->savelines = 0;
X
X term->flags = 0;
X
X if (!screen->jumpscroll) {
X term->flags |= SMOOTHSCROLL;
X update_jumpscroll();
X }
X update_bltscroll();
X if (term->misc.reverseWrap) {
X term->flags |= REVERSEWRAP;
X update_reversewrap();
X }
X if (term->misc.autoWrap) {
X term->flags |= WRAPAROUND;
X update_autowrap();
X }
X if (term->misc.re_verse) {
X term->flags |= REVERSE_VIDEO;
X update_reversevideo();
X }
X
X inhibit = 0;
X if (term->misc.logInhibit) inhibit |= I_LOG;
X if (term->misc.signalInhibit) inhibit |= I_SIGNAL;
X if (term->misc.tekInhibit) inhibit |= I_TEK;
X
X term->initflags = term->flags;
X
X/*
X * Set title and icon name if not specified
X */
X
X if (command_to_exec) {
X Arg args[2];
X
X if (!resource.title) {
X if (command_to_exec) {
X resource.title = basename (command_to_exec[0]);
X } /* else not reached */
X }
X
X if (!resource.icon_name)
X resource.icon_name = resource.title;
X XtSetArg (args[0], XtNtitle, resource.title);
X XtSetArg (args[1], XtNiconName, resource.icon_name);
X
X XtSetValues (toplevel, args, 2);
X }
X
X
X if(inhibit & I_TEK)
X screen->TekEmu = FALSE;
X
X if(screen->TekEmu && !TekInit())
X exit(ERROR_INIT);
X
X /* set up stderr properly */
X i = -1;
X#ifdef DEBUG
X if(debug)
X i = open ("xterm.debug.log", O_WRONLY | O_CREAT | O_TRUNC,
X 0666);
X#endif /* DEBUG */
X if(i >= 0) {
X#ifdef USE_SYSV_TERMIO
X /* SYSV has another pointer which should be part of the
X ** FILE structure but is actually a seperate array.
X */
X unsigned char *old_bufend;
X
X old_bufend = (unsigned char *) _bufend(stderr);
X stderr->_file = i;
X _bufend(stderr) = old_bufend;
X#else /* USE_SYSV_TERMIO */
X stderr->_file = i;
X#endif /* USE_SYSV_TERMIO */
X
X /* mark this file as close on exec */
X (void) fcntl(i, F_SETFD, 1);
X }
X
X /* open a terminal for client */
X get_terminal ();
X spawn ();
X /* Child process is out there, let's catch it's termination */
X signal (SIGCHLD, reapchild);
X
X /* Realize procs have now been executed */
X
X Xsocket = screen->display->fd;
X pty = screen->respond;
X
X if (am_slave) { /* Write window id so master end can read and use */
X char buf[80];
X
X buf[0] = '\0';
X sprintf (buf, "%lx\n",
X screen->TekEmu ? XtWindow (XtParent (tekWidget)) :
X XtWindow (XtParent (term)));
X write (pty, buf, strlen (buf));
X }
X
X if (term->misc.log_on) {
X StartLog(screen);
X }
X screen->inhibit = inhibit;
X
X#ifdef USE_SYSV_TERMIO
X if (0 > (mode = fcntl(pty, F_GETFL, 0)))
X Error();
X mode |= O_NDELAY;
X if (fcntl(pty, F_SETFL, mode))
X Error();
X#else /* USE_SYSV_TERMIO */
END_OF_FILE
if test 29484 -ne `wc -c <'xterm/main.c.aa'`; then
echo shar: \"'xterm/main.c.aa'\" unpacked with wrong size!
fi
# end of 'xterm/main.c.aa'
fi
if test -f 'xterm/termcap' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'xterm/termcap'\"
else
echo shar: Extracting \"'xterm/termcap'\" \(923 characters\)
sed "s/^X//" >'xterm/termcap' <<'END_OF_FILE'
X# @(#)termcap X10/6.6 11/7/86
X# if you don't insert mode applications very often (e.g. vi), replace the
X# line that reads
X#
X# :im=\E[4h:ei=\E[4l:mi:\
X#
X# with one that reads
X#
X# :ic=\E[@:\
X#
Xvs|xterm|vs100|xterm terminal emulator (X window system):\
X :AL=\E[%dL:DC=\E[%dP:DL=\E[%dM:DO=\E[%dB:IC=\E[%d@:MT:UP=\E[%dA:\
X :al=\E[L:am:\
X :bs:cd=\E[J:ce=\E[K:cl=\E[H\E[2J:cm=\E[%i%d;%dH:co#80:\
X :cs=\E[%i%d;%dr:ct=\E[3k:\
X :dc=\E[P:dl=\E[M:do=^J:\
X :ei=\E[4l:ho=\E[H:im=\E[4h:is=\E[r\E[m\E[2J\E[H\E[?7h\E[?1;3;4;6l:\
X :k1=\EOP:k2=\EOQ:k3=\EOR:k4=\EOS:kb=^H:kd=\EOB:ke=\E[?1l\E>:\
X :kl=\EOD:kn#4:kr=\EOC:ks=\E[?1h\E=:ku=\EOA:\
X :le=^H:li#65:md=\E[1m:me=\E[m:mi:mr=\E[7m:ms:nd=\E[C:pt:\
X :rs=\E[r\E<\E[m\E[2J\E[H\E[?7h\E[?1;3;4;6l:\
X :se=\E[m:sf=\n:so=\E[7m:sr=\EM:\
X :te=\E[2J\E[?47l\E8:ti=\E7\E[?47h:\
X :ue=\E[m:up=\E[A:us=\E[4m:xn:
Xv2|xterms|vs100s|xterm terminal emulator (small)(X window system):\
X :co#80:li#24:tc=xterm:
END_OF_FILE
if test 923 -ne `wc -c <'xterm/termcap'`; then
echo shar: \"'xterm/termcap'\" unpacked with wrong size!
fi
# end of 'xterm/termcap'
fi
echo shar: End of archive 6 \(of 14\).
cp /dev/null ark6isdone
MISSING=""
for I in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 ; do
if test ! -f ark${I}isdone ; then
MISSING="${MISSING} ${I}"
fi
done
if test "${MISSING}" = "" ; then
echo You have unpacked all 14 archives.
rm -f ark[1-9]isdone ark[1-9][0-9]isdone
else
echo You still need to unpack the following archives:
echo " " ${MISSING}
fi
## End of shell archive.
exit 0
dan
----------------------------------------------------
O'Reilly && Associates argv@sun.com / argv@ora.com
Opinions expressed reflect those of the author only.