projects/ldc: dmd/expression.c comparison

comparison dmd/expression.c @ 510:6aee82889553

Merged DMD 1.034, array operations are not yet implemented ;)

author	Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
date	Thu, 14 Aug 2008 06:55:41 +0200
parents	a34078905d01
children	f79bbd1d0b27

comparison

equal deleted inserted replaced

-:337554fd34f1
+:6aee82889553
 	else if (e->op == TOKdotexp)
 	{
 	    e->error("expression has no value");
 	}
 }
 return e;
 }
 /******************************
 	    e = e->semantic(sc);
 	    exps->data[i] = (void *)e;
 	}
 }
 }
+/******************************
+* Perform canThrow() on an array of Expressions.
+*/
+#if DMDV2
+int arrayExpressionCanThrow(Expressions *exps)
+{
+if (exps)
+{
+	for (size_t i = 0; i < exps->dim; i++)
+	{   Expression *e = (Expression *)exps->data[i];
+	    if (e && e->canThrow())
+		return 1;
+	}
+}
+return 0;
+}
+#endif
 /****************************************
 * Expand tuples.
 */
 #endif
 /****************************************
 * Now that we know the exact type of the function we're calling,
 * the arguments[] need to be adjusted:
-*	1) implicitly convert argument to the corresponding parameter type
+*	1. implicitly convert argument to the corresponding parameter type
-*	2) add default arguments for any missing arguments
+*	2. add default arguments for any missing arguments
-*	3) do default promotions on arguments corresponding to ...
+*	3. do default promotions on arguments corresponding to ...
-*	4) add hidden _arguments[] argument
+*	4. add hidden _arguments[] argument
 */
 void functionArguments(Loc loc, Scope *sc, TypeFunction *tf, Expressions *arguments)
 {
 unsigned n;
 /******************************** Expression **************************/
 Expression::Expression(Loc loc, enum TOK op, int size)
 : loc(loc)
 {
+//printf("Expression::Expression(op = %d) this = %p\n", op, this);
 this->loc = loc;
 this->op = op;
 this->size = size;
 type = NULL;
 }
 	dump(0);
 #endif
 	assert(0);
 }
 e = (Expression *)mem.malloc(size);
+//printf("Expression::copy(op = %d) e = %p\n", op, e);
 return (Expression *)memcpy(e, this, size);
 }
 /**************************
 * Semantically analyze Expression.
 return this;
 }
 Expression *Expression::modifiableLvalue(Scope *sc, Expression *e)
 {
+//printf("Expression::modifiableLvalue() %s, type = %s\n", toChars(), type->toChars());
 // See if this expression is a modifiable lvalue (i.e. not const)
 return toLvalue(sc, e);
 }
 /************************************
 	    type = Type::tint64;
 	else
 	    type = Type::tint32;
 }
 else
-{	type = type->semantic(loc, sc);
+{	if (!type->deco)
+	    type = type->semantic(loc, sc);
 }
 return this;
 }
 Expression *IntegerExp::toLvalue(Scope *sc, Expression *e)
 s = sc->search(loc, ident, &scopesym);
 if (s)
 {	Expression *e;
 	WithScopeSymbol *withsym;
-	// See if it was a with class
+	/* See if the symbol was a member of an enclosing 'with'
+	 */
 	withsym = scopesym->isWithScopeSymbol();
 	if (withsym)
 	{
 	    s = s->toAlias();
 		e = new DotIdExp(loc, e, ident);
 	    }
 	    else
 	    {	Type *t = withsym->withstate->wthis->type;
 		if (t->ty == Tpointer)
-		    t = t->next;
+		    t = ((TypePointer *)t)->next;
 		e = new TypeDotIdExp(loc, t, ident);
 	    }
 	}
 	else
 	{
 if (!sc->intypeof)
 	sc->callSuper |= CSXthis;
 return this;
 Lerr:
-error("'this' is only allowed in non-static member functions, not %s", sc->parent->toChars());
+error("'this' is only defined in non-static member functions, not %s", sc->parent->toChars());
-type = Type::tint32;
+type = Type::terror;
 return this;
 }
 int ThisExp::isBool(int result)
 {
 	if (!t0)
 	{   t0 = e->type;
 	    // Convert any static arrays to dynamic arrays
 	    if (t0->ty == Tsarray)
 	    {
-		t0 = t0->next->arrayOf();
+		t0 = ((TypeSArray *)t0)->next->arrayOf();
 		e = e->implicitCastTo(sc, t0);
 	    }
 	}
 	else
 	    e = e->implicitCastTo(sc, t0);
 {   Expression *e;
 #if LOGSEMANTIC
 printf("StructLiteralExp::semantic('%s')\n", toChars());
 #endif
+if (type)
+	return this;
 // Run semantic() on each element
 for (size_t i = 0; i < elements->dim; i++)
 {	e = (Expression *)elements->data[i];
 	if (!e)
 * Gets expression at offset of type.
 * Returns NULL if not found.
 */
 Expression *StructLiteralExp::getField(Type *type, unsigned offset)
-{   Expression *e = NULL;
+{
+//printf("StructLiteralExp::getField(this = %s, type = %s, offset = %u)\n",
+//	/*toChars()*/"", type->toChars(), offset);
+Expression *e = NULL;
 int i = getFieldIndex(type, offset);
 if (i != -1)
-{   e = (Expression *)elements->data[i];
+{
+	//printf("\ti = %d\n", i);
+	assert(i < elements->dim);
+	e = (Expression *)elements->data[i];
 	if (e)
 	{
 	    e = e->copy();
 	    e->type = type;
 	}
 	     * Ensure we have the right one.
 	     */
 	    Dsymbol *s = cd->toParent2();
 	    ClassDeclaration *cdn = s->isClassDeclaration();
-	    //printf("isNested, cdn = %s\n", cdn ? cdn->toChars() : "null");
+	    //printf("cd isNested, cdn = %s\n", cdn ? cdn->toChars() : "null");
 	    if (cdn)
 	    {
 		if (!cdthis)
 		{
 		    // Supply an implicit 'this' and try again
 	    arg = resolveProperties(sc, arg);
 	    arg = arg->implicitCastTo(sc, Type::tsize_t);
 	    if (arg->op == TOKint64 && (long long)arg->toInteger() < 0)
 		error("negative array index %s", arg->toChars());
 	    arguments->data[i] = (void *) arg;
-	    tb = tb->next->toBasetype();
+	    tb = ((TypeDArray *)tb)->next->toBasetype();
 	}
 }
 else if (tb->isscalar())
 {
 	if (arguments && arguments->dim)
 // See if this expression is a modifiable lvalue (i.e. not const)
 return toLvalue(sc, e);
 }
+/******************************** OverExp **************************/
+#if DMDV2
+OverExp::OverExp(OverloadSet *s)
+	: Expression(loc, TOKoverloadset, sizeof(OverExp))
+{
+//printf("OverExp(this = %p, '%s')\n", this, var->toChars());
+vars = s;
+type = Type::tvoid;
+}
+int OverExp::isLvalue()
+{
+return 1;
+}
+Expression *OverExp::toLvalue(Scope *sc, Expression *e)
+{
+return this;
+}
+#endif
 /******************************** TupleExp **************************/
 TupleExp::TupleExp(Loc loc, Expressions *exps)
 	: Expression(loc, TOKtuple, sizeof(TupleExp))
 {
 buf->writestring("typeid(");
 typeidType->toCBuffer(buf, NULL, hgs);
 buf->writeByte(')');
 }
+/************************ TraitsExp ************************************/
+#if DMDV2
+/*
+*	__traits(identifier, args...)
+*/
+TraitsExp::TraitsExp(Loc loc, Identifier *ident, Objects *args)
+: Expression(loc, TOKtraits, sizeof(TraitsExp))
+{
+this->ident = ident;
+this->args = args;
+}
+Expression *TraitsExp::syntaxCopy()
+{
+return new TraitsExp(loc, ident, TemplateInstance::arraySyntaxCopy(args));
+}
+void TraitsExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
+{
+buf->writestring("__traits(");
+buf->writestring(ident->toChars());
+if (args)
+{
+	for (int i = 0; i < args->dim; i++)
+	{
+	    buf->writeByte(',');
+	    Object *oarg = (Object *)args->data[i];
+	    ObjectToCBuffer(buf, hgs, oarg);
+	}
+}
+buf->writeByte(')');
+}
+#endif
 /************************************************************/
 HaltExp::HaltExp(Loc loc)
 	: Expression(loc, TOKhalt, sizeof(HaltExp))
 {
 }
 Expression *IsExp::semantic(Scope *sc)
 {   Type *tded;
-//printf("IsExp::semantic()\n");
+/* is(targ id tok tspec)
+* is(targ id == tok2)
+*/
+//printf("IsExp::semantic(%s)\n", toChars());
 if (id && !(sc->flags & SCOPEstaticif))
 	error("can only declare type aliases within static if conditionals");
 unsigned errors_save = global.errors;
 global.errors = 0;
 		    goto Lno;
 		if (!((TypeClass *)targ)->sym->isInterfaceDeclaration())
 		    goto Lno;
 		tded = targ;
 		break;
+#if DMDV2
+	    case TOKconst:
+		if (!targ->isConst())
+		    goto Lno;
+		tded = targ;
+		break;
+	    case TOKinvariant:
+		if (!targ->isInvariant())
+		    goto Lno;
+		tded = targ;
+		break;
+#endif
 	    case TOKsuper:
 		// If class or interface, get the base class and interfaces
 		if (targ->ty != Tclass)
 		    goto Lno;
 		break;
 	    case TOKdelegate:
 		if (targ->ty != Tdelegate)
 		    goto Lno;
-		tded = targ->next;	// the underlying function type
+		tded = ((TypeDelegate *)targ)->next;	// the underlying function type
 		break;
 	    case TOKfunction:
-	    {	if (targ->ty != Tfunction)
+	    {
+		if (targ->ty != Tfunction)
 		    goto Lno;
 		tded = targ;
 		/* Generate tuple from function parameter types.
 		 */
 	    case TOKreturn:
 		/* Get the 'return type' for the function,
 		 * delegate, or pointer to function.
 		 */
 		if (targ->ty == Tfunction)
-		    tded = targ->next;
+		    tded = ((TypeFunction *)targ)->next;
 		else if (targ->ty == Tdelegate)
 		    tded = targ->next->next;
 		else if (targ->ty == Tpointer && targ->next->ty == Tfunction)
 		    tded = targ->next->next;
 		else
 	e = op_overload(sc);
 	if (e)
 	    return e;
+	if (e1->op == TOKslice)
+	{   // T[] op= ...
+	    typeCombine(sc);
+	    type = e1->type;
+	    return arrayOp(sc);
+	}
 	e1 = e1->modifiableLvalue(sc, e1);
 	e1->checkScalar();
 	type = e1->type;
 	if (type->toBasetype()->ty == Tbool)
 	{
 	e2 = resolveProperties(sc, e2);
 	e = op_overload(sc);
 	if (e)
 	    return e;
+	if (e1->op == TOKslice)
+	{   // T[] op= ...
+	    typeCombine(sc);
+	    type = e1->type;
+	    return arrayOp(sc);
+	}
 	e1 = e1->modifiableLvalue(sc, e1);
 	e1->checkScalar();
 	type = e1->type;
 	if (type->toBasetype()->ty == Tbool)
 {
 	e1 = resolveProperties(sc, e1);
 	eleft = NULL;
 	eright = e1;
 }
+#if DMDV2
+if (e1->op == TOKtuple && ident == Id::offsetof)
+{	/* 'distribute' the .offsetof to each of the tuple elements.
+	 */
+	TupleExp *te = (TupleExp *)e1;
+	Expressions *exps = new Expressions();
+	exps->setDim(te->exps->dim);
+	for (int i = 0; i < exps->dim; i++)
+	{   Expression *e = (Expression *)te->exps->data[i];
+	    e = e->semantic(sc);
+	    e = new DotIdExp(e->loc, e, Id::offsetof);
+	    exps->data[i] = (void *)e;
+	}
+	e = new TupleExp(loc, exps);
+	e = e->semantic(sc);
+	return e;
+}
+#endif
 if (e1->op == TOKtuple && ident == Id::length)
 {
 	TupleExp *te = (TupleExp *)e1;
 	e = new IntegerExp(loc, te->exps->dim, Type::tsize_t);
 	     ident != Id::init && ident != Id::__sizeof &&
 	     ident != Id::alignof && ident != Id::offsetof &&
 	     ident != Id::mangleof && ident != Id::stringof)
 {
 	e = new PtrExp(loc, e1);
-	e->type = e1->type->next;
+	e->type = ((TypePointer *)e1->type)->next;
 	return e->type->dotExp(sc, e, ident);
 }
 else
 {
 	e = e1->type->dotExp(sc, e1, ident);
 return this;
 }
 Expression *DotVarExp::modifiableLvalue(Scope *sc, Expression *e)
 {
-//printf("DotVarExp::modifiableLvalue(%s)\n", toChars());
+#if 0
+printf("DotVarExp::modifiableLvalue(%s)\n", toChars());
+printf("e1->type = %s\n", e1->type->toChars());
+printf("var->type = %s\n", var->type->toChars());
+#endif
 if (var->isCtorinit())
 {	// It's only modifiable if inside the right constructor
 	Dsymbol *s = sc->func;
 	while (1)
 e1 = e1->semantic(sc);
 t1 = e1->type;
 if (t1)
 	t1 = t1->toBasetype();
 //t1->print();
+/* Extract the following from e1:
+*	s: the symbol which ti should be a member of
+*	eleft: if not NULL, it is the 'this' pointer for ti
+*/
 if (e1->op == TOKdotexp)
 {	DotExp *de = (DotExp *)e1;
 	eleft = de->e1;
 	eright = de->e2;
 }
 	s = t1->toDsymbol(sc);
 	eleft = e1;
 }
 else if (t1 && t1->ty == Tpointer)
 {
-	t1 = t1->next->toBasetype();
+	t1 = ((TypePointer *)t1)->next->toBasetype();
 	if (t1->ty != Tstruct)
 	    goto L1;
 	s = t1->toDsymbol(sc);
 	eleft = e1;
 }
 TypeFunction *tf;
 FuncDeclaration *f;
 int i;
 Type *t1;
 int istemp;
+Objects *targsi = NULL;	// initial list of template arguments
 #if LOGSEMANTIC
 printf("CallExp::semantic() %s\n", toChars());
 #endif
 if (type)
 		e1 = new IdentifierExp(dotid->loc, dotid->ident);
 	    }
 	}
 }
+#if DMDV2
+/* This recognizes:
+*	foo!(tiargs)(funcargs)
+*/
+if (e1->op == TOKimport && !e1->type)
+{	ScopeExp *se = (ScopeExp *)e1;
+	TemplateInstance *ti = se->sds->isTemplateInstance();
+	if (ti && !ti->semanticdone)
+	{
+	    /* Attempt to instantiate ti. If that works, go with it.
+	     * If not, go with partial explicit specialization.
+	     */
+	    ti->semanticTiargs(sc);
+	    unsigned errors = global.errors;
+	    global.gag++;
+	    ti->semantic(sc);
+	    global.gag--;
+	    if (errors != global.errors)
+	    {
+		/* Didn't work, go with partial explicit specialization
+		 */
+		global.errors = errors;
+		targsi = ti->tiargs;
+		e1 = new IdentifierExp(loc, ti->name);
+	    }
+	}
+}
+/* This recognizes:
+*	expr.foo!(tiargs)(funcargs)
+*/
+if (e1->op == TOKdotti && !e1->type)
+{	DotTemplateInstanceExp *se = (DotTemplateInstanceExp *)e1;
+	TemplateInstance *ti = se->ti;
+	if (!ti->semanticdone)
+	{
+	    /* Attempt to instantiate ti. If that works, go with it.
+	     * If not, go with partial explicit specialization.
+	     */
+	    ti->semanticTiargs(sc);
+	    Expression *etmp;
+	    unsigned errors = global.errors;
+	    global.gag++;
+	    etmp = e1->semantic(sc);
+	    global.gag--;
+	    if (errors != global.errors)
+	    {
+		global.errors = errors;
+		targsi = ti->tiargs;
+		e1 = new DotIdExp(loc, se->e1, ti->name);
+	    }
+	    else
+		e1 = etmp;
+	}
+}
+#endif
 istemp = 0;
 Lagain:
+//printf("Lagain: %s\n", toChars());
 f = NULL;
 if (e1->op == TOKthis || e1->op == TOKsuper)
 {
 	// semantic() run later for these
 }
 	return this;
 }
 else if (t1->ty != Tfunction)
 {
 	if (t1->ty == Tdelegate)
-	{
+	{   TypeDelegate *td = (TypeDelegate *)t1;
-	    assert(t1->next->ty == Tfunction);
+	    assert(td->next->ty == Tfunction);
-	    tf = (TypeFunction *)(t1->next);
+	    tf = (TypeFunction *)(td->next);
 	    goto Lcheckargs;
 	}
-	else if (t1->ty == Tpointer && t1->next->ty == Tfunction)
+	else if (t1->ty == Tpointer && ((TypePointer *)t1)->next->ty == Tfunction)
 	{   Expression *e;
 	    e = new PtrExp(loc, e1);
-	    t1 = t1->next;
+	    t1 = ((TypePointer *)t1)->next;
 	    e->type = t1;
 	    e1 = e;
 	}
 	else if (e1->op == TOKtemplate)
 	{
 if (f && f->tintro)
 {
 	Type *t = type;
 	int offset = 0;
+	TypeFunction *tf = (TypeFunction *)f->tintro;
-	if (f->tintro->next->isBaseOf(t, &offset) && offset)
-	{
+	if (tf->next->isBaseOf(t, &offset) && offset)
-	    type = f->tintro->next;
+	{
+	    type = tf->next;
 	    return castTo(sc, t);
 	}
 }
 return this;
 	{
 	    DotVarExp *dve = (DotVarExp *)e1;
 	    FuncDeclaration *f = dve->var->isFuncDeclaration();
 	    if (f)
-	    {	Expression *e;
+	    {	Expression *e = new DelegateExp(loc, dve->e1, f);
-		e = new DelegateExp(loc, dve->e1, f);
 		e = e->semantic(sc);
 		return e;
 	    }
 	}
 	else if (e1->op == TOKvar)
 PtrExp::PtrExp(Loc loc, Expression *e)
 	: UnaExp(loc, TOKstar, sizeof(PtrExp), e)
 {
 if (e->type)
-	type = e->type->next;
+	type = ((TypePointer *)e->type)->next;
 }
 PtrExp::PtrExp(Loc loc, Expression *e, Type *t)
 	: UnaExp(loc, TOKstar, sizeof(PtrExp), e)
 {
 	e = op_overload(sc);
 	if (e)
 	    return e;
 	e1->checkNoBool();
-	e1->checkArithmetic();
+	if (e1->op != TOKslice)
+	    e1->checkArithmetic();
 	type = e1->type;
 }
 return this;
 }
 	e = op_overload(sc);
 	if (e)
 	    return e;
 	e1->checkNoBool();
-	e1 = e1->checkIntegral();
+	if (e1->op != TOKslice)
+	    e1 = e1->checkIntegral();
 	type = e1->type;
 }
 return this;
 }
 		error("cannot delete instance of COM interface %s", cd->toChars());
 	    }
 	    break;
 	}
 	case Tpointer:
-	    tb = tb->next->toBasetype();
+	    tb = ((TypePointer *)tb)->next->toBasetype();
 	    if (tb->ty == Tstruct)
 	    {
 		TypeStruct *ts = (TypeStruct *)tb;
 		StructDeclaration *sd = ts->sym;
 		FuncDeclaration *f = sd->aggDelete;
 	    e = e1;
 	}
 	return e;
 }
-type = t->next->arrayOf();
+type = t->nextOf()->arrayOf();
 return e;
 Lerror:
 char *s;
 if (t->ty == Tvoid)
 		if (index < 0 || index >= length)
 		    error("array index [%lld] is outside array bounds [0 .. %lld]",
 			    index, length);
 	    }
 #endif
-	    e->type = t1->next;
+	    e->type = t1->nextOf();
 	    break;
 	}
 	case Taarray:
 	{   TypeAArray *taa = (TypeAArray *)t1;
 }
 else
 {
 	e2 = e2->implicitCastTo(sc, e1->type);
 }
+/* Look for array operations
+*/
+if (e1->op == TOKslice && !ismemset &&
+	(e2->op == TOKadd || e2->op == TOKmin ||
+	 e2->op == TOKmul || e2->op == TOKdiv ||
+	 e2->op == TOKmod || e2->op == TOKxor ||
+	 e2->op == TOKand || e2->op == TOKor  ||
+	 e2->op == TOKtilde || e2->op == TOKneg))
+{
+	type = e1->type;
+	return arrayOp(sc);
+}
 type = e1->type;
 assert(type);
 return this;
 }
 e = op_overload(sc);
 if (e)
 	return e;
-e1 = e1->modifiableLvalue(sc, e1);
 Type *tb1 = e1->type->toBasetype();
 Type *tb2 = e2->type->toBasetype();
+if (e1->op == TOKslice)
+{
+	typeCombine(sc);
+	type = e1->type;
+	return arrayOp(sc);
+}
+else
+{
+	e1 = e1->modifiableLvalue(sc, e1);
+}
 if ((tb1->ty == Tarray || tb1->ty == Tsarray) &&
 	(tb2->ty == Tarray || tb2->ty == Tsarray) &&
-	tb1->next->equals(tb2->next)
+	tb1->nextOf()->equals(tb2->nextOf())
 )
 {
 	type = e1->type;
 	e = this;
 }
 	    {   // Rewrite e1+=e2 to (v=&e1),*v=*v+e2
 		VarDeclaration *v;
 		Expression *ea;
 		Expression *ex;
-		char name[6+6+1];
+		Identifier *id = Lexer::uniqueId("__name");
-		Identifier *id;
-		static int idn;
-		sprintf(name, "__name%d", ++idn);
-		id = Lexer::idPool(name);
 		v = new VarDeclaration(loc, tb1->pointerTo(), id, NULL);
 		v->semantic(sc);
 		if (!sc->insert(v))
 		    assert(0);
 e2 = resolveProperties(sc, e2);
 e = op_overload(sc);
 if (e)
 	return e;
+if (e1->op == TOKslice)
+{	// T[] -= ...
+	typeCombine(sc);
+	type = e1->type;
+	return arrayOp(sc);
+}
 e1 = e1->modifiableLvalue(sc, e1);
 e1->checkScalar();
 e1->checkNoBool();
 if (e1->type->ty == Tpointer && e2->type->isintegral())
 	e2 = e2->castTo(sc, e1->type);
 	type = e1->type;
 	e = this;
 }
 else if ((tb1->ty == Tarray) &&
-	e2->implicitConvTo(tb1->next)
+	e2->implicitConvTo(tb1->nextOf())
 )
 {	// Append element
-	e2 = e2->castTo(sc, tb1->next);
+	e2 = e2->castTo(sc, tb1->nextOf());
 	type = e1->type;
 	e = this;
 }
 else
 {
 e2 = resolveProperties(sc, e2);
 e = op_overload(sc);
 if (e)
 	return e;
+if (e1->op == TOKslice)
+{	// T[] -= ...
+	typeCombine(sc);
+	type = e1->type;
+	return arrayOp(sc);
+}
 e1 = e1->modifiableLvalue(sc, e1);
 e1->checkScalar();
 e1->checkNoBool();
 type = e1->type;
 e = op_overload(sc);
 if (e)
 	return e;
+if (e1->op == TOKslice)
+{	// T[] -= ...
+	typeCombine(sc);
+	type = e1->type;
+	return arrayOp(sc);
+}
 e1 = e1->modifiableLvalue(sc, e1);
 e1->checkScalar();
 e1->checkNoBool();
 type = e1->type;
 typeCombine(sc);
 	Type *tb1 = e1->type->toBasetype();
 	Type *tb2 = e2->type->toBasetype();
 if ((tb1->ty == Tarray || tb1->ty == Tsarray) &&
 (tb2->ty == Tarray || tb2->ty == Tsarray) &&
-tb1->next->equals(tb2->next)
+tb1->nextOf()->equals(tb2->nextOf())
 )
 {
 type = e1->type;
 e = this;
 }
 	    d_int64 stride;
 	    Expression *e;
 	    typeCombine(sc);		// make sure pointer types are compatible
 	    type = Type::tptrdiff_t;
-	    stride = t2->next->size();
+	    stride = t2->nextOf()->size();
-if (!stride)
+	    if (stride == 0)
-return new IntegerExp(0, 0, Type::tptrdiff_t);
+	    {
-	    e = new DivExp(loc, this, new IntegerExp(0, stride, Type::tptrdiff_t));
+		e = new IntegerExp(loc, 0, Type::tptrdiff_t);
-	    e->type = Type::tptrdiff_t;
+	    }
+	    else
+	    {
+		e = new DivExp(loc, this, new IntegerExp(0, stride, Type::tptrdiff_t));
+		e->type = Type::tptrdiff_t;
+	    }
 	    return e;
 	}
 	else if (t2->isintegral())
 	    e = scaleFactor(sc);
 	else
-	{   error("incompatible types for -");
+	{   error("incompatible types for minus");
 	    return new IntegerExp(0);
 	}
 }
 else if (t2->ty == Tpointer)
 {
 	e2->type->print();
 #endif
 	if ((tb1->ty == Tsarray || tb1->ty == Tarray) &&
 	    e2->type->equals(tb1->next))
 	{
-	    type = tb1->next->arrayOf();
+	    type = tb1->nextOf()->arrayOf();
 	    if (tb2->ty == Tarray)
 	    {	// Make e2 into [e2]
 		e2 = new ArrayLiteralExp(e2->loc, e2);
 		e2->type = type;
 	    }
 	    return this;
 	}
 	else if ((tb2->ty == Tsarray || tb2->ty == Tarray) &&
 	    e1->type->equals(tb2->next))
 	{
-	    type = tb2->next->arrayOf();
+	    type = tb2->nextOf()->arrayOf();
 	    if (tb1->ty == Tarray)
 	    {	// Make e1 into [e1]
 		e1 = new ArrayLiteralExp(e1->loc, e1);
 		e1->type = type;
 	    }
 	{
 	    e = this;
 	}
 	else
 	{
+	    //printf("(%s) ~ (%s)\n", e1->toChars(), e2->toChars());
 	    error("Can only concatenate arrays, not (%s ~ %s)",
 		e1->type->toChars(), e2->type->toChars());
 	    type = Type::tint32;
 	    e = this;
 	}
 e = op_overload(sc);
 if (e)
 	return e;
 typeCombine(sc);
-e1->checkArithmetic();
+if (e1->op != TOKslice && e2->op != TOKslice)
-e2->checkArithmetic();
+{	e1->checkArithmetic();
+	e2->checkArithmetic();
+}
 if (type->isfloating())
 {	Type *t1 = e1->type;
 	Type *t2 = e2->type;
 	if (t1->isreal())
 e = op_overload(sc);
 if (e)
 	return e;
 typeCombine(sc);
-e1->checkArithmetic();
+if (e1->op != TOKslice && e2->op != TOKslice)
-e2->checkArithmetic();
+{	e1->checkArithmetic();
+	e2->checkArithmetic();
+}
 if (type->isfloating())
 {	Type *t1 = e1->type;
 	Type *t2 = e2->type;
 	if (t1->isreal())
 e = op_overload(sc);
 if (e)
 	return e;
 typeCombine(sc);
-e1->checkArithmetic();
+if (e1->op != TOKslice && e2->op != TOKslice)
-e2->checkArithmetic();
+{	e1->checkArithmetic();
+	e2->checkArithmetic();
+}
 if (type->isfloating())
 {	type = e1->type;
 	if (e2->type->iscomplex())
 	{   error("cannot perform modulo complex arithmetic");
 	    return new IntegerExp(0);
 	    e = this;
 	}
 	else
 	{
 	    typeCombine(sc);
-	    e1->checkIntegral();
+	    if (e1->op != TOKslice && e2->op != TOKslice)
-	    e2->checkIntegral();
+	    {   e1->checkIntegral();
+		e2->checkIntegral();
+	    }
 	}
 }
 return this;
 }
 	    e = this;
 	}
 	else
 	{
 	    typeCombine(sc);
-	    e1->checkIntegral();
+	    if (e1->op != TOKslice && e2->op != TOKslice)
-	    e2->checkIntegral();
+	    {   e1->checkIntegral();
+		e2->checkIntegral();
+	    }
 	}
 }
 return this;
 }
 	    e = this;
 	}
 	else
 	{
 	    typeCombine(sc);
-	    e1->checkIntegral();
+	    if (e1->op != TOKslice && e2->op != TOKslice)
-	    e2->checkIntegral();
+	    {   e1->checkIntegral();
+		e2->checkIntegral();
+	    }
 	}
 }
 return this;
 }
 	// Convert key to type of key
 	e1 = e1->implicitCastTo(sc, ta->index);
 	// Return type is pointer to value
-	type = ta->next->pointerTo();
+	type = ta->nextOf()->pointerTo();
 }
 return this;
 }
 int InExp::isBit()
 	e = new IntegerExp(0);
 }
 #endif
 else
 	e = this;
+//printf("CmpExp: %s\n", e->toChars());
 return e;
 }
 int CmpExp::isBit()
 {

Mercurial > projects > ldc

comparison dmd/expression.c @ 510:6aee82889553