projects/ldc: dmd2/parse.c comparison

comparison dmd2/parse.c @ 1452:638d16625da2

LDC 2 compiles again.

author	Robert Clipsham <robert@octarineparrot.com>
date	Sat, 30 May 2009 17:23:32 +0100
parents	356e65836fb5
children	54b3c1394d62

comparison

equal deleted inserted replaced

-:42bd767ec5a4
+:638d16625da2
 // Compiler implementation of the D programming language
-// Copyright (c) 1999-2008 by Digital Mars
+// Copyright (c) 1999-2009 by Digital Mars
 // All Rights Reserved
 // written by Walter Bright
 // http://www.digitalmars.com
 // License for redistribution is by either the Artistic License
 // in artistic.txt, or the GNU General Public License in gnu.txt.
 // This is the D parser
 #include <stdio.h>
 #include <assert.h>
-#include "mem.h"
+#include "rmem.h"
 #include "lexer.h"
 #include "parse.h"
 #include "init.h"
 #include "attrib.h"
 #include "cond.h"
 #include "declaration.h"
 #include "aggregate.h"
 #include "enum.h"
 #include "id.h"
 #include "version.h"
+#include "aliasthis.h"
 // How multiple declarations are parsed.
 // If 1, treat as C.
 // If 0, treat:
 //	int *p, i;
 {
 	unsigned char *comment = token.blockComment;
 	bool safe = FALSE;
 	nextToken();
+#if DMDV2
 	if (token.value == TOKlparen)
 	{
 	    nextToken();
 	    if (token.value != TOKidentifier)
-	    {	error("module (safe) identifier expected");
+	    {	error("module (system) identifier expected");
 		goto Lerr;
 	    }
 	    Identifier *id = token.ident;
 	    if (id == Id::system)
 	    else
 		error("(safe) expected, not %s", id->toChars());
 	    nextToken();
 	    check(TOKrparen);
 	}
+#endif
 	if (token.value != TOKidentifier)
 	{   error("Identifier expected following module");
 	    goto Lerr;
 	}
 	    case TOKthis:
 		s = parseCtor();
 		break;
+#if 0 // dead end, use this(this){} instead
 	    case TOKassign:
 		s = parsePostBlit();
 		break;
+#endif
 	    case TOKtilde:
 		s = parseDtor();
 		break;
 	    case TOKinvariant:
 			// invariant(type)
 			goto Ldeclaration;
 		}
 		else
 		{
-		    stc = STCinvariant;
+		    stc = STCimmutable;
 		    goto Lstc;
 		}
 		break;
 	    }
 		goto Lstc;
 	    case TOKimmutable:
 		if (peek(&token)->value == TOKlparen)
 		    goto Ldeclaration;
-		stc = STCinvariant;
+		stc = STCimmutable;
+		goto Lstc;
+	    case TOKshared:
+		if (peek(&token)->value == TOKlparen)
+		    goto Ldeclaration;
+		stc = STCshared;
 		goto Lstc;
 	    case TOKfinal:	  stc = STCfinal;	 goto Lstc;
 	    case TOKauto:	  stc = STCauto;	 goto Lstc;
 	    case TOKscope:	  stc = STCscope;	 goto Lstc;
 	    case TOKoverride:	  stc = STCoverride;	 goto Lstc;
 	    case TOKabstract:	  stc = STCabstract;	 goto Lstc;
 	    case TOKsynchronized: stc = STCsynchronized; goto Lstc;
 	    case TOKdeprecated:   stc = STCdeprecated;	 goto Lstc;
+#if DMDV2
 	    case TOKnothrow:      stc = STCnothrow;	 goto Lstc;
 	    case TOKpure:         stc = STCpure;	 goto Lstc;
 	    case TOKref:          stc = STCref;          goto Lstc;
 	    case TOKtls:          stc = STCtls;		 goto Lstc;
+	    case TOKgshared:      stc = STCgshared;	 goto Lstc;
 	    //case TOKmanifest:	  stc = STCmanifest;	 goto Lstc;
+#endif
 	    Lstc:
 		if (storageClass & stc)
 		    error("redundant storage class %s", Token::toChars(token.value));
-		{
+		composeStorageClass(storageClass | stc);
-		unsigned u = storageClass | stc;
-		u &= STCconst | STCinvariant | STCmanifest;
-		if (u & (u - 1))
-		    error("conflicting storage class %s", Token::toChars(token.value));
-		}
 		nextToken();
 	    Lstc2:
 		storageClass |= stc;
 		switch (token.value)
 		{
 		    case TOKconst:
 		    case TOKinvariant:
 		    case TOKimmutable:
+		    case TOKshared:
 			// If followed by a (, it is not a storage class
 			if (peek(&token)->value == TOKlparen)
 			    break;
 			if (token.value == TOKconst)
 			    stc = STCconst;
+			else if (token.value == TOKshared)
+			    stc = STCshared;
 			else
-			    stc = STCinvariant;
+			    stc = STCimmutable;
 			goto Lstc;
 		    case TOKfinal:	  stc = STCfinal;	 goto Lstc;
 		    case TOKauto:	  stc = STCauto;	 goto Lstc;
 		    case TOKscope:	  stc = STCscope;	 goto Lstc;
 		    case TOKoverride:	  stc = STCoverride;	 goto Lstc;
 		    case TOKdeprecated:   stc = STCdeprecated;	 goto Lstc;
 		    case TOKnothrow:      stc = STCnothrow;	 goto Lstc;
 		    case TOKpure:         stc = STCpure;	 goto Lstc;
 		    case TOKref:          stc = STCref;          goto Lstc;
 		    case TOKtls:          stc = STCtls;		 goto Lstc;
+		    case TOKgshared:      stc = STCgshared;	 goto Lstc;
 		    //case TOKmanifest:	  stc = STCmanifest;	 goto Lstc;
 		    default:
 			break;
 		}
 		 */
 		Token *tk;
 		if (token.value == TOKidentifier &&
 		    (tk = peek(&token))->value == TOKlparen &&
 		    skipParens(tk, &tk) &&
-		    peek(tk)->value == TOKlparen)
+		    (peek(tk)->value == TOKlparen ||
+		     peek(tk)->value == TOKlcurly)
+		   )
 		{
 		    a = parseDeclarations(storageClass);
 		    decldefs->append(a);
 		    continue;
 		}
 	}
 } while (!once);
 return decldefs;
 }
+/*********************************************
+* Give error on conflicting storage classes.
+*/
+void Parser::composeStorageClass(unsigned stc)
+{
+unsigned u = stc;
+u &= STCconst | STCimmutable | STCmanifest;
+if (u & (u - 1))
+	error("conflicting storage class %s", Token::toChars(token.value));
+u = stc;
+u &= STCgshared | STCshared | STCtls;
+if (u & (u - 1))
+	error("conflicting storage class %s", Token::toChars(token.value));
+}
 /********************************************
 * Parse declarations after an align, protection, or extern decl.
 */
 switch (token.value)
 {
 	case TOKsemicolon:
 	    error("declaration expected following attribute, not ';'");
 	    nextToken();
+	    break;
+	case TOKeof:
+	    error("declaration expected following attribute, not EOF");
 	    break;
 	case TOKlcurly:
 	    nextToken();
 	    a = parseDeclDefs(0);
 }
 /*****************************************
 * Parse a constructor definition:
-*	this(arguments) { body }
+*	this(parameters) { body }
 * or postblit:
 *	this(this) { body }
+* or constructor template:
+*	this(templateparameters)(parameters) { body }
 * Current token is 'this'.
 */
-FuncDeclaration *Parser::parseCtor()
+Dsymbol *Parser::parseCtor()
 {
 Loc loc = this->loc;
 nextToken();
 if (token.value == TOKlparen && peek(&token)->value == TOKthis)
 	check(TOKrparen);
 	PostBlitDeclaration *f = new PostBlitDeclaration(loc, 0);
 	parseContracts(f);
 	return f;
 }
+/* Look ahead to see if:
+*   this(...)(...)
+* which is a constructor template
+*/
+TemplateParameters *tpl = NULL;
+if (token.value == TOKlparen && peekPastParen(&token)->value == TOKlparen)
+{	tpl = parseTemplateParameterList();
+	int varargs;
+	Arguments *arguments = parseParameters(&varargs);
+	Expression *constraint = NULL;
+	if (tpl)
+	    constraint = parseConstraint();
+	CtorDeclaration *f = new CtorDeclaration(loc, 0, arguments, varargs);
+	parseContracts(f);
+	// Wrap a template around it
+	Array *decldefs = new Array();
+	decldefs->push(f);
+	TemplateDeclaration *tempdecl =
+	    new TemplateDeclaration(loc, f->ident, tpl, constraint, decldefs);
+	return tempdecl;
+}
+/* Just a regular constructor
+*/
 int varargs;
 Arguments *arguments = parseParameters(&varargs);
 CtorDeclaration *f = new CtorDeclaration(loc, 0, arguments, varargs);
 parseContracts(f);
 return f;
 		case TOKinvariant:
 		case TOKimmutable:
 		    if (peek(&token)->value == TOKlparen)
 			goto Ldefault;
-		    stc = STCinvariant;
+		    stc = STCimmutable;
+		    goto L2;
+		case TOKshared:
+		    if (peek(&token)->value == TOKlparen)
+			goto Ldefault;
+		    stc = STCshared;
 		    goto L2;
 		case TOKin:	   stc = STCin;		goto L2;
 		case TOKout:	   stc = STCout;	goto L2;
 		case TOKinout:
 			(storageClass & STCin && stc & (STCconst | STCscope)) ||
 			(stc & STCin && storageClass & (STCconst | STCscope))
 		       )
 			error("redundant storage class %s", Token::toChars(token.value));
 		    storageClass |= stc;
-		    {
+		    composeStorageClass(storageClass);
-		    unsigned u = storageClass & (STCconst | STCinvariant);
-		    if (u & (u - 1))
-			error("conflicting storage class %s", Token::toChars(token.value));
-		    }
 		    continue;
 #if 0
 		case TOKstatic:	   stc = STCstatic;		goto L2;
 		case TOKauto:   storageClass = STCauto;		goto L4;
 		    stc = storageClass & (STCin | STCout | STCref | STClazy);
 		    if (stc & (stc - 1))	// if stc is not a power of 2
 			error("incompatible parameter storage classes");
 		    if ((storageClass & (STCconst | STCout)) == (STCconst | STCout))
 			error("out cannot be const");
-		    if ((storageClass & (STCinvariant | STCout)) == (STCinvariant | STCout))
+		    if ((storageClass & (STCimmutable | STCout)) == (STCimmutable | STCout))
-			error("out cannot be invariant");
+			error("out cannot be immutable");
 		    if ((storageClass & STCscope) &&
 			(storageClass & (STCref | STCout)))
 			error("scope cannot be ref or out");
 		    at = parseType(&ai);
 		    ae = NULL;
 return parseTemplateArgumentList2();
 }
 Objects *Parser::parseTemplateArgumentList2()
 {
+//printf("Parser::parseTemplateArgumentList2()\n");
 Objects *tiargs = new Objects();
 enum TOK endtok = TOKrparen;
 nextToken();
 // Get TemplateArgumentList
 		tiargs->push(ta);
 	    }
 	    else
 	    {	// Template argument is an expression
 		Expression *ea = parseAssignExp();
+		if (ea->op == TOKfunction)
+		{   FuncLiteralDeclaration *fd = ((FuncExp *)ea)->fd;
+		    if (fd->type->ty == Tfunction)
+		    {
+			TypeFunction *tf = (TypeFunction *)fd->type;
+			/* If there are parameters that consist of only an identifier,
+			 * rather than assuming the identifier is a type, as we would
+			 * for regular function declarations, assume the identifier
+			 * is the parameter name, and we're building a template with
+			 * a deduced type.
+			 */
+			TemplateParameters *tpl = NULL;
+			for (int i = 0; i < tf->parameters->dim; i++)
+			{   Argument *param = (Argument *)tf->parameters->data[i];
+			    if (param->ident == NULL &&
+				param->type &&
+				param->type->ty == Tident &&
+				((TypeIdentifier *)param->type)->idents.dim == 0
+			       )
+			    {
+				/* Switch parameter type to parameter identifier,
+				 * parameterize with template type parameter _T
+				 */
+				TypeIdentifier *pt = (TypeIdentifier *)param->type;
+				param->ident = pt->ident;
+				Identifier *id = Lexer::uniqueId("__T");
+				param->type = new TypeIdentifier(pt->loc, id);
+				TemplateParameter *tp = new TemplateTypeParameter(fd->loc, id, NULL, NULL);
+				if (!tpl)
+				    tpl = new TemplateParameters();
+				tpl->push(tp);
+			    }
+			}
+			if (tpl)
+			{   // Wrap a template around function fd
+			    Array *decldefs = new Array();
+			    decldefs->push(fd);
+			    TemplateDeclaration *tempdecl =
+				new TemplateDeclaration(fd->loc, fd->ident, tpl, NULL, decldefs);
+			    tempdecl->literal = 1;	// it's a template 'literal'
+			    tiargs->push(tempdecl);
+			    goto L1;
+			}
+		    }
+		}
 		tiargs->push(ea);
 	    }
+	 L1:
 	    if (token.value != TOKcomma)
 		break;
 	    nextToken();
 	}
 }
 	    if (!a)
 		a = new Array();
 	    a->push(id);
 	    nextToken();
 	    if (token.value != TOKidentifier)
-	    {   error("Identifier expected following package");
+	    {   error("identifier expected following package");
 		break;
 	    }
 	    id = token.ident;
 	    nextToken();
 	}
-	s = new Import(loc, a, token.ident, aliasid, isstatic);
+	s = new Import(loc, a, id, aliasid, isstatic);
 	decldefs->push(s);
 	/* Look for
 	 *	: alias=name, alias=name;
 	 * syntax.
 	 */
 	if (token.value == TOKcolon)
 	{
 	    do
 	    {	Identifier *name;
-		Identifier *alias;
 		nextToken();
 		if (token.value != TOKidentifier)
 		{   error("Identifier expected following :");
 		    break;
 		}
-		alias = token.ident;
+		Identifier *alias = token.ident;
 		nextToken();
 		if (token.value == TOKassign)
 		{
 		    nextToken();
 		    if (token.value != TOKidentifier)
 }
 return NULL;
 }
+#if DMDV2
 Type *Parser::parseType(Identifier **pident, TemplateParameters **tpl)
 {   Type *t;
-if (token.value == TOKconst && peek(&token)->value != TOKlparen)
+/* Take care of the storage class prefixes that
+* serve as type attributes:
+*  const shared, shared const, const, invariant, shared
+*/
+if (token.value == TOKconst && peekNext() == TOKshared && peekNext2() != TOKlparen ||
+	token.value == TOKshared && peekNext() == TOKconst && peekNext2() != TOKlparen)
+{
+	nextToken();
+	nextToken();
+	/* shared const type
+	 */
+	t = parseType(pident, tpl);
+	t = t->makeSharedConst();
+	return t;
+}
+else if (token.value == TOKconst && peekNext() != TOKlparen)
 {
 	nextToken();
 	/* const type
 	 */
 	t = parseType(pident, tpl);
 	t = t->makeConst();
 	return t;
 }
 else if ((token.value == TOKinvariant || token.value == TOKimmutable) &&
-peek(&token)->value != TOKlparen)
+peekNext() != TOKlparen)
 {
 	nextToken();
 	/* invariant type
 	 */
 	t = parseType(pident, tpl);
 	t = t->makeInvariant();
 	return t;
 }
+else if (token.value == TOKshared && peekNext() != TOKlparen)
+{
+	nextToken();
+	/* shared type
+	 */
+	t = parseType(pident, tpl);
+	t = t->makeShared();
+	return t;
+}
 else
 	t = parseBasicType();
 t = parseDeclarator(t, pident, tpl);
 return t;
 }
+#endif
 Type *Parser::parseBasicType()
 {   Type *t;
 Identifier *id;
 TypeQualified *tid;
 	    // const(type)
 	    nextToken();
 	    check(TOKlparen);
 	    t = parseType();
 	    check(TOKrparen);
-	    t = t->makeConst();
+	    if (t->isShared())
+		t = t->makeSharedConst();
+	    else
+		t = t->makeConst();
 	    break;
 	case TOKinvariant:
 	case TOKimmutable:
 	    // invariant(type)
 	    nextToken();
 	    check(TOKlparen);
 	    t = parseType();
 	    check(TOKrparen);
 	    t = t->makeInvariant();
+	    break;
+	case TOKshared:
+	    // shared(type)
+	    nextToken();
+	    check(TOKlparen);
+	    t = parseType();
+	    check(TOKrparen);
+	    if (t->isConst())
+		t = t->makeSharedConst();
+	    else
+		t = t->makeShared();
 	    break;
 	default:
 	    error("basic type expected, not %s", token.toChars());
 	    t = Type::tint32;
 		while (1)
 		{
 		    switch (token.value)
 		    {
 			case TOKconst:
-			    tf = tf->makeConst();
+			    if (tf->isShared())
+				tf = tf->makeSharedConst();
+			    else
+				tf = tf->makeConst();
 			    nextToken();
 			    continue;
 			case TOKinvariant:
 			case TOKimmutable:
 			    tf = tf->makeInvariant();
+			    nextToken();
+			    continue;
+			case TOKshared:
+			    if (tf->isConst())
+				tf = tf->makeSharedConst();
+			    else
+				tf = tf->makeShared();
 			    nextToken();
 			    continue;
 			case TOKnothrow:
 			    ((TypeFunction *)tf)->isnothrow = 1;
 	goto L2;
 }
 switch (token.value)
 {
+	case TOKalias:
+	    /* Look for:
+	     *   alias identifier this;
+	     */
+	    tok = token.value;
+	    nextToken();
+	    if (token.value == TOKidentifier && peek(&token)->value == TOKthis)
+	    {
+		AliasThis *s = new AliasThis(this->loc, token.ident);
+		nextToken();
+		check(TOKthis);
+		check(TOKsemicolon);
+		a = new Array();
+		a->push(s);
+		addComment(s, comment);
+		return a;
+	    }
+	    break;
 	case TOKtypedef:
-	case TOKalias:
 	    tok = token.value;
 	    nextToken();
 	    break;
 }
 	    case TOKinvariant:
 	    case TOKimmutable:
 		if (peek(&token)->value == TOKlparen)
 		    break;
-		stc = STCinvariant;
+		stc = STCimmutable;
 		goto L1;
 	    case TOKshared:
 		if (peek(&token)->value == TOKlparen)
 		    break;
 	    case TOKscope:	stc = STCscope;		 goto L1;
 	    case TOKoverride:	stc = STCoverride;	 goto L1;
 	    case TOKabstract:	stc = STCabstract;	 goto L1;
 	    case TOKsynchronized: stc = STCsynchronized; goto L1;
 	    case TOKdeprecated: stc = STCdeprecated;	 goto L1;
+#if DMDV2
 	    case TOKnothrow:    stc = STCnothrow;	 goto L1;
 	    case TOKpure:       stc = STCpure;		 goto L1;
 	    case TOKref:        stc = STCref;            goto L1;
 	    case TOKtls:        stc = STCtls;		 goto L1;
+	    case TOKgshared:    stc = STCgshared;	 goto L1;
 	    case TOKenum:	stc = STCmanifest;	 goto L1;
+#endif
 	    L1:
 		if (storage_class & stc)
 		    error("redundant storage class '%s'", token.toChars());
 		storage_class = (STC) (storage_class | stc);
-		{
+		composeStorageClass(storage_class);
-		unsigned u = storage_class;
-		u &= STCconst | STCinvariant | STCmanifest;
-		if (u & (u - 1))
-		    error("conflicting storage class %s", Token::toChars(token.value));
-		}
 		nextToken();
 		continue;
 	    case TOKextern:
 		if (peek(&token)->value != TOKlparen)
 	case TOKconst:
 	case TOKauto:
 	case TOKextern:
 	case TOKfinal:
 	case TOKinvariant:
+#if DMDV2
 	case TOKimmutable:
+	case TOKshared:
+	case TOKnothrow:
+	case TOKpure:
+	case TOKtls:
+	case TOKgshared:
+#endif
 //	case TOKtypeof:
 	Ldeclaration:
 	{   Array *a;
 	    a = parseDeclarations(STCundefined);
 		{
 		    Dsymbol *d = (Dsymbol *)a->data[i];
 		    s = new DeclarationStatement(loc, d);
 		    as->push(s);
 		}
-		s = new CompoundStatement(loc, as);
+		s = new CompoundDeclarationStatement(loc, as);
 	    }
 	    else if (a->dim == 1)
 	    {
 		Dsymbol *d = (Dsymbol *)a->data[0];
 		s = new DeclarationStatement(loc, d);
 {
 //printf("isDeclaration(needId = %d)\n", needId);
 int haveId = 0;
 #if DMDV2
-if ((t->value == TOKconst || t->value == TOKinvariant || token.value == TOKimmutable) &&
+if ((t->value == TOKconst ||
+	 t->value == TOKinvariant ||
+	 t->value == TOKimmutable ||
+	 t->value == TOKshared) &&
 	peek(t)->value != TOKlparen)
 {	/* const type
-	 * invariant type
+	 * immutable type
+	 * shared type
 	 */
 	t = peek(t);
 }
 #endif
 if (!isBasicType(&t))
+{
 	goto Lisnot;
+}
 if (!isDeclarator(&t, &haveId, endtok))
 	goto Lisnot;
 if ( needId == 1 ||
 	(needId == 0 && !haveId) ||
 	(needId == 2 &&  haveId))
 	    goto L2;
 	case TOKconst:
 	case TOKinvariant:
 	case TOKimmutable:
-	    // const(type)  or  invariant(type)
+	case TOKshared:
+	    // const(type)  or  immutable(type)  or  shared(type)
 	    t = peek(t);
 	    if (t->value != TOKlparen)
 		goto Lfalse;
 	    t = peek(t);
 	    if (!isDeclaration(t, 0, TOKrparen, &t))
+	    {
 		goto Lfalse;
+	    }
 	    t = peek(t);
 	    break;
 	default:
 	    goto Lfalse;
 {
 	parens = FALSE;
 	switch (t->value)
 	{
 	    case TOKmul:
-//	    case TOKand:
+	    //case TOKand:
 		t = peek(t);
 		continue;
 	    case TOKlbracket:
 		t = peek(t);
 	    case TOKlparen:
 		parens = FALSE;
 		if (!isParameters(&t))
 		    return FALSE;
+#if DMDV2
 		while (1)
 		{
 		    switch (t->value)
 		    {
 			case TOKconst:
 			case TOKinvariant:
 			case TOKimmutable:
+			case TOKshared:
 			case TOKpure:
 			case TOKnothrow:
 			    t = peek(t);
 			    continue;
 			default:
 			    break;
 		    }
 		    break;
 		}
+#endif
 		continue;
 	    // Valid tokens that follow a declaration
 	    case TOKrparen:
 	    case TOKrbracket:
 	    case TOKref:
 	    case TOKlazy:
 	    case TOKconst:
 	    case TOKinvariant:
 	    case TOKimmutable:
+	    case TOKshared:
 	    case TOKfinal:
 		continue;
 #if 0
 	    case TOKstatic:
 	    e = new SuperExp(loc);
 	    nextToken();
 	    break;
 	case TOKint32v:
-	    e = new IntegerExp(loc, token.int32value, Type::tint32);
+	    e = new IntegerExp(loc, (d_int32)token.int64value, Type::tint32);
 	    nextToken();
 	    break;
 	case TOKuns32v:
-	    e = new IntegerExp(loc, token.uns32value, Type::tuns32);
+	    e = new IntegerExp(loc, (d_uns32)token.uns64value, Type::tuns32);
 	    nextToken();
 	    break;
 	case TOKint64v:
 	    e = new IntegerExp(loc, token.int64value, Type::tint64);
 	    nextToken();
 	    break;
 #if DMDV2
 	case TOKfile:
-	{   char *s = loc.filename ? loc.filename : mod->ident->toChars();
+	{   const char *s = loc.filename ? loc.filename : mod->ident->toChars();
-	    e = new StringExp(loc, s, strlen(s), 0);
+	    e = new StringExp(loc, (char *)s, strlen(s), 0);
 	    nextToken();
 	    break;
 	}
 	case TOKline:
 	    e = new IntegerExp(loc, 0, Type::tbool);
 	    nextToken();
 	    break;
 	case TOKcharv:
-	    e = new IntegerExp(loc, token.uns32value, Type::tchar);
+	    e = new IntegerExp(loc, (d_uns8)token.uns64value, Type::tchar);
 	    nextToken();
 	    break;
 	case TOKwcharv:
-	    e = new IntegerExp(loc, token.uns32value, Type::twchar);
+	    e = new IntegerExp(loc, (d_uns16)token.uns64value, Type::twchar);
 	    nextToken();
 	    break;
 	case TOKdcharv:
-	    e = new IntegerExp(loc, token.uns32value, Type::tdchar);
+	    e = new IntegerExp(loc, (d_uns32)token.uns64value, Type::tdchar);
 	    nextToken();
 	    break;
 	case TOKstring:
 	{   unsigned char *s;
 	    check(TOKdot, t->toChars());
 	    if (token.value != TOKidentifier)
 	    {   error("found '%s' when expecting identifier following '%s.'", token.toChars(), t->toChars());
 		goto Lerr;
 	    }
-	    e = new TypeDotIdExp(loc, t, token.ident);
+	    e = typeDotIdExp(loc, t, token.ident);
 	    nextToken();
 	    break;
 	case TOKtypeof:
 	{
 			 token.value == TOKunion ||
 			 token.value == TOKclass ||
 			 token.value == TOKsuper ||
 			 token.value == TOKenum ||
 			 token.value == TOKinterface ||
+#if DMDV2
 			 token.value == TOKconst && peek(&token)->value == TOKrparen ||
 			 token.value == TOKinvariant && peek(&token)->value == TOKrparen ||
 			 token.value == TOKimmutable && peek(&token)->value == TOKrparen ||
+			 token.value == TOKshared && peek(&token)->value == TOKrparen ||
+#endif
 			 token.value == TOKfunction ||
 			 token.value == TOKdelegate ||
 			 token.value == TOKreturn))
 		    {
 			tok2 = token.value;
 		    else
 			break;
 		    nextToken();
 		}
 	    }
 	    TypeFunction *tf = new TypeFunction(arguments, t, varargs, linkage);
 	    tf->ispure = ispure;
 	    tf->isnothrow = isnothrow;
 	    fd = new FuncLiteralDeclaration(loc, 0, tf, save, NULL);
 	    parseContracts(fd);
 	case TOKnew:
 	    e = parseNewExp(NULL);
 	    break;
 	case TOKcast:				// cast(type) expression
-	{   Type *t;
+	{
 	    nextToken();
 	    check(TOKlparen);
-	    /* Look for cast(const) and cast(invariant)
+	    /* Look for cast(), cast(const), cast(immutable),
+	     * cast(shared), cast(shared const)
 	     */
-	    if ((token.value == TOKconst || token.value == TOKinvariant || token.value == TOKimmutable) &&
+	    unsigned m;
-		peek(&token)->value == TOKrparen)
+	    if (token.value == TOKrparen)
-	    {	enum TOK tok = token.value;
+	    {
-		nextToken();
+		m = 0;
+		goto Lmod1;
+	    }
+	    else if (token.value == TOKconst && peekNext() == TOKrparen)
+	    {
+		m = MODconst;
+		goto Lmod2;
+	    }
+	    else if ((token.value == TOKimmutable || token.value == TOKinvariant) && peekNext() == TOKrparen)
+	    {
+		m = MODinvariant;
+		goto Lmod2;
+	    }
+	    else if (token.value == TOKshared && peekNext() == TOKrparen)
+	    {
+		m = MODshared;
+		goto Lmod2;
+	    }
+	    else if (token.value == TOKconst && peekNext() == TOKshared && peekNext2() == TOKrparen ||
+		     token.value == TOKshared && peekNext() == TOKconst && peekNext2() == TOKrparen)
+	    {
+		m = MODshared | MODconst;
+		nextToken();
+	      Lmod2:
+		nextToken();
+	      Lmod1:
 		nextToken();
 		e = parseUnaryExp();
-		e = new CastExp(loc, e, tok);
+		e = new CastExp(loc, e, m);
 	    }
 	    else
 	    {
-		t = parseType();		// ( type )
+		Type *t = parseType();		// ( type )
 		check(TOKrparen);
 		e = parseUnaryExp();
 		e = new CastExp(loc, e, t);
 	    }
 	    break;
 			    nextToken();
 			    if (token.value != TOKidentifier)
 			    {   error("Identifier expected following (type).");
 				return NULL;
 			    }
-			    e = new TypeDotIdExp(loc, t, token.ident);
+			    e = typeDotIdExp(loc, t, token.ident);
 			    nextToken();
 			    e = parsePostExp(e);
 			}
 			else
 			{

Mercurial > projects > ldc

comparison dmd2/parse.c @ 1452:638d16625da2