Обсуждение: Re: [HACKERS] What is nameout() for?

--- Bruce Momjian <maillist@candle.pha.pa.us> wrote:
> I am confused by nameout().  There are a number of places where table
> names are output using nameout(), and many other cases where they are
> just output without calling nameout.  Can someone explain why the dash
> is important?  I can see the pstrdup as being important, but not in all
> of the cases where nameout is called.
> 
>
---------------------------------------------------------------------------
> 
> /*
>  *      nameout - converts internal reprsentation to "..."
>  */
> char *
> nameout(NameData *s)
> {  
>     if (s == NULL)
>         return "-";
>     else 
>         return pstrdup(s->data);
> }
> 

Actually, I have 'C' question regarding the above code. Where does the
"-" live in RAM? Does the compiler generated a data hunk such that this
string will be apart of the final executable and each invocation of this
routine would result in a pointer to that 'global' location being
returned? 
Or does it allocate the memory for, and initialize, the "-" on the stack? 
If so, isn't returning a "-" a dangerous act?

In fact, isn't returning a "-" dangerous either way without the 
protoype being:

const char *nameout(NameData *s);
^^^^^

Sorry to drift off topice, but I was just curious,

Mike Mascari
(mascarim@yahoo.com)





=====

__________________________________________________
Do You Yahoo!?
Bid and sell for free at http://auctions.yahoo.com

> Actually, I have 'C' question regarding the above code. Where does the
> "-" live in RAM? Does the compiler generated a data hunk such that this
> string will be apart of the final executable and each invocation of this
> routine would result in a pointer to that 'global' location being
> returned? 
> Or does it allocate the memory for, and initialize, the "-" on the stack? 
> If so, isn't returning a "-" a dangerous act?
> 
> In fact, isn't returning a "-" dangerous either way without the 
> protoype being:

One copy, usually in the text segment because it is ready-only.


--  Bruce Momjian                        |  http://www.op.net/~candle maillist@candle.pha.pa.us            |  (610)
853-3000+  If your life is a hard drive,     |  830 Blythe Avenue +  Christ can be your backup.        |  Drexel Hill,
Pennsylvania19026
 

At 12:38 PM 11/7/99 -0800, Mike Mascari wrote:

>Actually, I have 'C' question regarding the above code. Where does the
>"-" live in RAM? Does the compiler generated a data hunk such that this
>string will be apart of the final executable and each invocation of this
>routine would result in a pointer to that 'global' location being
>returned? 

Yes.



- Don Baccus, Portland OR <dhogaza@pacifier.com> Nature photos, on-line guides, Pacific Northwest Rare Bird Alert
Serviceand other goodies at http://donb.photo.net.
 

Mike Mascari <mascarim@yahoo.com> writes:
> Actually, I have 'C' question regarding the above code. Where does the
> "-" live in RAM? Does the compiler generated a data hunk such that this
> string will be apart of the final executable and each invocation of this
> routine would result in a pointer to that 'global' location being
> returned? 
> Or does it allocate the memory for, and initialize, the "-" on the stack? 
> If so, isn't returning a "-" a dangerous act?

As Bruce already explained, the existing code returns a pointer to a
constant string "-" sitting somewhere in the program's text segment
(or data segment, possibly, depending on your compiler).  So it's OK
in the sense that the pointer still points at well-defined memory
even after the function returns.  But I believe the code is bogus
anyway, because one path returns palloc'd storage and the other
doesn't.  If the caller pfree'd the returned pointer, it'd work
just until nameout was given a NULL pointer; then it'd coredump.

> In fact, isn't returning a "-" dangerous either way without the 
> protoype being:

> const char *nameout(NameData *s);
> ^^^^^

That's a different issue: if the caller tries to *modify* the returned
string, should the compiler complain?  If the caller tries that, and
the compiler doesn't complain, and the compiler puts the constant string
"-" into data segment, then you've got trouble: that supposedly constant
string will get changed and will no longer look like "-" on its next
use.  (Shades of Fortran II :-(.)  But I'm not very worried about that
in practice, because most of the developers use gcc which puts constant
string in text segment.  Any attempt to modify a constant string will
instantly coredump under gcc, so the logic error will be found and fixed
before long.

The trouble with declaring nameout and similar functions to return
const char * is that C (and C++) don't distinguish "thou shalt not
modify" from "thou shalt not free".  Ideally we'd like to declare
nameout as returning a string that the caller can't modify, but can
free when no longer needed.  We can't do that unfortunately...
        regards, tom lane