🚀 go-pugleaf

I have been following this thread for a while, and since nobody else
seems to have said it, I will.

>>     struct fred { int i; char s [1]; } *f;
>>     char *s;
>> 
>>     /* ... */
>>     f = malloc (sizeof f + strlen (ss));

>>     f->s[1 /* or 2, or anything other than 0 */] ;

Despite all the assertions to the contrary, it seems to me that this
program does not conform to the ANSI C standards.

As is pointed out in previous posts, the pointer returned by malloc
points to an area big enough for the job.  In fact, the following
should be legal:

    char*           p = malloc( sizeof( struct fred ) + strlen( ss ) ) ;
    p += offsetof( struct fred , s ) ;
    p[ 1 /* Or anything up to the end of the malloced memory */ ]

The problem with the example is that the pointer under consideration
is *not* the pointer returned from malloc, but rather the results of
the pointer expression f->s (which has a type of char*).  Note that
this is definitely a pointer to an array object (sizeof( f->s ) == 1),
and so according to the ANSI standard, bounds checking is allowed.

In the reality, I suspect that any compiler that actually did this
would break a lot of code (including some of my own).
--
James Kanze                     GABI Software, Sarl.
email: kanze@us-es.sel.de       8 rue du Faisan
                                67000 Strasbourg
                                France