projects/ddmd: dmd/BinExp.d comparison

comparison dmd/BinExp.d @ 174:af724d3510d7

lot os toCBuffer methods implemented moved shared Type.* stuff into Global

author	korDen
date	Sun, 10 Oct 2010 03:47:23 +0400
parents	14feb7ae01a6
children	94b6033c07f3

comparison

equal deleted inserted replaced

-:d237b38b5858
+:af724d3510d7
 			else if (i1)
 			{
 				goto Lt1;
 			}
 			else if (t1.ty == TY.Tclass && t2.ty == TY.Tclass)
 			{
 				TypeClass tc1 = cast(TypeClass)t1;
 				TypeClass tc2 = cast(TypeClass)t2;
 				/* Pick 'tightest' type
 				 */
 	{
 		super(loc, op, size);
 		this.e1 = e1;
 		this.e2 = e2;
 	}
 override Expression syntaxCopy()
 	{
 		BinExp e = cast(BinExp)copy();
 		e.type = null;
 		e.e1 = e.e1.syntaxCopy();
 			error("%s has no value", e2.toChars());
 			e2.type = Type.terror;
 		}
 		return this;
 	}
 Expression semanticp(Scope sc)
 	{
 		BinExp.semantic(sc);
 		e1 = resolveProperties(sc, e1);
 		e2 = resolveProperties(sc, e2);
 		return this;
 	}
 	/***************************
 	 * Common semantic routine for some xxxAssignExp's.
 	 */
 Expression commonSemanticAssign(Scope sc)
 	{
 			{
 				e = ArrayLengthExp.rewriteOpAssign(this);
 				e = e.semantic(sc);
 				return e;
 			}
 			if (e1.op == TOKslice)
 			{
 				// T[] op= ...
 				typeCombine(sc);
 				type = e1.type;
 				return arrayOp(sc);
 			}
 			{
 				e = ArrayLengthExp.rewriteOpAssign(this);
 				e = e.semantic(sc);
 				return e;
 			}
 			if (e1.op == TOK.TOKslice)
 			{   // T[] op= ...
 				typeCombine(sc);
 				type = e1.type;
 				return arrayOp(sc);
 			e2.checkIntegral();
 		}
 		return this;
 	}
 override bool checkSideEffect(int flag)
 	{
 		switch (op) {
 			case TOK.TOKplusplus:
 			case TOK.TOKminusminus:
 			default:
 				return Expression.checkSideEffect(flag);
 		}
 	}
 override void toCBuffer(OutBuffer buf, HdrGenState* hgs)
 	{
 		expToCBuffer(buf, hgs, e1, precedence[op]);
 		buf.writeByte(' ');
 		buf.writestring(Token.toChars(op));
 		ulong stride;
 		Type t1b = e1.type.toBasetype();
 		Type t2b = e2.type.toBasetype();
 		if (t1b.ty == Tpointer && t2b.isintegral())
 		{
 			// Need to adjust operator by the stride
 			// Replace (ptr + int) with (ptr + (int * stride))
 			Type t = Type.tptrdiff_t;
 			stride = t1b.nextOf().size(loc);
 			e2 = new MulExp(loc, e2, new IntegerExp(Loc(0), stride, t));
 			e2.type = t;
 			type = e1.type;
 		}
 		else if (t2b.ty == Tpointer && t1b.isintegral())
 		{
 			// Need to adjust operator by the stride
 			// Replace (int + ptr) with (ptr + (int * stride))
 			Type t = Type.tptrdiff_t;
 			Expression e;
 			e1 = e2;
 			e2 = e;
 		}
 		return this;
 	}
 	/************************************
 	 * Bring leaves to common type.
 	 */
 Expression typeCombine(Scope sc)
 	{
 			{
 				long  i2 = e2.toInteger();
 				ulong sz = e1.type.size() * 8;
 				if (i2 < 0 || i2 > sz)
 				{
 					error("shift assign by %jd is outside the range 0..%zu", i2, sz);
 					e2 = new IntegerExp(0);
 				}
 			}
 		}
 bool isunsigned()
 	{
 		return e1.type.isunsigned() || e2.type.isunsigned();
 	}
 void incompatibleTypes()
 	{
 		error("incompatible types for ((%s) %s (%s)): '%s' and '%s'",
 e1.toChars(), Token.toChars(op), e2.toChars(),
 e1.type.toChars(), e2.type.toChars());
 		return e;
 	Lcant:
 		return EXP_CANT_INTERPRET;
 	}
 Expression interpretAssignCommon(InterState istate, Expression function(Type, Expression, Expression) fp, int post = 0)
 	{
 version (LOG)
 {
 		writef("BinExp.interpretAssignCommon() %.*s\n", toChars());
 		Expression e1 = this.e1;
 		if (fp)
 		{
 			if (e1.op == TOKcast)
 			{
 				CastExp ce = cast(CastExp)e1;
 				e1 = ce.e1;
 			}
 		}
 		if (e1 is EXP_CANT_INTERPRET)
 			return e1;
 		Expression e2 = this.e2.interpret(istate);
 		if (e2 is EXP_CANT_INTERPRET)
 			return e2;
 		// Chase down rebinding of out and ref.
 		if (e1.op == TOKvar)
 		{
 			VarExp ve = cast(VarExp)e1;
 			VarDeclaration v = ve.var.isVarDeclaration();
 			if (v && v.value && v.value.op == TOKvar)
 			{
 				VarExp ve2 = cast(VarExp)v.value;
 				if (ve2.var.isSymbolDeclaration())
 				{
 					// This can happen if v is a struct initialized to
 					// 0 using an __initZ SymbolDeclaration from
 					// TypeStruct.defaultInit()
 				}
 				else
 					e1 = v.value;
 			}
 			else if (v && v.value && (v.value.op==TOKindex || v.value.op == TOKdotvar))
 			{
 				// It is no longer a TOKvar, eg when a[4] is passed by ref.
 				e1 = v.value;
 			}
 		}
 		// To reduce code complexity of handling dotvar expressions,
 		// extract the aggregate now.
 		Expression aggregate;
 		if (e1.op == TOKdotvar) {
 			aggregate = (cast(DotVarExp)e1).e1;
 		// Get rid of 'this'.
 			if (aggregate.op == TOKthis && istate.localThis)
 				aggregate = istate.localThis;
 		}
 		/* Assignment to variable of the form:
 		 *	v = e2
 		 */
 		if (e1.op == TOKvar)
 		{
 			VarExp ve = cast(VarExp)e1;
 			VarDeclaration v = ve.var.isVarDeclaration();
 			assert(v);
 			if (v && !v.isCTFE())
 			{
 				// Can't modify global or static data
 				error("%s cannot be modified at compile time", v.toChars());
 				return EXP_CANT_INTERPRET;
 			}
 			if (v && v.isCTFE())
 			{
 				Expression ev = v.value;
 				if (fp && !ev)
 				{
 					error("variable %s is used before initialization", v.toChars());
 					return e;
 				}
 				if (fp)
 					e2 = (*fp)(v.type, ev, e2);
 				else
 				{
 					/* Look for special case of struct being initialized with 0.
 					 */
 					if (v.type.toBasetype().ty == Tstruct && e2.op == TOKint64)
 					{
 						e2 = v.type.defaultInitLiteral(Loc(0));
 				v.value = e2;
 				e = Cast(type, type, post ? ev : e2);
 			}
 		}
 		else if (e1.op == TOKdotvar && aggregate.op == TOKdotvar)
 		{
 			// eg  v.u.var = e2,  v[3].u.var = e2, etc.
 			error("Nested struct assignment %s is not yet supported in CTFE", toChars());
 		}
 		/* Assignment to struct member of the form:
 		 *   v.var = e2
 		 */
 		else if (e1.op == TOKdotvar && aggregate.op == TOKvar)
 		{
 			VarDeclaration v = (cast(VarExp)aggregate).var.isVarDeclaration();
 			if (!v.isCTFE())
 			{
 				// Can't modify global or static data
 				error("%s cannot be modified at compile time", v.toChars());
 				return EXP_CANT_INTERPRET;
 			} else {
 				// Chase down rebinding of out and ref
 				if (v.value && v.value.op == TOKvar)
 				{
 					VarExp ve2 = cast(VarExp)v.value;
 					if (ve2.var.isSymbolDeclaration())
 					{
 						// This can happen if v is a struct initialized to
 						// 0 using an __initZ SymbolDeclaration from
 						// TypeStruct.defaultInit()
 					}
 					else
 						v = ve2.var.isVarDeclaration();
 					assert(v);
 				}
 			}
 			if (fp && !v.value)
 			{
 				error("variable %s is used before initialization", v.toChars());
 				return e;
 			}
 			if (v.value is null && v.init.isVoidInitializer())
 			{
 				/* Since a void initializer initializes to undefined
 				 * values, it is valid here to use the default initializer.
 				 * No attempt is made to determine if someone actually relies
 				 * on the void value - to do that we'd need a VoidExp.
 				 * That's probably a good enhancement idea.
 		}
 		/* Assignment to struct member of the form:
 		 *   *(symoffexp) = e2
 		 */
 		else if (e1.op == TOKstar && (cast(PtrExp)e1).e1.op == TOKsymoff)
 		{
 			SymOffExp soe = cast(SymOffExp)(cast(PtrExp)e1).e1;
 			VarDeclaration v = soe.var.isVarDeclaration();
 			if (!v.isCTFE())
 			{
 				error("%s cannot be modified at compile time", v.toChars());
 				return EXP_CANT_INTERPRET;
 			}
 			if (fp && !v.value)
 			{
 				error("variable %s is used before initialization", v.toChars());
 				return e;
 			}
 			Expression vie = v.value;
 			if (vie.op == TOKvar)
 		}
 		/* Assignment to array element of the form:
 		 *   a[i] = e2
 		 */
 		else if (e1.op == TOKindex && (cast(IndexExp)e1).e1.op == TOKvar)
 		{
 			IndexExp ie = cast(IndexExp)e1;
 			VarExp ve = cast(VarExp)ie.e1;
 			VarDeclaration v = ve.var.isVarDeclaration();
 			if (!v || !v.isCTFE())
 			{
 			}
 			if (v.value && v.value.op == TOKvar)
 			{
 				VarExp ve2 = cast(VarExp)v.value;
 				if (ve2.var.isSymbolDeclaration())
 				{
 					// This can happen if v is a struct initialized to
 					// 0 using an __initZ SymbolDeclaration from
 					// TypeStruct.defaultInit()
 				}
 				else
 				assert(v);
 			}
 			if (!v.value)
 			{
 				if (fp)
 				{
 					error("variable %s is used before initialization", v.toChars());
 					return e;
 				}
 				Type t = v.type.toBasetype();
 				e2 = (*fp)(type, ev, e2);
 			else
 				e2 = Cast(type, type, e2);
 			if (e2 is EXP_CANT_INTERPRET)
 				return e2;
 			addVarToInterstate(istate, v);
 			if (ae)
 			{
 				/* Create new array literal reflecting updated elem
 				 */
 				Expressions keysx = aae.keys;
 				Expressions valuesx = new Expressions();
 				valuesx.setDim(aae.values.dim);
 				int updated = 0;
 				for (size_t j = valuesx.dim; j; )
 				{
 					j--;
 					Expression ekey = aae.keys[j];
 					Expression ex = Equal(TOKequal, Type.tbool, ekey, index);
 					if (ex is EXP_CANT_INTERPRET)
 						return EXP_CANT_INTERPRET;
 					if (ex.isBool(true))
 					{
 						valuesx[j] = e2;
 						updated = 1;
 					}
 					else
 						valuesx[j] = aae.values[j];
 				}
 				if (!updated)
 				{
 					// Append index/e2 to keysx[]/valuesx[]
 					valuesx.push(e2);
 					keysx = keysx.copy();
 					keysx.push(index);
 				}
 			else
 				assert(0);
 			e = Cast(type, type, post ? ev : e2);
 		}
 		/* Assignment to struct element in array, of the form:
 		 *  a[i].var = e2
 		 */
 		else if (e1.op == TOKdotvar && aggregate.op == TOKindex &&
 			 (cast(IndexExp)aggregate).e1.op == TOKvar)
 				return EXP_CANT_INTERPRET;
 			int elemi = cast(int)index.toInteger();
 			if (elemi >= ae.elements.dim)
 			{
 				error("array index %d is out of bounds %s[0..%d]", elemi,
 					v.toChars(), ae.elements.dim);
 				return EXP_CANT_INTERPRET;
 			}
 			// Get old element
 			auto vie = ae.elements[elemi];
 				return EXP_CANT_INTERPRET;
 			int fieldi = se.getFieldIndex(type, vf.offset);
 			if (fieldi == -1)
 				return EXP_CANT_INTERPRET;
 			Expression ev = se.getField(type, vf.offset);
 			if (fp)
 				e2 = (*fp)(type, ev, e2);
 			else
 				e2 = Cast(type, type, e2);
 			// Chase down rebinding of out and ref
 			if (v.value && v.value.op == TOKvar)
 			{
 				VarExp ve2 = cast(VarExp)v.value;
 				if (ve2.var.isSymbolDeclaration())
 				{
 					// This can happen if v is a struct initialized to
 					// 0 using an __initZ SymbolDeclaration from
 					// TypeStruct.defaultInit()
 				}
 				else
 				if (lower is EXP_CANT_INTERPRET)
 					return EXP_CANT_INTERPRET;
 			}
 			Type t = v.type.toBasetype();
 			size_t dim;
 			if (t.ty == Tsarray)
 				dim = cast(size_t)(cast(TypeSArray)t).dim.toInteger();
 			else if (t.ty == Tarray)
 			{
 				if (!v.value || v.value.op == TOKnull)
 				{
 			}
 			if (e2.op == TOKarrayliteral)
 			{
 				// Static array assignment from literal
 				ArrayLiteralExp ae = cast(ArrayLiteralExp)e2;
 				if (ae.elements.dim != (upperbound - lowerbound))
 				{
 					error("Array length mismatch assigning [0..%d] to [%d..%d]", ae.elements.dim, lowerbound, upperbound);
 					return e;
 				}
 				else
 				{
 					// value[] = value[0..lower] ~ ae ~ value[upper..$]
 					existing.elements = spliceElements(existing.elements, createBlockDuplicatedArrayLiteral(v.type, e2, upperbound-lowerbound).elements, lowerbound);
 					v.value = existing;
 				}
 				return e2;
 			}
 			else if (e2.op == TOKstring)
 			{
 				StringExp se = cast(StringExp)e2;
 	version(DMDV2)
 override bool canThrow()
 	{
 		return e1.canThrow() || e2.canThrow();
 	}
 	// generate an error if this is a nonsensical *=,/=, or %=, eg real *= imaginary
 	void checkComplexMulAssign()
 	{
 		// Any multiplication by an imaginary or complex number yields a complex result.
 		// r *= c, i*=c, r*=i, i*=i are all forbidden operations.
 		string opstr = Token.toChars(op);
 		if ( e1.type.isreal() && e2.type.iscomplex())
 		{
 			error("%s %s %s is undefined. Did you mean %s %s %s.re ?",
 				e1.type.toChars(), opstr, e2.type.toChars(),
 				e1.type.toChars(), opstr, e2.type.toChars());
 		}
 		else if (e1.type.isimaginary() && e2.type.iscomplex())
 		{
 			error("%s %s %s is undefined. Did you mean %s %s %s.im ?",
 	void checkComplexAddAssign()
 	{
 		// Addition or subtraction of a real and an imaginary is a complex result.
 		// Thus, r+=i, r+=c, i+=r, i+=c are all forbidden operations.
 		if ( (e1.type.isreal() && (e2.type.isimaginary() || e2.type.iscomplex())) ||
 			 (e1.type.isimaginary() && (e2.type.isreal() || e2.type.iscomplex()))
 			)
 		{
 			error("%s %s %s is undefined (result is complex)",
 			e1.type.toChars(), Token.toChars(op), e2.type.toChars());
 		}
 	 * Construct the array operation expression.
 	 */
 Expression arrayOp(Scope sc)
 	{
 		//printf("BinExp.arrayOp() %s\n", toChars());
 		if (type.toBasetype().nextOf().toBasetype().ty == Tvoid)
 		{
 			error("Cannot perform array operations on void[] arrays");
 			return new ErrorExp();
 		}
 		auto arguments = new Expressions();
 		/* The expression to generate an array operation for is mangled
 		 * into a name to use as the array operation function name.
 		 * Mangle in the operands and operators in RPN order, and type.
 override int inlineCost(InlineCostState* ics)
 	{
 		return 1 + e1.inlineCost(ics) + e2.inlineCost(ics);
 	}
 override Expression doInline(InlineDoState ids)
 	{
 		BinExp be = cast(BinExp)copy();
 		be.e1 = e1.doInline(ids);
 		be.e2 = e2.doInline(ids);
 		return be;
 	}
 override Expression inlineScan(InlineScanState* iss)
 	{
 		e1 = e1.inlineScan(iss);
 		e2 = e2.inlineScan(iss);
 		return this;
 				if (fd)
 				{
 					overloadResolveX(&m, fd, null, args2);
 				}
 				else
 				{
 					td = s.isTemplateDeclaration();
 					templateResolve(&m, td, sc, loc, null, null, args2);
 				}
 			}
 			lastf = m.lastf;
 			if (s_r)
 			{
 				fd = s_r.isFuncDeclaration();
 				if (fd)
 				{
 					overloadResolveX(&m, fd, null, args1);
 				}
 				else
 				{
 					td = s_r.isTemplateDeclaration();
 					templateResolve(&m, td, sc, loc, null, null, args1);
 				}
 			}
 				 *	b.opfunc(a)
 				 * and see which is better.
 				 */
 				if (!argsset)
 				{
 					args1.setDim(1);
 					args1[0] = e1;
 					args2.setDim(1);
 					args2[0] = e2;
 				}
 		el_setLoc(e,loc);
 		return e;
 	}
 	final void AssignExp_buildArrayIdent(OutBuffer buf, Expressions arguments, string Str)
 	{
 		/* Evaluate assign expressions right to left
 		 */
 		e2.buildArrayIdent(buf, arguments);
 		e1.buildArrayIdent(buf, arguments);
 		buf.writestring(Str);
 		buf.writestring("ass");
 	}
 	final void Exp_buildArrayIdent(OutBuffer buf, Expressions arguments, string Str)
 	{
 		/* Evaluate assign expressions left to right
 		 */
 		e1.buildArrayIdent(buf, arguments);
 		e2.buildArrayIdent(buf, arguments);
 		buf.writestring(Str);
 	}
 	final Expression AssignExp_buildArrayLoop(AssignExpType)(Parameters fparams)// if (is (AssignExpType : AssignExp))
 	{
 		/* Evaluate assign expressions right to left
 		 */
 		Expression ex2 = e2.buildArrayLoop(fparams);
 		auto param = fparams[0];
 		param.storageClass = STCundefined;
 		Expression e = new AssignExpType(Loc(0), ex1, ex2);
 		return e;
 	}
 	final Expression Exp_buildArrayLoop(ExpType)(Parameters fparams) if (is (ExpType : BinExp))
 	{
 		/* Evaluate assign expressions left to right
 		 */
 		Expression ex1 = e1.buildArrayLoop(fparams);

Mercurial > projects > ddmd

comparison dmd/BinExp.d @ 174:af724d3510d7