OpenSolaris_b135/tools/cscope-fast/cgrep.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*	Copyright (c) 1990 AT&T	*/
/*	  All Rights Reserved  	*/


/*
 * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

/*
 *	cscope - interactive C symbol or text cross-reference
 *
 *	text searching functions
 */

#include <fcntl.h>
#include <setjmp.h>
#include <stdio.h>
#include <string.h>
#include <memory.h>
#include <ctype.h>
#include <unistd.h>
#include "library.h"

typedef enum {
	NO = 0,
	YES = 1
} BOOL;

typedef struct re_bm {
	int delta0[256];
	int *delta2;
	uchar_t *cmap;
	uchar_t *bmpat;
	int patlen;
} re_bm;

typedef struct Link {
	uchar_t lit;
	struct Node *node;
	struct Link *next;
} Link;

typedef struct Node {
	short out;
	short d;
	short shift1;
	short shift2;
	long id;
	struct Node **tab;
	Link *alts;
	struct Node *fail;
} Node;

typedef struct re_cw {
	int maxdepth, mindepth;
	long nodeid;
	int step[256];
	uchar_t *cmap;
	struct Node *root;
} re_cw;

typedef enum {
	/* lit expression types */
	Literal, Dot, Charclass, EOP,

	/* non-lit expression types */
	Cat, Alternate, Star, Plus, Quest,

	/* not really expression types, just helping */
	Lpar, Rpar, Backslash

} Exprtype;

typedef int ID;

typedef struct Expr {
	Exprtype type;	/* Type of expression (in grammar) */
	ID id;		/* unique ID of lit expression  */
	int lit;	/* Literal character or tag */
	int flen;	/* Number of following lit expressions */
	ID *follow;	/* Array of IDs of following lit expressions */
	struct Expr *l; /* pointer to Left child (or ccl count) */
	struct Expr *r; /* pointer to Right child (or ccl mask) */
	struct Expr *parent; /* pointer to Parent */
} Expr;

typedef struct State {
	struct State *tab[256];
	int cnt; /* number of matched chars on full match, -1 otherwise  */
	int npos;	/* number of IDs in position set for this state. */
	int pos;	/* index into posbase for beginning of IDs */
} State;

typedef struct FID {
	ID	id;	/* Lit Expression id */
	int	fcount; /* Number of Lit exp matches before this one. */
} FID;

typedef struct Positionset {
	int count;	/* Number of lit exps in position set */
	ID last;	/* ID of last lit exp in position set */
	FID *base;	/* array of MAXID FIDS */
			/* 0 means not in position set */
			/* -1 means first in position set */
			/* n (>0) is ID of prev member of position set. */
} Positionset;

typedef struct re_re {
	FID  *posbase;	/* Array of IDs from all states */
	int nposalloc;	/* Allocated size of posbase */
	int posnext;	/* Index into free space in posbase */
	int posreset;	/* Index into end of IDs for initial state in posbase */
	int maxid;	/* Number of (also maximum ID of) lit expressions */
	Expr *root;	/* Pointer to root (EOP) expression */
	Expr **ptr;	/* Pointer to array of ptrs to lit expressions. */
	uchar_t *cmap;	/* Character mapping array */
	Positionset firstpos;
	Positionset tmp;
	int nstates;	/* Number of current states defined */
	int statelim;	/* Limit on number of states before flushing */
	State *states;	/* Array of states */
	State istate;	/* Initial state */
} re_re;

typedef struct {
	uchar_t *cmap;
	re_re *re_ptr;
	re_bm *bm_ptr;
	re_cw *cw_ptr;
	BOOL fullmatch;
	BOOL (*procfn)();
	BOOL (*succfn)();
	uchar_t *loc1;
	uchar_t *loc2;
	uchar_t *expression;
} PATTERN;

typedef enum {
	BEGIN,		/* File is not yet in buffer at all */
	MORE,		/* File is partly in buffer */
	NO_MORE		/* File has been completely read into buffer */
} FILE_STAT;

typedef struct {
	uchar_t	*prntbuf; /* current line of input from data file */
	uchar_t	*newline; /* end of line (real or sentinel \n) */
	long	ln;	/* line number */
} LINE;

#define	NL '\n'

#define	CCL_SIZ		32
#define	CCL_SET(a, c)	((a)[(c) >> 3] |= bittab[(c) & 07])
#define	CCL_CLR(a, c)	((a)[(c) >> 3] &= ~bittab[(c) & 07])
#define	CCL_CHK(a, c)	((a)[(c) >> 3] & bittab[(c) & 07])

#define	ESIZE (BUFSIZ)
#define	MAXBUFSIZE (64*BUFSIZ)

#define	MAXMALLOCS	1024
#define	MAXLIT	256	/* is plenty big enough */
#define	LARGE	MAXBUFSIZE+ESIZE+2

#define	CLEAR(r, rps)	(void) memset((char *)(rps)->base, 0, \
			    (int)((r)->maxid * sizeof (FID))), \
			    (rps)->count = 0, (rps)->last = -1
#define	SET(rps, n, cnt) { \
	if ((rps)->base[n].id == 0) {\
		(rps)->count++;\
		(rps)->base[n].fcount = (cnt);\
		(rps)->base[n].id = (rps)->last;\
		(rps)->last = (n);\
	} else if ((cnt) > (rps)->base[n].fcount) {\
		(rps)->base[n].fcount = (cnt);\
	}}

#define	START	{ _p = tmp; }
#define	ADDL(c)	{ if (_p >= &tmp[MAXLIT]) _p--; *_p++ = c; }
#define	FINISH	{ ADDL(0) if ((_p-tmp) > bestlen) \
		    (void) memmove(best, tmp, bestlen = _p-tmp); }


#define	NEW(N)	(froot?(t = froot, froot = froot->next, t->next = NULL, \
		    t->node = N, t): newlink(0, N))
#define	ADD(N)	if (qtail) qtail = qtail->next = NEW(N); \
			else qtail = qhead = NEW(N)
#define	DEL()	{ Link *_l = qhead; if ((qhead = qhead->next) == NULL) \
			qtail = NULL; _l->next = froot; froot = _l; }

static uchar_t	*buffer;
static uchar_t	*bufend;
static FILE	*output;
static char	*format;
static char	*file;
static int	file_desc;
static FILE_STAT file_stat;
static PATTERN	match_pattern;
static uchar_t	char_map[2][256];
static int	iflag;
static Exprtype	toktype;
static int	toklit, parno, maxid;
static uchar_t	tmp[MAXLIT], best[MAXLIT];
static uchar_t	*_p;
static int	bestlen;
static Node	*next_node;
static Link	*froot, *next_link;
static jmp_buf	env;

static int nmalloc;
static uchar_t	*mallocs[MAXMALLOCS];

static uchar_t	bittab[] = { 1, 2, 4, 8, 16, 32, 64, 128 };

#ifdef	DEBUG
#define		TRACE(n)	(n < debug)
#define		EPRINTSIZE	50000
static void spr(int c, int *p, uchar_t *buf);
void epr(Expr *e, uchar_t *res);
static int debug = 12;
#endif

static void init_file(LINE *cur_ptr);
static void get_line(LINE *cur_ptr, uchar_t *s);
static void get_ncount(LINE *cur_ptr, uchar_t *s);
static int execute(void);
static State *startstate(re_re *r);
static State *stateof(re_re *r, Positionset *ps);
static State *nextstate(re_re *r, State *s, int a);
static State *addstate(re_re *r, Positionset *ps, int cnt);
static BOOL match(Expr *e, int a);
static BOOL first_lit(Positionset *fpos, Expr *e);
static void eptr(re_re *r, Expr *e);
static void efollow(re_re *r, Positionset *fpos, Expr *e);
static void follow(Positionset *fpos, Expr *e);
static void followstate(re_re *r, State *s, int a, Positionset *fpos);
static Expr *eall(re_re *r, PATTERN *pat);
static Expr *d0(re_re *r, PATTERN *pat);
static Expr *d1(re_re *r, PATTERN *pat);
static Expr *d2(re_re *r, PATTERN *pat);
static Expr *d3(re_re *r, PATTERN *pat);
static Expr *newexpr(Exprtype t, int lit, Expr *left, Expr *right);
static void lex(re_re *r, PATTERN *pat);
static int re_lit(PATTERN *pat, uchar_t **b, uchar_t **e);
static void traverse(PATTERN *pat, Expr *e);
static int ccl(PATTERN *pat, uchar_t *tab);
static BOOL altlist(), word();
static BOOL altlist(Expr *e, uchar_t *buf, re_cw *pat);
static Node *newnode(re_cw *c, int d);
static Link *newlink(uchar_t lit, Node *n);
static void fail(Node *root);
static void zeroroot(Node *root, Node *n);
static void shift(re_cw *c);
static void shifttab(Node *n);
static void shiftprop(re_cw *c, Node *n);
static void delta_2(re_bm *b);
static int getstate(re_re *r, Positionset *ps);
static void savestate(re_re *r);
static void stateinit(re_re *r);
static re_bm *re_bmcomp(uchar_t *pb, uchar_t *pe, uchar_t *cmap);
static re_cw *re_cwinit(uchar_t *cmap);
static re_cw *re_recw(re_re *r, uchar_t *map);
static re_re *egprep(PATTERN *pat);
static void re_cwadd(re_cw *c, uchar_t *s, uchar_t *e);
static void re_cwcomp(re_cw *c);
static void eginit(re_re *r);
static BOOL re_bmexec(PATTERN *pat, uchar_t *s, uchar_t *e, uchar_t **mb,
    uchar_t **me);
static BOOL re_cwexec(PATTERN *pat, uchar_t *rs, uchar_t *re, uchar_t **mb,
    uchar_t **me);
static BOOL re_reexec(PATTERN *pat, uchar_t *b, uchar_t *e, uchar_t **mb,
    uchar_t **me);
static uchar_t *egmalloc(size_t n);
static void fgetfile(LINE *cur_ptr);
static void dogre(PATTERN *pat);
static BOOL pattern_match(PATTERN *pat, LINE *lptr);
static BOOL fixloc(uchar_t **mb, uchar_t **me);
static BOOL grepmatch(PATTERN *pat, uchar_t **mb, uchar_t **me);
static void err(char *s);

static char *message;

void
egrepcaseless(int i)
{
	iflag = i;	/* simulate "egrep -i" */
}

char *
egrepinit(char *expression)
{
	static int firsttime = 1;
	int i;

	if (firsttime) {
		firsttime = 0;
		for (i = 0; i < 256; i++) {
			char_map[0][i] = (uchar_t)i;
			char_map[1][i] = tolower(i);
		}
	}
	for (i = 0; i < nmalloc; i ++)
		free(mallocs[i]);
	nmalloc = 0;
	message = NULL;

	match_pattern.expression = (uchar_t *)expression;
	match_pattern.cmap = char_map[iflag];
	if (setjmp(env) == 0) {
		dogre(&match_pattern);
#ifdef	DEBUG
		{
		PATTERN *p = match_pattern;
		if (p->procfn == re_bmexec)
			if (!p->fullmatch)
				if (p->succfn == re_reexec)
					printf("PARTIAL BOYER_MOORE\n");
				else
					printf("PARTIAL B_M with GREP\n");
			else
				printf("FULL BOYER_MOORE\n");
		else if (p->procfn == re_cwexec)
			printf("C_W\n");
		else
			printf("GENERAL\n");
		}
#endif
	}
	return (message);
}

static void
dogre(PATTERN *pat)
{
	uchar_t *lb, *le;

#ifdef	DEBUG
	printf("PATTERN %s\n", pat->expression);
#endif
	pat->re_ptr = egprep(pat);
	bestlen = re_lit(pat, &lb, &le);

	if (bestlen && pat->fullmatch) { /* Full Boyer Moore */
#ifdef	DEBUG
		printf("BESTLEN %d\n", bestlen);
		{
			uchar_t *p;
			for (p = lb; p < le; p++) printf("%c", *p);
			printf("\n");
		}
#endif
		pat->bm_ptr = re_bmcomp(lb, le, pat->cmap);
		pat->procfn = re_bmexec;
		return;
	}
	if (bestlen > 1) {
			/* Partial Boyer Moore */
		pat->bm_ptr = re_bmcomp(lb, le, pat->cmap);
		pat->procfn = re_bmexec;
		pat->fullmatch = NO;
	} else {
		pat->fullmatch = YES;
		if ((pat->cw_ptr = re_recw(pat->re_ptr, pat->cmap)) != NULL) {
			pat->procfn = re_cwexec; /* CW */
			return;
		}
	}
	/* general egrep regular expression */
	pat->succfn = re_reexec;

	if (pat->fullmatch) {
		pat->procfn = pat->succfn;
		pat->succfn = NULL;
	}
}

static BOOL
fixloc(uchar_t **mb, uchar_t **me)
{
	/* Handle match to null string */

	while (*me <= *mb)
		(*me)++;

	if (*(*me - 1) != NL)
		while (**me != NL)
			(*me)++;

	/* Handle match to new-line only */

	if (*mb == *me - 1 && **mb == NL) {
		(*me)++;
	}

	/* Handle match including beginning or ending new-line */

	if (**mb == NL)
		(*mb)++;
	if (*(*me - 1) == NL)
		(*me)--;
	return (YES);
}

static BOOL
grepmatch(PATTERN *pat, uchar_t **mb, uchar_t **me)
{
	uchar_t *s, *f;

	if (pat->fullmatch)
		return (fixloc(mb, me));

	for (f = *me - 1; *f != NL; f++) {
	}
	f++;
	for (s = *mb; *s != NL; s--) {
	}

	if ((*pat->succfn)(pat, s, f, mb, me)) {
		return (YES);
	} else {
		*mb = f;
		return (NO);
	}
}

static void
eginit(re_re *r)
{
	unsigned int n;

	r->ptr = (Expr **)egmalloc(r->maxid * sizeof (Expr *));
	eptr(r, r->root);
	n = r->maxid * sizeof (FID);
	r->firstpos.base = (FID *)egmalloc(n);
	r->tmp.base = (FID *)egmalloc(n);
	CLEAR(r, &r->firstpos);
	if (!first_lit(&r->firstpos, r->root->l)) {
		/*
		 * This expression matches the null string!!!!
		 * Add EOP to beginning position set.
		 */
		SET(&r->firstpos, r->root->id, 0)
		/* (void) printf("first of root->l == 0, b=%s\n", b); */
	}
	stateinit(r);
	(void) addstate(r, &r->firstpos, 0);
	savestate(r);
}

static void
eptr(re_re *r, Expr *e)
{
	if ((e->id < 0) || (e->id >= r->maxid)) {
		err("internal error");
	}
	r->ptr[e->id] = e;
	if (e->type != Charclass) {
		if (e->l) eptr(r, e->l);
		if (e->r) eptr(r, e->r);
	}
}

static BOOL
re_reexec(PATTERN *pat, uchar_t *b, uchar_t *e, uchar_t **mb, uchar_t **me)
{
	re_re *r = pat->re_ptr;
	State *s, *t;

#ifdef	DEBUG
	if (TRACE(10)) {
		uchar_t buf[EPRINTSIZE];
		epr(r->root, buf);
		(void) printf("expr='%s'\n", buf);
	}
#endif
	s = startstate(r);

	for (;;) {
		uchar_t c;

		if (s->cnt >= 0) {
#ifdef	DEBUG
			if (TRACE(6))
				(void) printf("match at input '%s'\n", b);
#endif
			*mb = b - s->cnt;
			*me = b;
			if (fixloc(mb, me))
				return (YES);
		}

		if (b >= e) break;
		c = pat->cmap[*b];
#ifdef	DEBUG
		if (TRACE(4))
			(void) printf("state %d: char '%c'\n", s-r->states, *b);
#endif
		if ((t = s->tab[c]) != NULL) s = t;
		else s = nextstate(r, s, (int)c);
		b++;
	}
#ifdef	DEBUG
	if (TRACE(3)) {
		uchar_t buf[EPRINTSIZE];

		epr(r->root, buf);
		(void) printf("pat = %s\n", buf);
	}
#endif
	return (NO);
}

static BOOL
match(Expr *e, int a)
{
	switch (e->type) {
	case Dot:	return ((BOOL)(a != NL));
	case Literal:	return ((BOOL)(a == e->lit));
	case Charclass:	return ((BOOL)(CCL_CHK((uchar_t *)e->r, a)));
	default:	return (NO);
	}
}

/*
 * generates the followset for a node in fpos
 */
static void
follow(Positionset *fpos, Expr *e)
{
	Expr *p;

	if (e->type == EOP)
		return;
	else
		p = e->parent;
	switch (p->type) {
	case EOP:
		SET(fpos, p->id, 0)
		break;
	case Plus:
	case Star:
		(void) first_lit(fpos, e);
		follow(fpos, p);
		break;
	case Quest:
	case Alternate:
		follow(fpos, p);
		break;
	case Cat:
		if (e == p->r || !first_lit(fpos, p->r))
			follow(fpos, p);
		break;
	default:
		break;
	}
}

/*
 * first_lit returns NO if e is nullable and in the process,
 * ets up fpos.
 */
static BOOL
first_lit(Positionset *fpos, Expr *e)
{
	BOOL k;

	switch (e->type) {
	case Literal:
	case Dot:
	case Charclass:
		SET(fpos, e->id, 0)
		return (YES);
	case EOP:
	case Star:
	case Quest:
		(void) first_lit(fpos, e->l);
		return (NO);
	case Plus:
		return (first_lit(fpos, e->l));
	case Cat:
		return ((BOOL)(first_lit(fpos, e->l) || first_lit(fpos, e->r)));
	case Alternate:
		k = first_lit(fpos, e->r);
		return ((BOOL)(first_lit(fpos, e->l) && k));
	default:
		err("internal error");
	}
	return (NO);
}

static void
efollow(re_re *r, Positionset *fpos, Expr *e)
{
	ID i, *p;

	CLEAR(r, fpos);
	follow(fpos, e);
	e->flen = fpos->count;
	e->follow = (ID *)egmalloc(e->flen * sizeof (ID));
	p = e->follow;
#ifdef	DEBUG
	printf("ID = %d LIT %c FLEN = %d\n", e->id, e->lit, e->flen);
#endif
	for (i = fpos->last; i > 0; i = fpos->base[i].id) {
		*p++ = i;
#ifdef	DEBUG
	printf("FOLLOW ID = %d LIT %c\n", r->ptr[i]->id, r->ptr[i]->lit);
#endif
	}
	if (p != e->follow + e->flen) {
		err("internal error");
	}
}

static State *
addstate(re_re *r, Positionset *ps, int cnt)
{
	ID j;
	FID *p, *q;
	State *s;

	if (cnt) {
		s = r->states + getstate(r, ps);
		(void) memset((char *)s->tab, 0, sizeof (s->tab));
		s->cnt = r->istate.cnt;
	} else {
		s = &r->istate;
		s->cnt = -1;
	}
	s->pos = r->posnext;
	r->posnext += ps->count;
	s->npos = ps->count;
	p = r->posbase + s->pos;
	for (j = ps->last; j > 0; p++, j = q->id) {
		q = &ps->base[j];
		p->id = j;
		p->fcount = q->fcount;
		if (p->id == r->root->id && s->cnt < p->fcount)
			s->cnt = p->fcount;
	}
#ifdef	DEBUG
	if (TRACE(3)) {
		uchar_t buf[2000];
		spr(s->npos, s->pos+r->posbase, buf);
		(void) printf("new state[%d] %s%s\n", s-r->states, buf,
		    s->cnt?" cnt":"");
	}
#endif
	return (s);
}

static State *
nextstate(re_re *r, State *s, int a)
{
	State *news;

	CLEAR(r, &r->tmp);
	followstate(r, s, a, &r->tmp);
	if (s != &r->istate) followstate(r, &r->istate, a, &r->tmp);

#ifdef	DEBUG
	if (TRACE(5)) {
		uchar_t buf[2000];
		ppr(&r->tmp, buf);
		(void) printf("nextstate(%d, '%c'): found %s\n", s-r->states,
		    a, buf);
	}
#endif
	if (r->tmp.count == 0)
		news = &r->istate;
	else if ((news = stateof(r, &r->tmp)) == NULL)
		news = addstate(r, &r->tmp, 1);
	s->tab[a] = news;
#ifdef	DEBUG
	if (TRACE(5)) {
		(void) printf("nextstate(%d, '%c'): returning %ld\n",
		    s-r->states, a, news);
	}
#endif
	return (news);
}

static void
followstate(re_re *r, State *s, int a, Positionset *fpos)
{
	int j;
	ID *q, *eq;
	Expr *e;

	for (j = s->pos; j < (s->pos + s->npos); j++) {
		e = r->ptr[r->posbase[j].id];
		if (e->type == EOP) continue;
		if (match(e, a)) {
			if (e->follow == NULL) efollow(r, &r->firstpos, e);
			for (q = e->follow, eq = q + e->flen; q < eq; q++) {
				SET(fpos, *q, r->posbase[j].fcount + 1)
#ifdef	DEBUG
				printf("CHAR %c FC %c COUNT %d\n",
					a,
					r->ptr[*q]->lit,
					r->posbase[j].fcount+1);
#endif
			}
		}
	}
}

static uchar_t *
egmalloc(size_t n)
{
	uchar_t *x;

	x = (uchar_t *)mymalloc(n);
	mallocs[nmalloc++] = x;
	if (nmalloc >= MAXMALLOCS)
		nmalloc = MAXMALLOCS - 1;
	return (x);
}

#ifdef	DEBUG
void
ppr(Positionse *ps, char *p)
{
	ID n;

	if (ps->count < 1) {
		(void) sprintf(p, "{}");
		return;
	}
	*p++ = '{';
	for (n = ps->last; n > 0; n = ps->base[n].id) {
		(void) sprintf(p, "%d,", n);
		p = strchr(p, 0);
	}
	p[-1] = '}';
}

void
epr(Expr *e, uchar_t *res)
{
	uchar_t r1[EPRINTSIZE], r2[EPRINTSIZE];
	int i;

	if (e == NULL) {
		(void) sprintf(res, "!0!");
		return;
	}
	switch (e->type) {
	case Dot:
	case Literal:
		spr(e->flen, e->follow, r1);
		(void) sprintf(res, "%c%s", e->lit, r1);
		break;
	case Charclass:
		*res++ = '[';
		for (i = 0; i < 256; i++)
			if (CCL_CHK((uchar_t *)e->r, i)) {
				*res++ = i;
			}
		*res++ = ']';
		*res = '\0';
		break;
	case Cat:
		epr(e->l, r1);
		epr(e->r, r2);
		(void) sprintf(res, "%s%s", r1, r2);
		break;
	case Alternate:
		epr(e->l, r1);
		epr(e->r, r2);
		(void) sprintf(res, "(%s|%s)", r1, r2);
		break;
	case Star:
		epr(e->l, r1);
		(void) sprintf(res, "(%s)*", r1);
		break;
	case Plus:
		epr(e->l, r1);
		(void) sprintf(res, "(%s)+", r1);
		break;
	case Quest:
		epr(e->l, r1);
		(void) sprintf(res, "(%s)?", r1);
		break;
	case EOP:
		epr(e->l, r1);
		(void) sprintf(res, "%s<EOP>", r1);
		break;
	default:
		(void) sprintf(res, "<undef type %d>", e->type);
		err(res);
		break;
	}
}

static void
spr(int c, int *p, uchar_t *buf)
{
	if (c > 0) {
		*buf++ = '{';
		*buf = '\0';
		while (--c > 0) {
			(void) sprintf(buf, "%d,", *p++);
			buf = strchr(buf, 0);
		}
		(void) sprintf(buf, "%d}", *p);
	} else
		(void) sprintf(buf, "{}");
}
#endif

static void
stateinit(re_re *r)
{
	/* CONSTANTCONDITION */
	r->statelim = (sizeof (int) < 4 ? 32 : 128);
	r->states = (State *)egmalloc(r->statelim * sizeof (State));

	/* CONSTANTCONDITION */
	r->nposalloc = (sizeof (int) < 4 ? 2048 : 8192);
	r->posbase = (FID *)egmalloc(r->nposalloc * sizeof (FID));
	r->nstates = r->posnext = 0;
}

static void
clrstates(re_re *r)
{
	r->nstates = 0;		/* reclaim space for states and positions */
	r->posnext = r->posreset;
	(void) memset((char *)r->istate.tab, 0, sizeof (r->istate.tab));
}

static void
savestate(re_re *r)
{
	r->posreset = r->posnext;	/* save for reset */
}

static State *
startstate(re_re *r)
{
	return (&r->istate);
}

static int
getstate(re_re *r, Positionset *ps)
{
	if (r->nstates >= r->statelim ||
	    r->posnext + ps->count >= r->nposalloc) {
		clrstates(r);
#ifdef	DEBUG
		printf("%d STATES FLUSHED\n", r->statelim);
#endif
	}
	return (r->nstates++);
}

static State *
stateof(re_re *r, Positionset *ps)
{
	State *s;
	int i;
	FID *p, *e;

	for (i = 0, s = r->states; i < r->nstates; i++, s++) {
		if (s->npos == ps->count) {
			for (p = s->pos+r->posbase, e = p+s->npos; p < e; p++)
				if (ps->base[p->id].id == 0 ||
					ps->base[p->id].fcount != p->fcount)
						goto next;
			return (s);
		}
	next:;
	}
	return (NULL);
}

static re_re *
egprep(PATTERN *pat)
{
	re_re *r;

	r = (re_re *)egmalloc(sizeof (re_re));
	(void) memset((char *)r, 0, sizeof (re_re));

	pat->loc1 = pat->expression;
	pat->loc2 = pat->expression + strlen((char *)pat->expression);

	parno = 0;
	maxid = 1;
	r->cmap = pat->cmap;
	lex(r, pat);
	r->root = newexpr(EOP, '#', eall(r, pat), (Expr *)NULL);
	r->maxid = maxid;

	eginit(r);
	return (r);
}

static Expr *
newexpr(Exprtype t, int lit, Expr *left, Expr *right)
{
	Expr *e = (Expr *)egmalloc(sizeof (Expr));

	e->type = t;
	e->parent = NULL;
	e->lit = lit;

	if (e->lit) e->id = maxid++;
	else e->id = 0;

	if ((e->l = left) != NULL) {
		left->parent = e;
	}
	if ((e->r = right) != NULL) {
		right->parent = e;
	}
	e->follow = NULL;
	e->flen = 0;
	return (e);
}

static void
lex(re_re *r, PATTERN *pat)
{
	if (pat->loc1 == pat->loc2) {
		toktype = EOP;
		toklit = -1;
	} else switch (toklit = *pat->loc1++) {
	case '.':	toktype = Dot; break;
	case '*':	toktype = Star; break;
	case '+':	toktype = Plus; break;
	case '?':	toktype = Quest; break;
	case '[':	toktype = Charclass; break;
	case '|':	toktype = Alternate; break;
	case '(':	toktype = Lpar; break;
	case ')':	toktype = Rpar; break;
	case '\\':	toktype = Backslash;
			if (pat->loc1 == pat->loc2) {
				err("syntax error - missing character "
				    "after \\");
			} else
			    toklit = r->cmap[*pat->loc1++];
			break;
	case '^': case '$':	toktype = Literal; toklit = NL; break;
	default:	toktype = Literal; toklit = r->cmap[toklit]; break;
	}
}

static int
ccl(PATTERN *pat, uchar_t *tab)
{
	int i;
	int range = 0;
	int lastc = -1;
	int count = 0;
	BOOL comp = NO;

	(void) memset((char *)tab, 0, CCL_SIZ * sizeof (uchar_t));
	if (*pat->loc1 == '^') {
		pat->loc1++;
		comp = YES;
	}
	if (*pat->loc1 == ']') {
		uchar_t c = pat->cmap[*pat->loc1];
		CCL_SET(tab, c);
		lastc = *pat->loc1++;
	}
	/* scan for chars */
	for (; (pat->loc1 < pat->loc2) && (*pat->loc1 != ']');
							pat->loc1++) {
		if (*pat->loc1 == '-') {
			if (lastc < 0) CCL_SET(tab, pat->cmap['-']);
			else range = 1;
			continue;
		}
		if (range) {
			for (i = *pat->loc1; i >= lastc; i--) {
				CCL_SET(tab, pat->cmap[i]);
			}
		} else {
			uchar_t c = pat->cmap[*pat->loc1];
			CCL_SET(tab, c);
		}

		range = 0;

		lastc = *pat->loc1;
	}
	if (range) CCL_SET(tab, pat->cmap['-']);

	if (pat->loc1 < pat->loc2) pat->loc1++;
	else err("syntax error - missing ]");

	if (comp) {
		CCL_SET(tab, pat->cmap[NL]);
		for (i = 0; i < CCL_SIZ; i++) tab[i] ^= 0xff;
	}
	for (i = 0; i < 256; i++) {
		if (pat->cmap[i] != i) CCL_CLR(tab, i);
		if (CCL_CHK(tab, i)) {
			lastc = i;
			count++;
		}
	}
	if (count == 1)
		*tab = (char)lastc;
	return (count);
}

/*
 * egrep patterns:
 *
 * Alternation:	d0:	d1 { '|' d1 }*
 * Concatenation:	d1:	d2 { d2 }*
 * Repetition:	d2:	d3 { '*' | '?' | '+' }
 * Literal:	d3:	lit | '.' | '[]' | '(' d0 ')'
 */

static Expr *
d3(re_re *r, PATTERN *pat)
{
	Expr *e;
	uchar_t *tab;
	int count;

	switch (toktype) {
	case Backslash:
	case Literal:
		e = newexpr(Literal, toklit, (Expr *)NULL, (Expr *)NULL);
		lex(r, pat);
		break;
	case Dot:
		e = newexpr(Dot, '.', (Expr *)NULL, (Expr *)NULL);
		lex(r, pat);
		break;
	case Charclass:
		tab = egmalloc(CCL_SIZ * sizeof (uchar_t));
		count = ccl(pat, tab);
		if (count == 1) {
			toklit = *tab;
			e = newexpr(Literal, toklit, (Expr *)NULL,
			    (Expr *)NULL);
		} else {
			e = newexpr(Charclass, '[', (Expr *)NULL, (Expr *)NULL);
			e->l = (Expr *)count;	/* number of chars */
			e->r = (Expr *)tab;	/* bitmap of chars */
		}
		lex(r, pat);
		break;
	case Lpar:
		lex(r, pat);
		count = ++parno;
		e = d0(r, pat);
		if (toktype == Rpar)
			lex(r, pat);
		else
			err("syntax error - missing )");
		return (e);
	default:
		err("syntax error");
		e = NULL;
	}
	return (e);
}

static Expr *
d2(re_re *r, PATTERN *pat)
{
	Expr *e;
	Exprtype t;

	e = d3(r, pat);
	while ((toktype == Star) || (toktype == Plus) || (toktype == Quest)) {
		t = toktype;
		lex(r, pat);
		e = newexpr(t, 0, e, (Expr *)NULL);
	}
	return (e);
}

static Expr *
d1(re_re *r, PATTERN *pat)
{
	Expr *e, *f;

	e = d2(r, pat);
	while ((toktype == Literal) || (toktype == Dot) || (toktype == Lpar) ||
		(toktype == Backslash) || (toktype == Charclass)) {
		f = d2(r, pat);
		e = newexpr(Cat, 0, e, f);
	}
	return (e);
}

static Expr *
d0(re_re *r, PATTERN *pat)
{
	Expr *e, *f;

	e = d1(r, pat);
	while (toktype == Alternate) {
		lex(r, pat);
		if (toktype == EOP)
			continue;
		f = d1(r, pat);
		e = newexpr(Alternate, 0, e, f);
	}
	return (e);
}

static Expr *
eall(re_re *r, PATTERN *pat)
{
	Expr *e;

	while (toktype == Alternate)	/* bogus but user-friendly */
		lex(r, pat);
	e = d0(r, pat);
	while (toktype == Alternate)	/* bogus but user-friendly */
		lex(r, pat);
	if (toktype != EOP)
		err("syntax error");
	return (e);
}

static void
err(char *s)
{
	message = s;
	longjmp(env, 1);
}

static int
re_lit(PATTERN *pat, uchar_t **b, uchar_t **e)
{
	bestlen = 0;
	pat->fullmatch = YES;
	START
	traverse(pat, pat->re_ptr->root->l);
	FINISH
	if (bestlen < 2)
		return (0);
	*b = egmalloc(bestlen * sizeof (uchar_t));
	(void) memmove(*b, best, bestlen);
	*e = *b + bestlen - 1;
	return (bestlen - 1);
}

static void
traverse(PATTERN *pat, Expr *e)
{
	switch (e->type) {
	case Literal:
		ADDL(e->lit)
		break;
	case Cat:
		traverse(pat, e->l);
		traverse(pat, e->r);
		break;
	case Plus:
		traverse(pat, e->l);
		FINISH	/* can't go on past a + */
		pat->fullmatch = NO;
		START	/* but we can start with one! */
		traverse(pat, e->l);
		break;
	default:
		FINISH
		pat->fullmatch = NO;
		START
		break;
	}
}

static re_bm *
re_bmcomp(uchar_t *pb, uchar_t *pe, uchar_t *cmap)
{
	int j;
	int delta[256];
	re_bm *b;

	b = (re_bm *)egmalloc(sizeof (*b));

	b->patlen = pe - pb;
	b->cmap = cmap;
	b->bmpat = pb;

	delta_2(b);

	for (j = 0; j < 256; j++)
		delta[j] = b->patlen;

	for (pe--; pb < pe; pb++)
		delta[b->cmap[*pb]] = pe - pb;

	delta[b->cmap[*pb]] = LARGE;

	for (j = 0; j < 256; j++)
		b->delta0[j] = delta[b->cmap[j]];
	return (b);
}

static void
delta_2(re_bm *b)
{
	int m = b->patlen;
	int i, k, j;

	b->delta2 = (int *)egmalloc(m * sizeof (int));

	for (j = 0; j < m; j++) {
		k = 1;
again:
		while (k <= j && b->bmpat[j-k] == b->bmpat[j]) k++;

		for (i = j + 1; i < m; i++) {
			if (k <= i && b->bmpat[i-k] != b->bmpat[i]) {
				k++;
				goto again;
			}
		}
		b->delta2[j] = k + m - j - 1;
	}
}

static BOOL
re_bmexec(PATTERN *pat, uchar_t *s, uchar_t *e, uchar_t **mb, uchar_t **me)
{
	re_bm *b = pat->bm_ptr;
	uchar_t *sp;
	int k;

	s += b->patlen - 1;
	while ((unsigned long)s < (unsigned long)e) {
		while ((unsigned long)(s += b->delta0[*s]) < (unsigned long)e)
			;
		if ((unsigned long)s < (unsigned long)(e + b->patlen))
			return (NO); /* no match */
		s -= LARGE;
		for (k = b->patlen-2, sp = s-1; k >= 0; k--) {
			if (b->cmap[*sp--] != b->bmpat[k]) break;
		}
		if (k < 0) {
			*mb = ++sp;
			*me = s+1;
			if (grepmatch(pat, mb, me))
				return (YES);
			s = *mb;
		} else if (k < 0) {
			s++;
		} else {
			int j;
			j = b->delta2[k];
			k = b->delta0[*++sp];
			if ((j > k) || (k == (int)LARGE))
				k = j;
			s = sp + k;
		}
	}
	return (NO);
}

static re_cw *
re_recw(re_re *r, uchar_t *map)
{
	Expr *e, *root = r->root;
	re_cw *pat;
	uchar_t *buf;

	if (root->type != EOP)
		return (NULL);
	e = root->l;
	pat = re_cwinit(map);
	buf = (uchar_t *)egmalloc(20000 * sizeof (uchar_t));
	if (!altlist(e, buf, pat)) {
		return (NULL);
	}
	re_cwcomp(pat);
	return (pat);
}

static BOOL
altlist(Expr *e, uchar_t *buf, re_cw *pat)
{
	if (e->type == Alternate)
		return ((BOOL)(altlist(e->l, buf, pat) &&
		    altlist(e->r, buf, pat)));
	return (word(e, buf, pat));
}

static BOOL
word(Expr *e, uchar_t *buf, re_cw *pat)
{
	static uchar_t *p;

	if (buf) p = buf;

	if (e->type == Cat) {
		if (!word(e->l, (uchar_t *)NULL, pat))
			return (NO);
		if (!word(e->r, (uchar_t *)NULL, pat))
			return (NO);
	} else if (e->type == Literal)
		*p++ = e->lit;
	else
		return (NO);

	if (buf)
		re_cwadd(pat, buf, p);
	return (YES);
}

static re_cw *
re_cwinit(uchar_t *cmap)
{
	re_cw *c;

	froot = NULL;
	next_node = NULL;
	next_link = NULL;
	c = (re_cw *)egmalloc(sizeof (*c));
	c->nodeid = 0;
	c->maxdepth = 0;
	c->mindepth = 10000;
	c->root = newnode(c, 0);
	c->cmap = cmap;
	return (c);
}

static void
re_cwadd(re_cw *c, uchar_t *s, uchar_t *e)
{
	Node *p, *state;
	Link *l;
	int depth;

	state = c->root;
	while (s <= --e) {
		for (l = state->alts; l; l = l->next)
			if (l->lit == *e)
				break;
		if (l == NULL)
			break;
		else
			state = l->node;
	}
	if (s <= e) {
		depth = state->d+1;
		l = newlink(*e--, p = newnode(c, depth++));
		l->next = state->alts;
		state->alts = l;
		state = p;
		while (s <= e) {
			state->alts = newlink(*e--, p = newnode(c, depth++));
			state = p;
		}
		if (c->mindepth >= depth) c->mindepth = depth-1;
	}
	state->out = 1;
}

#ifdef	DEBUG
static
pr(Node *n)
{
	Link *l;

	printf("%d[%d,%d]: ", n->id, n->shift1, n->shift2);
	for (l = n->alts; l; l = l->next) {
		printf("edge from \"%d\" to \"%d\" label {\"%c\"};",
		    n->id, l->node->id, l->lit);
		if (l->node->out) {
			printf(" draw \"%d\" as Doublecircle;", l->node->id);
		}
		if (l->node->fail) {
			printf(" edge from \"%d\" to \"%d\" dashed;",
			    l->node->id, l->node->fail->id);
		}
		printf("\n");
		pr(l->node);
	}
}
#endif

static void
fail(Node *root)
{
	Link *qhead = NULL, *qtail = NULL;
	Link *l, *ll;
	Link *t;
	Node *state, *r, *s;
	int a;

	for (l = root->alts; l; l = l->next) {
		ADD(l->node);
		l->node->fail = root;
	}
	while (qhead) {
		r = qhead->node;
		DEL();
		for (l = r->alts; l; l = l->next) {
			s = l->node;
			a = l->lit;
			ADD(s);
			state = r->fail;
			while (state) {
				for (ll = state->alts; ll; ll = ll->next)
					if (ll->lit == a)
						break;
				if (ll || (state == root)) {
					if (ll)
						state = ll->node;
					/*
					 *	do it here as only other exit is
					 *	state 0
					 */
					if (state->out) {
						s->out = 1;
					}
					break;
				} else
					state = state->fail;
			}
			s->fail = state;
		}
	}
	zeroroot(root, root);
}

static void
zeroroot(Node *root, Node *n)
{
	Link *l;

	if (n->fail == root)
		n->fail = NULL;
	for (l = n->alts; l; l = l->next)
		zeroroot(root, l->node);
}

static void
shift(re_cw *c)
{
	Link *qhead = NULL, *qtail = NULL;
	Link *l;
	Link *t;
	Node *state, *r, *s;
	int k;

	for (k = 0; k < 256; k++)
		c->step[k] = c->mindepth+1;
	c->root->shift1 = 1;
	c->root->shift2 = c->mindepth;
	for (l = c->root->alts; l; l = l->next) {
		l->node->shift2 = c->root->shift2;
		ADD(l->node);
		l->node->fail = NULL;
	}
	while (qhead) {
		r = qhead->node;
		DEL();
		r->shift1 = c->mindepth;
		r->shift2 = c->mindepth;
		if ((state = r->fail) != NULL) {
			do {
				k = r->d - state->d;
				if (k < state->shift1) {
					state->shift1 = k;
				}
				if (r->out && (k < state->shift2)) {
					state->shift2 = k;
				}
			} while ((state = state->fail) != NULL);
		}
		for (l = r->alts; l; l = l->next) {
			s = l->node;
			ADD(s);
		}
	}
	shiftprop(c, c->root);
	shifttab(c->root);
	c->step[0] = 1;
}

static void
shifttab(Node *n)
{
	Link *l;
	Node **nn;

	n->tab = nn = (Node **)egmalloc(256 * sizeof (Node *));
	(void) memset((char *)n->tab, 0, 256 * sizeof (Node *));
	for (l = n->alts; l; l = l->next)
		nn[l->lit] = l->node;
}

static void
shiftprop(re_cw *c, Node *n)
{
	Link *l;
	Node *nn;

	for (l = n->alts; l; l = l->next) {
		if (c->step[l->lit] > l->node->d)
			c->step[l->lit] = l->node->d;
		nn = l->node;
		if (n->shift2 < nn->shift2)
			nn->shift2 = n->shift2;
		shiftprop(c, nn);
	}
}

static void
re_cwcomp(re_cw *c)
{
	fail(c->root);
	shift(c);
}

static BOOL
re_cwexec(PATTERN *pat, uchar_t *rs, uchar_t *re, uchar_t **mb, uchar_t **me)
{
	Node *state;
	Link *l;
	uchar_t *sp;
	uchar_t *s;
	uchar_t *e;
	Node *ostate;
	int k;
	re_cw *c = pat->cw_ptr;
	uchar_t fake[1];
	uchar_t mappedsp;

	fake[0] = 0;
	state = c->root;

	s = rs+c->mindepth-1;
	e = re;
	while (s < e) {
		/* scan */
		for (sp = s; (ostate = state) != NULL; ) {
			mappedsp = c->cmap[*sp];
			if (state->tab) {
				if ((state = state->tab[mappedsp]) == NULL)
					goto nomatch;
			} else {
				for (l = state->alts; ; l = l->next) {
					if (l == NULL)
						goto nomatch;
					if (l->lit == mappedsp) {
						state = l->node;
						break;
					}
				}
			}
			if (state->out) {
				*mb = sp;
				*me = s+1;
				if (fixloc(mb, me))
					return (YES);
			}
			if (--sp < rs) {
				sp = fake;
				break;
			}
		}
	nomatch:
		k = c->step[c->cmap[*sp]] - ostate->d - 1;
		if (k < ostate->shift1)
			k = ostate->shift1;
		if (k > ostate->shift2)
			k = ostate->shift2;
		s += k;
		state = c->root;
	}
	return (NO);
}

static Node *
newnode(re_cw *c, int d)
{
	static Node *lim = NULL;
	static int incr = 256;

	if (!next_node) lim = NULL;
	if (next_node == lim) {
		next_node = (Node *)egmalloc(incr * sizeof (Node));
		lim = next_node + incr;
	}
	next_node->d = d;
	if (d > c->maxdepth) c->maxdepth = d;
	next_node->id = c->nodeid++;
	next_node->alts = NULL;
	next_node->tab = NULL;
	next_node->out = 0;
	return (next_node++);
}

static Link *
newlink(uchar_t lit, Node *n)
{
	static Link *lim = NULL;
	static int incr = 256;

	if (!next_link) lim = NULL;
	if (next_link == lim) {
		next_link = (Link *)egmalloc(incr * sizeof (Link));
		lim = next_link + incr;
	}
	next_link->lit = lit;
	next_link->node = n;
	next_link->next = NULL;
	return (next_link++);
}

int
egrep(char *f, FILE *o, char *fo)
{
	uchar_t		buff[MAXBUFSIZE + ESIZE];

	buffer = buff;
	*buffer++ = NL;  /* New line precedes buffer to prevent runover */
	file = f;
	output = o;
	format = fo;
	return (execute());
}

static int
execute(void)
{
	LINE		current;
	BOOL		matched;
	BOOL	all_searched; /* file being matched until end */

	if ((file_desc = open(file, O_RDONLY)) < 0) {
		return (-1);
	}
	init_file(&current);
		/* while there is more get more text from the data stream */
	for (;;) {
		all_searched = NO;

		/*
		 * Find next new-line in buffer.
		 * Begin after previous new line character
		 */

		current.prntbuf = current.newline + 1;
		current.ln++; /* increment line number */

		if (current.prntbuf < bufend) {
			/* There is more text in buffer */

			/*
			 * Take our next
			 * "line" as the entire remaining buffer.
			 * However, if there is more of the file yet
			 * to be read in, exclude any incomplete
			 * line at end.
			 */
			if (file_stat == NO_MORE) {
				all_searched = YES;
				current.newline = bufend - 1;
				if (*current.newline != NL) {
					current.newline = bufend;
				}
			} else {
				/*
				 * Find end of the last
				 * complete line in the buffer.
				 */
				current.newline = bufend;
				while (*--current.newline != NL) {
				}
				if (current.newline < current.prntbuf) {
					/* end not found */
					current.newline = bufend;
				}
			}
		} else {
			/* There is no more text in the buffer. */
			current.newline = bufend;
		}
		if (current.newline >= bufend) {
			/*
			 * There is no more text in the buffer,
			 * or no new line was found.
			 */
			switch (file_stat) {
			case MORE:	/* file partly unread */
			case BEGIN:
				fgetfile(&current);

				current.ln--;
				continue; /* with while loop */
			case NO_MORE:
				break;
			}
			/* Nothing more to read in for this file. */
			if (current.newline <= current.prntbuf) {
				/* Nothing in the buffer, either */
				/* We are done with the file. */
				current.ln--;
				break; /* out of while loop */
			}
			/* There is no NL at the end of the file */
		}

		matched = pattern_match(&match_pattern, &current);
		if (matched) {
			int nc;

			get_ncount(&current, match_pattern.loc1);
			get_line(&current, match_pattern.loc2);

			nc = current.newline + 1 - current.prntbuf;
			(void) fprintf(output, format, file, current.ln);
			(void) fwrite((char *)current.prntbuf, 1, nc, output);
		} else {
			if (all_searched)
				break; /* out of while loop */

			get_ncount(&current, current.newline + 1);
		}
	}

	(void) close(file_desc);
	return (0);
}

static void
init_file(LINE *cur_ptr)
{
	file_stat = BEGIN;
	cur_ptr->ln = 0;
	bufend = buffer;
	cur_ptr->newline = buffer - 1;
}

static BOOL
pattern_match(PATTERN *pat, LINE *lptr)
{
	if ((*pat->procfn)(pat, lptr->prntbuf - 1, lptr->newline + 1,
	    &pat->loc1, &pat->loc2)) {
		return (YES);
	} else {
		pat->loc1 = lptr->prntbuf;
		pat->loc2 = lptr->newline - 1;
		return (NO);
	}
} /* end of function pattern_match() */

static void
fgetfile(LINE *cur_ptr)
{
	/*
	 * This function reads as much of the current file into the buffer
	 * as will fit.
	 */
	int	bytes;	  /* bytes read in current buffer */
	int	bufsize = MAXBUFSIZE; /* free space in data buffer */
	int 	save_current;
	uchar_t	*begin = cur_ptr->prntbuf;

	/*
	 * Bytes of current incomplete line, if any, save_current in buffer.
	 * These must be saved.
	 */
	save_current = (int)(bufend - begin);

	if (file_stat == MORE) {
		/*
		 * A portion of the file fills the buffer. We must clear
		 * out the dead wood to make room for more of the file.
		 */

		int k = 0;

		k = begin - buffer;
		if (!k) {
			/*
			 * We have one humungous current line,
			 * which fills the whole buffer.
			 * Toss it.
			 */
			begin = bufend;
			k = begin - buffer;
			save_current = 0;
		}

		begin = buffer;
		bufend = begin + save_current;

		bufsize = MAXBUFSIZE - save_current;

		if (save_current > 0) {
			/*
			 * Must save portion of current line.
			 * Copy to beginning of buffer.
			 */
			(void) memmove(buffer, buffer + k, save_current);
		}
	}

	/* Now read in the file. */

	do {
		bytes = read(file_desc, (char *)bufend, (unsigned int)bufsize);
		if (bytes < 0) {
			/* can't read any more of file */
			bytes = 0;
		}
		bufend += bytes;
		bufsize -= bytes;
	} while (bytes > 0 && bufsize > 0);


	if (begin >= bufend) {
		/* No new lines or incomplete line in buffer */
		file_stat = NO_MORE;
	} else if (bufsize) {
		/* Still space in the buffer, so we have read entire file */
		file_stat = NO_MORE;
	} else {
		/* We filled entire buffer, so there may be more yet to read */
		file_stat = MORE;
	}
		/* Note: bufend is 1 past last good char */
	*bufend = NL;	/* Sentinel new-line character */
	/* Set newline to character preceding the current line */
	cur_ptr->newline = begin - 1;
}

static void
get_line(LINE *cur_ptr, uchar_t *s)
{
	while (*s++ != NL) {
	}
	cur_ptr->newline = --s;
	cur_ptr->ln++;
}

static void
get_ncount(LINE *cur_ptr, uchar_t *s)
{
	uchar_t	*p = cur_ptr->prntbuf;

	while (*--s != NL) {
	}
	cur_ptr->newline = s++;
	while ((s > p) &&
	    (p = (uchar_t *)memchr((char *)p, NL, s - p)) != NULL) {
		cur_ptr->ln++;
		++p;
	}
	cur_ptr->ln--;
	cur_ptr->prntbuf = s;
}