How to detect using of wildcard (asterisk *) as parameter for shell script?

Question

In my script, how can I distinguish when the asterisk wildcard character was used instead of strongly typed parameters?

This

# myscript *

from this

# myscript p1 p2 p3 ... (where parameters are unknown number)

Answer 1

You can't.

It is one of the strengths (or, in some eyes, weaknesses) of Unix.

See the diatribe(s) in "The UNIX-HATERS Handbook".

Answer 2

$arg_num == ***; // detects *(literally anything since it's a global wildcard)
$arg_num == *_*; // detects _

here is an example of it working with _

for i in $*
  do
    if [[ "$i" == *_* ]]; 
      then echo $i; 
    fi
  done

output of ./bash test * test2 _

_

output of ./bash test * test2 _ with *** rather then *_*

test
bash
pass.rtf
test2
_

NOTE: the * is so global in bash that it printed out files matching that description or in my case of the files on my oh-so-unused desktop. I wish I could give you a better answer but the best choice it to use something other then * or another scripting language.

Answer 3

If this is something you feel you must do, perhaps:

# if the number of parms is not the same as the number of files in cwd
# then user did not use *
dir_contents=(*)
if [[ "${#@}" -ne "${#dir_contents[@]}" ]]; then 
    used_star=false
else
    # if one of the params is not a file in cwd
    # then user did not use *
    used_star=true
    for f; do [[ ! -a "$f" ]] && { used_star=false; break; }; done
fi
unset dir_contents

$used_star && echo "used star" || echo "did not use star"

Pedantically, this will echo "used star" if the user actually used an asterisk or if the user manually entered the directory contents in any order.

Answer 4

The shell expands the wildcard. By the time a script is run, the wildcard has been expanded, and there is no way a script can tell whether the arguments were a wildcard or an explicit list.

Which means that your script will need help from something else which is not a script. Specifically, something which is run before command-line processing. That something is an alias. This is your alias

alias myscript='set -f; globstopper /usr/bin/myscript'

What this does is set up an alias called 'myscript', so when someone types 'myscript', this is what gets run. The alias does two things: firstly, it turns off wildcard expansion with set -f, then it runs a function called globstopper, passing in the path to your script, and the rest of the command-line arguments.

So what's the globstopper function? This:

globstopper() {
  if [[ "$2" == "*" ]]
    then echo "You cannot use a wildcard"
    return
  fi
  set +f
  "$@";
}

This function does three things. Firstly, it checks to see if the argument to the script is a wildcard (caveat: it only checks the first argument, and it only checks to see if it's a simple star; extending this to cover more cases is left as an exercise to the reader). Secondly, it switches wildcard expansion back on. Lastly, it runs the original command.

For this to work, you do need to be able to set up the alias and the shell function in the user's shell, and require your users to use the alias, not the script. But if you can do that, it ought to work.

I should add that i am leaning heavily on the resplendent Simon Tatham's essay 'Magic Aliases: A Layering Loophole in the Bourne Shell' here.