rework type coercion in ternary expr (a bit) and uncomment previously failing test. Be more explicit in diagnostic messages.

Udo committed 6 years ago

Commit 9272fac1 parent a9e7fe13 files · +112 −47Browse files

Unified · Split

3 files

tccgen.c +81 −44
tests/tests2/33_ternary_op.c +29 −3
tests/tests2/33_ternary_op.expect +2 −0

  no_var: ;
 }
-static void cast_error(CType *st, CType *dt)
+static void type_incompatibility_error(CType* st, CType* dt, const char* fmt)
+{
+    char buf1[256], buf2[256];
+    type_to_str(buf1, sizeof(buf1), st, NULL);
+    type_to_str(buf2, sizeof(buf2), dt, NULL);
+    tcc_error(fmt, buf1, buf2);
+}
+static void type_incompatibility_warning(CType* st, CType* dt, const char* fmt)
 {
     char buf1[256], buf2[256];
     type_to_str(buf1, sizeof(buf1), st, NULL);
     type_to_str(buf2, sizeof(buf2), dt, NULL);
-    tcc_error("cannot convert '%s' to '%s'", buf1, buf2);
+    tcc_warning(fmt, buf1, buf2);
+}
+static void cast_error(CType *st, CType *dt)
+{
+    type_incompatibility_error(st, dt, "cannot convert '%s' to '%s'");
 }
 /* verify type compatibility to store vtop in 'dt' type */
             test_lvalue();
             gaddrof();
             /* expect pointer on structure */
-            if ((vtop->type.t & VT_BTYPE) != VT_STRUCT)
+            if ( (vtop->type.t & VT_BTYPE) != VT_STRUCT ) {
-                expect("struct or union");
+                char got[256];
+                type_to_str(got, sizeof got, &vtop->type, NULL);
+                tcc_error("expected struct or union but not '%s'", got);
+            }
             if (tok == TOK_CDOUBLE)
                 expect("field name");
             next();
             /* cast operands to correct type according to ISOC rules */
             if (bt1 == VT_VOID || bt2 == VT_VOID) {
                 type.t = VT_VOID; /* NOTE: as an extension, we accept void on only one side */
-            } else if (is_float(bt1) || is_float(bt2)) {
+            } else if ( bt1 == VT_BOOL && bt2 == VT_BOOL ) {
+                type = type1;
+            } else if ( is_float(bt1) && is_integer_btype(bt2) ) {
+                type = type1;
+            } else if ( is_integer_btype(bt1) && is_float(bt2) ) {
+                type = type2;
+            } else if (is_float(bt1) && is_float(bt2)) {
                 if (bt1 == VT_LDOUBLE || bt2 == VT_LDOUBLE) {
                     type.t = VT_LDOUBLE;
                 } else {
                     type.t = VT_FLOAT;
                 }
-            } else if (bt1 == VT_LLONG || bt2 == VT_LLONG) {
+            } else if ((bt1 == VT_LLONG && is_integer_btype(bt2)) ||
+                       (bt2 == VT_LLONG && is_integer_btype(bt1))) {
                 /* cast to biggest op */
                 type.t = VT_LLONG | VT_LONG;
-                if (bt1 == VT_LLONG)
+                if ( bt1 == VT_LLONG )
                     type.t &= t1;
-                if (bt2 == VT_LLONG)
+                if ( bt2 == VT_LLONG )
                     type.t &= t2;
                 /* convert to unsigned if it does not fit in a long long */
                 if ((t1 & (VT_BTYPE | VT_UNSIGNED | VT_BITFIELD)) == (VT_LLONG | VT_UNSIGNED) ||
                     (t2 & (VT_BTYPE | VT_UNSIGNED | VT_BITFIELD)) == (VT_LLONG | VT_UNSIGNED))
                     type.t |= VT_UNSIGNED;
-            } else if (bt1 == VT_PTR || bt2 == VT_PTR) {
+            }
-                /* http://port70.net/~nsz/c/c99/n1256.html#6.5.15p6 */
+            /* http://port70.net/~nsz/c/c99/n1256.html#6.5.15p6 */
-                /* If one is a null ptr constant the result type
+            /* If one is a null ptr constant the result type
-                   is the other.  */
+                is the other.  */
-                if (is_null_pointer (vtop)) type = type1;
+            else if ( bt1 == VT_PTR && is_null_pointer(vtop) ) {
-                else if (is_null_pointer (&sv)) type = type2;
+                type = type1;
-                else if (bt1 != bt2)
+            } else if ( is_null_pointer(&sv) && bt2 == VT_PTR ) {
-		    tcc_error("incompatible types in conditional expressions");
+                type = type2;
-		else {
+            }  else if ( bt1 == VT_PTR && is_integer_btype(bt2) ) {
-		    CType *pt1 = pointed_type(&type1);
+                type = type1;
-		    CType *pt2 = pointed_type(&type2);
+                tcc_warning("pointer/integer mismatch");
-                    int pbt1 = pt1->t & VT_BTYPE;
+            } else if ( is_integer_btype(bt1) && bt2 == VT_PTR ) {
-                    int pbt2 = pt2->t & VT_BTYPE;
+                type = type2;
-		    int newquals, copied = 0;
+                tcc_warning("pointer/integer mismatch");
-		    /* pointers to void get preferred, otherwise the
+            } else if ( bt1==VT_PTR && bt2 == VT_PTR ) {
-		       pointed to types minus qualifs should be compatible */
+		CType *pt1 = pointed_type(&type1);
-                    type = (pbt1 == VT_VOID) ? type1 : type2;
+		CType *pt2 = pointed_type(&type2);
-                    if (pbt1 != VT_VOID && pbt2 != VT_VOID) {
+                int pbt1 = pt1->t & VT_BTYPE;
-                        if(!compare_types(pt1, pt2, 1/*unqualif*/))
+                int pbt2 = pt2->t & VT_BTYPE;
-                            tcc_warning("pointer type mismatch in conditional expression\n");
+		int newquals, copied = 0;
-                    }
+		/* pointers to void get preferred, otherwise the
-                    /* combine qualifs */
+		   pointed to types minus qualifs should be compatible */
-		    newquals = ((pt1->t | pt2->t) & (VT_CONSTANT | VT_VOLATILE));
+                type = (pbt1 == VT_VOID) ? type1 : type2;
-		    if ((~pointed_type(&type)->t & (VT_CONSTANT | VT_VOLATILE))
+                if (pbt1 != VT_VOID && pbt2 != VT_VOID && ! compare_types(pt1, pt2, 1/*unqualif*/) ) {
+                    type_incompatibility_warning(&type1, &type2, "incompatible pointer types");
+                    // result is void*
+                    type.t = VT_VOID;
+                    mk_pointer(&type);
+                }
+                /* combine qualifs */
+		newquals = ((pt1->t | pt2->t) & (VT_CONSTANT | VT_VOLATILE));
+		if ((~pointed_type(&type)->t & (VT_CONSTANT | VT_VOLATILE))
 			& newquals)
-		      {
+		{
 			/* copy the pointer target symbol */
 			type.ref = sym_push(SYM_FIELD, &type.ref->type,
 					    0, type.ref->c);
 			copied = 1;
 			pointed_type(&type)->t |= newquals;
-		      }
+		}
-                    /* pointers to incomplete arrays get converted to
+                /* pointers to incomplete arrays get converted to
-		       pointers to completed ones if possible */
+		   pointers to completed ones if possible */
-		    if (pt1->t & VT_ARRAY
+		if (pt1->t & VT_ARRAY
 			&& pt2->t & VT_ARRAY
 			&& pointed_type(&type)->ref->c < 0
 			&& (pt1->ref->c > 0 || pt2->ref->c > 0))
-		      {
+		{
 			if (!copied)
 			  type.ref = sym_push(SYM_FIELD, &type.ref->type,
 					      0, type.ref->c);
 				     0, pointed_type(&type)->ref->c);
                         pointed_type(&type)->ref->c =
 			    0 < pt1->ref->c ? pt1->ref->c : pt2->ref->c;
-		      }
+		}
+            } else if (bt1 == VT_STRUCT && bt2 == VT_STRUCT) {
+                /* test structure compatibility */
+                if ( type1.ref != type2.ref ) {
+                    type_incompatibility_error(&type1, &type2,"different struct/union types '%s' vs. '%s'");
+                } else {
+                    type = bt1 == VT_STRUCT ? type1 : type2;
                 }
-            } else if (bt1 == VT_STRUCT || bt2 == VT_STRUCT) {
+            } else if ( is_integer_btype(bt1) && is_integer_btype(bt2) ) {
-                /* XXX: test structure compatibility */
-                type = bt1 == VT_STRUCT ? type1 : type2;
-            } else {
                 /* integer operations */
                 type.t = VT_INT | (VT_LONG & (t1 | t2));
-                /* convert to unsigned if it does not fit in an integer */
+                /* convert to unsigned if one of both is unsigned */
                 if ((t1 & (VT_BTYPE | VT_UNSIGNED | VT_BITFIELD)) == (VT_INT | VT_UNSIGNED) ||
                     (t2 & (VT_BTYPE | VT_UNSIGNED | VT_BITFIELD)) == (VT_INT | VT_UNSIGNED))
                     type.t |= VT_UNSIGNED;
+            } else {
+                type_incompatibility_error(&type1, &type2, "type '%s' is incompatible to '%s'");
             }
             /* keep structs lvalue by transforming `(expr ? a : b)` to `*(expr ? &a : &b)` so
                that `(expr ? a : b).mem` does not error  with "lvalue expected" */
             islv = (vtop->r & VT_LVAL) && (sv.r & VT_LVAL) && VT_STRUCT == (type.t & VT_BTYPE);

tests/tests2/33_ternary_op.c+29−3

@@ -1,5 +1,5 @@
1	#include <stdio.h>
2	#include <assert.h>	1	#include <assert.h>
		2	extern int printf(const char*, ...);
3		3
4	char arr[1];	4	char arr[1];
5	static void f (void){}	5	static void f (void){}
@@ -22,8 +22,21 @@ void call_fp() · 16 unmodified lines
22	(fp?f:&f)();	22	(fp?f:&f)();
23	_Generic((__typeof(fp?0L:(void)0)){0}, void: (void)0);	23	_Generic((__typeof(fp?0L:(void)0)){0}, void: (void)0);
24		24
25	//Should cleanly fail, not segfault:	25	/* The following line causes a warning */
26	/(fp?f:1);/	26	void *xx = fp?f:1;
		27	}
		28
		29	struct condstruct {
		30	int i;
		31	};
		32
		33	static int getme(struct condstruct* s, int i)
		34	{
		35	int i1 = (i != 0 ? 0 : s)->i;
		36	int i2 = (i == 0 ? s : 0)->i;
		37	int i3 = (i != 0 ? (void*)0 : s)->i;
		38	int i4 = (i == 0 ? s : (void*)0)->i;
		39	return i1 + i2 + i3 + i4;
27	}	40	}
28		41
29	int main()	42	int main()
@@ -39,12 +52,25 @@ int main() · 9 unmodified lines
39	int c = 0;	52	int c = 0;
40	#define ASSERT(X) assert(X)	53	#define ASSERT(X) assert(X)
41	static struct stru { int x; } a={'A'},b={'B'};	54	static struct stru { int x; } a={'A'},b={'B'};
		55	static const struct stru2 { int x; } d = { 'D' };
42	ASSERT('A'==(*(1?&a:&b)).x);	56	ASSERT('A'==(*(1?&a:&b)).x);
43	ASSERT('A'==(1?a:b).x);	57	ASSERT('A'==(1?a:b).x);
44	ASSERT('A'==(c?b:a).x);	58	ASSERT('A'==(c?b:a).x);
45	ASSERT('A'==(0?b:a).x);	59	ASSERT('A'==(0?b:a).x);
46	c=1;	60	c=1;
47	ASSERT('A'==(c?a:b).x);	61	ASSERT('A'==(c?a:b).x);
		62	ASSERT(sizeof(int) == sizeof(0 ? 'a' : c));
		63	ASSERT(sizeof(double) == sizeof(0 ? 'a' : 1.0));
		64	ASSERT(sizeof(double) == sizeof(0 ? 0.0 : 'a'));
		65	ASSERT(sizeof(float) == sizeof(0 ? 'a' : 1.0f));
		66	ASSERT(sizeof(double) == sizeof(0 ? 0.0 : 1.0f));
		67	struct condstruct cs = { 38 };
		68	printf("%d\n", getme(&cs, 0));
		69
		70	// the following lines contain type mismatch errors in every ternary expression
		71	//printf("comparing double with pointer : size = %d\n", sizeof(0 ? &c : 0.0));
		72	//printf("'%c' <> '%c'\n", (0 ? a : d).x, (1 ? a : d).x);
		73	//0 ? a : 0.0;
48	}	74	}
49		75
50		76

tests/tests2/33_ternary_op.expect+2−0

@@ -1,3 +1,4 @@
		1	33_ternary_op.c:26: warning: pointer/integer mismatch
1	0	2	0
2	1	3	1
3	4	4	4
@@ -8,3 +9,4 @@ · 4 unmodified lines
8	21	9	21
9	24	10	24
10	27	11	27
		12	152

rework type coercion in ternary expr (a bit) and uncomment previously failing test. Be more explicit in diagnostic messages.

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code