/*	$OpenBSD: re_search.c,v 1.33 2017/08/06 04:39:45 bcallah Exp $	*/

/* This file is in the public domain. */

/*

 *	regular expression search commands for Mg

 *

 * This file contains functions to implement several of gnuemacs's regular

 * expression functions for Mg.  Several of the routines below are just minor

 * re-arrangements of Mg's non-regular expression search functions.  Some of

 * them are similar in structure to the original MicroEMACS, others are

 * modifications of Rich Ellison's code.  Peter Newton re-wrote about half of

 * them from scratch.

 */

#ifdef REGEX

#include <sys/queue.h>

#include <sys/types.h>

#include <regex.h>

#include <signal.h>

#include <stdio.h>

#include <string.h>

#include "def.h"

#include "macro.h"

#define SRCH_BEGIN	(0)		/* search sub-codes		    */

#define SRCH_FORW	(-1)

#define SRCH_BACK	(-2)

#define SRCH_NOPR	(-3)

#define SRCH_ACCM	(-4)

#define SRCH_MARK	(-5)

#define RE_NMATCH	10		/* max number of matches	    */

#define REPLEN		256		/* max length of replacement string */

char	re_pat[NPAT];			/* regex pattern		    */

int	re_srch_lastdir = SRCH_NOPR;	/* last search flags		    */

int	casefoldsearch = TRUE;		/* does search ignore case?	    */

static int	 re_doreplace(RSIZE, char *);

static int	 re_forwsrch(void);

static int	 re_backsrch(void);

static int	 re_readpattern(char *);

static int	 killmatches(int);

static int	 countmatches(int);

/*

 * Search forward.

 * Get a search string from the user and search for it starting at ".".  If

 * found, move "." to just after the matched characters.  display does all

 * the hard stuff.  If not found, it just prints a message.

 */

/* ARGSUSED */

int

re_forwsearch(int f, int n)

{

	int	s;

	}

}

/*

 * Reverse search.

 * Get a search string from the user, and search, starting at "."

 * and proceeding toward the front of the buffer. If found "." is left

 * pointing at the first character of the pattern [the last character that

 * was matched].

 */

/* ARGSUSED */

int

re_backsearch(int f, int n)

{

	int	s;

	}

}

/*

 * Search again, using the same search string and direction as the last search

 * command.  The direction has been saved in "srch_lastdir", so you know which

 * way to go.

 *

 * XXX: This code has problems -- some incompatibility(?) with extend.c causes

 * match to fail when it should not.

 */

/* ARGSUSED */

int

re_searchagain(int f, int n)

{

	}

		}

	}

		}

}

/* Compiled regex goes here-- changed only when new pattern read */

static regex_t		regex_buff;

static regmatch_t	regex_match[RE_NMATCH];

/*

 * Re-Query Replace.

 *	Replace strings selectively.  Does a search and replace operation.

 */

/* ARGSUSED */

int

re_queryrepl(int f, int n)

{

	int	rcnt = 0;		/* replacements made so far	*/

	int	plen, s;		/* length of found string	*/

	/*

	 * Search forward repeatedly, checking each time whether to insert

	 * or not.  The "!" case makes the check always true, so it gets put

	 * into a tighter loop for efficiency.

	 */

retry:

		case ' ':

		case '.':

		case CCHR('G'):				/* ^G */

		case CCHR('['):				/* ESC */

		case '`':

			goto stopsearch;

		case '!':

			do {

			goto stopsearch;

		case CCHR('?'):				/* To not replace */

			break;

		default:

		}

	}

stopsearch:

		else

	}

}

/*

 * Routine re_doreplace calls lreplace to make replacements needed by

 * re_query replace.  Its reason for existence is to deal with \1, \2. etc.

 *  plen: length to remove

 *  st:   replacement string

 */

static int

re_doreplace(RSIZE plen, char *st)

{

	int	 j, k, s, more, num, state;

	struct line	*clp;

	more = TRUE;

	j = 0;

	state = 0;

	num = 0;

	/* The following FSA parses the replacement string */

		case 0:

				state = 1;

			else {

			}

			break;

		case 1:

				state = 2;

			else {

				state = 0;

			}

			break;

		case 2:

				j += k;

					state = 1;

					state = 0;

				}

			}

			break;

		}		/* switch (state) */

	}			/* while (more)   */

}

/*

 * This routine does the real work of a forward search.  The pattern is

 * sitting in the external variable "pat".  If found, dot is updated, the

 * window system is notified of the change, and TRUE is returned.  If the

 * string isn't found, FALSE is returned.

 */

static int

re_forwsrch(void)

{

	int	 tbo, tdotline, error;

	struct line	*clp;

		/*

		 * Don't start matching past end of line -- must move to

		 * beginning of next line, unless at end of file.

		 */

			tbo = 0;

		}

	/*

	 * Note this loop does not process the last line, but this editor

	 * always makes the last line empty so this is good.

	 */

		    REG_STARTEND);

			tbo = 0;

		} else {

		}

	}

}

/*

 * This routine does the real work of a backward search.  The pattern is sitting

 * in the external variable "re_pat".  If found, dot is updated, the window

 * system is notified of the change, and TRUE is returned.  If the string isn't

 * found, FALSE is returned.

 */

static int

re_backsrch(void)

{

	struct line		*clp;

	int		 tbo, tdotline;

	regmatch_t	 lastmatch;

	/* Start search one position to the left of dot */

		/* must move up one line */

	}

	/*

	 * Note this loop does not process the last line, but this editor

	 * always makes the last line empty so this is good.

	 */

		lastmatch.rm_so = -1;

		/*

		 * Keep searching until we don't match any longer.  Assumes a

		 * non-match does not modify the regex_match array.  We have to

		 * do this character-by-character after the first match since

		 * POSIX regexps don't give you a way to do reverse matches.

		 */

		}

		} else {

		}

	}

}

/*

 * Read a pattern.

 * Stash it in the external variable "re_pat". The "pat" is

 * not updated if the user types in an empty line. If the user typed

 * an empty line, and there is no old pattern, it is an error.

 * Display the old pattern, in the style of Jeff Lomicka. There is

 * some do-it-yourself control expansion.

 */

static int

re_readpattern(char *re_prompt)

{

	static int	dofree = 0;

	int		flags, error, s;

	else

		    EFNUL | EFNEW | EFCR, re_prompt, re_pat);

		/* New pattern given */

		else

			flags = REG_EXTENDED;

			return (FALSE);

		}

		s = TRUE;

		/* Just using old pattern */

	else

		s = FALSE;

}

/*

 * Cause case to not matter in searches.  This is the default.	If called

 * with argument cause case to matter.

 */

/* ARGSUSED*/

int

setcasefold(int f, int n)

{

	}

	/*

	 * Invalidate the regular expression pattern since I'm too lazy to

	 * recompile it.

	 */

}

/*

 * Delete all lines after dot that contain a string matching regex.

 */

/* ARGSUSED */

int

delmatchlines(int f, int n)

{

	int	s;

}

/*

 * Delete all lines after dot that don't contain a string matching regex.

 */

/* ARGSUSED */

int

delnonmatchlines(int f, int n)

{

	int	s;

}

/*

 * This function does the work of deleting matching lines.

 */

static int

killmatches(int cond)

{

	int	 s, error;

	int	 count = 0;

	struct line	*clp;

		/* Consider dot on next line */

		/* see if line matches */

		    REG_STARTEND);

		/* Delete line when appropriate */

		} else

	}

}

/*

 * Count lines matching regex.

 */

/* ARGSUSED */

int

cntmatchlines(int f, int n)

{

	int	s;

}

/*

 * Count lines that fail to match regex.

 */

/* ARGSUSED */

int

cntnonmatchlines(int f, int n)

{

	int	s;

}

/*

 * This function does the work of counting matching lines.

 */

int

countmatches(int cond)

{

	int	 error;

	int	 count = 0;

	struct line	*clp;

		/* Consider dot on next line */

		/* see if line matches */

		    REG_STARTEND);

		/* Count line when appropriate */

	}

	else

}

#endif	/* REGEX */