Date: Fri, 21 Feb 2025 10:55:56 -0500
From: Chet Ramey <chet.ra...@case.edu>
Message-ID: <c697bcba-3a24-499d-9702-0567be1b9...@case.edu>
| That is bizarre and indefensible.
Like I said, it isn't what I'd do, but it is easy to see how an
implementation might end up like that (and ksh93's might be one of
the first of them, which kind of sets the standard). But if it
has been fixed in a later version (I also have not updated the one
I have in a while) then this really no longer matters.
| There is no user who would think that using a numbered conversion
| specifier is not an absolute position in the original argument list.
Probably not, but it doesn't matter if the application doesn't mix
numbered and unnumbered conversions, and it shouldn't.
| ksh93 seems to be alone in its interpretation.
Apparently was. But there are plenty of other differences between
the implementations when it comes to mixing numbered and numbered
args, one being what is the sequence of the unnumbered args when
interleaved with numbered args.
That is, in the example
printf '%s %3$s %s\n' A B C D
The updated ksh93 seems to ignore the numbered conversions when counting
the args for the unnumbered ones (so "A C B" (for the first line anyway,
I won't go on about repeating the format string again).
The previous version made an unnumbered arg conversion use the next arg
after the last one used (which would give "A C D" using a more reasonable
interpretation of %3$).
A third possibility is to simply observe that it is the third conversion,
and so should use the third arg, thus giving "A C C". It might be tempting
to say "except skip any args used by numbered conversions" but that leads
to bizarre special cases, eg: consider
printf '%s %s %s %3$s %s\n' A B C D
and decide what that is supposed to do, and if you conclude something
about that one, apply the same rule to
printf '%s %$4s %s %s %s' A B C D
and see if you like the result. Try this same test whichever of these
three rules you'd adopt -- or even some other possibility I haven't
considered, another, somewhat weird one, might be to restart the numbering
sequence for unnumbered args after any numbered arg conversion, which would
lead to "A C A" in the original (again, just the first line).
When I was looking at implementing this (I actually had an implementation
that I ended up discarding, as I was never going to to the "rescan the
format" in the numbered conversion case) I tested all the printf
implementations which implemented numbered conversions that I could find,
and they were all amazingly different - it is no surprise at all that
POSIX made mixing the things unspecified (it is also an amazingly useless
thing to support in general, and simply issuing an error and not
proceeding with any further conversions once the first "different" style
of arg reference is encountered is not at all a bad choice).
| It's worse -- even if a format string using only numbered conversions
| doesn't consume all the arguments, as long as it consumes the last one,
| the format string doesn't get reused. It all depends on whatever peculiar
| definition of "satisfy" you use.
Yes, which is where the trick of including a conversion "%999$.0s" in the
format string is supposed to stop format string reuse -- as long as there are
no more than 999 args given of course. This issue has nothing to do with the
mixed numbered/unnumbered problem, which rightly should just be unspecified,
and implementations do whatever they like, reasonable or not (as in the eye
of the coder), but that format string reuse is simply wrong in the numbered
conversion case, no-one really needs that.
kre
