path: root/tap/readline/tab.c

/* tab.c
 * Part of the Readline module for Tap. This is where command line
 * completion is implemented.
 */

/* Copyright (C) 1999 Jonathan duSaint
 *
 * This file is part of Tap, an interactive program for reading and
 * writing data to the serial port to facilitate the reverse
 * engineering of communication protocols.
 *
 * Tap is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2, or (at your option)
 * any later version.
 *
 * Tap is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
 * License for more details.
 *
 * The GNU General Public License is generally kept in a file called
 * COPYING or LICENSE.  If you do not have a copy of the license, write
 * to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include "readline.h"
#include <glob.h>

/* returned to do_tab_completion () when a successful match hasn't been made */
char *null_match[] = { NULL, NULL };

/* find the number of matching characters in the two strings */
int
strmatch (char *first, char *second)
{
  int highest;

  for (highest = 0; highest < MAX (strlen (first), strlen (second)); highest++)
    if (first[highest] != second[highest]) break;

  return (highest);
}

/* Scan an array of strings looking for the largest
 * number of matching characters. For the array
 *
 *   "dobri"
 *   "dyen"
 *   "dinamacheskiye"
 *   "dudayevtsi"
 *
 * the result would be 1.
 */
int
find_matching_chars (char *matches[])
{
  int current_match, max_match = INT_MAX, index, last = 0;

  while (matches[last + 1] != NULL) last++;

  if (!last) return (strlen (matches[0])); /* one item in array */

  for (index = 1; index <= last; index++)
    {
      current_match = strmatch (matches[index - 1], matches[index]);

      max_match = MIN (max_match, current_match);
    }

  return (max_match);
}

/* Return an array of strings containing the main command names */
char **
command_names (void)
{
  static char **names = NULL;
  int index = 0, max_commands;

  if (names != NULL) return (names);

  names = xmalloc (sizeof (char *) * INCR_VALUE);
  max_commands = INCR_VALUE;

  while (commands[index].name != NULL)
    {
      if (index == max_commands - 1)
	{
	  names = xrealloc (names, sizeof (char *)*(max_commands+INCR_VALUE));
	  max_commands += INCR_VALUE;
	}

      names[index] = commands[index].name;
      index++;
    }

  names[index] = NULL;

  return (names);
}

/* Return the `number' of the current token */
int
find_current_token_number (void)
{
  int token_number = 1, pos = current_position + 1;

  while (pos--)
    { /* scan backward counting whitespace regions */

      if (current_line[pos] == ' ') /* found one */
	{
	  token_number++;

	  /* skip the rest of the region */
	  while (current_line[pos] == ' ' && pos) pos--;

	  /* if the first char is ' ' */
	  if (!pos && current_line[pos] ==  ' ') token_number--;
	}
    }

  return (token_number);
}

/* move the point to the end of the current token */
void
move_to_token_end (void)
{
  while (current_line[current_position] != ' '
	 && current_position != chars_in_line) move_cursor_right ();
}

/* If a match string for a command is \f, this function is
 * called. Uses the POSIX.2 function glob() to match files
 * and returns all files matched by SEARCH with a '*' tacked
 * onto the end.
 */
char **
match_file_esc (char *search)
{
  glob_t file_list;
  int k;
  char **ret_list, *pattern;

  pattern = xmalloc (strlen (search) + 2);
  sprintf (pattern, "%s*", search);

  if (glob (pattern, GLOB_MARK, NULL, &file_list)) return (null_match);

  ret_list = xmalloc ((file_list.gl_pathc + 1) * sizeof (char *));

  for (k = 0; k < file_list.gl_pathc; k++)
    {
      ret_list[k] = xmalloc (strlen (file_list.gl_pathv[k]) + 1);
      strcpy (ret_list[k], file_list.gl_pathv[k]);
    }

  ret_list[file_list.gl_pathc] = NULL;

  xfree (pattern);
  return (ret_list);
}

/* Returns an array of strings which match the escape. Valid
 * escapes are \f - a filename, \c - a command name, and \m - anything.
 */
char **
find_esc_matches (char *search, char *esc_code)
{
  switch (esc_code[1])
    {
    case 'f':
      return (match_file_esc (search));

      /* this will be made functional later -- it isn't
       * used for anything now anyways */
    case 'c':

    case 'm': /* this doesn't match anything specific */
      return (null_match);
    }

  return (null_match);
}

/* Given a search string and an array of strings, returns an
 * array of strings which match
 */
char **
find_matches (char *search, char **potential_matches)
{
  char **actual_matches;
  int possible_completions, length = strlen (search), last_completion = -1, k;
  
  /* count the entries in potential_matches */
  for (possible_completions = 0;
       potential_matches[possible_completions] != NULL;
       possible_completions++);

  /* check for escapes */
  if (possible_completions == 1 && potential_matches[0][0] == '\\')
    return (find_esc_matches (search, potential_matches[0]));

  actual_matches = xmalloc ((possible_completions + 1) * sizeof (char *));

  /* zero out the output array */
  for (k = 0; k < possible_completions + 1; k++) actual_matches[k] = NULL;

  /* loop backward looking for matches */
  while (possible_completions--)
    {
      /* found a match */
      if (!strncmp (search, potential_matches[possible_completions], length))
	{
	  /* add to match list */
	  actual_matches[++last_completion] =
	    potential_matches[possible_completions];
	}
    }

  return (actual_matches);
}

/* Expands a token to the maximum possible size using
 * partial matches. Assumes that the point is at the end of the token
 * to be expanded, that token contains the partial token, and
 * that matches is a NULL terminated array with strings that
 * are matched by token.
 */
void
expand_text (char *token, char *matches[])
{
  int match_length, tok_length, match_pos;

  match_pos = tok_length = strlen (token);

  match_length = find_matching_chars (matches) - tok_length;

  if (match_length < 1) return;

  while (match_length--) insert_char (matches[0][match_pos++]);

  if (current_line[current_position] != ' '
      && matches[1] == NULL
      && current_line[current_position - 1] != '/')
    insert_char (' ');
}

/* Retrieves the match string for COMMAND. In other words
 * returns commands[n].tab_completion when
 * strcmp (command, commands[n].name) == 0
 */
char *
get_match_string (char *command)
{
  int index = -1, tok_len = strlen (command);

  while (commands[++index].name != NULL)
    {
      if (!strncmp (command, commands[index].name, tok_len))
	return (commands[index].tab_completion);
    }

  /* this should never be reached */
  return (zero_length_string);
}

/* print all of the strings in MATCHES */
void
print_partial_matches (char *matches[])
{
  int index, command_width = 0, commands_per_line;
  int x_pos = input_window->_curx, y, y_offset;

  y = input_window->_cury;
  move_cursor_to_end ();
  y_offset = input_window->_cury - y;

  waddch (input_window, '\n');

  /* find longest string */
  index = -1;
  while (matches[++index] != NULL)
    command_width = MAX (command_width, strlen (matches[index]));

  command_width += PADDING;

  commands_per_line = window_width / command_width;

  /* print strings */
  index = -1;
  while (matches[++index] != NULL)
    {
      wprintw (input_window, "%-*s", command_width, matches[index]);
      if (!((index + 1) % commands_per_line)) waddch (input_window, '\n');
    }

  if (input_window->_curx) waddch (input_window, '\n');

  start_y = input_window->_cury;

  wprintw (input_window, "%s%s", prompt, current_line);

  input_window->_curx = x_pos;
  input_window->_cury -= y_offset;
}

/* Returns the NUMBERth token in current_line */
char *
get_token_by_number (int number)
{
  int pos = 0;

  while (number--)
    {
      if (number)
	while (current_line[pos] != ' ' && pos < chars_in_line) pos++;

      while (current_line[pos] == ' ' && pos < chars_in_line) pos++;
    }

  return (get_token_only (current_line + pos));
}

/* Returns the position of the next level one match_string
 */
int
next_level_one (char *match_string, int pos)
{
  int depth = 0;

  pos--;

  while (match_string[++pos] != '\0')
    {
      switch (match_string[pos])
	{
	case '{':
	  depth++;
	  break;
	case '}':
	  depth--;
	  break;
	case ',':
	  if (!depth)
	    return (pos + 1);
	}
    }

  return (-1);
}

/* Returns the sub-match_string for TOKEN. If TOKEN isn't in
 * MATCH_STRING, returns ""
 */
char *
get_sublist (char *token, char *match_string)
{
  int pos = 0, len;
  char *sublist;

  while (1)
    {
      /* got a match */
      if (!strncmp (token, match_string + pos, strlen (token))) break;

      pos = next_level_one (match_string, pos);

      if (pos == -1) return (zero_length_string);
    }

  /* skip to end of token */
  while ((match_string[pos] != ',') && (match_string[pos] != '{')
	 && (match_string[pos] != '\0')) pos++;

  if (match_string[pos] != '{') return (zero_length_string);

  /* find substring */
  len = next_level_one (match_string, pos);

  if (len == -1)
    len = strlen (match_string) - pos + 1;
  else
    len -= pos;

  len -= 3;

  /* extract */
  sublist = xmalloc (len + 1);
  strncpy (sublist, match_string + pos + 1, len);
  sublist[len] = '\0';

  return (sublist);
}

/* Returns an array with the top level entries in SEARCH_TEXT */
char **
get_search_strings (char *search_text)
{
  char **search_strings = NULL;
  int offset, pos = 0, current = 0, max_str;

  search_strings = xmalloc (INCR_VALUE * sizeof (char *));
  max_str = INCR_VALUE;

  while (1)
    {
      offset = 0;
      while ((search_text[pos + offset] != ',')
	     && (search_text[pos + offset] != '{')
	     && (search_text[pos + offset] != '\0')) offset++;

      if (offset == 0) break;

      if (current == max_str - 1)
	{
	  search_strings = xrealloc (search_strings,
				     sizeof (char *) * (max_str + INCR_VALUE));
	  max_str += INCR_VALUE;
	}

      search_strings[current] = xmalloc (offset + 1);
      strncpy (search_strings[current], search_text + pos, offset);
      search_strings[current++][offset] = '\0';

      switch (search_text[pos + offset])
	{
	case ',':
	  pos = pos + offset + 1;
	  break;
	case '{':
	  pos = next_level_one (search_text, pos + offset);
	  break;
	case '\0':
	  goto END;
	}
    }

 END:
  search_strings[current] = NULL;
  return (search_strings);
}

/* Frees the array returned by get_search_strings () */
void
free_search_strings (char *search_strings[])
{
  int index = -1;

  while (search_strings[++index] != NULL) xfree (search_strings[index]);

  xfree (search_strings);
}

/* Completes the current token as much as possible */
void
do_tab_completion (void)
{
  char *first, **matches, **search_strings, *match_string, *token = NULL;
  int token_number = find_current_token_number (), tok;

  search_strings = command_names ();

  first = get_token_by_number (1);

  matches = find_matches (first, search_strings);

  if (matches[0] == NULL)
    {
      warning_beep ();
      return;
    }

  if (token_number == 1)
    {
      /* just matching the first token */
      move_to_token_end ();
      expand_text (first, matches);

      if (matches[1] != NULL) print_partial_matches (matches);

      return;
    }
  else if (matches[1] != NULL)
    {
      /* trying to match other than the first token w/o a unique
       * first token -- bad news
       */
      warning_beep ();
      return;
    }

  /* matching other than the first token */
  match_string = get_match_string (first);

  /* match all preceding tokens to find out what is trying to be matched */
  for (tok = 2; tok < token_number; tok++)
    {
      token = get_token_by_number (tok);
      match_string = get_sublist (token, match_string);

      if (strlen (match_string) == 0)
	{
	  warning_beep ();
	  return;
	}
    }

  token = get_token_by_number (token_number);

  /* got a matchlist for this token */
  search_strings = get_search_strings (match_string);

  matches = find_matches (token, search_strings);

  if (matches[0] == NULL)
    {
      warning_beep ();
      return;
    }

  move_to_token_end ();
  expand_text (token, matches);

  if (matches[1] != NULL) print_partial_matches (matches);

  free_search_strings (search_strings);
}