What is the final type when we use typed of typedef ... ?

I am trying to find out looking at samples. But what is the rule?

--- GCC ---

https://godbolt.org/z/fsMMzcqGz

#include <stdio.h>
#include <typeinfo>
#include <cxxabi.h>

int status;
#define TYPE(EXPR) \
printf("%s=", #EXPR); \
printf("%s\n", abi::__cxa_demangle(typeid(typeof(EXPR)).name(),0,0,&status))

typedef char* T1;
typedef const T1 CONST_T1;
typedef CONST_T1 T2[5];
typedef T2 T3[2];

int main()
{ TYPE(T1);
TYPE(CONST_T1);
TYPE(T2);
TYPE(T3);
} -----
It prints:

T1=char*
CONST_T1=char*
T2=char* [5]
T3=char* [2][5]

Sometimes the const disappears, like CONST_T1.

changing to
typedef const char* CONST_T1;
then CONST_T1 prints
CONST_T1=char const*

On 22/10/2021 12:38, Thiago Adams wrote:
>
> What is the final type when we use typed of typedef ... ?
>
> I am trying to find out looking at samples. But what is the rule?
>
> --- GCC ---
>
> https://godbolt.org/z/fsMMzcqGz
>
> #include <stdio.h>
> #include <typeinfo>
> #include <cxxabi.h>
>
> int status;
> #define TYPE(EXPR) \
> printf("%s=", #EXPR); \
> printf("%s\n", abi::__cxa_demangle(typeid(typeof(EXPR)).name(),0,0,&status))
>
> typedef char* T1;
> typedef const T1 CONST_T1;
> typedef CONST_T1 T2[5];
> typedef T2 T3[2];
>
> int main()
> {
> TYPE(T1);
> TYPE(CONST_T1);
> TYPE(T2);
> TYPE(T3);
> }
> -----
> It prints:
>
> T1=char*
> CONST_T1=char*
> T2=char* [5]
> T3=char* [2][5]
>
> Sometimes the const disappears, like CONST_T1.
>
> changing to
> typedef const char* CONST_T1;
> then CONST_T1 prints
> CONST_T1=char const*

If I do this in my C compiler, which has the special directive $showtype:

typedef char* T1;
typedef const T1 CONST_T1;
typedef CONST_T1 T2[5];
typedef T2 T3[2];

$showtype T1;
$showtype const T1;
$showtype T2;
$showtype T3;

then when compiling, it shows (using Algol68-style LTR type syntax):

Type is: ref schar
Type is: const ref schar
Type is: [5]const ref schar
Type is: [2][5]const ref schar

This seems to be in accordance with what gcc reports for this code:

int main()
{
T2 a;
T3 b;

a[0]=0;
b[0][0]=0;
}

Both of those array elements are read-only.

Perhaps your cxxabi header doesn't work properly.

On Friday, October 22, 2021 at 9:12:54 AM UTC-3, Bart wrote:
> On 22/10/2021 12:38, Thiago Adams wrote:
> >
> > What is the final type when we use typed of typedef ... ?
> >
> > I am trying to find out looking at samples. But what is the rule?
> >
> > --- GCC ---
> >
> > https://godbolt.org/z/fsMMzcqGz
> >
> > #include <stdio.h>
> > #include <typeinfo>
> > #include <cxxabi.h>
> >
> > int status;
> > #define TYPE(EXPR) \
> > printf("%s=", #EXPR); \
> > printf("%s\n", abi::__cxa_demangle(typeid(typeof(EXPR)).name(),0,0,&status))
> >
> > typedef char* T1;
> > typedef const T1 CONST_T1;
> > typedef CONST_T1 T2[5];
> > typedef T2 T3[2];
> >
> > int main()
> > {
> > TYPE(T1);
> > TYPE(CONST_T1);
> > TYPE(T2);
> > TYPE(T3);
> > }
> > -----
> > It prints:
> >
> > T1=char*
> > CONST_T1=char*
> > T2=char* [5]
> > T3=char* [2][5]
> >
> > Sometimes the const disappears, like CONST_T1.
> >
> > changing to
> > typedef const char* CONST_T1;
> > then CONST_T1 prints
> > CONST_T1=char const*
> If I do this in my C compiler, which has the special directive $showtype:
> typedef char* T1;
> typedef const T1 CONST_T1;
> typedef CONST_T1 T2[5];
> typedef T2 T3[2];
> $showtype T1;
> $showtype const T1;
> $showtype T2;
> $showtype T3;
>
> then when compiling, it shows (using Algol68-style LTR type syntax):
>
> Type is: ref schar
> Type is: const ref schar
> Type is: [5]const ref schar
> Type is: [2][5]const ref schar
>
> This seems to be in accordance with what gcc reports for this code:
>
> int main()
> {
> T2 a;
> T3 b;
>
> a[0]=0;
> b[0][0]=0;
> }
>
> Both of those array elements are read-only.
>
> Perhaps your cxxabi header doesn't work properly.

Yes it is not printing correctly.
My question still the same but the sample can be ignored.

Thiago Adams <thiago.adams@gmail.com> writes:

> #include <stdio.h>
> #include <typeinfo>
> #include <cxxabi.h>
>
> int status;
> #define TYPE(EXPR) \
> printf("%s=", #EXPR); \
> printf("%s\n", abi::__cxa_demangle(typeid(typeof(EXPR)).name(),0,0,&status))
>
> typedef char* T1;
> typedef const T1 CONST_T1;
> typedef CONST_T1 T2[5];
> typedef T2 T3[2];
>
> int main()
> {
> TYPE(T1);
> TYPE(CONST_T1);
> TYPE(T2);
> TYPE(T3);
> }

This is C++ behaving as specified:

In all cases, top-level cv-qualifiers are ignored by typeid (that is,
typeid(const T) == typeid(T)).

https://en.cppreference.com/w/cpp/language/typeid

--
Ben.

On Friday, October 22, 2021 at 9:19:24 AM UTC-3, Thiago Adams wrote:
> On Friday, October 22, 2021 at 9:12:54 AM UTC-3, Bart wrote:
> > On 22/10/2021 12:38, Thiago Adams wrote:
> > >
> > > What is the final type when we use typed of typedef ... ?
> > >
> > > I am trying to find out looking at samples. But what is the rule?
> > >
> > > --- GCC ---
> > >
> > > https://godbolt.org/z/fsMMzcqGz
> > >
> > > #include <stdio.h>
> > > #include <typeinfo>
> > > #include <cxxabi.h>
> > >
> > > int status;
> > > #define TYPE(EXPR) \
> > > printf("%s=", #EXPR); \
> > > printf("%s\n", abi::__cxa_demangle(typeid(typeof(EXPR)).name(),0,0,&status))
> > >
> > > typedef char* T1;
> > > typedef const T1 CONST_T1;
> > > typedef CONST_T1 T2[5];
> > > typedef T2 T3[2];
> > >
> > > int main()
> > > {
> > > TYPE(T1);
> > > TYPE(CONST_T1);
> > > TYPE(T2);
> > > TYPE(T3);
> > > }
> > > -----
> > > It prints:
> > >
> > > T1=char*
> > > CONST_T1=char*
> > > T2=char* [5]
> > > T3=char* [2][5]
> > >
> > > Sometimes the const disappears, like CONST_T1.
> > >
> > > changing to
> > > typedef const char* CONST_T1;
> > > then CONST_T1 prints
> > > CONST_T1=char const*
> > If I do this in my C compiler, which has the special directive $showtype:
> > typedef char* T1;
> > typedef const T1 CONST_T1;
> > typedef CONST_T1 T2[5];
> > typedef T2 T3[2];
> > $showtype T1;
> > $showtype const T1;
> > $showtype T2;
> > $showtype T3;
> >
> > then when compiling, it shows (using Algol68-style LTR type syntax):
> >
> > Type is: ref schar
> > Type is: const ref schar
> > Type is: [5]const ref schar
> > Type is: [2][5]const ref schar
> >
> > This seems to be in accordance with what gcc reports for this code:
> >
> > int main()
> > {
> > T2 a;
> > T3 b;
> >
> > a[0]=0;
> > b[0][0]=0;
> > }
> >
> > Both of those array elements are read-only.
> >
> > Perhaps your cxxabi header doesn't work properly.
> Yes it is not printing correctly.
> My question still the same but the sample can be ignored.

Looking at the samples I assumed const was disappearing but it is not.
Sorry.

So the const is always there. It just changes meaning.

typedef char* T1;
typedef const T1 T2;
//T2 is a const pointer to char*
NOT
//pointer to const char*

T2 should print
"char * const"
(it is printing char* using gcc facilities)

(
I need in my compiler to create the algorithm to convert from typedefs to
declarations (without typedefs).
I need to "move " const extract the pointers and arrays and re-arrange.
)

On Friday, October 22, 2021 at 9:39:05 AM UTC-3, Ben Bacarisse wrote:
> Thiago Adams <thiago...@gmail.com> writes:
>
> > #include <stdio.h>
> > #include <typeinfo>
> > #include <cxxabi.h>
> >
> > int status;
> > #define TYPE(EXPR) \
> > printf("%s=", #EXPR); \
> > printf("%s\n", abi::__cxa_demangle(typeid(typeof(EXPR)).name(),0,0,&status))
> >
> > typedef char* T1;
> > typedef const T1 CONST_T1;
> > typedef CONST_T1 T2[5];
> > typedef T2 T3[2];
> >
> > int main()
> > {
> > TYPE(T1);
> > TYPE(CONST_T1);
> > TYPE(T2);
> > TYPE(T3);
> > }
> This is C++ behaving as specified:
>
> In all cases, top-level cv-qualifiers are ignored by typeid (that is,
> typeid(const T) == typeid(T)).
>
> https://en.cppreference.com/w/cpp/language/typeid

Interesting.

I think it is doing the same in C.

#include <stdio.h>
int main() {
const int i = 1;
printf("%s", _Generic(i,
const int : "const int",
int : "int"
));
} prints int not const int.
https://godbolt.org/z/YGsrah173

(I am implementing typeid in my compiler and I was planning to keep const.)

On 22/10/2021 13:41, Thiago Adams wrote:
> On Friday, October 22, 2021 at 9:19:24 AM UTC-3, Thiago Adams wrote:

>>> Perhaps your cxxabi header doesn't work properly.
>> Yes it is not printing correctly.
>> My question still the same but the sample can be ignored.
>
> Looking at the samples I assumed const was disappearing but it is not.
> Sorry.
>
> So the const is always there. It just changes meaning.
>
> typedef char* T1;
> typedef const T1 T2;
> //T2 is a const pointer to char*
> NOT
> //pointer to const char*
>
> T2 should print
> "char * const"
> (it is printing char* using gcc facilities)
>
> (
> I need in my compiler to create the algorithm to convert from typedefs to
> declarations (without typedefs).
> I need to "move " const extract the pointers and arrays and re-arrange.
> )
>

If you implement typedef in a normal compiler, then the 'typedef' part
just disappears. You're left with your internal representation of the
type. Then it can be written out as you like; as C syntax if really
necessary!

But if you are doing it with just text processing, then it's going to be
challenging. Bear in mind that typedefs can be written like:

char typedef* T1;

And also:

char const const typedef *T1, T2, * const * const T3[4];

You can blame C's bizarre syntax for this. With something saner, you
just stick 'const' on the left of any type, or any part of it, that
needs to be readonly.

On Friday, October 22, 2021 at 9:49:35 AM UTC-3, Thiago Adams wrote:
> On Friday, October 22, 2021 at 9:39:05 AM UTC-3, Ben Bacarisse wrote:
> > Thiago Adams <thiago...@gmail.com> writes:
> >
> > > #include <stdio.h>
> > > #include <typeinfo>
> > > #include <cxxabi.h>
> > >
> > > int status;
> > > #define TYPE(EXPR) \
> > > printf("%s=", #EXPR); \
> > > printf("%s\n", abi::__cxa_demangle(typeid(typeof(EXPR)).name(),0,0,&status))
> > >
> > > typedef char* T1;
> > > typedef const T1 CONST_T1;
> > > typedef CONST_T1 T2[5];
> > > typedef T2 T3[2];
> > >
> > > int main()
> > > {
> > > TYPE(T1);
> > > TYPE(CONST_T1);
> > > TYPE(T2);
> > > TYPE(T3);
> > > }
> > This is C++ behaving as specified:
> >
> > In all cases, top-level cv-qualifiers are ignored by typeid (that is,
> > typeid(const T) == typeid(T)).
> >
> > https://en.cppreference.com/w/cpp/language/typeid
> Interesting.
>
> I think it is doing the same in C.

Another sample very similar

#include <stdio.h>

int main()
{ char * const s1;
printf("%s\n", _Generic(s1,
const char* : "const char *",
char * const : "char * const",
char * : "char *"
));
//prints char *

const char * s2;
printf("%s\n", _Generic(s2,
const char* : "const char *",
char * const : "char * const",
char * : "char *"
));
//prints: const char *
}

On Friday, October 22, 2021 at 9:52:30 AM UTC-3, Bart wrote:
> On 22/10/2021 13:41, Thiago Adams wrote:
> > On Friday, October 22, 2021 at 9:19:24 AM UTC-3, Thiago Adams wrote:
>
> >>> Perhaps your cxxabi header doesn't work properly.
> >> Yes it is not printing correctly.
> >> My question still the same but the sample can be ignored.
> >
> > Looking at the samples I assumed const was disappearing but it is not.
> > Sorry.
> >
> > So the const is always there. It just changes meaning.
> >
> > typedef char* T1;
> > typedef const T1 T2;
> > //T2 is a const pointer to char*
> > NOT
> > //pointer to const char*
> >
> > T2 should print
> > "char * const"
> > (it is printing char* using gcc facilities)
> >
> > (
> > I need in my compiler to create the algorithm to convert from typedefs to
> > declarations (without typedefs).
> > I need to "move " const extract the pointers and arrays and re-arrange.
> > )
> >
> If you implement typedef in a normal compiler, then the 'typedef' part
> just disappears. You're left with your internal representation of the
> type. Then it can be written out as you like; as C syntax if really
> necessary!

The problem is to join typedefs of typedefs ...
like:
typedef char* const T1[5];
typedef const T1 *T2[2];

I want the type of T2 "expanded" with no typedefs to be able to compare types.

On 22/10/2021 13:49, Thiago Adams wrote:
> On Friday, October 22, 2021 at 9:39:05 AM UTC-3, Ben Bacarisse wrote:
>> Thiago Adams <thiago...@gmail.com> writes:
>>
>>> #include <stdio.h>
>>> #include <typeinfo>
>>> #include <cxxabi.h>
>>>
>>> int status;
>>> #define TYPE(EXPR) \
>>> printf("%s=", #EXPR); \
>>> printf("%s\n", abi::__cxa_demangle(typeid(typeof(EXPR)).name(),0,0,&status))
>>>
>>> typedef char* T1;
>>> typedef const T1 CONST_T1;
>>> typedef CONST_T1 T2[5];
>>> typedef T2 T3[2];
>>>
>>> int main()
>>> {
>>> TYPE(T1);
>>> TYPE(CONST_T1);
>>> TYPE(T2);
>>> TYPE(T3);
>>> }
>> This is C++ behaving as specified:
>>
>> In all cases, top-level cv-qualifiers are ignored by typeid (that is,
>> typeid(const T) == typeid(T)).
>>
>> https://en.cppreference.com/w/cpp/language/typeid
>
> Interesting.
>
> I think it is doing the same in C.
>
> #include <stdio.h>
> int main() {
> const int i = 1;
> printf("%s", _Generic(i,
> const int : "const int",
> int : "int"
> ));
> }
> prints int not const int.
> https://godbolt.org/z/YGsrah173

My 'bcc' compiler shows 'const int'.

I don't why gcc shows only 'int' (as do clang and tcc, but there I know
why: they are just copying gcc).

All compilers have trouble using Generic for array types, probably to do
with the decaying of array expressions to pointers.

On mine, I also have typeof(), and $showmode which works on expressions
not types. Then this:

const int i = 1;
$showtype typeof(i);
$showmode i;

shows both as 'const int'.

Le 22/10/2021 à 13:38, Thiago Adams a écrit :
>
> What is the final type when we use typed of typedef ... ?
>
> I am trying to find out looking at samples. But what is the rule?
>
> --- GCC ---
>
> https://godbolt.org/z/fsMMzcqGz
>
> #include <stdio.h>
> #include <typeinfo>
> #include <cxxabi.h>

'typeinfo' and 'cxxabi.h' are not standard C headers. Your TYPE() macro
is C++. Why post in comp.lang.c?

On 2021-10-22, Guillaume <message@bottle.org> wrote:
> Le 22/10/2021 ?? 13:38, Thiago Adams a ??crit??:
>>
>> What is the final type when we use typed of typedef ... ?
>>
>> I am trying to find out looking at samples. But what is the rule?
>>
>> --- GCC ---
>>
>> https://godbolt.org/z/fsMMzcqGz
>>
>> #include <stdio.h>
>> #include <typeinfo>
>> #include <cxxabi.h>
>
>
> 'typeinfo' and 'cxxabi.h' are not standard C headers. Your TYPE() macro
> is C++. Why post in comp.lang.c?

Because Google Groups?

Am 22.10.2021 um 19:26 schrieb Guillaume:
> Le 22/10/2021 à 13:38, Thiago Adams a écrit :
>>
>> What is the final type when we use typed of typedef ... ?
>>
>> I am trying to find out looking at samples. But what is the rule?
>>
>> --- GCC ---
>>
>> https://godbolt.org/z/fsMMzcqGz
>>
>> #include <stdio.h>
>> #include <typeinfo>
>> #include <cxxabi.h>
>
>
> 'typeinfo' and 'cxxabi.h' are not standard C headers. Your TYPE() macro
> is C++. Why post in comp.lang.c?

Because you could mostly use a C++-compiler like it would be
a C-compiler and use some features for debugging. There some
tiny differences that would make a .cpp-program not compilable
in C-mode later, but that's easy to circuvent.

On Friday, October 22, 2021 at 2:31:18 PM UTC-3, Kaz Kylheku wrote:
> On 2021-10-22, Guillaume <mes...@bottle.org> wrote:
> > Le 22/10/2021 ?? 13:38, Thiago Adams a ??crit??:
> >>
> >> What is the final type when we use typed of typedef ... ?
> >>
> >> I am trying to find out looking at samples. But what is the rule?
> >>
> >> --- GCC ---
> >>
> >> https://godbolt.org/z/fsMMzcqGz
> >>
> >> #include <stdio.h>
> >> #include <typeinfo>
> >> #include <cxxabi.h>
> >
> >
> > 'typeinfo' and 'cxxabi.h' are not standard C headers. Your TYPE() macro
> > is C++. Why post in comp.lang.c?
> Because Google Groups?

The C++ part was not important to the question.
I was used to print the name of the type only.

On Friday, October 22, 2021 at 10:01:10 AM UTC-3, Bart wrote:
> On 22/10/2021 13:49, Thiago Adams wrote:
> > On Friday, October 22, 2021 at 9:39:05 AM UTC-3, Ben Bacarisse wrote:
> >> Thiago Adams <thiago...@gmail.com> writes:
> >>
> >>> #include <stdio.h>
> >>> #include <typeinfo>
> >>> #include <cxxabi.h>
> >>>
> >>> int status;
> >>> #define TYPE(EXPR) \
> >>> printf("%s=", #EXPR); \
> >>> printf("%s\n", abi::__cxa_demangle(typeid(typeof(EXPR)).name(),0,0,&status))
> >>>
> >>> typedef char* T1;
> >>> typedef const T1 CONST_T1;
> >>> typedef CONST_T1 T2[5];
> >>> typedef T2 T3[2];
> >>>
> >>> int main()
> >>> {
> >>> TYPE(T1);
> >>> TYPE(CONST_T1);
> >>> TYPE(T2);
> >>> TYPE(T3);
> >>> }
> >> This is C++ behaving as specified:
> >>
> >> In all cases, top-level cv-qualifiers are ignored by typeid (that is,
> >> typeid(const T) == typeid(T)).
> >>
> >> https://en.cppreference.com/w/cpp/language/typeid
> >
> > Interesting.
> >
> > I think it is doing the same in C.
> >
> > #include <stdio.h>
> > int main() {
> > const int i = 1;
> > printf("%s", _Generic(i,
> > const int : "const int",
> > int : "int"
> > ));
> > }
> > prints int not const int.
> > https://godbolt.org/z/YGsrah173
> My 'bcc' compiler shows 'const int'.
>
> I don't why gcc shows only 'int' (as do clang and tcc, but there I know
> why: they are just copying gcc).
>
> All compilers have trouble using Generic for array types, probably to do
> with the decaying of array expressions to pointers.
>
> On mine, I also have typeof(), and $showmode which works on expressions
> not types. Then this:
> const int i = 1;
> $showtype typeof(i);
> $showmode i;
>
> shows both as 'const int'.

typedef void* (*T1)(char, char);
typedef const T1 (*T2)(double);
typedef volatile T2 (*T3)[3];

what does your compiler prints for:

$showtype typeof(T3);

I want to figure out how to merge these typedefs.

Thiago Adams <thiago.adams@gmail.com> writes:
> printf("%s\n", abi::__cxa_demangle(typeid(typeof(EXPR)).name(),0,0,&status))

With "::", it can't be C.

The error message for the following program shows
that "const" has become part of "ic":

int main( void )
{ typedef int const ic;
ic i = 0;
int * p = &i; }

On 22/10/2021 19:29, Thiago Adams wrote:
> On Friday, October 22, 2021 at 10:01:10 AM UTC-3, Bart wrote:
>> On 22/10/2021 13:49, Thiago Adams wrote:
>>> On Friday, October 22, 2021 at 9:39:05 AM UTC-3, Ben Bacarisse wrote:
>>>> Thiago Adams <thiago...@gmail.com> writes:
>>>>
>>>>> #include <stdio.h>
>>>>> #include <typeinfo>
>>>>> #include <cxxabi.h>
>>>>>
>>>>> int status;
>>>>> #define TYPE(EXPR) \
>>>>> printf("%s=", #EXPR); \
>>>>> printf("%s\n", abi::__cxa_demangle(typeid(typeof(EXPR)).name(),0,0,&status))
>>>>>
>>>>> typedef char* T1;
>>>>> typedef const T1 CONST_T1;
>>>>> typedef CONST_T1 T2[5];
>>>>> typedef T2 T3[2];
>>>>>
>>>>> int main()
>>>>> {
>>>>> TYPE(T1);
>>>>> TYPE(CONST_T1);
>>>>> TYPE(T2);
>>>>> TYPE(T3);
>>>>> }
>>>> This is C++ behaving as specified:
>>>>
>>>> In all cases, top-level cv-qualifiers are ignored by typeid (that is,
>>>> typeid(const T) == typeid(T)).
>>>>
>>>> https://en.cppreference.com/w/cpp/language/typeid
>>>
>>> Interesting.
>>>
>>> I think it is doing the same in C.
>>>
>>> #include <stdio.h>
>>> int main() {
>>> const int i = 1;
>>> printf("%s", _Generic(i,
>>> const int : "const int",
>>> int : "int"
>>> ));
>>> }
>>> prints int not const int.
>>> https://godbolt.org/z/YGsrah173
>> My 'bcc' compiler shows 'const int'.
>>
>> I don't why gcc shows only 'int' (as do clang and tcc, but there I know
>> why: they are just copying gcc).
>>
>> All compilers have trouble using Generic for array types, probably to do
>> with the decaying of array expressions to pointers.
>>
>> On mine, I also have typeof(), and $showmode which works on expressions
>> not types. Then this:
>> const int i = 1;
>> $showtype typeof(i);
>> $showmode i;
>>
>> shows both as 'const int'.
>
> typedef void* (*T1)(char, char);
> typedef const T1 (*T2)(double);
> typedef volatile T2 (*T3)[3];
>
> what does your compiler prints for:
>
> $showtype typeof(T3);
>
> I want to figure out how to merge these typedefs.
>

It shows:

Type is: ref [3]ref proc(double)const ref proc(schar,schar)ref void

Read left-to-right:

'ref' means 'pointer to'
'[n]' means 'array n of'
'proc' means 'function'
'schar' means 'signed char'
'(...)' encloses a parameter list, followed by the return type

'volatile' is ignored; just assume to works like const.

(If you're on Windows (or maybe running Wine), you can try it yourself:

https://github.com/sal55/langs/blob/master/bcc.exe

(This is a UPX-compressed version; just run it as normal.)

Use -c when compiling if there is no 'main': bcc -c prog.c

Use $showtype T; outside of a function only. ($showmode X; goes inside a
function; can't remember why...)

You need to use either main(void), or -old option to allow main().)

On 22/10/2021 20:00, Bart wrote:
> On 22/10/2021 19:29, Thiago Adams wrote:

>> I want to figure out how to merge these typedefs.
>>
>

> (If you're on Windows (or maybe running Wine), you can try it yourself:
>
>   https://github.com/sal55/langs/blob/master/bcc.exe
>
> (This is a UPX-compressed version; just run it as normal.)
>
> Use -c when compiling if there is no 'main': bcc -c prog.c
>
> Use $showtype T; outside of a function only. ($showmode X; goes inside a
> function; can't remember why...)
>
> You need to use either main(void), or -old option to allow main().)

Perhaps simpler, use:

bcc -debug prog.c

This writes some debug info to bcc.log, including a symbol table
listing. That will show the typedefs (T1, T2, T3 for your example) and
their types.

Thiago Adams <thiago.adams@gmail.com> writes:

> On Friday, October 22, 2021 at 9:39:05 AM UTC-3, Ben Bacarisse wrote:
>> Thiago Adams <thiago...@gmail.com> writes:
>>
>> > #include <stdio.h>
>> > #include <typeinfo>
>> > #include <cxxabi.h>
>> >
>> > int status;
>> > #define TYPE(EXPR) \
>> > printf("%s=", #EXPR); \
>> > printf("%s\n", abi::__cxa_demangle(typeid(typeof(EXPR)).name(),0,0,&status))
>> >
>> > typedef char* T1;
>> > typedef const T1 CONST_T1;
>> > typedef CONST_T1 T2[5];
>> > typedef T2 T3[2];
>> >
>> > int main()
>> > {
>> > TYPE(T1);
>> > TYPE(CONST_T1);
>> > TYPE(T2);
>> > TYPE(T3);
>> > }
>> This is C++ behaving as specified:
>>
>> In all cases, top-level cv-qualifiers are ignored by typeid (that is,
>> typeid(const T) == typeid(T)).
>>
>> https://en.cppreference.com/w/cpp/language/typeid
>
> Interesting.
>
> I think it is doing the same in C.
>
> #include <stdio.h>
> int main() {
> const int i = 1;
> printf("%s", _Generic(i,
> const int : "const int",
> int : "int"
> ));
> }
> prints int not const int.

Yes, but for a different reason:

6.3.2.1

2 Except when it is the operand of the sizeof operator, the _Alignof
operator, the unary & operator, the ++ operator, the -- operator, or
the left operand of the . operator or an assignment operator, an
lvalue that does not have array type is converted to the value
stored in the designated object (and is no longer an lvalue); this
is called lvalue conversion. If the lvalue has qualified type, the
value has the unqualified version of the type of the lvalue;
additionally ...

--
Ben.

Bart <bc@freeuk.com> writes:

> On 22/10/2021 13:49, Thiago Adams wrote:
>> On Friday, October 22, 2021 at 9:39:05 AM UTC-3, Ben Bacarisse wrote:
>>> Thiago Adams <thiago...@gmail.com> writes:
>>>
>>>> #include <stdio.h>
>>>> #include <typeinfo>
>>>> #include <cxxabi.h>
>>>>
>>>> int status;
>>>> #define TYPE(EXPR) \
>>>> printf("%s=", #EXPR); \
>>>> printf("%s\n", abi::__cxa_demangle(typeid(typeof(EXPR)).name(),0,0,&status))
>>>>
>>>> typedef char* T1;
>>>> typedef const T1 CONST_T1;
>>>> typedef CONST_T1 T2[5];
>>>> typedef T2 T3[2];
>>>>
>>>> int main()
>>>> {
>>>> TYPE(T1);
>>>> TYPE(CONST_T1);
>>>> TYPE(T2);
>>>> TYPE(T3);
>>>> }
>>> This is C++ behaving as specified:
>>>
>>> In all cases, top-level cv-qualifiers are ignored by typeid (that is,
>>> typeid(const T) == typeid(T)).
>>>
>>> https://en.cppreference.com/w/cpp/language/typeid
>> Interesting.
>> I think it is doing the same in C.
>> #include <stdio.h>
>> int main() {
>> const int i = 1;
>> printf("%s", _Generic(i,
>> const int : "const int",
>> int : "int"
>> ));
>> }
>> prints int not const int.
>> https://godbolt.org/z/YGsrah173
>
> My 'bcc' compiler shows 'const int'.

A conforming implementation should display int.

> I don't why gcc shows only 'int' (as do clang and tcc, but there I
> know why: they are just copying gcc).

They may be copying gcc, but then gcc is often a good implementation to
copy. Anyway, they are all correct to give the result they do. See my
other reply for why.

> All compilers have trouble using Generic for array types, probably to
> do with the decaying of array expressions to pointers.

It's more likely that they all implement C as specified. Some may not,
in all cases, but apart from the issue with yours that you pointed out I
don't know of any.

> On mine, I also have typeof(), and $showmode which works on
> expressions not types. Then this:
>
> const int i = 1;
> $showtype typeof(i);
> $showmode i;
>
> shows both as 'const int'.

Do you really mean it outputs a string? I'd have provided an operator
that returns a string.

--
Ben.

Thiago Adams <thiago.adams@gmail.com> writes:

> Looking at the samples I assumed const was disappearing but it is not.
> Sorry.
>
> So the const is always there. It just changes meaning.

Eh?

> typedef char* T1;
> typedef const T1 T2;
> //T2 is a const pointer to char*

No. You can't have thought it meant that. Did you mean to write "T2 is
const pointer to char"?

> NOT
> //pointer to const char*

As above. Did you mean to write "pointer to const char"?

> T2 should print
> "char * const"

What do you mean by "should"? See the quotes I gave about C++'s
type_info class and C's _Generic.

--
Ben.

Thiago Adams <thiago.adams@gmail.com> writes:

> The problem is to join typedefs of typedefs ...
> like:
> typedef char* const T1[5];
> typedef const T1 *T2[2];
>
> I want the type of T2 "expanded" with no typedefs to be able to
> compare types.

For C++ (which has typeid) both of these should work because neither has
a top-level const qualification.

This is a bad topic for comp.lang.c because you seem to be working in
C++ and the two languages are patricularly far apart on this topic.

--
Ben.

On Friday, October 22, 2021 at 6:36:00 PM UTC-3, Ben Bacarisse wrote:
> Thiago Adams <thiago...@gmail.com> writes:
>
> > The problem is to join typedefs of typedefs ...
> > like:
> > typedef char* const T1[5];
> > typedef const T1 *T2[2];
> >
> > I want the type of T2 "expanded" with no typedefs to be able to
> > compare types.
> For C++ (which has typeid) both of these should work because neither has
> a top-level const qualification.
>
> This is a bad topic for comp.lang.c because you seem to be working in
> C++ and the two languages are patricularly far apart on this topic.

The question is not about C++ typedid etc..

It is about how to "expand" the type T3 (for instance) to a type without typedefs
or in other words expand to the equivalent type or real type.

typedef void* (*T1)(char, char);
typedef const T1 (*T2)(double);
typedef volatile T2 (*T3)[3];

I was using gcc/c++ facilities just to print the type. (In the middle of test
const behavior - my mistake - added some noise to the topic.) A derived topic
was the const behavior with _Generic as well.

Thiago Adams <thiago.adams@gmail.com> writes:
>how to "expand" the type T3 (for instance) to a type without typedefs

One can omit the "const" on the return type, so it's
void * (* (* volatile (*)[3])(double))(char, char).

On 22/10/2021 22:19, Ben Bacarisse wrote:
> Bart <bc@freeuk.com> writes:

>> My 'bcc' compiler shows 'const int'.
>
> A conforming implementation should display int.

I understand now that for such expressions, the leftmost 'const' (if it
were to be expressed left to right) of the type of an expression is removed.

>> On mine, I also have typeof(), and $showmode which works on
>> expressions not types. Then this:
>>
>> const int i = 1;
>> $showtype typeof(i);
>> $showmode i;
>>
>> shows both as 'const int'.
>
> Do you really mean it outputs a string? I'd have provided an operator
> that returns a string.

The compiler displays a message, for debugging purposes; there is no
runtime code generated.

However, delving into my source code, I see that there is a version of
$showtype that can be used like this:

puts(strtype(typeof(i)));