A batch system for 4.2 (2 of 2)

Sat Apr 27 14:40:23 AEST 1985

<I'm hungry>

	Here are the routines required for the local library.  These
	routines are required for the batch program in the previous
	posting.  Note, these routines were originally built for
	portability + convenience.

	The Makefile will build a library for BSD4.2 by default.

Regards,
Dave Shimell.  <shimell at stc.UUCP>
{root44, ukc, idec, stl, creed}!stc!shimell

-=-=-=-=-=-=--=-=-=-=-=-=-=-=--=-=-=-=-=-=-=-=--=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
# To unbundle, csh this file
echo Makefile
cat >Makefile <<'End of Makefile'
# Makefile for local libraries
# %W%
#

SCCS	=	.
BIN	=	/usr/local/lib

LIB	=	liblocal.a
CFLAGS	=	-O

#-------------------------------------------------------------------------------

all:		$(LIB)
		@echo programs are up to date

.DEFAULT:
		$(GET) $(GFLAGS) $(SCCS)/s.$<

rm clean tidy:

cp install:	$(LIB)
		-rm -f $(BIN)/$(LIB)
		cp $(LIB) $(BIN)/$(LIB)
		ranlib $(BIN)/$(LIB)

# The following is a list of files for BDS4.2.

$(LIB):		\
		$(LIB)(curdir.o)\
		$(LIB)(dname.o)\
		$(LIB)(fswitch.o)\
		$(LIB)(getopt.o)\
		$(LIB)(sname.o)\
		$(LIB)(error.o)\
		$(LIB)(quit.o)\
		$(LIB)(warning.o)\
		$(LIB)(salloc.o)\
		$(LIB)(ename.o)

# The following is a complete list of files.
# This will need editing for your system and
# moved above.

#$(LIB):		
#
#		$(LIB)(curdir.o)\
#		$(LIB)(dname.o)\
#		$(LIB)(fswitch.o)\
#		$(LIB)(getopt.o)\
#		$(LIB)(rename.o)\
#		$(LIB)(sname.o)\
#		$(LIB)(umask.o)\
#		$(LIB)(ndir.h)\
#		$(LIB)(opendir.o)\
#		$(LIB)(closedir.o)\
#		$(LIB)(readdir.o)\
#		$(LIB)(seekdir.o)\
#		$(LIB)(telldir.o)\
#		\
#		$(LIB)(error.o)\
#		$(LIB)(quit.o)\
#		$(LIB)(warning.o)\
#		$(LIB)(salloc.o)\
#		$(LIB)(ename.o)\
'End of Makefile'
echo closedir.c
cat >closedir.c <<'End of closedir.c'
#ifndef lint
#ifndef NSCCS
static char sccsid[] = "%W%";
#endif
#endif

#include <sys/types.h>
#include <ndir.h>

/*
 * close a directory.
 */
void
closedir(dirp)
	register DIR *dirp;
{
	close(dirp->dd_fd);
	dirp->dd_fd = -1;
	dirp->dd_loc = 0;
	free(dirp);
}
'End of closedir.c'
echo curdir.c
cat >curdir.c <<'End of curdir.c'
#ifndef lint
#ifndef NSCCS
static char sccsid[] = "%W%";
#endif
#endif

#include <stdio.h>

extern FILE *popen();

curdir(pwd)
char *pwd;		/* Fill this in with the current directory */
{
	register FILE *fp;
	int reply = -1;

	if ((fp = popen("pwd", "r")) != NULL) {
		reply = 0;
		fscanf(fp, " %s ", pwd);
		pclose(fp);
	}
	return(reply);
}
'End of curdir.c'
echo dname.c
cat >dname.c <<'End of dname.c'
#ifndef lint
#ifndef NSCCS
static char sccsid[] = "%W%";
#endif
#endif

char *
dname(nam)
char *nam;
{
	register char *slash;
	register char *cp;

	/*
	 * Find last slash in nam.
	 */

	for (slash = cp = nam; *cp != '\0'; cp++)
		if (*cp == '/')
			slash = cp;

	if (slash == nam)
		nam = (*slash == '/' ? "/" : ".");
	else
		*slash = '\0';
	return(nam);
}
'End of dname.c'
echo ename.c
cat >ename.c <<'End of ename.c'
#include <stdio.h>

extern char *sname();

#ifndef lint
#ifndef NSCCS
static char sccsid[] = "%W%";
#endif
#endif

/*
 * Returns a pointer to the file type (file
 * extension) or NULL if one cannot be found.
 * Eg.
 * /usr.xyz/file.plm	returns ".plm"
 * /usr.xyz/file	returns NULL
 */

char *
ename(file)
register char *file;
{
	register char *dot = NULL;

	for (file = sname(file); *file; file++)
		if (*file == '.')
			dot = file;
	return(dot);
}
'End of ename.c'
echo error.c
cat >error.c <<'End of error.c'
#ifndef lint
#ifndef NSCCS
static char sccsid[] = "%W%";
#endif
#endif

#include <stdio.h>

extern char *program;

unsigned ecount;

/* VARARGS1 */
error(s, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)
char *s;
{
	ecount++;
	fflush(stdout);
	fprintf(stderr, "%s: error, ", program);
	fprintf(stderr, s, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
	fprintf(stderr, "\n");
}
'End of error.c'
echo fswitch.c
cat >fswitch.c <<'End of fswitch.c'
#ifndef lint
#ifndef NSCCS
static char sccsid[] = "%W%";
#endif
#endif

#include <stdio.h>
#include <assert.h>

#ifndef TRUE
#	define TRUE 1
#	define FALSE 0
#endif

fswitch()
{
	assert(FALSE);
}
'End of fswitch.c'
echo getopt.c
cat >getopt.c <<'End of getopt.c'
#include <stdio.h>

#define ERR(S, A)	if (opterr) error((S), (A)); else

int	opterr = 1;
int	optind = 1;
int	optopt;
char	*optarg;
char	*program;

extern	char *sname();
extern	char *index();

#ifndef lint
#ifndef NSCCS
static char sccsid[] = "%W%";
#endif
#endif

int
getopt(argc, argv, opts)
char **argv, *opts;
{
	static int sp = 1;
	register c;
	register char *cp;

	if (program == NULL)
		program = sname(argv[0]);

	if (sp == 1) {
		if (optind >= argc || argv[optind][0] != '-' || argv[optind][1] == '\0')
			return(EOF);
		else if (strcmp(argv[optind], "--") == NULL) {
			optind++;
			return(EOF);
		}
	}
	optopt = c = argv[optind][sp];
	if (c == ':' || (cp = index(opts, c)) == NULL) {
		ERR("illegal option -%c", c);
		if (argv[optind][++sp] == '\0') {
			optind++;
			sp = 1;
		}
		return('?');
	}
	if (*++cp == ':') {
		if (argv[optind][sp + 1] != '\0')
			optarg = &argv[optind++][sp + 1];
		else if (++optind >= argc) {
			ERR("option -%c requires an argument", c);
			sp = 1;
			return('?');
		} else
			optarg = argv[optind++];
		sp = 1;
	} else {
		if (argv[optind][++sp] == '\0') {
			sp = 1;
			optind++;
		}
		optarg = NULL;
	}
	return(c);
}
'End of getopt.c'
echo ndir.h
cat >ndir.h <<'End of ndir.h'
static char ndir[] = "%W%";

/*
 * Change notice (rti!trt):  To be compatible with non-bsd systems:
 * #defines for u_short, u_long, and void added.
 */

#define	u_short	unsigned short
#define	u_long	long
#define	void

/*
 * A directory consists of some number of blocks of DIRBLKSIZ
 * bytes, where DIRBLKSIZ is chosen such that it can be transferred
 * to disk in a single atomic operation (e.g. 512 bytes on most machines).
 *
 * Each DIRBLKSIZ byte block contains some number of directory entry
 * structures, which are of variable length.  Each directory entry has
 * a struct direct at the front of it, containing its inode number,
 * the length of the entry, and the length of the name contained in
 * the entry.  These are followed by the name padded to a 4 byte boundary
 * with null bytes.  All names are guaranteed null terminated.
 * The maximum length of a name in a directory is MAXNAMLEN.
 *
 * The macro DIRSIZ(dp) gives the amount of space required to represent
 * a directory entry.  Free space in a directory is represented by
 * entries which have dp->d_reclen >= DIRSIZ(dp).  All DIRBLKSIZ bytes
 * in a directory block are claimed by the directory entries.  This
 * usually results in the last entry in a directory having a large
 * dp->d_reclen.  When entries are deleted from a directory, the
 * space is returned to the previous entry in the same directory
 * block by increasing its dp->d_reclen.  If the first entry of
 * a directory block is free, then its dp->d_ino is set to 0.
 * Entries other than the first in a directory do not normally have
 * dp->d_ino set to 0.
 */
#define DIRBLKSIZ	512
#define	MAXNAMLEN	255

struct	direct {
	u_long	d_ino;			/* inode number of entry */
	u_short	d_reclen;		/* length of this record */
	u_short	d_namlen;		/* length of string in d_name */
	char	d_name[MAXNAMLEN + 1];	/* name must be no longer than this */
};

/*
 * The DIRSIZ macro gives the minimum record length which will hold
 * the directory entry.  This requires the amount of space in struct direct
 * without the d_name field, plus enough space for the name with a terminating
 * null byte (dp->d_namlen+1), rounded up to a 4 byte boundary.
 */
#undef DIRSIZ
#define DIRSIZ(dp) \
    ((sizeof (struct direct) - (MAXNAMLEN+1)) + (((dp)->d_namlen+1 + 3) &~ 3))

#ifndef KERNEL
/*
 * Definitions for library routines operating on directories.
 */
typedef struct _dirdesc {
	int	dd_fd;
	long	dd_loc;
	long	dd_size;
	char	dd_buf[DIRBLKSIZ];
} DIR;
#ifndef NULL
#define NULL 0
#endif
extern	DIR *opendir();
extern	struct direct *readdir();
extern	long telldir();
extern	void seekdir();
#define rewinddir(dirp)	seekdir((dirp), (long)0)
extern	void closedir();
#endif KERNEL
'End of ndir.h'
echo opendir.c
cat >opendir.c <<'End of opendir.c'
#ifndef lint
#ifndef NSCCS
static char sccsid[] = "%W%";
#endif
#endif

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

/*
 * open a directory.
 */
DIR *
opendir(name)
	char *name;
{
	register DIR *dirp;
	register int fd;
	struct stat sbuf;

	if ((fd = open(name, 0)) == -1)
		return NULL;
	fstat(fd, &sbuf);
	if (((sbuf.st_mode & S_IFDIR) == 0) ||
	    ((dirp = (DIR *)malloc(sizeof(DIR))) == NULL)) {
		close (fd);
		return NULL;
	}
	dirp->dd_fd = fd;
	dirp->dd_loc = 0;
	return dirp;
}
'End of opendir.c'
echo quit.c
cat >quit.c <<'End of quit.c'
#ifndef lint
#ifndef NSCCS
static char sccsid[] = "%W%";
#endif
#endif

int fail_status = 1;	/* Exit status on error */

#include <stdio.h>

extern char *program;

/* VARARGS1 */
quit(s, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)
char *s;
{
	fflush(stdout);
	fprintf(stderr, "%s: fatal, ", program);
	fprintf(stderr, s, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
	fprintf(stderr, "\n");
	exit(fail_status);
}
'End of quit.c'
echo readdir.c
cat >readdir.c <<'End of readdir.c'
#ifndef lint
#ifndef NSCCS
static char sccsid[] = "%W%";
#endif
#endif

#include <sys/types.h>
#include <ndir.h>

/*
 * read an old stlye directory entry and present it as a new one
 */
#define	ODIRSIZ	14

struct	olddirect {
	ino_t	od_ino;
	char	od_name[ODIRSIZ];
};

/*
 * get next entry in a directory.
 */
struct direct *
readdir(dirp)
	register DIR *dirp;
{
	register struct olddirect *dp;
	static struct direct dir;

	for (;;) {
		if (dirp->dd_loc == 0) {
			dirp->dd_size = read(dirp->dd_fd, dirp->dd_buf,
			    DIRBLKSIZ);
			if (dirp->dd_size <= 0)
				return NULL;
		}
		if (dirp->dd_loc >= dirp->dd_size) {
			dirp->dd_loc = 0;
			continue;
		}
		dp = (struct olddirect *)(dirp->dd_buf + dirp->dd_loc);
		dirp->dd_loc += sizeof(struct olddirect);
		if (dp->od_ino == 0)
			continue;
		dir.d_ino = dp->od_ino;
		strncpy(dir.d_name, dp->od_name, ODIRSIZ);
		dir.d_name[ODIRSIZ] = '\0'; /* insure null termination */
		dir.d_namlen = strlen(dir.d_name);
		dir.d_reclen = DIRBLKSIZ;
		return (&dir);
	}
}
'End of readdir.c'
echo rename.c
cat >rename.c <<'End of rename.c'
#ifndef lint
#ifndef NSCCS
static char sccsid[] = "%W%";
#endif
#endif

rename(from, to)
char *from;	/* Old name */
char *to;	/* New name */
{
	register status = -1;

	if (link(from, to) != -1 && unlink(from) != -1)
		status = 0;
	return(status);
}
'End of rename.c'
echo salloc.c
cat >salloc.c <<'End of salloc.c'
#include <stdio.h>

#ifndef lint
#ifndef NSCCS
static char sccsid[] = "%W%";
#endif
#endif

extern char *malloc();
extern char *strcpy();

/*
 * Allocate and copy a string
 * into dynamic memory.
 */

char *
salloc(nam)
char *nam;
{
	register char *p;

	if ((p = malloc((unsigned)strlen(nam) + 1)) == NULL)
		quit("dynamic memory exhausted");
	return(strcpy(p, nam));
}
'End of salloc.c'
echo seekdir.c
cat >seekdir.c <<'End of seekdir.c'
#ifndef lint
#ifndef NSCCS
static char sccsid[] = "%W%";
#endif
#endif

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

/*
 * seek to an entry in a directory.
 * Only values returned by "telldir" should be passed to seekdir.
 */
void
seekdir(dirp, loc)
	register DIR *dirp;
	long loc;
{
	long base, offset;
	struct direct *dp;

/* rti!trt: Always seek.  Slower, but safer. This may even fix a bug.
	if (loc == telldir(dirp))
		return;
 */
	base = loc & ~(DIRBLKSIZ - 1);
	offset = loc & (DIRBLKSIZ - 1);
	lseek(dirp->dd_fd, base, 0);
	dirp->dd_loc = 0;
	while (dirp->dd_loc < offset) {
		dp = readdir(dirp);
		if (dp == NULL)
			return;
	}
}
'End of seekdir.c'
echo sname.c
cat >sname.c <<'End of sname.c'
#ifndef lint
#ifndef NSCCS
static char sccsid[] = "%W%";
#endif
#endif

char *
sname(nam)
register char *nam;
{
	register char *slash;

	slash = nam;
	while (*nam != '\0') {
		if (*nam++ == '/')
			slash = nam;
	}
	return(slash);
}
'End of sname.c'
echo telldir.c
cat >telldir.c <<'End of telldir.c'
#ifndef lint
#ifndef NSCCS
static char sccsid[] = "%W%";
#endif
#endif

#include <sys/types.h>
#include <ndir.h>

extern	long	lseek();	/* needed for pdp 11s -- ikonas!mcm */

/*
 * return a pointer into a directory
 */
long
telldir(dirp)
	DIR *dirp;
{
	return (lseek(dirp->dd_fd, 0L, 1) - dirp->dd_size + dirp->dd_loc);
}
'End of telldir.c'
echo umask.c
cat >umask.c <<'End of umask.c'
/*
 * Some systems do not have this
 * system call.
 *
 * DB Shimell	September 1984
 */

#ifndef lint
#ifndef NSCCS
static char sccsid[] = "%W%";
#endif
#endif

umask(numask)
{
	return(0);
}
'End of umask.c'
echo warning.c
cat >warning.c <<'End of warning.c'
#ifndef lint
#ifndef NSCCS
static char sccsid[] = "%W%";
#endif
#endif

#include <stdio.h>

extern char *program;

unsigned wcount;

/* VARARGS1 */
warning(s, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)
char *s;
{
	wcount++;
	fflush(stdout);
	fprintf(stderr, "%s: warning, ", program);
	fprintf(stderr, s, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
	fprintf(stderr, "\n");
}
'End of warning.c'
exit 0
-- 

Regards,
Dave Shimell.  <shimell at stc.UUCP>
{root44, ukc, idec, stl, creed}!stc!shimell