Very Computer

while test "$1" != ""
do
        case "$1" in
                -i) input=$2; shift ;;
                [+\-][0-9]*) version=$1 ;;
                -v) month=$2; day=$3; shift; shift ;;
                -d) del="yes" ; echo "XX" ;;
                -*) echo "get: unknown argument $1" 1>&2; exit 1 ;;
                *)  file=$1 ;;
        esac
        shift
done

The echo "XX" statement is only for debugging.

Anyway, when $1 is "-d", the test statement exits false, and the -d)
line in the case statement is not executed.  Any arguments after this
one are ignored by the while statement.  When I change the line in the
case statemet to -b) , the script works as expected.

What gives?

k

--

--    Bull Nederland NV, Product Support Unix, Amsterdam, The Netherlands

Many versions of test have problems when doing string comparisions,
when the first argument starts with a '-'.  Change it to read:

while test "x$1" != "x"
...

        -Jeff
--

Quote:(Karl Anderson) writes:
> I'm trying to write a dinky sh script which contains the following
> while loop:

> while test "$1" != ""
> do
>         case "$1" in
>                 -i) input=$2; shift ;;
>                 [+\-][0-9]*) version=$1 ;;
>                 -v) month=$2; day=$3; shift; shift ;;
>                 -d) del="yes" ; echo "XX" ;;
>                 -*) echo "get: unknown argument $1" 1>&2; exit 1 ;;
>                 *)  file=$1 ;;
>         esac
>         shift
> done

> The echo "XX" statement is only for debugging.

> Anyway, when $1 is "-d", the test statement exits false, and the -d)
> line in the case statement is not executed.  Any arguments after this
> one are ignored by the while statement.  When I change the line in the
> case statemet to -b) , the script works as expected.

  while test $# -ne 0

instead of

  while test "$1" != ""

Second answer:  Testing the equality of strings is a bit tricky.  If $1
equals "-d", then the shell expands

  while test "$1" != ""

to

  while test -d != ""

Now "test" sees "-d" (= "does directory exist?") and consequently checks
whether you have a directory called "!=".  Since you don't have such
a directory, the test fails.

The safe way to write a string comparison is to prepend some string that
is never interpreted by "test" to both arguments.  For example

  test "xxx$1" != 'xxx'

if you want to check whether $1 is not the empty string, or

  test "FOO$1" = "FOO$TEST"

if you want to check whether $1 equals $TEST.

--
Uwe Waldmann, Max-Planck-Institut fuer Informatik
Im Stadtwald, D-W6600 Saarbruecken 1, Germany

        while test -n "$1"

Just use
        while test x"$1" != x""
        do
                something
        done
and you will be happy.

Bye,
   UST
--
Ulrich STeimann, Quantum GmbH,    | Descartes enters a pub.
D-4600 Dortmund                   | "Evening, Descartes. Same as usual?"

Tel: +49-0231-75441-151, FAX -115 | -- and disappears.

In any case, when you're processing every word on the command line,
it's better to test the count of arguments being greater than 0:

while [ $# -gt 0 ] ; do
        case $1 in
        ...
        esac
        shift
done

Also, if you're going to be processing options that have their own
arguments, it's better to bite the bullet and use getopts(1) if you
have it, or getopt(1) if you don't.  Wierd cases come up when a
command requires that an option's argument take the form of a
suffix.  SCCS commands do that.  So what getopts (or getopt) pulls
apart, you sometimes have to put back together:

while getopts abo: c
do
        case $c in
        a | b)    opts="$opts -$c" ;;
        o)        opts="$opts -${c}${OPTARG}" ;;
        \?)       echo $usage
        esac
done
shift `expr $OPTIND - 1`

The "o" case sticks the option and argument back together.

-r

It may be that your shell sees the "test -d ..." as a test for what follows
to be a file that exists and is a directory.  You could prevent this (if it
is the case) by adopting a convention often used to obviate having to quote
(possibly null) strings in a "test", by prepending a character to the values
being compared:

        while test x$1 != x""

Or you might substitute:

        while test -n "$1"    or      while test $# -ne 0

Or, you might investigate the shell builtin "getopts" (if your shell has
it) or the UNIX program "getopt" (if your system has it), which are meant
to ease/standardize handling arguments given to shell scripts.  They have
the advantage of allowing a switch/flag followed by an argument to given
either with or without intervening whitespace with equivalent effect.

--

--

| while test "$1" != ""
| do
|         case "$1" in
|                 -i) input=$2; shift ;;
|                 [+\-][0-9]*) version=$1 ;;
|                 -v) month=$2; day=$3; shift; shift ;;
|                 -d) del="yes" ; echo "XX" ;;
|                 -*) echo "get: unknown argument $1" 1>&2; exit 1 ;;
|                 *)  file=$1 ;;
|         esac
|         shift
| done

| Anyway, when $1 is "-d", the test statement exits false, and the -d)
| line in the case statement is not executed.  Any arguments after this
| one are ignored by the while statement.  When I change the line in the
| case statemet to -b) , the script works as expected.

test understands "-d" as one of its own operator.  test -d != "" looks like
"while there exists a directory named !=" and the trailing "" is ignored; or
perhaps something similar happens.  At any rate, -d is a standard test
operator whereas -v, -i, and -b are not.

Some versions of test allow a - or -- option to make sure that all the rest
of the command line arguments are taken as strings.  This is surer, though:

while test Z"$1" != "Z"
do
        [your case structure, unchanged]
        shift
done

David W. Tamkin   Box 59297   Northtown Station, Illinois  60659-0297