# HG changeset patch # User Leandro Lucarella # Date 1262801899 10800 # Node ID 1b24e9c7cc261b7ec0c72b4b69b6566e12f1d7f8 # Parent 1d5721f9ae183a5b8abf9c14fce9f78ac6de81a4 Use just \n as end of line --- dmd/arraytypes.h | 102 ++++---- dmd/enum.c | 652 ++++++++++++++++++++++++++-------------------------- dmd/parse.h | 292 ++++++++++++------------ dmd/staticassert.c | 240 ++++++++++---------- 4 files changed, 643 insertions(+), 643 deletions(-) diff -r 1d5721f9ae18 -r 1b24e9c7cc26 dmd/arraytypes.h --- a/dmd/arraytypes.h Wed Jan 06 15:18:19 2010 -0300 +++ b/dmd/arraytypes.h Wed Jan 06 15:18:19 2010 -0300 @@ -1,51 +1,51 @@ - -// Compiler implementation of the D programming language -// Copyright (c) 2006-2007 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. -// See the included readme.txt for details. - -#ifndef DMD_ARRAYTYPES_H -#define DMD_ARRAYTYPES_H - -#ifdef __DMC__ -#pragma once -#endif /* __DMC__ */ - - -#include "root.h" - -struct Expression; -struct Statement; -struct BaseClass; -struct TemplateParameter; -struct FuncDeclaration; -struct Identifier; -struct Initializer; - -struct TemplateParameters : Array { }; - -struct Expressions : Array { }; - -struct Statements : Array { }; - -struct BaseClasses : Array { }; - -struct ClassDeclarations : Array { }; - -struct Dsymbols : Array { }; - -struct Objects : Array { }; - -struct FuncDeclarations : Array { }; - -struct Arguments : Array { }; - -struct Identifiers : Array { }; - -struct Initializers : Array { }; - -#endif + +// Compiler implementation of the D programming language +// Copyright (c) 2006-2007 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. +// See the included readme.txt for details. + +#ifndef DMD_ARRAYTYPES_H +#define DMD_ARRAYTYPES_H + +#ifdef __DMC__ +#pragma once +#endif /* __DMC__ */ + + +#include "root.h" + +struct Expression; +struct Statement; +struct BaseClass; +struct TemplateParameter; +struct FuncDeclaration; +struct Identifier; +struct Initializer; + +struct TemplateParameters : Array { }; + +struct Expressions : Array { }; + +struct Statements : Array { }; + +struct BaseClasses : Array { }; + +struct ClassDeclarations : Array { }; + +struct Dsymbols : Array { }; + +struct Objects : Array { }; + +struct FuncDeclarations : Array { }; + +struct Arguments : Array { }; + +struct Identifiers : Array { }; + +struct Initializers : Array { }; + +#endif diff -r 1d5721f9ae18 -r 1b24e9c7cc26 dmd/enum.c --- a/dmd/enum.c Wed Jan 06 15:18:19 2010 -0300 +++ b/dmd/enum.c Wed Jan 06 15:18:19 2010 -0300 @@ -1,326 +1,326 @@ - -// 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. -// See the included readme.txt for details. - -#include -#include - -#include "root.h" -#include "enum.h" -#include "mtype.h" -#include "scope.h" -#include "declaration.h" - -/********************************* EnumDeclaration ****************************/ - -EnumDeclaration::EnumDeclaration(Loc loc, Identifier *id, Type *memtype) - : ScopeDsymbol(id) -{ - this->loc = loc; - type = new TypeEnum(this); - this->memtype = memtype; - maxval = 0; - minval = 0; - defaultval = 0; -#if IN_DMD - sinit = NULL; -#endif - isdeprecated = 0; -} - -Dsymbol *EnumDeclaration::syntaxCopy(Dsymbol *s) -{ - Type *t = NULL; - if (memtype) - t = memtype->syntaxCopy(); - - EnumDeclaration *ed; - if (s) - { ed = (EnumDeclaration *)s; - ed->memtype = t; - } - else - ed = new EnumDeclaration(loc, ident, t); - ScopeDsymbol::syntaxCopy(ed); - return ed; -} - -void EnumDeclaration::semantic(Scope *sc) -{ int i; - uinteger_t number; - Type *t; - Scope *sce; - - //printf("EnumDeclaration::semantic(sd = %p, '%s')\n", sc->scopesym, sc->scopesym->toChars()); - if (symtab) // if already done - return; - if (!memtype) - memtype = Type::tint32; - if (sc->stc & STCdeprecated) - isdeprecated = 1; - - parent = sc->scopesym; - memtype = memtype->semantic(loc, sc); - - /* Check to see if memtype is forward referenced - */ - if (memtype->ty == Tenum) - { EnumDeclaration *sym = (EnumDeclaration *)memtype->toDsymbol(sc); - if (!sym->memtype) - { - error("base enum %s is forward referenced", sym->toChars()); - memtype = Type::tint32; - } - } - - if (!memtype->isintegral()) - { error("base type must be of integral type, not %s", memtype->toChars()); - memtype = Type::tint32; - } - - t = isAnonymous() ? memtype : type; - symtab = new DsymbolTable(); - sce = sc->push(this); - sce->parent = this; - number = 0; - if (!members) // enum ident; - return; - if (members->dim == 0) - error("enum %s must have at least one member", toChars()); - int first = 1; - for (i = 0; i < members->dim; i++) - { - EnumMember *em = ((Dsymbol *)members->data[i])->isEnumMember(); - Expression *e; - - if (!em) - /* The e->semantic(sce) can insert other symbols, such as - * template instances and function literals. - */ - continue; - - //printf("Enum member '%s'\n",em->toChars()); - e = em->value; - if (e) - { - assert(e->dyncast() == DYNCAST_EXPRESSION); - e = e->semantic(sce); - e = e->optimize(WANTvalue); - // Need to copy it because we're going to change the type - e = e->copy(); - e = e->implicitCastTo(sc, memtype); - e = e->optimize(WANTvalue); - number = e->toInteger(); - e->type = t; - } - else - { // Default is the previous number plus 1 - - // Check for overflow - if (!first) - { - switch (t->toBasetype()->ty) - { - case Tbool: - if (number == 2) goto Loverflow; - break; - - case Tint8: - if (number == 128) goto Loverflow; - break; - - case Tchar: - case Tuns8: - if (number == 256) goto Loverflow; - break; - - case Tint16: - if (number == 0x8000) goto Loverflow; - break; - - case Twchar: - case Tuns16: - if (number == 0x10000) goto Loverflow; - break; - - case Tint32: - if (number == 0x80000000) goto Loverflow; - break; - - case Tdchar: - case Tuns32: - if (number == 0x100000000LL) goto Loverflow; - break; - - case Tint64: - if (number == 0x8000000000000000LL) goto Loverflow; - break; - - case Tuns64: - if (number == 0) goto Loverflow; - break; - - Loverflow: - error("overflow of enum value"); - break; - - default: - assert(0); - } - } - e = new IntegerExp(em->loc, number, t); - } - em->value = e; - - // Add to symbol table only after evaluating 'value' - if (isAnonymous()) - { - //sce->enclosing->insert(em); - for (Scope *scx = sce->enclosing; scx; scx = scx->enclosing) - { - if (scx->scopesym) - { - if (!scx->scopesym->symtab) - scx->scopesym->symtab = new DsymbolTable(); - em->addMember(sce, scx->scopesym, 1); - break; - } - } - } - else - em->addMember(sc, this, 1); - - if (first) - { first = 0; - defaultval = number; - minval = number; - maxval = number; - } - else if (memtype->isunsigned()) - { - if (number < minval) - minval = number; - if (number > maxval) - maxval = number; - } - else - { - if ((sinteger_t)number < (sinteger_t)minval) - minval = number; - if ((sinteger_t)number > (sinteger_t)maxval) - maxval = number; - } - - number++; - } - //printf("defaultval = %lld\n", defaultval); - - sce->pop(); - //members->print(); -} - -int EnumDeclaration::oneMember(Dsymbol **ps) -{ - if (isAnonymous()) - return Dsymbol::oneMembers(members, ps); - return Dsymbol::oneMember(ps); -} - -void EnumDeclaration::toCBuffer(OutBuffer *buf, HdrGenState *hgs) -{ int i; - - buf->writestring("enum "); - if (ident) - { buf->writestring(ident->toChars()); - buf->writeByte(' '); - } - if (memtype) - { - buf->writestring(": "); - memtype->toCBuffer(buf, NULL, hgs); - } - if (!members) - { - buf->writeByte(';'); - buf->writenl(); - return; - } - buf->writenl(); - buf->writeByte('{'); - buf->writenl(); - for (i = 0; i < members->dim; i++) - { - EnumMember *em = ((Dsymbol *)members->data[i])->isEnumMember(); - if (!em) - continue; - //buf->writestring(" "); - em->toCBuffer(buf, hgs); - buf->writeByte(','); - buf->writenl(); - } - buf->writeByte('}'); - buf->writenl(); -} - -Type *EnumDeclaration::getType() -{ - return type; -} - -const char *EnumDeclaration::kind() -{ - return "enum"; -} - -int EnumDeclaration::isDeprecated() -{ - return isdeprecated; -} - -/********************************* EnumMember ****************************/ - -EnumMember::EnumMember(Loc loc, Identifier *id, Expression *value) - : Dsymbol(id) -{ - this->value = value; - this->loc = loc; -} - -Dsymbol *EnumMember::syntaxCopy(Dsymbol *s) -{ - Expression *e = NULL; - if (value) - e = value->syntaxCopy(); - - EnumMember *em; - if (s) - { em = (EnumMember *)s; - em->loc = loc; - em->value = e; - } - else - em = new EnumMember(loc, ident, e); - return em; -} - -void EnumMember::toCBuffer(OutBuffer *buf, HdrGenState *hgs) -{ - buf->writestring(ident->toChars()); - if (value) - { - buf->writestring(" = "); - value->toCBuffer(buf, hgs); - } -} - -const char *EnumMember::kind() -{ - return "enum member"; -} - - + +// 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. +// See the included readme.txt for details. + +#include +#include + +#include "root.h" +#include "enum.h" +#include "mtype.h" +#include "scope.h" +#include "declaration.h" + +/********************************* EnumDeclaration ****************************/ + +EnumDeclaration::EnumDeclaration(Loc loc, Identifier *id, Type *memtype) + : ScopeDsymbol(id) +{ + this->loc = loc; + type = new TypeEnum(this); + this->memtype = memtype; + maxval = 0; + minval = 0; + defaultval = 0; +#if IN_DMD + sinit = NULL; +#endif + isdeprecated = 0; +} + +Dsymbol *EnumDeclaration::syntaxCopy(Dsymbol *s) +{ + Type *t = NULL; + if (memtype) + t = memtype->syntaxCopy(); + + EnumDeclaration *ed; + if (s) + { ed = (EnumDeclaration *)s; + ed->memtype = t; + } + else + ed = new EnumDeclaration(loc, ident, t); + ScopeDsymbol::syntaxCopy(ed); + return ed; +} + +void EnumDeclaration::semantic(Scope *sc) +{ int i; + uinteger_t number; + Type *t; + Scope *sce; + + //printf("EnumDeclaration::semantic(sd = %p, '%s')\n", sc->scopesym, sc->scopesym->toChars()); + if (symtab) // if already done + return; + if (!memtype) + memtype = Type::tint32; + if (sc->stc & STCdeprecated) + isdeprecated = 1; + + parent = sc->scopesym; + memtype = memtype->semantic(loc, sc); + + /* Check to see if memtype is forward referenced + */ + if (memtype->ty == Tenum) + { EnumDeclaration *sym = (EnumDeclaration *)memtype->toDsymbol(sc); + if (!sym->memtype) + { + error("base enum %s is forward referenced", sym->toChars()); + memtype = Type::tint32; + } + } + + if (!memtype->isintegral()) + { error("base type must be of integral type, not %s", memtype->toChars()); + memtype = Type::tint32; + } + + t = isAnonymous() ? memtype : type; + symtab = new DsymbolTable(); + sce = sc->push(this); + sce->parent = this; + number = 0; + if (!members) // enum ident; + return; + if (members->dim == 0) + error("enum %s must have at least one member", toChars()); + int first = 1; + for (i = 0; i < members->dim; i++) + { + EnumMember *em = ((Dsymbol *)members->data[i])->isEnumMember(); + Expression *e; + + if (!em) + /* The e->semantic(sce) can insert other symbols, such as + * template instances and function literals. + */ + continue; + + //printf("Enum member '%s'\n",em->toChars()); + e = em->value; + if (e) + { + assert(e->dyncast() == DYNCAST_EXPRESSION); + e = e->semantic(sce); + e = e->optimize(WANTvalue); + // Need to copy it because we're going to change the type + e = e->copy(); + e = e->implicitCastTo(sc, memtype); + e = e->optimize(WANTvalue); + number = e->toInteger(); + e->type = t; + } + else + { // Default is the previous number plus 1 + + // Check for overflow + if (!first) + { + switch (t->toBasetype()->ty) + { + case Tbool: + if (number == 2) goto Loverflow; + break; + + case Tint8: + if (number == 128) goto Loverflow; + break; + + case Tchar: + case Tuns8: + if (number == 256) goto Loverflow; + break; + + case Tint16: + if (number == 0x8000) goto Loverflow; + break; + + case Twchar: + case Tuns16: + if (number == 0x10000) goto Loverflow; + break; + + case Tint32: + if (number == 0x80000000) goto Loverflow; + break; + + case Tdchar: + case Tuns32: + if (number == 0x100000000LL) goto Loverflow; + break; + + case Tint64: + if (number == 0x8000000000000000LL) goto Loverflow; + break; + + case Tuns64: + if (number == 0) goto Loverflow; + break; + + Loverflow: + error("overflow of enum value"); + break; + + default: + assert(0); + } + } + e = new IntegerExp(em->loc, number, t); + } + em->value = e; + + // Add to symbol table only after evaluating 'value' + if (isAnonymous()) + { + //sce->enclosing->insert(em); + for (Scope *scx = sce->enclosing; scx; scx = scx->enclosing) + { + if (scx->scopesym) + { + if (!scx->scopesym->symtab) + scx->scopesym->symtab = new DsymbolTable(); + em->addMember(sce, scx->scopesym, 1); + break; + } + } + } + else + em->addMember(sc, this, 1); + + if (first) + { first = 0; + defaultval = number; + minval = number; + maxval = number; + } + else if (memtype->isunsigned()) + { + if (number < minval) + minval = number; + if (number > maxval) + maxval = number; + } + else + { + if ((sinteger_t)number < (sinteger_t)minval) + minval = number; + if ((sinteger_t)number > (sinteger_t)maxval) + maxval = number; + } + + number++; + } + //printf("defaultval = %lld\n", defaultval); + + sce->pop(); + //members->print(); +} + +int EnumDeclaration::oneMember(Dsymbol **ps) +{ + if (isAnonymous()) + return Dsymbol::oneMembers(members, ps); + return Dsymbol::oneMember(ps); +} + +void EnumDeclaration::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ int i; + + buf->writestring("enum "); + if (ident) + { buf->writestring(ident->toChars()); + buf->writeByte(' '); + } + if (memtype) + { + buf->writestring(": "); + memtype->toCBuffer(buf, NULL, hgs); + } + if (!members) + { + buf->writeByte(';'); + buf->writenl(); + return; + } + buf->writenl(); + buf->writeByte('{'); + buf->writenl(); + for (i = 0; i < members->dim; i++) + { + EnumMember *em = ((Dsymbol *)members->data[i])->isEnumMember(); + if (!em) + continue; + //buf->writestring(" "); + em->toCBuffer(buf, hgs); + buf->writeByte(','); + buf->writenl(); + } + buf->writeByte('}'); + buf->writenl(); +} + +Type *EnumDeclaration::getType() +{ + return type; +} + +const char *EnumDeclaration::kind() +{ + return "enum"; +} + +int EnumDeclaration::isDeprecated() +{ + return isdeprecated; +} + +/********************************* EnumMember ****************************/ + +EnumMember::EnumMember(Loc loc, Identifier *id, Expression *value) + : Dsymbol(id) +{ + this->value = value; + this->loc = loc; +} + +Dsymbol *EnumMember::syntaxCopy(Dsymbol *s) +{ + Expression *e = NULL; + if (value) + e = value->syntaxCopy(); + + EnumMember *em; + if (s) + { em = (EnumMember *)s; + em->loc = loc; + em->value = e; + } + else + em = new EnumMember(loc, ident, e); + return em; +} + +void EnumMember::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring(ident->toChars()); + if (value) + { + buf->writestring(" = "); + value->toCBuffer(buf, hgs); + } +} + +const char *EnumMember::kind() +{ + return "enum member"; +} + + diff -r 1d5721f9ae18 -r 1b24e9c7cc26 dmd/parse.h --- a/dmd/parse.h Wed Jan 06 15:18:19 2010 -0300 +++ b/dmd/parse.h Wed Jan 06 15:18:19 2010 -0300 @@ -1,146 +1,146 @@ - -// Compiler implementation of the D programming language -// 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. -// See the included readme.txt for details. - -#ifndef DMD_PARSE_H -#define DMD_PARSE_H - -#ifdef __DMC__ -#pragma once -#endif /* __DMC__ */ - -#include "arraytypes.h" -#include "lexer.h" -#include "enum.h" - -struct Type; -struct TypeQualified; -struct Expression; -struct Declaration; -struct Statement; -struct Import; -struct Initializer; -struct FuncDeclaration; -struct CtorDeclaration; -struct PostBlitDeclaration; -struct DtorDeclaration; -struct StaticCtorDeclaration; -struct StaticDtorDeclaration; -struct ConditionalDeclaration; -struct InvariantDeclaration; -struct UnitTestDeclaration; -struct NewDeclaration; -struct DeleteDeclaration; -struct Condition; -struct Module; -struct ModuleDeclaration; -struct TemplateDeclaration; -struct TemplateInstance; -struct StaticAssert; - -/************************************ - * These control how parseStatement() works. - */ - -enum ParseStatementFlags -{ - PSsemi = 1, // empty ';' statements are allowed - PSscope = 2, // start a new scope - PScurly = 4, // { } statement is required - PScurlyscope = 8, // { } starts a new scope -}; - - -struct Parser : Lexer -{ - ModuleDeclaration *md; - enum LINK linkage; - Loc endloc; // set to location of last right curly - int inBrackets; // inside [] of array index or slice - - Parser(Module *module, unsigned char *base, unsigned length, int doDocComment); - - Array *parseModule(); - Array *parseDeclDefs(int once); - Array *parseAutoDeclarations(StorageClass storageClass, unsigned char *comment); - Array *parseBlock(); - void composeStorageClass(StorageClass stc); - Expression *parseConstraint(); - TemplateDeclaration *parseTemplateDeclaration(); - TemplateParameters *parseTemplateParameterList(int flag = 0); - Dsymbol *parseMixin(); - Objects *parseTemplateArgumentList(); - Objects *parseTemplateArgumentList2(); - Objects *parseTemplateArgument(); - StaticAssert *parseStaticAssert(); - TypeQualified *parseTypeof(); - enum LINK parseLinkage(); - Condition *parseDebugCondition(); - Condition *parseVersionCondition(); - Condition *parseStaticIfCondition(); - Dsymbol *parseCtor(); - PostBlitDeclaration *parsePostBlit(); - DtorDeclaration *parseDtor(); - StaticCtorDeclaration *parseStaticCtor(); - StaticDtorDeclaration *parseStaticDtor(); - InvariantDeclaration *parseInvariant(); - UnitTestDeclaration *parseUnitTest(); - NewDeclaration *parseNew(); - DeleteDeclaration *parseDelete(); - Arguments *parseParameters(int *pvarargs); - EnumDeclaration *parseEnum(); - Dsymbol *parseAggregate(); - BaseClasses *parseBaseClasses(); - Import *parseImport(Array *decldefs, int isstatic); - Type *parseType(Identifier **pident = NULL, TemplateParameters **tpl = NULL); - Type *parseBasicType(); - Type *parseBasicType2(Type *t); - Type *parseDeclarator(Type *t, Identifier **pident, TemplateParameters **tpl = NULL); - Array *parseDeclarations(); - void parseContracts(FuncDeclaration *f); - Statement *parseStatement(int flags); - Initializer *parseInitializer(); - Expression *parseDefaultInitExp(); - void check(Loc loc, enum TOK value); - void check(enum TOK value); - void check(enum TOK value, const char *string); - int isDeclaration(Token *t, int needId, enum TOK endtok, Token **pt); - int isBasicType(Token **pt); - int isDeclarator(Token **pt, int *haveId, enum TOK endtok); - int isParameters(Token **pt); - int isExpression(Token **pt); - int isTemplateInstance(Token *t, Token **pt); - int skipParens(Token *t, Token **pt); - - Expression *parseExpression(); - Expression *parsePrimaryExp(); - Expression *parseUnaryExp(); - Expression *parsePostExp(Expression *e); - Expression *parseMulExp(); - Expression *parseAddExp(); - Expression *parseShiftExp(); - Expression *parseRelExp(); - Expression *parseEqualExp(); - Expression *parseCmpExp(); - Expression *parseAndExp(); - Expression *parseXorExp(); - Expression *parseOrExp(); - Expression *parseAndAndExp(); - Expression *parseOrOrExp(); - Expression *parseCondExp(); - Expression *parseAssignExp(); - - Expressions *parseArguments(); - - Expression *parseNewExp(Expression *thisexp); - - void addComment(Dsymbol *s, unsigned char *blockComment); -}; - -#endif /* DMD_PARSE_H */ + +// Compiler implementation of the D programming language +// 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. +// See the included readme.txt for details. + +#ifndef DMD_PARSE_H +#define DMD_PARSE_H + +#ifdef __DMC__ +#pragma once +#endif /* __DMC__ */ + +#include "arraytypes.h" +#include "lexer.h" +#include "enum.h" + +struct Type; +struct TypeQualified; +struct Expression; +struct Declaration; +struct Statement; +struct Import; +struct Initializer; +struct FuncDeclaration; +struct CtorDeclaration; +struct PostBlitDeclaration; +struct DtorDeclaration; +struct StaticCtorDeclaration; +struct StaticDtorDeclaration; +struct ConditionalDeclaration; +struct InvariantDeclaration; +struct UnitTestDeclaration; +struct NewDeclaration; +struct DeleteDeclaration; +struct Condition; +struct Module; +struct ModuleDeclaration; +struct TemplateDeclaration; +struct TemplateInstance; +struct StaticAssert; + +/************************************ + * These control how parseStatement() works. + */ + +enum ParseStatementFlags +{ + PSsemi = 1, // empty ';' statements are allowed + PSscope = 2, // start a new scope + PScurly = 4, // { } statement is required + PScurlyscope = 8, // { } starts a new scope +}; + + +struct Parser : Lexer +{ + ModuleDeclaration *md; + enum LINK linkage; + Loc endloc; // set to location of last right curly + int inBrackets; // inside [] of array index or slice + + Parser(Module *module, unsigned char *base, unsigned length, int doDocComment); + + Array *parseModule(); + Array *parseDeclDefs(int once); + Array *parseAutoDeclarations(StorageClass storageClass, unsigned char *comment); + Array *parseBlock(); + void composeStorageClass(StorageClass stc); + Expression *parseConstraint(); + TemplateDeclaration *parseTemplateDeclaration(); + TemplateParameters *parseTemplateParameterList(int flag = 0); + Dsymbol *parseMixin(); + Objects *parseTemplateArgumentList(); + Objects *parseTemplateArgumentList2(); + Objects *parseTemplateArgument(); + StaticAssert *parseStaticAssert(); + TypeQualified *parseTypeof(); + enum LINK parseLinkage(); + Condition *parseDebugCondition(); + Condition *parseVersionCondition(); + Condition *parseStaticIfCondition(); + Dsymbol *parseCtor(); + PostBlitDeclaration *parsePostBlit(); + DtorDeclaration *parseDtor(); + StaticCtorDeclaration *parseStaticCtor(); + StaticDtorDeclaration *parseStaticDtor(); + InvariantDeclaration *parseInvariant(); + UnitTestDeclaration *parseUnitTest(); + NewDeclaration *parseNew(); + DeleteDeclaration *parseDelete(); + Arguments *parseParameters(int *pvarargs); + EnumDeclaration *parseEnum(); + Dsymbol *parseAggregate(); + BaseClasses *parseBaseClasses(); + Import *parseImport(Array *decldefs, int isstatic); + Type *parseType(Identifier **pident = NULL, TemplateParameters **tpl = NULL); + Type *parseBasicType(); + Type *parseBasicType2(Type *t); + Type *parseDeclarator(Type *t, Identifier **pident, TemplateParameters **tpl = NULL); + Array *parseDeclarations(); + void parseContracts(FuncDeclaration *f); + Statement *parseStatement(int flags); + Initializer *parseInitializer(); + Expression *parseDefaultInitExp(); + void check(Loc loc, enum TOK value); + void check(enum TOK value); + void check(enum TOK value, const char *string); + int isDeclaration(Token *t, int needId, enum TOK endtok, Token **pt); + int isBasicType(Token **pt); + int isDeclarator(Token **pt, int *haveId, enum TOK endtok); + int isParameters(Token **pt); + int isExpression(Token **pt); + int isTemplateInstance(Token *t, Token **pt); + int skipParens(Token *t, Token **pt); + + Expression *parseExpression(); + Expression *parsePrimaryExp(); + Expression *parseUnaryExp(); + Expression *parsePostExp(Expression *e); + Expression *parseMulExp(); + Expression *parseAddExp(); + Expression *parseShiftExp(); + Expression *parseRelExp(); + Expression *parseEqualExp(); + Expression *parseCmpExp(); + Expression *parseAndExp(); + Expression *parseXorExp(); + Expression *parseOrExp(); + Expression *parseAndAndExp(); + Expression *parseOrOrExp(); + Expression *parseCondExp(); + Expression *parseAssignExp(); + + Expressions *parseArguments(); + + Expression *parseNewExp(Expression *thisexp); + + void addComment(Dsymbol *s, unsigned char *blockComment); +}; + +#endif /* DMD_PARSE_H */ diff -r 1d5721f9ae18 -r 1b24e9c7cc26 dmd/staticassert.c --- a/dmd/staticassert.c Wed Jan 06 15:18:19 2010 -0300 +++ b/dmd/staticassert.c Wed Jan 06 15:18:19 2010 -0300 @@ -1,120 +1,120 @@ - -// Copyright (c) 1999-2007 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. -// See the included readme.txt for details. - -#include -#include -#include - -#include "dsymbol.h" -#include "staticassert.h" -#include "expression.h" -#include "id.h" -#include "hdrgen.h" -#include "scope.h" -#include "template.h" - - -/********************************* AttribDeclaration ****************************/ - -StaticAssert::StaticAssert(Loc loc, Expression *exp, Expression *msg) - : Dsymbol(Id::empty) -{ - this->loc = loc; - this->exp = exp; - this->msg = msg; -} - -Dsymbol *StaticAssert::syntaxCopy(Dsymbol *s) -{ - StaticAssert *sa; - - assert(!s); - sa = new StaticAssert(loc, exp->syntaxCopy(), msg ? msg->syntaxCopy() : NULL); - return sa; -} - -int StaticAssert::addMember(Scope *sc, ScopeDsymbol *sd, int memnum) -{ - return 0; // we didn't add anything -} - -void StaticAssert::semantic(Scope *sc) -{ -} - -#include "scope.h" -#include "template.h" -#include "declaration.h" - -void StaticAssert::semantic2(Scope *sc) -{ - Expression *e; - - //printf("StaticAssert::semantic2() %s\n", toChars()); - e = exp->semantic(sc); - e = e->optimize(WANTvalue | WANTinterpret); - if (e->isBool(FALSE)) - { - if (msg) - { HdrGenState hgs; - OutBuffer buf; - - msg = msg->semantic(sc); - msg = msg->optimize(WANTvalue | WANTinterpret); - hgs.console = 1; - msg->toCBuffer(&buf, &hgs); - error("%s", buf.toChars()); - } - else - error("(%s) is false", exp->toChars()); - if(sc->tinst) - sc->tinst->printInstantiationTrace(); - if (!global.gag) { - fatal(); - } - } - else if (!e->isBool(TRUE)) - { - error("(%s) is not evaluatable at compile time", exp->toChars()); - } -} - -int StaticAssert::oneMember(Dsymbol **ps) -{ - //printf("StaticAssert::oneMember())\n"); - *ps = NULL; - return TRUE; -} - -void StaticAssert::inlineScan() -{ -} - -void StaticAssert::toObjFile(int multiobj) -{ -} - -const char *StaticAssert::kind() -{ - return "static assert"; -} - -void StaticAssert::toCBuffer(OutBuffer *buf, HdrGenState *hgs) -{ - buf->writestring(kind()); - buf->writeByte('('); - exp->toCBuffer(buf, hgs); - if (msg) - { - buf->writeByte(','); - msg->toCBuffer(buf, hgs); - } - buf->writestring(");"); - buf->writenl(); -} + +// Copyright (c) 1999-2007 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. +// See the included readme.txt for details. + +#include +#include +#include + +#include "dsymbol.h" +#include "staticassert.h" +#include "expression.h" +#include "id.h" +#include "hdrgen.h" +#include "scope.h" +#include "template.h" + + +/********************************* AttribDeclaration ****************************/ + +StaticAssert::StaticAssert(Loc loc, Expression *exp, Expression *msg) + : Dsymbol(Id::empty) +{ + this->loc = loc; + this->exp = exp; + this->msg = msg; +} + +Dsymbol *StaticAssert::syntaxCopy(Dsymbol *s) +{ + StaticAssert *sa; + + assert(!s); + sa = new StaticAssert(loc, exp->syntaxCopy(), msg ? msg->syntaxCopy() : NULL); + return sa; +} + +int StaticAssert::addMember(Scope *sc, ScopeDsymbol *sd, int memnum) +{ + return 0; // we didn't add anything +} + +void StaticAssert::semantic(Scope *sc) +{ +} + +#include "scope.h" +#include "template.h" +#include "declaration.h" + +void StaticAssert::semantic2(Scope *sc) +{ + Expression *e; + + //printf("StaticAssert::semantic2() %s\n", toChars()); + e = exp->semantic(sc); + e = e->optimize(WANTvalue | WANTinterpret); + if (e->isBool(FALSE)) + { + if (msg) + { HdrGenState hgs; + OutBuffer buf; + + msg = msg->semantic(sc); + msg = msg->optimize(WANTvalue | WANTinterpret); + hgs.console = 1; + msg->toCBuffer(&buf, &hgs); + error("%s", buf.toChars()); + } + else + error("(%s) is false", exp->toChars()); + if(sc->tinst) + sc->tinst->printInstantiationTrace(); + if (!global.gag) { + fatal(); + } + } + else if (!e->isBool(TRUE)) + { + error("(%s) is not evaluatable at compile time", exp->toChars()); + } +} + +int StaticAssert::oneMember(Dsymbol **ps) +{ + //printf("StaticAssert::oneMember())\n"); + *ps = NULL; + return TRUE; +} + +void StaticAssert::inlineScan() +{ +} + +void StaticAssert::toObjFile(int multiobj) +{ +} + +const char *StaticAssert::kind() +{ + return "static assert"; +} + +void StaticAssert::toCBuffer(OutBuffer *buf, HdrGenState *hgs) +{ + buf->writestring(kind()); + buf->writeByte('('); + exp->toCBuffer(buf, hgs); + if (msg) + { + buf->writeByte(','); + msg->toCBuffer(buf, hgs); + } + buf->writestring(");"); + buf->writenl(); +}