mc/src/command.c
Timur Bakeyev a39568367e Glibing..... (2)
Wed Jan 27 03:17:44 1999  Timur Bakeyev <mc@bat.ru>

	* Converted memory managment to Glib. Now we use g_new()/g_malloc()/
	g_strdup()/g_free() routings. Also, copy_strings() replaced by
	g_strconcat(), strcasecmp() -> g_strcasecmp(),and sprintf() by
	g_snprintf().

	* Some sequences of malloc()/sprintf() changed to g_strdup_printf().

	* mad.[ch]: Modified, to work with new GLib's memory managment. Fixed
	a missing #undef for tempnam, which caused dead loop. Add several new
	functions to emulate GLib memory managment.

	*main.c, mad.[ch]: Add a new switch  "-M", which allows to redirect MAD
	messages to the file.

	* util.[ch], utilunix.c: Modified, deleted our variants of strcasecmp()
	and strdup() - we have g_ equivalences. Remove get_full_name() - it is
	similar to concat_dir_and_file(). Some other tricks with g_* functions.

	* global.h: Modified, extended. Now it is main memory mangment include -
	i.e. all inclusions of <stdlib.h>, <malloc.h>, <glib.h>, "fs.h", "mem.h",
	"util.h" and "mad.h" done there. This elimanates problem with proper or-
	der of #include's.

	* All around the source - changed order of #include's, most of them gone
	to global.h (see above), minor changes, like "0" -> NULL in string func-
	tions.
1999-01-27 01:08:30 +00:00

275 lines
7.3 KiB
C

/* Command line widget.
Copyright (C) 1995 Miguel de Icaza
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., 675 Mass Ave, Cambridge, MA 02139, USA.
This widget is derived from the WInput widget, it's used to cope
with all the magic of the command input line, we depend on some
help from the program's callback.
*/
#include <config.h>
#include <errno.h>
#include "tty.h"
#include <string.h>
#include "global.h" /* home_dir */
#include "dlg.h"
#include "widget.h"
#include "command.h"
#include "complete.h" /* completion constants */
#include "dialog.h" /* message () */
#include "dir.h" /* required by panel.h */
#include "panel.h" /* view_tree enum. Also, needed by main.h */
#include "main.h" /* do_cd */
#include "layout.h" /* for command_prompt variable */
#include "user.h" /* expand_format */
#include "subshell.h"
#include "tree.h" /* for tree_chdir */
#include "color.h"
#include "../vfs/vfs.h"
/* This holds the command line */
WCommand *cmdline;
/*Tries variable substitution, and if a variable CDPATH
of the form e.g. CDPATH=".:~:/usr" exists, we try then all the paths which
are mentioned there. Also, we do not support such extraordinary things as
${var:-value}, etc. Use the eval cd 'path' command instead.
Bugs: No quoting occurrs here, so ${VAR} and $VAR will be always
substituted. I think we can encourage users to use in such extreme
cases instead of >cd path< command a >eval cd 'path'< command, which works
as they might expect :)
FIXME: Perhaps we should do wildcard matching as well? */
static int examine_cd (char *path)
{
char *p;
int result;
char *q, *r, *s, *t, c;
q = g_malloc (MC_MAXPATHLEN + 10);
/* Variable expansion */
for (p = path, r = q; *p && r < q + MC_MAXPATHLEN; ) {
if (*p != '$' || (p [1] == '[' || p [1] == '('))
*(r++)=*(p++);
else {
p++;
if (*p == '{') {
p++;
s = strchr (p, '}');
} else
s = NULL;
if (s == NULL)
s = strchr (p, PATH_SEP);
if (s == NULL)
s = strchr (p, 0);
c = *s;
*s = 0;
t = getenv (p);
*s = c;
if (t == NULL) {
*(r++) = '$';
if (*(p - 1) != '$')
*(r++) = '{';
} else {
if (r + strlen (t) < q + MC_MAXPATHLEN) {
strcpy (r, t);
r = strchr (r, 0);
}
if (*s == '}')
p = s + 1;
else
p = s;
}
}
}
*r = 0;
result = do_cd (q, cd_parse_command);
/* CDPATH handling */
if (*q != PATH_SEP && !result) {
p = getenv ("CDPATH");
if (p == NULL)
c = 0;
else
c = ':';
while (!result && c == ':') {
s = strchr (p, ':');
if (s == NULL)
s = strchr (p, 0);
c = *s;
*s = 0;
if (*p) {
r = concat_dir_and_file (p, q);
result = do_cd (r, cd_parse_command);
g_free (r);
}
*s = c;
p = s + 1;
}
}
g_free (q);
return result;
}
/* Execute the cd command on the command line */
void do_cd_command (char *cmd)
{
int len;
/* Any final whitespace should be removed here
(to see why, try "cd fred "). */
/* NOTE: I think we should not remove the extra space,
that way, we can cd into hidden directories */
len = strlen (cmd) - 1;
while (len >= 0 &&
(cmd [len] == ' ' || cmd [len] == '\t' || cmd [len] == '\n')){
cmd [len] = 0;
len --;
}
if (cmd [2] == 0)
cmd = "cd ";
if (get_current_type () == view_tree){
if (cmd [0] == 0){
sync_tree (home_dir);
} else if (strcmp (cmd+3, "..") == 0){
char *dir = cpanel->cwd;
int len = strlen (dir);
while (len && dir [--len] != PATH_SEP);
dir [len] = 0;
if (len)
sync_tree (dir);
else
sync_tree (PATH_SEP_STR);
} else if (cmd [3] == PATH_SEP){
sync_tree (cmd+3);
} else {
char *old = cpanel->cwd;
char *new;
new = concat_dir_and_file (old, cmd+3);
sync_tree (new);
g_free (new);
}
} else
if (!examine_cd (&cmd [3])) {
message (1, MSG_ERROR, _(" Can't chdir to '%s' \n %s "),
&cmd [3], unix_error_string (errno));
return;
}
}
/* Returns 1 if the we could handle the enter, 0 if not */
static int enter (WCommand *cmdline)
{
Dlg_head *old_dlg;
if (command_prompt && strlen (input_w (cmdline)->buffer)){
char *cmd;
/* Any initial whitespace should be removed at this point */
cmd = input_w (cmdline)->buffer;
while (*cmd == ' ' || *cmd == '\t' || *cmd == '\n')
cmd++;
if (strncmp (cmd, "cd ", 3) == 0 || strcmp (cmd, "cd") == 0){
do_cd_command (cmd);
new_input (input_w (cmdline));
return MSG_HANDLED;
} else {
char *command, *s;
int i, j;
if (!vfs_current_is_local ()) {
message (1, MSG_ERROR, _(" You can not execute commands on non-local filesystems"));
return MSG_NOT_HANDLED;
}
command = g_malloc (strlen (cmd) + 1);
command [0] = 0;
for (i = j = 0; i < strlen (cmd); i ++){
if (cmd [i] == '%'){
i ++;
s = expand_format (cmd [i], 1);
command = g_realloc (command, strlen (command) + strlen (s)
+ strlen (cmd) - i + 1);
strcat (command, s);
g_free (s);
j = strlen (command);
} else {
command [j] = cmd [i];
j ++;
}
command [j] = 0;
}
old_dlg = current_dlg;
current_dlg = 0;
new_input (input_w (cmdline));
execute (command);
g_free (command);
#ifdef HAVE_SUBSHELL_SUPPORT
if (quit & SUBSHELL_EXIT){
quiet_quit_cmd ();
return MSG_HANDLED;
}
if (use_subshell)
load_prompt (0, 0);
#endif
current_dlg = old_dlg;
}
}
return MSG_HANDLED;
}
static int command_callback (Dlg_head *h, WCommand *cmd, int msg, int par)
{
switch (msg){
case WIDGET_FOCUS:
/* We refuse the focus always: needed not to unselect the panel */
return MSG_NOT_HANDLED;
case WIDGET_KEY:
/* Special case: we handle the enter key */
if (par == '\n'){
return enter (cmd);
}
}
return (*cmd->old_callback)(h, cmd, msg, par);
}
WCommand *command_new (int y, int x, int cols)
{
WInput *in;
WCommand *cmd = g_new (WCommand, 1);
in = input_new (y, x, DEFAULT_COLOR, cols, "", "cmdline");
cmd->input = *in;
g_free (in);
/* Add our hooks */
cmd->old_callback = (callback_fn) cmd->input.widget.callback;
cmd->input.widget.callback = (int (*) (Dlg_head *, void *, int, int))
command_callback;
cmd->input.completion_flags |= INPUT_COMPLETE_COMMANDS;
return cmd;
}