segfault w/ block, but not file scope

[Dieter]

Hi.

In the snippet of code below, I'm trying to understand why when the

struct dirent ** namelist

is declared with "file" scope, I don't have a problem freeing the
allocated memory. But when the struct is declared in main (block scope)
it will segfault when passing namelist to freeFileNames().

Since this seems to be just a matter of my understanding scope and
pointer parameter passing better, I only included what thought to be
relevant code. I'll happily provide compilable code if deemed necessary.

Please see commented lines:
struct dirent **namelist; /* file scope works */

int main(void)
{
/* struct dirent **namelist */ /* block scope doesn't work */
int n;

n = getFileNames(H5DIR, namelist); /* included from mylib.h */
freeFileNames(namelist, n); /* included from mylib.h */

return 0;
}
Thank you very much for your comments,
Dieter

[Jordan Abel]

On 2006-01-09, Keith Thompson <ks***@mib.org> wrote:

[context is the term "pass by reference]

What do you call the corresponding programming technique? (Ideally,
I'd like to see a pity and language-independent term, just as we use
the term "linked list" regardless of the implementation language.)

If some other language, say C+++ (sic),
Or, say, lisp.
had built-in support for linked lists, would you insist on not using
the term "linked list" in the context of a C program?

Apparently not.

[Jordan Abel]

On 2006-01-09, aegis <ae***@mad.scientist.com> wrote:

Jordan Abel wrote:

On 2006-01-08, aegis <ae***@mad.scientist.com> wrote:

> Passing by reference has to do with passing around actual containers
> or in C's case, objects.

I disagree.

> We don't do that in C. We instead pass the
> values stored in objects around to functions. The standard is clear
> here and supports absolutely diddly squat in regards to a concept
> called "pass by reference".

The language itself supports absolutely squat in regards to another
concept called "linked list", or "binary tree", or any number of other
things, which means absolutely squat to people who use those concepts
anyway in C regardless.

What a terrible comparison. The actual passing mechanism supported
by C is defined by the standard. Because it is a mechanism of the
language. Concepts such as 'linked list' and 'binary tree' are
implemented with the language. Not /into/ the language. So you
compare to a concept not associated with making up the actual
language. Call by value or pass by value is clearly outlined in
section 3.3.2.2 of c89. Which section describes this so called
concept 'pass by reference' or 'call by reference'? I suspect
there is no section as there is no mechanism of such implemented
into the language.

yet there _is_ a technique, which has been described in detail,
which can be implemented with C, and which is used extensively in
the standard library, and you have repeatedly failed to put forth a
better name for it than "pass by reference".

[Dik T. Winter]

In article <dp**********@malatesta.hpl.hp.com> Chris Dollin <ke**@hpl.hp.com> writes:

Dik T. Winter wrote:

The distinction between passing by reference and passing by value is
that at the callers end you can not distinguish the two, it is at
the callees end that the two are distinguished. So in Algol 60
(which has proper pass by reference (actually pass by name, but the
distinction is minor)

Surely not, as Jensen's Device illustrates. (And trying to compile
it.)

In the context the difference is minor. And I know exactly how call
by name was compiled on the system I did use.
--
dik t. winter, cwi, kruislaan 413, 1098 sj amsterdam, nederland, [phone]
home: bovenover 215, 1025 jn amsterdam, nederland; http://www.cwi.nl/~dik/

[Dik T. Winter]

In article <dp***********@pc-news.cogsci.ed.ac.uk> ri*****@cogsci.ed.ac.uk (Richard Tobin) writes:

In article <Is********@cwi.nl>, Dik T. Winter <Di********@cwi.nl> wrote:

(which has proper pass by reference (actually pass by name, but the
distinction is minor) and pass by value)
The distinction is minor when the actual parameter is a variable, but
not when it is an expression.

I know all that. I have quite a bit of experience with Algol 60 (it was
the first computer language I ever used). My "minor" was intended in
context.

Anyhow the major distinction between call by value, reference, name,
value-return, or whatever is not at the callers side. It is at the
callees side. Even in Algol 68 you could write:
function(argument)
without knowing whether "argument" could be changed or not, unless you
looked at the definition of "function". In this sense C is an improvement
on Algol 68; if I write:
function(argument)
I am sure that argument will not change, at most what argument points to.
In Algol 68 this is quite a bit more subtle.
not when it is an expression. In the latter case you have something
like a closure (traditionally called a "thunk" in this context).

Or was your use of "proper" meant to imply that pass by reference
ought to work like this?

-- Richard

--
dik t. winter, cwi, kruislaan 413, 1098 sj amsterdam, nederland, [phone]
home: bovenover 215, 1025 jn amsterdam, nederland; http://www.cwi.nl/~dik/

[aegis]

Jordan Abel wrote:

On 2006-01-09, aegis <ae***@mad.scientist.com> wrote:

Jordan Abel wrote:

On 2006-01-08, aegis <ae***@mad.scientist.com> wrote:
> Passing by reference has to do with passing around actual containers
> or in C's case, objects.

I disagree.

> We don't do that in C. We instead pass the
> values stored in objects around to functions. The standard is clear
> here and supports absolutely diddly squat in regards to a concept
> called "pass by reference".

The language itself supports absolutely squat in regards to another
concept called "linked list", or "binary tree", or any number of other
things, which means absolutely squat to people who use those concepts
anyway in C regardless.

What a terrible comparison. The actual passing mechanism supported
by C is defined by the standard. Because it is a mechanism of the
language. Concepts such as 'linked list' and 'binary tree' are
implemented with the language. Not /into/ the language. So you
compare to a concept not associated with making up the actual
language. Call by value or pass by value is clearly outlined in
section 3.3.2.2 of c89. Which section describes this so called
concept 'pass by reference' or 'call by reference'? I suspect
there is no section as there is no mechanism of such implemented
into the language.

yet there _is_ a technique, which has been described in detail,
which can be implemented with C, and which is used extensively in
the standard library, and you have repeatedly failed to put forth a
better name for it than "pass by reference".

My original post was in reply to your opposition of the claim
that C does not support 'pass by reference'. I thought it was clear
that this was about a mechanism of the language and not
something you implement with the language. If instead,
you mean to say the value of a pointer object can
also be called a reference and that when passing it to
a function therefore qualifies the language as supporting
'pass by reference', then I think that you are confused. What
you really want to say is 'pass a reference'. I know this is
an international forum so English may not be your native
language but do you understand the difference?
--
aegis

[Chris Dollin]

Jordan Abel wrote:

On 2006-01-09, Chris Dollin <ke**@hpl.hp.com> wrote:

the use "pass by" instead of "call by" distinguishes the programming
technique from the language feature.

That's interesting distinction, but the only place I ever seen it made
is in your post - have you a (preferably online) reference to update me?

I coined it just now because I think the programming technique deserves
a name. What would you call the technique used in the list of standard
library functions i named upthread?

If you could be more explicit about the list (I looked back a way but
found it not), then I could offer a name.

I note that the pass by / call by distinction you offer is idiosyncratic
to you.

--
Chris "believes seventeen improbable things before coffee" Dollin
Seventeen, forty-two - what else is there?

[Chris Dollin]

Keith Thompson wrote:

Here are a couple of questions for those of you who insist that the
term "pass by reference" should apply only to a built-in language
feature:

What do you call the corresponding programming technique? (Ideally,
I'd like to see a pity and language-independent term, just as we use
the term "linked list" regardless of the implementation language.)
"passing a pointer". Or "indirection". Or "passing a reference". Or
even (as I'm an old fogey who defaults, as we have seen, to the term
"call by reference" for the language feature) "pass by reference",
but since that appears to be becomming the term for the feature, I'd
best change my habits.
If some other language, say C+++ (sic), had built-in support for
linked lists, would you insist on not using the term "linked list" in
the context of a C program?

No. I'd just say that C+++ "had" linked lists, and C didn't. (Actually
I'd be likely to say that they had/had not "lists", because my own
idiosyncracy is to think of "list" as /meaning/ linked list; these
funny psuedo-arrays that eg Java call "lists" always seem to me to
be misnamed. But I know that's Just Me.)

I'd try to be /clear/, in any case. "Well, C+++ has linked lists as
a built-in feature; C doesn't have them, but you can implement them,
or something pretty close."

--
Chris "believes seventeen improbable things before coffee" Dollin
(But the coffee machine is broken. Belief overload!)

[M.B]

Chris Dollin wrote:

Keith Thompson wrote:

Here are a couple of questions for those of you who insist that the
term "pass by reference" should apply only to a built-in language
feature:

What do you call the corresponding programming technique? (Ideally,
I'd like to see a pity and language-independent term, just as we use
the term "linked list" regardless of the implementation language.)
"passing a pointer". Or "indirection". Or "passing a reference". Or
even (as I'm an old fogey who defaults, as we have seen, to the term
"call by reference" for the language feature) "pass by reference",
but since that appears to be becomming the term for the feature, I'd
best change my habits.

If some other language, say C+++ (sic), had built-in support for
linked lists, would you insist on not using the term "linked list" in
the context of a C program?

No. I'd just say that C+++ "had" linked lists, and C didn't. (Actually
I'd be likely to say that they had/had not "lists", because my own
idiosyncracy is to think of "list" as /meaning/ linked list; these
funny psuedo-arrays that eg Java call "lists" always seem to me to
be misnamed. But I know that's Just Me.)

I'd try to be /clear/, in any case. "Well, C+++ has linked lists as
a built-in feature; C doesn't have them, but you can implement them,
or something pretty close."

Does this answer this long argument
http://c-faq.com/ptrs/passbyref.html
--
Chris "believes seventeen improbable things before coffee" Dollin
(But the coffee machine is broken. Belief overload!)

[Jordan Abel]

On 2006-01-10, aegis <ae***@mad.scientist.com> wrote:

My original post was in reply to your opposition of the claim that C
does not support 'pass by reference'. I thought it was clear that this
was about a mechanism of the language and not something you implement
with the language. If instead, you mean to say the value of a pointer
object can also be called a reference and that when passing it to a
function therefore qualifies the language as supporting 'pass by
reference', then I think that you are confused. What you really want
to say is 'pass a reference'.
yes - you "pass a reference" _by which reference_ you are thus passing
the object whose address is taken. thus "pass by [that] reference". the
'reference' or 'pointer' is something you are _using_ as a mechanism to
pass something, which is why the word "by" is used. The only difference
is whether you, the programmer, are doing it, vs the compiler doing it.
I know this is an international forum so English may not be your
native language but do you understand the difference?

I think _you_ are the one who is not looking at the actual meanings of
the words, and unjustifiably seeing the phrase "pass by reference" as
indivisible.

[Jordan Abel]

On 2006-01-10, Chris Dollin <ke**@hpl.hp.com> wrote:

Keith Thompson wrote:

Here are a couple of questions for those of you who insist that the
term "pass by reference" should apply only to a built-in language
feature:

What do you call the corresponding programming technique? (Ideally,
I'd like to see a pity and language-independent term, just as we use
the term "linked list" regardless of the implementation language.)

"passing a pointer". Or "indirection". Or "passing a reference". Or
even (as I'm an old fogey who defaults, as we have seen, to the term
"call by reference" for the language feature) "pass by reference",
but since that appears to be becomming the term for the feature, I'd
best change my habits.

If some other language, say C+++ (sic), had built-in support for
linked lists, would you insist on not using the term "linked list" in
the context of a C program?

No. I'd just say that C+++ "had" linked lists, and C didn't. (Actually
I'd be likely to say that they had/had not "lists", because my own
idiosyncracy is to think of "list" as /meaning/ linked list; these
funny psuedo-arrays that eg Java call "lists" always seem to me to
be misnamed. But I know that's Just Me.)

I'd try to be /clear/, in any case. "Well, C+++ has linked lists as
a built-in feature; C doesn't have them, but you can implement them,
or something pretty close."

But saying "C doesn't have linked lists, this isn't C+++" in response to
EVERY mention of "linked list", even when it was clear that it wasn't
about a language feature, would be widely seen as a troll, wouldn't it?

[Chris Dollin]

Jordan Abel wrote:

On 2006-01-10, aegis <ae***@mad.scientist.com> wrote:

My original post was in reply to your opposition of the claim that C
does not support 'pass by reference'. I thought it was clear that this
was about a mechanism of the language and not something you implement
with the language. If instead, you mean to say the value of a pointer
object can also be called a reference and that when passing it to a
function therefore qualifies the language as supporting 'pass by
reference', then I think that you are confused. What you really want
to say is 'pass a reference'.

yes - you "pass a reference" _by which reference_ you are thus passing
the object whose address is taken. thus "pass by [that] reference". the
'reference' or 'pointer' is something you are _using_ as a mechanism to
pass something, which is why the word "by" is used. The only difference
is whether you, the programmer, are doing it, vs the compiler doing it.

I know this is an international forum so English may not be your
native language but do you understand the difference?

I think _you_ are the one who is not looking at the actual meanings of
the words, and unjustifiably seeing the phrase "pass by reference" as
indivisible.

Technical terms often have meanings that are not quite the same as
a naive reading would imply. Witness, for example, "call by value".
I'd be quite happy to believe that "pass by reference" was a technical
term that meant something more specific than "a reference was passed",
just as I know that "call by value" doesn't /mean/ "a value was called",
even when in the construct a value /was/ called.

--
Chris "believes seventeen improbable things before coffee" Dollin
But now the machine works, and it's /after/ coffee ..............

[Richard Bos]

Joseph Dionne <sp******@mindspring.com> wrote:

It astounds me to read some the post here, most being "off topic" or "don't do
that" for people seeking solutions to problems the responders have most likely
implemented.

It also astounds me to realize how many c programmers, a low level language,
have little to no understanding of how the c compiler works, some even
claiming the OS "jumps to main" which is completely false.

Then again, it astounds me how few Unix and/or Windows weenies refer to
"the" way "the" C compiler works, as if their pet systems were the one
and only measure of computer architecture.

Richard

[Keith Thompson]

Chris Dollin <ke**@hpl.hp.com> writes:
[...]

Technical terms often have meanings that are not quite the same as
a naive reading would imply. Witness, for example, "call by value".
I'd be quite happy to believe that "pass by reference" was a technical
term that meant something more specific than "a reference was passed",
just as I know that "call by value" doesn't /mean/ "a value was called",
even when in the construct a value /was/ called.

Even in plain English, I wouldn't expect "call by value" to mean that
a value is called. The phrase means that something unspecified is
called. The "by value" could mean either that the value does the
calling, or that the value is used in the process of calling.

It's true that technical phrases don't necessarily have exactly the
meaning you'd expect from the literal meanings of their constituent
words, but most of them are fairly close. Usually the technical
definition of a phrase is consistent with the plain meaning, but with
some restrictions.

--
Keith Thompson (The_Other_Keith) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[Michael Wojcik]

In article <ln************@nuthaus.mib.org>, Keith Thompson <ks***@mib.org> writes:

mw*****@newsguy.com (Michael Wojcik) writes:

I agree with Chris (or what I take to be the main point of one of his
posts in this thread): "pass by reference" is more usefully defined
specifically as a syntactic feature of a language. And C does not
have that syntactic feature.
Here are a couple of questions for those of you who insist that the
term "pass by reference" should apply only to a built-in language
feature:

What do you call the corresponding programming technique?

"Passing a reference". I realize this may cause confusion with a
certain C++ feature; too bad. I can't change how C++ decided to
name its features. I don't go out of my way to avoid the word
"template" when discussing C either, even though it names a feature
in C++.

Since references can be implemented using mechanisms other than
pointers, a general term for the technique shouldn't mention
pointers.

The phrase "passing a reference" describes the technique in question
just as precisely as possible, and no more. The recipient gets some
token that it can use to identify the variable to be modified.
If some other language, say C+++ (sic), had built-in support for
linked lists, would you insist on not using the term "linked list" in
the context of a C program?

Why in the world would I? Lisp has built-in support for linked
lists, and that doesn't prevent me from using the term. My
objection to applying "pass-by-reference" to C has nothing to do
with its presence in other languages (except insofar as that
presence has led to the use of the term in the first place).

"Pass-by-reference" (and "call-by-reference") is a term of art of
long standing, and it historically has usually referred to a
mechanism for passing a reference which is implemented in the
syntax of the language. As I wrote in my previous post, I think
it's more useful to preserve both of those attributes in its
definition than it is to drop the latter one. Doing so preserves
an important and useful distinction, as Richard and others have
argued in this thread.

--
Michael Wojcik mi************@microfocus.com

Push up the bottom with your finger, it will puffy and makes stand up.
-- instructions for "swan" from an origami kit

[Chris Torek]

`But "glory" doesn't mean "a nice knock-down argument",' Alice objected.

`When *I* use a word,' Humpty Dumpty said, in a rather scornful tone,
`it means just what I choose it to mean -- neither more nor less.'

`The question is,' said Alice, `whether you *can* make words mean so
many different things.'

`The question is,' said Humpty, `which is to be master -- that's all.'

(see <http://www.sabian.org/Alice/lgchap06.htm>).

Chris Torek wrote:

... C remains pass-by-value. The gimmick is that the "value" of
an array is a pointer to the array's first element. In:

void f(void) {
char buf[100];
char *p;

p = buf;

we attempt to copy the "value" of buf -- an array -- to the pointer
variable p. The "value" of the array is a pointer to the array's
first element, so this sets p to point to &buf[0]. ... [Passing "buf" to a function g() likewise provides the value &buf[0].] Within g(), as for any simulation of by-reference in C, we have to
use the unary "*" operator in order to write to buf[0]:

void g(char * ptr) {
* ptr = 42;
...
}

and if we fail to prefix "ptr" with the unary "*" operator when
assigning, we will "re-bind" it so that it no longer points to
"buf" at all ...

In article <o9*****************@newsread3.news.atl.earthlink. net>
Joseph Dionne <jd*****@hotmail.com> wrote:Look who is being humorous. Sir, in you example, "buf" will never
change is memory value, even *if* you pass it by reference, "& buf".
[I assume "is memory value" is a typo for "its memory value".]

First, I must continue to insist that passing "&buf" does not pass
buf by-reference, as the term "by-reference" is used in compiler
circles. It passes the value &buf by value, which is what one
would expect, since C passes all parameter by value. Note that
the type of &buf differs from the type of "the value of buf" --
&buf has type (char (*)[100]), as one can see from the following:

% cat t.c
void f(void) {
char buf[100];
char *p1;
char (*p2)[50];
char (*p3)[100];

p1 = &buf; /* line 7 - draws a diagnostic */
p2 = &buf; /* line 8 - draws a diagnostic */
p3 = &buf; /* line 9 - no diagnostic */
}
% strictcc -O -c t.c
t.c: In function `f':
t.c:7: error: assignment from incompatible pointer type
t.c:8: error: assignment from incompatible pointer type
%

Second -- but perhaps even more important -- in a very real sense
(but not in the quirky C language, where the "value" of an array
is a pointer to the array's first element), the "memory value" of
buf is a sequence of 100 "char"s. Thus, whether in f() or in g(),
if we change any of the 100 array elements, we have in fact changed
the "memory value" of buf. What you mean to say is that we cannot
change the *address* of buf -- neither "buf as a whole" (i.e., we
cannot move the array from addresses A through A+99 on the x86
stack on an actual implementation, to some new set of addresses B
through B+99), nor any element of it. This is of course true.
However, the address, wherever it may be, is not in fact fixed
forever, but only for the lifetime of the given function activation:

% cat t.c
#include <stdio.h>

void f(int r) {
char buf[100];

printf("&buf[0]: %p\n", (void *)&buf[0]);
if (r > 0)
f(r - 1);
}

void g(void) {
char x[20];
f(0);
}

int main(void) {
f(1);
g();
return 0;
}
% strictcc -o t t.c
% ./t
&buf[0]: 0x8047a58
&buf[0]: 0x80479c8
&buf[0]: 0x8047a18
%

Note that three different numbers appeared. On this particular
(x86) implementation, these are addresses on the system-supplied
stack, printed as if via %#x. The system uses linear, byte-addressed
virtual memory, so these are the actual "hardware addresses"
(virtualized, of course) within the process running the program.
In the second, recursive call to f(), there are of course two
"buf"s outstanding in memory, one for each activation; in the third,
there is only one "buf" but its address is different from either
of the previous two because g()'s activation record is occupying
space above it (the x86 stack having a "natural" downward-growing
direction).
I think we all can agree the pascal and c++ support pass by
reference by different syntax. I assert the c uses yet another
syntax to implement pass by reference, nothing more or less.

Unfortunately for you and/or anyone with whom you are trying to
communicate, your definition of what constitutes "pass by reference"
disagrees with the majority in computing science / informatics.
For the rest of us, if special syntax is required on *every*
(de)reference, what we have is not an actual, language-provided,
by-reference mechanism. It is fine to say that C lets us simulate
by-reference via pointers, and when speaking informally, calling
it "by reference" is not completely out of the question (though I
myself would try to stick to the phrase "passing *a* reference")
-- but one should make it clear, if asked, that this is not what
is, in informatics, called "by-reference".

It is also worth pointing out that the distinction does show
through if the function you call, to which you pass a reference,
happens to implement the call as value-result internally and
uses a global variable and you pass the address of that global.
(See my earlier example, elsewhere in this thread.)
--
In-Real-Life: Chris Torek, Wind River Systems
Salt Lake City, UT, USA (40°39.22'N, 111°50.29'W) [phone]
email: forget about it http://web.torek.net/torek/index.html
Reading email is like searching for food in the garbage, thanks to spammers.

[Michael Wojcik]

In article <sl**********************@random.yi.org>, Jordan Abel <ra*******@gmail.com> writes:

I think _you_ are the one who is not looking at the actual meanings of
the words, and unjustifiably seeing the phrase "pass by reference" as
indivisible.

If we're going to quibble over semantics, could we at least try to
formulate decent arguments? There's ample justification for treating
the phrase "pass by reference" as a term of art.

--
Michael Wojcik mi************@microfocus.com

Bohemia is only a stage in a man's life, except in the case of fools and
a very few others. It is not a profession. -- Arthur Ransome