Hi all,

Attached patches implement the plan9 extensions to c, also implemented by gcc&co. It also improves the quality of error messages for code using typedefs.

I've split the patch into two parts: the first implements the simpler half of the extension and the error improvements, while the second, which implements the other half of the extension, is somewhat invasive and may not be worthwhile to support. (Particularly since it can be simulated in-userspace using _Generic.)

Cheers,

 -E
diff --git a/libtcc.c b/libtcc.c
index ec33591..956ee0f 100644
--- a/libtcc.c
+++ b/libtcc.c
@@ -788,6 +788,7 @@ LIBTCCAPI TCCState *tcc_new(void)
     s->cversion = 199901; /* default unless -std=c11 is supplied */
     s->warn_implicit_function_declaration = 1;
     s->ms_extensions = 1;
+    s->plan9_extensions = 1;
 
 #ifdef CHAR_IS_UNSIGNED
     s->char_is_unsigned = 1;
@@ -1594,6 +1595,7 @@ static const FlagDef options_f[] = {
     { offsetof(TCCState, nocommon), FD_INVERT, "common" },
     { offsetof(TCCState, leading_underscore), 0, "leading-underscore" },
     { offsetof(TCCState, ms_extensions), 0, "ms-extensions" },
+    { offsetof(TCCState, plan9_extensions), 0, "plan9-extensions" },
     { offsetof(TCCState, dollars_in_identifiers), 0, "dollars-in-identifiers" 
},
     { offsetof(TCCState, test_coverage), 0, "test-coverage" },
     { 0, 0, NULL }
diff --git a/tcc.h b/tcc.h
index 2e27850..090c939 100644
--- a/tcc.h
+++ b/tcc.h
@@ -480,7 +480,7 @@ typedef struct CString {
 
 /* type definition */
 typedef struct CType {
-    int t;
+    int t, td; /* td: token used for typedef, if applicable */
     struct Sym *ref;
 } CType;
 
@@ -591,7 +591,7 @@ typedef struct Section {
     struct Section *reloc;   /* corresponding section for relocation, if any */
     struct Section *hash;    /* hash table for symbols */
     struct Section *prev;    /* previous section on section stack */
-    char name[1];           /* section name */
+    char name[1];            /* section name */
 } Section;
 
 typedef struct DLLReference {
@@ -760,6 +760,10 @@ struct TCCState {
     unsigned char char_is_unsigned;
     unsigned char leading_underscore;
     unsigned char ms_extensions; /* allow nested named struct w/o identifier 
behave like unnamed */
+    unsigned char plan9_extensions; /* allow referring to unnamed nexted 
struct by its typedef name (if
+                                       present); and, convert a pointer to a 
structure to a pointer to
+                                       its unnamed field (if present) */
+
     unsigned char dollars_in_identifiers;  /* allows '$' char in identifiers */
     unsigned char ms_bitfields; /* if true, emulate MS algorithm for aligning 
bitfields */
 
@@ -1485,12 +1489,12 @@ ST_FUNC void greloca(Section *s, Sym *sym, unsigned 
long offset, int type, addr_
 ST_INLN void sym_free(Sym *sym);
 ST_FUNC Sym *sym_push(int v, CType *type, int r, int c);
 ST_FUNC void sym_pop(Sym **ptop, Sym *b, int keep);
-ST_FUNC Sym *sym_push2(Sym **ps, int v, int t, int c);
+ST_FUNC Sym *sym_push2(Sym **ps, int v, int t, int td, int c);
 ST_FUNC Sym *sym_find2(Sym *s, int v);
 ST_INLN Sym *sym_find(int v);
 ST_INLN Sym *struct_find(int v);
 
-ST_FUNC Sym *global_identifier_push(int v, int t, int c);
+ST_FUNC Sym *global_identifier_push(int v, int t, int td, int c);
 ST_FUNC Sym *external_global_sym(int v, CType *type);
 ST_FUNC Sym *external_helper_sym(int v);
 ST_FUNC void vpush_helper_func(int v);
diff --git a/tccasm.c b/tccasm.c
index 097f41c..20c42f0 100644
--- a/tccasm.c
+++ b/tccasm.c
@@ -78,7 +78,7 @@ static Sym *asm_label_push(int v)
     /* We always add VT_EXTERN, for sym definition that's tentative
        (for .set, removed for real defs), for mere references it's correct
        as is.  */
-    Sym *sym = global_identifier_push(v2, VT_ASM | VT_EXTERN | VT_STATIC, 0);
+    Sym *sym = global_identifier_push(v2, VT_ASM | VT_EXTERN | VT_STATIC, 0, 
0);
     if (addeddot)
         sym->asm_label = v;
     return sym;
diff --git a/tccgen.c b/tccgen.c
index c36032a..1c16f02 100644
--- a/tccgen.c
+++ b/tccgen.c
@@ -958,6 +958,7 @@ ST_FUNC void tccgen_init(TCCState *s1)
     memset(vtop, 0, sizeof *vtop);
 
     /* define some often used types */
+    int_type.td = char_type.td = 0;
     int_type.t = VT_INT;
 
     char_type.t = VT_BYTE;
@@ -967,6 +968,7 @@ ST_FUNC void tccgen_init(TCCState *s1)
     mk_pointer(&char_pointer_type);
 
     func_old_type.t = VT_FUNC;
+    func_old_type.td = 0;
     func_old_type.ref = sym_push(SYM_FIELD, &int_type, 0, 0);
     func_old_type.ref->f.func_call = FUNC_CDECL;
     func_old_type.ref->f.func_type = FUNC_OLD;
@@ -1222,7 +1224,7 @@ ST_INLN void sym_free(Sym *sym)
 }
 
 /* push, without hashing */
-ST_FUNC Sym *sym_push2(Sym **ps, int v, int t, int c)
+ST_FUNC Sym *sym_push2(Sym **ps, int v, int t, int td, int c)
 {
     Sym *s;
 
@@ -1230,6 +1232,7 @@ ST_FUNC Sym *sym_push2(Sym **ps, int v, int t, int c)
     memset(s, 0, sizeof *s);
     s->v = v;
     s->type.t = t;
+    s->type.td = td;
     s->c = c;
     /* add in stack */
     s->prev = *ps;
@@ -1287,7 +1290,7 @@ ST_FUNC Sym *sym_push(int v, CType *type, int r, int c)
         ps = &local_stack;
     else
         ps = &global_stack;
-    s = sym_push2(ps, v, type->t, c);
+    s = sym_push2(ps, v, type->t, type->td, c);
     s->type.ref = type->ref;
     s->r = r;
     /* don't record fields or anonymous symbols */
@@ -1310,10 +1313,10 @@ ST_FUNC Sym *sym_push(int v, CType *type, int r, int c)
 }
 
 /* push a global identifier */
-ST_FUNC Sym *global_identifier_push(int v, int t, int c)
+ST_FUNC Sym *global_identifier_push(int v, int t, int td, int c)
 {
     Sym *s, **ps;
-    s = sym_push2(&global_stack, v, t, c);
+    s = sym_push2(&global_stack, v, t, td, c);
     s->r = VT_CONST | VT_SYM;
     /* don't record anonymous symbol */
     if (v < SYM_FIRST_ANOM) {
@@ -1431,6 +1434,7 @@ static void vpush64(int ty, unsigned long long v)
     CValue cval;
     CType ctype;
     ctype.t = ty;
+    ctype.td = 0;
     ctype.ref = NULL;
     cval.i = v;
     vsetc(&ctype, VT_CONST, &cval);
@@ -1465,6 +1469,7 @@ static void vseti(int r, int v)
 {
     CType type;
     type.t = VT_INT;
+    type.td = 0;
     type.ref = NULL;
     vset(&type, r, v);
 }
@@ -1644,7 +1649,7 @@ ST_FUNC Sym *external_global_sym(int v, CType *type)
     s = sym_find(v);
     if (!s) {
         /* push forward reference */
-        s = global_identifier_push(v, type->t | VT_EXTERN, 0);
+        s = global_identifier_push(v, type->t | VT_EXTERN, type->td, 0);
         s->type.ref = type->ref;
     } else if (IS_ASM_SYM(s)) {
         s->type.t = type->t | (s->type.t & VT_EXTERN);
@@ -1658,7 +1663,7 @@ ST_FUNC Sym *external_global_sym(int v, CType *type)
    This avoids type conflicts if the symbol is used from C too */
 ST_FUNC Sym *external_helper_sym(int v)
 {
-    CType ct = { VT_ASM_FUNC, NULL };
+    CType ct = { VT_ASM_FUNC, 0, NULL };
     return external_global_sym(v, &ct);
 }
 
@@ -1732,6 +1737,7 @@ static void patch_type(Sym *sym, CType *type)
     if (IS_ASM_SYM(sym)) {
         /* stay static if both are static */
         sym->type.t = type->t & (sym->type.t | ~VT_STATIC);
+        sym->type.td = type->td;
         sym->type.ref = type->ref;
     }
 
@@ -1761,6 +1767,7 @@ static void patch_type(Sym *sym, CType *type)
             struct FuncAttr f = sym->type.ref->f;
             /* put complete type, use static from prototype */
             sym->type.t = (type->t & ~(VT_STATIC|VT_INLINE)) | static_proto;
+            sym->type.td = type->td;
             sym->type.ref = type->ref;
             merge_funcattr(&sym->type.ref->f, &f);
         } else {
@@ -1839,7 +1846,7 @@ static Sym *external_sym(int v, CType *type, int r, 
AttributeDef *ad)
 
     if (!s) {
         /* push forward reference */
-        s = global_identifier_push(v, type->t, 0);
+        s = global_identifier_push(v, type->t, type->td, 0);
         s->r |= r;
         s->a = ad->a;
         s->asm_label = ad->asm_label;
@@ -2049,6 +2056,7 @@ static void move_reg(int r, int s, int t)
     if (r != s) {
         save_reg(r);
         sv.type.t = t;
+        sv.type.td = 0;
         sv.type.ref = NULL;
         sv.r = s;
         sv.c.i = 0;
@@ -2326,6 +2334,7 @@ ST_FUNC int gv(int rc)
         vtop->type.t &= ~VT_STRUCT_MASK;
 
         type.ref = NULL;
+        type.td = 0;
         type.t = vtop->type.t & VT_UNSIGNED;
         if ((vtop->type.t & VT_BTYPE) == VT_BOOL)
             type.t |= VT_UNSIGNED;
@@ -3083,6 +3092,11 @@ static void type_to_str(char *buf, int buf_size,
     char buf1[256];
     const char *tstr;
 
+    if (type->td) {
+        pstrcpy(buf, buf_size, get_tok_str(type->td, NULL));
+        return;
+    }
+
     t = type->t;
     bt = t & VT_BTYPE;
     buf[0] = '\0';
@@ -3095,6 +3109,7 @@ static void type_to_str(char *buf, int buf_size,
         pstrcat(buf, buf_size, "typedef ");
     if (t & VT_INLINE)
         pstrcat(buf, buf_size, "inline ");
+
     if (bt != VT_PTR) {
         if (t & VT_VOLATILE)
             pstrcat(buf, buf_size, "volatile ");
@@ -3336,6 +3351,7 @@ static int combine_types(CType *dest, SValue *op1, SValue 
*op2, int op)
     int ret = 1;
 
     type.t = VT_VOID;
+    type.td = 0;
     type.ref = NULL;
 
     if (bt1 == VT_VOID || bt2 == VT_VOID) {
@@ -3666,6 +3682,7 @@ static void gen_cast_s(int t)
 {
     CType type;
     type.t = t;
+    type.td = 0;
     type.ref = NULL;
     gen_cast(&type);
 }
@@ -3991,6 +4008,7 @@ ST_FUNC void mk_pointer(CType *type)
     Sym *s;
     s = sym_push(SYM_FIELD, type, 0, -1);
     type->t = VT_PTR | (type->t & VT_STORAGE);
+    type->td = 0;
     type->ref = s;
 }
 
@@ -4533,18 +4551,23 @@ redo:
 static Sym * find_field (CType *type, int v, int *cumofs)
 {
     Sym *s = type->ref;
-    v |= SYM_FIELD;
+    int fv = v | SYM_FIELD;
     while ((s = s->next) != NULL) {
        if ((s->v & SYM_FIELD) &&
            (s->type.t & VT_BTYPE) == VT_STRUCT &&
            (s->v & ~SYM_FIELD) >= SYM_FIRST_ANOM) {
-           Sym *ret = find_field (&s->type, v, cumofs);
+           Sym *ret;
+
+            if (tcc_state->plan9_extensions && s->type.td == v)
+                break;
+
+            ret = find_field (&s->type, fv, cumofs);
            if (ret) {
                 *cumofs += s->c;
                return ret;
             }
        }
-       if (s->v == v)
+       if (s->v == fv)
          break;
     }
     return s;
@@ -4556,13 +4579,22 @@ static void check_fields (CType *type, int check)
 
     while ((s = s->next) != NULL) {
         int v = s->v & ~SYM_FIELD;
-        if (v < SYM_FIRST_ANOM) {
-            TokenSym *ts = table_ident[v - TOK_IDENT];
-            if (check && (ts->tok & SYM_FIELD))
-                tcc_error("duplicate member '%s'", get_tok_str(v, NULL));
-            ts->tok ^= SYM_FIELD;
-        } else if ((s->type.t & VT_BTYPE) == VT_STRUCT)
+        TokenSym *ts;
+        if ((s->type.t & VT_BTYPE) == VT_STRUCT &&
+            v >= SYM_FIRST_ANOM) {
             check_fields (&s->type, check);
+            v = s->type.td & ~SYM_FIELD;
+            if (!(tcc_state->plan9_extensions && s->type.td
+                  && TOK_IDENT < v))
+                continue;
+        }
+        if (v > SYM_FIRST_ANOM)
+            continue;
+
+        ts = table_ident[v - TOK_IDENT];
+        if (check && (ts->tok & SYM_FIELD))
+            tcc_error("duplicate member '%s'", get_tok_str(v, NULL));
+        ts->tok ^= SYM_FIELD;
     }
 }
 
@@ -4744,7 +4776,7 @@ static void struct_layout(CType *type, AttributeDef *ad)
     /* check whether we can access bitfields by their type */
     for (f = type->ref->next; f; f = f->next) {
         int s, px, cx, c0;
-        CType t;
+        CType t = {0};
 
         if (0 == (f->type.t & VT_BITFIELD))
             continue;
@@ -4846,12 +4878,14 @@ static void struct_decl(CType *type, int u)
     }
     /* Record the original enum/struct/union token.  */
     type1.t = u == VT_ENUM ? u | VT_INT | VT_UNSIGNED : u;
+    type1.td = 0;
     type1.ref = NULL;
     /* we put an undefined size for struct/union */
     s = sym_push(v | SYM_STRUCT, &type1, 0, -1);
     s->r = 0; /* default alignment is zero as gcc */
 do_decl:
     type->t = s->type.t;
+    type->td = 0;
     type->ref = s;
 
     if (tok == '{') {
@@ -4865,6 +4899,7 @@ do_decl:
         if (u == VT_ENUM) {
             long long ll = 0, pl = 0, nl = 0;
            CType t;
+            t.td = 0;
             t.ref = s;
             /* enum symbols have static storage */
             t.t = VT_INT|VT_STATIC|VT_ENUM_VAL;
@@ -4944,7 +4979,7 @@ do_decl:
                            else {
                                int v = btype.ref->v;
                                if (!(v & SYM_FIELD) && (v & ~SYM_STRUCT) < 
SYM_FIRST_ANOM) {
-                                   if (tcc_state->ms_extensions == 0)
+                                   if (!tcc_state->ms_extensions && 
!tcc_state->plan9_extensions)
                                        expect("identifier");
                                }
                            }
@@ -5066,6 +5101,7 @@ static int parse_btype(CType *type, AttributeDef *ad)
     typespec_found = 0;
     t = VT_INT;
     bt = st = -1;
+    type->td = 0;
     type->ref = NULL;
 
     while(1) {
@@ -5288,6 +5324,7 @@ static int parse_btype(CType *type, AttributeDef *ad)
             t &= ~(VT_BTYPE|VT_LONG);
             u = t & ~(VT_CONSTANT | VT_VOLATILE), t ^= u;
             type->t = (s->type.t & ~VT_TYPEDEF) | u;
+            type->td = n;
             type->ref = s->type.ref;
             if (t)
                 parse_btype_qualify(type, t);
@@ -5392,6 +5429,7 @@ static int post_type(CType *type, AttributeDef *ad, int 
storage, int td)
                     if (n < TOK_UIDENT)
                         expect("identifier");
                     pt.t = VT_VOID; /* invalid type */
+                    pt.td = 0;
                     pt.ref = NULL;
                     next();
                 }
@@ -5434,6 +5472,7 @@ static int post_type(CType *type, AttributeDef *ad, int 
storage, int td)
         s->f = ad->f;
         s->next = first;
         type->t = VT_FUNC;
+        type->td = 0;
         type->ref = s;
     } else if (tok == '[') {
        int saved_nocode_wanted = nocode_wanted;
@@ -5513,6 +5552,7 @@ static int post_type(CType *type, AttributeDef *ad, int 
storage, int td)
            element type */
         s = sym_push(SYM_FIELD, type, 0, n);
         type->t = (t1 ? VT_VLA : VT_ARRAY) | VT_PTR;
+        type->td = 0;
         type->ref = s;
     }
     return 1;
@@ -5636,6 +5676,7 @@ static void gfunc_param_typed(Sym *func, Sym *arg)
             gen_cast_s(VT_DOUBLE);
         } else if (vtop->type.t & VT_BITFIELD) {
             type.t = vtop->type.t & (VT_BTYPE | VT_UNSIGNED);
+            type.td = vtop->type.td;
            type.ref = vtop->type.ref;
             gen_cast(&type);
         } else if (vtop->r & VT_MUSTCAST) {
@@ -5705,8 +5746,8 @@ static void parse_builtin_params(int nc, const char *args)
            continue;
         }
         expr_eq();
+        type.t = type.td = 0;
         type.ref = NULL;
-        type.t = 0;
        switch (c) {
            case 'e':
                continue;
@@ -5857,6 +5898,7 @@ ST_FUNC void unary(void)
 
     sizeof_caller = in_sizeof;
     in_sizeof = 0;
+    type.td = 0;
     type.ref = NULL;
     /* XXX: GCC 2.95.3 does not generate a table although it should be
        better here */
@@ -7606,9 +7648,9 @@ again:
            if (s->r & LABEL_FORWARD) {
                /* start new goto chain for cleanups, linked via label->next */
                if (cur_scope->cl.s && !nocode_wanted) {
-                    sym_push2(&pending_gotos, SYM_FIELD, 0, cur_scope->cl.n);
+                    sym_push2(&pending_gotos, SYM_FIELD, 0, 0, 
cur_scope->cl.n);
                     pending_gotos->prev_tok = s;
-                    s = sym_push2(&s->next, SYM_FIELD, 0, 0);
+                    s = sym_push2(&s->next, SYM_FIELD, 0, 0, 0);
                     pending_gotos->next = s;
                 }
                s->jnext = gjmp(s->jnext);
@@ -7922,7 +7964,7 @@ static int decl_designator(init_params *p, CType *type, 
unsigned long c,
 
     if (!(flags & DIF_SIZE_ONLY) && nb_elems > 1) {
         Sym aref = {0};
-        CType t1;
+        CType t1 = {0};
         int i;
         if (p->sec || (type->t & VT_ARRAY)) {
             /* make init_putv/vstore believe it were a struct */
@@ -8469,7 +8511,7 @@ static void decl_initializer_alloc(CType *type, 
AttributeDef *ad, int r,
             sym = sym_push(v, type, r, addr);
            if (ad->cleanup_func) {
                Sym *cls = sym_push2(&all_cleanups,
-                    SYM_FIELD | ++cur_scope->cl.n, 0, 0);
+                    SYM_FIELD | ++cur_scope->cl.n, 0, 0, 0);
                cls->prev_tok = sym;
                cls->next = ad->cleanup_func;
                cls->ncl = cur_scope->cl.s;
@@ -8632,7 +8674,7 @@ static void gen_function(Sym *sym)
     /* put debug symbol */
     tcc_debug_funcstart(tcc_state, sym);
     /* push a dummy symbol to enable local sym storage */
-    sym_push2(&local_stack, SYM_FIELD, 0, 0);
+    sym_push2(&local_stack, SYM_FIELD, 0, 0, 0);
     local_scope = 1; /* for function parameters */
     gfunc_prolog(sym);
     local_scope = 0;
@@ -8656,6 +8698,7 @@ static void gen_function(Sym *sym)
     cur_text_section = NULL;
     funcname = ""; /* for safety */
     func_vt.t = VT_VOID; /* for safety */
+    func_vt.td = 0; /* for unsafety */
     func_var = 0; /* for safety */
     ind = 0; /* for safety */
     nocode_wanted = 0x80000000;
diff --git a/tccpp.c b/tccpp.c
index 815ffe4..db747e4 100644
--- a/tccpp.c
+++ b/tccpp.c
@@ -1364,7 +1364,7 @@ ST_INLN void define_push(int v, int macro_type, int *str, 
Sym *first_arg)
     Sym *s, *o;
 
     o = define_find(v);
-    s = sym_push2(&define_stack, v, macro_type, 0);
+    s = sym_push2(&define_stack, v, macro_type, 0, 0);
     s->d = str;
     s->next = first_arg;
     table_ident[v - TOK_IDENT]->sym_define = s;
@@ -1413,7 +1413,7 @@ ST_FUNC Sym *label_find(int v)
 ST_FUNC Sym *label_push(Sym **ptop, int v, int flags)
 {
     Sym *s, **ps;
-    s = sym_push2(ptop, v, 0, 0);
+    s = sym_push2(ptop, v, 0, 0, 0);
     s->r = flags;
     ps = &table_ident[v - TOK_IDENT]->sym_label;
     if (ptop == &global_label_stack) {
@@ -1575,7 +1575,7 @@ ST_FUNC void parse_define(void)
             if (varg < TOK_IDENT)
         bad_list:
                 tcc_error("bad macro parameter list");
-            s = sym_push2(&define_stack, varg | SYM_FIELD, is_vaargs, 0);
+            s = sym_push2(&define_stack, varg | SYM_FIELD, is_vaargs, 0, 0);
             *ps = s;
             ps = &s->next;
             if (tok == ')')
@@ -3140,7 +3140,7 @@ static int *macro_arg_subst(Sym **nested_list, const int 
*macro_str, Sym *args)
                           used multiple times, but not if the argument
                           contains the __COUNTER__ macro.  */
                        TokenString str2;
-                       sym_push2(&s->next, s->v, s->type.t, 0);
+                       sym_push2(&s->next, s->v, s->type.t, s->type.td, 0);
                        tok_str_new(&str2);
                        macro_subst(&str2, nested_list, st);
                        tok_str_add(&str2, 0);
@@ -3456,7 +3456,7 @@ static int macro_subst_tok(
                 str.len -= spc;
                 tok_str_add(&str, -1);
                 tok_str_add(&str, 0);
-                sa1 = sym_push2(&args, sa->v & ~SYM_FIELD, sa->type.t, 0);
+                sa1 = sym_push2(&args, sa->v & ~SYM_FIELD, sa->type.t, 
sa->type.td, 0);
                 sa1->d = str.str;
                 sa = sa->next;
                 if (tok == ')') {
@@ -3491,7 +3491,7 @@ static int macro_subst_tok(
             parse_flags = saved_parse_flags;
         }
 
-        sym_push2(nested_list, s->v, 0, 0);
+        sym_push2(nested_list, s->v, 0, 0, 0);
         parse_flags = saved_parse_flags;
         joined_str = macro_twosharps(mstr);
         macro_subst(tok_str, nested_list, joined_str ? joined_str : mstr);
diff --git a/tccgen.c b/tccgen.c
index 1c16f02..dd65b8e 100644
--- a/tccgen.c
+++ b/tccgen.c
@@ -259,6 +259,7 @@ static void gv_dup(void);
 static int get_temp_local_var(int size,int align);
 static void clear_temp_local_var_list();
 static void cast_error(CType *st, CType *dt);
+static Sym *find_anon_field(CType *structure, CType *field, int *cumofs);
 
 ST_INLN int is_float(int t)
 {
@@ -4068,8 +4069,7 @@ static void verify_assign_cast(CType *dt)
         if (is_compatible_types(type1, type2))
             break;
         for (qualwarn = lvl = 0;; ++lvl) {
-            if (((type2->t & VT_CONSTANT) && !(type1->t & VT_CONSTANT)) ||
-                ((type2->t & VT_VOLATILE) && !(type1->t & VT_VOLATILE)))
+            if ((type2->t & (VT_CONSTANT|VT_VOLATILE)) & ~(type1->t & 
(VT_CONSTANT|VT_VOLATILE)))
                 qualwarn = 1;
             dbt = type1->t & (VT_BTYPE|VT_LONG);
             sbt = type2->t & (VT_BTYPE|VT_LONG);
@@ -4090,11 +4090,32 @@ static void verify_assign_cast(CType *dt)
                   base types, though, in particular for unsigned enums
                   and signed int targets.  */
             } else {
+                Sym *s;
+                int cumofs = 0;
+                if (tcc_state->plan9_extensions
+                    && dbt == VT_STRUCT && sbt == VT_STRUCT
+                    && (s = find_anon_field(type2, type1, &cumofs))) {
+                    /* duplicating code from the '.' operator */
+                    vtop->type = char_pointer_type;
+                    vpushi(cumofs + s->c);
+                    gen_op('+');
+                    vtop->type = s->type;
+                    mk_pointer(&vtop->type);
+
+                    /* generate a warning for, e.g.:
+                     * typedef struct {} Inner; struct { const Inner; } outer; 
Inner *i = &outer;
+                     */
+                    if ((s->type.t & (VT_CONSTANT|VT_VOLATILE)) & ~(type1->t & 
(VT_CONSTANT|VT_VOLATILE)))
+                        goto qualwarn;
+                    break;
+                }
+
                 tcc_warning("assignment from incompatible pointer type");
                 break;
             }
         }
         if (qualwarn)
+qualwarn:
             tcc_warning("assignment discards qualifiers from pointer target 
type");
         break;
     case VT_BYTE:
@@ -4573,6 +4594,30 @@ static Sym * find_field (CType *type, int v, int *cumofs)
     return s;
 }
 
+static Sym *find_anon_field(CType *structure, CType *field, int *cumofs)
+{
+    Sym *s = structure->ref;
+    while ((s = s->next) != NULL) {
+        if ((s->v & SYM_FIELD) &&
+            (s->type.t & VT_BTYPE) == VT_STRUCT &&
+            (s->v & ~SYM_FIELD) >= SYM_FIRST_ANOM) {
+            Sym *ret;
+
+            if (compare_types(&s->type, field, 1)) {
+                return s;
+            }
+
+            ret = find_anon_field(&s->type, field, cumofs);
+            if (ret) {
+                *cumofs += s->c;
+                return ret;
+            }
+        }
+    }
+
+    return NULL;
+}
+
 static void check_fields (CType *type, int check)
 {
     Sym *s = type->ref;
diff --git a/tests/tests2/126_plan9_ms.c b/tests/tests2/126_plan9_ms.c
new file mode 100644
index 0000000..942954b
--- /dev/null
+++ b/tests/tests2/126_plan9_ms.c
@@ -0,0 +1,28 @@
+#include <stdio.h>
+
+typedef struct { int x1, x2, x3; } Inner;
+typedef struct {
+    int x0;
+    Inner;
+    // int Inner; // an error with -fplan9-extensions, but not with 
-fms-extensions
+} Outer;
+
+void set_x2(Inner *i) {
+    i->x2 = 2;
+}
+
+void warn() {
+    struct { const Inner; } tmp;
+    Inner *i = &tmp; /* warning: assignment discards qualifiers from pointer 
target type */
+}
+
+int main() {
+    Outer o;
+    Inner *i = &o;
+    i->x1 = 1;
+    set_x2(&o);
+    o.x3 = 3;
+    o.x0 = 10;
+    printf("%d\n", o.x1 + o.x2 + o.x3);
+    return 0;
+}
diff --git a/tests/tests2/126_plan9_ms.expect b/tests/tests2/126_plan9_ms.expect
new file mode 100644
index 0000000..385bb1e
--- /dev/null
+++ b/tests/tests2/126_plan9_ms.expect
@@ -0,0 +1,2 @@
+126_plan9_ms.c:16: warning: assignment discards qualifiers from pointer target 
type
+6
_______________________________________________
Tinycc-devel mailing list
[email protected]
https://lists.nongnu.org/mailman/listinfo/tinycc-devel

Reply via email to