/*	$OpenBSD: util.c,v 1.57 2017/04/03 16:18:35 tedu Exp $	*/

/*-

 * Copyright (c) 1999 James Howard and Dag-Erling Coïdan Smørgrav

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND

 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE

 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

 * SUCH DAMAGE.

 */

#include <sys/types.h>

#include <sys/stat.h>

#include <ctype.h>

#include <err.h>

#include <errno.h>

#include <fts.h>

#include <regex.h>

#include <stdbool.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <zlib.h>

#include "grep.h"

/*

 * Process a file line by line...

 */

static int	linesqueued;

static int	procline(str_t *l, int);

static int	grep_search(fastgrep_t *, char *, size_t, regmatch_t *pmatch, int);

#ifndef SMALL

static bool	grep_cmp(const char *, const char *, size_t);

static void	grep_revstr(unsigned char *, int);

#endif

int

grep_tree(char **argv)

{

	FTS	*fts;

	FTSENT	*p;

	int	c, fts_flags;

	c = 0;

	fts_flags = FTS_PHYSICAL | FTS_NOSTAT | FTS_NOCHDIR;

		case FTS_DNR:

			break;

		case FTS_ERR:

			break;

		case FTS_DP:

			break;

		default:

		}

	}

}

int

procfile(char *fn)

{

	file_t *f;

	int c, t, z, nottext;

		fn = "(standard input)";

	}

	}

	}

			break;

	}

	}

/*

 * Process an individual line in a file. Return non-zero if it matches.

 */

#define isword(x) (isalnum((unsigned char)x) || (x) == '_')

static int

procline(str_t *l, int nottext)

{

	int		c, i, r;

	regoff_t	offset;

	/* size_t will be converted to regoff_t. ssize_t is guaranteed to fit

	 * into regoff_t */

	}

	c = 0;

	i = 0;

		c = 1;

	}

redo:

			int flags = 0;

		}

		}

			c = 1;

			break;

		}

	}

print:

		}

	}

	}

#ifndef SMALL

void

fgrepcomp(fastgrep_t *fg, const unsigned char *pattern)

{

	int i;

	/* Initialize. */

	/*

	 * Make a copy and upper case it for later if in -i mode,

	 * else just copy the pointer.

	 */

	/* Preprocess pattern. */

		/*

		 * If case is ignored, make the jump apply to both upper and

		 * lower cased characters.  As the pattern is stored in upper

		 * case, apply the same to the lower case equivalents.

		 */

	}

#endif

/*

 * Returns: -1 on failure, 0 on success

 */

int

fastcomp(fastgrep_t *fg, const char *pattern)

{

#ifdef SMALL

	return -1;

#else

	int i;

	int bol = 0;

	int eol = 0;

	int shiftPatternLen;

	int hasDot = 0;

	int firstHalfDot = -1;

	int firstLastHalfDot = -1;

	int lastHalfDot = 0;

	/* Initialize. */

	/* Remove end-of-line character ('$'). */

		eol++;

	/* Remove beginning-of-line character ('^'). */

		bol++;

	/* Remove enclosing [[:<:]] and [[:>:]] (word match). */

		/* basic re's use \( \), extended re's ( ) */

	/*

	 * Copy pattern minus '^' and '$' characters as well as word

	 * match character classes at the beginning and ending of the

	 * string respectively.

	 */

	/* Look for ways to cheat...er...avoid the full regex engine. */

	{

		case '.':

			hasDot = i;

					/* Closest dot to the beginning */

			} else {

				/* Closest dot to the end of the pattern. */

				lastHalfDot = i;

			}

			break;

		case '(': case ')':

		case '{': case '}':

			/* Special in BRE if preceded by '\\' */

		case '?':

		case '+':

		case '|':

			/* Not special in BRE. */

				goto nonspecial;

		case '\\':

		case '*':

		case '[': case ']':

			/* Free memory and let others know this is empty. */

		default:

nonspecial:

			break;

		}

	}

	/*

	 * Determine if a reverse search would be faster based on the placement

	 * of the dots.

	 */

	/*

	 * Normal Quick Search would require a shift based on the position the

	 * next character after the comparison is within the pattern.  With

	 * wildcards, the position of the last dot effects the maximum shift

	 * distance.

	 * The closer to the end the wild card is the slower the search.  A

	 * reverse version of this algorithm would be useful for wildcards near

	 * the end of the string.

	 *

	 * Examples:

	 * Pattern	Max shift

	 * -------	---------

	 * this		5

	 * .his		4

	 * t.is		3

	 * th.s		2

	 * thi.		1

	 */

	/* Adjust the shift based on location of the last dot ('.'). */

	/* Preprocess pattern. */

		/*

		 * If case is ignored, make the jump apply to both upper and

		 * lower cased characters.  As the pattern is stored in upper

		 * case, apply the same to the lower case equivalents.

		 */

	}

	/*

	 * Put pattern back to normal after pre-processing to allow for easy

	 * comparisons later.

	 */

#endif

/*

 * Word boundaries using regular expressions are defined as the point

 * of transition from a non-word char to a word char, or vice versa.

 * This means that grep -w +a and grep -w a+ never match anything,

 * because they lack a starting or ending transition, but grep -w a+b

 * does match a line containing a+b.

 */

#define wmatch(d, l, s, e)	\

	((s == 0 || !isword(d[s-1])) && (e == l || !isword(d[e])) && \

	  e > s && isword(d[s]) && isword(d[e-1]))

static int

grep_search(fastgrep_t *fg, char *data, size_t dataLen, regmatch_t *pmatch,

    int flags)

{

#ifdef SMALL

	return 0;

#else

	regoff_t j;

	int rtrnVal = REG_NOMATCH;

	/* No point in going farther if we do not have enough data. */

	/* Only try once at the beginning or ending of the line. */

		/* Simple text comparison. */

		/* Verify data is >= pattern length before searching on it. */

			/* Determine where in data to start search at. */

			else

				j = 0;

					    pmatch->rm_so, pmatch->rm_eo))

				}

		}

		/* Quick Search algorithm. */

		j = dataLen;

			    fg->patternLen)) {

				    pmatch->rm_so, pmatch->rm_eo)) {

					rtrnVal = 0;

				}

			}

			/* Shift if within bounds, otherwise, we are done. */

				break;

	} else {

		/* Quick Search algorithm. */

		j = 0;

				    pmatch->rm_eo)) {

					rtrnVal = 0;

				}

			}

			/* Shift if within bounds, otherwise, we are done. */

				break;

			else

	}

#endif

void *

grep_malloc(size_t size)

{

	void	*ptr;

}

void *

grep_calloc(size_t nmemb, size_t size)

{

	void	*ptr;

}

void *

grep_realloc(void *ptr, size_t size)

{

}

void *

grep_reallocarray(void *ptr, size_t nmemb, size_t size)

{

}

#ifndef SMALL

/*

 * Returns:	true on success, false on failure

 */

static bool

grep_cmp(const char *pattern, const char *data, size_t len)

{

	size_t i;

			continue;

	}

static void

grep_revstr(unsigned char *str, int len)

{

	int i;

	char c;

	}

#endif

void

printline(str_t *line, int sep, regmatch_t *pmatch)

{

	int n;

	n = 0;

		++n;

	}

	}

	else