How to pass files found by find as arguments?

Question

First to cut off trivial but inapplicable answers: I can use neither the find+xargs trick nor its variants (like find with -exec) because I need to use few such expressions per call. I will get back to this at the end.

---

Now for a better example let's consider:

$ find -L some/dir -name \*.abc | sort
some/dir/1.abc
some/dir/2.abc
some/dir/a space.abc

How do I pass those as arguments to program?

Just doing it doesn't do the trick

$ ./program $(find -L some/dir -name \*.abc | sort)

fails since program gets following arguments:

[0]: ./program
[1]: some/dir/1.abc
[2]: some/dir/2.abc
[3]: some/dir/a
[4]: space.abc

As can be seen, the path with space was split and program considers it to be two different arguments.

Quote until it works

It seems novice users such as myself, when faced with such problems, tend to randomly add quotes until it finally works - only here it doesn't seem to help…

"$(…)"

$ ./program "$(find -L some/dir -name \*.abc | sort)"
[0]: ./program
[1]: some/dir/1.abc
some/dir/2.abc
some/dir/a space.abc

Because the quotes prevent word-splitting, all the files are passed as a single argument.

Quoting individual paths

A promising approach:

$ ./program $(find -L some/dir -name \*.abc -printf '"%p"\n' | sort)
[1]: "some/dir/1.abc"
[2]: "some/dir/2.abc"
[3]: "some/dir/a
[4]: space.abc"

The quotes are there, sure. But they are no longer interpreted. They are just part of the strings. So not only they did not prevent word splitting, but also they got into arguments!

Change IFS

Then I tried playing around with IFS. I would prefer find with -print0 and sort with -z anyway - so that they will have no issues on "wired paths" themselves. So why not force word splitting on the null character and have it all?

$ ./program $(IFS=$'\0' find -L some/dir -name \*.abc -print0 | sort -z)
[0]: ./program
[1]: some/dir/1.abcsome/dir/2.abcsome/dir/a
[2]: space.abc

So it still splits on space and does not split on the null.

I tried to place the IFS assignment both in $(…) (as shown above) and before ./program. Also I tried other syntax like \0, \x0, \x00 both quoted with ' and " as well as with and without the $. None of those seemed to make any difference…

---

And here I'm out of ideas. I tried few more things but all seemed to run down to the same problems as listed.

What else could I do? Is it doable at all?

Sure, I could make the program accept the patterns and do searches itself. But it is a lot of double work while fixing it to a specific syntax. (What about providing files by a grep for example?).

Also I could make the program accept a file with a list of paths. Then I can easily dump find expression to some temp file and provide the path to that file only. This could supported be along direct paths so that if user has just a simple path it can be provided without intermediate file. But this doesn't seem nice - one needs to create extra files and take care of them, not to mention extra implementation required. (On the plus side, however, it could be a rescue for cases in which the number of files as arguments start to cause issues with command line length…)

---

At the end, let me remind you again that find+xargs (and alike) tricks will not work in my case. For description simplicity I'm showing only one argument. But my true case looks more like this:

$ ABC_FILES=$(find -L some/dir -name \*.abc | sort)
$ XYZ_FILES=$(find -L other/dir -name \*.xyz | sort)
$ ./program --abc-files $ABC_FILES --xyz-files $XYZ_FILES

So doing an xargs from one search still leaves me with how to deal with the other one…

Answer 1

Use arrays.

If you don't need to handle the possibility of newlines in your filenames, then you could get away with

mapfile -t ABC_FILES < <(find -L some/dir -name \*.abc | sort)
mapfile -t XYZ_FILES < <(find -L other/dir -name \*.xyz | sort)

then

./program --abc-files "${ABC_FILES[@]}" --xyz-files "${XYZ_FILES[@]}"

If you do need to handle newlines within filenames, and have bash >= 4.4, you can use -print0 and -d '' to null-terminate the names during array construction:

mapfile -td '' ABC_FILES < <(find -L some/dir -name \*.abc -print0 | sort -z)

(and similarly for the XYZ_FILES). If you don't have the newer bash, then you could use a null-terminated read loop to append filenames to the arrays e.g.

ABC_FILES=()
while IFS= read -rd '' f; do ABC_FILES+=( "$f" ); done < <(find -L some/dir -name \*.abc -print0 | sort -z)

Answer 2

You can use IFS=newline (assuming no filenames contain newline) but you must set it in the outer shell BEFORE the substitution:

$ ls -1
a file with spaces
able
alpha
baker
boo hoo hoo
bravo
$ # note semicolon here; it's not enough to be in the environment passed
$ # to printf, it must be in the environment OF THE SHELL WHILE PARSING
$ IFS=$'\n'; printf '%s\n' --afiles $(find . -name 'a*') --bfiles $(find . -name 'b*')
--afiles
./able
./a file with spaces
./alpha
--bfiles
./bravo
./boo hoo hoo
./baker

With zsh but not bash you can use null $'\0' as well. Even in bash you could handle newline if there's one sufficiently strange character that is never used like

 IFS=$'\1'; ... $(find ... -print0 | tr '\0' '\1') ...

However, this approach does not handle the additional request you made in comments on @steeldriver's answer to omit the --afiles if find a is empty.

Answer 3

I'm not sure I understand why you gave up on xargs.

So doing an xargs from one search still leaves me with how to deal with the other one…

The string --xyz-files is just one of many arguments and there's no reason to consider it special before it is interpreted by your program. I think you can pass it through xargs among both find results:

{ find -L some/dir -name \*.abc -print0 | sort -z; echo -ne "--xyz-files\0"; find -L other/dir -name \*.xyz -print0 | sort -z; } | xargs -0 ./program --abc-files