[SOLVED] 'command -v' for true bourne shells

orbea · 04-13-2017, 10:56 AM

As a way to learn I have been playing with different shells to see how portable I could do something and then came across this discussion on 'which' vs. 'command -v'.

https://unix.stackexchange.com/quest...at-to-use-then

Suffice to say I was not very happy with command -v, especially given it does not always have the same behavior in different shells (See mksh). So with some effort and several different iterations I came up with this function that serves most of my needs while working with at least ash (busybox and netbsd), bash, dash, ksh93, mksh, pdksh, yash and zsh.

Code:

exists () {
  v=1
  while [ "$#" -gt 0 ]; do
    arg="$1"; shift
    case "$arg" in ''|*/) continue ;; esac
    x="${arg##*/}" z="${arg%/*}"
    [ "$x" != "$z" ] || [ "$z/$x" = "$arg" ] && [ ! -f "$z/$x" ] && continue 
    [ "$x" = "$z" ] && [ -x "$z/$x" ] && [ ! -f "$arg" ] && z=
    p="$z:$PATH"
    while [ "$p" != "${p#*:}" ]; do
      d="${p%%:*}" p="${p#*:}" b="$d/$x"
      [ -f "$b" ] && [ -x "$b" ] && printf %s\\n "$b" && v=0 && break
    done
  done
  return "$v"
}

Usage:

Code:

$ exists cat
/usr/bin/cat

$ exists cat ls awk
/usr/bin/cat
/usr/bin/ls
/usr/bin/awk

$ exists foo
$ echo $?
1

$ exists foo cat
/usr/bin/cat
$ echo $?
0

However I then wondered if this would work on even older true bourne shells (See hsh and osh) and it did not. The problem was the splitting of variables with "${foo##*bar}" which these limited shells did not have, note that they do not even have 'command'...

So I then changed it to use cut instead which does work. Though this predictably suffered from the problem of calling cut several times and a rather noticeable performance drop.

Code:

exists () {
  v=1
  while [ "$#" -gt 0 ]; do
    arg="$1"; shift
    case "$arg" in ''|*/) continue ;; esac
    x="`printf %s "$arg" | cut -d '/' -f 2-`"
    z="`printf %s "$arg" | cut -d '/' -f 1`"
    [ "$x" != "$z" ] || [ "$z/$x" = "$arg" ] && [ ! -f "$z/$x" ] && continue
    [ "$x" = "$z" ] && [ -x "$z/$x" ] && [ ! -f "$arg" ] && z=
    p="$z:$PATH"
    while [ "$p" != "`printf %s "$p" | cut -d ':' -f 1`" ]; do
      d="`printf %s "$p" | cut -d ':' -f 1`"
      p="`printf %s "$p" | cut -d ':' -f 2-`"
      [ -f "$d/$x" ] && [ -x "$d/$x" ] && printf %s\\n "$d/$x" && v=0 && break
    done
  done
  return "$v"
}

So my question is there a better way of doing this? Or is it as good as it gets?

grail · 04-13-2017, 12:00 PM

Do you have access to the 'type' command? I have previously used it in place of 'which'.
It is not pretty but seemed to work, you may have to change it to be more posix correct:

Code:

#!/bin/bash

#   Used to find the location of an executable
#
#   Usage: which [paramters] executable
#

usage()
{
	cat<<-USAGE
		 
		Which is designed to tell the user where an executable is located

		Usage:      which [options] executable
		Example:    which bash

		Options:

		-i			Ignore commands not found
		-h      Display this information
		 
		USAGE

	exit 1
} #end usage

ignore=0

if (( $# == 0 ))
then
    usage
else
    while getopts ":hi" option
    do
        case $option in
					  i)  ignore=1;;
            *)  usage;;
        esac
    done

    shift $((OPTIND - 1))

    for EXE
    do
        if ! type -a $EXE 2>/dev/null
        then
						NOEXE+="$EXE\n"
        fi
    done

    (( ${#NOEXE[*]} > 0 && ignore == 0 )) && echo -e "\nThe following were not found:\n\e[1;33m${NOEXE[*]}\e[0m" >&2
fi

exit 0

MadeInGermany · 04-13-2017, 12:51 PM

Traditionally you simply set PATH at the beginning of the script, then run the plain commands.
If you have incompatble commands in different directories, you might need to think a bit about their order in the PATH.

orbea · 04-13-2017, 12:54 PM

In hsh type is expectingly limited...

Code:

type name ...
             For each name, prints if it would be executed  as  a  shell
             function,  as a special command, or as an external command.
             In the last case, the full path name to the command is also
             printed.

Also if the goal is portability, type is problematic if you consider pdksh and mksh.

Code:

$ pdksh 
$ type type
type is an alias for 'whence -v'

$ mksh
$ type type
type is an alias for '\builtin whence -v'

And if you would start a script with 'unalias -a'...

Not to mention with hsh you don't have 'unalias' or even 'alias'.

orbea · 04-13-2017, 01:11 PM

Quote:

Originally Posted by MadeInGermany

Traditionally you simply set PATH at the beginning of the script, then run the plain commands.
If you have incompatble commands in different directories, you might need to think a bit about their order in the PATH.

I think this should be a safe way to do that in pretty much every posix shell short of bash and zsh where 'unset' can be a function. This is a variation of what is explained in the posix spec for 'command' under examples.

Code:

un\set -f command unalias 2>/dev/null
un\alias -a
PATH="$(command -p getconf PATH):$PATH"

Additionally can set IFS to (space)(tab)(newline) at the top.

orbea · 06-23-2017, 08:25 AM

I just want to mention the original function had some bugs, here is a corrected version.

Code:

exists () {
  v=1
  while [ "$#" -gt 0 ]; do
    arg="$1"; shift
    case "$arg" in ''|*/) continue ;; esac
    x="${arg##*/}" z="${arg%/*}"
    [ ! -f "$z/$x" ] || [ ! -x "$z/$x" ] && [ "$z/$x" = "$arg" ] && continue
    [ "$x" = "$z" ] && [ -x "$z/$x" ] && [ ! -f "$arg" ] && z=
    p=":$z:$PATH"
    while [ "$p" != "${p#*:}" ]; do
      p="${p#*:}"; d="${p%%:*}"; b="$d/$x"
      [ -f "$b" ] && [ -x "$b" ] && printf %s\\n "$b" && v=0 && break
    done
  done
  return "$v"
}