DragonFlyBSD

CFLAGS+=-DDEBUG -Wall -I${.CURDIR}/../strfile

DPADD=	${LIBCOMPAT}

LDADD=	-lcompat

.include "${.CURDIR}/../../Makefile.inc"

.include <bsd.prog.mk>

# include	<fcntl.h>

# include	<assert.h>

# include	<unistd.h>

# include	<stdio.h>

# include	<ctype.h>

# include	<stdlib.h>

# include	"strfile.h"

# include	"pathnames.h"

# define	MINW	6		/* minimum wait if desired */

# define	CPERS	20		/* # of chars for each sec */

# define	SLEN	160		/* # of chars in short fortune */

	int		fd, datfd;

	long            pos;

	FILE		*inf;

	char		*datfile, *posfile;

	bool		read_tbl;

	bool		was_pos_file;

} FILEDESC;

bool	Found_one;			/* did we find a match? */

#ifndef NO_REGEX

#endif

#ifdef DEBUG

#endif

char	*Fortbuf = NULL;			/* fortune buffer for -m */

STRFILE		Noprob_tbl;		/* sum of data for all no prob files */

void	 all_forts (FILEDESC *, char *);

void	 display (FILEDESC *);

void	 do_free (void *);

void	*do_malloc (u_int);

int	 fortlen (void);

void	 get_fort (void);

void	 get_pos (FILEDESC *);

void	 get_tbl (FILEDESC *);

void	 getargs (int, char *[]);

void	 init_prob (void);

int	 max (int, int);

FILEDESC *

	 new_fp (void);

void	 open_dat (FILEDESC *);

void	 open_fp (FILEDESC *);

FILEDESC *

# ifndef NO_REGEX

	char	*pat;

# endif	/* NO_REGEX */

	int ch;

# ifndef NO_REGEX

	pat = NULL;

# endif /* NO_REGEX */

			break;

		case 'l':		/* long ones only */

			Long_only++;

			break;

		case 'o':		/* offensive ones only */

			Offend++;

			break;

		case 's':		/* short ones only */

			Short_only++;

			break;

		case 'w':		/* give time to read */

			Wait++;

 * form_file_list:

 *	Form the file list from the file specifications.

 */

form_file_list(char **files, int file_cnt)

{

	if (file_cnt == 0) {

		if (Find_files) {

			i = add_file(NO_PROB, FORTDIR, NULL, &File_list,

					&File_tail, NULL);

			return i;

		} else

			return add_file(NO_PROB, "fortunes", FORTDIR,

				percent = percent * 10 + *sp - '0';

			if (percent > 100) {

				fprintf(stderr, "percentages must be <= 100\n");

			}

			if (*sp == '.') {

				fprintf(stderr, "percentages must be integers\n");

			}

			/*

			 * If the number isn't followed by a '%', then

			else if (*++sp == '\0') {

				if (++i >= file_cnt) {

					fprintf(stderr, "percentages must precede files\n");

				}

				sp = files[i];

			}

		if (strcmp(sp, "all") == 0)

			sp = FORTDIR;

		if (!add_file(percent, sp, NULL, &File_list, &File_tail, NULL))

	}

}

/*

 * add_file:

 *	Add a file to the file list.

 */

{

	FILEDESC	*fp;

	int		fd;

	bool		was_malloc;

	bool		isdir;

	if (dir == NULL) {

		path = file;

	}

	else {

	}

	if ((isdir = is_dir(path)) && parent != NULL) {

		if (was_malloc)

	}

	offensive = NULL;

	if (!isdir && parent == NULL && (All_forts || Offend) &&

		offensive = off_name(path);

		if (Offend) {

			if (was_malloc)

			path = offensive;

			offensive = NULL;

			DPRINTF(1, (stderr, "\ttrying \"%s\"\n", path));

			file = off_name(file);

		}

		 */

		if (All_forts && offensive != NULL) {

			if (was_malloc)

			path = offensive;

			offensive = NULL;

			DPRINTF(1, (stderr, "\ttrying \"%s\"\n", path));

			file = off_name(file);

			goto over;

		if (parent == NULL)

			perror(path);

		if (was_malloc)

	}

	DPRINTF(2, (stderr, "path = \"%s\"\n", path));

				"fortune:%s not a fortune file or directory\n",

				path);

		if (was_malloc)

		do_free(fp->datfile);

		do_free(fp->posfile);

		free((char *) fp);

		do_free(offensive);

	}

	/*

	 * If the user said -a, we need to make this node a pointer to

	fp->was_pos_file = (access(fp->posfile, W_OK) >= 0);

#endif	/* OK_TO_WRITE_DISK */

}

/*

	fp->inf = NULL;

	fp->fd = -1;

	fp->percent = NO_PROB;

	fp->next = NULL;

	fp->prev = NULL;

	fp->child = NULL;

 *	Return a pointer to the offensive version of a file of this name.

 */

char *

{

	char	*new;

 * is_off_name:

 *	Is the file an offensive-style name?

 */

{

	int	len;

	if (fp->child != NULL)	/* this is a directory, not a file */

		return;

		return;

	if ((fd = open(offensive, 0)) < 0)

		return;

		obscene->name = ++sp;

	obscene->datfile = datfile;

	obscene->posfile = posfile;

#ifdef	OK_TO_WRITE_DISK

	obscene->was_pos_file = (access(obscene->posfile, W_OK) >= 0);

#endif	/* OK_TO_WRITE_DISK */

 * add_dir:

 *	Add the contents of an entire directory.

 */

add_dir(FILEDESC *fp)

{

	DIR		*dir;

	fp->fd = -1;

	if ((dir = opendir(fp->path)) == NULL) {

		perror(fp->path);

	}

	tailp = NULL;

	DPRINTF(1, (stderr, "adding dir \"%s\"\n", fp->path));

	if (fp->num_children == 0) {

		(void) fprintf(stderr,

		    "fortune: %s: No fortune files in directory.\n", fp->path);

	}

}

/*

 * is_dir:

 */

{

	auto struct stat	sbuf;

	if (stat(file, &sbuf) < 0)

	return (sbuf.st_mode & S_IFDIR);

}

/*

 * is_fortfile:

 *	exclude files without reading them if possible to avoid

 *	overhead.  Files which start with ".", or which have "illegal"

 *	suffixes, as contained in suflist[], are ruled out.

 */

/* ARGSUSED */

{

	int	i;

	char	*datfile;

				"dat", "pos", "c", "h", "p", "i", "f",

				"pas", "ftn", "ins.c", "ins,pas",

				"ins.ftn", "sml",

	if (check_for_offend && !All_forts) {

		i = strlen(file);

		if (Offend ^ (file[i - 2] == '-' && file[i - 1] == 'o')) {

		}

	}

	else

		sp++;

	if (*sp == '.') {

	}

	if (Fortunes_only && strncmp(sp, "fortunes", 8) != 0) {

	}

	if ((sp = rindex(sp, '.')) != NULL) {

		sp++;

		for (i = 0; suflist[i] != NULL; i++)

			if (strcmp(sp, suflist[i]) == 0) {

			}

	}

	datfile = copy(file, (unsigned int) (strlen(file) + 4)); /* +4 for ".dat" */

	strcat(datfile, ".dat");

	if (access(datfile, R_OK) < 0) {

#ifdef DEBUG

		if (Debug < 2)

			DPRINTF(0, (stderr, "Warning: file \"%s\" unreadable\n", datfile));

#endif

		free(datfile);

	}

	if (datp != NULL)

		*datp = datfile;

		*posp = NULL;

#endif	/* OK_TO_WRITE_DISK */

	}

}

/*

 *	Return a malloc()'ed copy of the string

 */

char *

{

	char	*new, *sp;

			choice = random() % Noprob_tbl.str_numstr;

			DPRINTF(1, (stderr, "choice = %d (of %ld) \n", choice,

				    Noprob_tbl.str_numstr));

				choice -= fp->tbl.str_numstr;

				fp = fp->next;

				DPRINTF(1, (stderr,

		choice = random() % parent->tbl.str_numstr;

		DPRINTF(1, (stderr, "    choice = %d (of %ld)\n",

			    choice, parent->tbl.str_numstr));

		     fp = fp->next) {

			choice -= fp->tbl.str_numstr;

			DPRINTF(1, (stderr, "\tskip %s, %ld (choice = %d)\n",

void

sum_noprobs(FILEDESC *fp)

{

	if (did_noprobs)

		return;

		sum_tbl(&Noprob_tbl, &fp->tbl);

		fp = fp->next;

	}

}

int

		fp->pos = random() % fp->tbl.str_numstr;

#endif /* OK_TO_WRITE_DISK */

	}

		fp->pos -= fp->tbl.str_numstr;

	DPRINTF(1, (stderr, "pos for %s is %ld\n", fp->name, fp->pos));

}

			sum_tbl(&fp->tbl, &child->tbl);

		}

	}

}

/*

	/* extra length, "%\n" is appended */

	Fortbuf = do_malloc((unsigned int) Fort_len + 10);

	matches_in_list(File_list);

	return Found_one;

	/* NOTREACHED */

		}

		else {

			get_tbl(fp);

				maxlen = fp->tbl.str_longlen;

		}

	}

		DPRINTF(1, (stderr, "searching in %s\n", fp->path));

		open_fp(fp);

		sp = Fortbuf;

		while (fgets(sp, Fort_len, fp->inf) != NULL)

			if (fp->tbl.str_flags & STR_COMMENTS

			    && sp[0] == fp->tbl.str_delim

					    fp->tbl.str_delim);

					if (!in_file) {

						printf(" (%s)", fp->name);

					}

					putchar('\n');

					(void) fwrite(Fortbuf, 1, (sp - Fortbuf), stdout);

PROG=	strfile

MAN=	strfile.8

MLINKS= strfile.8 unstr.8

.include "${.CURDIR}/../../Makefile.inc"

.include <bsd.prog.mk>

 */

# include	<sys/param.h>

# include	<stdio.h>

# include       <stdlib.h>

# include	<ctype.h>

 *	Added ordering options.

 */

# define	STORING_PTRS	(Oflag || Rflag)

# define	CHUNKSIZE	512

			} \

		}

typedef struct {

	char	first;

	long    pos;

	Outfile[MAXPATHLEN] = "",	/* output file name */

	Delimch		= '%';		/* delimiting character */

long	Num_pts		= 0;		/* number of pointers/strings */

long    *Seekpts;

			if (!length)

				continue;

			add_offset(outf, pos);

				Tbl.str_longlen = length;

				Tbl.str_shortlen = length;

			first = Oflag;

		}

			else

				fp->first = *nsp;

			fp->pos = Seekpts[Num_pts - 1];

		}

	} while (sp != NULL);

	(void) fseek(Sort_1, p1->pos, 0);

	(void) fseek(Sort_2, p2->pos, 0);

	while (!isalnum(c1 = getc(Sort_1)) && c1 != '\0' && c1 != EOF)

		SET_N(n1, c1);

	while (!isalnum(c2 = getc(Sort_2)) && c2 != '\0' && c2 != EOF)

PROG=	unstr

NOMAN=	noman

.include "${.CURDIR}/../../Makefile.inc"

.include <bsd.prog.mk>

FILE	*Inf, *Dataf;

/* ARGSUSED */

int

{

	static STRFILE	tbl;		/* description table */

void

order_unstr(STRFILE *tbl)

{

	char	*sp;

	long            pos;

	char		buf[BUFSIZ];