Re: "not-const" qualifier for C

On 2024-04-25, Thiago Adams <thiago.adams@gmail.com> wrote:

>
>
Em 4/24/2024 8:13 PM, Kaz Kylheku escreveu:

On 2024-04-24, Thiago Adams <thiago.adams@gmail.com> wrote:

Motivation sample:
>
struct X {
       const char* const type;
};
>
struct X * make_x(){
    struct X * p = malloc(sizeof *p);
    if (p)
    {
>
        p->type = strdup("X");  // *** error, type is const ***
>
        if (p->type == NULL)
        {
           free(p);
           p = NULL;
        }
    }
    return p; //ok
}

 
Different idea: allow all conversions without a cast which only
add qualifiers anywhere in the type:
 
   struct X {
     const char* const type;
   };
 
   struct mutable_X {
     char* type;
   };

>
In this case the types struct X and struct mutable_X are not
convertible.  They are not the same type.

And your mutable keyword is a syntax error in the current C language!

The idea is that we allow "pointer to struct mutable_X" to convert to
"pointer to struct X" without a cast, because the two types are
structurally equivalent, and every element of the destination type at
least as qualified as its counterpart in the source type.

I don't entirely like the idea because it entails structural
equivalence. That has various problems. Ideological: we are used
to "struct foo" and "struct bar" (in the same translation unit)
being different types. Structural equivalence requires complete
types. We could end up with the situation where "foo *" cannot
convert to "bar *" without a cast in one scope in the program
where foo is an incomplete type, but in another scope, foo is
completed in a way that the assignment is compatible.

--
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal
Mastodon: @Kazinator@mstdn.ca