On Thu, 31 May 2007, Les wrote:
On Thu, 2007-05-31 at 18:44 -0500, Mike McCarty wrote:
Les Mikesell wrote:
Mike McCarty wrote:
[Les wrote about "older" compilers]
Older? ANSI C is since 1989. I guess one could characterize 19 years
as "older". :-)
C was old before ANSI came along. Maybe we could revive the discussion
of why "abcd" must evaluate to 'c'.
I wasn't explicit enough, I guess. I wouldn't characterize
19 years as "older", but rather as "antique" or "ancient"
in this context. I was objecting to using too weak a word,
not too strong a word :-)
I'm sorry, I don't think of myself as antique or ancient. You assume
that all C compilers are ANSI compliant. They are not. K&R was around
a long time before the standards committee got involved. And although
the standard may have been generated in 1989, Microsoft didn't implement
the ANSI standard for several years after that, and then failed some of
the standard tests. SUN's compiler was not ANSII compliant until about
1994 or so. There are many compilers out there, and most are probably
not fully compliant either. AND I do know that the variables are not
initialized in many compilers. I have fixed code for many, many people.
If static variables are not initialized, those compilers are broken. K&R
woud tell you so even for pre-ANSI/ISO compilers.
I know why their programs failed. I also know that C uses a pushdown
stack for variables in subroutines. You can check it out with a very
simple program using pointers:
printf ("%d %d %d\n",*x++,*X++;*X++);
printf ("%d %d %d\n",*x++,*x++,*x++);
printf ("%d %d %d\n",*x++,*x++,*x++);
Just an exercise you understand. compile and run this with several c
packages, or if the package you choose supports it, have it compile K&R.
and try it.
Of course, several constructs here are undefined, so there is no such
thing as "correct" or "incorrect" behavior.
After correcting obvious typos and adding #include <stdio.h> so it would
compile, I got (using gcc-4.1.1-51.fc6 with no options):
5 4 6
0 0 0
0 0 0
Was that what you were expecting?
I cannot vouch for every compiler, only Microsoft, Sun, and Instant C
off the top of my head. I have used a few other packages as well. But
any really good programmer NEVER relies on system initialization. It is
destined to fail you at bad times.
How much effort are you willing to expend to defend against potentially
buggy compilers (as opposed to undefined or implementation-defined
behaviors)? The Intel fdiv bug would seem to prove that you should NEVER
rely on arithmetic instructions to provide the correct answer. There's an
economic tradeoff between protecting yourself from all conceivable errors
and actually getting work done.
One case is as has been pointed out
here, that NULL is sometimes 0, sometimes 0x80000000, and sometimes
0xffffffff. Even NULL as a char may be 0xFF 0xFF00 or 0x8000 depending
on the implementation. But strings always end in a character NULL or
0x00 for 8 bit ascii, if you use GNU, Microsoft, or Sun C compilers.
They may do otherwise on some others. It can byte (;-) you if you are
In your source code, NULL is *always* written 0 (or sometimes (void *) 0
to indicate that it's intented to stand for a null pointer value, not a
NUL character value). The string terminator character is *always* written
'\0'. The machine's representation of that value is immaterial. If you
type-pun to try to look at the actual machine's representation, your
program's behavior is undefined and you deserve what you get. It's the
compiler's responsibility to ensure that things work as expected, no
matter what the machine's representation is. (For example, '\0' == 0 must
And since that is so, how are those variables initialized? and to
what value? What is a pointer set to when it is intialized. Hint, on
Cyber the supposed default for assigned pointers used to the the address
of the pointer. Again, system dependencies may get you.
Pre-ANSI/ISO compilers might have initialized static memory to
all-bits-zero even when that was not the correct representation of the
default for the type being initialized. ANSI/ISO compilers are not
allowed to do that. The required default initializations are well
defined. (This is the sort of thing that motivates the creation of
standards in the first place.)
And those systems that used the first location to store the return
address are not re-entrant, without other supporting code in the
background. I think I used one of those once as well.
There's no requirement for re-entrancy in K&R or ANSI/ISO. In fact
several standard library routines are known to not be re-entrant.
PS. A stack doesn't necessarily mean a processor call and return
stack. It is any mechanism of memory address where the data is applied
to the current location, then the pointer incremented (or decremented
depending on the architecture).
But usually in the context of discussions about compiler architectures,
call stacks are exactly what is meant.
Clemson University Math Sciences
mjs AT clemson DOT edu