Return to x.c CVS log

Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / bin / csh

Power 6/32 Unix version 1.21

char	xstr[];
#line 1 "sh.time.c"

static char sccsid[] = (&xstr[4268]);



#line 1 "./sh.h"



#line 1 "./sh.local.h"














































#line 51 "./sh.local.h"

#line 4 "./sh.h"

#line 1 "/DIST/usr/include/sys/time.h"






struct timeval {
	long	tv_sec;		
	long	tv_usec;	
};

struct timezone {
	int	tz_minuteswest;	
	int	tz_dsttime;	
};


























struct	itimerval {
	struct	timeval it_interval;	
	struct	timeval it_value;	
};




struct tm {
	int	tm_sec;
	int	tm_min;
	int	tm_hour;
	int	tm_mday;
	int	tm_mon;
	int	tm_year;
	int	tm_wday;
	int	tm_yday;
	int	tm_isdst;
};


extern	struct tm *gmtime(), *localtime();
extern	char *asctime(), *ctime();

#line 5 "./sh.h"

#line 1 "/DIST/usr/include/sys/resource.h"



















struct	rusage {
	struct timeval ru_utime;	
	struct timeval ru_stime;	
	long	ru_maxrss;

	long	ru_ixrss;		
	long	ru_idrss;		
	long	ru_isrss;		
	long	ru_minflt;		
	long	ru_majflt;		
	long	ru_nswap;		
	long	ru_inblock;		
	long	ru_oublock;		
	long	ru_msgsnd;		
	long	ru_msgrcv;		
	long	ru_nsignals;		
	long	ru_nvcsw;		
	long	ru_nivcsw;		

};















struct rlimit {
	int	rlim_cur;		
	int	rlim_max;		
};
#line 6 "./sh.h"











#line 1 "/DIST/usr/include/sys/param.h"





#line 8 "/DIST/usr/include/sys/param.h"


#line 1 "/DIST/usr/include/machine/param.h"























				


































#line 10 "/DIST/usr/include/sys/param.h"













































#line 57 "/DIST/usr/include/sys/param.h"


#line 1 "/DIST/usr/include/signal.h"
















































int	(*signal())();





struct	sigvec {
	int	(*sv_handler)();	
	int	sv_mask;		
	int	sv_onstack;		
};




struct	sigstack {
	char	*ss_sp;			
	int	ss_onstack;		
};








struct	sigcontext {
	int	sc_onstack;		
	int	sc_mask;		
	int	sc_sp;			
	int	sc_pc;			
	int	sc_ps;			
};





#line 91 "/DIST/usr/include/signal.h"


#line 59 "/DIST/usr/include/sys/param.h"







































#line 103 "/DIST/usr/include/sys/param.h"













#line 1 "/DIST/usr/include/sys/types.h"















typedef	unsigned char	u_char;
typedef	unsigned short	u_short;
typedef	unsigned int	u_int;
typedef	unsigned long	u_long;
typedef	unsigned short	ushort;		
typedef	unsigned int	uint;		
typedef	unsigned long	ulong;		

typedef	struct	_physadr { int r[1]; } *physadr;
typedef	struct	label_t	{
	int	val[14];
} label_t;

typedef	struct	_quad { long val[2]; } quad;
typedef	long	daddr_t;
typedef	char *	caddr_t;
typedef	u_long	ino_t;
typedef	long	swblk_t;
typedef	int	size_t;
typedef	int	time_t;
typedef	short	dev_t;
typedef	int	off_t;

typedef	struct	fd_set { int fds_bits[1]; } fd_set;
#line 116 "/DIST/usr/include/sys/param.h"
#line 120 "/DIST/usr/include/sys/param.h"









































































#line 17 "./sh.h"

#line 1 "/DIST/usr/include/sys/stat.h"


struct	stat
{
	dev_t	st_dev;
	ino_t	st_ino;
	unsigned short st_mode;
	short	st_nlink;
	short	st_uid;
	short	st_gid;
	dev_t	st_rdev;
	off_t	st_size;
	time_t	st_atime;
	int	st_spare1;
	time_t	st_mtime;
	int	st_spare2;
	time_t	st_ctime;
	int	st_spare3;
	long	st_blksize;
	long	st_blocks;
	long	st_spare4[2];
};














#line 18 "./sh.h"




#line 1 "/DIST/usr/include/errno.h"

















































	













	













	












#line 22 "./sh.h"

#line 1 "/DIST/usr/include/setjmp.h"


typedef int jmp_buf[14];	
#line 23 "./sh.h"

#line 1 "/DIST/usr/include/signal.h"












#line 92 "/DIST/usr/include/signal.h"

#line 24 "./sh.h"

#line 1 "/DIST/usr/include/sys/times.h"





struct tms {
	time_t	tms_utime;		
	time_t	tms_stime;		
	time_t	tms_cutime;		
	time_t	tms_cstime;		
};
#line 25 "./sh.h"

typedef	char	bool;













bool	chkstop;		
bool	didcch;			
bool	didfds;			
bool	doneinp;		
bool	exiterr;		
bool	child;			
bool	haderr;			
bool	intty;			
bool	intact;			
bool	justpr;			
bool	loginsh;		
bool	neednote;		
bool	noexec;			
bool	pjobs;			
bool	setintr;		
bool	timflg;			




char	*arginp;		
int	onelflg;		
char	*file;			

char	*err;			
int	errno;			
char	*shtemp;		
struct	timeval time0;		
struct	rusage ru0;




char	*doldol;		
int	uid;			
time_t	chktim;			
int	shpgrp;			
int	tpgrp;			

int	opgrp;			
int	oldisc;			
struct	tms shtimes;		






struct	biltins {
	char	*bname;
	int	(*bfunct)();
	short	minargs, maxargs;
} bfunc[];



struct srch {
	char	*s_name;
	short	s_value;
} srchn[];









short	SHIN;			
short	SHOUT;			
short	SHDIAG;			
short	OLDSTD;			









jmp_buf	reslab;



	



char	*gointr;		
int	(*parintr)();		
int	(*parterm)();		


















struct	Bin {
	off_t	Bfseekp;		
	off_t	Bfbobp;			
	off_t	Bfeobp;			
	short	Bfblocks;		
	char	**Bfbuf;		
} B;







off_t	btell();






off_t	lineloc;


off_t	tell();
bool	cantell;			






struct	wordent {
	char	*word;
	struct	wordent *prev;
	struct	wordent *next;
};





















char	labuf[1024		];

char	*lap;








struct	command {
	short	t_dtyp;				
	short	t_dflg;				
	union {
		char	*T_dlef;		
		struct	command *T_dcar;	
	} L;
	union {
		char	*T_drit;		
		struct	command *T_dcdr;	
	} R;




	char	**t_dcom;			
	struct	command *t_dspr;		
	short	t_nice;
};





















































struct	whyle {
	off_t	w_start;		
	off_t	w_end;			
	char	**w_fe, **w_fe0;	
	char	*w_fename;		
	struct	whyle *w_next;		
} *whyles;






struct	varent {
	char	**vec;		
	char	*name;		
	struct	varent *link;
} shvhed, aliases;





struct	wordent *alhistp;		
struct	wordent *alhistt;		
char	**alvec;			




short	gflag;				










char	**gargv;			
short	gargc;				
short	gnleft;




char	**pargv;			
char	*pargs;				
short	pargc;				
short	pnleft;				
char	*pargcp;			












struct	Hist {
	struct	wordent Hlex;
	int	Hnum;
	int	Href;
	struct	Hist *Hnext;
} Histlist;

struct	wordent	paraml;			
int	eventno;			
int	lastev;				

char	HIST;				
char	HISTSUB;			

char	*Dfix1();
struct	varent *adrof(), *adrof1();
char	**blkcat();
char	**blkcpy();
char	**blkend();
char	**blkspl();
char	*calloc();
char	*cname();
char	**copyblk();
char	**dobackp();
char	*domod();
struct	wordent *dosub();
char	*exp3();
char	*exp3a();
char	*exp4();
char	*exp5();
char	*exp6();
struct	Hist *enthist();
struct	Hist *findev();
struct	wordent *freenod();
char	*getenv();
char	*getinx();
struct	varent *getvx();
struct	passwd *getpwnam();
struct	wordent *gethent();
struct	wordent *getsub();
char	*getwd();
char	*globone();
struct	biltins *isbfunc();
char	**glob();
char	*operate();
int	phup();
int	pintr();
int	pchild();
char	*putn();
char	**saveblk();
char	*savestr();
char	*strcat();
char	*strcpy();
char	*strend();
char	*strings();
char	*strip();
char	*strspl();
char	*subword();
struct	command *syntax();
struct	command *syn0();
struct	command *syn1();
struct	command *syn1a();
struct	command *syn1b();
struct	command *syn2();
struct	command *syn3();
int	tglob();
int	trim();
char	*value(), *value1();
char	*xhome();
char	*xname();
char	*xset();






char	*bname;



char	*Vsav;
char	**Vav;
char	*Vdp;


char	**evalvec;
char	*evalp;

struct	mesg {
	char	*iname;		
	char	*pname;		
} mesg[];
#line 6 "sh.time.c"




struct	tms times0;
struct	tms timesdol;

settimes()
{
	struct rusage ruch;

	gettimeofday(&time0, (struct timezone *)0);
	getrusage(0, &ru0);
	getrusage(-1, &ruch);
	ruadd(&ru0, &ruch);
}





dotime()
{
	struct timeval timedol;
	struct rusage ru1, ruch;

	getrusage(0, &ru1);
	getrusage(-1, &ruch);
	ruadd(&ru1, &ruch);
	gettimeofday(&timedol, (struct timezone *)0);
	prusage(&ru0, &ru1, &timedol, &time0);
}




donice(v)
	register char **v;
{
	register char *cp;

	v++, cp = *v++;
	if (cp == 0) {

		nice(20);
		nice(-10);

		nice(4);
	} else if (*v == 0 && any(cp[0], (&xstr[1099]))) {

		nice(20);
		nice(-10);

		nice(getn(cp));
	}
}

ruadd(ru, ru2)
	register struct rusage *ru, *ru2;
{
	register long *lp, *lp2;
	register int cnt;

	tvadd(&ru->ru_utime, &ru2->ru_utime);
	tvadd(&ru->ru_stime, &ru2->ru_stime);
	if (ru2->ru_maxrss > ru->ru_maxrss)
		ru->ru_maxrss = ru2->ru_maxrss;
	cnt = &ru->	ru_nivcsw - &ru->ru_ixrss + 1;
	lp = &ru->ru_ixrss; lp2 = &ru2->ru_ixrss;
	do
		*lp++ += *lp2++;
	while (--cnt > 0);
}

prusage(r0, r1, e, b)
	register struct rusage *r0, *r1;
	struct timeval *e, *b;
{
	register time_t t =
	    (r1->ru_utime.tv_sec-r0->ru_utime.tv_sec)*100+
	    (r1->ru_utime.tv_usec-r0->ru_utime.tv_usec)/10000+
	    (r1->ru_stime.tv_sec-r0->ru_stime.tv_sec)*100+
	    (r1->ru_stime.tv_usec-r0->ru_stime.tv_usec)/10000;
	register char *cp;
	register int i;
	register struct varent *vp = adrof((&xstr[1493]));
	int ms =
	    (e->tv_sec-b->tv_sec)*100 + (e->tv_usec-b->tv_usec)/10000;

	cp = (&xstr[4305]);
	if (vp && vp->vec[0] && vp->vec[1])
		cp = vp->vec[1];
	for (; *cp; cp++)
	if (*cp != '%')
		putchar(*cp);
	else if (cp[1]) switch(*++cp) {

	case 'U':
		pdeltat(&r1->ru_utime, &r0->ru_utime);
		break;

	case 'S':
		pdeltat(&r1->ru_stime, &r0->ru_stime);
		break;

	case 'E':
		psecs(ms / 100);
		break;

	case 'P':
		printf((&xstr[4343]), (int) (t*100 / ((ms ? ms : 1))));
		break;

	case 'W':
		i = r1->ru_nswap - r0->ru_nswap;
		printf((&xstr[3573]), i);
		break;

	case 'X':
		printf((&xstr[3573]), t == 0 ? 0 : (r1->ru_ixrss-r0->ru_ixrss)/t);
		break;

	case 'D':
		printf((&xstr[3573]), t == 0 ? 0 :
		    (r1->ru_idrss+r1->ru_isrss-(r0->ru_idrss+r0->ru_isrss))/t);
		break;

	case 'K':
		printf((&xstr[3573]), t == 0 ? 0 :
		    ((r1->ru_ixrss+r1->ru_isrss+r1->ru_idrss) -
		    (r0->ru_ixrss+r0->ru_idrss+r0->ru_isrss))/t);
		break;

	case 'M':
		printf((&xstr[3573]), r1->ru_maxrss/2);
		break;

	case 'F':
		printf((&xstr[3573]), r1->ru_majflt-r0->ru_majflt);
		break;

	case 'R':
		printf((&xstr[3573]), r1->ru_minflt-r0->ru_minflt);
		break;

	case 'I':
		printf((&xstr[3573]), r1->ru_inblock-r0->ru_inblock);
		break;

	case 'O':
		printf((&xstr[3573]), r1->ru_oublock-r0->ru_oublock);
		break;
	}
	putchar('\n');
}

pdeltat(t1, t0)
	struct timeval *t1, *t0;
{
	struct timeval td;

	tvsub(&td, t1, t0);
	printf((&xstr[4348]), td.tv_sec, td.tv_usec/100000);
}

tvadd(tsum, t0)
	struct timeval *tsum, *t0;
{

	tsum->tv_sec += t0->tv_sec;
	tsum->tv_usec += t0->tv_usec;
	if (tsum->tv_usec > 1000000)
		tsum->tv_sec++, tsum->tv_usec -= 1000000;
}

tvsub(tdiff, t1, t0)
	struct timeval *tdiff, *t1, *t0;
{

	tdiff->tv_sec = t1->tv_sec - t0->tv_sec;
	tdiff->tv_usec = t1->tv_usec - t0->tv_usec;
	if (tdiff->tv_usec < 0)
		tdiff->tv_sec--, tdiff->tv_usec += 1000000;
}

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.