bv3456@leah.albany.edu (Victor @ The Concrete Museum) (10/27/89)
I thought I read somewhere on this group that C++ now has "type-safe" linkage. Is this so, or was I halucinating? If such a feature exists, how is it done? Many thanks. - victor
jnh@ecemwl.ncsu.edu (Joseph N. Hall) (10/27/89)
In article <2118@leah.Albany.Edu> bv3456@leah.albany.edu (Victor @ The Concrete Museum) writes: > >I thought I read somewhere on this group that C++ now has "type-safe" >linkage. Is this so, or was I halucinating? If such a feature exists, >how is it done? The type information is encoded into the "mangled" function names. Two functions with the same name but different argument or return types are given distinct mangled names. This requires no extra smarts on the part of the linker, although it does require that the linker handle relatively long symbols (I don't know what the minimum allowed by C++ 2.0 is, but I'd guess it's around 32 characters). This also allows the linker to catch usage errors resulting from improperly declared functions (or undeclared functions), or functions called with the wrong number/types of arguments, etc. All in all it's a pretty good deal; it's unlikely that linkers that can cope with type information will be ubiquitous any time soon, and this is about as elegant a workaround as is possible within the constraints of C++ and the UNIX-like environment. See the "Selected Readings" book from AT&T for the Stroustrup paper about this feature. v v sssss|| joseph hall || 4116 Brewster Drive v v s s || jnh@ecemwl.ncsu.edu (Internet) || Raleigh, NC 27606 v sss || SP Software/CAD Tool Developer, Mac Hacker and Keyboardist -----------|| Disclaimer: NCSU may not share my views, but is welcome to.
smb@ulysses.homer.nj.att.com (Steven M. Bellovin) (10/27/89)
In article <2118@leah.Albany.Edu>, bv3456@leah.albany.edu (Victor @ The Concrete Museum) writes: > > I thought I read somewhere on this group that C++ now has "type-safe" > linkage. Is this so, or was I halucinating? If such a feature exists, > how is it done? Yes, it's true. It's done by name-mangling; if you have a function foo, it will be emitted as something quite ghastly by cfront. For example, cfront translated this: int foo() {return 0;}; int foo(char s) {return s;}; int foo(char s, char t) {return s;}; into this: int foo__Fv (){ return (int )0 ; } int foo__Fc (__0s )char __0s ; { return (int )__0s ; } int foo__FcT1 (__0s , __0t )char __0s ; char __0t ; { return (int )__0s ; } (I've run it through cb to make things vaguely comprehensible.) Makes using a debugger fun, too, though there's an name-demangler program.
bright@Data-IO.COM (Walter Bright) (10/28/89)
In article <2118@leah.Albany.Edu> bv3456@leah.albany.edu (Victor @ The Concrete Museum) writes:
<I thought I read somewhere on this group that C++ now has "type-safe"
<linkage. Is this so, or was I halucinating? If such a feature exists,
<how is it done?
Yes (in 2.0). It is done by converting the types of function parameters
into a signature "string", and appending that string to the function name.
If the function parameter types don't line up across object files, the
linker won't match up the names and will issue error messages.
Note that variables and function return types are not included in this scheme.
Bjarne Stroustrup presented a paper on this at the Denver Usenix C++ conference.bright@Data-IO.COM (Walter Bright) (10/28/89)
In article <4321@ncsuvx.ncsu.edu> jnh@ecemwl.UUCP (Joseph N. Hall) writes:
<The type information is encoded into the "mangled" function names.
<Two functions with the same name but different argument or return types
<are given distinct mangled names.
Not the return types. This is because you cannot overload functions based
on return types.