🚀 go-pugleaf

In article <44h3ak$p3j@newshost.lanl.gov>,
tanmoy@qcd.lanl.gov (Tanmoy Bhattacharya) wrote:

>By the way, does this mean that that after
>
>int f(const int);
>int g(const int);
>int g(const int);
>
>f has type int(const int) because types do not need to be composed: there is
>only one declaration, but g has type int(int)? Maybe, but it does not have
>any observable effects yet. 

A few years ago it was suggested on the Fidonet C Echo that the
declaring a parameter const could be used by an optimizing compiler to
avoid redundant parameter loading in consecutive calls:

    void f(const double a, const int b);
    void g(const double a, const int b);
    ...
    f(x, y);
    g(x, y);

might be optimized (using stack for parameters) from 

    PUSHINT y
    PUSHFLT x
    CALL    f
    DECRSP  (length x + length y)
    PUSHINT y
    PUSHFLT x
    CALL    g
    DECRSP  (length x + length y)

to:

    PUSHINT y
    PUSHFLT x
    CALL    f
    CALL    g
    DECRSP  (length x + length y)

>|> Technical Corrigendum 1 says that "In the determination of type
>|> compatibility and of a composite type, ... each parameter declared with
>|> qualified type is taken as having the unqualified version of its declared
>|> type." So does that means that
>
>Note that the sentence does not apply to the determination of the type of
>parameter `a': it applies to determination of the compatibility and
>the composite type of the function. In absence of any specific statement to
>the contrary, `a' continues to be `const int' (even though the composite
>function type is void(int).)

If parameters a and b in my example need not be const in the
implemention of f, as your analysis suggests, the proposed
optimization would fail.

Thad