1 files changed, 246 insertions, 0 deletions
diff --git a/mini-commander/src/cmd_completion.c b/mini-commander/src/cmd_completion.c
new file mode 100644
index 00000000..7b91ff5b
--- /dev/null
+++ b/mini-commander/src/cmd_completion.c
@@ -0,0 +1,246 @@
+/*
+ * Mini-Commander Applet
+ * Copyright (C) 1998, 1999 Oliver Maruhn <[email protected]>
+ *
+ * Author: Oliver Maruhn <[email protected]>
+ *
+ * This program 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 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+/*
+ If you expect tons of C code for command completion then you will
+ probably be astonished...
+
+ These routines have probably to be rewritten in future. But they
+ should work on every system with a bash-alike shell. 
+*/
+
+#include <config.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include <mate-panel-applet.h>
+
+#include <sys/stat.h>
+#include <dirent.h>
+
+#include "cmd_completion.h"
+#include "preferences.h"
+#include "macro.h"
+
+
+static GList* cmdc( char* );
+static void process_dir( const gchar* );
+static void cleanup( void );
+static gint g_list_str_cmp( gconstpointer, gconstpointer );
+
+/* global declaration so g_atexit() can reference it to free it.
+ * (not strictly necessary).
+ */
+static GList *path_elements = NULL;
+
+void
+mc_cmd_completion (MCData *mc,
+ char *cmd)
+{
+ char buffer[MC_MAX_COMMAND_LENGTH] = "";
+ char largest_possible_completion[MC_MAX_COMMAND_LENGTH] = "";
+ int num_whitespaces, i, pos;
+
+ GList *possible_completions_list = NULL;
+ GList *completion_element;
+
+ 
+ if(strlen(cmd) == 0)
+ {
+ return;
+ }
+
+ num_whitespaces = mc_macro_prefix_len_wspace (mc, cmd) - mc_macro_prefix_len (mc, cmd);
+ possible_completions_list = cmdc(cmd + mc_macro_prefix_len_wspace (mc, cmd));
+
+ /* get first possible completion */
+ completion_element = g_list_first(possible_completions_list);
+ if(completion_element)
+ strcpy(largest_possible_completion, (char *) completion_element->data);
+ else
+ strcpy(largest_possible_completion, "");
+
+ /* get the rest */
+ while((completion_element = g_list_next(completion_element)))
+ {
+ strcpy(buffer, (char *) completion_element->data);
+ pos = 0;
+ while(largest_possible_completion[pos] != '\000' 
+ && buffer[pos] != '\000'
+ && strncmp(largest_possible_completion, buffer, pos + 1) == 0)
+ pos++;
+ strncpy(largest_possible_completion, buffer, pos);
+ /* strncpy does not add \000 to the end */
+ largest_possible_completion[pos] = '\000';
+ }
+ 
+ if(strlen(largest_possible_completion) > 0)
+ {
+ if(mc_macro_get_prefix(mc, cmd) != NULL)
+ strcpy(cmd, mc_macro_get_prefix(mc, cmd));
+ else
+ strcpy(cmd, "");
+
+ /* fill up the whitespaces */
+ for(i = 0; i < num_whitespaces; i++)
+ strcat(cmd, " "); 
+
+ strcat(cmd, largest_possible_completion);
+ }
+}
+
+/*
+ * cmdc() -- command completion function.
+ *
+ * cmdc takes a char* and returns a GList* of possible completions.
+ *
+ * Initial version by Travis Hume <[email protected]>.
+ *
+ */
+static GList *
+cmdc( char *s )
+{
+ GCompletion *completion = NULL;
+ GList *ret_list = NULL;
+ static GHashTable *path_hash = NULL;
+ static char *path = NULL;
+ gchar *path_elem;
+ struct stat buf;
+ static gboolean inited = FALSE;
+ gpointer hash_key = NULL;
+
+
+ /*
+ * Only want to build the GCompletion once. At some point I'd like to add
+ * code to refresh the GCompletion, either at a regular interval, or when
+ * there is a completion failure, ...
+ *
+ */
+ if(!inited)
+ {
+ /* Make a local copy of the path variable. Otherwise the path
+ environment variable would be modified. */
+ path = (char *) malloc(sizeof(char) * (strlen(getenv("PATH")) + 1));
+ strcpy(path, getenv("PATH"));
+ 
+ path_hash = g_hash_table_new( g_str_hash, g_str_equal );
+
+ for( path_elem = strtok( path, ":" ); path_elem;
+ path_elem = strtok( NULL, ":" ))
+ {
+ if( stat( path_elem, &buf ))
+ continue;
+
+ if( buf.st_mode & S_IFDIR )
+ {
+ /* keep a hash of processed paths, to avoid reprocessing
+ * dupped path entries.
+ */
+ hash_key = g_hash_table_lookup( path_hash, path_elem );
+ if( hash_key )
+ continue; /* duplicate $PATH entry */
+ else
+ {
+ g_hash_table_insert(
+ path_hash, (gpointer)path_elem, (gpointer)path_elem );
+
+ process_dir( path_elem );
+ }
+ }
+ }
+
+ /* atexit() we want to free the completion. */
+ g_atexit( cleanup );
+
+ inited = TRUE;
+ }
+
+ completion = g_completion_new( NULL );
+ g_completion_add_items( completion, path_elements );
+ ret_list = g_list_copy( g_completion_complete( completion, s, NULL ));
+ g_completion_free( completion );
+
+ return g_list_sort( ret_list, (GCompareFunc)g_list_str_cmp );
+}
+
+
+/*
+ * Compare function to return a sorted completion.
+ */
+static gint
+g_list_str_cmp( gconstpointer a, gconstpointer b )
+{
+ return( strcmp( (char *)a, (char *)b ));
+}
+
+
+
+/*
+ * Reads directory entries and adds non-dir, executable files
+ * to the GCompletion.
+ * Initial version by Travis Hume <[email protected]>.
+ */
+static void
+process_dir( const char *d )
+{
+ DIR *dir;
+ struct dirent *de;
+ struct stat buf;
+ gpointer data;
+ gchar *path_str;
+
+
+ if( (dir = opendir( d )) == NULL )
+ return;
+
+ while( (de = readdir( dir )) != NULL )
+ {
+ if( strcmp( de->d_name, "." ) == 0 || strcmp( de->d_name, "..") == 0)
+ continue;
+
+ path_str = (gchar *)g_malloc( strlen( d ) + 1 + strlen( de->d_name ) + 1);
+ strcpy( path_str, d );
+ strcat( path_str, "/" );
+ strcat( path_str, de->d_name );
+ if( stat( path_str, &buf ) != 0)
+ continue;
+ g_free( (gpointer)path_str );
+
+ if( S_ISDIR( buf.st_mode ) )
+ continue;
+
+ data = g_malloc( strlen( (gchar *)de->d_name ) + 1 );
+ strcpy( (gchar *)data, (gchar *)(de->d_name) );
+ if( buf.st_mode & S_IXUSR )
+ path_elements = g_list_append( path_elements, data );
+ }
+ closedir( dir );
+}
+
+
+/*
+ * cleanup() -- free the memory used by the GCompletion.
+ */
+static void
+cleanup( void )
+{
+ g_list_free( path_elements );
+}