You're dereferencing an uninitialized pointer. The C programming language does not guarantee that this will work.
> is it a different implementation of the routine in this operating system?
Yes, the implementation is different.
HP-UX contains HP's own C library, while Linux uses open-source GNU glibc.
By ANSI C, the strcmp(3) function is not required to accept NULL parameters. This may be a feature of some standards that HP-UX complies with but Linux does not. Or it might be a HP-UX specific feature.
You're also making three dangerous assumptions:
1.) that the uninitialized memory location assigned to store **x contains by default a bit pattern that is equivalent to a NULL pointer.
This depends on the hardware architecture and OS implementation, and is not generally guaranteed.
2.) that you can dereference a NULL pointer, i.e. you can read *(NULL).
Whenever possible, Linux guarantees that this *is not* true.
I understand that in modern Linux, the NULL address is usually "booby-trapped", so that any attempt to dereference it is guaranteed to cause the program to crash immediately with a segmentation fault. As a result, the platform will force you to break bad habits and to write portable code.
3.) that there is a NULL value at the end of the NULL pointer:
( (void *) *(NULL) ) == NULL
The original ANSI C standard does not define this; the result of dereferencing a NULL pointer will be platform-specific undefined behaviour. Any program that assumes it can successfully dereference a NULL pointer will not be _portable_ ANSI C.
In program code:
char **x;
x = NULL;
printf("If this program crashes now, assumption 2 is incorrect because *x is not accessible\n");
if ( *x == NULL ) {
printf("Assumptions 2 and 3 are correct, at least this time.\n");
} else {
printf("Assumption 2 is correct but assumption 3 is incorrect: *x is accessible but is not NULL\n");
}
By what I understand, these assumptions used to be valid in HP-UX (older PA-RISC versions at least). This allows some pointer algorithms to be written in more compact form, with less explicit tests for NULL.
But later this has been found to encourage sloppy thinking and sloppy coding. It also causes pain when code must be ported from an architecture that allows dereferencing NULL to an architecture that doesn't.
(For example, in the old Commodore 64, the memory addresses 0x0000 and 0x0001 contained important hardware control registers. Because there was no MMU and no way to create a virtual address space for user-space process, setting *(NULL) to NULL would have, among other things, disabled all system ROMs and started the cassette tape drive motor.)
MK
MK
