/*	$OpenBSD: ex_argv.c,v 1.20 2016/05/27 09:18:12 martijn Exp $	*/

/*-

 * Copyright (c) 1993, 1994

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

 * Copyright (c) 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 <dirent.h>

#include <errno.h>

#include <limits.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include "../common/common.h"

static int argv_alloc(SCR *, size_t);

static int argv_comp(const void *, const void *);

static int argv_fexp(SCR *, EXCMD *,

	char *, size_t, char *, size_t *, char **, size_t *, int);

static int argv_lexp(SCR *, EXCMD *, char *);

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

/*

 * argv_init --

 *	Build  a prototype arguments list.

 *

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

 */

int

argv_init(SCR *sp, EXCMD *excp)

{

	EX_PRIVATE *exp;

}

/*

 * argv_exp0 --

 *	Append a string to the argument list.

 *

 * PUBLIC: int argv_exp0(SCR *, EXCMD *, char *, size_t);

 */

int

argv_exp0(SCR *sp, EXCMD *excp, char *cmd, size_t cmdlen)

{

	EX_PRIVATE *exp;

}

/*

 * argv_exp1 --

 *	Do file name expansion on a string, and append it to the

 *	argument list.

 *

 * PUBLIC: int argv_exp1(SCR *, EXCMD *, char *, size_t, int);

 */

int

argv_exp1(SCR *sp, EXCMD *excp, char *cmd, size_t cmdlen, int is_bang)

{

	}

	/* If it's empty, we're done. */

				break;

			goto ret;

	} else

		goto ret;

}

/*

 * argv_exp2 --

 *	Do file name and shell expansion on a string, and append it to

 *	the argument list.

 *

 * PUBLIC: int argv_exp2(SCR *, EXCMD *, char *, size_t);

 */

int

argv_exp2(SCR *sp, EXCMD *excp, char *cmd, size_t cmdlen)

{

	int rval;

#define	SHELLECHO	"echo "

#define	SHELLOFFSET	(sizeof(SHELLECHO) - 1)

#if defined(DEBUG) && 0

	TRACE(sp, "file_argv: {%.*s}\n", (int)cmdlen, cmd);

#endif

		rval = 1;

	}

#if defined(DEBUG) && 0

	TRACE(sp, "before shell: %d: {%s}\n", len, bp);

#endif

	/*

	 * Do shell word expansion -- it's very, very hard to figure out what

	 * magic characters the user's shell expects.  Historically, it was a

	 * union of v7 shell and csh meta characters.  We match that practice

	 * by default, so ":read \%" tries to read a file named '%'.  It would

	 * make more sense to pass any special characters through the shell,

	 * but then, if your shell was csh, the above example will behave

	 * differently in nvi than in vi.  If you want to get other characters

	 * passed through to your shell, change the "meta" option.

	 *

	 * To avoid a function call per character, we do a first pass through

	 * the meta characters looking for characters that aren't expected

	 * to be there, and then we can ignore them in the user's argument.

	 */

	else {

				break;

					break;

		} else

					break;

	}

	/*

	 * If we found a meta character in the string, fork a shell to expand

	 * it.  Unfortunately, this is comparatively slow.  Historically, it

	 * didn't matter much, since users don't enter meta characters as part

	 * of pathnames that frequently.  The addition of filename completion

	 * broke that assumption because it's easy to use.  As a result, lots

	 * folks have complained that the expansion code is too slow.  So, we

	 * detect filename completion as a special case, and do it internally.

	 * Note that this code assumes that the <asterisk> character is the

	 * match-anything meta character.  That feels safe -- if anyone writes

	 * a shell that doesn't follow that convention, I'd suggest giving them

	 * a festive hot-lead enema.

	 */

	case 0:

	case 1:

		}

		/* FALLTHROUGH */

	default:

			rval = 1;

		}

	}

}

/*

 * argv_exp3 --

 *	Take a string and break it up into an argv, which is appended

 *	to the argument list.

 *

 * PUBLIC: int argv_exp3(SCR *, EXCMD *, char *, size_t);

 */

int

argv_exp3(SCR *sp, EXCMD *excp, char *cmd, size_t cmdlen)

{

	EX_PRIVATE *exp;

	size_t len;

	int ch, off;

	char *ap, *p;

		/* Skip any leading whitespace. */

				break;

		}

			break;

		/*

		 * Determine the length of this whitespace delimited

		 * argument.

		 *

		 * QUOTING NOTE:

		 *

		 * Skip any character preceded by the user's quoting

		 * character.

		 */

				break;

		}

		/*

		 * Copy the argument into place.

		 *

		 * QUOTING NOTE:

		 *

		 * Lose quote chars.

		 */

	}

#if defined(DEBUG) && 0

	for (cnt = 0; cnt < exp->argsoff; ++cnt)

		TRACE(sp, "arg %d: {%s}\n", cnt, exp->argv[cnt]);

#endif

}

/*

 * argv_fexp --

 *	Do file name and bang command expansion.

 */

static int

argv_fexp(SCR *sp, EXCMD *excp, char *cmd, size_t cmdlen, char *p,

    size_t *lenp, char **bpp, size_t *blenp, int is_bang)

{

	EX_PRIVATE *exp;

	char *bp, *t;

	/* Replace file name characters. */

		case '!':

				goto ins_ch;

				    "No previous command to replace \"!\"");

			}

		case '%':

				    "No filename to substitute for %%");

			}

		case '#':

				    "No filename to substitute for #");

			}

		case '\\':

			/*

			 * QUOTING NOTE:

			 *

			 * Strip any backslashes that protected the file

			 * expansion characters.

			 */

			}

			/* FALLTHROUGH */

		default:

		}

	/* Nul termination. */

	/* Return the new string length, buffer, buffer length. */

}

/*

 * argv_alloc --

 *	Make more space for arguments.

 */

static int

argv_alloc(SCR *sp, size_t len)

{

	ARGS *ap;

	EX_PRIVATE *exp;

	int cnt, off;

	/*

	 * Allocate room for another argument, always leaving

	 * enough room for an ARGS structure with a length of 0.

	 */

#define	INCREMENT	20

		}

	}

	/* First argument. */

			goto mem;

	}

	/* First argument buffer. */

		}

	}

	/* Second argument. */

			goto mem;

	}

	/* 0 length serves as end-of-argument marker. */

}

/*

 * argv_free --

 *	Free up argument structures.

 *

 * PUBLIC: int argv_free(SCR *);

 */

int

argv_free(SCR *sp)

{

	EX_PRIVATE *exp;

	int off;

				continue;

		}

	}

}

/*

 * argv_lexp --

 *	Find all file names matching the prefix and append them to the

 *	buffer.

 */

static int

argv_lexp(SCR *sp, EXCMD *excp, char *path)

{

	struct dirent *dp;

	DIR *dirp;

	EX_PRIVATE *exp;

	int off;

	size_t dlen, nlen;

	char *dname, *name, *p;

	/* Set up the name and length for comparison. */

		dname = ".";

		dlen = 0;

		name = path;

			dname = "/";

			dlen = 1;

			dname = path;

		}

	}

	}

				continue;

		} else {

				continue;

		}

		/* Directory + name + slash + null. */

		}

	}

		/*

		 * If we didn't find a match, complain that the expansion

		 * failed.  We can't know for certain that's the error, but

		 * it's a good guess, and it matches historic practice.

		 */

	}

}

/*

 * argv_comp --

 *	Alphabetic comparison.

 */

static int

argv_comp(const void *a, const void *b)

{

}

/*

 * argv_sexp --

 *	Fork a shell, pipe a command through it, and read the output into

 *	a buffer.

 */

static int

argv_sexp(SCR *sp, char **bpp, size_t *blenp, size_t *lenp)

{

	enum { SEXP_ERR, SEXP_EXPANSION_ERR, SEXP_OK } rval;

	FILE *ifp;

	pid_t pid;

	size_t blen, len;

	char *bp, *p, *sh, *sh_path;

	/* Secure means no shell access. */

"Shell expansions not supported when the secure edit option is set");

	}

	else

	/* Local copies of the buffer variables. */

	/*

	 * There are two different processes running through this code, named

	 * the utility (the shell) and the parent. The utility reads standard

	 * input and writes standard output and standard error output.  The

	 * parent writes to the utility, reads its standard output and ignores

	 * its standard error output.  Historically, the standard error output

	 * was discarded by vi, as it produces a lot of noise when file patterns

	 * don't match.

	 *

	 * The parent reads std_output[0], and the utility writes std_output[1].

	 */

	ifp = NULL;

	}

	}

	/*

	 * Do the minimal amount of work possible, the shell is going to run

	 * briefly and then exit.  We sincerely hope.

	 */

	case -1:			/* Error. */

	case 0:				/* Utility. */

		/* Redirect stdout to the write end of the pipe. */

		/* Close the utility's file descriptors. */

		/*

		 * XXX

		 * Assume that all shells have -c.

		 */

	default:			/* Parent. */

		/* Close the pipe ends the parent won't use. */

		break;

	}

	/*

	 * Copy process standard output into a buffer.

	 *

	 * !!!

	 * Historic vi apparently discarded leading \n and \r's from

	 * the shell output stream.  We don't on the grounds that any

	 * shell that does that is broken.

	 */

		}

	/* Delete the final newline, nul terminate the string. */

	}

		goto ioerr;

alloc_err:	rval = SEXP_ERR;

		rval = SEXP_OK;

	/*

	 * Wait for the process.  If the shell process fails (e.g., "echo $q"

	 * where q wasn't a defined variable) or if the returned string has

	 * no characters or only blank characters, (e.g., "echo $5"), complain

	 * that the shell expansion failed.  We can't know for certain that's

	 * the error, but it's a good guess, and it matches historic practice.

	 * This won't catch "echo foo_$5", but that's not a common error and

	 * historic vi didn't catch it either.

	 */

			break;

}