Re: question about linker

Bart <bc@freeuk.com> writes:

On 29/11/2024 20:35, Keith Thompson wrote:

Bart <bc@freeuk.com> writes:
[...]

C's syntax allows a 14-parameter function F to be declared in the same
statement as a simple int 'i'.

Yes (except that it's a declaration, not a statement) :
     int i = 42, F(int, int, int, int, int, int, int,
                   int, int, int, int, int, int, int);
Are you under the impression that anyone here was not already aware
of
that?  Would you prefer it if the number of parameters were arbitrarily
restricted to 13?
Do you think that anyone would actually write code like the above?
C generally doesn't impose arbitrary restrictions.  Because of that,
it's possible to write absurd code like the declaration above.  99% of
programmers simply don't do that, so it's not a problem in practice.
 

I'd say that F and i are different types! (Actually I wouldn't even
consider F to be type, but a function.)

Neither F nor i is a type.  i is an object (of type int), and F is a
function (of type int(int, int, int, int, int, int, int, int, int, int,
int, int, int, int)).
 

That F(1, 2, 3.0, "5", "six", seven, ...) might yield the same type as
'i' is irrelevant here.

It's relevant to the syntax.  i and F can be declared in the same
declaration only because the type of i and the return type of F happen
to be the same.  If F returned void, i and F would have to be declared
separately.
Which, of course, is a good idea anyway.
You're posting repeatedly trying to convince everyone that C allows
ridiculous code.  We already know that.  You are wasting everyone's time
telling us something that we already know.  Most of us just don't obsess
about it as much as you do.  Most of us recognize that, however
convoluted C's declaration syntax might be, it cannot be fixed in a
language calling itself "C".
Most of us here are more interested in talking about C as it's
specified, and actually trying to understand it, than in complaining
about it.
 

Usually, given these declarations:
>
   int A[100]
   int *B;
   int (*C)();
>
people would consider the types of A, B and C to be array, pointer and
function pointer respectively. Otherwise, which of the 4 or 5 possible
types would you say that D has here:
>
   int D[3][4][5];
>
It depends on how it is used in an expression, which can be any of &D,
D, D[i], D[i][j], D[i][j][k], none of which include 'Array' type!

No, the object D unambiguously has type int[3][4][5]

>
(So it would have a different type from E declared on in the same
declaration:
>
   int D[3][4][5], E;
>
? In that case tell that to David Brown!)

Yes, of course D and E have different types.  I'm certain he's
aware of that.

I wrote that the object D is unambiguously of type int[3][4][5], and the
expression D can be of the array type int[3][4][5] or of the pointer
type int(*)[3][4], depending on the context.  Do you agree?  Or do you
still claim that D can have any of "4 or 5 possible types"?

(Note that I'm not talking about the type of the expression D[i] or of
any other expression that includes D as a subexpression.)

You seem have missed the point of my post, which was a reply to
David's remark that 'they can't have totally different types' which
was in response to my saying that each variable in the same
declaration can 'be [of] a totally different type'.

David apparently has a different definition of "totally different types"
than you do.  Since the standard doesn't define that phrase, I suggest
not wasting time arguing about it.

Given:
    int D[3][4][5], E;
the object D is of type int[3][4][5], and E is of type int.  Do you
understand that?

If you wanted to change the type of D from int[3][4][5] to
double[3][4][5], you'd have to use two separate declarations.
Do you understand that?  (Of course you do, but will you admit that
you understand it?)

I think that distinction is what David had in mind.  double[3][4][5] and
int are "totally different types", but int[3][4][5] and int are not.
Entities of "totally different types" cannot be declared in a single
declaration.  You don't have to accept that meaning of the phrase (which
I find a bit vague), but it's clearly what David meant.

The point is that there are restrictions on what can be combined into a
single declaration.  But these days it's usually considered good style
to declare only one identifier in each declaration, so while this :
    int i, *p;
is perfectly valid, and every C compiler must accept it, this :
    int i;
    int *p;
is preferred by most C programmers.

Do you understand that?

DB is assuming the type of the variable after it's been used in an
expression that is fully evaluated to yield its base type. So my
A[100] is used as A[i], and D[3][4][5]  is used as D[i][j][k].
>
But of course they may be evaluated only partially, yielding a range
of types.

What "range of types" do you think D can have?

Would you write "const int F();"?  Or would you omit the "const"?  How
does the fact that "const" is allowed inconvenience you?

>
It's another point of confusion. In my language I don't treat function
declarations like variable declarations. A function is not a
variable. There is no data storage associated with it.

In C, declarations can declare objects, functions, types, etc.  I fail
to see how your language is relevant.

In C it is unfortunate, as it makes it hard to trivially distinguish a
function declaration (or the start of a function definition) from a
variable declaration.

It's not as hard as you insist on pretending it is.  A function
declaration includes a pair of parentheses, either empty or
containing a list of parameters or parameter types.

Function declarations outside header files are valid, but tend to be
rare in well-written C code.

--
Keith Thompson (The_Other_Keith) Keith.S.Thompson+u@gmail.com
void Void(void) { Void(); } /* The recursive call of the void */