While statement: Cannot get compound of multiple conditions to work

Question

I try to parse arguments by a recursive descent schema.

The while statements calls an eat! function after every execution to get the next $current_token to process.

The problem now is that this way it goes into an infinite loop.

To be exact, there are two while loops in the function.

Either one of them or both are not working because the compound is syntactically (or logically?) wrong.

Could you please check what might be wrong with the following code on the many levels possible?

1)

while $(isWord? $current_token) || ! $(isVersionNumber? $current_token) && ! $(endOfInput?); do

while isVersionNumber? $current_token && ! endOfInput?; do

Also what is correct? To put the checking-functions in a command substitution or not?

Could it be that short-circuiting also prevents the endOfInput?-test ?

Because that should absolutely stop the loop.

On request of ilkkachu

The test functions' code:

isWord? () {
    local pattern="^[a-zA-Z0-9_-]+$"
    if [[ $1 =~ $pattern ]]; then
        echo true
    else
        echo false
    fi
}

isVersionNumber? () {
    local pattern="^[0-9]{1,2}(\.[0-9]{,2})*$"
    if [[ $1 =~ $pattern ]]; then
        echo true
    else
        echo false
    fi
}

EO_ARGS=1

function endOfInput? {
 if [ $current_token_index -ge $ARGC ]; then
    EO_ARGS=0
 fi
 echo $EO_ARGS
}

I assume it outputs another command, since you're using it in a command substitution?

No it was just a try because I don't know whether or not I can just call the functions in the conditional without command substitution.

For completeness' sake, I also add the eat! function.

eat! () {
    
if [[ ! $(($current_char_index + 1)) -gt $ARGC ]]; then
  current_token=${ARGV[$current_token_index]}
  ((current_token_index += 1))

  current_char=${current_token:0:1}
}

And may the conditions maybe be formulated better with test / [ ([[) ?

Could the exclamation mark be the point of failure?

The following seems to be syntactically wrong:

while [ endOfInput -eq 1 ] && isWord? "$current_token" || ! isVersionNumber? "$current_token"; do

From the bracket [ I get the error message

[: endOfInput: integral expression expected (translation)

Answer 1

If a function return 0 for true and anything else for false, you can use it directly:

my-true () {
    return 0
}

while my-true ; do
    echo Infinite loop...
done

If it outputs nothing when false but outputs something when true, use command substitution

my-true () {
    echo OK
}
while [ "$(my-true)" ] ; do
    echo Infinite loop...
done

To chain the functions in the former case, you can use the && and || operators:

while func1 && func2 ; do

In the latter case, you can use concatenation instead of ||:

while [ "$(func1 ; func2)" ] && [ "$(func3)" ]

Note that in the latter case, you can't modify global variables in the function, as it's called in a subshell.

BTW, using ? in a function name is not forbidden, but it may cause problems, as it's a wildcard:

abc? () {
    return $1
}
abc? 0   # Everything OK.
touch abcX
abc? 0   # line 9: ./abcX: Permission denied
abc\? 0  # This works, but where's the charm?

! is the default history expansion character, but that's mostly relevant to interactive shells only.

Answer 2

Could you please check what might be wrong with the following code on the many levels possible?

Ok, fine.

Also what is correct? To put the checking-functions in a command substitution or not?

A command substitution takes the what ever the command inside prints, and puts that on the command line. (After splitting and globbing, if the expansion was unquoted.) So if you have

foo() {
    echo true
}
if $(foo); then
    echo hello
fi

then the command substitution would produce true and that would run in the condition part of the if-statement, and the exit status from it would be used to determine if the main branch of the if runs. It would, in this case.

But that's silly. You could just return the exit status from directly, without going through a command substitution (which in Bash involves a fork):

foo() {
    return 0
}
if foo; then
    echo hello
fi

Or you could just end the function with true, since the exit status of the last command is used as the exit status of the function.

So you could write:

isWord? () {
    local pattern="^[a-zA-Z0-9_-]+$"
    if [[ $1 =~ $pattern ]]; then
        return 0
    else
        return 1
    fi
}
while isWord? "$current_token"

or even:

isWord? () {
    local pattern="^[a-zA-Z0-9_-]+$"
    [[ $1 =~ $pattern ]]
}
while isWord? "$current_token"

Note that you need to quote the variable, for the all the usual reasons (i.e. word splitting and globbing).

while $(isWord? $current_token) || ! $(isVersionNumber? $current_token) && ! $(endOfInput?); do

Here, note that the a || b && c construct groups as (a || b) && c, i.e. it executes left to right. Unlike in real programming languages where an and operator has higher precedence than or (meaning it would be a || (b && c) instead). So, check which one you need.

Also, while with default settings on Bash, a name like isWord? is perhaps not a problem too often, it is still a glob. If you have a file or files matching it in the current directory, it will be expanded to those filenames. And if you switch to using failglob or nullglob, they'll affect that too. E.g. with failglob:

$ foo? () { echo hi; }
$ foo?
bash: no match: foo?
$ "foo?"
hi

You'd need to quote it to make not behave as a glob. Note that in Zsh, an unmatching glob fails by default.

The bang as the last character of a function name shouldn't matter. It could hit history expansion if it was at the start or the middle of the name, and the shell had history expansion on (interactive shells do by default, scripts don't).

Could it be that short-circuiting also prevents the endOfInput?-test ?

If you have something like while bar && ! endOfInput?; do, then yes, if bar on the left-hand side returns a falsy status, the result of the and is already known, and the right-hand side is skipped. Similarly for || and a truthy returh. That's what && and || do.

But you didn't give any context to this question, i.e. why it would matter to you if the function isn't called, so it's hard to think of better ways to do it.