projects/ldc: dmd2/attrib.c comparison

comparison dmd2/attrib.c @ 1452:638d16625da2

LDC 2 compiles again.

author	Robert Clipsham <robert@octarineparrot.com>
date	Sat, 30 May 2009 17:23:32 +0100
parents	2667e3a145be
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.
 #include <stdio.h>
 #include <stdlib.h>
 #include <assert.h>
-#if _WIN32 || IN_GCC || IN_LLVM
+#include "rmem.h"
-#include "mem.h"
-#elif POSIX
-#include "../root/mem.h"
-#endif
 #include "init.h"
 #include "declaration.h"
 #include "attrib.h"
 #include "cond.h"
 #include "aggregate.h"
 #include "module.h"
 #include "parse.h"
 #include "template.h"
+#if IN_LLVM
 #include "../gen/enums.h"
 #include "llvm/Support/CommandLine.h"
 static llvm::cl::opt<bool> ignoreUnsupportedPragmas("ignore",
 llvm::cl::desc("Ignore unsupported pragmas"),
 llvm::cl::ZeroOrMore);
+#endif
 extern void obj_includelib(const char *name);
+#if IN_DMD
 void obj_startaddress(Symbol *s);
+#endif
 /********************************* AttribDeclaration ****************************/
 AttribDeclaration::AttribDeclaration(Array *decl)
 void AttribDeclaration::emitComment(Scope *sc)
 {
 //printf("AttribDeclaration::emitComment(sc = %p)\n", sc);
-/* If generating doc comment, skip this because if we're inside
+/* A general problem with this, illustrated by BUGZILLA 2516,
-* a template, then include(NULL, NULL) will fail.
+* is that attributes are not transmitted through to the underlying
+* member declarations for template bodies, because semantic analysis
+* is not done for template declaration bodies
+* (only template instantiations).
+* Hence, Ddoc omits attributes from template members.
 */
-//    if (sc->docbuf)
-//	return;
 Array *d = include(NULL, NULL);
 if (d)
 {
 	    //printf("AttribDeclaration::emitComment %s\n", s->toChars());
 	    s->emitComment(sc);
 	}
 }
 }
+#if IN_DMD
 void AttribDeclaration::toObjFile(int multiobj)
 {
 Array *d = include(NULL, NULL);
 	    nwritten += n;
 	}
 }
 return nwritten;
 }
+#endif
 int AttribDeclaration::hasPointers()
 {
 Array *d = include(NULL, NULL);
 void StorageClassDeclaration::semantic(Scope *sc)
 {
 if (decl)
 {	unsigned stc_save = sc->stc;
-	/* These sets of storage classes are mutually exclusive,
+	if (stc & (STCauto | STCscope | STCstatic | STCextern))
-	 * so choose the innermost or most recent one.
+	    sc->stc &= ~(STCauto | STCscope | STCstatic | STCextern);
-	 */
-	if (stc & (STCauto | STCscope | STCstatic | STCextern | STCmanifest))
-	    sc->stc &= ~(STCauto | STCscope | STCstatic | STCextern | STCmanifest);
-	if (stc & (STCauto | STCscope | STCstatic | STCtls | STCmanifest))
-	    sc->stc &= ~(STCauto | STCscope | STCstatic | STCtls | STCmanifest);
-	if (stc & (STCconst | STCinvariant | STCmanifest))
-	    sc->stc &= ~(STCconst | STCinvariant | STCmanifest);
 	sc->stc |= stc;
 	for (unsigned i = 0; i < decl->dim; i++)
 	{
 	    Dsymbol *s = (Dsymbol *)decl->data[i];
 }
 else
 	sc->stc = stc;
 }
-void StorageClassDeclaration::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
+void StorageClassDeclaration::stcToCBuffer(OutBuffer *buf, int stc)
 {
 struct SCstring
 {
 	int stc;
 	enum TOK tok;
 	{ STCauto,         TOKauto },
 	{ STCscope,        TOKscope },
 	{ STCstatic,       TOKstatic },
 	{ STCextern,       TOKextern },
 	{ STCconst,        TOKconst },
-	{ STCinvariant,    TOKimmutable },
+	{ STCimmutable,    TOKimmutable },
 	{ STCshared,       TOKshared },
 	{ STCfinal,        TOKfinal },
 	{ STCabstract,     TOKabstract },
 	{ STCsynchronized, TOKsynchronized },
 	{ STCdeprecated,   TOKdeprecated },
 	{ STCoverride,     TOKoverride },
 	{ STCnothrow,      TOKnothrow },
 	{ STCpure,         TOKpure },
 	{ STCref,          TOKref },
 	{ STCtls,          TOKtls },
+	{ STCgshared,      TOKgshared },
+	{ STClazy,         TOKlazy },
+	{ STCalias,        TOKalias },
+	{ STCout,          TOKout },
+	{ STCin,           TOKin },
 };
-int written = 0;
 for (int i = 0; i < sizeof(table)/sizeof(table[0]); i++)
 {
 	if (stc & table[i].stc)
 	{
-	    if (written)
-		buf->writeByte(' ');
-	    written = 1;
 	    buf->writestring(Token::toChars(table[i].tok));
-	}
+	    buf->writeByte(' ');
-}
+	}
+}
+}
+void StorageClassDeclaration::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
+{
+stcToCBuffer(buf, stc);
 AttribDeclaration::toCBuffer(buf, hgs);
 }
 /********************************* LinkDeclaration ****************************/
 	case LINKc:		p = "C";		break;
 	case LINKcpp:		p = "C++";		break;
 	case LINKwindows:	p = "Windows";		break;
 	case LINKpascal:	p = "Pascal";		break;
-// LDC
+#if IN_LLVM
 case LINKintrinsic: p = "Intrinsic"; break;
+#endif
 	default:
 	    assert(0);
 	    break;
 }
 buf->writestring("extern (");
 // other alignments are simply ignored. my tests show this is what llvm-gcc does too ...
 //printf("\tAlignDeclaration::semantic '%s'\n",toChars());
 if (decl)
 {	unsigned salign_save = sc->structalign;
+#if IN_DMD
+	sc->structalign = salign;
+#endif
 	for (unsigned i = 0; i < decl->dim; i++)
 	{
 	    Dsymbol *s = (Dsymbol *)decl->data[i];
 if (s->isStructDeclaration() && salign == 1)
 //	printf("\tad  = %p\n", ad);
 //	printf("\taad = %p\n", &aad);
 	sc = sc->push();
 	sc->anonAgg = &aad;
-	sc->stc &= ~(STCauto | STCscope | STCstatic | STCtls);
+	sc->stc &= ~(STCauto | STCscope | STCstatic | STCtls | STCgshared);
 	sc->inunion = isunion;
 	sc->offset = 0;
 	sc->flags = 0;
 	aad.structalign = sc->structalign;
 	aad.parent = ad;
 	for (unsigned i = 0; i < decl->dim; i++)
 	{
 	    Dsymbol *s = (Dsymbol *)decl->data[i];
 	    s->semantic(sc);
 	ad->alignmember(aad.structalign, aad.alignsize, &sc->offset);
 	//ad->structsize = sc->offset;
 //printf("sc->offset = %d\n", sc->offset);
 	// Add members of aad to ad
-	//printf("\tadding members of aad (%p) to '%s'\n", &aad, ad->toChars());
+	//printf("\tadding members of aad to '%s'\n", ad->toChars());
 	for (unsigned i = 0; i < aad.fields.dim; i++)
 	{
 	    VarDeclaration *v = (VarDeclaration *)aad.fields.data[i];
-// LDC
+#if IN_LLVM
 v->offset2 = sc->offset;
+#endif
 	    v->offset += sc->offset;
-// LDC
+#if IN_LLVM
 if (!v->anonDecl)
 v->anonDecl = this;
+#endif
 	    ad->fields.push(v);
 	}
 	// Add size of aad to ad
 	if (adisunion)
 this->args = args;
 }
 Dsymbol *PragmaDeclaration::syntaxCopy(Dsymbol *s)
 {
+//printf("PragmaDeclaration::syntaxCopy(%s)\n", toChars());
 PragmaDeclaration *pd;
 assert(!s);
 pd = new PragmaDeclaration(loc, ident,
 	Expression::arraySyntaxCopy(args), Dsymbol::arraySyntaxCopy(decl));
 {   // Should be merged with PragmaStatement
 #if IN_LLVM
 int llvm_internal = 0;
 std::string arg1str;
 #endif
 //printf("\tPragmaDeclaration::semantic '%s'\n",toChars());
 if (ident == Id::msg)
 {
 		e = e->semantic(sc);
 		e = e->optimize(WANTvalue | WANTinterpret);
 		if (e->op == TOKstring)
 		{
 		    StringExp *se = (StringExp *)e;
-		    fprintf(stdmsg, "%.*s", (int)se->len, se->string);
+		    fprintf(stdmsg, "%.*s", (int)se->len, (char*)se->string);
 		}
 		else
 		    error("string expected for message, not '%s'", e->toChars());
 	    }
 	    fprintf(stdmsg, "\n");
 		error("function name expected for start address, not '%s'", e->toChars());
 	}
 	goto Lnodecl;
 }
-/////////////////////////////////////////////////////////////
+// LDC
-/////////////////////////////////////////////////////////////
-// LDC
 #if IN_LLVM
 // pragma(intrinsic, "string") { funcdecl(s) }
 else if (ident == Id::intrinsic)
 {
 {
 sc->module->llvmForceLogging = true;
 }
 else
 {
-error("command '%s' invalid");
+error("command '%s' invalid", expr->toChars());
 fatal();
 }
 }
-#endif
+// pragma(llvm_inline_asm) { templdecl(s) }
-// LDC
+else if (ident == Id::llvm_inline_asm)
-/////////////////////////////////////////////////////////////
+{
-/////////////////////////////////////////////////////////////
+if (args && args->dim > 0)
+{
+error("takes no parameters");
+fatal();
+}
+llvm_internal = LLVMinline_asm;
+}
+#endif // LDC
 else if (ignoreUnsupportedPragmas)
 {
 	if (global.params.verbose)
 	{
 	    printf("pragma    %s", ident->toChars());
 	    if (args)
 	    {
 		for (size_t i = 0; i < args->dim; i++)
 		{
+// ignore errors in ignored pragmas.
+global.gag++;
+unsigned errors_save = global.errors;
 		    Expression *e = (Expression *)args->data[i];
 		    e = e->semantic(sc);
 		    e = e->optimize(WANTvalue | WANTinterpret);
 		    if (i == 0)
 			printf(" (");
 		    else
 			printf(",");
 		    printf("%s", e->toChars());
+// restore error state.
+global.gag--;
+global.errors = errors_save;
 		}
 		if (args->dim)
 		    printf(")");
 	    }
 	    printf("\n");
 	}
-	goto Lnodecl;
 }
 else
 	error("unrecognized pragma(%s)", ident->toChars());
 if (decl)
 error("the '%s' pragma must only be used on function declarations of type 'void* function(uint nbytes)'", ident->toChars());
 fatal();
 }
 break;
+case LLVMinline_asm:
+if (TemplateDeclaration* td = s->isTemplateDeclaration())
+{
+if (td->parameters->dim > 1)
+{
+error("the '%s' pragma template must have exactly zero or one template parameters", ident->toChars());
+fatal();
+}
+else if (!td->onemember)
+{
+error("the '%s' pragma template must have exactly one member", ident->toChars());
+fatal();
+}
+td->llvmInternal = llvm_internal;
+}
+else
+{
+error("the '%s' pragma is only allowed on template declarations", ident->toChars());
+fatal();
+}
+break;
 default:
 warning("the LDC specific pragma '%s' is not yet implemented, ignoring", ident->toChars());
 }
 }
 const char *PragmaDeclaration::kind()
 {
 return "pragma";
 }
+#if IN_DMD
 void PragmaDeclaration::toObjFile(int multiobj)
 {
 if (ident == Id::lib)
 {
 	assert(args && args->dim == 1);
 	StringExp *se = (StringExp *)e;
 	char *name = (char *)mem.malloc(se->len + 1);
 	memcpy(name, se->string, se->len);
 	name[se->len] = 0;
+#if OMFOBJ
+	/* The OMF format allows library names to be inserted
+	 * into the object file. The linker will then automatically
+	 * search that library, too.
+	 */
 	obj_includelib(name);
-}
+#elif ELFOBJ || MACHOBJ
+	/* The format does not allow embedded library names,
+	 * so instead append the library name to the list to be passed
+	 * to the linker.
+	 */
+	global.params.libfiles->push((void *) name);
+#else
+	error("pragma lib not supported");
+#endif
+}
+#if DMDV2
 else if (ident == Id::startaddress)
 {
 	assert(args && args->dim == 1);
 	Expression *e = (Expression *)args->data[0];
 	Dsymbol *sa = getDsymbol(e);
 	FuncDeclaration *f = sa->isFuncDeclaration();
 	assert(f);
 	Symbol *s = f->toSymbol();
-assert(0 && "startaddress pragma not implemented");
+	obj_startaddress(s);
-// 	obj_startaddress(s);
+}
-}
+#endif
 AttribDeclaration::toObjFile(multiobj);
 }
+#endif
 void PragmaDeclaration::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
 {
 buf->printf("pragma (%s", ident->toChars());
 if (args && args->dim)
 {
 //printf("ConditionalDeclaration::emitComment(sc = %p)\n", sc);
 if (condition->inc)
 {
 	AttribDeclaration::emitComment(sc);
+}
+else if (sc->docbuf)
+{
+	/* If generating doc comment, be careful because if we're inside
+	 * a template, then include(NULL, NULL) will fail.
+	 */
+	Array *d = decl ? decl : elsedecl;
+	for (unsigned i = 0; i < d->dim; i++)
+	{   Dsymbol *s = (Dsymbol *)d->data[i];
+	    s->emitComment(sc);
+	}
 }
 }
 // Decide if 'then' or 'else' code should be included

Mercurial > projects > ldc

comparison dmd2/attrib.c @ 1452:638d16625da2