/*	$OpenBSD: ex_subst.c,v 1.30 2017/04/18 01:45:35 deraadt 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/queue.h>

#include <sys/time.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/common.h"

#include "../vi/vi.h"

#define MAXIMUM(a, b)	(((a) > (b)) ? (a) : (b))

#define	SUB_FIRST	0x01		/* The 'r' flag isn't reasonable. */

#define	SUB_MUSTSETR	0x02		/* The 'r' flag is required. */

static int re_conv(SCR *, char **, size_t *, int *);

static int re_sub(SCR *, char *, char **, size_t *, size_t *, regmatch_t [10]);

static int re_tag_conv(SCR *, char **, size_t *, int *);

static int s(SCR *, EXCMD *, char *, regex_t *, u_int);

/*

 * ex_s --

 *	[line [,line]] s[ubstitute] [[/;]pat[/;]/repl[/;] [cgr] [count] [#lp]]

 *

 *	Substitute on lines matching a pattern.

 *

 * PUBLIC: int ex_s(SCR *, EXCMD *);

 */

int

ex_s(SCR *sp, EXCMD *cmdp)

{

	regex_t *re;

	u_int flags;

	int delim;

	char *bp, *ptrn, *rep, *p, *t;

	/*

	 * Skip leading white space.

	 *

	 * !!!

	 * Historic vi allowed any non-alphanumeric to serve as the

	 * substitution command delimiter.

	 *

	 * !!!

	 * If the arguments are empty, it's the same as &, i.e. we

	 * repeat the last substitution.

	 */

		goto subagain;

			break;

	}

	/*

	 * !!!

	 * The full-blown substitute command reset the remembered

	 * state of the 'c' and 'g' suffices.

	 */

	/*

	 * Get the pattern string, toss escaping characters.

	 *

	 * !!!

	 * Historic vi accepted any of the following forms:

	 *

	 *	:s/abc/def/		change "abc" to "def"

	 *	:s/abc/def		change "abc" to "def"

	 *	:s/abc/			delete "abc"

	 *	:s/abc			delete "abc"

	 *

	 * QUOTING NOTE:

	 *

	 * Only toss an escaping character if it escapes a delimiter.

	 * This means that "s/A/\\\\f" replaces "A" with "\\f".  It

	 * would be nice to be more regular, i.e. for each layer of

	 * escaping a single escaping character is removed, but that's

	 * not how the historic vi worked.

	 */

			/*

			 * !!!

			 * Nul terminate the pattern string -- it's passed

			 * to regcomp which doesn't understand anything else.

			 */

			break;

		}

		}

	}

	/*

	 * If the pattern string is empty, use the last RE (not just the

	 * last substitution RE).

	 */

		}

		/* Re-compile the RE if necessary. */

		flags = 0;

		/*

		 * !!!

		 * Compile the RE.  Historic practice is that substitutes set

		 * the search direction as well as both substitute and search

		 * RE's.  We compile the RE twice, as we don't want to bother

		 * ref counting the pattern string and (opaque) structure.

		 */

		flags = SUB_FIRST;

	}

	/*

	 * Get the replacement string.

	 *

	 * The special character & (\& if O_MAGIC not set) matches the

	 * entire RE.  No handling of & is required here, it's done by

	 * re_sub().

	 *

	 * The special character ~ (\~ if O_MAGIC not set) inserts the

	 * previous replacement string into this replacement string.

	 * Count ~'s to figure out how much space we need.  We could

	 * special case nonexistent last patterns or whether or not

	 * O_MAGIC is set, but it's probably not worth the effort.

	 *

	 * QUOTING NOTE:

	 *

	 * Only toss an escaping character if it escapes a delimiter or

	 * if O_MAGIC is set and it escapes a tilde.

	 *

	 * !!!

	 * If the entire replacement pattern is "%", then use the last

	 * replacement pattern.  This semantic was added to vi in System

	 * V and then percolated elsewhere, presumably around the time

	 * that it was added to their version of ed(1).

	 */

	else {

				break;

			}

						goto tilde;

				}

			}

		}

			}

		}

	}

}

/*

 * ex_subagain --

 *	[line [,line]] & [cgr] [count] [#lp]]

 *

 *	Substitute using the last substitute RE and replacement pattern.

 *

 * PUBLIC: int ex_subagain(SCR *, EXCMD *);

 */

int

ex_subagain(SCR *sp, EXCMD *cmdp)

{

	}

}

/*

 * ex_subtilde --

 *	[line [,line]] ~ [cgr] [count] [#lp]]

 *

 *	Substitute using the last RE and last substitute replacement pattern.

 *

 * PUBLIC: int ex_subtilde(SCR *, EXCMD *);

 */

int

ex_subtilde(SCR *sp, EXCMD *cmdp)

{

	}

}

/*

 * s --

 * Do the substitution.  This stuff is *really* tricky.  There are lots of

 * special cases, and general nastiness.  Don't mess with it unless you're

 * pretty confident.

 *

 * The nasty part of the substitution is what happens when the replacement

 * string contains newlines.  It's a bit tricky -- consider the information

 * that has to be retained for "s/f\(o\)o/^M\1^M\1/".  The solution here is

 * to build a set of newline offsets which we use to break the line up later,

 * when the replacement is done.  Don't change it unless you're *damned*

 * confident.

 */

#define	NEEDNEWLINE(sp) {						\

	if ((sp)->newl_len == (sp)->newl_cnt) {				\

		(sp)->newl_len += 25;					\

		REALLOCARRAY((sp), (sp)->newl,				\

		    (sp)->newl_len, sizeof(size_t));			\

		if ((sp)->newl == NULL) {				\

			(sp)->newl_len = 0;				\

			return (1);					\

		}							\

	}								\

}

#define	BUILD(sp, l, len) {						\

	if (lbclen + (len) > lblen) {					\

		lblen += MAXIMUM(lbclen + (len), 256);			\

		REALLOC((sp), lb, lblen);				\

		if (lb == NULL) {					\

			lbclen = 0;					\

			return (1);					\

		}							\

	}								\

	memcpy(lb + lbclen, (l), (len));				\

	lbclen += (len);						\

}

#define	NEEDSP(sp, len, pnt) {						\

	if (lbclen + (len) > lblen) {					\

		lblen += MAXIMUM(lbclen + (len), 256);			\

		REALLOC((sp), lb, lblen);				\

		if (lb == NULL) {					\

			lbclen = 0;					\

			return (1);					\

		}							\

		(pnt) = lb + lbclen;					\

	}								\

}

static int

s(SCR *sp, EXCMD *cmdp, char *s, regex_t *re, u_int flags)

{

	recno_t elno, lno, slno;

	size_t offset, saved_offset, scno;

	int lflag, nflag, pflag, rflag;

	int didsub, do_eol_match, eflags, nempty, eval;

	int linechanged, matched, quit, rval;

	unsigned long ul;

	/*

	 * !!!

	 * Historically, the 'g' and 'c' suffices were always toggled as flags,

	 * so ":s/A/B/" was the same as ":s/A/B/ccgg".  If O_EDCOMPATIBLE was

	 * not set, they were initialized to 0 for all substitute commands.  If

	 * O_EDCOMPATIBLE was set, they were initialized to 0 only if the user

	 * specified substitute/replacement patterns (see ex_s()).

	 */

	/*

	 * Historic vi permitted the '#', 'l' and 'p' options in vi mode, but

	 * it only displayed the last change.  I'd disallow them, but they are

	 * useful in combination with the [v]global commands.  In the current

	 * model the problem is combining them with the 'c' flag -- the screen

	 * would have to flip back and forth between the confirm screen and the

	 * ex print screen, which would be pretty awful.  We do display all

	 * changes, though, for what that's worth.

	 *

	 * !!!

	 * Historic vi was fairly strict about the order of "options", the

	 * count, and "flags".  I'm somewhat fuzzy on the difference between

	 * options and flags, anyway, so this is a simpler approach, and we

	 * just take it them in whatever order the user gives them.  (The ex

	 * usage statement doesn't reflect this.)

	 */

	lflag = nflag = pflag = rflag = 0;

		goto noargs;

		case ' ':

		case '\t':

			continue;

		case '+':

		case '-':

		case '0': case '1': case '2': case '3': case '4':

		case '5': case '6': case '7': case '8': case '9':

				goto usage;

				else

			}

			/*

			 * In historic vi, the count was inclusive from the

			 * second address.

			 */

			break;

		case '#':

			nflag = 1;

		case 'c':

			/* Ex text structure initialization. */

			}

			break;

		case 'g':

		case 'l':

			lflag = 1;

		case 'p':

			pflag = 1;

		case 'r':

		    "Regular expression specified; r flag meaningless");

			}

			}

			rflag = 1;

		default:

			goto usage;

		}

	}

"The #, l and p flags may not be combined with the c flag in vi mode");

	}

	/*

	 * bp:		if interactive, line cache

	 * blen:	if interactive, line cache length

	 * lb:		build buffer pointer.

	 * lbclen:	current length of built buffer.

	 * lblen;	length of build buffer.

	 */

	/* For each line... */

		/* Someone's unhappy, time to stop. */

			break;

		/* Get the line. */

			goto err;

		/*

		 * Make a local copy if doing confirmation -- when calling

		 * the confirm routine we're likely to lose the cached copy.

		 */

			} else

		}

		/* Start searching from the beginning. */

		offset = 0;

		/* Reset the build buffer offset. */

		/* Reset empty match test variable. */

		nempty = -1;

		/*

		 * We don't want to have to do a setline if the line didn't

		 * change -- keep track of whether or not this line changed.

		 * If doing confirmations, don't want to keep setting the

		 * line if change is refused -- keep track of substitutions.

		 */

		didsub = linechanged = 0;

		/* New line, do an EOL match. */

		do_eol_match = 1;

		/* It's not nul terminated, but we pretend it is. */

		/* The search area is from s + offset to the EOL.  */

		/* Get the next match. */

		/*

		 * There wasn't a match or if there was an error, deal with

		 * it.  If there was a previous match in this line, resolve

		 * the changes into the database.  Otherwise, just move on.

		 */

			goto endmatch;

		}

		matched = 1;

		/* Only the first search can match an anchored expression. */

		/*

		 * !!!

		 * It's possible to match 0-length strings -- for example, the

		 * command s;a*;X;, when matched against the string "aabb" will

		 * result in "XbXbX", i.e. the matches are "aa", the space

		 * between the b's and the space between the b's and the end of

		 * the string.  There is a similar space between the beginning

		 * of the string and the a's.  The rule that we use (because vi

		 * historically used it) is that any 0-length match, occurring

		 * immediately after a match, is ignored.  Otherwise, the above

		 * example would have resulted in "XXbXbX".  Another example is

		 * incorrectly using " *" to replace groups of spaces with one

		 * space.

		 *

		 * If the match is empty and at the same place as the end of the

		 * previous match, ignore the match and move forward.  If

		 * there's no more characters in the string, we were

		 * attempting to match after the last character, so quit.

		 */

			nempty = -1;

				goto endmatch;

		}

		/* Confirm change. */

			/*

			 * Set the cursor position for confirmation.  Note,

			 * if we matched on a '$', the cursor may be past

			 * the end of line.

			 */

			/*

			 * Both ex and vi have to correct for a change before

			 * the first character in the line.

			 */

				/*

				 * Only vi has to correct for a change after

				 * the last character in the line.

				 *

				 * XXX

				 * It would be nice to change the vi code so

				 * that we could display a cursor past EOL.

				 */

					goto err;

					goto err;

				case E_CHARACTER:

					break;

				case E_EOF:

				case E_ERR:

				case E_INTERRUPT:

					goto lquit;

				default:

				}

			} else {

					goto lquit;

					goto err;

			}

			case CH_YES:

				break;

			default:

			case CH_NO:

				didsub = 0;

			case CH_QUIT:

				/* Set the quit/interrupted flags. */

lquit:				quit = 1;

				/*

				 * Resolve any changes, then return to (and

				 * exit from) the main loop.

				 */

			}

		}

		/*

		 * Set the cursor to the last position changed, converting

		 * from 1-based to 0-based.

		 */

		/* Copy the bytes before the match into the build buffer. */

		/* Substitute the matching bytes. */

		didsub = 1;

			goto err;

		/* Set the change flag so we know this line was modified. */

		/* Move past the matched bytes. */

		/* A match cannot be followed by an empty pattern. */

		/*

		 * If doing a global change with confirmation, we have to

		 * update the screen.  The basic idea is to store the line

		 * so the screen update routines can find it, and restart.

		 */

			/*

			 * The new search offset will be the end of the

			 * modified line.

			 */

			/* Copy the rest of the line. */

			/* Set the new offset. */

			offset = saved_offset;

			/* Store inserted lines, adjusting the build buffer. */

			last = 0;

						goto err;

				}

			}

			/* Store and retrieve the line. */

				goto err;

				goto err;

			/* Restart the build. */

			/*

			 * If we haven't already done the after-the-string

			 * match, do one.  Set REG_NOTEOL so the '$' pattern

			 * only matches once.

			 */

				goto endmatch;

				do_eol_match = 0;

			}

		}

		/*

		 * If it's a global:

		 *

		 * If at the end of the string, do a test for the after

		 * the string match.  Set REG_NOTEOL so the '$' pattern

		 * only matches once.

		 */

				do_eol_match = 0;

			}

		}

			continue;

		/* Copy any remaining bytes into the build buffer. */

		/* Store inserted lines, adjusting the build buffer. */

		last = 0;

					goto err;

			}

		}

		/* Store the changed line. */

			goto err;

		/* Update changed line counter. */

		}

		/*

		 * !!!

		 * Display as necessary.  Historic practice is to only

		 * display the last line of a line split into multiple

		 * lines.

		 */

		}

	}

	/*

	 * !!!

	 * Historically, vi attempted to leave the cursor at the same place if

	 * the substitution was done at the current cursor position.  Otherwise

	 * it moved it to the first non-blank of the last line changed.  There

	 * were some problems: for example, :s/$/foo/ with the cursor on the

	 * last character of the line left the cursor on the last character, or

	 * the & command with multiple occurrences of the matching string in the

	 * line usually left the cursor in a fairly random position.

	 *

	 * We try to do the same thing, with the exception that if the user is

	 * doing substitution with confirmation, we move to the last line about

	 * which the user was consulted, as opposed to the last line that they

	 * actually changed.  This prevents a screen flash if the user doesn't

	 * change many of the possible lines.

	 */

	}

	/*

	 * If not in a global command, and nothing matched, say so.

	 * Else, if none of the lines displayed, put something up.

	 */

	rval = 0;

		}

	if (0) {

err:		rval = 1;

	}

}

/*

 * re_compile --

 *	Compile the RE.

 *

 * PUBLIC: int re_compile(SCR *,

 * PUBLIC:     char *, size_t, char **, size_t *, regex_t *, u_int);

 */

int

re_compile(SCR *sp, char *ptrn, size_t plen, char **ptrnp, size_t *lenp,

    regex_t *rep, u_int flags)

{

	size_t len;

	char *p;

	/* Set RE flags. */

	reflags = 0;

					break;

		}

	}

	/* If we're replacing a saved value, clear the old one. */

	}

	}

	/*

	 * If we're saving the string, it's a pattern we haven't seen before,

	 * so convert the vi-style RE's to POSIX 1003.2 RE's.  Save a copy for

	 * later recompilation.   Free any previously saved value.

	 */

		} else

		/* Discard previous pattern. */

		/*

		 * Copy the string into allocated memory.

		 *

		 * XXX

		 * Regcomp isn't 8-bit clean, so the pattern is nul-terminated

		 * for now.  There's just no other solution.

		 */

		}

		/* Free up conversion-routine-allocated memory. */

	}

	/*

	 * XXX

	 * Regcomp isn't 8-bit clean, so we just lost if the pattern

	 * contained a nul.  Bummer!

	 */

	}

}

/*

 * re_conv --

 *	Convert vi's regular expressions into something that the

 *	the POSIX 1003.2 RE functions can handle.

 *

 * There are two conversions we make to make vi's RE's (specifically

 * the global, search, and substitute patterns) work with POSIX RE's.

 * We assume that \<ptrn\> does "word" searches, which is non-standard

 * but supported by most regexp libraries..

 *

 * 1: If O_MAGIC is not set, strip backslashes from the magic character

 *    set (.[*~) that have them, and add them to the ones that don't.

 * 2: If O_MAGIC is not set, the string "\~" is replaced with the text

 *    from the last substitute command's replacement string.  If O_MAGIC

 *    is set, it's the string "~".

 *

 * !!!/XXX

 * This doesn't exactly match the historic behavior of vi because we do

 * the ~ substitution before calling the RE engine, so magic characters

 * in the replacement string will be expanded by the RE engine, and they

 * weren't historically.  It's a bug.

 */

static int

re_conv(SCR *sp, char **ptrnp, size_t *plenp, int *replacedp)

{

	int magic;

	char *bp, *p, *t;

	/*

	 * First pass through, we figure out how much space we'll need.