Adding upstream version 5.2.15.upstream/5.2.15upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 420 insertions, 0 deletions

diff --git a/builtins/type.def b/builtins/type.def
new file mode 100644
index 0000000..a8e47c0
--- /dev/null
+++ b/builtins/type.def
@@ -0,0 +1,420 @@
+This file is type.def, from which is created type.c.
+It implements the builtin "type" in Bash.
+
+Copyright (C) 1987-2020 Free Software Foundation, Inc.
+
+This file is part of GNU Bash, the Bourne Again SHell.
+
+Bash 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 3 of the License, or
+(at your option) any later version.
+
+Bash 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 Bash.  If not, see <http://www.gnu.org/licenses/>.
+
+$PRODUCES type.c
+
+$BUILTIN type
+$FUNCTION type_builtin
+$SHORT_DOC type [-afptP] name [name ...]
+Display information about command type.
+
+For each NAME, indicate how it would be interpreted if used as a
+command name.
+
+Options:
+  -a	display all locations containing an executable named NAME;
+		includes aliases, builtins, and functions, if and only if
+		the `-p' option is not also used
+  -f	suppress shell function lookup
+  -P	force a PATH search for each NAME, even if it is an alias,
+		builtin, or function, and returns the name of the disk file
+		that would be executed
+  -p	returns either the name of the disk file that would be executed,
+		or nothing if `type -t NAME' would not return `file'
+  -t	output a single word which is one of `alias', `keyword',
+		`function', `builtin', `file' or `', if NAME is an alias,
+		shell reserved word, shell function, shell builtin, disk file,
+		or not found, respectively
+
+Arguments:
+  NAME	Command name to be interpreted.
+
+Exit Status:
+Returns success if all of the NAMEs are found; fails if any are not found.
+$END
+
+#include <config.h>
+
+#include "../bashtypes.h"
+#include "posixstat.h"
+
+#if defined (HAVE_UNISTD_H)
+#  include <unistd.h>
+#endif
+
+#include <stdio.h>
+#include "../bashansi.h"
+#include "../bashintl.h"
+
+#include "../shell.h"
+#include "../parser.h"
+#include "../execute_cmd.h"
+#include "../findcmd.h"
+#include "../hashcmd.h"
+
+#if defined (ALIAS)
+#include "../alias.h"
+#endif /* ALIAS */
+
+#include "common.h"
+#include "bashgetopt.h"
+
+extern int find_reserved_word PARAMS((char *));
+
+/* For each word in LIST, find out what the shell is going to do with
+   it as a simple command. i.e., which file would this shell use to
+   execve, or if it is a builtin command, or an alias.  Possible flag
+   arguments:
+	-t		Returns the "type" of the object, one of
+			`alias', `keyword', `function', `builtin',
+			or `file'.
+
+	-p		Returns the pathname of the file if -type is
+			a file.
+
+	-a		Returns all occurrences of words, whether they
+			be a filename in the path, alias, function,
+			or builtin.
+
+	-f		Suppress shell function lookup, like `command'.
+
+	-P		Force a path search even in the presence of other
+			definitions.
+
+   Order of evaluation:
+	alias
+	keyword
+	function
+	builtin
+	file
+ */
+
+int
+type_builtin (list)
+     WORD_LIST *list;
+{
+  int dflags, any_failed, opt;
+  WORD_LIST *this;
+
+  if (list == 0)
+    return (EXECUTION_SUCCESS);
+
+  dflags = CDESC_SHORTDESC;	/* default */
+  any_failed = 0;
+
+  /* Handle the obsolescent `-type', `-path', and `-all' by prescanning
+     the arguments and converting those options to the form that
+     internal_getopt recognizes. Converts `--type', `--path', and `--all'
+     also. THIS SHOULD REALLY GO AWAY. */
+  for (this = list; this && this->word->word[0] == '-'; this = this->next)
+    {
+      char *flag = &(this->word->word[1]);
+
+      if (STREQ (flag, "type") || STREQ (flag, "-type"))
+	{
+	  this->word->word[1] = 't';
+	  this->word->word[2] = '\0';
+	}
+      else if (STREQ (flag, "path") || STREQ (flag, "-path"))
+	{
+	  this->word->word[1] = 'p';
+	  this->word->word[2] = '\0';
+	}
+      else if (STREQ (flag, "all") || STREQ (flag, "-all"))
+	{
+	  this->word->word[1] = 'a';
+	  this->word->word[2] = '\0';
+	}
+    }
+
+  reset_internal_getopt ();
+  while ((opt = internal_getopt (list, "afptP")) != -1)
+    {
+      switch (opt)
+	{
+	case 'a':
+	  dflags |= CDESC_ALL;
+	  break;
+	case 'f':
+	  dflags |= CDESC_NOFUNCS;
+	  break;
+	case 'p':
+	  dflags |= CDESC_PATH_ONLY;
+	  dflags &= ~(CDESC_TYPE|CDESC_SHORTDESC);
+	  break;
+	case 't':
+	  dflags |= CDESC_TYPE;
+	  dflags &= ~(CDESC_PATH_ONLY|CDESC_SHORTDESC);
+	  break;
+	case 'P':	/* shorthand for type -ap */
+	  dflags |= (CDESC_PATH_ONLY|CDESC_FORCE_PATH);
+	  dflags &= ~(CDESC_TYPE|CDESC_SHORTDESC);
+	  break;
+	CASE_HELPOPT;
+	default:
+	  builtin_usage ();
+	  return (EX_USAGE);
+	}
+    }
+  list = loptend;
+
+  while (list)
+    {
+      int found;
+
+      found = describe_command (list->word->word, dflags);
+
+      if (!found && (dflags & (CDESC_PATH_ONLY|CDESC_TYPE)) == 0)
+	sh_notfound (list->word->word);
+
+      any_failed += found == 0;
+      list = list->next;
+    }
+
+  opt = (any_failed == 0) ? EXECUTION_SUCCESS : EXECUTION_FAILURE;
+  return (sh_chkwrite (opt));
+}
+
+/*
+ * Describe COMMAND as required by the type and command builtins.
+ *
+ * Behavior is controlled by DFLAGS.  Flag values are
+ *	CDESC_ALL	print all descriptions of a command
+ *	CDESC_SHORTDESC	print the description for type and command -V
+ *	CDESC_REUSABLE	print in a format that may be reused as input
+ *	CDESC_TYPE	print the type for type -t
+ *	CDESC_PATH_ONLY	print the path for type -p
+ *	CDESC_FORCE_PATH	force a path search for type -P
+ *	CDESC_NOFUNCS	skip function lookup for type -f
+ *	CDESC_ABSPATH	convert to absolute path, no ./ prefix
+ *	CDESC_STDPATH	command -p standard path list
+ *
+ * CDESC_ALL says whether or not to look for all occurrences of COMMAND, or
+ * return after finding it once.
+ */
+int
+describe_command (command, dflags)
+     char *command;
+     int dflags;
+{
+  int found, i, found_file, f, all;
+  char *full_path, *x, *pathlist;
+  SHELL_VAR *func;
+#if defined (ALIAS)
+  alias_t *alias;
+#endif
+
+  all = (dflags & CDESC_ALL) != 0;
+  found = found_file = 0;
+  full_path = (char *)NULL;
+
+#if defined (ALIAS)
+  /* Command is an alias? */
+  if (((dflags & CDESC_FORCE_PATH) == 0) && expand_aliases && (alias = find_alias (command)))
+    {
+      if (dflags & CDESC_TYPE)
+	puts ("alias");
+      else if (dflags & CDESC_SHORTDESC)
+	printf (_("%s is aliased to `%s'\n"), command, alias->value);
+      else if (dflags & CDESC_REUSABLE)
+	{
+	  x = sh_single_quote (alias->value);
+	  printf ("alias %s=%s\n", command, x);
+	  free (x);
+	}
+
+      found = 1;
+
+      if (all == 0)
+	return (1);
+    }
+#endif /* ALIAS */
+
+  /* Command is a shell reserved word? */
+  if (((dflags & CDESC_FORCE_PATH) == 0) && (i = find_reserved_word (command)) >= 0)
+    {
+      if (dflags & CDESC_TYPE)
+	puts ("keyword");
+      else if (dflags & CDESC_SHORTDESC)
+	printf (_("%s is a shell keyword\n"), command);
+      else if (dflags & CDESC_REUSABLE)
+	printf ("%s\n", command);
+
+      found = 1;
+
+      if (all == 0)
+	return (1);
+    }
+
+  /* Command is a function? */
+  if (((dflags & (CDESC_FORCE_PATH|CDESC_NOFUNCS)) == 0) && (func = find_function (command)))
+    {
+      if (dflags & CDESC_TYPE)
+	puts ("function");
+      else if (dflags & CDESC_SHORTDESC)
+	{
+	  char *result;
+
+	  printf (_("%s is a function\n"), command);
+
+	  /* We're blowing away THE_PRINTED_COMMAND here... */
+
+	  result = named_function_string (command, function_cell (func), FUNC_MULTILINE|FUNC_EXTERNAL);
+	  printf ("%s\n", result);
+	}
+      else if (dflags & CDESC_REUSABLE)
+	printf ("%s\n", command);
+
+      found = 1;
+
+      if (all == 0)
+	return (1);
+    }
+
+  /* Command is a builtin? */
+  if (((dflags & CDESC_FORCE_PATH) == 0) && find_shell_builtin (command))
+    {
+      if (dflags & CDESC_TYPE)
+	puts ("builtin");
+      else if (dflags & CDESC_SHORTDESC)
+	{
+	  if (posixly_correct && find_special_builtin (command) != 0)
+	    printf (_("%s is a special shell builtin\n"), command);
+	  else
+	    printf (_("%s is a shell builtin\n"), command);
+	}
+      else if (dflags & CDESC_REUSABLE)
+	printf ("%s\n", command);
+
+      found = 1;
+
+      if (all == 0)
+	return (1);
+    }
+
+  /* Command is a disk file? */
+  /* If the command name given is already an absolute command, just
+     check to see if it is executable. */
+  if (absolute_program (command))
+    {
+      f = file_status (command);
+      if (f & FS_EXECABLE)
+	{
+	  if (dflags & CDESC_TYPE)
+	    puts ("file");
+	  else if (dflags & CDESC_SHORTDESC)
+	    printf (_("%s is %s\n"), command, command);
+	  else if (dflags & (CDESC_REUSABLE|CDESC_PATH_ONLY))
+	    printf ("%s\n", command);
+
+	  /* There's no use looking in the hash table or in $PATH,
+	     because they're not consulted when an absolute program
+	     name is supplied. */
+	  return (1);
+	}
+    }
+
+  /* If the user isn't doing "-a", then we might care about
+     whether the file is present in our hash table. */
+  if (all == 0 || (dflags & CDESC_FORCE_PATH))
+    {
+      if (full_path = phash_search (command))
+	{
+	  if (dflags & CDESC_TYPE)
+	    puts ("file");
+	  else if (dflags & CDESC_SHORTDESC)
+	    printf (_("%s is hashed (%s)\n"), command, full_path);
+	  else if (dflags & (CDESC_REUSABLE|CDESC_PATH_ONLY))
+	    printf ("%s\n", full_path);
+
+	  free (full_path);
+	  return (1);
+	}
+    }
+
+  /* Now search through $PATH. */
+  while (1)
+    {
+      if (dflags & CDESC_STDPATH)	/* command -p, all cannot be non-zero */
+	{
+	  pathlist = conf_standard_path ();
+	  full_path = find_in_path (command, pathlist, FS_EXEC_PREFERRED|FS_NODIRS);
+	  free (pathlist);
+	  /* Will only go through this once, since all == 0 if STDPATH set */
+	}
+      else if (all == 0)
+	full_path = find_user_command (command);
+      else
+	full_path = user_command_matches (command, FS_EXEC_ONLY, found_file);	/* XXX - should that be FS_EXEC_PREFERRED? */
+
+      if (full_path == 0)
+	break;
+
+      /* If we found the command as itself by looking through $PATH, it
+	 probably doesn't exist.  Check whether or not the command is an
+	 executable file.  If it's not, don't report a match.  This is
+	 the default posix mode behavior */
+      if (STREQ (full_path, command) || posixly_correct)
+	{
+	  f = file_status (full_path);
+	  if ((f & FS_EXECABLE) == 0)
+	    {
+	      free (full_path);
+	      full_path = (char *)NULL;
+	      if (all == 0)
+		break;
+	    }
+	  else if (ABSPATH (full_path))
+	    ;	/* placeholder; don't need to do anything yet */
+	  else if (dflags & (CDESC_REUSABLE|CDESC_PATH_ONLY|CDESC_SHORTDESC))
+	    {
+	      f = MP_DOCWD | ((dflags & CDESC_ABSPATH) ? MP_RMDOT : 0);
+	      x = sh_makepath ((char *)NULL, full_path, f);
+	      free (full_path);
+	      full_path = x;
+	    }
+	}
+      /* If we require a full path and don't have one, make one */
+      else if ((dflags & CDESC_ABSPATH) && ABSPATH (full_path) == 0)
+	{
+	  x = sh_makepath ((char *)NULL, full_path, MP_DOCWD|MP_RMDOT);
+	  free (full_path);
+	  full_path = x;
+	}
+
+      found_file++;
+      found = 1;
+
+      if (dflags & CDESC_TYPE)
+	puts ("file");
+      else if (dflags & CDESC_SHORTDESC)
+	printf (_("%s is %s\n"), command, full_path);
+      else if (dflags & (CDESC_REUSABLE|CDESC_PATH_ONLY))
+	printf ("%s\n", full_path);
+
+      free (full_path);
+      full_path = (char *)NULL;
+
+      if (all == 0)
+	break;
+    }
+
+  return (found);
+}