projects/ddmd: dmd/FuncDeclaration.d comparison

comparison dmd/FuncDeclaration.d @ 137:09c858522d55

merge

author	Trass3r
date	Mon, 13 Sep 2010 23:29:00 +0200
parents	af1bebfd96a4
children	bc45b1c53019

comparison

equal deleted inserted replaced

-:9d194c848e3a
+:09c858522d55
 		if (!originalType)
 			originalType = type;
 		if (!type.deco)
 		{
+	    sc = sc.push();
+	        sc.stc |= storage_class & STC.STCref;	// forward refness to function type
+	        type = type.semantic(loc, sc);
+	        sc = sc.pop();
 			/* Apply const, immutable and shared storage class
 			 * to the function type
 			 */
-			type = type.semantic(loc, sc);
 			StorageClass stc = storage_class;
-			if (type.isInvariant())
+			if (type.isImmutable())
 				stc |= STC.STCimmutable;
 			if (type.isConst())
 				stc |= STC.STCconst;
 			if (type.isShared() || storage_class & STC.STCsynchronized)
 				stc |= STC.STCshared;
+	        if (type.isWild())
+	            stc |= STC.STCwild;
 			switch (stc & STC.STC_TYPECTOR)
 			{
 				case STC.STCimmutable:
 				case STC.STCimmutable | STC.STCconst:
 				case STC.STCimmutable | STC.STCconst | STC.STCshared:
 				case STC.STCimmutable | STC.STCshared:
+case STC.STCimmutable | STC.STCwild:
+	            case STC.STCimmutable | STC.STCconst | STC.STCwild:
+	            case STC.STCimmutable | STC.STCconst | STC.STCshared | STC.STCwild:
+	            case STC.STCimmutable | STC.STCshared | STC.STCwild:
 				// Don't use toInvariant(), as that will do a merge()
 				type = type.makeInvariant();
 				goto Lmerge;
 				case STC.STCconst:
+	            case STC.STCconst | STC.STCwild:
 				type = type.makeConst();
 				goto Lmerge;
 				case STC.STCshared | STC.STCconst:
+	            case STC.STCshared | STC.STCconst | STC.STCwild:
 				type = type.makeSharedConst();
 				goto Lmerge;
 				case STC.STCshared:
 				type = type.makeShared();
+		        goto Lmerge;
+	            case STC.STCwild:
+		        type = type.makeWild();
+		        goto Lmerge;
+	            case STC.STCshared | STC.STCwild:
+		        type = type.makeSharedWild();
+		        goto Lmerge;
 				Lmerge:
 					if (!(type.ty == Tfunction && !type.nextOf()))
 						/* Can't do merge if return type is not known yet
 					     */
 						type.deco = type.merge().deco;
 				default:
 				assert(0);
 			}
 		}
-		//type.print();
+storage_class &= ~STC.STCref;
 		if (type.ty != TY.Tfunction)
 		{
 		error("%s must be a function", toChars());
 		return;
 		}
 		error("functions cannot be scope");
 		if (isAbstract() && !isVirtual())
 		error("non-virtual functions cannot be abstract");
-		if ((f.isConst() || f.isInvariant()) && !isThis())
+		if ((f.isConst() || f.isImmutable()) && !isThis())
 		error("without 'this' cannot be const/immutable");
 		if (isAbstract() && isFinal())
 		error("cannot be both final and abstract");
 static if (false) {
 				else
 				{	assert(thandle.ty == TY.Tpointer);
 				thandle = thandle.nextOf().constOf().pointerTo();
 				}
 			}
-			else if (storage_class & STC.STCimmutable || type.isInvariant())
+			else if (storage_class & STC.STCimmutable || type.isImmutable())
 			{
 				if (thandle.ty == TY.Tclass)
 				thandle = thandle.invariantOf();
 				else
 				{	assert(thandle.ty == TY.Tpointer);
 				sc2.insert(argptr);
 				argptr.parent = this;
 			}
 }
 		}
+static if(false) {
 		// Propagate storage class from tuple parameters to their element-parameters.
 		if (f.parameters)
 		{
 			foreach (arg; f.parameters)
 			{
 				    narg.storageClass = arg.storageClass;
 				}
 			}
 			}
 		}
+}
 		/* Declare all the function parameters as variables
 		 * and install them in parameters[]
 		 */
 		size_t nparams = Parameter.dim(f.parameters);
 		if (nparams)
 		Type tb = type.toBasetype();
 		assert(tb.ty == Tfunction);
 		TypeFunction tf = cast(TypeFunction)tb;
 		Type tret = tf.next.toBasetype();
-		if (tf.varargs)
+		if (tf.varargs && arguments && parameters && arguments.dim != parameters.dim)
 		{
 			cantInterpret = 1;
-			error("Variadic functions are not yet implemented in CTFE");
+			error("C-style variadic functions are not yet implemented in CTFE");
 			return null;
 		}
 		// Ensure there are no lazy parameters
 		if (tf.parameters)
 				printf("interpreted arg[%d] = %s\n", i, earg.toChars());
 }
 			}
 		}
 		// Don't restore the value of 'this' upon function return
-		if (needThis() && thisarg.op==TOKvar) {
+		if (needThis() && thisarg.op == TOKvar && istate) {
 			VarDeclaration thisvar = (cast(VarExp)thisarg).var.isVarDeclaration();
 			foreach (size_t i, Dsymbol s; istate.vars)
 			{
 				auto v = cast(VarDeclaration)s;
 				if (v == thisvar)
 			}
 		}
 		/* Save the values of the local variables used
 		 */
-		scope Expressions valueSaves = new Expressions();
+		scope valueSaves = new Expressions();
 		if (istate && !isNested())
 		{
 			//printf("saving local variables...\n");
 			valueSaves.setDim(istate.vars.dim);
 			foreach (size_t i, Dsymbol s3; istate.vars)
 			block_appendexp(irs.blx.curblock, e);
 		}
 	}
+/*********************************************
+* Return the function's parameter list, and whether
+* it is variadic or not.
+*/
+Parameters getParameters(int *pvarargs)
+{
+Parameters fparameters;
+int fvarargs;
+if (type)
+{
+	        assert(type.ty == Tfunction);
+	        auto fdtype = cast(TypeFunction)type;
+	        fparameters = fdtype.parameters;
+	        fvarargs = fdtype.varargs;
+}
+else // Constructors don't have type's
+{
+CtorDeclaration fctor = isCtorDeclaration();
+	        assert(fctor);
+	        fparameters = fctor.arguments;
+	        fvarargs = fctor.varargs;
+}
+if (pvarargs)
+	    *pvarargs = fvarargs;
+return fparameters;
+}
 override FuncDeclaration isFuncDeclaration() { return this; }
 }
 alias Vector!FuncDeclaration FuncDeclarations;

Mercurial > projects > ddmd

comparison dmd/FuncDeclaration.d @ 137:09c858522d55