Hacker News Reader

Comment by kazinator | Hacker News Reader

This invokes UB, unfortunately. It works where it works.

ISO C says that:

"The parameters argc and argv and the strings pointed to by the argv array shall be modifiable by the program, and retain their last-stored values between program startup and program termination."

Thus within the boundaries of defined ISO C, you can do this:

  argv++;       // argv pointer to array element modifiable

and you can do this:

  argv[0][0]++; // the string pointed to by the array is modifiable.

but not this:

  argv[0]++;    // array itself (the pointers) not required to be modifiable

I seem to recall finding a problem like this in the K&R2 book also, probably close to thirty years ago. I don't have the book now, but the page number 117 seems to be coming up in my dim memory.

View on HN

Oh, wow thanks. I made sure to check the strings are modifiable, but that *argv may not be modifiable never occurred to me, I suppose this is an easy enough fix, I'll look into it later.

Edit: I just saw this SO comment [0]:

> The standard calls argv consistently an array. Modifying an array refers to modifying its members. Thus, it seems obvious that the wording in the standard refers to modifying the members in the argv array, when it states that argv is modifiable.

It is still a mater of interpretation so you shouldn't depend on it.

[0] https://stackoverflow.com/questions/35105918/are-the-pointer...

I don't see the interpretation issue. The "parameters argc and argv" are the scalar, local variables. "argv array" is the object that "parameter argv" points to; it is not a parameter.

The modifiability of argv was the subject of at three items in 1998 in meeting n849.

https://www.open-std.org/jtc1/sc22/wg14/www/docs/n849.htm

Someone proposed that clarifying text be added saying "Whether or not the pointers of the argv array shall be modifiable by the program is implementation-defined. If they are modifiable, they shall retain their last-stored values between program startup and program termination." This was rejected due to insufficient interest.

It was proposed that, since of course parameters are modifiable, the sentence in question be shortened to "The strings pointed to by the argv array shall be modifiable by the program, and retain their last-stored values between program startup and program termination", omitting the mention of "parameters argc and argv". This was discussed, but not accepted.

The question was raised whether the pointers are modifiable. Response was: "This is currently implictly unspecified and the committee has chosen to leave it that way."

I'm skeptical there's a single C compiler out there that makes the first two behave as expected but not the third. In fact, I wouldn't be surprised if the real oversight is that the standard meant to say all three, or that the authors thought it implied.

It's not necessarily up to a compiler, or its program setup stub code, but possibly up to the host environment.

Of course argv is mutable since it's a local variable/param. But what if the pointers are placed, by the OS, into read-only VM pages? Begrudgingly, the string data is made writable though, to conform to the standard.

Please name one platform where this is the case.

Another thing to consider is that the pointers may be writable, but changing them causes harm. E.g. suppose argv[] is prepared by a function which dynamically allocates each pointer, and then the run-time calls free on it when the program exits. According to ISO C, that would be conforming.

I don't know of any platform where there are any ill effects. But the number of platforms out there with C implementations is much larger than my direct experience. Maybe this is just some historic baggage that is overdue for a revision. It was discussed in 1998, but no changes were accepted at the time.

In most coding situations, I probably wouldn't care, the same way I don't care about, say, platforms where for some reason you cannot compare pointers to distinct objects using inequality (another thing not required by ISO C). It's better to break the rules knowingly, though. You want to be badass, not dumbass.

Reply on news.ycombinator.com