Re: tee stdin and grep without creating a temp file

[Bart Schaefer <schaefer@xxxxxxxxxxxxxxxx>]

[This is really a question of the zsh-users variety, but ...]

On Oct 23,  2:46pm, Cary Lewis wrote:
} 
} I have a situation where I need to grep an stdin input stream, and based on
} whether I find a certain pattern, take appropriate action. The action
} involves processing the stdin stream again.

This is only going to work with a temp file, because your last step
("take appropriate action") depends on two inputs, the result of grep
and the original input stream.  That means the input stream has to be
buffered somewhere until grep gets a hit, and the only way you can do
an arbitrary amount of buffering is to use a temp file.

However, you should be able to run the grep in parallel with creating
the temp file, rather than capturing the entire output in the file
before you begin to grep it.

} I tried to create a fifo with mkfifo, and tee the stdin to the pipe
} and then grep on the output of the tee. This approach doesn't work
} correctly.

For this to work, you'd have to have something reading from the fifo
to keep the buffer from filling up.  It ought to be possible to get
this approach to work by replacing the fifo with an actual file, or to
use a zsh "multio" instead of tee.

    setopt multios # Probably not needed, this is the default
    if print -l some simulated input > bufferfile | grep -q simulated
    then read -E appropriate_action < bufferfile
    fi

Depending on how far back you need to look in the stream once the
grep succeeds, you might consider using e.g. perl for the whole task.
Buffer what you need inside the program that's doing the pattern match,
then have that program branch to the appropriate action.  This would
be particularly effective if you don't need to "look behind" at all,
that is, if it's only a matter of changing where the remainder of the
output is going once the pattern matches.

You could do that in zsh with a "while read ..." loop but that would
be slower than grep or perl on a large input.