/*
 * Copyright (c) 1980 Regents of the University of California.
 * All rights reserved.  The Berkeley software License Agreement
 * specifies the terms and conditions for redistribution.
 */

#ifndef lint
char copyright[] =
"@(#) Copyright (c) 1980 Regents of the University of California.\n\
 All rights reserved.\n";
#endif not lint

#ifndef lint
static char sccsid[] = "@(#)ps.c	5.5 (Berkeley) 01/10/86";
#endif not lint

#include <stdio.h>
#include <ctype.h>
#include <a.out.h>
#include <pwd.h>
#include <sys/param.h>

#ifndef	PSFILE
char	*psdb	= "/etc/psdatabase";
#else
char	*psdb	= PSFILE;
#endif

int	chkpid = -1;
int	aflg, cflg, eflg, gflg, kflg, lflg, nflg, sflg,
	uflg, vflg, xflg, Uflg;
int	nchans;				/* total # of wait channels */
char	*tptr;
char	*gettty(), *getcmd(), *getname(), *savestr(), *state();
char	*rindex(), *calloc(), *sbrk(), *strcpy(), *strcat(), *strncat();
char	*strncpy(), *index(), *ttyname(), mytty[MAXPATHLEN+1];

			    mproc->p_pgrp == 0 && xflg == 0)
				continue;
			if (tptr == 0 && gflg == 0 && xflg == 0 &&
			    mproc->p_ppid == 1)
				continue;
			if (uid != mproc->p_uid && aflg==0)
				continue;
			if (chkpid != -1 && chkpid != mproc->p_pid)
				continue;
			if (vflg && gflg == 0 && xflg == 0) {
				if (mproc->p_stat == SZOMB ||
				    mproc->p_flag&SWEXIT)
					continue;
				if (mproc->p_slptime > MAXSLP &&
				    (mproc->p_stat == SSLEEP ||

static char *sccsid = "@(#)rm.c	4.18 (Berkeley) 01/06/86";

/*
 * rm - for ReMoving files, directories & trees.
 */

#include <stdio.h>
#include <sys/param.h>

			default:
				fprintf(stderr, "usage: rm [-rif] file ...\n");
				exit(1);
			}
	}

	if (argc < 2 && !fflg) {
		fprintf(stderr, "usage: rm [-rif] file ...\n");
		exit(1);
	}

	while (--argc > 0)
		(void) rm(*++argv, 0);

.\" Copyright (c) 1983 Regents of the University of California.
.\" All rights reserved.  The Berkeley software License Agreement
.\" specifies the terms and conditions for redistribution.
.\"
.\"	@(#)stty.1	6.3 (Berkeley) 01/09/86
.\"
.TH STTY 1 ""
.UC 4
.SH NAME
stty \- set terminal options
.SH SYNOPSIS
.B stty
[ option ... ]
.SH DESCRIPTION
.I Stty
sets certain I/O options on the current output terminal,
placing its output on the diagnostic output.
With no argument, it reports the speed of the terminal and the
settings of the options which are different from their defaults.
Use of one of the following options modifies the output as described:
.TP 10
.B all
All normally used option settings are reported.
.TP 10
.B everything
Everything
.I stty
knows about is printed.
.TP 10
.B speed
The terminal speed alone is printed on the standard output.
.TP 10
.B size
The terminal (window) sizes are printed on the standard output,
first rows and then columns.
.sp
The option strings are
selected from the following set:
.TP  10
.B even 
allow even parity input
.br
.ns

.br
.ns
.TP 10
.BI brk \ c\fR
set break character to
.I c
(default undefined.)
This character is an additional character causing wakeup.
.br
.ns
.TP 10
.B  cr0 cr1 cr2 cr3
.br
select style of delay for carriage return (see
.IR ioctl (2))

.br
.ns
.TP 10
.B  "50 75 110 134 150 200 300 600 1200 1800 2400 4800 9600 exta extb"
.br
Set terminal baud rate to the number given, if possible.
(These are the speeds supported by the DH-11 interface).
.TP 10
.BI rows \ n\fR
The terminal size is recorded as having
.I n
rows.
.BI columns \ n\fR
The terminal size is recorded as having
.I n
columns.
.PP
A teletype driver which supports the job control processing of
.IR csh (1)
and more functionality than the basic driver is fully described in
.IR tty (4).
The following options apply only to it.
.TP 10

/*
 * Copyright (c) 1980 Regents of the University of California.
 * All rights reserved.  The Berkeley software License Agreement
 * specifies the terms and conditions for redistribution.
 */

#ifndef lint
char copyright[] =
"@(#) Copyright (c) 1980 Regents of the University of California.\n\
 All rights reserved.\n";
#endif not lint

#ifndef lint
static char sccsid[] = "@(#)stty.c	5.3 (Berkeley) 01/09/86";
#endif not lint

/*
 * set teletype modes
 */

#include <stdio.h>

				goto done;
			win.ws_row = atoi(*++argv);
		}
		if (eq("columns")) {
			if (--argc == 0)
				goto done;
			win.ws_col = atoi(*++argv);
		}
		if (eq("size")) {
			ioctl(open("/dev/tty", 0), TIOCGWINSZ, &win);
			printf("%d %d\n", win.ws_row, win.ws_col);
			exit(0);
		}
		for(i=0; speeds[i].string; i++)
			if(eq(speeds[i].string)) {
				mode.sg_ispeed = mode.sg_ospeed = speeds[i].speed;
				goto cont;
			}
		if (eq("speed")) {

1,5c
/*
 * Copyright (c) 1980 Regents of the University of California.
 * All rights reserved.  The Berkeley software License Agreement
 * specifies the terms and conditions for redistribution.
 */
.
/Msccsid/c
static char Msccsid[] = "@(#)Mesgfix	5.2 (Berkeley) 01/08/86";

.
/Last update/!date
mark a
g/Sun /s//Sunday, /
g/Mon /s//Monday, /
g/Tue /s//Tuesday, /
g/Wed /s//Wednesday, /
g/Thu /s//Thursday, /
g/Fri /s//Friday, /
g/Sat /s//Saturday, /
g/Jan /s//January /
g/Feb /s//February /
g/Mar /s//March /
g/Apr /s//April /
g/Jun /s//June /
g/Jul /s//July /
g/Aug /s//August /
g/Sep /s//September /
g/Oct /s//October /
g/Nov /s//November /
g/Dec /s//December /
g/  /s// /
'as/ ..:..:.. .../,/
'as/^/	"Last update on /
'as/$/.",/
w!
q

/*
 * Copyright (c) 1980 Regents of the University of California.
 * All rights reserved. The Berkeley software License Agreement
 * specifies the terms and conditions for redistribution.
 */

#ifndef lint
static char Msccsid[] = "@(#)Mesgfix	5.1 (Berkeley) 5/29/85";
static char sccsid[] = "@(#)message.c	4.2 (Berkeley) 01/08/86";
#endif not lint

char	*message[] = {
	"Last update on Saturday, March 30, 1985.",
	"Check the file /usr/public/gammon.news for details.",
	0
};

#
# Copyright (c) 1980 Regents of the University of California.
# All rights reserved.  The Berkeley software License Agreement
# specifies the terms and conditions for redistribution.
#
#	@(#)Makefile	5.10 (Berkeley) 86/01/10
#
# Doing a make install builds /usr/include
#
# Define SHARED to indicate whether you want
# symbolic links to the system source (``symlinks''),
# or a separate copy (``copies'').
# (latter useful in environments where it's

		rm -rf ${DESTDIR}/usr/include/$$i; \
		ln -s /sys/$$i ${DESTDIR}/usr/include/$$i; \
	done
	rm -rf ${DESTDIR}/usr/include/sys
	ln -s /sys/h ${DESTDIR}/usr/include/sys

copies:
	-for i in ${SYSDIRS}; do \
		rm -rf ${DESTDIR}/usr/include/$$i; \
		cd /sys; \
		tar cf - $$i/*.h | (cd ${DESTDIR}/usr/include; tar xpfB -); \
	done
	rm -rf ${DESTDIR}/usr/include/sys;
	mkdir ${DESTDIR}/usr/include/sys; 
	chmod 775 ${DESTDIR}/usr/include/sys;
	-(cd /sys/h; tar cf - *.h | (cd ${DESTDIR}/usr/include/sys; tar xpfB -))

tags:
	cwd=/usr/include; \
	for i in ${STD} ${LINKS}; do \
		ctags -a -f ${TAGSFILE} $$cwd/$$i; \
	done

clean:
	rm -f tags

/*
 * Copyright (c) 1983 Regents of the University of California.
 * All rights reserved.  The Berkeley software License Agreement
 * specifies the terms and conditions for redistribution.
 *
 *	@(#)nameser.h	5.9 (Berkeley) 01/08/86
 */

/*
 * Define constants based on rfc883
 */
#define PACKETSZ	512		/* maximum packet size */
#define MAXDNAME	256		/* maximum domain name */

 * Currently defined opcodes
 */
#define QUERY		0		/* standard query */
#define IQUERY		1		/* inverse query */
#define CQUERYM		2		/* completion query (multiple) */
#define CQUERYU		3		/* completion query (unique) */
	/* non standard */
#define UPDATEA		100		/* add resource record */
#define UPDATED		101		/* delete resource record */
#define UPDATEM		102		/* modify resource record */
#define ZONEINIT	103		/* initial zone transfer */
#define ZONEREF		104		/* incremental zone referesh */

/*
 * Currently defined response codes
 */
#define NOERROR		0		/* no error */
#define FORMERR		1		/* format error */
#define SERVFAIL	2		/* server failure */
#define NXDOMAIN	3		/* non existent domain */
#define NOTIMP		4		/* not implemented */
#define REFUSED		5		/* query refused */
	/* non standard */
#define NOCHANGE	100		/* update failed to change db */

/*
 * Type values for resources and queries
 */
#define T_A		1		/* host address */
#define T_NS		2		/* authoritative server */
#define T_MD		3		/* mail destination */
#define T_MF		4		/* mail forwarder */
#define T_CNAME		5		/* connonical name */
#define T_SOA		6		/* start of authority zone */
#define T_MB		7		/* mailbox domain name */
#define T_MG		8		/* mail group member */
#define T_MR		9		/* mail rename name */
#define T_NULL		10		/* null resource record */
#define T_WKS		11		/* well known service */
#define T_PTR		12		/* domain name pointer */
#define T_HINFO		13		/* host information */
#define T_MINFO		14		/* mailbox information */
#define T_MX		15		/* mail routing information */
	/* non standard */
#define T_UINFO		100		/* user (finger) information */
#define T_UID		101		/* user ID */
#define T_GID		102		/* group ID */
	/* Query type values which do not appear in resource records */
#define T_AXFR		252		/* transfer zone of authority */
#define T_MAILB		253		/* transfer mailbox records */
#define T_MAILA		254		/* transfer mail agent records */
#define T_ANY		255		/* wildcard match */

/*

.\" Copyright (c) 1980 Regents of the University of California.
.\" All rights reserved.  The Berkeley software License Agreement
.\" specifies the terms and conditions for redistribution.
.\"
.\"	@(#)sigvec.2	6.3 (Berkeley) 01/08/86
.\"
.TH SIGVEC 2 ""
.UC 4
.ie t .ds d \(dg
.el .ds d \z'|+'
.ie t .ds b \(bu
.el .ds b @

SIGTTOU	22\*d	background write attempted to control terminal
SIGIO	23\*b	i/o is possible on a descriptor (see \fIfcntl\fP(2))
SIGXCPU	24	cpu time limit exceeded (see \fIsetrlimit\fP(2))
SIGXFSZ	25	file size limit exceeded (see \fIsetrlimit\fP(2))
SIGVTALRM	26	virtual time alarm (see \fIsetitimer\fP(2))
SIGPROF	27	profiling timer alarm (see \fIsetitimer\fP(2))
SIGWINCH	28\*b	window size change
SIGUSR1	30	user defined signal 1
SIGUSR2	31	user defined signal 2
.fi
.PP
The starred signals in the list above cause a core image
if not caught or ignored.
.PP
Once a signal handler is installed, it remains installed
until another

.\" Copyright (c) 1980 Regents of the University of California.
.\" All rights reserved.  The Berkeley software License Agreement
.\" specifies the terms and conditions for redistribution.
.\"
.\"	@(#)setjmp.3	6.2 (Berkeley) 01/09/86
.\"
.TH SETJMP 3 ""
.UC 4
.SH NAME
setjmp, longjmp \- non-local goto
.SH SYNOPSIS
.nf

save and restore the signal mask
.IR sigmask (2),
while
.I _setjmp
and
.I _longjmp
manipulate only the C stack and registers.
.SH ERRORS
.PP
If the contents of the
.B jmp_buf
are corrupted, or correspond to an environment that has already returned,
.I longjmp
calls the routine 
.IR longjmperror .
If
.I longjmperror
returns the program is aborted.
The default version of 
.I longjmperror
prints the message ``longjmp botch'' to standard error and returns.
User programs wishing to exit more gracefully can write their own
versions of 
.IR longjmperror .
.SH "SEE ALSO"
sigvec(2), sigstack(2), signal(3)

/*
 * Copyright (c) 1980 Regents of the University of California.
 * All rights reserved.  The Berkeley software License Agreement
 * specifies the terms and conditions for redistribution.
 */

#ifndef lint
static char sccsid[] = "@(#)setjmperr.c	5.1 (Berkeley) 01/09/86";
#endif not lint

#define ERRMSG	"longjmp botch\n"

/*
 * This routine is called from longjmp() when an error occurs.
 * Programs that wish to exit gracefully from this error may
 * write their own versions.
 * If this routine returns, the program is aborted.
 */
longjmperror()
{

	write(2, ERRMSG, sizeof(ERRMSG));
}

.\" Copyright (c) 1980 Regents of the University of California.
.\" All rights reserved.  The Berkeley software License Agreement
.\" specifies the terms and conditions for redistribution.
.\"
.\"	@(#)signal.3	6.3 (Berkeley) 01/08/86
.\"
.TH SIGNAL 3C ""
.UC 4
.ie t .ds d \(dg
.el .ds d \z'|+'
.ie t .ds b \(bu
.el .ds b @

SIGTTOU	22\*d	background write attempted to control terminal
SIGIO	23\*b	i/o is possible on a descriptor (see \fIfcntl\fP(2))
SIGXCPU	24	cpu time limit exceeded (see \fIsetrlimit\fP(2))
SIGXFSZ	25	file size limit exceeded (see \fIsetrlimit\fP(2))
SIGVTALRM	26	virtual time alarm (see \fIsetitimer\fP(2))
SIGPROF	27	profiling timer alarm (see \fIsetitimer\fP(2))
SIGWINCH	28\*b	Window size change
SIGUSR1	30	User defined signal 1
SIGUSR2	31	User defined signal 2
.fi
.PP
The starred signals in the list above cause a core image
if not caught or ignored.
.PP
If
.I func

.\" Copyright (c) 1980 Regents of the University of California.
.\" All rights reserved.  The Berkeley software License Agreement
.\" specifies the terms and conditions for redistribution.
.\"
.\"	@(#)@(#)ualarm.3	6.1 (Berkeley) 01/09/86
.\"
.TH UALARM 3  ""
.UC 6
.SH NAME
ualarm \- schedule signal after specified time
.SH SYNOPSIS
.nf
.B ualarm(value, interval)
.B unsigned value;
.B unsigned interval;
.fi
.SH DESCRIPTION
.ft B
This is a simplified interface to setitimer(2).
.ft R
.PP
.I Ualarm
causes signal SIGALRM, see
.IR signal (3C),
to be sent to the invoking process
in a number of microseconds given by the
.I value
argument.
Unless caught or ignored, the signal terminates the process.
.PP
If the
.I interval
argument is non-zero, the SIGALRM signal will be sent
to the process every
.I interval
microseconds after the timer expires (e.g. after
.I value
microseconds have passed).
.PP
Because of scheduling delays,
resumption of execution of when the signal is
caught may be delayed an arbitrary amount.
The longest specifiable delay time (on the vax) is 2147483647 microseconds.
.PP
The return value is the amount of time previously remaining in the alarm clock.
.sh BUGS
This routine is expensive to use because it is implemented using 
.IR setitimer (2)
and does eight system calls each time it is invoked.
.SH "SEE ALSO"
getitimer(2), setitimer(2), sigpause(2), sigvec(2), signal(3C), sleep(3),
alarm(3), ualarm(3)

.\" Copyright (c) 1980 Regents of the University of California.
.\" All rights reserved.  The Berkeley software License Agreement
.\" specifies the terms and conditions for redistribution.
.\"
.\"	@(#)@(#)usleep.3	6.1 (Berkeley) 01/09/86
.\"
.TH USLEEP 3  ""
.UC 6
.SH NAME
usleep \- suspend execution for interval
.SH SYNOPSIS
.nf
.B usleep(useconds)
.B unsigned useconds;
.fi
.SH DESCRIPTION
The current process is suspended from execution for the number
of microseconds specified by the argument.
The actual suspension time may be an arbitrary amount longer
because of other activity in the system.
.PP
The routine is implemented by setting an interval timer
and pausing until it occurs.
The previous state of this timer is saved and restored.
If the sleep time exceeds the time to the expiration of the
previous timer,
the process sleeps only until the signal would have occurred, and the
signal is sent 2 system clock ticks later.
.sh BUGS
This routine is expensive to use because it is implemented using 
.IR setitimer (2)
and does eight system calls each time it is invoked.
It should be implemented using 
.IR select (2).
.SH "SEE ALSO"
setitimer(2), getitimer(2), sigpause(2), ualarm(3), sleep(3), alarm(3)

/*
 * Copyright (c) 1983 Regents of the University of California.
 * All rights reserved.  The Berkeley software License Agreement
 * specifies the terms and conditions for redistribution.
 */

#ifndef lint
static char sccsid[] = "@(#)gethostnamadr.c	5.4 (Berkeley) 01/09/86";
#endif not lint

#include <stdio.h>
#include <netdb.h>
#include <sys/file.h>
#include <ndbm.h>
#include <ctype.h>

#define	MAXALIASES	35

static struct hostent host;
static char *host_aliases[MAXALIASES];
static char hostbuf[BUFSIZ+1];
static char *host_addrs[2];

int h_errno;

/*
 * The following is shared with gethostent.c
 */
extern	char *_host_file;
DBM	*_host_db = (DBM *)NULL;
int	_host_stayopen;	/* set by sethostent(), cleared by endhostent() */

        key.dptr = lowname;
        key.dsize = strlen(lowname);
	hp = fetchhost(key);
	if (!_host_stayopen) {
		dbm_close(_host_db);
		_host_db = (DBM *)NULL;
	}
	if ( hp == NULL)
		h_errno = HOST_NOT_FOUND;
        return (hp);
}

struct hostent *
gethostbyaddr(addr, length, type)
	char *addr;
	register int length;

		while (hp = gethostent()) {
			if (hp->h_addrtype == type && hp->h_length == length
			    && bcmp(hp->h_addr, addr, length) == 0)
				break;
		}
		if (!_host_stayopen)
			endhostent();
		if ( hp == NULL)
			h_errno = HOST_NOT_FOUND;
		return (hp);
	}
        key.dptr = addr;
        key.dsize = length;
	hp = fetchhost(key);
	if (!_host_stayopen) {
		dbm_close(_host_db);
		_host_db = (DBM *)NULL;
	}
	if ( hp == NULL)
		h_errno = HOST_NOT_FOUND;
        return (hp);
}

/*
 * Copyright (c) 1985 Regents of the University of California.
 * All rights reserved.  The Berkeley software License Agreement
 * specifies the terms and conditions for redistribution.
 */

#ifndef lint
static char sccsid[] = "@(#)res_debug.c	5.9 (Berkeley) 01/08/86";
#endif not lint

#if defined(lint) && !defined(DEBUG)
#define DEBUG
#endif

#include <sys/types.h>

		fprintf(file,", retry=%ld", getlong(cp));
		cp += sizeof(u_long);
		fprintf(file,", expire=%ld", getlong(cp));
		cp += sizeof(u_long);
		fprintf(file,", min=%ld\n", getlong(cp));
		cp += sizeof(u_long);
		break;

	case T_MX:
		fprintf(file,"\tname = ");
		cp = p_cdname(cp, msg, file);
		fprintf(file,", preference = %ld",getlong(cp));
		cp += sizeof(u_long);
		break;

	case T_MINFO:
		fprintf(file,"\trequests = ");
		cp = p_cdname(cp, msg, file);
		fprintf(file,"\n\terrors = ");
		cp = p_cdname(cp, msg, file);
		break;

		return("CNAME");
	case T_SOA:		/* start of authority zone */
		return("SOA");
	case T_MB:		/* mailbox domain name */
		return("MB");
	case T_MG:		/* mail group member */
		return("MG");
	case T_MX:		/* mail routing info */
		return("MX");
	case T_MR:		/* mail rename name */
		return("MR");
	case T_NULL:		/* null resource record */
		return("NULL");
	case T_WKS:		/* well known service */
		return("WKS");
	case T_PTR:		/* domain name pointer */

.\" Copyright (c) 1985 Regents of the University of California.
.\" All rights reserved.  The Berkeley software License Agreement
.\" specifies the terms and conditions for redistribution.
.\"
.\"	@(#)resolver.3	1.3 (Berkeley) 01/07/86
.\"
.TH RESOLVER 3 "15 November 1985"
.UC 4
.SH NAME
res_mkquery, res_send, res_init, dn_comp, dn_expand \- resolver routines
.SH SYNOPSIS
.B #include <sys/types.h>

as the name is compressed.
If
.I dnptr
is NULL, we don't try to compress names. If
.I lastdnptr
is NULL, we don't update the list.
.SH FILES
/etc/resolv.conf see resolver(5)







.SH "SEE ALSO"
named(8), resolver(5), RFC882, RFC883

/*
 * Copyright (c) 1983 Regents of the University of California.
 * All rights reserved.  The Berkeley software License Agreement
 * specifies the terms and conditions for redistribution.
 */

#ifndef lint
static char sccsid[] = "@(#)malloc.c	5.4 (Berkeley) 01/10/86";
#endif not lint

/*
 * malloc.c (Caltech) 2/21/82
 * Chris Kingsley, kingsley@cit-20.
 *
 * This is a very fast storage allocator.  It allocates blocks of a small 

 * nmalloc[i] is the difference between the number of mallocs and frees
 * for a given block size.
 */
static	u_int nmalloc[NBUCKETS];
#include <stdio.h>
#endif

#if defined(DEBUG) || defined(RCHECK)
#define	ASSERT(p)   if (!(p)) botch("p")
#include <stdio.h>
static
botch(s)
	char *s;
{

	fprintf(stderr, "\r\nassertion botched: %s\r\n", s);
 	(void) fflush(stderr);		/* just in case user buffered it */
	abort();
}
#else
#define	ASSERT(p)
#endif

char *

		n = -(sizeof (*op) + RSLOP);
	} else {
		amt = pagesz;
		bucket = pagebucket;
	}
	while (nbytes > amt + n) {
		amt <<= 1;
		if (amt == 0)
			return (NULL);
		bucket++;
	}
	/*
	 * If nothing in hash bucket right now,
	 * request more memory from the system.
	 */
  	if ((op = nextf[bucket]) == NULL) {

#endif
  	return ((char *)(op + 1));
}

/*
 * Allocate more memory to the indicated bucket.
 */

morecore(bucket)
	int bucket;
{
  	register union overhead *op;
	register int sz;		/* size of desired block */
  	int amt;			/* amount to allocate */
  	int nblks;			/* how many blocks we get */

	/*
	 * sbrk_size <= 0 only for big, FLUFFY, requests (about
	 * 2^30 bytes on a VAX, I think) or for a negative arg.
	 */
	sz = 1 << (bucket + 3);
	if (sz <= 0)
		return;
	if (sz < pagesz) {
		amt = pagesz;
  		nblks = amt / sz;
	} else {
		amt = sz + pagesz;
		nblks = 1;
	}

		 *
		 * Search for the old block of memory on the
		 * free list.  First, check the most common
		 * case (last element free'd), then (this failing)
		 * the last ``realloc_srchlen'' items free'd.
		 * If all lookups fail, then assume the size of
		 * the memory block being realloc'd is the
		 * largest possible (so that all "nbytes" of new
		 * memory are copied into).  Note that this could cause
		 * a memory fault if the old area was tiny, and the moon
		 * is gibbous.  However, that is very unlikely.
		 */
		if ((i = findbucket(op, 1)) < 0 &&
		    (i = findbucket(op, realloc_srchlen)) < 0)

			i = NBUCKETS;



	}
	onb = 1 << (i + 3);
	if (onb < pagesz)
		onb -= sizeof (*op) + RSLOP;
	else
		onb += pagesz - sizeof (*op) - RSLOP;
	/* avoid the copy if same size block */

#endif
			return(cp);
		} else
			free(cp);
	}
  	if ((res = malloc(nbytes)) == NULL)
  		return (NULL);
  	if (cp != res)		/* common optimization if "compacting" */
		bcopy(cp, res, (nbytes < onb) ? nbytes : onb);
  	return (res);
}

/*
 * Search ``srchlen'' elements of each free list for a block whose
 * header starts at ``freep''.  If srchlen is -1 search the whole list.

.\" Copyright (c) 1983 Regents of the University of California.
.\" All rights reserved.  The Berkeley software License Agreement
.\" specifies the terms and conditions for redistribution.
.\"
.\"	@(#)Xsetregid.2	6.2 (Berkeley) 01/07/86
.\"
.TH SETREGID 2 ""
.UC 5
.SH NAME
setregid \- set real and effective group ID
.SH SYNOPSIS
.nf
.ft B
#include <sys/types.h>
.PP
.ft B
setregid(rgid, egid)
.br
gid_t rgid, egid;
.ft R
.SH DESCRIPTION
The real and effective group ID's of the current process
are set to the arguments.
Unprivileged users may change the real group
ID to the effective group ID and vice-versa; only the super-user may
make other changes.

.\" Copyright (c) 1983 Regents of the University of California.
.\" All rights reserved.  The Berkeley software License Agreement
.\" specifies the terms and conditions for redistribution.
.\"
.\"	@(#)getgid.2	6.2 (Berkeley) 01/07/86
.\"
.TH GETGID 2 ""
.UC 5
.SH NAME
getgid, getegid \- get group identity
.SH SYNOPSIS
.nf
.ft B
#include <sys/types.h>
.PP
.nf
.ft B
gid = getgid()
gid_t gid;
.PP
.ft B
egid = getegid()
gid_t egid;
.fi
.SH DESCRIPTION
.I Getgid
returns the real group ID of the current process,
.I getegid
the effective group ID.
.PP

.\" Copyright (c) 1980 Regents of the University of California.
.\" All rights reserved.  The Berkeley software License Agreement
.\" specifies the terms and conditions for redistribution.
.\"
.\"	@(#)getuid.2	6.3 (Berkeley) 01/07/86
.\"
.TH GETUID 2 ""
.UC 4
.SH NAME
getuid, geteuid \- get user identity
.SH SYNOPSIS
.nf
.ft B
#include <sys/types.h>
.PP
.ft B
.nf
uid = getuid()
uid_t uid;
.PP
.ft B
euid = geteuid()
uid_t euid;
.fi
.SH DESCRIPTION
.I Getuid
returns the real user ID of the current process,
.I geteuid
the effective user ID.
.PP

.\" Copyright (c) 1983 Regents of the University of California.
.\" All rights reserved.  The Berkeley software License Agreement
.\" specifies the terms and conditions for redistribution.
.\"
.\"	@(#)setuid.2	6.2 (Berkeley) 01/07/86
.\"
.TH SETUID 3 "" 
.UC 5
.SH NAME
setuid, seteuid, setruid, setgid, setegid, setrgid \- set user and group ID
.SH SYNOPSIS
.nf
.ft B
#include <sys/types.h>
.PP
.ft B
.nf
setuid(uid)
seteuid(euid)
setruid(ruid)
uid_t uid, euid, ruid;
.PP
.ft B
.nf
setgid(gid)
setegid(egid)
setrgid(rgid)
gid_t gid, egid, rgid;
.fi
.SH DESCRIPTION
.I Setuid
.RI ( setgid )
sets both the real and effective
user ID (group ID) of the current process to
as specified.

.\" Copyright (c) 1983 Regents of the University of California.
.\" All rights reserved.  The Berkeley software License Agreement
.\" specifies the terms and conditions for redistribution.
.\"
.\"	@(#)socket.2	6.3 (Berkeley) 01/07/86
.\"
.TH SOCKET 2 ""
.UC 5
.SH NAME
socket \- create an endpoint for communication
.SH SYNOPSIS
.nf

The currently understood formats are
.PP
.RS
.nf
.ta 1.25i 1.75i
AF_UNIX	(UNIX path names),
AF_INET	(ARPA Internet addresses),
AF_NS	(Xerox Network Systems addresses), and
AF_IMPLINK	(IMP \*(lqhost at IMP\*(rq addresses).
.fi
.RE
.PP
The socket has the indicated
.I type,
which specifies the semantics of communication.  Currently

.PP
A SOCK_STREAM type provides sequenced, reliable,
two-way connection based byte streams with an out-of-band data
transmission mechanism.
A SOCK_DGRAM socket supports
datagrams (connectionless, unreliable messages of
a fixed (typically small) maximum length).
A SOCK_SEQPACKET socket may provide a sequenced, reliable,
two-way connection-based data transmission path for datagrams
of fixed maximum length; a consumer may be required to read
an entire packet with each read system call.
This facility is protocol specific, and presently implemented
only for AF_NS.
SOCK_RAW sockets provide access to internal network interfaces.
The types SOCK_RAW,
which is available only to the super-user, and
SOCK_RDM, which is planned,
but not yet implemented, are not described here.
.PP
The
.I protocol
specifies a particular protocol to be used with the socket.
Normally only a single protocol exists to support a particular
socket type using a given address format.  However, it is possible

An error is then indicated if no response can be
elicited on an otherwise
idle connection for a extended period (e.g. 5 minutes).
A SIGPIPE signal is raised if a process sends
on a broken stream; this causes naive processes,
which do not handle the signal, to exit.
.PP
SOCK_SEQPACKET sockets employ the same system calls
as SOCK_STREAM sockets.  The only difference
is that 
.IR read (2)
calls will return only the amount of data requested,
and any remaining in the arriving packet will be discarded.
.PP
SOCK_DGRAM and SOCK_RAW
sockets allow sending of datagrams to correspondents
named in
.IR send (2)
calls.  It is also possible to receive datagrams at
such a socket with
.IR recv (2).

/*
 * Copyright (c) 1980 Regents of the University of California.
 * All rights reserved.  The Berkeley software License Agreement
 * specifies the terms and conditions for redistribution.
 */

#ifndef lint
	.asciz	"@(#)_setjmp.s	5.3 (Berkeley) 01/09/86"
#endif not lint


/*
 * C library -- _setjmp, _longjmp
 *
 *	_longjmp(a,v)

	ret				# unwind stack before signals enabled
3:
	addl2	$8,sp			# compensate for PSL-PC push
4:
	jmp	*4(r1)			# done, return....

botch:



	calls	$0,_longjmperror
	halt

/*
 * Copyright (c) 1983 Regents of the University of California.
 * All rights reserved.  The Berkeley software License Agreement
 * specifies the terms and conditions for redistribution.
 */

#ifndef lint
	.asciz	"@(#)setjmp.s	5.4 (Berkeley) 01/09/86"
#endif not lint

/*
 * C library -- setjmp, longjmp
 *
 *	longjmp(a,v)
 * will generate a "return(v)" from

4:
#endif NOCOMPAT

	pushl	r1			# pointer to sigcontext
	calls	$1,_sigreturn		# restore previous context
					# we should never return
botch:



	calls	$0,_longjmperror
	halt

.\" Copyright (c) 1983 Regents of the University of California.
.\" All rights reserved.  The Berkeley software License Agreement
.\" specifies the terms and conditions for redistribution.
.\"
.\"	@(#)gettytab.5	6.2 (Berkeley) 01/07/86
.\"
.TH GETTYTAB 5 ""
.UC 5
.SH NAME
gettytab \- terminal configuration data base
.SH SYNOPSIS
/etc/gettytab

cb	bool	false	use crt backspace mode
cd	num	0	carriage-return delay
ce	bool	false	use crt erase algorithm
ck	bool	false	use crt kill algorithm
cl	str	NULL	screen clear sequence
co	bool	false	console - add \\n after login prompt
ds	str	^Y	delayed suspend character
dx	bool	false	set DECCTLQ
ec	bool	false	leave echo \s-2OFF\s0
ep	bool	false	terminal uses even parity
er	str	^?	erase character
et	str	^D	end of text (\s-2EOF\s0) character
ev	str	NULL	initial enviroment
f0	num	unused	tty mode flags to write messages
f1	num	unused	tty mode flags to read login name

/*
 * Copyright (c) 1980 Regents of the University of California.
 * All rights reserved.  The Berkeley software License Agreement
 * specifies the terms and conditions for redistribution.
 *
 *	@(#)gettytab.h	5.2 (Berkeley) 01/07/86
 */

/*
 * Getty description definitions.
 */
struct	gettystrs {
	char	*field;		/* name to lookup in gettytab */

#define	LC	gettyflags[13].value
#define	UC	gettyflags[14].value
#define	IG	gettyflags[15].value
#define	PS	gettyflags[16].value
#define	HC	gettyflags[17].value
#define UB	gettyflags[18].value
#define AB	gettyflags[19].value
#define DX	gettyflags[20].value

int	getent();
long	getnum();
int	getflag();
char	*getstr();

extern	struct gettyflags gettyflags[];
extern	struct gettynums gettynums[];
extern	struct gettystrs gettystrs[];
extern	int hopcount;

/*
 * Copyright (c) 1980 Regents of the University of California.
 * All rights reserved.  The Berkeley software License Agreement
 * specifies the terms and conditions for redistribution.
 */

#ifndef lint
static char sccsid[] = "@(#)init.c	5.2 (Berkeley) 01/07/86";
#endif not lint

/*
 * Getty table initializations.
 *
 * Melbourne getty.
 */

	{ "lc",	0 },			/* terminal las lower case */
	{ "uc",	0 },			/* terminal has no lower case */
	{ "ig",	0 },			/* ignore garbage */
	{ "ps",	0 },			/* do port selector speed select */
	{ "hc",	1 },			/* don't set hangup on close */
	{ "ub", 0 },			/* unbuffered output */
	{ "ab", 0 },			/* auto-baud detect with '\r' */
	{ "dx", 0 },			/* set decctlq */
	{ 0 }
};

/*
 * Copyright (c) 1980 Regents of the University of California.
 * All rights reserved.  The Berkeley software License Agreement
 * specifies the terms and conditions for redistribution.
 */

#ifndef lint
static char sccsid[] = "@(#)subr.c	5.4 (Berkeley) 01/07/86";
#endif not lint

/*
 * Melbourne getty.
 */
#include <sgtty.h>
#include "gettytab.h"

	if (EC)
		f |= ECHO;

	if (XC)
		f |= CTLECH;

	if (DX)
		f |= DECCTQ;

	return (f);
}

struct delayval {
	unsigned	delay;		/* delay in ms */
	int		bits;
};

/*
 * Copyright (c) 1983 Regents of the University of California.
 * All rights reserved.  The Berkeley software License Agreement
 * specifies the terms and conditions for redistribution.
 */

#ifndef lint
char copyright[] =
"@(#) Copyright (c) 1983 Regents of the University of California.\n\
 All rights reserved.\n";
#endif not lint

#ifndef lint
static char sccsid[] = "@(#)rlogind.c	5.10 (Berkeley) 01/07/86";
#endif not lint

/*
 * remote login server:
 *	remuser\0
 *	locuser\0
 *	terminal info\0

 */
protocol(f, p)
	int f, p;
{
	char pibuf[1024], fibuf[1024], *pbp, *fbp;
	register pcc = 0, fcc = 0;
	int cc;
	char cntl;

	/*
	 * Must ignore SIGTTOU, otherwise we'll stop
	 * when we try and set slave pty's window shape
	 * (our controlling tty is the master pty).
	 */
	(void) signal(SIGTTOU, SIG_IGN);
	send(f, oobdata, 1, MSG_OOB);	/* indicate new rlogin */
	for (;;) {
		int ibits, obits, ebits;

		ibits = 0;
		obits = 0;
		if (fcc)
			obits |= (1<<p);
		else
			ibits |= (1<<f);
		if (pcc >= 0)
			if (pcc)
				obits |= (1<<f);
			else
				ibits |= (1<<p);
		ebits = (1<<p);
		if (select(16, &ibits, &obits, &ebits, 0) < 0) {
			if (errno == EINTR)
				continue;
			fatalperror(f, "select", errno);
		}
		if (ibits == 0 && obits == 0 && ebits == 0) {
			/* shouldn't happen... */
			sleep(5);
			continue;
		}
#define	pkcontrol(c)	((c)&(TIOCPKT_FLUSHWRITE|TIOCPKT_NOSTOP|TIOCPKT_DOSTOP))
		if (ebits & (1<<p)) {
			cc = read(p, &cntl, 1);
			if (cc == 1 && pkcontrol(cntl)) {
				cntl |= oobdata[0];
				send(f, &cntl, 1, MSG_OOB);
				if (cntl & TIOCPKT_FLUSHWRITE) {
					pcc = 0;
					ibits &= ~(1<<p);
				}
			}
		}
		if (ibits & (1<<f)) {
			fcc = read(f, fibuf, sizeof (fibuf));
			if (fcc < 0 && errno == EWOULDBLOCK)
				fcc = 0;
			else {
				register char *cp;

			if (pcc < 0 && errno == EWOULDBLOCK)
				pcc = 0;
			else if (pcc <= 0)
				break;
			else if (pibuf[0] == 0)
				pbp++, pcc--;
			else {

				if (pkcontrol(pibuf[0])) {
					pibuf[0] |= oobdata[0];
					send(f, &pibuf[0], 1, MSG_OOB);
				}
				pcc = 0;
			}
		}

static char sccsid[] = "ifontinfo.c	1.6	(Berkeley)	86/01/05";

/* Font Information for Imagen-style fonts (RST format)
 *      taken from vfontinfo, by Andy Hertzfeld  4/79
 */

#include <stdio.h>
#include <ctype.h>

	p.p_linesp = rd4();
	p.p_wordsp = rd4();
	p.p_rot = rd2();
	p.p_cadv = rd1();
	p.p_ladv = rd1();
	p.p_id = rd4();
	p.p_res = rd2();



	i = p.p_glyph - 44;
	idstrings = (char *) malloc (i);
	endstring = idstrings;
	while (i--) if ((*(endstring++) = getc(FID)) == EOF)
	    error("bad preamble in Font file.");

#ifndef lint
static char sccsid[] = "@(#)tac.c	1.2 01/11/86";
#endif

/*
 * tac.c - Print file segments in reverse order
 *
 * Original line-only version by unknown author off the net.
 * 1985 mods by Jay Lepreau, Univ of Utah, to allocate memory
 * dynamically and handle string bounded segments (latter idea
 * suggested by Rob Pike).
 */

#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>

/*

	/*
	 * Arrange for the first read to lop off enough to
	 * leave the rest of the file a multiple of readsize.
	 * Since readsize can change, this may not always hold during
	 * the pgm run, but since it usually will, leave it here
	 * for i/o efficiency (page/sector boundaries and all that).
	 * Note: the efficiency gain has never been verified...
	 */
	if ((i = off % readsize) == 0)
	    i = readsize;
	off -= i;

	(void) lseek(fd, off, 0);
	if (read(fd, buf, i) != i) {

/*
 * Copyright (c) 1983 Regents of the University of California.
 * All rights reserved.  The Berkeley software License Agreement
 * specifies the terms and conditions for redistribution.
 */

#ifndef lint
static char sccsid[] = "@(#)check.c	5.2 (Berkeley) 01/10/86";
#endif not lint

static char rcsid[] = "$Header: check.c,v 1.5 84/12/26 10:38:35 linton Exp $";

/*
 * Check a tree for semantic correctness.
 */

    Symbol f;

    checkref(p);
    switch (p->op) {
	case O_ASSIGN:
	    p1 = p->value.arg[0];
	    p2 = p->value.arg[1];
	    if (varIsSet("$unsafeassign")) {
		if (size(p1->nodetype) != size(p2->nodetype)) {
		    error("incompatible sizes");
		}
	    } else if (not compatible(p1->nodetype, p2->nodetype)) {
		error("incompatible types");
	    }
	    break;

	case O_CATCH:
	case O_IGNORE:
	    if (p->value.lcon < 0 or p->value.lcon > NSIG) {

/*
 * Copyright (c) 1983 Regents of the University of California.
 * All rights reserved.  The Berkeley software License Agreement
 * specifies the terms and conditions for redistribution.
 */

#ifndef lint
static char sccsid[] = "@(#)fortran.c	5.3 (Berkeley) 01/10/86";
#endif not lint

static char rcsid[] = "$Header: fortran.c,v 1.5 84/12/26 10:39:37 linton Exp $";

/*
 * FORTRAN dependent symbol routines.
 */

#include "eval.h"
#include "operators.h"
#include "mappings.h"
#include "process.h"
#include "runtime.h"
#include "machine.h"

#define isspecial(range) ( \
    range->symvalue.rangev.upper == 0 and range->symvalue.rangev.lower > 0 \
)

#define isrange(t, name) (t->class == RANGE and istypename(t->type, name))

#define MAXDIM  20

Symbol eltype;

    switch (s->class) {

	case CONST:
	    
	    printf("parameter %s = ", symname(s));
	    eval(s->symvalue.constval);
            printval(s);
	    break;

        case REF:
            printf(" (dummy argument) ");

	case VAR:

		printf("\"%.*s\"", len, sp);
	    } else {
		fortran_printarray(s);
	    }
	    break;

	case RANGE:
	    if (isspecial(s)) {
		switch (s->symvalue.rangev.lower) {
		    case sizeof(short):
			if (istypename(s->type, "logical*2")) {
			    printlogical(pop(short));
			}
			break;

		    case sizeof(float):
			if (istypename(s->type, "logical")) {
			    printlogical(pop(long));
			} else {
			    prtreal(pop(float));
			}
			break;

		    case sizeof(double):
			if (istypename(s->type, "complex")) {
			    d2 = pop(float);
			    d1 = pop(float);
			    printf("(");
			    prtreal(d1);
			    printf(",");
			    prtreal(d2);
			    printf(")");

			prtreal(d1);
			printf(",");
			prtreal(d2);
			printf(")");
			break;
		
		    default:
			panic("bad size \"%d\" for special",
                                  s->symvalue.rangev.lower);
			break;
		}
	    } else {
		printint(popsmall(s), s);
	    }
	    break;

	default:
	    if (ord(s->class) > ord(TYPEREF)) {
		panic("printval: bad class %d", ord(s->class));
	    }
	    error("don't know how to print a %s", fortran_classname(s));
	    /* NOTREACHED */
    }
}

/*
 * Print out a logical
 */

private printlogical(i)
Integer i;
{
    if (i == 0) {
	printf(".false.");
    } else {
	printf(".true.");
    }
}

/*
 * Print out an int 
 */

private printint(i, t)
Integer i;
register Symbol t;
{



    if ( (t->type == t_int) or istypename(t->type, "integer") or
                  istypename(t->type,"integer*2") ) {
	printf("%ld", i);
    } else if (istypename(t->type, "addr")) {
	printf("0x%lx", i);
    } else {
	error("unknown type in fortran printint");
    }
}

/*
 * Print out a null-terminated string (pointer to char)
 * starting at the given address.
 */

/*
 * Copyright (c) 1983 Regents of the University of California.
 * All rights reserved.  The Berkeley software License Agreement
 * specifies the terms and conditions for redistribution.
 */

#ifndef lint
static char sccsid[] = "@(#)runtime.c	5.2 (Berkeley) 01/10/86";
#endif not lint

static char rcsid[] = "$Header: runtime.c,v 1.5 84/12/26 10:41:52 linton Exp $";

/*
 * Runtime organization dependent routines, mostly dealing with
 * activation records.

Symbol proc;
Node arglist;
{
    Stack *savesp;
    int argc, args_size;

    savesp = sp;
    if (varIsSet("$unsafecall")) {
	argc = unsafe_evalargs(proc, arglist);
    } else {
	argc = evalargs(proc, arglist);
    }
    args_size = sp - savesp;
    setreg(STKP, reg(STKP) - args_size);
    dwrite(savesp, reg(STKP), args_size);
    sp = savesp;
    return argc;
}

	++count;
    }
    if (chk) {
	if (formal != nil) {
	    sp = savesp;
	    error("not enough parameters to %s", symname(proc));
	}
    }
    return count;
}

/*
 * Evaluate an argument list without concern for matching the formal
 * parameters of a function in type or quantity.  Useful for functions
 * like C's printf().
 */

private integer unsafe_evalargs(proc, arglist)
Symbol proc;
Node arglist;
{
    Node p;
    Integer count;

    count = 0;
    for (p = arglist; p != nil; p = p->value.arg[1]) {
	assert(p->op == O_COMMA);
	eval(p->value.arg[0]);
	++count;
    }
    return count;
}

public procreturn(f)
Symbol f;
{

static	char *sccsid = "@(#)files.c	4.12 (Berkeley) 86/01/09";
#include <fcntl.h>

/* UNIX DEPENDENT PROCEDURES */


/* DEFAULT RULES FOR UNIX */

	dirpref = "";
	filepat = pat;
	cp = varptr("VPATH");
	if (*cp->varval == 0) path = ".";
	else {
	       path = pth; 
	       *path = '\0';
	       if (strncmp(cp->varval, ".:", 2) != 0) strcpy(pth,".:");
	       strcat(pth, cp->varval);
	       }
	}
else	{
	*endir = '\0';
	path = strcpy(pth, pat);
	dirpref = concat(pat, "/", temp);

static	char *sccsid = "@(#)main.c	4.8 (Berkeley) 86/01/09";
# include "defs"
/*
command make to update programs.
Flags:	'd'  print out debugging comments
	'p'  print out a version of the input graph
	's'  silent mode--don't print out commands
	'f'  the next argument is the name of the description file;

fin = k;
yylineno = 0;
zznextc = 0;

if( yyparse() )
	fatal("Description file error");

if(fin != NULL && fin != stdin)
	fclose(fin);

return(0);
}

printdesc(prntflag)
int prntflag;

#ifndef lint
static	char sccsid[] = "@(#)c21.c 4.17 01/08/86";
#endif
/* char C21[] = {"@(#)c21.c 1.83 80/10/16 21:18:22 JFR"}; /* sccs ident */

/*
 * C object code improver-- second part
 */

			switch (shcnt)
			{
			case 1:	pf->subop = WORD; break;
			case 2:	pf->subop = LONG; break;
			case 3:	pf->subop = QUAD; break;
			}
			redunm++; nsaddr++; nchange++;

			goto std;
		}
ashadd:
		/* at this point, RT2 and RT3 are guaranteed to be simple regs*/
		if (shcnt == 1 && equstr(regs[RT2], regs[RT3]))
		{
			/*
			** quickie:
			**	ashl	$1,A,A	>	addl2	A,A

#	Makefile	1.1	86/01/11
#
# Makefile for portable c compiler
#
DESTDIR=
M=	../mip.tahoe
CFLAGS=	-O -I${M} -I.
OBJS=	rodata.o cgram.o xdefs.o scan.o pftn.o trees.o optim.o code.o local.o \
	reader.o local2.o order.o match.o allo.o comm1.o table.o stab.o

all:	ccom alist

ccom: 	${OBJS}
	$(CC) $(LDFLAGS) ${OBJS} -o ccom
alist: alist.c
	$(CC) -o alist $(CFLAGS)  alist.c
	
trees.o: $M/manifest macdefs $M/mfile1 $M/trees.c
	$(CC) -c $(CFLAGS)  $M/trees.c
optim.o: $M/manifest macdefs $M/mfile1 $M/optim.c
	$(CC) -c $(CFLAGS) $M/optim.c
pftn.o: $M/manifest macdefs $M/mfile1 $M/pftn.c
	$(CC) -c $(CFLAGS) $M/pftn.c
code.o: $M/manifest macdefs $M/mfile1
	$(CC) -c $(CFLAGS) code.c
local.o: $M/manifest macdefs $M/mfile1
	$(CC) -c $(CFLAGS) local.c
stab.o: $M/manifest macdefs $M/mfile1
	$(CC) -c $(CFLAGS) stab.c
scan.o: $M/manifest macdefs $M/mfile1 $M/scan.c
	$(CC) -c $(CFLAGS) $M/scan.c
xdefs.o: $M/manifest $M/mfile1 macdefs $M/xdefs.c
	$(CC) -c $(CFLAGS) $M/xdefs.c
cgram.o: $M/manifest $M/mfile1 macdefs cgram.c
	$(CC) -c $(CFLAGS) cgram.c
rodata.o: rodata.c
	$(CC) -c $(CFLAGS) -R rodata.c
rodata.c cgram.c: $M/cgram.y
	$(YACC) $M/cgram.y
	rm -f rodata.c
	./:yyfix yyexca yyact yypact yypgo yyr1 yyr2 yychk yydef
	mv y.tab.c cgram.c
comm1.o: $M/manifest $M/mfile1 $M/common macdefs $M/comm1.c
	$(CC) -c $(CFLAGS) $M/comm1.c
table.o: $M/manifest $M/mfile2 mac2defs macdefs table.c
	$(CC) -c $(CFLAGS) -R table.c
reader.o: $M/manifest $M/mfile2 mac2defs macdefs $M/reader.c
	$(CC) -c $(CFLAGS) $M/reader.c
local2.o: $M/manifest $M/mfile2 mac2defs macdefs
	$(CC) -c $(CFLAGS) local2.c
order.o: $M/manifest $M/mfile2 mac2defs macdefs
	$(CC) -c $(CFLAGS) order.c
match.o: $M/manifest $M/mfile2 mac2defs macdefs $M/match.c
	$(CC) -c $(CFLAGS) $M/match.c
allo.o: $M/manifest $M/mfile2 mac2defs macdefs $M/allo.c
	$(CC) -c $(CFLAGS) $M/allo.c
clean:
	rm -f *.o ccom cgram.c rodata.c
lintall:
	lint -hv -I. -I$M $(CFLAGS) rodata.c cgram.c $M/xdefs.c \
	$M/scan.c $M/pftn.c $M/trees.c $M/optim.c code.c local.c \
	$M/reader.c local2.c order.c $M/match.c $M/allo.c $M/comm1.c table.c

install: all
	-mv ${DESTDIR}/lib/ccom ${DESTDIR}/lib/ccom.old
	install -s ccom ${DESTDIR}/lib/ccom
	install -s alist ${DESTDIR}/lib/alist

#ifndef lint
static char sccsid[] = "@(#)code.c	1.1 (Berkeley) 01/11/86";
#endif

# include "mfile1"
# include <sys/types.h>
# include <a.out.h>
# include <stab.h>

int proflg = 0;	/* are we generating profiling code? */
int strftn = 0;  /* is the current function one which returns a value */
int gdebug;
int fdefflag;  /* are we within a function definition ? */
#ifndef STABDOT
char NULLNAME[8];
#endif
int labelno;

branch( n ){
	/* output a branch to label n */
	/* exception is an ordinary function branching to retlab: then, return */
	if( n == retlab && !strftn ){
		register TWORD t;
		register r;
			/* set number of regs in assem comment field */
			/* so optimizers can do a better job */
		r = 0;
		if( retstat & RETVAL ){ /* the function rets a val somewhere */
			t = (&stab[curftn])->stype;
			t = DECREF(t);
			r++;	/* it is at least one */
			if(t == DOUBLE)
				r++;	/* it takes two */
		} else		/* the fn does not ret a val	*/
			r = 2;
		printf( "	ret#%d\n", r );
		}
	else printf( "	jbr 	L%d\n", n );
	}

int lastloc = { -1 };

short log2tab[] = {0, 0, 1, 2, 2, 3, 3, 3, 3};
#define LOG2SZ 9

defalign(n) {
	/* cause the alignment to become a multiple of n */
	n /= SZCHAR;
	if( lastloc != PROG && n > 1 ) printf( "	.align	%d\n", n >= 0 && n < LOG2SZ ? log2tab[n] : 0 );
	}

locctr( l ){
	register temp;
	/* l is PROG, ADATA, DATA, STRNG, ISTRNG, or STAB */

	if( l == lastloc ) return(l);
	temp = lastloc;
	lastloc = l;
	switch( l ){

	case PROG:
		printf( "	.text\n" );
		psline();
		break;

	case DATA:
	case ADATA:
		printf( "	.data\n" );
		break;

	case STRNG:
		printf( "	.data	1\n" );
		break;

	case ISTRNG:
		printf( "	.data	2\n" );
		break;

	case STAB:
		printf( "	.stab\n" );
		break;

	default:
		cerror( "illegal location counter" );
		}

	return( temp );
	}

deflab( n ){
	/* output something to define the current position as label n */
	printf( "L%d:\n", n );
	}

int crslab = 10;

getlab(){
	/* return a number usable for a label */
	return( ++crslab );
	}


efcode(){
	/* code for the end of a function */

	if( strftn ){  /* copy output (in R2) to caller */
		register NODE *l, *r;
		register struct symtab *p;
		register TWORD t;
		register int i;

		p = &stab[curftn];
		t = p->stype;
		t = DECREF(t);

		deflab( retlab );

		i = getlab();	/* label for return area */
#ifndef LCOMM
		printf("	.data\n" );
		printf("	.align	2\n" );
		printf("L%d:	.space	%d\n", i, tsize(t, p->dimoff, p->sizoff)/SZCHAR );
		printf("	.text\n" );
#else
		{ int sz = tsize(t, p->dimoff, p->sizoff) / SZCHAR;
		if (sz % (SZINT/SZCHAR))
			sz += (SZINT/SZCHAR) - (sz % (SZINT/SZCHAR));
		printf("	.lcomm	L%d,%d\n", i, sz);
		}
#endif
		psline();
		printf("	movab	L%d,r1\n", i);

		reached = 1;
		l = block( REG, NIL, NIL, PTR|t, p->dimoff, p->sizoff );
		l->tn.rval = 1;  /* R1 */
		l->tn.lval = 0;  /* no offset */
		r = block( REG, NIL, NIL, PTR|t, p->dimoff, p->sizoff );
		r->tn.rval = 0;  /* R0 */
		r->tn.lval = 0;
		l = buildtree( UNARY MUL, l, NIL );
		r = buildtree( UNARY MUL, r, NIL );
		l = buildtree( ASSIGN, l, r );
		l->in.op = FREE;
		ecomp( l->in.left );
		printf( "	movab	L%d,r0\n", i );
		/* turn off strftn flag, so return sequence will be generated */
		strftn = 0;
		}
	branch( retlab );
	p2bend();
	fdefflag = 0;
	}

int ftlab1, ftlab2;

bfcode( a, n ) int a[]; {
	/* code for the beginning of a function; a is an array of
		indices in stab for the arguments; n is the number */
	register i;
	register temp;
	register struct symtab *p;
	int off;
#ifdef REG_CHAR
	char *toreg();
#endif
	char *rname();

	locctr( PROG );
	p = &stab[curftn];
	printf( "	.align	1\n");
	defnam( p );
	temp = p->stype;
	temp = DECREF(temp);
	strftn = (temp==STRTY) || (temp==UNIONTY);

	retlab = getlab();

	/* routine prolog */

	printf( "	.word	L%d\n", ftnno);
	if (gdebug) {
#ifdef STABDOT
		pstabdot(N_SLINE, lineno);
#else
		pstab(NULLNAME, N_SLINE);
		printf("0,%d,LL%d\n", lineno, labelno);
		printf("LL%d:\n", labelno++);
#endif
	}
	ftlab1 = getlab();
	ftlab2 = getlab();
	printf( "	jbr 	L%d\n", ftlab1);
	printf( "L%d:\n", ftlab2);
	if( proflg ) {	/* profile code */
		i = getlab();
		printf("	pushl	$L%d\n", i);
		printf("	callf	$8,mcount\n");
		printf("	.data\n");
		printf("	.align	2\n");
		printf("L%d:	.long	0\n", i);
		printf("	.text\n");
		psline();
		}

	off = ARGINIT;

	for( i=0; i<n; ++i ){
		p = &stab[a[i]];
		if( p->sclass == REGISTER ){
			temp = p->offset;  /* save register number */
			p->sclass = PARAM;  /* forget that it is a register */
			p->offset = NOOFFSET;
			oalloc( p, &off );
#ifdef REG_CHAR
			printf( "	%s", toreg(p->stype)) );
#else
			printf("	movl");
#endif
			printf( "	%d(fp),%s\n", p->offset/SZCHAR, rname(temp) );
			p->offset = temp;  /* remember register number */
			p->sclass = REGISTER;   /* remember that it is a register */
#ifdef REG_CHAR
			temp = p->stype;
			if( temp==CHAR || temp==SHORT )
				p->stype = INT;
			else if( temp==UCHAR || temp==USHORT )
				p->stype = UNSIGNED;
#endif
			}
		else if( p->stype == STRTY || p->stype == UNIONTY ) {
			p->offset = NOOFFSET;
			if( oalloc( p, &off ) ) cerror( "bad argument" );
			SETOFF( off, ALSTACK );
			}
		else {
			if( oalloc( p, &off ) ) cerror( "bad argument" );
			}

		}
	fdefflag = 1;
	}

bccode(){ /* called just before the first executable statment */
		/* by now, the automatics and register variables are allocated */
	SETOFF( autooff, SZINT );
	/* set aside store area offset */
	p2bbeg( autooff, regvar );
	}

ejobcode( flag ){
	/* called just before final exit */
	/* flag is 1 if errors, 0 if none */
	}

aobeg(){
	/* called before removing automatics from stab */
	}

aocode(p) struct symtab *p; {
	/* called when automatic p removed from stab */
	}

aoend(){
	/* called after removing all automatics from stab */
	}

defnam( p ) register struct symtab *p; {
	/* define the current location as the name p->sname */

	if( p->sclass == EXTDEF ){
		printf( "	.globl	%s\n", exname( p->sname ) );
		}
	if( p->sclass == STATIC && p->slevel>1 ) deflab( p->offset );
	else printf( "%s:\n", exname( p->sname ) );

	}

bycode( t, i ){
#ifdef ASSTRINGS
static	int	lastoctal = 0;
#endif

	/* put byte i+1 in a string */

#ifdef ASSTRINGS

	i &= 077;
	if ( t < 0 ){
		if ( i != 0 )	printf( "\"\n" );
	} else {
		if ( i == 0 ) printf("\t.ascii\t\"");
		if ( t == '\\' || t == '"'){
			lastoctal = 0;
			printf("\\%c", t);
		}
		else if ( t < 040 || t >= 0177 ){
			lastoctal++;
			printf("\\%o",t);
		}
		else if ( lastoctal && '0' <= t && t <= '9' ){
			lastoctal = 0;
			printf("\"\n\t.ascii\t\"%c", t );
		}
		else
		{	
			lastoctal = 0;
			putchar(t);
		}
		if ( i == 077 ) printf("\"\n");
	}
#else

	i &= 07;
	if( t < 0 ){ /* end of the string */
		if( i != 0 ) printf( "\n" );
		}

	else { /* stash byte t into string */
		if( i == 0 ) printf( "	.byte	" );
		else printf( "," );
		printf( "0x%x", t );
		if( i == 07 ) printf( "\n" );
		}
#endif
	}

zecode( n ){
	/* n integer words of zeros */
	OFFSZ temp;
	if( n <= 0 ) return;
	printf( "	.space	%d\n", (SZINT/SZCHAR)*n );
	temp = n;
	inoff += temp*SZINT;
	}

fldal( t ) unsigned t; { /* return the alignment of field of type t */
	uerror( "illegal field type" );
	return( ALINT );
	}

fldty( p ) struct symtab *p; { /* fix up type of field p */
	;
	}

where(c){ /* print location of error  */
	/* c is either 'u', 'c', or 'w' */
	/* GCOS version */
	fprintf( stderr, "%s, line %d: ", ftitle, lineno );
	}


#ifdef REG_CHAR
/* tbl - toreg() returns a pointer to a char string
		  which is the correct  "register move" for the passed type 
 */
struct type_move {TWORD fromtype; char tostrng[8];} toreg_strs[] =
	{
	CHAR, "cvtbl",
	SHORT, "cvtwl",
	UCHAR,	"movzbl",
	USHORT,	"movzwl",
	0, "movl"
	};

char
*toreg(type)
	TWORD type;
{
	struct type_move *p;

	for ( p=toreg_strs; p->fromtype != 0; p++)
		if (p->fromtype == type) return(p->tostrng);

	/* type not found, must be a word type */
	return(p->tostrng);
}
/* tbl */
#endif


main( argc, argv ) char *argv[]; {
#ifdef BUFSTDERR
	char errbuf[BUFSIZ];
	setbuf(stderr, errbuf);
#endif
	return(mainp1( argc, argv ));
	}

struct sw heapsw[SWITSZ];	/* heap for switches */

genswitch(p,n) register struct sw *p;{
	/*	p points to an array of structures, each consisting
		of a constant value and a label.
		The first is >=0 if there is a default label;
		its value is the label number
		The entries p[1] to p[n] are the nontrivial cases
		*/
	register i;
	register CONSZ j;
	register CONSZ unsigned range;
	register dlab, swlab;

	range = p[n].sval-p[1].sval;

	if( range <= 3*n && n>=4 ){ /* implement a direct switch */

		swlab = getlab();
		dlab = p->slab >= 0 ? p->slab : getlab();

		/* already in r0 */
		printf( "	casel	r0,$" );
		printf( CONFMT, p[1].sval );
		printf(",$");
		printf( CONFMT, range);
		printf("\n	.align 1\nL%d:\n", swlab);
		for( i=1,j=p[1].sval; i<=n; j++) {
			printf("	.word	L%d-L%d\n", (j == p[i].sval ? ((j=p[i++].sval), p[i-1].slab) : dlab),
				swlab);
			}

		if( p->slab >= 0 ) branch( dlab );
		else printf("L%d:\n", dlab);
		return;

		}

	if( n>8 ) {	/* heap switch */

		heapsw[0].slab = dlab = p->slab >= 0 ? p->slab : getlab();
		makeheap(p, n, 1);	/* build heap */

		walkheap(1, n);	/* produce code */

		if( p->slab >= 0 )
			branch( dlab );
		else
			printf("L%d:\n", dlab);
		return;
	}

	/* debugging code */

	/* out for the moment
	if( n >= 4 ) werror( "inefficient switch: %d, %d", n, (int) (range/n) );
	*/

	/* simple switch code */

	for( i=1; i<=n; ++i ){
		/* already in r0 */

		printf( "	cmpl	r0,$" );
		printf( CONFMT, p[i].sval );
		printf( "\n	jeql	L%d\n", p[i].slab );
		}

	if( p->slab>=0 ) branch( p->slab );
	}

makeheap(p, m, n)
register struct sw *p;
{
	register int q;

	q = select(m);
	heapsw[n] = p[q];
	if( q>1 ) makeheap(p, q-1, 2*n);
	if( q<m ) makeheap(p+q, m-q, 2*n+1);
}

select(m) {
	register int l,i,k;

	for(i=1; ; i*=2)
		if( (i-1) > m ) break;
	l = ((k = i/2 - 1) + 1)/2;
	return( l + (m-k < l ? m-k : l));
}

walkheap(start, limit)
{
	int label;


	if( start > limit ) return;
	printf( "	cmpl	r0,$" );
	printf( CONFMT, heapsw[start].sval);
	printf("\n	jeql	L%d\n", heapsw[start].slab);
	if( (2*start) > limit ) {
		printf("	jbr 	L%d\n", heapsw[0].slab);
		return;
	}
	if( (2*start+1) <= limit ) {
		label = getlab();
		printf("	jgtr	L%d\n", label);
	} else
		printf("	jgtr	L%d\n", heapsw[0].slab);
	walkheap( 2*start, limit);
	if( (2*start+1) <= limit ) {
		printf("L%d:\n", label);
		walkheap( 2*start+1, limit);
	}
}

#ifndef lint
static char sccsid[] = "@(#)local.c	1.1 (Berkeley) 01/11/86";
#endif

# include "mfile1"

/*	this file contains code which is dependent on the target machine */

NODE *
clocal(p) register NODE *p; {

	/* this is called to do local transformations on
	   an expression tree preparitory to its being
	   written out in intermediate code.
	*/

	/* the major essential job is rewriting the
	   automatic variables and arguments in terms of
	   REG and OREG nodes */
	/* conversion ops which are not necessary are also clobbered here */
	/* in addition, any special features (such as rewriting
	   exclusive or) are easily handled here as well */

	register struct symtab *q;
	register NODE *r;
	register int o;
	register int m, ml;

	switch( o = p->in.op ){

	case NAME:
		if( p->tn.rval < 0 ) { /* already processed; ignore... */
			return(p);
			}
		q = &stab[p->tn.rval];
		switch( q->sclass ){

		case AUTO:
		case PARAM:
			/* fake up a structure reference */
			r = block( REG, NIL, NIL, PTR+STRTY, 0, 0 );
			r->tn.lval = 0;
			r->tn.rval = STKREG;
			p = stref( block( STREF, r, p, 0, 0, 0 ) );
			break;

		case ULABEL:
		case LABEL:
		case STATIC:
			if( q->slevel == 0 ) break;
			p->tn.lval = 0;
			p->tn.rval = -q->offset;
			break;

		case REGISTER:
			p->in.op = REG;
			p->tn.lval = 0;
			p->tn.rval = q->offset;
#ifdef REG_CHAR
			m = p->in.type;
			if( m==CHAR || m==SHORT )
				p->in.type = INT;
			else if( m==UCHAR || m==USHORT )
				p->in.type = UNSIGNED;
#endif
			break;

			}
		break;

	case LT:
	case LE:
	case GT:
	case GE:
		if( ISPTR( p->in.left->in.type ) || ISPTR( p->in.right->in.type ) ){
			p->in.op += (ULT-LT);
			}
		break;

	case PCONV:
		/* do pointer conversions for char and longs */
		ml = p->in.left->in.type;
		if( ( ml==CHAR || ml==UCHAR || ml==SHORT || ml==USHORT ) && p->in.left->in.op != ICON ) break;

		/* pointers all have the same representation; the type is inherited */

	inherit:
		p->in.left->in.type = p->in.type;
		p->in.left->fn.cdim = p->fn.cdim;
		p->in.left->fn.csiz = p->fn.csiz;
		p->in.op = FREE;
		return( p->in.left );

	case SCONV:
		m = p->in.type;
		ml = p->in.left->in.type;
		if(m == FLOAT || m == DOUBLE) {
			if(p->in.left->in.op==SCONV &&
			 (ml == FLOAT || ml == DOUBLE) &&
			 p->in.left->in.left->in.type==m) {
				p->in.op = p->in.left->in.op = FREE;
				return(p->in.left->in.left);
			}
			if(p->in.left->in.op==FCON)
				goto inherit;
			break;
		}
		if(ml == FLOAT || ml == DOUBLE){
			if (p->in.left->in.op == FCON){
				p->in.left->in.op = FREE;
				p->in.op = ICON;
				p->tn.lval = p->in.left->fpn.dval;
				p->tn.rval = NONAME;
				return(p);
			}
			break;
		}
		/* now, look for conversions downwards */

		if( p->in.left->in.op == ICON ){ /* simulate the conversion here */
			CONSZ val;
			val = p->in.left->tn.lval;
			switch( m ){
			case CHAR:
				p->in.left->tn.lval = (char) val;
				break;
			case UCHAR:
				p->in.left->tn.lval = val & 0XFF;
				break;
			case USHORT:
				p->in.left->tn.lval = val & 0XFFFFL;
				break;
			case SHORT:
				p->in.left->tn.lval = (short)val;
				break;
			case UNSIGNED:
				p->in.left->tn.lval = val & 0xFFFFFFFFL;
				break;
			case INT:
				p->in.left->tn.lval = (int)val;
				break;
				}
			p->in.left->in.type = m;
			}
		else {
			/* meaningful ones are conversion of int to char, int to short,
			   and short to char, and unsigned versions thereof */
			if( m==CHAR || m==UCHAR ){
				if( ml!=CHAR && ml!= UCHAR ) break;
				}
			else if( m==SHORT || m==USHORT ){
				if( ml!=CHAR && ml!=UCHAR && ml!=SHORT && ml!=USHORT ) break;
				}
			}

		/* clobber conversion */
		if( tlen(p) == tlen(p->in.left) ) goto inherit;
		p->in.op = FREE;
		return( p->in.left );  /* conversion gets clobbered */

	case QUEST:	/* the right side should be COLON */
		if((r = p->in.right)->in.op == SCONV) {
			p->in.right = r->in.left;
			p->in.type = r->in.left->in.type;
			r->in.left = p;
			return(r);
		}
		return(p);

	case PVCONV:
	case PMCONV:
		if( p->in.right->in.op != ICON ) cerror( "bad conversion", 0);
		p->in.op = FREE;
		return( buildtree( o==PMCONV?MUL:DIV, p->in.left, p->in.right ) );

	case FLD:
		/* make sure that the second pass does not make the
		   descendant of a FLD operator into a doubly indexed OREG */

		if( p->in.left->in.op == UNARY MUL
				&& (r=p->in.left->in.left)->in.op == PCONV)
			if( r->in.left->in.op == PLUS || r->in.left->in.op == MINUS ) 
				if( ISPTR(r->in.type) ) {
					if( ISUNSIGNED(p->in.left->in.type) )
						p->in.left->in.type = UNSIGNED;
					else
						p->in.left->in.type = INT;
				}
		break;
		case FORTCALL: /* arg must be FLOAT */
			if((r = p->in.right)->in.type != FLOAT)
				p->in.right = clocal(makety(r, FLOAT, 0, FLOAT));
			return(p);
		}

	/* if both sides are FLOAT, so is the op */
	if(optype(o)!=LTYPE && p->in.left->in.type==DOUBLE &&
	 (o==UNARY MINUS || optype(o)==BITYPE && p->in.right->in.type==DOUBLE)) {
		r = p->in.left;
		if(r->in.op==SCONV && r->in.left->in.type==FLOAT) {
			if(optype(o)==BITYPE) {
				r = p->in.right;
				if(r->in.op==SCONV && r->in.left->in.type==FLOAT) {
					r->in.op = FREE;
					p->in.right = r->in.left;
				} else if(r->in.op==FCON)
					r->in.type = FLOAT;
				else
					return(p);
			}
			r = p->in.left;
			p->in.left = r->in.left;
		} else if(optype(o)==BITYPE && r->in.op==FCON) {
			r = p->in.right;
			if(!(r->in.op==SCONV && r->in.left->in.type==FLOAT))
				return(p);
			p->in.right = r->in.left;
			p->in.left->in.type = FLOAT;
		} else
			return(p);
		if(p->in.type==DOUBLE) {
			p->in.type = FLOAT;
			r->in.left = p;
			return(r);
		} else {	/* usually logop */
			r->in.op = FREE;
			return(p);
		}
	}
	return(p);
}

andable( p ) NODE *p; {
	return(1);  /* all names can have & taken on them */
	}

cendarg(){ /* at the end of the arguments of a ftn, set the automatic offset */
	autooff = AUTOINIT;
	}

cisreg( t ) TWORD t; { /* is an automatic variable of type t OK for a register variable */

	if( t==INT || t==UNSIGNED || t==LONG || t==ULONG	/* tbl */
#ifdef REG_CHAR
		|| t==CHAR || t==UCHAR || t==SHORT || t==USHORT		/* tbl */
#endif
		|| ISPTR(t)) return (1);			/* wnj */
	return(0);
	}

NODE *
offcon( off, t, d, s ) OFFSZ off; TWORD t; {

	/* return a node, for structure references, which is suitable for
	   being added to a pointer of type t, in order to be off bits offset
	   into a structure */

	register NODE *p;

	/* t, d, and s are the type, dimension offset, and sizeoffset */
	/* in general they  are necessary for offcon, but not on H'well */

	p = bcon(0);
	p->tn.lval = off/SZCHAR;
	return(p);

	}


static inwd	/* current bit offsed in word */;
static CONSZ word	/* word being built from fields */;

incode( p, sz ) register NODE *p; {

	/* generate initialization code for assigning a constant c
		to a field of width sz */
	/* we assume that the proper alignment has been obtained */
	/* inoff is updated to have the proper final value */
	/* we also assume sz  < SZINT */

	inwd += sz;
	if(inwd > SZINT) cerror("incode: field > int");
	word |= (p->tn.lval&((1L<<sz)-1)) << (SZINT-inwd);
	inoff += sz;
	if(inoff%SZINT == 0) {
		printf( "	.long	0x%08X\n", word);
		word = inwd = 0;
		}
	}

# ifdef PRTDCON
prtdcon( p ) register NODE *p; {
	int i;

	if( p->in.op == FCON ){
		if(p->fpn.dval == 0) {
			p->in.op = ICON;
			p->tn.rval = NONAME;
			return;
		}
		locctr( DATA );
		defalign( ALDOUBLE );
		deflab( i = getlab() );
# ifndef SFCON
		fincode( p->fpn.dval, p->in.type==DOUBLE ? SZDOUBLE : SZFLOAT);
# else
		p->in.type = fincode( p->fpn.dval, 0 );
# endif
		p->tn.lval = 0;
		p->tn.rval = -i;
		p->in.op = NAME;
		}
	}
# endif

fincode( d, sz ) double d; register int sz; {
	/*
	 * output code to initialize space of size sz to the value d
	 * the proper alignment has been obtained
	 * inoff is updated to have the proper final value
	 * this code should be the same for PDP, VAX and Tahoe
	 * SFCON makes use of value to determine type - only where
	 * float<->double conversions are ignored.
	 */

	register struct sh4 {
		unsigned short sh[4];
	} *x;
# ifdef SFCON
	register int type;
# else
	float f;

	if(sz == SZFLOAT) {	/* force rounding */
		f = d;
		d = f;
	}
# endif

	x = (struct sh4 *)&d;
	printf("	.long	0x%04x%04x", x->sh[0], x->sh[1]);
# ifdef SFCON
	if(sz==0)
		if(x->sh[2]==0 && x->sh[3]==0) {
			sz = SZFLOAT;
			type = FLOAT;
		} else {
			sz = SZDOUBLE;
			type = DOUBLE;
		}
# endif
	if(sz == SZDOUBLE) {
		printf(", 0x%04x%04x", x->sh[2], x->sh[3]);
		printf(" # .double %.17g\n", d);
	} else
		printf(" # .float %.8g\n", d);
	inoff += sz;
# ifdef SFCON
	return type;
# endif
	}

cinit( p, sz ) NODE *p; {
	/* arrange for the initialization of p into a space of
	size sz */
	/* the proper alignment has been opbtained */
	/* inoff is updated to have the proper final value */
	ecode( p );
	inoff += sz;
	}

vfdzero( n ){ /* define n bits of zeros in a vfd */

	if( n <= 0 ) return;

	inwd += n;
	inoff += n;
	if( inoff%ALINT ==0 ) {
		printf( "	.long	0x%08X\n", word );
		word = inwd = 0;
		}
	}

char *
exname( p ) char *p; {
	/* make a name look like an external name in the local machine */

#ifndef FLEXNAMES
	static char text[NCHNAM+1];
#else
	static char text[BUFSIZ+1];
#endif

	register int i;

	text[0] = '_';
#ifndef FLEXNAMES
	for( i=1; *p&&i<NCHNAM; ++i ){
#else
	for( i=1; *p; ++i ){
#endif
		text[i] = *p++;
		}

	text[i] = '\0';
#ifndef FLEXNAMES
	text[NCHNAM] = '\0';  /* truncate */
#endif

	return( text );
	}

ctype( type )TWORD type;{ /* map types which are not defined on the local machine */
	switch( BTYPE(type) ){

	case LONG:
		MODTYPE(type,INT);
		break;

	case ULONG:
		MODTYPE(type,UNSIGNED);
		}
	return( type );
	}

noinit() { /* curid is a variable which is defined but
	is not initialized (and not a function );
	This routine returns the stroage class for an uninitialized declaration */

	return(EXTERN);

	}

commdec( id ){ /* make a common declaration for id, if reasonable */
	register struct symtab *q;
	OFFSZ off, tsize();

	q = &stab[id];
	printf( "	.comm	%s,", exname( q->sname ) );
	off = tsize( q->stype, q->dimoff, q->sizoff );
	printf( "%d" /*CONFMT*/, off/SZCHAR );
	printf( "\n" );
	}


isitfloat( s ) char *s; {
	double atof();
	dcon = atof(s);
	return( FCON );
	}

ecode( p ) NODE *p; {

	/* walk the tree and write out the nodes.. */

	if( nerrors ) return;
	p2tree( p );
	p2compile( p );
	}

#ifndef ONEPASS
tlen(p) NODE *p; 
{
	switch(p->in.type) {
		case CHAR:
		case UCHAR:
			return(1);
			
		case SHORT:
		case USHORT:
			return(2);
			
		case DOUBLE:
			return(8);
			
		default:
			return(4);
		}
	}
#endif

#ifndef lint
static char sccsid[] = "@(#)local2.c	1.1 (Berkeley) 01/11/86";
#endif

# include "mfile2"
# include "ctype.h"
# ifdef FORT
int ftlab1, ftlab2;
# endif
/* a lot of the machine dependent parts of the second pass */

# define BITMASK(n) ((1L<<n)-1)

# ifndef ONEPASS
where(c){
	fprintf( stderr, "%s, line %d: ", filename, lineno );
	}
# endif

lineid( l, fn ) char *fn; {
	/* identify line l and file fn */
	printf( "#	line %d, file %s\n", l, fn );
	}

int ent_mask;

eobl2(){
	register OFFSZ spoff;	/* offset from stack pointer */
#ifndef FORT
	extern int ftlab1, ftlab2;
#endif

	spoff = maxoff;
	spoff /= SZCHAR;
	SETOFF(spoff,4);
#ifdef FORT
#ifndef FLEXNAMES
	printf( "	.set	.F%d,%d\n", ftnno, spoff );
#else
	/* SHOULD BE L%d ... ftnno but must change pc/f77 */
	printf( "	.set	LF%d,%d\n", ftnno, spoff );
#endif
	printf( "	.set	LWM%d,0x%x\n", ftnno, ent_mask&0x1ffc|0x1000);
#else
	printf( "	.set	L%d,0x%x\n", ftnno, ent_mask&0x1ffc);
	printf( "L%d:\n", ftlab1);
	if( maxoff > AUTOINIT )
		printf( "	subl3	$%d,fp,sp\n", spoff);
	printf( "	jbr 	L%d\n", ftlab2);
#endif
	ent_mask = 0;
	maxargs = -1;
	}

struct hoptab { int opmask; char * opstring; } ioptab[] = {

	PLUS,	"add",
	MINUS,	"sub",
	MUL,	"mul",
	DIV,	"div",
	MOD,	"div",
	OR,	"or",
	ER,	"xor",
	AND,	"and",
	-1,	""    };

hopcode( f, o ){
	/* output the appropriate string from the above table */

	register struct hoptab *q;

	if(asgop(o))
		o = NOASG o;
	for( q = ioptab;  q->opmask>=0; ++q ){
		if( q->opmask == o ){
			if(f == 'E')
				printf( "e%s", q->opstring);
			else
				printf( "%s%c", q->opstring, tolower(f));
			return;
			}
		}
	cerror( "no hoptab for %s", opst[o] );
	}

char *
rnames[] = {  /* keyed to register number tokens */

	"r0", "r1",
	"r2", "r3", "r4", "r5",
	"r6", "r7", "r8", "r9", "r10", "r11",
	"r12", "fp", "sp", "pc",
	};

/* output register name and update entry mask */
char *
rname(r)
	register int r;
{

	ent_mask |= 1<<r;
	return(rnames[r]);
}

int rstatus[] = {
	SAREG|STAREG, SAREG|STAREG,
	SAREG|STAREG, SAREG|STAREG, SAREG|STAREG, SAREG|STAREG,
	SAREG, SAREG, SAREG, SAREG, SAREG, SAREG,
	SAREG, SAREG, SAREG, SAREG,
	};

tlen(p) NODE *p;
{
	switch(p->in.type) {
		case CHAR:
		case UCHAR:
			return(1);

		case SHORT:
		case USHORT:
			return(2);

		case DOUBLE:
			return(8);

		default:
			return(4);
		}
}

prtype(n) NODE *n;
{
	switch (n->in.type)
		{

		case DOUBLE:
			printf("d");
			return;

		case FLOAT:
			printf("f");
			return;

		case INT:
		case UNSIGNED:
			printf("l");
			return;

		case SHORT:
		case USHORT:
			printf("w");
			return;

		case CHAR:
		case UCHAR:
			printf("b");
			return;

		default:
			if ( !ISPTR( n->in.type ) ) cerror("zzzcode- bad type");
			else {
				printf("l");
				return;
				}
		}
}

zzzcode( p, c ) register NODE *p; {
	register int m;
	int val;
	switch( c ){

	case 'N':  /* logical ops, turned into 0-1 */
		/* use register given by register 1 */
		cbgen( 0, m=getlab(), 'I' );
		deflab( p->bn.label );
		printf( "	clrl	%s\n", rname(getlr( p, '1' )->tn.rval) );
		deflab( m );
		return;

	case 'P':
		cbgen( p->in.op, p->bn.label, c );
		return;

	case 'A':	/* assignment and load (integer only) */
		{
		register NODE *l, *r;

		if (xdebug) eprint(p, 0, &val, &val);
		r = getlr(p, 'R');
		if (optype(p->in.op) == LTYPE || p->in.op == UNARY MUL) {
			l = resc;
			l->in.type = INT;
		} else
			l = getlr(p, 'L');
		if(r->in.type==FLOAT || r->in.type==DOUBLE
		 || l->in.type==FLOAT || l->in.type==DOUBLE)
			cerror("float in ZA");
		if (r->in.op == ICON)
			if(r->in.name[0] == '\0') {
				if (r->tn.lval == 0) {
					printf("clr");
					prtype(l);
					printf("	");
					adrput(l);
					return;
				}
				if (r->tn.lval < 0 && r->tn.lval >= -63) {
					printf("mneg");
					prtype(l);
					r->tn.lval = -r->tn.lval;
					goto ops;
				}
#ifdef MOVAFASTER
			} else {
				printf("movab");
				printf("	");
				acon(r);
				printf(",");
				adrput(l);
				return;
#endif MOVAFASTER
			}

		if (l->in.op == REG) {
			if( tlen(l) < tlen(r) ) {
				!ISUNSIGNED(l->in.type)?
					printf("cvt"):
					printf("movz");
				prtype(l);
				printf("l");
				goto ops;
			} else
				l->in.type = INT;
		}
		if (tlen(l) == tlen(r)) {
			printf("mov");
			prtype(l);
			goto ops;
		} else if (tlen(l) > tlen(r) && ISUNSIGNED(r->in.type))
			printf("movz");
		else
			printf("cvt");
		prtype(r);
		prtype(l);
	ops:
		printf("	");
		adrput(r);
		printf(",");
		adrput(l);
		return;
		}

	case 'B':	/* get oreg value in temp register for shift */
		{
		register NODE *r;
		if (xdebug) eprint(p, 0, &val, &val);
		r = p->in.right;
		if( tlen(r) == sizeof(int) && r->in.type != FLOAT )
			printf("movl");
		else {
			printf(ISUNSIGNED(r->in.type) ? "movz" : "cvt");
			prtype(r);
			printf("l");
			}
		return;
		}

	case 'C':	/* num bytes pushed on arg stack */
		{
		extern int gc_numbytes;
		extern int xdebug;

		if (xdebug) printf("->%d<-",gc_numbytes);

		printf("call%c	$%d",
		 (p->in.left->in.op==ICON && gc_numbytes<60)?'f':'s',
		 gc_numbytes+4);
		/* dont change to double (here's the only place to catch it) */
		if(p->in.type == FLOAT)
			rtyflg = 1;
		return;
		}

	case 'D':	/* INCR and DECR */
		zzzcode(p->in.left, 'A');
		printf("\n	");

	case 'E':	/* INCR and DECR, FOREFF */
 		if (p->in.right->tn.lval == 1)
			{
			printf("%s", (p->in.op == INCR ? "inc" : "dec") );
			prtype(p->in.left);
			printf("	");
			adrput(p->in.left);
			return;
			}
		printf("%s", (p->in.op == INCR ? "add" : "sub") );
		prtype(p->in.left);
		printf("2	");
		adrput(p->in.right);
		printf(",");
		adrput(p->in.left);
		return;

	case 'F':	/* masked constant for fields */
		printf("$%d", (p->in.right->tn.lval&((1<<fldsz)-1))<<fldshf);
		return;

	case 'H':	/* opcode for shift */
		if(p->in.op == LS || p->in.op == ASG LS)
			printf("shll");
		else if(ISUNSIGNED(p->in.left->in.type))
			printf("shrl");
		else
			printf("shar");
		return;

	case 'L':	/* type of left operand */
	case 'R':	/* type of right operand */
		{
		register NODE *n;
		extern int xdebug;

		n = getlr ( p, c);
		if (xdebug) printf("->%d<-", n->in.type);

		prtype(n);
		return;
		}

	case 'M':  /* initiate ediv for mod and unsigned div */
		{
		register char *r;
		m = getlr(p, '1')->tn.rval;
		r = rname(m);
		printf("\tclrl\t%s\n\tmovl\t", r);
		adrput(p->in.left);
		printf(",%s\n", rname(m+1));
		if(!ISUNSIGNED(p->in.type)) { 	/* should be MOD */
			m = getlab();
			printf("\tjgeq\tL%d\n\tmnegl\t$1,%s\n", m, r);
			deflab(m);
		}
		}
		return;

	case 'U':
		/* Truncate int for type conversions:
		    LONG|ULONG -> CHAR|UCHAR|SHORT|USHORT
		    SHORT|USHORT -> CHAR|UCHAR
		   increment offset to correct byte */
		{
		register NODE *p1;
		int dif;

		p1 = p->in.left;
		switch( p1->in.op ){
		case NAME:
		case OREG:
			dif = tlen(p1)-tlen(p);
			p1->tn.lval += dif;
			adrput(p1);
			p1->tn.lval -= dif;
			return;
		default:
			cerror( "Illegal ZU type conversion" );
			return;
			}
		}

	case 'T':	/* rounded structure length for arguments */
		{
		int size;

		size = p->stn.stsize;
		SETOFF( size, 4);
		printf("movab	-%d(sp),sp", size);
		return;
		}

	case 'S':  /* structure assignment */
		{
			register NODE *l, *r;
			register int size;

			if( p->in.op == STASG ){
				l = p->in.left;
				r = p->in.right;

				}
			else if( p->in.op == STARG ){  /* store an arg into a temporary */
				l = getlr( p, '3' );
				r = p->in.left;
				}
			else cerror( "STASG bad" );

			if( r->in.op == ICON ) r->in.op = NAME;
			else if( r->in.op == REG ) r->in.op = OREG;
			else if( r->in.op != OREG ) cerror( "STASG-r" );

			size = p->stn.stsize;

			if( size <= 0 || size > 65535 )
				cerror("structure size <0=0 or >65535");

			switch(size) {
				case 1:
					printf("	movb	");
					break;
				case 2:
					printf("	movw	");
					break;
				case 4:
					printf("	movl	");
					break;
				case 8:
					printf("	movl	");
					upput(r);
					printf(",");
					upput(l);
					printf("\n	movl	");
					break;
				default:
					printf("	movab	");
					adrput(l);
					printf(",r1\n	movab	");
					adrput(r);
					printf(",r0\n	movl	$%d,r2\n	movblk\n", size);
					rname(2);
					goto endstasg;
			}
			adrput(r);
			printf(",");
			adrput(l);
			printf("\n");
		endstasg:
			if( r->in.op == NAME ) r->in.op = ICON;
			else if( r->in.op == OREG ) r->in.op = REG;

			}
		break;

	default:
		cerror( "illegal zzzcode" );
		}
	}

rmove( rt, rs, t ) TWORD t;{
	printf( "	movl	%s,%s\n", rname(rs), rname(rt) );
	if(t==DOUBLE)
		printf( "	movl	%s,%s\n", rname(rs+1), rname(rt+1) );
	}

struct respref
respref[] = {
	INTAREG|INTBREG,	INTAREG|INTBREG,
	INAREG|INBREG,	INAREG|INBREG|SOREG|STARREG|STARNM|SNAME|SCON,
	INTEMP,	INTEMP,
	FORARG,	FORARG,
	INTEMP,	INTAREG|INAREG|INTBREG|INBREG|SOREG|STARREG|STARNM,
	0,	0 };

setregs(){ /* set up temporary registers */
	fregs = 6;	/* tbl- 6 free regs on Tahoe (0-5) */
	}

szty(t) TWORD t;{ /* size, in registers, needed to hold thing of type t */
	return(t==DOUBLE ? 2 : 1 );
	}

rewfld( p ) NODE *p; {
	return(1);
	}

callreg(p) NODE *p; {
	return( R0 );
	}

base( p ) register NODE *p; {
	register int o = p->in.op;

	if( (o==ICON && p->in.name[0] != '\0')) return( 100 ); /* ie no base reg */
	if( o==REG ) return( p->tn.rval );
    if( (o==PLUS || o==MINUS) && p->in.left->in.op == REG && p->in.right->in.op==ICON)
		return( p->in.left->tn.rval );
    if( o==OREG && !R2TEST(p->tn.rval) && (p->in.type==INT || p->in.type==UNSIGNED || ISPTR(p->in.type)) )
		return( p->tn.rval + 0200*1 );
	return( -1 );
	}

offset( p, tyl ) register NODE *p; int tyl; {

	if(tyl > 8) return( -1 );
	if( tyl==1 && p->in.op==REG && (p->in.type==INT || p->in.type==UNSIGNED) ) return( p->tn.rval );
	if( (p->in.op==LS && p->in.left->in.op==REG && (p->in.left->in.type==INT || p->in.left->in.type==UNSIGNED) &&
	      (p->in.right->in.op==ICON && p->in.right->in.name[0]=='\0')
	      && (1<<p->in.right->tn.lval)==tyl))
		return( p->in.left->tn.rval );
	return( -1 );
	}

makeor2( p, q, b, o) register NODE *p, *q; register int b, o; {
	register NODE *t;
	register int i;
	NODE *f;

	p->in.op = OREG;
	f = p->in.left; 	/* have to free this subtree later */

	/* init base */
	switch (q->in.op) {
		case ICON:
		case REG:
		case OREG:
			t = q;
			break;

		case MINUS:
			q->in.right->tn.lval = -q->in.right->tn.lval;
		case PLUS:
			t = q->in.right;
			break;

		case UNARY MUL:
			t = q->in.left->in.left;
			break;

		default:
			cerror("illegal makeor2");
	}

	p->tn.lval = t->tn.lval;
#ifndef FLEXNAMES
	for(i=0; i<NCHNAM; ++i)
		p->in.name[i] = t->in.name[i];
#else
	p->in.name = t->in.name;
#endif

	/* init offset */
	p->tn.rval = R2PACK( (b & 0177), o, (b>>7) );

	tfree(f);
	return;
	}

canaddr( p ) NODE *p; {
	register int o = p->in.op;

	if( o==NAME || o==REG || o==ICON || o==OREG || (o==UNARY MUL && shumul(p->in.left)) ) return(1);
	return(0);
	}

shltype( o, p ) register NODE *p; {
	return( o== REG || o == NAME || o == ICON || o == OREG || ( o==UNARY MUL && shumul(p->in.left)) );
	}

flshape( p ) NODE *p; {
	register int o = p->in.op;

	if( o==NAME || o==REG || o==ICON || o==OREG || (o==UNARY MUL && shumul(p->in.left)) ) return(1);
	return(0);
	}

shtemp( p ) register NODE *p; {
	if( p->in.op == STARG ) p = p->in.left;
	return( p->in.op==NAME || p->in.op ==ICON || p->in.op == OREG || (p->in.op==UNARY MUL && shumul(p->in.left)) );
	}

shumul( p ) register NODE *p; {
	register int o;
	extern int xdebug;

	if (xdebug) {
		 printf("\nshumul:op=%d,lop=%d,rop=%d", p->in.op, p->in.left->in.op, p->in.right->in.op);
		printf(" prname=%s,plty=%d, prlval=%D\n", p->in.right->in.name, p->in.left->in.type, p->in.right->tn.lval);
		}

	o = p->in.op;
	if(( o == NAME || (o == OREG && !R2TEST(p->tn.rval)) || o == ICON )
	 && p->in.type != PTR+DOUBLE)
		return( STARNM );

	return( 0 );
	}

special( p, shape ) register NODE *p; {
	if( shape==SIREG && p->in.op == OREG && R2TEST(p->tn.rval) ) return(1);
	else return(0);
}

adrcon( val ) CONSZ val; {
	printf( "$" );
	printf( CONFMT, val );
	}

conput( p ) register NODE *p; {
	switch( p->in.op ){

	case ICON:
		acon( p );
		return;

	case REG:
		printf( "%s", rname(p->tn.rval) );
		return;

	default:
		cerror( "illegal conput" );
		}
	}

insput( p ) NODE *p; {
	cerror( "insput" );
	}

upput( p ) register NODE *p; {
	/* output the address of the second long in the
	   pair pointed to by p (for DOUBLEs)*/
	CONSZ save;

	if( p->in.op == FLD ){
		p = p->in.left;
		}
	switch( p->in.op ){

	case NAME:
	case OREG:
		save = p->tn.lval;
		p->tn.lval += SZLONG/SZCHAR;
		adrput(p);
		p->tn.lval = save;
		return;

	case REG:
		printf( "%s", rname(p->tn.rval+1) );
		return;

	default:
		cerror( "illegal upper address" );
		}
	}

adrput( p ) register NODE *p; {
	register int r;
	/* output an address, with offsets, from p */

	if( p->in.op == FLD ){
		p = p->in.left;
		}
	switch( p->in.op ){

	case NAME:
		acon( p );
		return;

	case ICON:
		/* addressable value of the constant */
		printf( "$" );
		acon( p );
		return;

	case REG:
		printf( "%s", rname(p->tn.rval) );
		if(p->in.type == DOUBLE)	/* for entry mask */
			(void) rname(p->tn.rval+1);
		return;

	case OREG:
		r = p->tn.rval;
		if( R2TEST(r) ){ /* double indexing */
			register int flags;

			flags = R2UPK3(r);
			if( flags & 1 ) printf("*");
			if( p->tn.lval != 0 || p->in.name[0] != '\0' ) acon(p);
			if( R2UPK1(r) != 100) printf( "(%s)", rname(R2UPK1(r)) );
			printf( "[%s]", rname(R2UPK2(r)) );
			return;
			}
		if( r == FP && p->tn.lval > 0 ){  /* in the argument region */
			if( p->in.name[0] != '\0' ) werror( "bad arg temp" );
			printf( CONFMT, p->tn.lval );
			printf( "(fp)" );
			return;
			}
		if( p->tn.lval != 0 || p->in.name[0] != '\0') acon( p );
		printf( "(%s)", rname(p->tn.rval) );
		return;

	case UNARY MUL:
		/* STARNM or STARREG found */
		if( tshape(p, STARNM) ) {
			printf( "*" );
			adrput( p->in.left);
			}
		return;

	default:
		cerror( "illegal address" );
		return;

		}

	}

acon( p ) register NODE *p; { /* print out a constant */

	if( p->in.name[0] == '\0' ){
		printf( CONFMT, p->tn.lval);
		}
	else if( p->tn.lval == 0 ) {
#ifndef FLEXNAMES
		printf( "%.8s", p->in.name );
#else
		printf( "%s", p->in.name );
#endif
		}
	else {
#ifndef FLEXNAMES
		printf( "%.8s+", p->in.name );
#else
		printf( "%s+", p->in.name );
#endif
		printf( CONFMT, p->tn.lval );
		}
	}

genscall( p, cookie ) register NODE *p; {
	/* structure valued call */
	return( gencall( p, cookie ) );
	}

genfcall( p, cookie ) register NODE *p; {
	register NODE *p1;
	register int m;
	static char *funcops[6] = {
		"sin", "cos", "sqrt", "exp", "log", "atan"
	};

	/* generate function opcodes */
	if(p->in.op==UNARY FORTCALL && p->in.type==FLOAT &&
	 (p1 = p->in.left)->in.op==ICON &&
	 p1->tn.lval==0 && p1->in.type==INCREF(FTN|FLOAT)) {
#ifdef FLEXNAMES
		p1->in.name++;
#else
		strcpy(p1->in.name, p1->in.name[1]);
#endif
		for(m=0; m<6; m++)
			if(!strcmp(p1->in.name, funcops[m]))
				break;
		if(m >= 6)
			uerror("no opcode for fortarn function %s", p1->in.name);
	} else
		uerror("illegal type of fortarn function");
	p1 = p->in.right;
	p->in.op = FORTCALL;
	if(!canaddr(p1))
		order( p1, INAREG|INBREG|SOREG|STARREG|STARNM );
	m = match( p, INTAREG|INTBREG );
	return(m != MDONE);
}

/* tbl */
int gc_numbytes;
/* tbl */

gencall( p, cookie ) register NODE *p; {
	/* generate the call given by p */
	register NODE *p1, *ptemp;
	register int temp, temp1;
	register int m;

	if( p->in.right ) temp = argsize( p->in.right );
	else temp = 0;

	if( p->in.op == STCALL || p->in.op == UNARY STCALL ){
		/* set aside room for structure return */

		if( p->stn.stsize > temp ) temp1 = p->stn.stsize;
		else temp1 = temp;
		}

	if( temp > maxargs ) maxargs = temp;
	SETOFF(temp1,4);

	if( p->in.right ){ /* make temp node, put offset in, and generate args */
		ptemp = talloc();
		ptemp->in.op = OREG;
		ptemp->tn.lval = -1;
		ptemp->tn.rval = SP;
#ifndef FLEXNAMES
		ptemp->in.name[0] = '\0';
#else
		ptemp->in.name = "";
#endif
		ptemp->in.rall = NOPREF;
		ptemp->in.su = 0;
		genargs( p->in.right, ptemp );
		ptemp->in.op = FREE;
		}

	p1 = p->in.left;
	if( p1->in.op != ICON ){
		if( p1->in.op != REG ){
			if( p1->in.op != OREG || R2TEST(p1->tn.rval) ){
				if( p1->in.op != NAME ){
					order( p1, INAREG );
					}
				}
			}
		}

/* tbl
	setup gc_numbytes so reference to ZC works */

	gc_numbytes = temp&(0x3ff);

	p->in.op = UNARY CALL;
	m = match( p, INTAREG|INTBREG );

	return(m != MDONE);
	}

/* tbl */
char *
ccbranches[] = {
	"eql",
	"neq",
	"leq",
	"lss",
	"geq",
	"gtr",
	"lequ",
	"lssu",
	"gequ",
	"gtru",
	};
/* tbl */

cbgen( o, lab, mode ) { /*   printf conditional and unconditional branches */

		if(o != 0 && (o < EQ || o > UGT ))
			cerror( "bad conditional branch: %s", opst[o] );
		printf( "	j%s	L%d\n",
		 o == 0 ? "br" : ccbranches[o-EQ], lab );
	}

nextcook( p, cookie ) NODE *p; {
	/* we have failed to match p with cookie; try another */
	if( cookie == FORREW ) return( 0 );  /* hopeless! */
	if( !(cookie&(INTAREG|INTBREG)) ) return( INTAREG|INTBREG );
	if( !(cookie&INTEMP) && asgop(p->in.op) ) return( INTEMP|INAREG|INTAREG|INTBREG|INBREG );
	return( FORREW );
	}

lastchance( p, cook ) NODE *p; {
	/* forget it! */
	return(0);
	}

optim2( p ) register NODE *p; {
# ifdef ONEPASS
	/* do local tree transformations and optimizations */
# define RV(p) p->in.right->tn.lval
	register int o = p->in.op;
	register int i;

	/* change unsigned mods and divs to logicals (mul is done in mip & c2) */
	if(optype(o) == BITYPE && ISUNSIGNED(p->in.left->in.type)
	 && nncon(p->in.right) && (i=ispow2(RV(p)))>=0){
		switch(o) {
		case DIV:
		case ASG DIV:
			p->in.op = RS;
			RV(p) = i;
			break;
		case MOD:
		case ASG MOD:
			p->in.op = AND;
			RV(p)--;
			break;
		default:
			return;
		}
		if(asgop(o))
			p->in.op = ASG p->in.op;
	}
# endif
}

struct functbl {
	int fop;
	char *func;
} opfunc[] = {
	DIV,		"udiv", 
	ASG DIV,	"udiv", 
	0
};

hardops(p)  register NODE *p; {
	/* change hard to do operators into function calls.  */
	register NODE *q;
	register struct functbl *f;
	register int o;
	register TWORD t, t1, t2;

	o = p->in.op;

	for( f=opfunc; f->fop; f++ ) {
		if( o==f->fop ) goto convert;
	}
	return;

	convert:
	t = p->in.type;
	t1 = p->in.left->in.type;
	t2 = p->in.right->in.type;
	if ( t1 != UNSIGNED && (t2 != UNSIGNED)) return;

	/* need to rewrite tree for ASG OP */
	/* must change ASG OP to a simple OP */
	if( asgop( o ) ) {
		q = talloc();
		q->in.op = NOASG ( o );
		q->in.rall = NOPREF;
		q->in.type = p->in.type;
		q->in.left = tcopy(p->in.left);
		q->in.right = p->in.right;
		p->in.op = ASSIGN;
		p->in.right = q;
		zappost(q->in.left); /* remove post-INCR(DECR) from new node */
		fixpre(q->in.left);	/* change pre-INCR(DECR) to +/-	*/
		p = q;

	}
	/* turn logicals to compare 0 */
	else if( logop( o ) ) {
		ncopy(q = talloc(), p);
		p->in.left = q;
		p->in.right = q = talloc();
		q->in.op = ICON;
		q->in.type = INT;
#ifndef FLEXNAMES
		q->in.name[0] = '\0';
#else
		q->in.name = "";
#endif
		q->tn.lval = 0;
		q->tn.rval = 0;
		p = p->in.left;
	}

	/* build comma op for args to function */
	t1 = p->in.left->in.type;
	t2 = 0;
	if ( optype(p->in.op) == BITYPE) {
		q = talloc();
		q->in.op = CM;
		q->in.rall = NOPREF;
		q->in.type = INT;
		q->in.left = p->in.left;
		q->in.right = p->in.right;
		t2 = p->in.right->in.type;
	} else
		q = p->in.left;

	p->in.op = CALL;
	p->in.right = q;

	/* put function name in left node of call */
	p->in.left = q = talloc();
	q->in.op = ICON;
	q->in.rall = NOPREF;
	q->in.type = INCREF( FTN + p->in.type );
#ifndef FLEXNAMES
		strcpy( q->in.name, f->func );
#else
		q->in.name = f->func;
#endif
	q->tn.lval = 0;
	q->tn.rval = 0;

	}

zappost(p) NODE *p; {
	/* look for ++ and -- operators and remove them */

	register int o, ty;
	register NODE *q;
	o = p->in.op;
	ty = optype( o );

	switch( o ){

	case INCR:
	case DECR:
			q = p->in.left;
			p->in.right->in.op = FREE;  /* zap constant */
			ncopy( p, q );
			q->in.op = FREE;
			return;

		}

	if( ty == BITYPE ) zappost( p->in.right );
	if( ty != LTYPE ) zappost( p->in.left );
}

fixpre(p) NODE *p; {

	register int o, ty;
	o = p->in.op;
	ty = optype( o );

	switch( o ){

	case ASG PLUS:
			p->in.op = PLUS;
			break;
	case ASG MINUS:
			p->in.op = MINUS;
			break;
		}

	if( ty == BITYPE ) fixpre( p->in.right );
	if( ty != LTYPE ) fixpre( p->in.left );
}

NODE * addroreg(l) NODE *l;
				/* OREG was built in clocal()
				 * for an auto or formal parameter
				 * now its address is being taken
				 * local code must unwind it
				 * back to PLUS/MINUS REG ICON
				 * according to local conventions
				 */
{
	cerror("address of OREG taken");
}

# ifndef ONEPASS
main( argc, argv ) char *argv[]; {
	return( mainp2( argc, argv ) );
	}
# endif

myreader(p) register NODE *p; {
	walkf( p, hardops );	/* convert ops to function calls */
	canon( p );		/* expands r-vals for fileds */
	walkf( p, optim2 );
	}

Copyright (c) 1985 Regents of the University of California.
All rights reserved.  The Berkeley software License Agreement
specifies the terms and conditions for redistribution.

	@(#)DEBUGS	5.1 (Berkeley) 01/08/86

WHAT THE DEBUG FLAGS MEAN:

Debug flags preceded with an X are first pass flags; the rest are
second pass flags.

-Xa:	Print the actions taken for each operator as parse trees are
	assembled, from buildtree().

-Xb:	Extra information from buildtree() on parse tree assembly.  May
	be used to increase the information from -Xa.

-Xd:	Print information about declarations, from many places in pftn.c.
	May be repeated to get still more information.

-Xi:	Information about initializations, from several places in pftn.c.

-a:	From rallo(), print the address of the tree being worked on for
	the purpose of allocating registers, and indicate what this
	tree's requirements have been determined to be.

-e:	Print the expression tree at useful places, e.g. when an
	expression appears in the intermediate code file as a
	statement, or just before store() is called in codgen().

-l:	Print line number and file name at the end of every statement.

-o:	Print the expression tree when order() is called, and whenever
	the loop in order() takes us to the top after a rewrite.  Also
	prints the tree with extra info when a rewrite is forced due
	lack of a matching template.

-r:	Identify the register being worked on and what's in it and
	sometimes why it's being worked on, from rfree(), rbusy() and
	reclaim().

-s:	From tshape(), print the address of the given node and the
	shape that it's being tested against.  The opcode for the node
	is also printed.

-t:	From ttype(), print the node type and the type template which
	the node is being tested against.

-u:	Previously used to debug the Sethi-Ullman algorithm, currently
	defunct.

-v:	Report on multi-level tree matching.  Very verbose.

-x:	Prints intermediate code instructions in mainp2(); also used to
	debug zzzcode(), the routine that does specialized template
	interpretation.

Copyright (c) 1985 Regents of the University of California.
All rights reserved.  The Berkeley software License Agreement
specifies the terms and conditions for redistribution.

	@(#)INFO	5.1 (Berkeley) 01/08/86

HOW TO INTERPRET TEMPLATES:

Goals (represented by 'visit' fields) indicate the shape of what is
produced by using a template:

	Goal		Form of result

	FOREFF		Can be used for just side effects.  Used for things
			like initializing data, or gotos.
	INAREG		Result can end up in a register.
	INTAREG		Result can end up in a scratch register.
	INBREG		Result can end up in an index, address or floating
			point register -- not used on the VAX.
	INTBREG		The same except for temporary index registers.
	FORCC		Condition codes are set.
	INTEMP		Computes into a temporary location.
	FORARG		Computes a function argument onto the stack.
	FORREW		Forces the code generator to rewrite the tree.

Shapes are restrictions on operands:

	Shape		Form of operand

	SANY		Anything.

	SAREG		A register.
	STAREG		A temporary register (one that can be stomped on).
	SBREG		A secondary register -- not used on the VAX.
	STBREG		Ditto except this a temporary register.

	SCON		An int (32-bit or smaller) constant.
	SCCON		A short (16-bit) constant.
	SSCON		A char (8-bit) constant.
	SZERO		The constant 0.
	SONE		The constant 1.
	SMONE		The constant -1.

	SCC		Condition codes.

	SNAME		A constant address; not on the stack or indirect
			through a pointer.

	SFLD		A bit field.

	SOREG		A value whose address is the sum of a register and an
			offset.  E.g. 8(ap).
	SSOREG		A 'simple' OREG: not a pointer (e.g. rules out *8(ap)).
	SWADD		A value with an offset that is larger than a byte.
	STARNM		A value whose address is at some known address.
			An indirect value.  E.g. *_a, *8(ap).
	STARREG		Indirect through a register with auto-increment or
			-decrement.

Types restrict the type of an operand.  There are two ways of
representing types in the compiler; one is a specific type that
indicates things like indirection, and the other is used as a template
for the first.  To see whether a type matches a template, you call
ttype().  The template variety is what you see in code templates, and
has its own typedef, TWORD.  Here are some things you can ask for in
the way of type templates:

	Name		What it buys you

	TANY		Matches anything 'within reason'.

	TCHAR		Chars.
	TUCHAR		Unsigned chars.
	TSHORT		Shorts.
	TUSHORT		Unsigned shorts.
	TINT		Ints.
	TLONG		Longs.  (VAX ints.)
	TULONG		Unsigned longs.
	TUNSIGNED	Any unsigned type.
	TWORD		An integral type the size of an int, or a pointer.

	TFLOAT		Floats.
	TDOUBLE		Doubles.

	TSTRUCT		Structures or unions.

	TPTRTO		A pointer.  This must be or'ed in with other types;
			e.g.  TPTRTO|TFLOAT|TDOUBLE matches pointers to floats
			or pointers to doubles.  Can be multiply indirect.
	TPOINT		Complex types -- things with stars or brackets or etc.

	WPTR		Pointer to anything except structures/unions.
	ANYSIGNED	Pointers or signed integral types.
	ANYUSIGNED	Any unsigned integral type.
	ANYFIXED	Any integral type (excludes floating point or structs).

The template may request special resources.  These are indicated by
things in the needs field of a template:

	Needs		Resource wanted

	NAREG		Needs a register.  Can be multiplied up to 4 times
			to get up to 4 registers.
	NBREG		Ditto for secondary registers (not used on the VAX).
	NASL		Can share a register with the left operand.
	NASR		Can share a register with the right operand.
	NTEMP		Needs stack space.  Can be multiplied up to 8 times.
	EITHER		Don't settle for some of A and some of B.

The template indicates where the results end up, too.  The symbols in the
rewrite field have the following meanings:

	Result		Where the result is

	RNULL		Don't care about the result -- clobber it.
	RLEFT		Register associated with the left operand.
	RRIGHT		Register associated with the right operand.
	RESC1		First register requested by 'needs'.
	RESC2		Second register requested by 'needs'.
	RESC3		Third register requested by 'needs'.
	RESCC		The condition codes.
	RNOP		Doesn't make anything -- e.g. initializations, gotos.

The assembly language templates contain capital letter abbreviations
which are expanded in context to whatever is useful.  These
abbreviations may be 1, 2 or 3 characters long; the first character
codes for the length and generally tells what to do.  A standard second
or third character often indicates the location of an object in the
following way:

	Modifier	Meaning

	L		Left operand.
	R		Right operand
	1, 2, 3		Nth requested register (from 'needs').

Below are the various abbreviations; 'n' is used to indicate one of the
standard modifiers:

	Abbreviation	Rewrites as

	An		Address of operand n -- the most common abbreviation.
			Produces register names, externals, almost everything.
	Bn		Byte offset in a word (? -- not used on VAX).
	Cn		Only constants may be written this way.
	F		The rest of the line is ignored if this value is
			only being computed for side effects.
	H		Field shift; used with masks and bit fields.
	In		Illegal -- not currently used.
	L		A label.
	M		Field mask.
	N		Field mask, complemented.
	O[BWLFD]	Opcode string; used to rewrite operands of templates
			with generic opcodes like add, sub, mul.  The modifier
			is changed to lower case and appended.  For example if
			the template is OPFLOAT, the abbreviation is 'OD2' and
			the current node's operand is OPMUL, you get 'muld2'.
	S		Field size.
	T		Rewriting of the register type is suppressed.  I'm not
			sure what's going on but here's the explanation:  'The C
			language requires intermediate results to change type.
			This is inefficient or impossible on some machines; the
			"T" command in match supresses this type changing.'
	Un		Illegal -- not currently used.
	Zx		Local abbreviations (zzzcode()).  The x's are spelled
			out below:
	ZA		Used for straightforward conversions and assignments.
			Clever perhaps to excess in its coding.
	ZB		Gets difficult shapes into register prior to a shift.
	ZC		Interpolates the argument count in a function call.
	ZD		Get the value of the operand, then increment or
			decrement the original, depending on the opcode.
	ZE		Increment or decrement the operand.
	ZF		Produces 'd', 'f' or 'l' depending on whether the
			right operand (the node itself, for unary operators)
			is double, float or long; used for moves into register.
	ZI		Produces the appropriate conditional branch.
	ZL		Opcode type [bwlfd] for the left operand.
	ZN		Produces a jump and a clear to get logical values
			converted into 0 or 1.
	ZP		Just like ZI.
	ZR		Opcode type [bwlfd] for the right operand.
	ZS		Generates a structure assignment.
	ZT		Rounds up structure lengths for struct arguments.
	ZU		Subtracts the value of the constant right operand from
			32 and uses that for unsigned right shift offsets.
	ZZ		Complements the value of the constant right operand of
			a bit instruction and produces it.

# ifndef lint
static char *sccsid ="@(#)local2.c	1.13 (Berkeley) 01/08/86";
# endif

# include "pass2.h"
# include "ctype.h"
# ifdef FORT
int ftlab1, ftlab2;
# endif

				adrput(x);
				putchar('\n');
				putchar('\t');
				r = x;
				}
			l->in.type = (ISUNSIGNED(l->in.type) ? UNSIGNED : INT);
			}

		if ((r->in.type == UNSIGNED || r->in.type == ULONG) &&
		    mixtypes(l, r)) {
			int label1, label2;

			label1 = getlab();
			label2 = getlab();

			putstr("movl\t");
			adrput(r);
			putchar(',');
			adrput(l);
			putstr("\n\tbbsc\t$31,");
			adrput(l);
			printf(",L%d\n\tcvtl", label1);
			prtype(l);
			putchar('\t');
			adrput(l);
			putchar(',');
			adrput(l);
			printf("\n\tjbr\tL%d\nL%d:\n\tcvtl", label2, label1);
			prtype(l);
			putchar('\t');
			adrput(l);
			putchar(',');
			adrput(l);
			putstr("\n\tadd");
			prtype(l);
			putstr("2\t$0");
			prtype(l);
			putstr("2.147483648e9,");
			adrput(l);
			printf("\nL%d:", label2);

			return;
			}

		if (!mixtypes(l,r)) {
			if (tlen(l) == tlen(r)) {
				putstr("mov");
#ifdef FORT
				if (Oflag)
					prtype(l);

	ops:
		putchar('\t');
		adrput(r);
		putchar(',');
		adrput(l);
		return;
		}

	case 'G':	/* i *= f; asgops with int lhs and float rhs */
		{
		register NODE *l, *r, *s;
		int rt;

		l = p->in.left;
		r = p->in.right;
		s = talloc();
		rt = r->in.type;

		s->in.op = SCONV;
		s->in.left = l;
		s->in.type = rt;
		zzzcode(s, 'A');
		putstr("\n\t");

		hopcode(rt == FLOAT ? 'F' : 'D', p->in.op);
		putstr("2\t");
		adrput(r);
		putchar(',');
		adrput(resc);
		putstr("\n\t");

		s->in.op = ASSIGN;
		s->in.left = l;
		s->in.right = resc;
		s->in.type = l->in.type;
		zzzcode(s, 'A');

		s->in.op = FREE;
		return;
		}

	case 'B':	/* get oreg value in temp register for left shift */
		{
		register NODE *r;
		if (xdebug) eprint(p, 0, &val, &val);
		r = p->in.right;
		if( tlen(r) == sizeof(int) && r->in.type != FLOAT )

#if defined(FORT) || defined(SPRECC)
		if( p->in.type == FLOAT || p->in.type == DOUBLE ||
		    l->in.type == FLOAT || l->in.type == DOUBLE )
			return;
#else
		if( mixtypes(p, l) ) return;
#endif
		if( l->in.op == PCONV )
			return;

		/* Only trust it to get it right if the size is the same */
		if( tlen(p) != tlen(l) )
			return;

		/* clobber conversion */
		if( l->in.op != FLD )
			l->in.type = p->in.type;

#ifndef lint
static char *sccsid ="@(#)order.c	1.7 (Berkeley) 01/08/86";
#endif lint

# include "pass2.h"

int maxargs = { -1 };

stoasg( p, o ) register NODE *p; {

	printf( "L%d:\n", l );
	}

genargs( p ) register NODE *p; {
	register NODE *pasg;
	register align;
	register size;
	int count;

	/* generate code for the arguments */

	/*  first, do the arguments on the right */
	while( p->in.op == CM ){
		genargs( p->in.right );
		p->in.op = FREE;

			p->in.op = FREE;
			p = p->in.left;
			}
		else {
			/* make it look beautiful... */
			p->in.op = UNARY MUL;
			canon( p );  /* turn it into an oreg */
			for( count = 0; p->in.op != OREG && count < 10; ++count ){
				offstar( p->in.left );
				canon( p );




				}

			if( p->in.op != OREG ) cerror( "stuck starg" );
			}

		pasg = talloc();
		pasg->in.op = STARG;
		pasg->in.rall = NOPREF;
		pasg->stn.stsize = size;
		pasg->stn.stalign = align;

#ifndef lint
static char *sccsid ="@(#)table.c	1.13 (Berkeley) 01/08/86";
#endif lint

# include "pass2.h"

# define WPTR TPTRTO|TINT|TLONG|TFLOAT|TDOUBLE|TPOINT|TUNSIGNED|TULONG
# define AWD SNAME|SOREG|SCON|STARNM|STARREG
/* tbl */

SCONV,	INTAREG|FORCC,
	SAREG|AWD,	TDOUBLE,
	SANY,	TFLOAT,
		NAREG|NASL,	RESC1|RESCC,
		"	cvtdf	AL,A1\n",

SCONV,	INTAREG|FORCC,
	SAREG|AWD,	ANYSIGNED,
	SANY,	TFLOAT,
		NAREG|NASL,	RESC1|RESCC,
		"	cvtZLf	AL,TA1\n",

SCONV,	INTAREG|FORCC,
	SAREG|AWD,	TUCHAR|TUSHORT,
	SANY,	TFLOAT,

		"	cvtfd	AR,A1\n	OD2	A1,AL\n",

ASG OPFLOAT,	INAREG|INTAREG|FOREFF|FORCC,
	SAREG|AWD,	TFLOAT,
	SAREG|AWD,	TDOUBLE,
		NAREG,	RLEFT|RESC1|RESCC,
		"	cvtfd	AL,A1\n	OD2	AR,A1\n	cvtdf	A1,AL\n",

ASG OPFLOAT,	INAREG|FOREFF|FORCC,
	SAREG|AWD,	ANYFIXED,
#ifndef SPRECC
	SAREG|AWD,	TDOUBLE,		/* force FLOAT to register */
#else
	SAREG|AWD,	TFLOAT|TDOUBLE,
#endif
		NAREG,	RLEFT|RESCC,	/* usable() knows we need a reg pair */
		"	ZG\n",

OPFLOAT,	INAREG|INTAREG|FORCC,
	STAREG,	TDOUBLE,
	SAREG|AWD,	TDOUBLE,
		0,	RLEFT|RESCC,
		"	OD2	AR,AL\n",

/*	llib-lc	1.29	86/01/07	*/
/* LINTLIBRARY */
#include <sys/types.h>
#include <fstab.h>
#include <grp.h>
#include <sys/dir.h>
#include <nlist.h>
#include <pwd.h>

int	fcntl(f, c, a) { return (0); }
int	flock( f, o ) { return 0; }
int	fork() { return(0); }
int	fsync( f ) { return 0; }
int	fstat(f, b) struct stat *b; { return(0); }
int	ftruncate( d, l) off_t l; { return 0;}
int	getdtablesize() { return 20 ; }
gid_t	getegid() { return((gid_t)1); }
uid_t	geteuid() { return((uid_t)1); }
gid_t	getgid() { return((gid_t)1); }
int	getgroups( n, g ) int *n, *g; { return 0; }
long	gethostid() { return 1L; }
int	gethostname( n, l ) char *n; int l; { return 0 ;}
int	getitimer( w, v ) struct itimerval *v; { return 0; }
int	getpagesize() { return 1; }
int	getpgrp(p) { return 1; }
int	getpid() { return(1); }
int	getppid() { return(1); }
int	getpriority( w, who) { return 1;}
int	getrlimit( res, rip) struct rlimit *rip; { return 0;}
int	getrusage( res, rip) struct rusage *rip; { return 0;}
int	getsockname(s, name, namelen) char *name; int *namelen; { return(0); }
int	getsockopt( s, level, opt, buf, len ) { return 0;}
int	gettimeofday( t, z ) struct timeval *t; struct timezone *z; { return 0;}
uid_t	getuid() { return((uid_t)1); }
int	ioctl( d, r, p) char *p; { return 0;}
int	kill(p, s) { return(0); }
int	killpg( pg, s) { return 0;}
int	link(a, b) char *a, *b; { return(0); }
int	listen( s, b ){ return 0; }
off_t	lseek(f, o, d) off_t o; { return(o); }
int	lstat(s, b) char *s; struct stat *b; { return(0); }

int	sendmsg( s, m, l) struct msghdr m[]; { return l; }
int	setgroups( n, g) int *g; { return 0; }
int	sethostid( h ) long h; { return 0;}
int	sethostname( n, l ) char *n; int l; { return 0 ;}
int	setitimer( w, v, ov ) struct itimerval *v, *ov; { return 0; }
int	setpgrp( g, pg) { return 0; }
int	setpriority( w, who, pri ) { return 1;}
int	setregid( r, e) gid_t r, e; { return 0; }
int	setreuid( r, e) uid_t r, e; { return 0; }
int	setrlimit( res, rip) struct rlimit *rip; { return 0;}
	/* VARARGS */
int	setsockopt( s, level, opt, buf, len ) char *buf; { return 0;}
int	settimeofday( t, z ) struct timeval *t; struct timezone *z; { return 0;}
int	shutdown( s, h ){ return 0;}
int	(*signal(c, f))() int (*f)(); { return(f); }
int	sigvec(c, f, m) struct sigvec *f, *m; { return 0; }

char *	realloc(p, n) char *p; unsigned n; { static char c[1]; return(c);}
char *	rindex(s, c) char *s, c; { return s; }
int	scandir(d, n, s, c) char *d; struct direct *(*n[]); int (*s)(),(*c)();
		{ return 1; }
void	seekdir( p, l) DIR *p; long l; {}
int	setfsent() { return 0; }
int	setgrent() { return 0; }
int	setgid(g) gid_t g; { return(0); }
int	setjmp(e) jmp_buf e; { return(0); }
	setkey(k) char *k; {}
int	setlogmask(m) { return(0); }
	setpwent() {}
long *	setstate( st ) long *st; { return st; }
int	setuid(u) uid_t u; { return(0); }
	sleep(i) unsigned i; {}
int	srand(s){ return s; }
char *	strcat(a, b) char *a, *b; { return a; }
int	strcmp(a, b) char *a, *b; { return(1); }
char *	strcpy(a, b) char *a, *b; { return a; }
int	strlen(s) char *s; { return(1); }
char *	strncat(a, b, n) char *a, *b; { return a;}

#ifndef lint
static char sccsid[] = "@(#)lint.c	1.8	(Berkeley)	01/08/86";
#endif lint

# include "pass1.h"

# include "lmanifest.h"

# include <ctype.h>

	   REG and OREG nodes */
	/* conversion ops which are not necessary are also clobbered here */
	/* in addition, any special features (such as rewriting
	   exclusive or) are easily handled here as well */

	register o;
	register unsigned t, tl;
	int s;

	switch( o = p->in.op ){

	case SCONV:
	case PCONV:
		if( p->in.left->in.type==ENUMTY ){
			p->in.left = pconvert( p->in.left );

		return( p->in.left );

	case PVCONV:
	case PMCONV:
		if( p->in.right->in.op != ICON ) cerror( "bad conversion");
		p->in.op = FREE;
		return( buildtree( o==PMCONV?MUL:DIV, p->in.left, p->in.right ) );

	case RS:
	case LS:
	case ASG RS:
	case ASG LS:
		if( p->in.right->in.op != ICON )
			break;
		s = p->in.right->tn.lval;
		if( s < 0 )
			werror( "negative shift" );
		else
		if( s >= dimtab[ p->fn.csiz ] )
			werror( "shift greater than size of object" );
		break;

		}

	return(p);
	}

NODE *

/*	@(#)macdefs.h	1.5	(Berkeley)	01/08/86	*/

#if defined(pdp11) || defined(vax)
#define makecc(val,i)  lastcon |= val<<(8*i);  /* pdp-11 womp next char  */
#else
#define makecc(val,i)	lastcon = i ? (val<<8)|lastcon : val
#endif

# define bccode()
# define cendarg()
# define incode(a,s) (inoff += (s))
# define fincode(a,s) (inoff += (s) )
# define vfdzero(n) (inoff += (n))
# define aobeg()
# define aoend()
# define econvert(p)

# ifndef unix
# define NOFORTRAN  {extern int pflag; if(pflag) werror( "fortran keyword nonportable" );}
# else
# define NOFORTRAN { werror( "fortran keyword nonportable" ); }
# endif

# define LINT

#ifndef lint
static char *sccsid ="@(#)allo.c	4.8 (Berkeley) 01/08/86";
#endif lint

# include "pass2.h"

NODE resc[3];

int busy[REGSZ];

	if( isbreg(r) ){
		if( n&NAMASK ) return(0);
		}
	else {
		if( n & NBMASK ) return(0);
		}
	/*
	 * Some special cases that require register pairs...
	 * Have to check for ==, <=, etc. because the result is type int
	 * but need a register pair temp if either side is wide.
	 * For +=, *= etc. where lhs is narrow and rhs is wide, the temp
	 * register must be wide.
	 */
	if( (n&NAMASK) &&
	    (szty(p->in.type) == 2 ||
	     (logop(p->in.op) && (szty(p->in.left->in.type) == 2 ||
	      szty(p->in.right->in.type) == 2)) ||
	     (asgop(p->in.op) && szty(p->in.right->in.type) == 2 &&
	      szty(p->in.left->in.type) == 1))
	){
#ifndef NOEVENODD
		if( r&01 ) return(0);
#endif
		if( !istreg(r+1) ) return( 0 );
		if( busy[r+1] > 1 ) return( 0 );
		if( busy[r] == 0 && busy[r+1] == 0  ||
		    busy[r+1] == 0 && shareit( p, r, n ) ||

#ifndef lint
static char *sccsid ="@(#)optim.c	4.7 (Berkeley) 01/08/86";
#endif lint

# include "pass1.h"

# define SWAP(p,q) {sp=p; p=q; q=sp;}
# define RCON(p) (p->in.right->in.op==ICON)
# define RO(p) p->in.right->in.op

	case ASG MUL:
		/* change muls to adds or shifts */

		if( (o == MUL || o == ASG MUL) &&
		    nncon(p->in.right) && (i=ispow2(RV(p)))>=0){
			if( i == 0 ) /* multiplication by 1 */
				goto zapright;
			/* c2 will turn 'i << 1' into 'i + i' for us */





			else {
				p->in.op = (asgop(o) ? ASG LS : LS);
				o = p->in.op;
				p->in.right->in.type = p->in.right->fn.csiz = INT;
				RV(p) = i;
				}
			}

					p->in.op = COMOP; /* side effects */
				}
			else if( o == PLUS || o == MINUS ||
				 o == ASG PLUS || o == ASG MINUS ||
				 o == OR || o == ER ||
				 o == LS || o == RS )
				goto zapright;
			}
		if( o != LS && o != RS )
			break;
		/* FALL THROUGH */

	case ASG RS:
	case ASG LS:
		if( !ISUNSIGNED(p->in.left->in.type) )
			break;
		if( p->in.right->in.op == ICON &&
		    p->in.right->tn.lval < 0 ) {
			/*
			 * Technically negative shifts are illegal
			 * but we can support them, at least with
			 * constants; you take potluck with variables.
			 */
			p->in.right->tn.lval = -p->in.right->tn.lval;
			switch( o ){
			case LS:	p->in.op = RS; break;
			case ASG LS:	p->in.op = ASG RS; break;
			case RS:	p->in.op = LS; break;
			case ASG RS:	p->in.op = ASG LS; break;
				}
			}
		break;

	case ASG DIV:
	case DIV:
		if( nncon( p->in.right ) ){
			if( RV(p) == 0 ) uerror("division by zero");

#ifndef lint
static char *sccsid ="@(#)pftn.c	1.10 (Berkeley) 01/08/86";
#endif lint

# include "pass1.h"

unsigned int offsz;

struct symtab *schain[MAXSCOPES];	/* sym chains for clearst */

		case 0:
			break;

			}
		}

	if( dimtab[s]==0 ) {
		if( ty == STRTY )
			uerror( "undefined structure" );
		else
			uerror( "unknown size");
		return( SZINT );
		}
	return( (unsigned int) dimtab[ s ] * mult );
	}

inforce( n ) OFFSZ n; {  /* force inoff to have the value n */
	/* inoff is updated to have the value n */

		if( ISARY(t) ){
			t = DECREF(t);
			++d;
			continue;
			}
		else if( t == STRTY ){
			if( dimtab[pstk->in_s] == 0 ){
				uerror( "can't initialize undefined structure" );
				iclass = -1;
				return;
				}
			id = dimtab[pstk->in_x];
			p = &stab[id];
			if( p->sclass != MOS && !(p->sclass&FIELD) ) cerror( "insane structure member list" );
			t = p->stype;
			d = p->dimoff;
			s = p->sizoff;
			off += p->offset;

# endif

	switch( iclass ){

	case EXTERN:
	case AUTO:
	case REGISTER:
	case -1:
		return;
		}

	pstk = instack;

	t = pstk->in_t;
	d = pstk->in_d;

#ifndef lint
static char *sccsid ="@(#)trees.c	4.10 (Berkeley) 01/08/86";
#endif

# include "pass1.h"

# include <setjmp.h>

int bdebug = 0;

		p->in.left = r;
	else
		p->in.right = r;
	return(p);

	}

#ifndef econvert
econvert( p ) register NODE *p; {

	/* change enums to ints, or appropriate types */

	register TWORD ty;

	if( (ty=BTYPE(p->in.type)) == ENUMTY || ty == MOETY ) {
		if( dimtab[ p->fn.csiz ] == SZCHAR ) ty = CHAR;
		else if( dimtab[ p->fn.csiz ] == SZINT ) ty = INT;
		else if( dimtab[ p->fn.csiz ] == SZSHORT ) ty = SHORT;
		else ty = LONG;
		ty = ctype( ty );
		p->fn.csiz = ty;
		MODTYPE(p->in.type,ty);
		if( p->in.op == ICON && ty != LONG ) p->in.type = p->fn.csiz = INT;
		}
	}
#endif

NODE *
pconvert( p ) register NODE *p; {

	/* if p should be changed into a pointer, do so */

	if( ISARY( p->in.type) ){

NODE *
tymatch(p)  register NODE *p; {

	/* satisfy the types of various arithmetic binary ops */

	/* rules are:
		if assignment, type of LHS
		if any float or doubles, make double
		if any longs, make long
		otherwise, make int
		if either operand is unsigned, the result is...
	*/

	register TWORD t1, t2, t, tu;

#else
	if (t1 == DOUBLE || t1 == FLOAT || t2 == DOUBLE || t2 == FLOAT)
		t = DOUBLE;
#endif
	else if( t1==LONG || t2==LONG ) t = LONG;
	else t = INT;

	if( o == ASSIGN || o == CAST || o == RETURN ){
		tu = p->in.left->in.type;
		t = t1;
		}
	else {
		tu = (u && UNSIGNABLE(t))?ENUNSIGN(t):t;
		}

	/* because expressions have values that are at least as wide
	   as INT or UNSIGNED, the only conversions needed
	   are those involving FLOAT/DOUBLE, and those
	   from LONG to INT and ULONG to UNSIGNED */

	if( t != t1 && ! asgop(o) )
		p->in.left = makety( p->in.left, tu, 0, (int)tu );

	if( t != t2 || o==CAST )
		p->in.right = makety( p->in.right, tu, 0, (int)tu );

	if( asgop(o) ){
		p->in.type = p->in.left->in.type;
		p->fn.cdim = p->in.left->fn.cdim;
		p->fn.csiz = p->in.left->fn.csiz;
		}
	else if( !logop(o) ){

/*
 * Copyright (c) 1980 Regents of the University of California.
 * All rights reserved.  The Berkeley software License Agreement
 * specifies the terms and conditions for redistribution.
 */

#ifndef lint
char copyright[] =
"@(#) Copyright (c) 1980 Regents of the University of California.\n\
 All rights reserved.\n";
#endif not lint

#ifndef lint
static char sccsid[] = "@(#)machdep.c	5.2 (Berkeley) 01/09/86";
#endif not lint

/*
 * Various installation dependent routines
 *
 * $Revision: 1.7 $, $Date: 85/04/05 11:33:30 $
 */

 *			for high load average.
 *	WARNTIME	How much time between warnings when load gets
 *			too high (if not defined, it is the same as
 *			CHECKTIME).
 */

# include	<curses.h>
# include	"machdep.h"
# include	<signal.h>
# include	<sys/types.h>
# include	<sys/stat.h>
# include	<sys/file.h>

# ifdef	SCOREFILE


static char	*Lockfile = "/tmp/.fredlock";


# ifndef	NUMSCORES
# 	define	NUMSCORES	10
# 	define	NUMNAME		"Ten"
# endif		NUMSCORES

unsigned int	Numscores = NUMSCORES;

 */
getltchars()
{
# ifdef TIOCGLTC
	ioctl(1, TIOCGLTC, &Ltc);
	Got_ltc = TRUE;
	Orig_dsusp = Ltc.t_dsuspc;
	if (Orig_dsusp == CTRL(Y)) {
		Ltc.t_dsuspc = Ltc.t_suspc;
		ioctl(1, TIOCSLTC, &Ltc);
	}
# endif	TIOCGLTC
}

/*
 * start_score:
 *	Start the scoring sequence
 */

/*
 * Copyright (c) 1980 Regents of the University of California.
 * All rights reserved.  The Berkeley software License Agreement
 * specifies the terms and conditions for redistribution.
 */

#ifndef lint
char copyright[] =
"@(#) Copyright (c) 1980 Regents of the University of California.\n\
 All rights reserved.\n";
#endif not lint

#ifndef lint
static char sccsid[] = "@(#)sysline.c	5.6 (Berkeley) 01/09/86";
#endif not lint

/*
 * sysline - system status display on 25th line of terminal
 * j.k.foderaro
 *
 * Prints a variety of information on the special status line of terminals

		fflush(stdout);
	}

	/* the "-1" below is to avoid cursor wraparound problems */
	columns = tgetnum("co") - 1;
	if (window) {
		strcpy(to_status_line, "\r");

		cp = dis_status_line;	/* use the clear line sequence */
		*cp++ = '\r';
		tgetstr("ce", &cp);
		if (leftline)
			strcpy(from_status_line, dis_status_line + 1);
		else
			strcpy(from_status_line, "");
	} else {
		cp = to_status_line;
		tgetstr("ts", &cp);
		cp = from_status_line;
		tgetstr("fs", &cp);
		cp = dis_status_line;
		tgetstr("ds", &cp);

.\"	@(#)tar.1	6.3 (Berkeley) 01/07/86
.\"
.TH TAR 1 ""
.AT 3
.SH NAME
tar \- tape archiver
.SH SYNOPSIS
.B tar

.TP 10
.B B
Forces input and output blocking to 20 blocks per record.  This option
was added so that 
.I tar
can work across a communications channel where the blocking may not
be maintained.
.TP 10
.B C
If a file name is preceded by 
.BR \-C ,
then 
.I tar
will perform a
.IR chdir (2)
to that file name.  This allows multiple directories not

/*
 * Copyright (c) 1980 Regents of the University of California.
 * All rights reserved.  The Berkeley software License Agreement
 * specifies the terms and conditions for redistribution.
 */

#ifndef lint
static char sccsid[] = "@(#)main.c	5.2 (Berkeley) 01/09/86";
#endif not lint

#include "dump.h"

int	notify = 0;	/* notify operator flag */
int	blockswritten = 0;	/* number of blocks written on current tape */
int	tapeno = 0;	/* current tape number */
int	density = 0;	/* density in bytes/0.1" */
int	ntrec = NTREC;	/* # tape blocks in each tape record */
int	cartridge = 0;	/* Assume non-cartridge tape */
#ifdef RDUMP
char	*host;
#endif
int	anydskipped;	/* set true in mark() if any directories are skipped */
			/* this lets us avoid map pass 2 in some cases */

main(argc, argv)
	int	argc;
	char	*argv[];
{
	char		*arg;
	int		bflag = 0, i;

	}
	msiz = roundup(howmany(sblock->fs_ipg * sblock->fs_ncg, NBBY),
		TP_BSIZE);
	clrmap = (char *)calloc(msiz, sizeof(char));
	dirmap = (char *)calloc(msiz, sizeof(char));
	nodmap = (char *)calloc(msiz, sizeof(char));

	anydskipped = 0;
	msg("mapping (Pass I) [regular files]\n");
	pass(mark, (char *)NULL);		/* mark updates esize */

	if (anydskipped) {
		do {
			msg("mapping (Pass II) [directories]\n");
			nadded = 0;
			pass(add, dirmap);
		} while(nadded);
	} else				/* keep the operators happy */
		msg("mapping (Pass II) [directories]\n");

	bmapest(clrmap);
	bmapest(nodmap);

	if (cartridge) {
		/* Estimate number of tapes, assuming streaming stops at
		   the end of each block written, and not in mid-block.

/*
 * Copyright (c) 1980 Regents of the University of California.
 * All rights reserved.  The Berkeley software License Agreement
 * specifies the terms and conditions for redistribution.
 */

#ifndef lint
static char sccsid[] = "@(#)traverse.c	5.3 (Berkeley) 01/09/86";
#endif not lint

#include "dump.h"

pass(fn, map)
	register int (*fn)();
	register char *map;
{

	register int bits;
	ino_t maxino;

	maxino = sblock->fs_ipg * sblock->fs_ncg - 1;
	for (ino = 0; ino < maxino; ) {
		if ((ino % NBBY) == 0) {
			bits = ~0;
			if (map != NULL)
				bits = *map++;
		}
		ino++;
		if (bits & 1)

			(*fn)(getino(ino));

		bits >>= 1;
	}
}

mark(ip)
	struct dinode *ip;
{
	register int f;
	extern int anydskipped;

	f = ip->di_mode & IFMT;
	if (f == 0)
		return;
	BIS(ino, clrmap);
	if (f == IFDIR)
		BIS(ino, dirmap);
	if ((ip->di_mtime >= spcl.c_ddate || ip->di_ctime >= spcl.c_ddate) &&
	    !BIT(ino, nodmap)) {
		BIS(ino, nodmap);
		if (f != IFREG && f != IFDIR && f != IFLNK) {
			esize += 1;
			return;
		}
		est(ip);
	} else if (f == IFDIR)
		anydskipped = 1;
}

add(ip)
	register struct	dinode	*ip;
{
	register int i;
	long filesize;

/*
 * Copyright (c) 1980 Regents of the University of California.
 * All rights reserved.  The Berkeley software License Agreement
 * specifies the terms and conditions for redistribution.
 */

#ifndef lint
char copyright[] =
"@(#) Copyright (c) 1980 Regents of the University of California.\n\
 All rights reserved.\n";
#endif not lint

#ifndef lint
static char sccsid[] = "@(#)ncheck.c	5.4 (Berkeley) 01/09/86";
#endif not lint

/*
 * ncheck -- obtain file names from reading filesystem
 */

#define	NB		500

{
	register struct direct *dp;
	daddr_t lbn, d;

	for(;;) {
		if (dirp->loc >= dirp->ip->di_size)
			return NULL;
		if (blkoff(&sblock, dirp->loc) == 0) {
			lbn = lblkno(&sblock, dirp->loc);
			d = bmap(lbn);
			if(d == 0)
				return NULL;
			bread(fsbtodb(&sblock, d), dirp->dbuf,
			    dblksize(&sblock, dirp->ip, lbn));
		}
		dp = (struct direct *)

/*
 * Copyright (c) 1983 Regents of the University of California.
 * All rights reserved.  The Berkeley software License Agreement
 * specifies the terms and conditions for redistribution.
 */

#ifndef lint
char copyright[] =
"@(#) Copyright (c) 1983 Regents of the University of California.\n\
 All rights reserved.\n";
#endif not lint

#ifndef lint
static char sccsid[] = "@(#)main.c	5.5 (Berkeley) 01/06/86";
#endif not lint

/*
 * Routing Table Management Daemon
 */
#include "defs.h"
#include <sys/ioctl.h>

getsocket(domain, type, sin)
	int domain, type;
	struct sockaddr_in *sin;
{
	int s, on = 1;

	if ((s = socket(domain, type, 0)) < 0) {
		perror("socket");
		syslog(LOG_ERR, "socket: %m");
		return (-1);
	}
	if (setsockopt(s, SOL_SOCKET, SO_BROADCAST, &on, sizeof (on)) < 0) {
		syslog(LOG_ERR, "setsockopt SO_BROADCAST: %m");
		close(s);

/*
 * Copyright (c) 1980 Regents of the University of California.
 * All rights reserved.  The Berkeley software License Agreement
 * specifies the terms and conditions for redistribution.
 */

#ifndef lint
char copyright[] =
"@(#) Copyright (c) 1980 Regents of the University of California.\n\
 All rights reserved.\n";
#endif not lint

#ifndef lint
static char sccsid[] = "@(#)savecore.c	5.3 (Berkeley) 01/09/86";
#endif not lint

/*
 * savecore
 */

#include <stdio.h>

		exit(1);
	}
	ddev = find_dev(dsb.st_dev, S_IFBLK);
	dfd = Open(ddev, 0);
	Lseek(dfd, (long)(SBLOCK * DEV_BSIZE), 0);
	Read(dfd, (char *)&fs, sizeof fs);
	close(dfd);
	spacefree = freespace(&fs, fs.fs_minfree) * fs.fs_fsize / 1024;
	if (spacefree < read_number("minfree")) {
		fprintf(stderr,
		   "savecore: Dump omitted, not enough space on device\n");
		return (0);
	}

	if (freespace(&fs, fs.fs_minfree) < 0)
		fprintf(stderr,
			"Dump performed, but free space threshold crossed\n");
	return (1);
}

read_number(fn)
	char *fn;

a
AAA
AAAS
Aarhus
Aaron
ABA
Ababa
aback
abacus
abalone
abandon
abase
abash
abate
abbas
abbe

abridgment
abroad
abrogate
abrupt
abscess
abscissa
abscissae

absent
absentee
absenteeism
absentia
absentminded
absinthe
absolute

accessory
accident
accidental
accipiter
acclaim
acclamation
acclimate

accolade
accommodate
accompaniment
accompanist
accompany
accomplice
accomplish

accrue
acculturate
accumulate
accuracy
accurate
accusation
accusative
accusatory
accuse
accustom
ace
acerbic
acerbity
acetate
acetic
acetone
acetylene
ache
achieve
Achilles

Actaeon
actinic
actinide
actinium
actinolite
actinometer
activate


Acton
actor
actress

actual
actuarial
actuate
acuity
acumen
acute
acyclic
ad
Ada
adage
adagio
Adair
Adam
adamant

Adamson
adapt
adaptation
adaptive
add

addend
addenda
addendum
addict
Addis
Addison
addition

additive
addle
address
addressee
Addressograph
adduce
Adelaide
Adele
Adelia
Aden
adenine
adenoma
adenosine
adept
adequacy
adequate
adhere
adherent
adhesion
adhesive

Adolphus
Adonis
adopt
adoption
adoptive
adore
adorn
adposition
adrenal
adrenaline
Adrian
Adriatic
Adrienne
adrift
adroit
adsorb
adsorbate
adsorption
adsorptive
adulate
adult
adulterate
adulterous
adultery

advance
advantage
advantageous
advent
adventitious
adventure
adventurous

affectate
affectionate
afferent
affiance
affidavit
affiliate
affine

affirm
affirmation
affirmative
affix
afflict

affluent
afford
afforest
afforestation
affricate
affront
Afghan
Afghanistan
aficionado
afield
afire
aflame

afterglow
afterimage
afterlife
aftermath
afternoon
afterthought
afterward
afterword
again
against
Agamemnon
agate
Agatha
agave
age

ago
agone
agony
agouti
agrarian
agree
agreeable

agreeing
Agricola
agricultural
agriculture
agrimony
ague
Agway
ah
ahead
ahem
Ahmedabad
ahoy
aid
Aida
aide
Aides
Aiken
ail

airtight
airway
airy
aisle
Aitken
ajar
Ajax
AK
Akers
akin
Akron
AL
ala
Alabama
Alabamian
alabaster
alacrity
alai
Alameda

Albuquerque
Alcestis
alchemy
Alcmena
Alcoa
alcohol
alcoholic

Alcott
alcove
Aldebaran
aldehyde
Alden
alder
alderman

algaecide
algal
algebra
algebraic
Algenib
Alger
Algeria

Algiers
alginate
Algol
Algonquin
algorithm
algorithmic
Alhambra
Ali
alia
alias
alibi
Alice
Alicia
alien
alienate

alive
alizarin
alkali
alkaline
alkaloid
all
Allah
Allan
allay
allegate
allege
Allegheny
allegiant
allegoric
allegory
Allegra
allegro
allele
allemand
Allen
Allentown
allergic
allergy
alleviate
alley
alleyway
alliance

alligator
Allis
Allison
alliterate
allocable
allocate
allot

alpha
alphabet
alphabetic
alphanumeric
Alpheratz
Alphonse
alpine

already
Alsatian
also
Alsop
Altair
altar
alter

alveolar
alveoli
alveolus
Alvin
alway
alyssum
am
A&M
AMA
Amadeus
amalgam
amalgamate
amanita
amanuensis
amaranth

Amelia
ameliorate
amen
amend
amende
Amerada
America

Americana

americium
Ames
amethyst
amethystine
Amherst
ami
amicable

among
amongst
amoral
amorphous
amort
Amos
amount
amp
amperage
ampere
ampersand
Ampex
amphetamine
amphibian
amphibious
amphibole
amphibology
amphioxis
ample

amplify
amplitude
amply
amputate
amra
Amsterdam
Amtrak

analyst
analytic
anamorphic
anaplasmosis
anarch
anarchic
anarchy
Anastasia
anastigmat
anastigmatic
anastomosis
anastomotic
anathema
Anatole
anatomic
anatomy
ancestor
ancestral
ancestry
anchor
anchorage
anchorite

anchovy
ancient
ancillary
and
Andean
Andersen
Anderson
Andes
andesine
andesite
Andorra
Andover
Andre
Andrea
Andrei
Andrew

Andromache
Andromeda
Andy
anecdotal
anecdote
anemone
anent

Angelo
anger
Angie
angiosperm
angle
Angles
Anglican

angling
Anglo
Anglophobia
Angola
Angora
angry
angst

Anna
annal
Annale
Annalen
Annapolis
Anne
anneal
Annette
annex
Annie
annihilate
anniversary
annotate
announce
annoy

ANSI
answer
ant
antacid
Antaeus
antagonism
antagonist
antarctic
Antarctica
Antares
ante
anteater
antebellum
antecedent
antedate

antigorite
antimony
Antioch
antipasto
antipathy
antiperspirant
antiphonal
antipode
antiquarian
antiquary
antiquated
antique
antiquity
antisemite
antisemitic
antithetic
antler
Antoine
Antoinette
Anton
Antonio
Antony
antonym
Antwerp
anus
anvil
anxiety
anxious
any
anybody
anybody'd

Appleby
applejack
Appleton
appliance
applicable
applicant
applicate

applique
apply
appoint
appointe
appointee
apport
apposite

aquarium
Aquarius
aquatic
aqueduct
aqueous
Aquila
Aquinas
AR
Arab
arabesque
Arabia
Arabic
Araby
Arachne
arachnid

archae
archaic
archaism
archangel
archbishop
archdiocese
archenemy

archery
archetype
archetypical
archfool
Archibald
Archimedes

archipelago
architect
architectonic
architectural
architecture
archival
archive
arcing
arclength
arcsin
arcsine
arctan
arctangent
arctic
Arcturus
Arden

ardent
arduous
are
area
areaway
areawide
arena
arenaceous
aren't
Arequipa
Ares
Argentina
argillaceous
arginine
Argive
argo
argon
Argonaut
Argonne
argot
argue

armadillo
Armageddon
armament
Armata
armature
armchair
Armco
Armenia
armful
armhole
armillaria
armistice
armload
armoire
Armonk

asbestos
ascend
ascendant
ascension
ascent
ascertain
ascetic

ascomycetes
ascribe
ascription
aseptic
ash
ashame
ashen

Asilomar
asinine
ask
askance
askew
asleep
asocial
asparagine
asparagus
aspartic
aspect
aspen
asperity
aspersion
asphalt
aspheric
asphyxiate

assignee
assimilable
assimilate
assist
assistant
associable
associate

assonant
assort
assuage
assume
assumption
assurance
assure
Assyria
Assyriology
Astarte
astatine
aster
asteria
asterisk
asteroid
asteroidal
asthma
astigmat
astigmatic

ASTM
astonish
Astor
Astoria
astound
astraddle
astral

astronomy
astrophysical
astrophysics
astute
Asuncion
asunder
asylum

asymmetry
asymptote
asymptotic
asynchronous
asynchrony
at
Atalanta
atavism
atavistic
Atchison
ate
Athabascan
atheism
atheist
Athena
Athenian
Athens
athlete
athletic
athwart

attune
Atwater
Atwood
atypic
Auberge
Aubrey
auburn
Auckland
auction
auctioneer
audacious
audacity
audible
audience
audio

auger
augite
augment
augmentation
augur
august
Augusta

Augustine
Augustus
auk
aunt
auntie
aura
aural
Aurelius
aureomycin
auric
Auriga
aurochs
aurora
Auschwitz
auspices
auspicious
austenite
austere
Austin
Australia
Australis
australite
Austria
authentic

autograph
automat
automata
automate
automatic
automaton
automobile
automorphism
automotive
autonomic
autonomous
autonomy
autopsy
autosuggestible
autotransformer

aver
average
averred
averring
averse
aversion
avert

Avery
Avesta
aviary
aviate
aviatrix
avid
avionic

awkward
awl
awn
awoke
awry
ax
axe

axial
axiology
axiom
axiomatic
axis
axisymmetric
axle
axolotl
axon
aye
Ayers
Aylesbury
azalea
Azerbaijan
azimuth
azimuthal
Aztec
Aztecan
azure
AZ
b
babbitt
babble
Babcock
babe
Babel
baboon
baby

Babylon

babysat
babysit
babysitting
baccalaureate
baccarat
Bacchus
Bach
bachelor
bacilli
bacillus
back

bagpipe
bah
Bahama
Bahrein
bail
Bailey
bailiff
bainite
Baird
bait
bake
Bakelite
Bakersfield
bakery
Bakhtiari

balk
Balkan
balky
ball
ballad
Ballard
ballast

ballerina
ballet
balletomane
ballfield
balloon
ballot
ballroom

Balzac
bam
Bamako
Bamberger
Bambi
bamboo
ban
Banach
banal
banana
Banbury
band
bandage
bandgap
bandit

Bangui
banish
banister
banjo
bank
bankrupt
bankruptcy


banquet
banshee
bantam
banter
Bantu
Bantus
baptism

Barnet
Barnett
Barney
Barnhard
barnstorm
barnyard
barometer

baron
baroness
baronet
baronial
barony
baroque
Barr
barrack
barracuda
barrage
barre
barrel
barren
Barrett
barrette
barricade
barrier

Barrington
barrow
Barry
Barrymore
Barstow
bartend
bartender
barter
Barth
Bartholomew
Bartlett
Bartok
Barton
barycentric
basal
basalt
base
baseball
baseband
baseboard
Basel
baseline
baseman
basemen
baseplate
basepoint
bash
bashaw
bashful
basic
basidiomycetes
basil
basilar

Batavia
batch
Batchelder
bate
bateau
Bateman
bater

bath
bathe
bathos
bathrobe
bathroom
bathtub
Bathurst

bawd
bawdy
bawl
Baxter
bay
bayberry
Bayda

Bayesian
Baylor
bayonet
Bayonne
bayou
Bayport
Bayreuth

bean
bear
bearberry
beard
Beardsley
bearish
beast
beastie
beat
beaten
beater
beatific
beatify
beatitude
beatnik

beaver
bebop
becalm
became
because
Bechtel
beck

becket
Beckman
beckon
Becky
become
bed
bedazzle
bedbug

bedfast
Bedford
bedim
bedimmed
bedimming
bedlam
bedpost

behalf
behave
behavioral
behead
beheld
behind
behold
Beijing
beige
being
Beirut
bel
Bela
belate
belch

beman
bemoan
bemuse
Ben
bench
benchmark
bend

Bendix
beneath
Benedict
Benedictine
benediction
Benedikt
benefactor
benefice
beneficent
beneficial
beneficiary
benefit
Benelux

Bentham
benthic
Bentley
Benton
Benz
Benzedrine
benzene
Beograd
Beowulf
Beresford
beplaster
bequeath
bequest
berate
Berea
bereave
bereft

Bethlehem
bethought
betide
betoken
betony
betray
betrayal

betroth
betrothal
Betsey
Betsy
Bette

bettor
Betty
between
betwixt
bevel
beverage
Beverly
bevy
bewail
beware
bewhisker
bewilder
bewitch
bey
beyond
bezel
bhoy
Bhutan
Bialystok
bianco
bias
biaxial
bib
bibb
Bible
biblical
bibliography
bibliophile
bicameral
bicarbonate
bicep

bichromate
bicker
biconcave
biconnected
bicycle
bid

bidden
biddy
bide
bidiagonal
bidirectional
bien
biennial
biennium
bifocal
bifurcate
big
Bigelow
Biggs
bigot
bigotry
biharmonic
bijection
bijective
bijouterie
bikini
bilabial
bilateral
bilayer
bile
bilge
bilharziasis
bilinear
bilingual
bilk
bill
billboard
billet
billiard
Billie
Billiken

billion
billionth
billow
billy
Biltmore
bimetallic
bimetallism

Binghamton
bingle
Bini
binocular
binomial
binuclear
biochemic



biography
biology



Biometrika
biometry



biopsy




biota
biotic
biotite
bipartisan
bipartite
biplane
bipolar
biracial
birch
bird
birdbath
birdie

birdseed
birdwatch
birefringent
Birgit
Birmingham
birth
birthday
birthplace
birthright
biscuit
bisect
bisexual
bishop
bishopric
Bismarck
Bismark
bismuth
bison
bisque
Bissau
bistable
bistate
bit
bitch
bite
bitnet
bitt
bitten
bittern
bitternut
bitterroot
bittersweet
bitumen
bituminous
bitwise
bivalve
bivariate
bivouac
biz
bizarre
Bizet
blab

black
blackball
blackberry
blackbird
blackboard
blackbody
Blackburn

blame
blameworthy
blanc
blanch
Blanchard
Blanche
bland
blandish
blank
blanket
blare
blaspheme
blasphemous
blasphemy
blast
blastula
blat
blatant
blather

Blatz
blaze
blazon
bleach
bleak
bleary
bleat

Blomberg
Blomquist
blond
blonde
blood
bloodbath
bloodhound
bloodline
bloodroot
bloodshed
bloodshot
bloodstain
bloodstone
bloodstream
bloody
bloom
Bloomfield
Bloomington
bloop
blossom
blot
blotch

blouse
blow
blowfish
blown
blowup
blubber
bludgeon

bluff
bluish
Blum
Blumenthal
blunder
blunt
blur

blurry
blurt
blush
bluster
blustery
blutwurst
Blvd
Blythe
BMW
boa
boar
board
boardinghouse
boast
boastful
boat
boathouse
boatload
boatman
boatmen
boatswain
boatyard
bob
Bobbie
bobbin

bobble
bobby
bobcat
bobolink
Boca
bock
bode
bodhisattva
bodice

Bodleian
body
bodybuilder
bodybuilding
bodyguard
Boeing
Boeotia
bog
bogey
bogeymen
bogging
boggle
boggy
Bogota

bootlegger
bootlegging
bootstrap
bootstrapping
booty
booze
bop

borate
borax
Bordeaux
bordello
Borden
border
borderland

borough
Borroughs
borrow
Bosch
Bose
bosom
boson
bosonic
boss
Boston

Boswell
botanic
botanist
botany
botch
botfly
both