first pass for new make

[unix-history] / usr / src / usr.bin / find / find.c

/*-
 * Copyright (c) 1990 The Regents of the University of California.
 * All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * Cimarron D. Taylor of the University of California, Berkeley.
 *
 * %sccs.include.redist.c%
 */

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

#ifndef lint
static char sccsid[] = "@(#)find.c	4.25 (Berkeley) %G%";
#endif /* not lint */

#include <sys/types.h>
#include <sys/stat.h>
#include <fts.h>
#include <stdio.h>
#include <strings.h>
#include <errno.h>
#include "find.h"

FTS *tree;			/* pointer to top of FTS hierarchy */
time_t now;			/* time find was run */
dev_t curdev = (dev_t)-1;	/* device number of current tree */
int ftsoptions;			/* options passed to ftsopen() */
int depth;			/* set by -depth option */
int output_specified;		/* one of -print, -ok or -exec was specified */
int xdev;			/* set by -xdev option */

main(argc, argv)
	int argc;
	char **argv;
{
	PLAN *plan;
	char **paths, **find_getpaths();
	PLAN *find_formplan();
	time_t time();
    
	(void)time(&now);	/* initialize the time-of-day */

	if (argc < 2)
		usage();
    
	ftsoptions = FTS_MULTIPLE|FTS_NOSTAT|FTS_PHYSICAL;

	paths = find_getpaths(&argv);		/* places to start search */
	plan = find_formplan(argv);		/* execution plan */
	find_execute(plan, paths);
}

/*
 * find_formplan --
 *	process the command line and create a "plan" corresponding to the
 *	command arguments.
 */
PLAN *
find_formplan(argv)
	char **argv;
{
	PLAN *plan, *tail, *new;
	int i;
	PLAN *c_print(), *find_create(), *find_squish_not(), *find_squish_or();
	PLAN *find_squish_paren();

	/*
	 * for each argument in the command line, determine what kind of node
	 * it is, create the appropriate node type and add the new plan node
	 * to the end of the existing plan.  The resulting plan is a linked
	 * list of plan nodes.  For example, the string:
	 *
	 *	% find . -name foo -newer bar -print
	 *
	 * results in the plan:
	 *
	 *	[-name foo]--> [-newer bar]--> [-print]
	 *
	 * in this diagram, `[-name foo]' represents the plan node generated
	 * by c_name() with an argument of foo and `-->' represents the
	 * plan->next pointer.
	 */
	for (plan = NULL; *argv;) {
		new = find_create(&argv);
		if (plan == NULL)
			tail = plan = new;
		else {
			tail->next = new;
			tail = new;
		}
	}
    
	/*
	 * if the user didn't specify one of -print, -ok or -exec, then -print
	 * is assumed so we add a -print node on the end.  It is possible that
	 * the user might want the -print someplace else on the command line,
	 * but there's no way to know that.
	 */
	if (!output_specified) {
		new = c_print();
		if (plan == NULL)
			tail = plan = new;
		else {
			tail->next = new;
			tail = new;
		}
	}
    
	/*
	 * the command line has been completely processed into a search plan
	 * except for the (, ), !, and -o operators.  Rearrange the plan so
	 * that the portions of the plan which are affected by the operators
	 * are moved into operator nodes themselves.  For example:
	 *
	 *	[!]--> [-name foo]--> [-print]
	 *
	 * becomes
	 *
	 *	[! [-name foo] ]--> [-print]
	 *
	 * and
	 *
	 *	[(]--> [-depth]--> [-name foo]--> [)]--> [-print]
	 *
	 * becomes
	 *
	 *	[expr [-depth]-->[-name foo] ]--> [-print]
	 *
	 * operators are handled in order of precedence.
	 */

	plan = find_squish_paren(plan);		/* ()'s */
	plan = find_squish_not(plan);		/* !'s */
	plan = find_squish_or(plan);		/* -o's */
	return(plan);
}
 
/*
 * find_execute --
 *	take a search plan and an array of search paths and executes the plan
 *	over all FTSENT's returned for the given search paths.
 */
find_execute(plan, paths)
	PLAN *plan;		/* search plan */
	char **paths;		/* array of pathnames to traverse */
{
	FTSENT *entry;		/* current fts entry */
	PLAN *p;
    
	if (!(tree = ftsopen(paths, ftsoptions, NULL))) {
		(void)fprintf(stderr, "find: ftsopen: %s.\n", strerror(errno));
		exit(1);
	}
	while (entry = ftsread(tree)) {
		switch(entry->info) {
		case FTS_DNR:
			(void)fprintf(stderr,
			    "find: %s: unable to read.\n", entry->path);
			continue;
		case FTS_DNX:
			(void)fprintf(stderr,
			    "find: %s: unable to search.\n", entry->path);
			continue;
		case FTS_ERR:
			(void)fprintf(stderr,
			    "find: %s: %s.\n", entry->path, strerror(errno));
			continue;
		case FTS_D:
			if (depth)
				continue;
			break;
		case FTS_DC:
			(void)fprintf(stderr,
			    "find: directory cycle: %s.\n", entry->path);
			continue;
		case FTS_DP:
			if (!depth)
				continue;
		case FTS_NS:
			if (!(ftsoptions & FTS_NOSTAT)) {
				(void)fprintf(stderr,
				    "find: can't stat: %s.\n", entry->path);
				continue;
			}
			break;
		}

		/* always keep curdev up to date, -fstype uses it. */
		if (xdev && curdev != entry->statb.st_dev &&
		    ftsset(tree, entry, FTS_SKIP)) {
			(void)fprintf(stderr, "find: %s: %s.\n",
			    entry->path, strerror(errno));
			exit(1);
		}

		/*
		 * call all the functions in the execution plan until one is
		 * false or all have been executed.  This is where we do all
		 * the work specified by the user on the command line.
		 */
		for (p = plan; p && (p->eval)(p, entry); p = p->next);

		curdev = entry->statb.st_dev;
	}
	(void)ftsclose(tree);
}