(K&R) At least the first 31 characters of an internal name are significant?

Question

When taken literally, it makes sense, but what exactly does it mean to be a significant character of a variable name?

I'm a beginning learner of C using K&R. Here's a direct quote from the book:

"At least the first 31 characters of an internal name are significant. For function names and external variables, the number may be less than 31, because external names may be used by assemblers and loaders over which the language has no control. For external names, the standard guarantees only for 6 characters and a single case."

By the way, what does it mean by "single case"?

Answer 1

Single Case usually means "lower case". Except in some OS's where it means "upper case". The point is that mixed case is not guaranteed to work.

abcdef

ABCDEF

differ only in case. This is not guaranteed to work.

The "Significance" issue is one of how many letters can be the same.

Let's say we only have 6 significant characters.

a_very_long_name

a_very_long_name_thats_too_similar

Look different, but the first 16 characters are the same. Since only 6 are significant, those are the same variable.

Answer 2

It means that :

foobar1
foobar2

might be the same external name, because only the first 6 characters need be considered. The single case means that upper and lower case names need not be distinguished.

Please note that almost all modern linkers will consider much longer names, thogh there will still be a limit, dependent on the linker.

Answer 3

It just means that if you have two variables named

abcdefghijklmnopqrstuvwxyz78901A,

and

abcdefghijklmnopqrstuvwxyz78901B,

that there is no guarantee that will be treated as different, separate variables...

Answer 4

It means what you fear it means. For external names, the C standard at the time K&R 2nd ed. was written really does give only six case-insensitive characters! So you can't have afoobar and aFooBaz as independent entities.

This absurd limitation (which was to accommodate legacy linkers now long-gone) is no longer relevant to any environment much. The C99 standard offers 31 case-sensitive characters for external names and 63 internally, and commonly-used linkers in practice support much longer names.

Answer 5

G'day,

One of the problems with this limited symbol resolution occurs at link time.

Multiple symbols with the same name can exist across several libraries and the link editor usually only takes the first one it finds that matches what it is looking for.

So, using S.Lott's example from above, if your link editor is searching for the symbol "a_very_long_name" and it finds a library on its search path that contains the symbol "a_very_long_name_thats_too_similar" it will take this one. This will happen even if the library that contains the symbol that you want, i.e. "a_very_long_name" has been specified in your command. For example specifying the libraries as:

-L/my/library/path -lmy_wrong_lib -lmy_correct_lib

There are now compiler options, or more correctly compile time options which are passed through to the link editor, which enforce a search for multiple symbols in your link path. These are then usually raised as errors at link time.

In addition, many compilers, e.g. gcc, will default to such behaviour. You have to explicitly enable multiple definitions to allow the link editor to proceed without raising a fatal error if it finds multiple definitions for a symbol.

BTW I'd highly recommend working through the exercises in conjunction with Clovis Tondo's book "The C Answer Book 2nd ed.".

Doing this really helps make C stick in your mind.

HTH

cheers,