shithub: scc

Download patch

ref: ea965d122903adb6bf9da6c7100468f9796a2b62
parent: 5986230634beac84ad48ce29b9842cbccbeaa286
author: Roberto E. Vargas Caballero <[email protected]>
date: Fri Feb 3 04:44:49 EST 2017 

Revert "[cc1] Don't deal abbreviations as other operations"

This reverts commit 3b80bbd687997a5db6abff8329e63a21556d97b9.


--- a/cc1/expr.c
+++ b/cc1/expr.c
@@ -209,6 +209,39 @@
 	}
 }
 
+static Node *
+integerop(int op, Node *lp, Node *rp)
+{
+	if (!(lp->type->prop & TINTEGER) || !(rp->type->prop & TINTEGER))
+		error("operator requires integer operands");
+	arithconv(&lp, &rp);
+	return simplify(op, lp->type, lp, rp);
+}
+
+static Node *
+integeruop(int op, Node *np)
+{
+	if (!(np->type->prop & TINTEGER))
+		error("unary operator requires integer operand");
+	np = promote(np);
+	if (op == OCPL && np->op == OCPL)
+		return np->left;
+	return simplify(op, np->type, np, NULL);
+}
+
+static Node *
+numericaluop(int op, Node *np)
+{
+	if (!(np->type->prop & TARITH))
+		error("unary operator requires numerical operand");
+	np = promote(np);
+	if (op == OSNEG && np->op == OSNEG)
+		return np->left;
+	if (op == OADD)
+		return np;
+	return simplify(op, np->type, np, NULL);
+}
+
 Node *
 convert(Node *np, Type *newtp, char iscast)
 {
@@ -258,68 +291,9 @@
 	return castcode(np, newtp);
 }
 
-/*
- * op functions: These functions group the different kind of operators
- *       integer
- *       pointer
- *       numerical: (integers + float)
- *       arithmetic: (integer + float + pointers)
- *
- * integer_aop: Assignation abbreviation operator with integers
- * integer_op:  Operator with integers
- * integer_uop: Unary integer operator
- * numerical_uop: Unary numerical operator (integer and floats)
- * arithmetic_pop: Arithmetic pointer operator
- * arithmetic_aop: Assignation abbreviation operator with arithmetics
- * arithmetic_op: Arithmetic operator
- * compare_pop: Pointer comparision operator
- * compare_op: Comparision operator
- */
-
 static Node *
-integer_aop(int op, Node *lp, Node *rp)
+parithmetic(int op, Node *lp, Node *rp)
 {
-	if (!(lp->type->prop&TINTEGER) || !(rp->type->prop&TINTEGER))
-		error("operator requires integer operands");
-	return simplify(op, lp->type, lp, convert(rp, lp->type, 0));
-}
-
-static Node *
-integer_op(int op, Node *lp, Node *rp)
-{
-	if (!(lp->type->prop & TINTEGER) || !(rp->type->prop & TINTEGER))
-		error("operator requires integer operands");
-	arithconv(&lp, &rp);
-	return simplify(op, lp->type, lp, rp);
-}
-
-static Node *
-integer_uop(int op, Node *np)
-{
-	if (!(np->type->prop & TINTEGER))
-		error("unary operator requires integer operand");
-	np = promote(np);
-	if (op == OCPL && np->op == OCPL)
-		return np->left;
-	return simplify(op, np->type, np, NULL);
-}
-
-static Node *
-numerical_uop(int op, Node *np)
-{
-	if (!(np->type->prop & TARITH))
-		error("unary operator requires numerical operand");
-	np = promote(np);
-	if (op == OSNEG && np->op == OSNEG)
-		return np->left;
-	if (op == OADD)
-		return np;
-	return simplify(op, np->type, np, NULL);
-}
-
-static Node *
-arithmetic_pop(int op, Node *lp, Node *rp)
-{
 	Type *tp;
 	Node *size, *np;
 
@@ -359,24 +333,11 @@
 }
 
 static Node *
-arithmetic_aop(int op, Node *lp, Node *rp)
+arithmetic(int op, Node *lp, Node *rp)
 {
 	Type *ltp = lp->type, *rtp = rp->type;
 
-	if (ltp->prop&TARITH && rtp->prop&TARITH)
-		return simplify(op, lp->type, lp, convert(rp, lp->type, 0));
-	if (ltp->op == PTR && rtp->prop&TINTEGER)
-		return arithmetic_pop(op, lp, rp);
-        errorp("incorrect arithmetic operands");
-	return constnode(zero);
-}
-
-static Node *
-arithmetic_op(int op, Node *lp, Node *rp)
-{
-	Type *ltp = lp->type, *rtp = rp->type;
-
-	if (ltp->prop&TARITH && rtp->prop&TARITH) {
+	if ((ltp->prop & TARITH) && (rtp->prop & TARITH)) {
 		arithconv(&lp, &rp);
 		return simplify(op, lp->type, lp, rp);
 	} else if ((ltp->op == PTR || rtp->op == PTR)) {
@@ -383,9 +344,11 @@
 		switch (op) {
 		case OADD:
 		case OSUB:
+		case OA_ADD:
+		case OA_SUB:
 		case OINC:
 		case ODEC:
-			return arithmetic_pop(op, lp, rp);
+			return parithmetic(op, lp, rp);
 		}
 	}
 	errorp("incorrect arithmetic operands");
@@ -392,7 +355,7 @@
 }
 
 static Node *
-compare_pop(int op, Node *lp, Node *rp)
+pcompare(int op, Node *lp, Node *rp)
 {
 	Node *np;
 	int err = 0;
@@ -416,7 +379,7 @@
 }
 
 static Node *
-compare_op(int op, Node *lp, Node *rp)
+compare(int op, Node *lp, Node *rp)
 {
 	Type *ltp, *rtp;
 
@@ -424,7 +387,7 @@
 	rtp = rp->type;
 
 	if (ltp->op == PTR || rtp->op == PTR) {
-		return compare_pop(op, rp, lp);
+		return pcompare(op, rp, lp);
 	} else if ((ltp->prop & TARITH) && (rtp->prop & TARITH)) {
 		arithconv(&lp, &rp);
 		return simplify(op, inttype, lp, rp);
@@ -503,7 +466,7 @@
 	case OGT:
 		return (neg) ? negate(np) : np;
 	default:
-		return compare_op((neg) ?  OEQ : ONE, np, constnode(zero));
+		return compare((neg) ?  OEQ : ONE, np, constnode(zero));
 	}
 }
 
@@ -574,7 +537,7 @@
 
 	if (!(lp->type->prop & TINTEGER) && !(rp->type->prop & TINTEGER))
 		error("array subscript is not an integer");
-	np = arithmetic_op(OADD, lp, rp);
+	np = arithmetic(OADD, lp, rp);
 	tp = np->type;
 	if (tp->op != PTR)
 		errorp("subscripted value is neither array nor pointer");
@@ -582,7 +545,7 @@
 }
 
 static Node *
-assign_op(int op, Node *lp, Node *rp)
+assignop(int op, Node *lp, Node *rp)
 {
 	if ((rp = convert(rp, lp->type, 0)) == NULL) {
 		errorp("incompatible types when assigning");
@@ -614,7 +577,7 @@
 		errorp("wrong type argument to increment or decrement");
 		return np;
 	}
-	return arithmetic_op(op, np, inc);
+	return arithmetic(op, np, inc);
 }
 
 static Node *
@@ -883,9 +846,9 @@
 
 	switch (yytoken) {
 	case '!': op = 0;     fun = negation;     break;
-	case '+': op = OADD;  fun = numerical_uop; break;
-	case '-': op = OSNEG; fun = numerical_uop; break;
-	case '~': op = OCPL;  fun = integer_uop;   break;
+	case '+': op = OADD;  fun = numericaluop; break;
+	case '-': op = OSNEG; fun = numericaluop; break;
+	case '~': op = OCPL;  fun = integeruop;   break;
 	case '&': op = OADDR; fun = address;      break;
 	case '*': op = OPTR;  fun = content;      break;
 	case SIZEOF:
@@ -986,9 +949,9 @@
 	np = cast(1);
 	for (;;) {
 		switch (yytoken) {
-		case '*': op = OMUL; fun = arithmetic_op; break;
-		case '/': op = ODIV; fun = arithmetic_op; break;
-		case '%': op = OMOD; fun = integer_op;  break;
+		case '*': op = OMUL; fun = arithmetic; break;
+		case '/': op = ODIV; fun = arithmetic; break;
+		case '%': op = OMOD; fun = integerop;  break;
 		default: return np;
 		}
 		next();
@@ -1010,7 +973,7 @@
 		default:  return np;
 		}
 		next();
-		np = arithmetic_op(op, np, mul());
+		np = arithmetic(op, np, mul());
 	}
 }
 
@@ -1028,7 +991,7 @@
 		default:  return np;
 		}
 		next();
-		np = integer_op(op, np, add());
+		np = integerop(op, np, add());
 	}
 }
 
@@ -1048,7 +1011,7 @@
 		default:  return np;
 		}
 		next();
-		np = compare_op(op, np, shift());
+		np = compare(op, np, shift());
 	}
 }
 
@@ -1066,7 +1029,7 @@
 		default: return np;
 		}
 		next();
-		np = compare_op(op, np, relational());
+		np = compare(op, np, relational());
 	}
 }
 
@@ -1077,7 +1040,7 @@
 
 	np = eq();
 	while (accept('&'))
-		np = integer_op(OBAND, np, eq());
+		np = integerop(OBAND, np, eq());
 	return np;
 }
 
@@ -1088,7 +1051,7 @@
 
 	np = bit_and();
 	while (accept('^'))
-		np = integer_op(OBXOR,  np, bit_and());
+		np = integerop(OBXOR,  np, bit_and());
 	return np;
 }
 
@@ -1099,7 +1062,7 @@
 
 	np = bit_xor();
 	while (accept('|'))
-		np = integer_op(OBOR, np, bit_xor());
+		np = integerop(OBOR, np, bit_xor());
 	return np;
 }
 
@@ -1153,17 +1116,17 @@
 	np = ternary();
 	for (;;) {
 		switch (yytoken) {
-		case '=':    op = OASSIGN; fun = assign_op;   break;
-		case MUL_EQ: op = OA_MUL;  fun = arithmetic_aop; break;
-		case DIV_EQ: op = OA_DIV;  fun = arithmetic_aop; break;
-		case ADD_EQ: op = OA_ADD;  fun = arithmetic_aop; break;
-		case SUB_EQ: op = OA_SUB;  fun = arithmetic_aop; break;
-		case MOD_EQ: op = OA_MOD;  fun = integer_aop; break;
-		case SHL_EQ: op = OA_SHL;  fun = integer_aop; break;
-		case SHR_EQ: op = OA_SHR;  fun = integer_aop; break;
-		case AND_EQ: op = OA_AND;  fun = integer_aop; break;
-		case XOR_EQ: op = OA_XOR;  fun = integer_aop; break;
-		case OR_EQ:  op = OA_OR;   fun = integer_aop; break;
+		case '=':    op = OASSIGN; fun = assignop;   break;
+		case MUL_EQ: op = OA_MUL;  fun = arithmetic; break;
+		case DIV_EQ: op = OA_DIV;  fun = arithmetic; break;
+		case MOD_EQ: op = OA_MOD;  fun = integerop;  break;
+		case ADD_EQ: op = OA_ADD;  fun = arithmetic; break;
+		case SUB_EQ: op = OA_SUB;  fun = arithmetic; break;
+		case SHL_EQ: op = OA_SHL;  fun = integerop;  break;
+		case SHR_EQ: op = OA_SHR;  fun = integerop;  break;
+		case AND_EQ: op = OA_AND;  fun = integerop;  break;
+		case XOR_EQ: op = OA_XOR;  fun = integerop;  break;
+		case OR_EQ:  op = OA_OR;   fun = integerop;  break;
 		default: return np;
 		}
 		chklvalue(np);