/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 * Common Development and Distribution License (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) 2012 Joyent, Inc. All rights reserved.

 */

/*

 * This file contains all of the interfaces for mdb's tab completion engine.

 * Currently some interfaces are private to mdb and its internal implementation,

 * those are in mdb_tab.h. Other pieces are public interfaces. Those are in

 * mdb_modapi.h.

 *

 * Memory allocations in tab completion context have to be done very carefully.

 * We need to think of ourselves as the same as any other command that is being

 * executed by the user, which means we must use UM_GC to handle being

 * interrupted.

 */

#include <mdb/mdb_modapi.h>

#include <mdb/mdb_ctf.h>

#include <mdb/mdb_ctf_impl.h>

#include <mdb/mdb_string.h>

#include <mdb/mdb_module.h>

#include <mdb/mdb_debug.h>

#include <mdb/mdb_print.h>

#include <mdb/mdb_nv.h>

#include <mdb/mdb_tab.h>

#include <mdb/mdb.h>

#include <ctype.h>

/*

 * There may be another way to do this, but this works well enough.

 */

#define	COMMAND_SEPARATOR "::"

/*

 * find_command_start --

 *

 * 	Given a buffer find the start of the last command.

 */

static char *

tab_find_command_start(char *buf)

{

	char *offset = strstr(buf, COMMAND_SEPARATOR);

	if (offset == NULL)

		return (NULL);

	for (;;) {

		char *next = strstr(offset + strlen(COMMAND_SEPARATOR),

		    COMMAND_SEPARATOR);

		if (next == NULL) {

			return (offset);

		}

		offset = next;

	}

}

/*

 * get_dcmd --

 *

 * 	Given a buffer containing a command and its argument return

 * 	the name of the command and the offset in the buffer where

 * 	the command arguments start.

 *

 * 	Note: This will modify the buffer.

 */

char *

tab_get_dcmd(char *buf, char **args, uint_t *flags)

{

	char *start = buf + strlen(COMMAND_SEPARATOR);

	char *separator = start;

	const char *end = buf + strlen(buf);

	uint_t space = 0;

	while (separator < end && !isspace(*separator))

		separator++;

	if (separator == end) {

		*args = NULL;

	} else {

		if (isspace(*separator))

			space = 1;

		*separator++ = '\0';

		*args = separator;

	}

	if (space)

		*flags |= DCMD_TAB_SPACE;

	return (start);

}

/*

 * count_args --

 *

 * 	Given a buffer containing dmcd arguments return the total number

 * 	of arguments.

 *

 * 	While parsing arguments we need to keep track of whether or not the last

 * 	arguments ends with a trailing space.

 */

static int

tab_count_args(const char *input, uint_t *flags)

{

	const char *index;

	int argc = 0;

	uint_t space = *flags & DCMD_TAB_SPACE;

	index = input;

	while (*index != '\0') {

		while (*index != '\0' && isspace(*index)) {

			index++;

			space = 1;

		}

		if (*index != '\0' && !isspace(*index)) {

			argc++;

			space = 0;

			while (*index != '\0' && !isspace (*index)) {

				index++;

			}

		}

	}

	if (space)

		*flags |= DCMD_TAB_SPACE;

	else

		*flags &= ~DCMD_TAB_SPACE;

	return (argc);

}

/*

 * copy_args --

 *

 * 	Given a buffer containing dcmd arguments and an array of mdb_arg_t's

 * 	initialize the string value of each mdb_arg_t.

 *

 * 	Note: This will modify the buffer.

 */

static int

tab_copy_args(char *input, int argc, mdb_arg_t *argv)

{

	int i = 0;

	char *index;

	index = input;

	while (*index) {

		while (*index && isspace(*index)) {

			index++;

		}

		if (*index && !isspace(*index)) {

			char *end = index;

			while (*end && !isspace(*end)) {

				end++;

			}

			if (*end) {

				*end++ = '\0';

			}

			argv[i].a_type = MDB_TYPE_STRING;

			argv[i].a_un.a_str = index;

			index = end;

			i++;

		}

	}

	if (i != argc)

		return (-1);

	return (0);

}

/*

 * parse-buf --

 *

 * 	Parse the given buffer and return the specified dcmd, the number

 * 	of arguments, and array of mdb_arg_t containing the argument

 * 	values.

 *

 * 	Note: this will modify the specified buffer. Caller is responisble

 * 	for freeing argvp.

 */

static int

tab_parse_buf(char *buf, char **dcmdp, int *argcp, mdb_arg_t **argvp,

    uint_t *flags)

{

	char *data = tab_find_command_start(buf);

	char *args_data = NULL;

	char *dcmd = NULL;

	int argc = 0;

	mdb_arg_t *argv = NULL;

	if (data == NULL) {

		return (-1);

	}

	dcmd = tab_get_dcmd(data, &args_data, flags);

	if (dcmd == NULL) {

		return (-1);

	}

	if (args_data != NULL) {

		argc = tab_count_args(args_data, flags);

		if (argc != 0) {

			argv = mdb_alloc(sizeof (mdb_arg_t) * argc,

			    UM_SLEEP | UM_GC);

			if (tab_copy_args(args_data, argc, argv) == -1)

				return (-1);

		}

	}

	*dcmdp = dcmd;

	*argcp = argc;

	*argvp = argv;

	return (0);

}

/*

 * tab_command --

 *

 * 	This function is executed anytime a tab is entered. It checks

 * 	the current buffer to determine if there is a valid dmcd,

 * 	if that dcmd has a tab completion handler it will invoke it.

 *

 *	This function returns the string (if any) that should be added to the

 *	existing buffer to complete it.

 */

int

mdb_tab_command(mdb_tab_cookie_t *mcp, const char *buf)

{

	char *data;

	char *dcmd = NULL;

	int argc = 0;

	mdb_arg_t *argv = NULL;

	int ret = 0;

	mdb_idcmd_t *cp;

	uint_t flags = 0;

	/*

	 * Parsing the command and arguments will modify the buffer

	 * (replacing spaces with \0), so make a copy of the specified

	 * buffer first.

	 */

	data = mdb_alloc(strlen(buf) + 1, UM_SLEEP | UM_GC);

	(void) strcpy(data, buf);

	/*

	 * Get the specified dcmd and arguments from the buffer.

	 */

	ret = tab_parse_buf(data, &dcmd, &argc, &argv, &flags);

	if (ret != 0) {

		goto out;

	}

	/*

	 * Check to see if the buffer contains a valid dcmd

	 */

	cp = mdb_dcmd_lookup(dcmd);

	/*

	 * When argc is zero it indicates that we are trying to tab complete

	 */

	if (cp == NULL && argc != 0) {

		goto out;

	}

	/*

	 * Invoke the command specific tab completion handler or the built in

	 * dcmd one if there is no dcmd.

	 */

	if (cp == NULL)

		(void) mdb_tab_complete_dcmd(mcp, dcmd);

	else

		mdb_call_tab(cp, mcp, flags, argc, argv);

out:

	return (mdb_tab_size(mcp));

}

static int

tab_complete_dcmd(mdb_var_t *v, void *arg)

{

	mdb_idcmd_t *idcp = mdb_nv_get_cookie(mdb_nv_get_cookie(v));

	mdb_tab_cookie_t *mcp = (mdb_tab_cookie_t *)arg;

	/*

	 * The way that mdb is implemented, even commands like $C will show up

	 * here. As such, we don't want to match anything that doesn't start

	 * with an alpha or number. While nothing currently appears (via a

	 * cursory search with mdb -k) to start with a capital letter or a

	 * number, we'll support them anyways.

	 */

	if (!isalnum(idcp->idc_name[0]))

		return (0);

	mdb_tab_insert(mcp, idcp->idc_name);

	return (0);

}

int

mdb_tab_complete_dcmd(mdb_tab_cookie_t *mcp, const char *dcmd)

{

	mdb_tab_setmbase(mcp, dcmd);

	mdb_nv_sort_iter(&mdb.m_dcmds, tab_complete_dcmd, mcp,

	    UM_GC | UM_SLEEP);

	return (0);

}

static int

tab_complete_walker(mdb_var_t *v, void *arg)

{

	mdb_iwalker_t *iwp = mdb_nv_get_cookie(mdb_nv_get_cookie(v));

	mdb_tab_cookie_t *mcp = arg;

	mdb_tab_insert(mcp, iwp->iwlk_name);

	return (0);

}

int

mdb_tab_complete_walker(mdb_tab_cookie_t *mcp, const char *walker)

{

	if (walker != NULL)

		mdb_tab_setmbase(mcp, walker);

	mdb_nv_sort_iter(&mdb.m_walkers, tab_complete_walker, mcp,

	    UM_GC | UM_SLEEP);

	return (0);

}

mdb_tab_cookie_t *

mdb_tab_init(void)

{

	mdb_tab_cookie_t *mcp;

	mcp = mdb_zalloc(sizeof (mdb_tab_cookie_t), UM_SLEEP | UM_GC);

	(void) mdb_nv_create(&mcp->mtc_nv, UM_SLEEP | UM_GC);

	return (mcp);

}

size_t

mdb_tab_size(mdb_tab_cookie_t *mcp)

{

	return (mdb_nv_size(&mcp->mtc_nv));

}

/*

 * Determine whether the specified name is a valid tab completion for

 * the given command. If the name is a valid tab completion then

 * it will be saved in the mdb_tab_cookie_t.

 */

void

mdb_tab_insert(mdb_tab_cookie_t *mcp, const char *name)

{

	size_t len, matches, index;

	uint_t flags;

	mdb_var_t *v;

	char *n;

	const char *nvn;

	/*

	 * If we have a match set, then we want to verify that we actually match

	 * it.

	 */

	if (mcp->mtc_base != NULL &&

	    strncmp(name, mcp->mtc_base, strlen(mcp->mtc_base)) != 0)

		return;

	v = mdb_nv_lookup(&mcp->mtc_nv, name);

	if (v != NULL)

		return;

	/*

	 * Names that we get passed in may be longer than MDB_NV_NAMELEN which

	 * is currently 31 including the null terminator. If that is the case,

	 * then we're going to take care of allocating a string and holding it

	 * for our caller. Note that we don't need to free it, because we're

	 * allocating this with UM_GC.

	 */

	flags = 0;

	len = strlen(name);

	if (len > MDB_NV_NAMELEN - 1) {

		n = mdb_alloc(len + 1, UM_SLEEP | UM_GC);

		(void) strcpy(n, name);

		nvn = n;

		flags |= MDB_NV_EXTNAME;

	} else {

		nvn = name;

	}

	flags |= MDB_NV_RDONLY;

	(void) mdb_nv_insert(&mcp->mtc_nv, nvn, NULL, 0, flags);

	matches = mdb_tab_size(mcp);

	if (matches == 1) {

		(void) strlcpy(mcp->mtc_match, nvn, MDB_SYM_NAMLEN);

	} else {

		index = 0;

		while (mcp->mtc_match[index] &&

		    mcp->mtc_match[index] == nvn[index])

			index++;

		mcp->mtc_match[index] = '\0';

	}

}

/*ARGSUSED*/

static int

tab_print_cb(mdb_var_t *v, void *ignored)

{

	mdb_printf("%s\n", mdb_nv_get_name(v));

	return (0);

}

void

mdb_tab_print(mdb_tab_cookie_t *mcp)

{

	mdb_nv_sort_iter(&mcp->mtc_nv, tab_print_cb, NULL, UM_SLEEP | UM_GC);

}

const char *

mdb_tab_match(mdb_tab_cookie_t *mcp)

{

	size_t blen;

	if (mcp->mtc_base == NULL)

		blen = 0;

	else

		blen = strlen(mcp->mtc_base);

	return (mcp->mtc_match + blen);

}

void

mdb_tab_setmbase(mdb_tab_cookie_t *mcp, const char *base)

{

	(void) strlcpy(mcp->mtc_base, base, MDB_SYM_NAMLEN);

}

/*

 * This function is currently a no-op due to the fact that we have to GC because

 * we're in command context.

 */

/*ARGSUSED*/

void

mdb_tab_fini(mdb_tab_cookie_t *mcp)

{

}

/*

 * This function takes a ctf id and determines whether or not the associated

 * type should be considered as a potential match for the given tab

 * completion command. We verify that the type itself is valid

 * for completion given the current context of the command, resolve

 * its actual name, and then pass it off to mdb_tab_insert to determine

 * if it's an actual match.

 */

static int

tab_complete_type(mdb_ctf_id_t id, void *arg)

{

	int rkind;