misc.c

源码,标准c++用力

			return;
		}

		if(access(screen->logfile, F_OK) != 0
		   || access(screen->logfile, W_OK) != 0)
		    return;
		if((screen->logfd = open(screen->logfile, O_WRONLY | O_APPEND,
					 0644)) < 0)
			return;
	}
	screen->logstart = screen->TekEmu ? Tbptr : bptr;
	screen->logging = TRUE;
	update_logging();
}

CloseLog(screen)
register TScreen *screen;
{
	if(!screen->logging || (screen->inhibit & I_LOG))
		return;
	FlushLog(screen);
	close(screen->logfd);
	screen->logging = FALSE;
	update_logging();
}

FlushLog(screen)
register TScreen *screen;
{
	register Char *cp;
	register int i;

	cp = screen->TekEmu ? Tbptr : bptr;
	if((i = cp - screen->logstart) > 0)
		write(screen->logfd, (char *)screen->logstart, i);
	screen->logstart = screen->TekEmu ? Tbuffer : buffer;
}

#ifdef ALLOWLOGFILEEXEC
void logpipe()
{
	register TScreen *screen = &term->screen;

#ifdef SYSV
	(void) signal(SIGPIPE, SIG_IGN);
#endif	/* SYSV */
	if(screen->logging)
		CloseLog(screen);
}
#endif /* ALLOWLOGFILEEXEC */
#endif /* ALLOWLOGGING */


do_osc(func)
int (*func)();
{
	register int mode, c;
	register char *cp;
	char buf[512];
	char *bufend = &buf[(sizeof buf) - 1];	/* leave room for null */
	Bool okay = True;

	/* 
	 * lines should be of the form <ESC> ] number ; string <BEL>
	 *
	 * where number is one of 0, 1, 2, or 46
	 */
	mode = 0;
	while(isdigit(c = (*func)()))
		mode = 10 * mode + (c - '0');
	if (c != ';') okay = False;
	cp = buf;
	while(isprint((c = (*func)()) & 0x7f) && cp < bufend)
		*cp++ = c;
	if (c != 7) okay = False;
	*cp = 0;
	if (okay) switch(mode) {
	 case 0:	/* new icon name and title*/
		Changename(buf);
		Changetitle(buf);
		break;

	 case 1:	/* new icon name only */
		Changename(buf);
		break;

	 case 2:	/* new title only */
		Changetitle(buf);
		break;

	case 10:	case 11:	case 12:
	case 13:	case 14:	case 15:
	case 16:
		{
			extern Boolean ChangeColorsRequest();
			if (term->misc.dynamicColors)
			ChangeColorsRequest(term,mode-10,buf);
		}
		break;


#ifdef ALLOWLOGGING
	 case 46:	/* new log file */
#ifdef ALLOWLOGFILECHANGES
		/*
		 * Warning, enabling this feature allows people to overwrite
		 * arbitrary files accessible to the person running xterm.
		 */
		if((cp = malloc((unsigned)strlen(buf) + 1)) == NULL)
			break;
		strcpy(cp, buf);
		if(term->screen.logfile)
			free(term->screen.logfile);
		term->screen.logfile = cp;
#else
		Bell();
		Bell();
#endif
		break;
#endif /* ALLOWLOGGING */

	case 50:
		SetVTFont (fontMenu_fontescape, True, buf, NULL);
		break;

	/*
	 * One could write code to send back the display and host names,
	 * but that could potentially open a fairly nasty security hole.
	 */
	}
}

static ChangeGroup(attribute, value)
     String attribute;
     XtArgVal value;
{
	extern Widget toplevel;
	Arg args[1];

	XtSetArg( args[0], attribute, value );
	XtSetValues( toplevel, args, 1 );
}

Changename(name)
register char *name;
{
    ChangeGroup( XtNiconName, (XtArgVal)name );
}

Changetitle(name)
register char *name;
{
    ChangeGroup( XtNtitle, (XtArgVal)name );
}

/***================================================================***/

ScrnColors		*pOldColors= NULL;

Boolean
GetOldColors(pTerm)
XtermWidget	pTerm;
{
int i;
	if (pOldColors==NULL) {
		pOldColors= (ScrnColors *)XtMalloc(sizeof(ScrnColors));
	if (pOldColors==NULL) {
		fprintf(stderr,"allocation failure in GetOldColors\n");
		return(FALSE);
	}
	pOldColors->which= 0;
	for (i=0;i<NCOLORS;i++) {
		pOldColors->colors[i]=	0;
		pOldColors->names[i]=	NULL;
	}
	GetColors(pTerm,pOldColors);
		}
		return(TRUE);
}

Boolean
UpdateOldColors(pTerm,pNew)
XtermWidget	pTerm;
ScrnColors	*pNew;
{
int i;

	/* if we were going to free old colors, this would be the place to
	 * do it.  I've decided not to (for now), because it seems likely
	 * that we'd have a small set of colors we use over and over, and that
	 * we could save some overhead this way.  The only case in which this
	 * (clearly) fails is if someone is trying a boatload of colors, in
	 * which case they can restart xterm
	 */
	for (i=0;i<NCOLORS;i++) {
	if (COLOR_DEFINED(pNew,i)) {
		if (pOldColors->names[i]!=NULL) {
		XtFree(pOldColors->names[i]);
		pOldColors->names[i]= NULL;
		}
		if (pNew->names[i]) {
		pOldColors->names[i]= pNew->names[i];
		}
		pOldColors->colors[i]=	pNew->colors[i];
	}
	}
	return(TRUE);
}

void
ReverseOldColors()
{
register ScrnColors *pOld= pOldColors;
Pixel	tmpPix;
char *tmpName;

	if (pOld) {
	/* change text cursor, if necessary */
	if (pOld->colors[TEXT_CURSOR]==pOld->colors[TEXT_FG]) {
		pOld->colors[TEXT_CURSOR]=	pOld->colors[TEXT_BG];
		if (pOld->names[TEXT_CURSOR]) {
		XtFree(pOldColors->names[TEXT_CURSOR]);
		pOld->names[TEXT_CURSOR]= NULL;
		}
		if (pOld->names[TEXT_BG]) {
		tmpName= XtMalloc(strlen(pOld->names[TEXT_BG])+1);
		if (tmpName) {
			strcpy(tmpName,pOld->names[TEXT_BG]);
			pOld->names[TEXT_CURSOR]= tmpName;
		}
		}
	}

	/* swap text FG and BG */
	tmpPix=		pOld->colors[TEXT_FG];
	tmpName=	pOld->names[TEXT_FG];
	pOld->colors[TEXT_FG]=	pOld->colors[TEXT_BG];
	pOld->names[TEXT_FG]=	pOld->names[TEXT_BG];
	pOld->colors[TEXT_BG]=	tmpPix;
	pOld->names[TEXT_BG]=	tmpName;

	/* swap mouse FG and BG */
	tmpPix=		pOld->colors[MOUSE_FG];
	tmpName=	pOld->names[MOUSE_FG];
	pOld->colors[MOUSE_FG]=	pOld->colors[MOUSE_BG];
	pOld->names[MOUSE_FG]=	pOld->names[MOUSE_BG];
	pOld->colors[MOUSE_BG]=	tmpPix;
	pOld->names[MOUSE_BG]=	tmpName;

	/* swap Tek FG and BG */
	tmpPix=		pOld->colors[TEK_FG];
	tmpName= 	pOld->names[TEK_BG];
	pOld->colors[TEK_FG]=	pOld->colors[TEK_BG];
	pOld->names[TEK_FG]=	pOld->names[TEK_BG];
	pOld->colors[TEK_BG]=	tmpPix;
	pOld->names[TEK_BG]=	tmpName;
		}
		return;
}

Boolean 
AllocateColor(pTerm,pNew,ndx,name)
XtermWidget		pTerm;
ScrnColors		*pNew;
int 		ndx;
char		*name;
{
XColor			def;
register TScreen	*screen=	&pTerm->screen;
Colormap	cmap=	pTerm->core.colormap;
char	*newName;

	if ((XParseColor(screen->display,cmap,name,&def))&&
		(XAllocColor(screen->display,cmap,&def))) {
		SET_COLOR_VALUE(pNew,ndx,def.pixel);
		newName= XtMalloc(strlen(name)+1);
		if (newName) {
			strcpy(newName,name);
			SET_COLOR_NAME(pNew,ndx,newName);
		}
		return(TRUE);
	}
	return (FALSE);
}

Boolean
ChangeColorsRequest(pTerm,start,names)
XtermWidget		pTerm;
int		start;
register char *names;
{
char		*thisName;
ScrnColors	newColors;
int			i,ndx;

	if ((pOldColors==NULL)&&(!GetOldColors(pTerm))) {
		return(FALSE);
	}
	newColors.which=	0;
	for (i=0;i<NCOLORS;i++) {
		newColors.names[i]= NULL;
	}
	for (i=start;i<NCOLORS;i++) {
		if (term->misc.re_verse)	ndx=	OPPOSITE_COLOR(i);
		else		ndx=	i;
		if ((names==NULL)||(names[0]=='\0')) {
			newColors.names[ndx]=	NULL;
		}
		else {
			if (names[0]==';')
			 thisName=	NULL;
			else thisName=	names;
			names=	index(names,';');
			if (names!=NULL) {
			*names= '\0';
			names++;
			}
			if ((!pOldColors->names[ndx])||
			(thisName&&(strcmp(thisName,pOldColors->names[ndx])))) {
			AllocateColor(pTerm,&newColors,ndx,thisName);
			}
		}
	}
	
	if (newColors.which==0)
		return(TRUE);
	
	ChangeColors(pTerm,&newColors);
	UpdateOldColors(pTerm,&newColors);
	return(TRUE);
}

/***===============================================================***/

#ifndef DEBUG
/* ARGSUSED */
#endif
Panic(s, a)
char	*s;
int a;
{
#ifdef DEBUG
	if(debug) {
		fprintf(stderr, "%s: PANIC!	", xterm_name);
		fprintf(stderr, s, a);
		fputs("\r\n", stderr);
		fflush(stderr);
	}
#endif	/* DEBUG */
}

char *SysErrorMsg (n)
    int n;
{
#ifndef DONT_DECLARE_ERRLIST      /* The declarations are only needed
								   * if not in errno.h   -- JLM */
    extern char *sys_errlist[];
    extern int sys_nerr;
#endif

    return ((n >= 0 && n < sys_nerr) ? sys_errlist[n] : "unknown error");
}


SysError (i)
int i;
{
	int oerrno;

	oerrno = errno;
	/* perror(3) write(2)s to file descriptor 2 */
	fprintf (stderr, "%s: Error %d, errno %d: ", xterm_name, i, oerrno);
	fprintf (stderr, "%s\n", SysErrorMsg (oerrno));
	Cleanup(i);
}

Error (i)
int i;
{
	fprintf (stderr, "%s: Error %d\n", xterm_name, i);
	Cleanup(i);
}


/*
 * cleanup by sending SIGHUP to client processes
 */
Cleanup (code)
int code;
{
	extern XtermWidget term;
	register TScreen *screen;

	screen = &term->screen;
	if (screen->pid > 1) {
	    (void) kill_process_group (screen->pid, SIGHUP);
	}
	Exit (code);
}

/*
 * sets the value of var to be arg in the Unix 4.2 BSD environment env.
 * Var should end with '=' (bindings are of the form "var=value").
 * This procedure assumes the memory for the first level of environ
 * was allocated using calloc, with enough extra room at the end so not
 * to have to do a realloc().
 */
Setenv (var, value)
register char *var, *value;
{
	extern char **environ;
	register int envindex = 0;
	register int len = strlen(var);

	while (environ [envindex] != NULL) {
	    if (strncmp (environ [envindex], var, len) == 0) {
		/* found it */
		environ[envindex] = (char *)malloc ((unsigned)len + strlen (value) + 1);
		strcpy (environ [envindex], var);
		strcat (environ [envindex], value);
		return;
	    }
	    envindex ++;
	}

#ifdef DEBUG
	if (debug) fputs ("expanding env\n", stderr);
#endif	/* DEBUG */

	environ [envindex] = (char *) malloc ((unsigned)len + strlen (value) + 1);
	(void) strcpy (environ [envindex], var);
	strcat (environ [envindex], value);
	environ [++envindex] = NULL;
}

/*
 * returns a pointer to the first occurrence of s2 in s1,
 * or NULL if there are none.
 */
char *strindex (s1, s2)
register char	*s1, *s2;
{
	register char	*s3;
	int s2len = strlen (s2);

	while ((s3=index(s1, *s2)) != NULL) {
		if (strncmp(s3, s2, s2len) == 0)
			return (s3);
		s1 = ++s3;
	}
	return (NULL);
}

/*ARGSUSED*/
xerror(d, ev)
Display *d;
register XErrorEvent *ev;
{
    fprintf (stderr, "%s:  warning, error event receieved:\n", xterm_name);
    (void) XmuPrintDefaultErrorMessage (d, ev, stderr);
    Exit (ERROR_XERROR);
}

/*ARGSUSED*/
xioerror(dpy)
Display *dpy;
{
    (void) fprintf (stderr, 
		    "%s:  fatal IO error %d (%s) or KillClient on X server \"%s\"\r\n",
		    xterm_name, errno, SysErrorMsg (errno),
		    DisplayString (dpy));

    Exit(ERROR_XIOERROR);
}

XStrCmp(s1, s2)
char *s1, *s2;
{
  if (s1 && s2) return(strcmp(s1, s2));
  if (s1 && *s1) return(1);
  if (s2 && *s2) return(-1);
  return(0);
}

static void withdraw_window (dpy, w, scr)
    Display *dpy;
    Window w;
    int scr;
{
    (void) XmuUpdateMapHints (dpy, w, NULL);
    XWithdrawWindow (dpy, w, scr);
    return;
}


void set_vt_visibility (on)
    Boolean on;
{
    register TScreen *screen = &term->screen;

    if (on) {
	if (!screen->Vshow && term) {
	    VTInit ();
	    XtMapWidget (term->core.parent);
	    screen->Vshow = TRUE;
	}
    } else {
	if (screen->Vshow && term) {
	    withdraw_window (XtDisplay (term), 
			     XtWindow(XtParent(term)),
			     XScreenNumberOfScreen(XtScreen(term)));
	    screen->Vshow = FALSE;
	}
    }
    set_vthide_sensitivity();
    set_tekhide_sensitivity();
    update_vttekmode();
    update_tekshow();
    update_vtshow();
    return;
}
				
extern Atom wm_delete_window;	/* for ICCCM delete window */

void set_tek_visibility (on)
    Boolean on;
{
    register TScreen *screen = &term->screen;
    if (on) {
	if (!screen->Tshow && (tekWidget || TekInit())) {
	    Widget tekParent = tekWidget->core.parent;
	    XtRealizeWidget (tekParent);
	    XtMapWidget (tekParent);
	    XtOverrideTranslations(tekParent,
				   XtParseTranslationTable
				   ("<Message>WM_PROTOCOLS: DeleteWindow()"));
	    (void) XSetWMProtocols (XtDisplay(tekParent), 
				    XtWindow(tekParent),
				    &wm_delete_window, 1);
	    screen->Tshow = TRUE;
	}
    } else {
	if (screen->Tshow && tekWidget) {
	    withdraw_window (XtDisplay (tekWidget), 
			     XtWindow(XtParent(tekWidget)),
			     XScreenNumberOfScreen(XtScreen(tekWidget)));
	    screen->Tshow = FALSE;
	}
    }
    set_tekhide_sensitivity();
    set_vthide_sensitivity();
    update_vtshow();
    update_tekshow();
    update_vttekmode();
    return;
}

void end_tek_mode ()
{
    register TScreen *screen = &term->screen;

    if (screen->TekEmu) {
#ifdef ALLOWLOGGING
	if (screen->logging) {
	    FlushLog (screen);
	    screen->logstart = buffer;
	}
#endif
	longjmp(Tekend, 1);
    } 
    return;
}

void end_vt_mode ()
{
    register TScreen *screen = &term->screen;

    if (!screen->TekEmu) {
#ifdef ALLOWLOGGING
	if(screen->logging) {
	    FlushLog(screen);
	    screen->logstart = Tbuffer;
	}
#endif
	screen->TekEmu = TRUE;
	longjmp(VTend, 1);
    } 
    return;
}

void switch_modes (tovt)
    Bool tovt;				/* if true, then become vt mode */
{
    if (tovt) {
	if (TekRefresh) dorefresh();
	end_tek_mode ();		/* WARNING: this does a longjmp... */
    } else {
	end_vt_mode ();			/* WARNING: this does a longjmp... */
    }
}

void hide_vt_window ()
{
    register TScreen *screen = &term->screen;

    set_vt_visibility (FALSE);
    if (!screen->TekEmu) switch_modes (False);	/* switch to tek mode */
}

void hide_tek_window ()
{
    register TScreen *screen = &term->screen;

    set_tek_visibility (FALSE);
    TekRefresh = (TekLink *)0;
    if (screen->TekEmu) switch_modes (True);	/* does longjmp to vt mode */
}