projects/ldc: dmd2/declaration.c comparison

comparison dmd2/declaration.c @ 1526:54b3c1394d62

Merged dmdfe 2.031.

author	Robert Clipsham <robert@octarineparrot.com>
date	Tue, 07 Jul 2009 02:26:11 +0100
parents	f62347c22d81
children	e4f7b5d9c68a

comparison

equal deleted inserted replaced

-:d28cd7c45267
+:54b3c1394d62
 */
 s = type->toDsymbol(sc);
 if (s && ((s->getType() && type->equals(s->getType())) || s->isEnumMember()))
 	goto L2;			// it's a symbolic alias
+#if DMDV2
 if (storage_class & STCref)
 {	// For 'ref' to be attached to function types, and picked
 	// up by Type::resolve(), it has to go into sc.
 	sc = sc->push();
 	sc->stc |= STCref;
 	type->resolve(loc, sc, &e, &t, &s);
 	sc = sc->pop();
 }
 else
+#endif
 	type->resolve(loc, sc, &e, &t, &s);
 if (s)
 {
 	goto L2;
 }
 	error("cannot alias an expression %s", e->toChars());
 	t = e->type;
 }
 else if (t)
+{
 	type = t;
+}
 if (overnext)
 	ScopeDsymbol::multiplyDefined(0, this, overnext);
 this->inSemantic = 0;
 return;
 	if (f)
 	{
 	    if (overnext)
 	    {
 		FuncAliasDeclaration *fa = new FuncAliasDeclaration(f);
+#if IN_LLVM
 		fa->importprot = importprot;
+#endif
 		if (!fa->overloadInsert(overnext))
 		    ScopeDsymbol::multiplyDefined(0, f, overnext);
 		overnext = NULL;
 		s = fa;
 		s->parent = sc->parent;
 	{
 	    assert(global.errors);
 	    s = NULL;
 	}
 }
+//printf("setting aliassym %p to %p\n", this, s);
 aliassym = s;
 this->inSemantic = 0;
 }
 int AliasDeclaration::overloadInsert(Dsymbol *s)
 this->hinit = NULL;
 #endif
 this->loc = loc;
 offset = 0;
 noauto = 0;
+#if DMDV1
+nestedref = 0;
+#endif
 ctorinit = 0;
 aliassym = NULL;
 onstack = 0;
 canassign = 0;
 value = NULL;
-scope = NULL;
 #if IN_LLVM
 aggrIndex = 0;
 // LDC
 anonDecl = NULL;
 //printf("this = %p, parent = %p, '%s'\n", this, parent, parent->toChars());
 protection = sc->protection;
 //printf("sc->stc = %x\n", sc->stc);
 //printf("storage_class = x%x\n", storage_class);
+#if DMDV2
 if (storage_class & STCgshared && global.params.safe && !sc->module->safe)
 {
 	error("__gshared not allowed in safe mode; use shared");
 }
+#endif
 Dsymbol *parent = toParent();
 FuncDeclaration *fd = parent->isFuncDeclaration();
 Type *tb = type->toBasetype();
 {
 	AggregateDeclaration *aad = sc->anonAgg;
 	if (!aad)
 	    aad = parent->isAggregateDeclaration();
 	if (aad)
-	{   assert(!(storage_class & (STCextern | STCstatic | STCtls | STCgshared)));
+	{
+#if DMDV2
+	    assert(!(storage_class & (STCextern | STCstatic | STCtls | STCgshared)));
 	    if (storage_class & (STCconst | STCimmutable) && init)
 	    {
 		if (!type->toBasetype()->isTypeBasic())
 		    storage_class |= STCstatic;
 	    }
 	    else
+#endif
 		aad->addField(sc, this);
 	}
 	InterfaceDeclaration *id = parent->isInterfaceDeclaration();
 	if (id)
 		error("cannot use template to add field to aggregate '%s'", ad->toChars());
 	    }
 	}
 }
+#if DMDV2
 if ((storage_class & (STCref | STCparameter | STCforeach)) == STCref &&
 	ident != Id::This)
 {
 	error("only parameters or foreach declarations can be ref");
 }
+#endif
 if (type->isauto() && !noauto)
 {
 	if (storage_class & (STCfield | STCout | STCref | STCstatic | STCmanifest | STCtls | STCgshared) || !fd)
 	{
 	     */
 	    Expression *e = new IntegerExp(loc, 0, Type::tint32);
 	    Expression *e1;
 	    e1 = new VarExp(loc, this);
 	    e = new AssignExp(loc, e1, e);
+#if DMDV2
 	    e->op = TOKconstruct;
+#endif
 	    e->type = e1->type;		// don't type check this, it would fail
 	    init = new ExpInitializer(loc, e);
 	    return;
 	}
 	else if (type->ty == Ttypedef)
 	}
 	else
 	{
 	    init = getExpInitializer();
 	}
+#if DMDV2
 	// Default initializer is always a blit
 	op = TOKblit;
+#endif
 }
 if (init)
 {
 	sc = sc->push();
 		    e1 = new SliceExp(loc, e1, NULL, NULL);
 		}
 		else if (t->ty == Tstruct)
 		{
 		    ei->exp = ei->exp->semantic(sc);
+#if DMDV2
 		    /* Look to see if initializer is a call to the constructor
 		     */
 		    StructDeclaration *sd = ((TypeStruct *)t)->sym;
 		    if (sd->ctor &&		// there are constructors
 			ei->exp->type->ty == Tstruct &&	// rvalue is the same struct
 				    return;
 				}
 			    }
 			}
 		    }
+#endif
 		    if (!ei->exp->implicitConvTo(type))
 		    {	Type *ti = ei->exp->type->toBasetype();
 			// Don't cast away invariant or mutability in initializer
 			if (!(ti->ty == Tstruct && t->toDsymbol(sc) == ti->toDsymbol(sc)))
 			    ei->exp = new CastExp(loc, ei->exp, type);
 		//printf("-gag\n");
 		if (errors != global.errors)	// if errors happened
 		{
 		    if (global.gag == 0)
 			global.errors = errors;	// act as if nothing happened
+#if DMDV2
 		    /* Save scope for later use, to try again
 		     */
 		    scope = new Scope(*sc);
 		    scope->setNoFree();
+#endif
 		}
 		else if (ei)
 		{
 		    if (isDataseg())
 			/* static const/invariant does CTFE
 			e = e->optimize(WANTvalue);
 		    if (e->op == TOKint64 || e->op == TOKstring)
 		    {
 			ei->exp = e;		// no errors, keep result
 		    }
+#if DMDV2
 		    else
 		    {
 			/* Save scope for later use, to try again
 			 */
 			scope = new Scope(*sc);
 			scope->setNoFree();
 		    }
+#endif
 		}
 		else
 		    init = i2;		// no errors, keep result
 	    }
 	}
 	type->toCBuffer(buf, ident, hgs);
 else
 	buf->writestring(ident->toChars());
 if (init)
 {	buf->writestring(" = ");
+#if DMDV2
 	ExpInitializer *ie = init->isExpInitializer();
 	if (ie && (ie->exp->op == TOKconstruct || ie->exp->op == TOKblit))
 	    ((AssignExp *)ie->exp)->e2->toCBuffer(buf, hgs);
 	else
+#endif
 	    init->toCBuffer(buf, hgs);
 }
 buf->writeByte(';');
 buf->writenl();
 }
 }
 void TypeInfoDeclaration::semantic(Scope *sc)
 {
 assert(linkage == LINKc);
-// LDC
+#if IN_LLVM
 if (!global.params.useAvailableExternally)
 availableExternally = false;
+#endif
 }
 /***************************** TypeInfoConstDeclaration **********************/
 #if DMDV2

Mercurial > projects > ldc

comparison dmd2/declaration.c @ 1526:54b3c1394d62