/*	$OpenBSD: search.c,v 1.14 2016/08/14 21:47:16 guenther Exp $	*/

/*-

 * Copyright (c) 1992, 1993, 1994

 *	The Regents of the University of California.  All rights reserved.

 * Copyright (c) 1992, 1993, 1994, 1995, 1996

 *	Keith Bostic.  All rights reserved.

 *

 * See the LICENSE file for redistribution information.

 */

#include "config.h"

#include <sys/types.h>

#include <sys/queue.h>

#include <bitstring.h>

#include <ctype.h>

#include <errno.h>

#include <limits.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include "common.h"

typedef enum { S_EMPTY, S_EOF, S_NOPREV, S_NOTFOUND, S_SOF, S_WRAP } smsg_t;

static void	search_msg(SCR *, smsg_t);

static int	search_init(SCR *, dir_t, char *, size_t, char **, u_int);

/*

 * search_init --

 *	Set up a search.

 */

static int

search_init(SCR *sp, dir_t dir, char *ptrn, size_t plen, char **epp,

    u_int flags)

{

	int delim;

	char *p, *t;

	/* If the file is empty, it's a fast search. */

		}

	}

		/*

		 * Use the saved pattern if no pattern specified, or if only

		 * one or two delimiter characters specified.

		 *

		 * !!!

		 * Historically, only the pattern itself was saved, vi didn't

		 * preserve addressing or delta information.

		 */

			goto prev;

			goto prev;

		}

			/* Complain if we don't have a previous pattern. */

			}

			/* Re-compile the search pattern if necessary. */

			/* Set the search direction. */

		}

		/*

		 * Set the delimiter, and move forward to the terminating

		 * delimiter, handling escaped delimiters.

		 *

		 * QUOTING NOTE:

		 * Only discard an escape character if it escapes a delimiter.

		 */

				break;

			}

			}

		}

	}

	/* Compile the RE. */

	/* Set the search direction. */

}

/*

 * f_search --

 *	Do a forward search.

 *

 * PUBLIC: int f_search(SCR *, MARK *, MARK *, char *, size_t, char **, u_int);

 */

int

f_search(SCR *sp, MARK *fm, MARK *rm, char *ptrn, size_t plen, char **eptrn,

    u_int flags)

{

	busy_t btype;

	recno_t lno;

	int cnt, eval, rval, wrapped = 0;

		lno = 1;

		coff = 0;

		/*

		 * If doing incremental search, start searching at the previous

		 * column, so that we search a minimal distance and still match

		 * special patterns, e.g., \< for beginning of a word.

		 *

		 * Otherwise, start searching immediately after the cursor.  If

		 * at the end of the line, start searching on the next line.

		 * This is incompatible (read bug fix) with the historic vi --

		 * searches for the '$' pattern never moved forward, and the

		 * "-t foo" didn't work if the 'f' was the first character in

		 * the file.

		 */

			coff = 0;

				}

				lno = 1;

				wrapped = 1;

			}

		} else

			coff = fm->cno + 1;

	}

	btype = BUSY_ON;

				break;

				btype = BUSY_UPDATE;

			}

			cnt = INTERRUPT_CHECK;

		}

				break;

			}

				break;

			}

			lno = 0;

			wrapped = 1;

		}

		/* If already at EOL, just keep going. */

			continue;

		/* Set the termination. */

		/* Search the line. */

			continue;

			else

			break;

		}

		/* Warn if the search wrapped. */

		/*

		 * If a change command, it's possible to move beyond the end

		 * of a line.  Historic vi generally got this wrong (e.g. try

		 * "c?$<cr>").  Not all that sure this gets it right, there

		 * are lots of strange cases.

		 */

		rval = 0;

	}

}

/*

 * b_search --

 *	Do a backward search.

 *

 * PUBLIC: int b_search(SCR *, MARK *, MARK *, char *, size_t, char **, u_int);

 */

int

b_search(SCR *sp, MARK *fm, MARK *rm, char *ptrn, size_t plen, char **eptrn,

    u_int flags)

{

	busy_t btype;

	int cnt, eval, rval, wrapped;

	/*

	 * If doing incremental search, set the "starting" position past the

	 * current column, so that we search a minimal distance and still

	 * match special patterns, e.g., \> for the end of a word.  This is

	 * safe when the cursor is at the end of a line because we only use

	 * it for comparison with the location of the match.

	 *

	 * Otherwise, start searching immediately before the cursor.  If in

	 * the first column, start search on the previous line.

	 */

			}

	}

	btype = BUSY_ON;

				break;

				btype = BUSY_UPDATE;

			}

			cnt = INTERRUPT_CHECK;

		}

				break;

			}

				break;

			}

				break;

				break;

			}

			wrapped = 1;

		}

			break;

		/* Set the termination. */

		/* Search the line. */

			continue;

			else

			break;

		}

		/* Check for a match starting past the cursor. */

			continue;

		/* Warn if the search wrapped. */

		/*

		 * We now have the first match on the line.  Step through the

		 * line character by character until find the last acceptable

		 * match.  This is painful, we need a better interface to regex

		 * to make this work.

		 */

		for (;;) {

				break;

			    REG_STARTEND);

				break;

				else

				goto err;

			}

				break;

		}

		/* See comment in f_search(). */

		else

			rm->cno = last;

		rval = 0;

	}

}

/*

 * search_msg --

 *	Display one of the search messages.

 */

static void

search_msg(SCR *sp, smsg_t msg)

{

	case S_EMPTY:

	case S_EOF:

		    "Reached end-of-file without finding the pattern");

	case S_NOPREV:

	case S_NOTFOUND:

	case S_SOF:

		    "Reached top-of-file without finding the pattern");

	case S_WRAP:

	default:

	}

}

/*

 * search_busy --

 *	Put up the busy searching message.

 *

 * PUBLIC: void search_busy(SCR *, busy_t);

 */

void

search_busy(SCR *sp, busy_t btype)

{

}