auto_comp.c revision f2fc321be9b4df7748e8c31a5edd154b0177b139
/*
* 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
* 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 2007 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
#include <dirent.h>
#include <strings.h>
#include "filebench.h"
#include "auto_comp.h"
#define VARNAME_MAXLEN 128
#define FILENAME_MAXLEN 128
#define MALLOC_STEP 64
#define CSUF_CMD " "
#define CSUF_ARG " "
#define CSUF_LVARNAME "="
#define CSUF_RVARNAME ","
#define CSUF_ATTRNAME "="
#define ATTR_LIST_SEP ','
#define ATTR_ASSIGN_OP '='
#define VAR_ASSIGN_OP '='
#define VAR_PREFIX '$'
#ifndef HAVE_BOOLEAN_T
#endif
typedef char ac_fname_t[FILENAME_MAXLEN];
typedef struct ac_fname_cache {
int fnc_bufsize;
typedef enum ac_match_result {
/*
* We parse an user input line into multiple blank separated strings.
* The last string is always the one user wants to complete, the other
* preceding strings set up the context on how to complete the last one.
*
* ac_str_t repsents one such a string, which can be of the following
* types:
*
* STRTYPE_COMPLETE - the string is one of the preceding strings.
* STRTYPE_INCOMPLETE - the string is the one being completed, user
* has inputted at least one character for it.
* STRTYPE_NULL - the string is the one being completed, user
* has inputted nothing for it.
*
* ac_str_t structure has the following members:
*
* startp - the start position of the string in the user input buffer
* endp - the end position of the string in the user input buffer
* strtype - the type of the string. It can be of the following values:
* STRTYPE_COMPLETE, STRTYPE_INCOMPLETE, STRTYPE_NULL,
* and STRTYPE_INVALID.
*/
typedef enum ac_strtype {
} ac_strtype_t;
typedef struct ac_str {
const char *startp;
const char *endp;
} ac_str_t;
#define STR_NUM 3
typedef struct ac_inputline {
/*
* ac_iter represents a general interface to access a list of values for
* matching user input string. The structure has the following methods:
*
* bind - bind the iterator to a list, and save a pointer to user
* passed space in nlistpp.
* reset - reset internal index pointer to point to list head.
* get_nextstr - this is the method that does the real work. It
* walks through the list and returns string associated with
* the current item. It can also return some other thing the
* caller is interested via the user passed space pointed by
* nlistpp. In our case, that is a pointer to a list which
* contains all possible values for the next string in user
* input.
*
* It has the following data members:
*
* listp - a pointer to the list to be iterated through
* curp - index pointer to maintain position when iterating
* nlistpp - a pointer to user passed space for returning a list of
* values for the next string in user input
*/
typedef struct ac_iter {
void *listp;
void *curp;
void *nlistpp;
const char *(*get_nextstr)(struct ac_iter *);
} ac_iter_t;
/*
* We consider a filebench command is composed of a sequence of tokens
* (ie., command name, argument name, attribute name, etc.). Many of
* these tokens have limited string values. These values, as well as
* their dependencies, are used to complete user input string.
*
* There are the following tokens:
*
* TOKTYPE_CMD - command name
* TOKTYPE_ARG - argument name
* TOKTYPE_ATTRNAME - attribute name
* TOKTYPE_ATTRVAL - attribute value
* TOKTYPE_LVARNAME - variable name, used on left side of assign
* operator
* TOKTYPE_RVARNAME - variable name, used on right side of assign
* operator
* TOKTYPE_VARVAL - variable value
* TOKTYPE_LOADFILE - load file name
* TOKTYPE_ATTRLIST - pseudo token type for attribute list
* TOKTYPE_VARLIST - pseudo token type for variable list
* TOKTYPE_NULL - pseudo token type for aborting auto-completion
*
* The reason why there are two different token types for variable name
* is because, depending on its position, there are different requirements
* on how to do completion and display matching results. See more details
* in lvarname_iter and rvarname_iter definition.
*
* Attribute list and variable list are not really a single token. Instead
* they contain multiple tokens, and thus have different requirements on
* how to complete them. TOKTYPE_ATTRLIST and TOKTYPE_VARLIST are
* introduced to to solve this issue. See more details below on
* get_curtok() function in ac_tokinfo_t structure.
*
* ac_tokval_t represents a string value a token can have. The structure
* also contains a pointer to a ac_tvlist_t structure, which represents
* all possible values for the next token in the same command.
*
* str - the token's string value
* nlistp - a list which contains string values for the token
* that follows
*
* ac_tvlist_t represents all possible values for a token. These values
* are stored in an ac_tokval_t array. The structure also has a member
* toktype, which is used to index an ac_tokinfo_t array to get the
* information on how to access and use the associated value list.
*
* vals - a list of string values for this token
* toktype - the token's type
*
* ac_tokinfo_t contains information on how to access and use the
* string values of a specific token. Among them, the most important
* thing is an iterator to access the value list. The reason to use
* iterator is to encapsulate list implementation details. That is
* necessary because some tokens have dynamic values(for example,
* argument of load command), which cannot be predefined using
* ac_tokval_t array.
*
* ac_tokinfo_t structure has the following members:
*
* toktype - token type
* iter - iterator to access the token's value list
* cont_suffix - continuation suffix for this token. See note 1
* below on what is continuation suffix.
* get_curtok - a function to parse a multi-token user string.
* It parse that string and returns the word being
* completed and its token type. See note 2 below.
*
* Notes:
*
* 1) Continuation suffix is a convenient feature provided by libtecla.
* A continuation suffix is a string which is automatically appended
* to a fully completed string. For example, if a command name is
* fully completed, a blank space will be appended to it. This is
* very convenient because it not only saves typing, but also gives
* user an indication to continue.
*
* 2) get_curtok() function is a trick to support user input strings
* which have multiple tokens. Take attribute list as an example,
* although we defined a token type TOKTYPE_ATTRLIST for it, it is
* not a token actually, instead it contains multiple tokens like
* attribute name, attribute value, etc., and attribute value can
* be either a literal string or a variable name prefixed with a
* '$' sign. For this reason, get_curtok() function is needed to
* parse that string to get the word being completed and its token
* type so that we can match the word against with the proper value
* list.
*/
typedef enum ac_toktype {
} ac_toktype_t;
typedef struct ac_tokinfo {
char *cont_suffix;
} ac_tokinfo_t;
typedef struct ac_tokval {
char *str;
} ac_tokval_t;
typedef struct ac_tvlist {
} ac_tvlist_t;
/*
* Variables and prototypes
*/
static void common_bind(ac_iter_t *, void *, void *);
static void common_reset(ac_iter_t *);
static void varname_bind(ac_iter_t *, void *, void *);
static void loadfile_bind(ac_iter_t *, void *, void *);
static const char *get_next_tokval(ac_iter_t *);
static const char *get_next_lvarname(ac_iter_t *);
static const char *get_next_rvarname(ac_iter_t *);
static const char *get_next_loadfile(ac_iter_t *);
static ac_iter_t tokval_iter = {
NULL,
NULL,
NULL,
};
static ac_iter_t lvarname_iter = {
NULL,
NULL,
NULL,
};
static ac_iter_t rvarname_iter = {
NULL,
NULL,
NULL,
};
static ac_iter_t loadfile_iter = {
NULL,
NULL,
NULL,
};
/*
* Note: We use toktype to index into this array, so for each toktype,
* there must be one element in the array, and in the same order
* as that toktype is defined in ac_toktype.
*/
static ac_tokinfo_t token_info[] = {
};
static ac_tokval_t event_attrnames[] = {
{ "rate", NULL},
};
static ac_tvlist_t event_attrs = {
};
static ac_tokval_t file_attrnames[] = {
{ "path", NULL },
{ "reuse", NULL },
{ "prealloc", NULL },
{ "paralloc", NULL },
};
static ac_tvlist_t file_attrs = {
};
static ac_tokval_t fileset_attrnames[] = {
{ "size", NULL },
{ "path", NULL },
{ "dirwidth", NULL },
{ "prealloc", NULL },
{ "filesizegamma", NULL },
{ "dirgamma", NULL },
{ "cached", NULL },
{ "entries", NULL },
};
static ac_tvlist_t fileset_attrs = {
};
static ac_tokval_t process_attrnames[] = {
{ "nice", NULL },
{ "instances", NULL },
};
static ac_tvlist_t process_attrs = {
};
static ac_tokval_t create_argnames[] = {
{ "file", NULL },
{ "fileset", NULL },
{ "process", NULL },
};
static ac_tvlist_t create_args = {
};
static ac_tokval_t define_argnames[] = {
{ "file", &file_attrs },
{ "fileset", &fileset_attrs },
{ "process", &process_attrs },
};
static ac_tvlist_t define_args = {
};
static ac_tvlist_t load_args = {
NULL,
};
static ac_tvlist_t set_args = {
NULL,
};
static ac_tokval_t shutdown_argnames[] = {
{ "process", NULL },
};
static ac_tvlist_t shutdown_args = {
};
static ac_tokval_t stats_argnames[] = {
{ "clear", NULL },
{ "directory", NULL },
{ "command", NULL },
{ "dump", NULL },
{ "xmldump", NULL },
};
static ac_tvlist_t stats_args = {
};
static ac_tokval_t fb_cmdnames[] = {
{ "create", &create_args },
{ "define", &define_args },
{ "debug", NULL },
{ "echo", NULL },
{ "eventgen", &event_attrs },
{ "foreach", NULL },
{ "help", NULL },
{ "list", NULL },
{ "load", &load_args },
{ "log", NULL },
{ "quit", NULL },
{ "run", NULL },
{ "set", &set_args },
{ "shutdown", &shutdown_args },
{ "sleep", NULL },
{ "stats", &stats_args },
{ "system", NULL },
{ "usage", NULL },
{ "vars", NULL },
};
static ac_tvlist_t fb_cmds = {
};
static int search_loadfiles(ac_fname_cache_t *);
static void parse_user_input(const char *, int, ac_inputline_t *);
/*
* Bind the iterator to the passed list
*/
static void
{
}
/*
* Reset index pointer to point to list head
*/
static void
{
}
/*
* Walk through an array of ac_tokval_t structures and return string
* of each item.
*/
static const char *
{
/* user passed variable for returning value list for next token */
const char *p;
return (NULL);
/* get the current item's string */
/*
* save the current item's address into a user passed variable
*/
/* advance the index pointer */
return (p);
}
/*
* Bind the iterator to filebench_shm->var_list
*/
static void
{
}
/*
* Walk through a linked list of var_t type structures and return name
* of each variable with a preceding '$' sign
*/
static const char *
{
static char buf[VARNAME_MAXLEN];
/* User passed variable for returning value list for next token */
const char *p;
return (NULL);
/* Get current variable's name, copy it to buf, with a '$' prefix */
/* No information for the next input string */
/* Advance the index pointer */
return (buf);
}
/*
* Walk through a linked list of var_t type structures and return name
* of each variable
*/
static const char *
{
/* User passed variable for returning value list for next item */
const char *p;
return (NULL);
/* Get current variable's name */
/* No information for the next input string */
/* Advance the index pointer */
return (p);
}
/*
* Bind the iterator to loadnames.fnc_buf, which is an ac_fname_t array
* and contains up-to-date workload file names. The function calls
* search_loadfiles() to update the cache before the binding.
*/
static void
{
/* Check loadfile name cache, update it if needed */
(void) search_loadfiles(&loadnames);
}
/*
* Walk through a string(ac_fname_t, more exactly) array and return each
* string, until a NULL iterm is encountered.
*/
static const char *
{
/* User passed variable for returning value list for next item */
const char *p;
return (NULL);
/*
* Get current file name. If an NULL item is encountered, it means
* this is the end of the list. In that case, we need to set p to
* NULL to indicate to the caller that the end of the list is reached.
*/
p = (char *)curp;
if (*p == NULL)
p = NULL;
/* No information for the next input string */
/* Advance the index pointer */
return (p);
}
/*
* Search for available workload files in workload direcotry and
* update workload name cache.
*/
static int
{
int bufsize = MALLOC_STEP;
int len, i;
return (-1);
/* Return if there is no change since last time */
return (0);
/* Get loadfile names and cache it */
return (-1);
return (-1);
i = 0;
continue;
if (i == bufsize) {
bufsize += MALLOC_STEP;
return (-1);
}
/* Remove .f suffix in file name */
}
i++;
}
/* Added a NULL iterm as the array's terminator */
if (fnamecache->fnc_bufsize != 0)
return (0);
}
/*
* Parse user input line into a list of blank separated strings, and
* save the result in the passed ac_inputline_t structure. line and word_end
* parameters are passed from libtecla library. line points to user input
* buffer, and word_end is the index of the last character of user input.
*/
static void
{
const char *p = line;
int i;
/* Reset all fileds */
for (i = 0; i < STR_NUM; i++) {
}
/*
* Parse user input. We don't use word_end to do boundary checking,
* instead we take advantage of the fact that the passed line
* parameter is always terminated by '\0'.
*/
for (i = 0; i < STR_NUM; i++) {
/* Skip leading blank spaces */
while (*p == ' ')
p++;
if (*p == NULL) {
/*
* User input nothing for the string being input
* before he pressed TAB. We use STR_NULL flag
* to indicate this so that match_str() will list
* all available candidates.
*/
return;
}
/* Recoard the start and end of the string */
while ((*p != ' ') && (*p != NULL))
p++;
if (*p == NULL) {
return;
} else {
/* The string is followed by a blank space */
}
}
}
/*
* Parse an input string which is an attribue list, get the current word
* user wants to complete, and return its token type.
*
* An atribute list has the following format:
*
* name1=val,name2=$var,...
*
* The function modifies the passed acstr string on success to point to
* the word being completed.
*/
static ac_toktype_t
{
const char *p;
/*
* User has input a complete string for attribute list
* return TOKTYPE_NULL to abort the matching.
*/
return (TOKTYPE_ATTRLIST);
/*
* User haven't input anything for the attribute list,
* he must be trying to list all attribute names.
*/
return (TOKTYPE_ATTRNAME);
}
/*
* The string may contain multiple comma separated "name=value"
* items. Try to find the last one and move startp to point to it.
*/
/*
* The last character of the string is ',', which means
* user is trying to list all attribute names.
*/
return (TOKTYPE_ATTRNAME);
/*
* Found ',' between starp and endp, move startp pointer
* to point to the last item.
*/
}
/*
* Now startp points to the last "name=value" item. Search in
* the characters user has input for this item:
*
* a) if there isn't '=' character, user is inputting attribute name
* b) if there is a '=' character and it is followed by a '$',
* user is inputting variable name
* c) if there is a '=' character and it isn't followed by a '$',
* user is inputting a literal string as attribute value.
*/
if (*p == ATTR_ASSIGN_OP) {
/* Found "=" operator in the string */
if (*(p + 1) == VAR_PREFIX) {
else
return (TOKTYPE_RVARNAME);
} else {
return (TOKTYPE_ATTRVAL);
}
}
}
/* Didn't find '=' operator, the string must be an attribute name */
return (TOKTYPE_ATTRNAME);
}
/*
* Parse an input string which is a variable list, get the current word
* user wants to complete, and return its token type.
*
* A varaible list has the following format:
*
* $varname=value
*
* The function modifies the passed acstr string on success to point to
* the word being completed.
*/
static ac_toktype_t
{
const char *p;
/*
* User has input a complete string for var list
* return TOKTYPE_NULL to abort the matching.
*/
return (TOKTYPE_NULL);
/*
* User haven't input anything for the attribute list,
* he must be trying to list all available var names.
*/
return (TOKTYPE_LVARNAME);
}
/*
* Search in what user has input:
*
* a) if there isn't a '=' character, user is inputting var name
* b) if there is a '=' character, user is inputting var value
*/
if (*p == VAR_ASSIGN_OP)
return (TOKTYPE_VARVAL);
}
/* Didn't find '=' operator, user must be inputting an var name */
return (TOKTYPE_LVARNAME);
}
/*
* Compare two strings acstr and str. acstr is a string of ac_str_t type,
* str is a normal string. If issub is B_TRUE, the function checks if
* acstr is a sub-string of str, starting from index 0; otherwise it checks
* if acstr and str are exactly the same.
*
* The function returns 0 on success and -1 on failure. When it succeeds,
* it also set restp to point to the rest part of the normal string.
*/
static int
const char **restp)
{
const char *p, *q;
p++, q++) {
if (*p != *q)
return (-1);
}
*restp = q;
return (0);
}
}
return (-1);
}
/*
* Use the passed iterp iterator to access a list of string values to
* look for those matches with acstr, an user input string to be completed.
*
* cpl, line, work_end, and cont_suffix are parameters needed by
* cpl_add_completion(), which adds matched entries to libtecla.
*
* Since user input line may have multiple strings, the function is
* expected to be called multiple times to match those strings one
* by one until the last one is reached.
*
* The multi-step matching process also means the function should provide
* a way to indicate to the caller whether to continue or abort the
* whole matching process. The function does that with the following
* return values:
*
* MATCH_DONE - the matching for the whole user input is done. This
* can mean either some items are found or none is found.
* In either case, the caller shouldn't continue to
* match the rest strings, either because there is
* no strings left, or because the matching for the
* current string failed so there is no need to check
* further.
* MATCH_CONT - the matching for the current string succeeds, but
* user needs to continue to match the rest strings.
*/
static ac_match_result_t
{
/* Continue to check rest strings */
return (MATCH_CONT);
}
}
/* User input nothing. List all available strings */
NULL, cont_suffix);
}
/* It matches! Add it. */
NULL, cont_suffix);
}
}
}
return (MATCH_DONE);
}
/*
* This is the interface between filebench and libtecla for auto-
* completion. It is called by libtecla whenever user initiates a
* auto-completion request(ie., pressing TAB key).
*
* The function calls parse_user_input() to parse user input into
* multiple strings, then it calls match_string() to match each
* string in user input in sequence until either the last string
* is reached and completed or the the matching fails.
*/
{
char *cont_suffix;
int i, ret;
/* Parse user input and save the result in inputline variable. */
/*
* Match each string in user input against the proper token's
* value list, and continue the loop until either the last string
* is reached and completed or the matching aborts.
*/
for (i = 0; i < STR_NUM &&
i++) {
/*
* If the current stirng can contain multiple tokens, modify
* the stirng to point to the word being input and return
* its token type.
*/
if (get_curtok != NULL)
/* Return if there is no completion info for the token */
break;
/* Match user string against the token's list */
iterp, cont_suffix);
if (ret == MATCH_DONE)
return (0);
}
return (0);
}