Google Git
Sign in
gnu / gcc / refs/heads/devel/gccgo / . / gcc / d / dmd / dtoh.d
blob: 7c3ff4bccc2ca87842ac8164f82e3d26f6cd207f [file] [log] [blame]
/**
* This module contains the implementation of the C++ header generation available through
* the command line switch -Hc.
*
* Copyright: Copyright (C) 1999-2023 by The D Language Foundation, All Rights Reserved
* Authors: $(LINK2 https://www.digitalmars.com, Walter Bright)
* License: $(LINK2 https://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
* Source: $(LINK2 https://github.com/dlang/dmd/blob/master/src/dmd/dtohd, _dtoh.d)
* Documentation: https://dlang.org/phobos/dmd_dtoh.html
* Coverage: https://codecov.io/gh/dlang/dmd/src/master/src/dmd/dtoh.d
*/
module dmd.dtoh;
import core.stdc.stdio;
import core.stdc.string;
import core.stdc.ctype;
import dmd.astcodegen;
import dmd.astenums;
import dmd.arraytypes;
import dmd.attrib;
import dmd.dsymbol;
import dmd.errors;
import dmd.globals;
import dmd.hdrgen;
import dmd.identifier;
import dmd.location;
import dmd.root.filename;
import dmd.visitor;
import dmd.tokens;
import dmd.common.outbuffer;
import dmd.utils;
//debug = Debug_DtoH;
// Generate asserts to validate the header
//debug = Debug_DtoH_Checks;
/**
* Generates a C++ header containing bindings for all `extern(C[++])` declarations
* found in the supplied modules.
*
* Params:
* ms = the modules
*
* Notes:
* - the header is written to `<global.params.cxxhdrdir>/<global.params.cxxhdrfile>`
* or `stdout` if no explicit file was specified
* - bindings conform to the C++ standard defined in `global.params.cplusplus`
* - ignored declarations are mentioned in a comment if `global.params.doCxxHdrGeneration`
* is set to `CxxHeaderMode.verbose`
*/
extern(C++) void genCppHdrFiles(ref Modules ms)
{
initialize();
OutBuffer fwd;
OutBuffer done;
OutBuffer decl;
// enable indent by spaces on buffers
fwd.doindent = true;
fwd.spaces = true;
decl.doindent = true;
decl.spaces = true;
scope v = new ToCppBuffer(&fwd, &done, &decl);
// Conditionally include another buffer for sanity checks
debug (Debug_DtoH_Checks)
{
OutBuffer check;
check.doindent = true;
check.spaces = true;
v.checkbuf = &check;
}
OutBuffer buf;
buf.doindent = true;
buf.spaces = true;
foreach (m; ms)
m.accept(v);
if (global.params.cxxhdr.fullOutput)
buf.printf("// Automatically generated by %s Compiler v%d", global.vendor.ptr, global.versionNumber());
else
buf.printf("// Automatically generated by %s Compiler", global.vendor.ptr);
buf.writenl();
buf.writenl();
buf.writestringln("#pragma once");
buf.writenl();
hashInclude(buf, "<assert.h>");
hashInclude(buf, "<math.h>");
hashInclude(buf, "<stddef.h>");
hashInclude(buf, "<stdint.h>");
// buf.writestring(buf, "#include <stdio.h>\n");
// buf.writestring("#include <string.h>\n");
// Emit array compatibility because extern(C++) types may have slices
// as members (as opposed to function parameters)
buf.writestring(`
#ifdef CUSTOM_D_ARRAY_TYPE
#define _d_dynamicArray CUSTOM_D_ARRAY_TYPE
#else
/// Represents a D [] array
template<typename T>
struct _d_dynamicArray final
{
size_t length;
T *ptr;
_d_dynamicArray() : length(0), ptr(NULL) { }
_d_dynamicArray(size_t length_in, T *ptr_in)
: length(length_in), ptr(ptr_in) { }
T& operator[](const size_t idx) {
assert(idx < length);
return ptr[idx];
}
const T& operator[](const size_t idx) const {
assert(idx < length);
return ptr[idx];
}
};
#endif
`);
if (v.hasReal)
{
hashIf(buf, "!defined(_d_real)");
{
hashDefine(buf, "_d_real long double");
}
hashEndIf(buf);
}
buf.writenl();
// buf.writestringln("// fwd:");
buf.write(&fwd);
if (fwd.length > 0)
buf.writenl();
// buf.writestringln("// done:");
buf.write(&done);
// buf.writestringln("// decl:");
buf.write(&decl);
debug (Debug_DtoH_Checks)
{
// buf.writestringln("// check:");
buf.writestring(`
#if OFFSETS
template <class T>
size_t getSlotNumber(int dummy, ...)
{
T c;
va_list ap;
va_start(ap, dummy);
void *f = va_arg(ap, void*);
for (size_t i = 0; ; i++)
{
if ( (*(void***)&c)[i] == f)
return i;
}
va_end(ap);
}
void testOffsets()
{
`);
buf.write(&check);
buf.writestring(`
}
#endif
`);
}
// prevent trailing newlines
version (Windows)
while (buf.length >= 4 && buf[$-4..$] == "\r\n\r\n")
buf.remove(buf.length - 2, 2);
else
while (buf.length >= 2 && buf[$-2..$] == "\n\n")
buf.remove(buf.length - 1, 1);
if (global.params.cxxhdr.name is null)
{
// Write to stdout; assume it succeeds
size_t n = fwrite(buf[].ptr, 1, buf.length, stdout);
assert(n == buf.length); // keep gcc happy about return values
}
else
{
const(char)[] name = FileName.combine(global.params.cxxhdr.dir, global.params.cxxhdr.name);
writeFile(Loc.initial, name, buf[]);
}
}
private:
/****************************************************
* Visitor that writes bindings for `extern(C[++]` declarations.
*/
extern(C++) final class ToCppBuffer : Visitor
{
alias visit = Visitor.visit;
public:
enum EnumKind
{
Int,
Numeric,
String,
Enum,
Other
}
/// Namespace providing the actual AST nodes
alias AST = ASTCodegen;
/// Visited nodes
bool[void*] visited;
/// Forward declared nodes (which might not be emitted yet)
bool[void*] forwarded;
/// Buffer for forward declarations
OutBuffer* fwdbuf;
/// Buffer for integrity checks
debug (Debug_DtoH_Checks) OutBuffer* checkbuf;
/// Buffer for declarations that must emitted before the currently
/// visited node but can't be forward declared (see `includeSymbol`)
OutBuffer* donebuf;
/// Default buffer for the currently visited declaration
OutBuffer* buf;
/// The generated header uses `real` emitted as `_d_real`?
bool hasReal;
/// The generated header should contain comments for skipped declarations?
const bool printIgnored;
/// State specific to the current context which depends
/// on the currently visited node and it's parents
static struct Context
{
/// Default linkage in the current scope (e.g. LINK.c inside `extern(C) { ... }`)
LINK linkage = LINK.d;
/// Enclosing class / struct / union
AST.AggregateDeclaration adparent;
/// Enclosing template declaration
AST.TemplateDeclaration tdparent;
/// Identifier of the currently visited `VarDeclaration`
/// (required to write variables of funtion pointers)
Identifier ident;
/// Original type of the currently visited declaration
AST.Type origType;
/// Last written visibility level applying to the current scope
AST.Visibility.Kind currentVisibility;
/// Currently applicable storage classes
AST.STC storageClass;
/// How many symbols were ignored
int ignoredCounter;
/// Currently visited types are required by another declaration
/// and hence must be emitted
bool mustEmit;
/// Processing a type that can be forward referenced
bool forwarding;
/// Inside of an anonymous struct/union (AnonDeclaration)
bool inAnonymousDecl;
}
/// Informations about the current context in the AST
Context context;
// Generates getter-setter methods to replace the use of alias this
// This should be replaced by a `static foreach` once the gdc tester
// gets upgraded to version 10 (to support `static foreach`).
private extern(D) static string generateMembers()
{
string result = "";
foreach(member; __traits(allMembers, Context))
{
result ~= "ref auto " ~ member ~ "() { return context." ~ member ~ "; }\n";
}
return result;
}
mixin(generateMembers());
this(OutBuffer* fwdbuf, OutBuffer* donebuf, OutBuffer* buf) scope
{
this.fwdbuf = fwdbuf;
this.donebuf = donebuf;
this.buf = buf;
this.printIgnored = global.params.cxxhdr.fullOutput;
}
/**
* Emits `dsym` into `donebuf` s.t. it is declared before the currently
* visited symbol that written to `buf`.
*
* Temporarily clears `context` to behave as if it was visited normally.
*/
private void includeSymbol(AST.Dsymbol dsym)
{
debug (Debug_DtoH)
{
printf("[includeSymbol(AST.Dsymbol) enter] %s\n", dsym.toChars());
scope(exit) printf("[includeSymbol(AST.Dsymbol) exit] %s\n", dsym.toChars());
}
auto ptr = cast(void*) dsym in visited;
if (ptr && *ptr)
return;
// Temporary replacement for `buf` which is appended to `donebuf`
OutBuffer decl;
decl.doindent = true;
decl.spaces = true;
scope (exit) donebuf.write(&decl);
auto ctxStash = this.context;
auto bufStash = this.buf;
this.context = Context.init;
this.buf = &decl;
this.mustEmit = true;
dsym.accept(this);
this.context = ctxStash;
this.buf = bufStash;
}
/// Determines what kind of enum `type` is (see `EnumKind`)
private EnumKind getEnumKind(AST.Type type)
{
if (type) switch (type.ty)
{
case AST.Tint32:
return EnumKind.Int;
case AST.Tbool,
AST.Tchar, AST.Twchar, AST.Tdchar,
AST.Tint8, AST.Tuns8,
AST.Tint16, AST.Tuns16,
AST.Tuns32,
AST.Tint64, AST.Tuns64:
return EnumKind.Numeric;
case AST.Tarray:
if (type.isString())
return EnumKind.String;
break;
case AST.Tenum:
return EnumKind.Enum;
default:
break;
}
return EnumKind.Other;
}
/// Determines the type used to represent `type` in C++.
/// Returns: `const [w,d]char*` for `[w,d]string` or `type`
private AST.Type determineEnumType(AST.Type type)
{
if (auto arr = type.isTypeDArray())
{
switch (arr.next.ty)
{
case AST.Tchar: return AST.Type.tchar.constOf.pointerTo;
case AST.Twchar: return AST.Type.twchar.constOf.pointerTo;
case AST.Tdchar: return AST.Type.tdchar.constOf.pointerTo;
default: break;
}
}
return type;
}
/// Writes a final `;` and insert an empty line outside of aggregates
private void writeDeclEnd()
{
buf.writestringln(";");
if (!adparent)
buf.writenl();
}
/// Writes the corresponding access specifier if necessary
private void writeProtection(const AST.Visibility.Kind kind)
{
// Don't write visibility for global declarations
if (!adparent || inAnonymousDecl)
return;
string token;
switch(kind) with(AST.Visibility.Kind)
{
case none, private_:
if (this.currentVisibility == AST.Visibility.Kind.private_)
return;
this.currentVisibility = AST.Visibility.Kind.private_;
token = "private:";
break;
case package_, protected_:
if (this.currentVisibility == AST.Visibility.Kind.protected_)
return;
this.currentVisibility = AST.Visibility.Kind.protected_;
token = "protected:";
break;
case undefined, public_, export_:
if (this.currentVisibility == AST.Visibility.Kind.public_)
return;
this.currentVisibility = AST.Visibility.Kind.public_;
token = "public:";
break;
default:
printf("Unexpected visibility: %d!\n", kind);
assert(0);
}
buf.level--;
buf.writestringln(token);
buf.level++;
}
/**
* Writes an identifier into `buf` and checks for reserved identifiers. The
* parameter `canFix` determines how this function handles C++ keywords:
*
* `false` => Raise a warning and print the identifier as-is
* `true` => Append an underscore to the identifier
*
* Params:
* s = the symbol denoting the identifier
* canFixup = whether the identifier may be changed without affecting
* binary compatibility
*/
private void writeIdentifier(const AST.Dsymbol s, const bool canFix = false)
{
if (const mn = getMangleOverride(s))
return buf.writestring(mn);
writeIdentifier(s.ident, s.loc, s.kind(), canFix);
}
/** Overload of `writeIdentifier` used for all AST nodes not descending from Dsymbol **/
private void writeIdentifier(const Identifier ident, const Loc loc, const char* kind, const bool canFix = false)
{
bool needsFix;
void warnCxxCompat(const(char)* reason)
{
if (canFix)
{
needsFix = true;
return;
}
__gshared bool warned = false;
warning(loc, "%s `%s` is a %s", kind, ident.toChars(), reason);
if (!warned)
{
warningSupplemental(loc, "The generated C++ header will contain " ~
"identifiers that are keywords in C++");
warned = true;
}
}
if (global.params.warnings != DiagnosticReporting.off || canFix)
{
// Warn about identifiers that are keywords in C++.
if (auto kc = keywordClass(ident))
warnCxxCompat(kc);
}
buf.writestring(ident.toString());
if (needsFix)
buf.writeByte('_');
}
/// Checks whether `t` is a type that can be exported to C++
private bool isSupportedType(AST.Type t)
{
if (!t)
{
assert(tdparent);
return true;
}
switch (t.ty)
{
// Nested types
case AST.Tarray:
case AST.Tsarray:
case AST.Tpointer:
case AST.Treference:
case AST.Tdelegate:
return isSupportedType((cast(AST.TypeNext) t).next);
// Function pointers
case AST.Tfunction:
{
auto tf = cast(AST.TypeFunction) t;
if (!isSupportedType(tf.next))
return false;
foreach (_, param; tf.parameterList)
{
if (!isSupportedType(param.type))
return false;
}
return true;
}
// Noreturn has a different mangling
case AST.Tnoreturn:
// _Imaginary is C only.
case AST.Timaginary32:
case AST.Timaginary64:
case AST.Timaginary80:
return false;
default:
return true;
}
}
override void visit(AST.Dsymbol s)
{
debug (Debug_DtoH)
{
mixin(traceVisit!s);
import dmd.asttypename;
printf("[AST.Dsymbol enter] %s\n", s.astTypeName().ptr);
}
}
override void visit(AST.Import i)
{
debug (Debug_DtoH) mixin(traceVisit!i);
/// Writes `using <alias_> = <sym.ident>` into `buf`
const(char*) writeImport(AST.Dsymbol sym, const Identifier alias_)
{
/// `using` was introduced in C++ 11 and only works for types...
if (global.params.cplusplus < CppStdRevision.cpp11)
return "requires C++11";
if (auto ad = sym.isAliasDeclaration())
{
sym = ad.toAlias();
ad = sym.isAliasDeclaration();
// Might be an alias to a basic type
if (ad && !ad.aliassym && ad.type)
goto Emit;
}
// Restricted to types and other aliases
if (!sym.isScopeDsymbol() && !sym.isAggregateDeclaration())
return "only supports types";
// Write `using <alias_> = `<sym>`
Emit:
buf.writestring("using ");
writeIdentifier(alias_, i.loc, "renamed import");
buf.writestring(" = ");
// Start at module scope to avoid collisions with local symbols
if (this.context.adparent)
buf.writestring("::");
buf.writestring(sym.ident.toString());
writeDeclEnd();
return null;
}
// Only missing without semantic analysis
// FIXME: Templates need work due to missing parent & imported module
if (!i.parent)
{
assert(tdparent);
ignored("`%s` because it's inside of a template declaration", i.toChars());
return;
}
// Non-public imports don't create new symbols, include as needed
if (i.visibility.kind < AST.Visibility.Kind.public_)
return;
// Symbols from static imports should be emitted inline
if (i.isstatic)
return;
const isLocal = !i.parent.isModule();
// Need module for symbol lookup
assert(i.mod);
// Emit an alias for each public module member
if (isLocal && i.names.length == 0)
{
assert(i.mod.symtab);
// Sort alphabetically s.t. slight changes in semantic don't cause
// massive changes in the order of declarations
AST.Dsymbols entries;
entries.reserve(i.mod.symtab.length);
foreach (entry; i.mod.symtab.tab.asRange)
{
// Skip anonymous / invisible members
import dmd.access : symbolIsVisible;
if (!entry.key.isAnonymous() && symbolIsVisible(i, entry.value))
entries.push(entry.value);
}
// Seperate function because of a spurious dual-context deprecation
static int compare(const AST.Dsymbol* a, const AST.Dsymbol* b)
{
return strcmp(a.ident.toChars(), b.ident.toChars());
}
entries.sort!compare();
foreach (sym; entries)
{
includeSymbol(sym);
if (auto err = writeImport(sym, sym.ident))
ignored("public import for `%s` because `using` %s", sym.ident.toChars(), err);
}
return;
}
// Include all public imports and emit using declarations for each alias
foreach (const idx, name; i.names)
{
// Search the imported symbol
auto sym = i.mod.search(Loc.initial, name);
assert(sym); // Missing imports should error during semantic
includeSymbol(sym);
// Detect the assigned name for renamed import
auto alias_ = i.aliases[idx];
if (!alias_)
continue;
if (auto err = writeImport(sym, alias_))
ignored("renamed import `%s = %s` because `using` %s", alias_.toChars(), name.toChars(), err);
}
}
override void visit(AST.AttribDeclaration pd)
{
debug (Debug_DtoH) mixin(traceVisit!pd);
Dsymbols* decl = pd.include(null);
if (!decl)
return;
foreach (s; *decl)
{
if (adparent || s.visible().kind >= AST.Visibility.Kind.public_)
s.accept(this);
}
}
override void visit(AST.StorageClassDeclaration scd)
{
debug (Debug_DtoH) mixin(traceVisit!scd);
const stcStash = this.storageClass;
this.storageClass |= scd.stc;
visit(cast(AST.AttribDeclaration) scd);
this.storageClass = stcStash;
}
override void visit(AST.LinkDeclaration ld)
{
debug (Debug_DtoH) mixin(traceVisit!ld);
auto save = linkage;
linkage = ld.linkage;
visit(cast(AST.AttribDeclaration)ld);
linkage = save;
}
override void visit(AST.CPPMangleDeclaration md)
{
debug (Debug_DtoH) mixin(traceVisit!md);
const oldLinkage = this.linkage;
this.linkage = LINK.cpp;
visit(cast(AST.AttribDeclaration) md);
this.linkage = oldLinkage;
}
override void visit(AST.Module m)
{
debug (Debug_DtoH) mixin(traceVisit!m);
foreach (s; *m.members)
{
if (s.visible().kind < AST.Visibility.Kind.public_)
continue;
s.accept(this);
}
}
override void visit(AST.FuncDeclaration fd)
{
debug (Debug_DtoH) mixin(traceVisit!fd);
if (cast(void*)fd in visited)
return;
// printf("FuncDeclaration %s %s\n", fd.toPrettyChars(), fd.type.toChars());
visited[cast(void*)fd] = true;
// silently ignore non-user-defined destructors
if (fd.isGenerated && fd.isDtorDeclaration())
return;
// Note that tf might be null for templated (member) functions
auto tf = cast(AST.TypeFunction)fd.type;
if ((tf && (tf.linkage != LINK.c || adparent) && tf.linkage != LINK.cpp) || (!tf && fd.isPostBlitDeclaration()))
{
ignored("function %s because of linkage", fd.toPrettyChars());
return checkFunctionNeedsPlaceholder(fd);
}
if (fd.mangleOverride && tf && tf.linkage != LINK.c)
{
ignored("function %s because C++ doesn't support explicit mangling", fd.toPrettyChars());
return checkFunctionNeedsPlaceholder(fd);
}
if (!adparent && !fd.fbody)
{
ignored("function %s because it is extern", fd.toPrettyChars());
return;
}
if (fd.visibility.kind == AST.Visibility.Kind.none || fd.visibility.kind == AST.Visibility.Kind.private_)
{
ignored("function %s because it is private", fd.toPrettyChars());
return;
}
if (tf && !isSupportedType(tf.next))
{
ignored("function %s because its return type cannot be mapped to C++", fd.toPrettyChars());
return checkFunctionNeedsPlaceholder(fd);
}
if (tf) foreach (i, fparam; tf.parameterList)
{
if (!isSupportedType(fparam.type))
{
ignored("function %s because one of its parameters has type `%s` which cannot be mapped to C++",
fd.toPrettyChars(), fparam.type.toChars());
return checkFunctionNeedsPlaceholder(fd);
}
}
writeProtection(fd.visibility.kind);
if (tf && tf.linkage == LINK.c)
buf.writestring("extern \"C\" ");
else if (!adparent)
buf.writestring("extern ");
if (adparent && fd.isStatic())
buf.writestring("static ");
else if (adparent && (
// Virtual functions in non-templated classes
(fd.vtblIndex != -1 && !fd.isOverride()) ||
// Virtual functions in templated classes (fd.vtblIndex still -1)
(tdparent && adparent.isClassDeclaration() && !(this.storageClass & AST.STC.final_ || fd.isFinal))))
buf.writestring("virtual ");
debug (Debug_DtoH_Checks)
if (adparent && !tdparent)
{
auto s = adparent.search(Loc.initial, fd.ident);
auto cd = adparent.isClassDeclaration();
if (!(adparent.storage_class & AST.STC.abstract_) &&
!(cd && cd.isAbstract()) &&
s is fd && !fd.overnext)
{
const cn = adparent.ident.toChars();
const fn = fd.ident.toChars();
const vi = fd.vtblIndex;
checkbuf.printf("assert(getSlotNumber <%s>(0, &%s::%s) == %d);",
cn, cn, fn, vi);
checkbuf.writenl();
}
}
if (adparent && fd.isDisabled && global.params.cplusplus < CppStdRevision.cpp11)
writeProtection(AST.Visibility.Kind.private_);
funcToBuffer(tf, fd);
if (adparent)
{
if (tf && (tf.isConst() || tf.isImmutable()))
buf.writestring(" const");
if (global.params.cplusplus >= CppStdRevision.cpp11)
{
if (fd.vtblIndex != -1 && !(adparent.storage_class & AST.STC.final_) && fd.isFinalFunc())
buf.writestring(" final");
if (fd.isOverride())
buf.writestring(" override");
}
if (fd.isAbstract())
buf.writestring(" = 0");
else if (global.params.cplusplus >= CppStdRevision.cpp11 && fd.isDisabled())
buf.writestring(" = delete");
}
buf.writestringln(";");
if (adparent && fd.isDisabled && global.params.cplusplus < CppStdRevision.cpp11)
writeProtection(AST.Visibility.Kind.public_);
if (!adparent)
buf.writenl();
}
/++
+ Checks whether `fd` is a function that requires a dummy declaration
+ instead of simply emitting the declaration (because it would cause
+ ABI / behaviour issues). This includes:
+
+ - virtual functions to ensure proper vtable layout
+ - destructors that would break RAII
+/
private void checkFunctionNeedsPlaceholder(AST.FuncDeclaration fd)
{
// Omit redundant declarations - the slot was already
// reserved in the base class
if (fd.isVirtual() && fd.isIntroducing())
{
// Hide placeholders because they are not ABI compatible
writeProtection(AST.Visibility.Kind.private_);
__gshared int counter; // Ensure unique names in all cases
buf.printf("virtual void __vtable_slot_%u();", counter++);
buf.writenl();
}
else if (fd.isDtorDeclaration())
{
// Create inaccessible dtor to prevent code from keeping instances that
// need to be destroyed on the C++ side (but cannot call the dtor)
writeProtection(AST.Visibility.Kind.private_);
buf.writeByte('~');
buf.writestring(adparent.ident.toString());
buf.writestringln("();");
}
}
override void visit(AST.UnitTestDeclaration utd)
{
debug (Debug_DtoH) mixin(traceVisit!utd);
}
override void visit(AST.VarDeclaration vd)
{
debug (Debug_DtoH) mixin(traceVisit!vd);
if (!shouldEmitAndMarkVisited(vd))
return;
// Tuple field are expanded into multiple VarDeclarations
// (we'll visit them later)
if (vd.type && vd.type.isTypeTuple())
{
assert(vd.aliasTuple);
vd.toAlias().accept(this);
return;
}
if (vd.originalType && vd.type == AST.Type.tsize_t)
origType = vd.originalType;
scope(exit) origType = null;
if (!vd.alignment.isDefault() && !vd.alignment.isUnknown())
{
buf.printf("// Ignoring var %s alignment %d", vd.toChars(), vd.alignment.get());
buf.writenl();
}
// Determine the variable type which might be missing inside of
// template declarations. Infer the type from the initializer then
AST.Type type = vd.type;
if (!type)
{
assert(tdparent);
// Just a precaution, implicit type without initializer should be rejected
if (!vd._init)
return;
if (auto ei = vd._init.isExpInitializer())
type = ei.exp.type;
// Can happen if the expression needs further semantic
if (!type)
{
ignored("%s because the type could not be determined", vd.toPrettyChars());
return;
}
// Apply const/immutable to the inferred type
if (vd.storage_class & (AST.STC.const_ | AST.STC.immutable_))
type = type.constOf();
}
if (vd.storage_class & AST.STC.manifest)
{
EnumKind kind = getEnumKind(type);
if (vd.visibility.kind == AST.Visibility.Kind.none || vd.visibility.kind == AST.Visibility.Kind.private_) {
ignored("enum `%s` because it is `%s`.", vd.toPrettyChars(), AST.visibilityToChars(vd.visibility.kind));
return;
}
writeProtection(vd.visibility.kind);
final switch (kind)
{
case EnumKind.Int, EnumKind.Numeric:
// 'enum : type' is only available from C++-11 onwards.
if (global.params.cplusplus < CppStdRevision.cpp11)
goto case;
buf.writestring("enum : ");
determineEnumType(type).accept(this);
buf.writestring(" { ");
writeIdentifier(vd, true);
buf.writestring(" = ");
auto ie = AST.initializerToExpression(vd._init).isIntegerExp();
visitInteger(ie.toInteger(), type);
buf.writestring(" };");
break;
case EnumKind.String, EnumKind.Enum:
buf.writestring("static ");
auto target = determineEnumType(type);
target.accept(this);
buf.writestring(" const ");
writeIdentifier(vd, true);
buf.writestring(" = ");
auto e = AST.initializerToExpression(vd._init);
printExpressionFor(target, e);
buf.writestring(";");
break;
case EnumKind.Other:
ignored("enum `%s` because type `%s` is currently not supported for enum constants.", vd.toPrettyChars(), type.toChars());
return;
}
buf.writenl();
buf.writenl();
return;
}
if (vd.storage_class & (AST.STC.static_ | AST.STC.extern_ | AST.STC.gshared) ||
vd.parent && vd.parent.isModule())
{
const vdLinkage = vd.resolvedLinkage();
if (vdLinkage != LINK.c && vdLinkage != LINK.cpp && !(tdparent && (this.linkage == LINK.c || this.linkage == LINK.cpp)))
{
ignored("variable %s because of linkage", vd.toPrettyChars());
return;
}
if (vd.mangleOverride && vdLinkage != LINK.c)
{
ignored("variable %s because C++ doesn't support explicit mangling", vd.toPrettyChars());
return;
}
if (!isSupportedType(type))
{
ignored("variable %s because its type cannot be mapped to C++", vd.toPrettyChars());
return;
}
if (auto kc = keywordClass(vd.ident))
{
ignored("variable %s because its name is a %s", vd.toPrettyChars(), kc);
return;
}
writeProtection(vd.visibility.kind);
if (vdLinkage == LINK.c)
buf.writestring("extern \"C\" ");
else if (!adparent)
buf.writestring("extern ");
if (adparent)
buf.writestring("static ");
typeToBuffer(type, vd);
writeDeclEnd();
return;
}
if (adparent)
{
writeProtection(vd.visibility.kind);
typeToBuffer(type, vd, true);
buf.writestringln(";");
debug (Debug_DtoH_Checks)
{
checkbuf.level++;
const pn = adparent.ident.toChars();
const vn = vd.ident.toChars();
const vo = vd.offset;
checkbuf.printf("assert(offsetof(%s, %s) == %d);",
pn, vn, vo);
checkbuf.writenl();
checkbuf.level--;
}
return;
}
visit(cast(AST.Dsymbol)vd);
}
override void visit(AST.TypeInfoDeclaration tid)
{
debug (Debug_DtoH) mixin(traceVisit!tid);
}
override void visit(AST.AliasDeclaration ad)
{
debug (Debug_DtoH) mixin(traceVisit!ad);
if (!shouldEmitAndMarkVisited(ad))
return;
writeProtection(ad.visibility.kind);
if (auto t = ad.type)
{
if (t.ty == AST.Tdelegate || t.ty == AST.Tident)
{
visit(cast(AST.Dsymbol)ad);
return;
}
// for function pointers we need to original type
if (ad.originalType && ad.type.ty == AST.Tpointer &&
(cast(AST.TypePointer)t).nextOf.ty == AST.Tfunction)
{
origType = ad.originalType;
}
scope(exit) origType = null;
buf.writestring("typedef ");
typeToBuffer(origType !is null ? origType : t, ad);
writeDeclEnd();
return;
}
if (!ad.aliassym)
{
assert(0);
}
if (auto ti = ad.aliassym.isTemplateInstance())
{
visitTi(ti);
return;
}
if (auto sd = ad.aliassym.isStructDeclaration())
{
buf.writestring("typedef ");
sd.type.accept(this);
buf.writestring(" ");
writeIdentifier(ad);
writeDeclEnd();
return;
}
else if (auto td = ad.aliassym.isTemplateDeclaration())
{
if (global.params.cplusplus < CppStdRevision.cpp11)
{
ignored("%s because `using` declarations require C++ 11", ad.toPrettyChars());
return;
}
printTemplateParams(td);
buf.writestring("using ");
writeIdentifier(ad);
buf.writestring(" = ");
writeFullName(td);
buf.writeByte('<');
foreach (const idx, const p; *td.parameters)
{
if (idx)
buf.writestring(", ");
writeIdentifier(p.ident, p.loc, "parameter", true);
}
buf.writestringln(">;");
return;
}
auto fd = ad.aliassym.isFuncDeclaration();
if (fd && (fd.isGenerated() || fd.isDtorDeclaration()))
{
// Ignore. It's taken care of while visiting FuncDeclaration
return;
}
// Recognize member function aliases, e.g. alias visit = Parent.visit;
if (adparent && fd)
{
auto pd = fd.isMember();
if (!pd)
{
ignored("%s because free functions cannot be aliased in C++", ad.toPrettyChars());
}
else if (global.params.cplusplus < CppStdRevision.cpp11)
{
ignored("%s because `using` declarations require C++ 11", ad.toPrettyChars());
}
else if (ad.ident != fd.ident)
{
ignored("%s because `using` cannot rename functions in aggregates", ad.toPrettyChars());
}
else if (fd.toAliasFunc().parent.isTemplateMixin())
{
// Member's of template mixins are directly emitted into the aggregate
}
else
{
buf.writestring("using ");
// Print prefix of the base class if this function originates from a superclass
// because alias might be resolved through multiple classes, e.g.
// e.g. for alias visit = typeof(super).visit in the visitors
if (!fd.isIntroducing())
printPrefix(ad.toParent().isClassDeclaration().baseClass);
else
printPrefix(pd);
buf.writestring(fd.ident.toChars());
buf.writestringln(";");
}
return;
}
ignored("%s %s", ad.aliassym.kind(), ad.aliassym.toPrettyChars());
}
override void visit(AST.Nspace ns)
{
debug (Debug_DtoH) mixin(traceVisit!ns);
handleNspace(ns, ns.members);
}
override void visit(AST.CPPNamespaceDeclaration ns)
{
debug (Debug_DtoH) mixin(traceVisit!ns);
handleNspace(ns, ns.decl);
}
/// Writes the namespace declaration and visits all members
private void handleNspace(AST.Dsymbol namespace, Dsymbols* members)
{
buf.writestring("namespace ");
writeIdentifier(namespace);
buf.writenl();
buf.writestring("{");
buf.writenl();
buf.level++;
foreach(decl;(*members))
{
decl.accept(this);
}
buf.level--;
buf.writestring("}");
buf.writenl();
}
override void visit(AST.AnonDeclaration ad)
{
debug (Debug_DtoH) mixin(traceVisit!ad);
const anonStash = inAnonymousDecl;
inAnonymousDecl = true;
scope (exit) inAnonymousDecl = anonStash;
buf.writestringln(ad.isunion ? "union" : "struct");
buf.writestringln("{");
buf.level++;
foreach (s; *ad.decl)
{
s.accept(this);
}
buf.level--;
buf.writestringln("};");
}
private bool memberField(AST.VarDeclaration vd)
{
if (!vd.type || !vd.type.deco || !vd.ident)
return false;
if (!vd.isField())
return false;
if (vd.type.ty == AST.Tfunction)
return false;
if (vd.type.ty == AST.Tsarray)
return false;
return true;
}
override void visit(AST.StructDeclaration sd)
{
debug (Debug_DtoH) mixin(traceVisit!sd);
if (!shouldEmitAndMarkVisited(sd))
return;
const ignoredStash = this.ignoredCounter;
scope (exit) this.ignoredCounter = ignoredStash;
pushAlignToBuffer(sd.alignment);
writeProtection(sd.visibility.kind);
const structAsClass = sd.cppmangle == CPPMANGLE.asClass;
if (sd.isUnionDeclaration())
buf.writestring("union ");
else
buf.writestring(structAsClass ? "class " : "struct ");
writeIdentifier(sd);
if (!sd.members)
{
buf.writestringln(";");
buf.writenl();
return;
}
// D structs are always final
if (!sd.isUnionDeclaration())
buf.writestring(" final");
buf.writenl();
buf.writestring("{");
const protStash = this.currentVisibility;
this.currentVisibility = structAsClass ? AST.Visibility.Kind.private_ : AST.Visibility.Kind.public_;
scope (exit) this.currentVisibility = protStash;
buf.level++;
buf.writenl();
auto save = adparent;
adparent = sd;
foreach (m; *sd.members)
{
m.accept(this);
}
// Generate default ctor
if (!sd.noDefaultCtor && !sd.isUnionDeclaration())
{
writeProtection(AST.Visibility.Kind.public_);
buf.printf("%s()", sd.ident.toChars());
size_t varCount;
bool first = true;
buf.level++;
foreach (vd; sd.fields)
{
if (!memberField(vd) || vd.overlapped)
continue;
varCount++;
if (!vd._init && !vd.type.isTypeBasic() && !vd.type.isTypePointer && !vd.type.isTypeStruct &&
!vd.type.isTypeClass && !vd.type.isTypeDArray && !vd.type.isTypeSArray)
{
continue;
}
if (vd._init && vd._init.isVoidInitializer())
continue;
if (first)
{
buf.writestringln(" :");
first = false;
}
else
{
buf.writestringln(",");
}
writeIdentifier(vd, true);
buf.writeByte('(');
if (vd._init)
{
auto e = AST.initializerToExpression(vd._init);
printExpressionFor(vd.type, e, true);
}
buf.printf(")");
}
buf.level--;
buf.writenl();
buf.writestringln("{");
buf.writestringln("}");
auto ctor = sd.ctor ? sd.ctor.isFuncDeclaration() : null;
if (varCount && (!ctor || ctor.storage_class & AST.STC.disable))
{
buf.printf("%s(", sd.ident.toChars());
first = true;
foreach (vd; sd.fields)
{
if (!memberField(vd) || vd.overlapped)
continue;
if (!first)
buf.writestring(", ");
assert(vd.type);
assert(vd.ident);
typeToBuffer(vd.type, vd, true);
// Don't print default value for first parameter to not clash
// with the default ctor defined above
if (!first)
{
buf.writestring(" = ");
printExpressionFor(vd.type, findDefaultInitializer(vd));
}
first = false;
}
buf.writestring(") :");
buf.level++;
buf.writenl();
first = true;
foreach (vd; sd.fields)
{
if (!memberField(vd) || vd.overlapped)
continue;
if (first)
first = false;
else
buf.writestringln(",");
writeIdentifier(vd, true);
buf.writeByte('(');
writeIdentifier(vd, true);
buf.writeByte(')');
}
buf.writenl();
buf.writestringln("{}");
buf.level--;
}
}
buf.level--;
adparent = save;
buf.writestringln("};");
popAlignToBuffer(sd.alignment);
buf.writenl();
// Workaround because size triggers a forward-reference error
// for struct templates (the size is undetermined even if the
// size doesn't depend on the parameters)
debug (Debug_DtoH_Checks)
if (!tdparent)
{
checkbuf.level++;
const sn = sd.ident.toChars();
const sz = sd.size(Loc.initial);
checkbuf.printf("assert(sizeof(%s) == %llu);", sn, sz);
checkbuf.writenl();
checkbuf.level--;
}
}
/// Starts a custom alignment section using `#pragma pack` if
/// `alignment` specifies a custom alignment
private void pushAlignToBuffer(structalign_t alignment)
{
// DMD ensures alignment is a power of two
//assert(alignment > 0 && ((alignment & (alignment - 1)) == 0),
// "Invalid alignment size");
// When no alignment is specified, `uint.max` is the default
// FIXME: alignment is 0 for structs templated members
if (alignment.isDefault() || (tdparent && alignment.isUnknown()))
{
return;
}
buf.printf("#pragma pack(push, %d)", alignment.get());
buf.writenl();
}
/// Ends a custom alignment section using `#pragma pack` if
/// `alignment` specifies a custom alignment
private void popAlignToBuffer(structalign_t alignment)
{
if (alignment.isDefault() || (tdparent && alignment.isUnknown()))
return;
buf.writestringln("#pragma pack(pop)");
}
override void visit(AST.ClassDeclaration cd)
{
debug (Debug_DtoH) mixin(traceVisit!cd);
if (cd.baseClass && shouldEmit(cd))
includeSymbol(cd.baseClass);
if (!shouldEmitAndMarkVisited(cd))
return;
writeProtection(cd.visibility.kind);
const classAsStruct = cd.cppmangle == CPPMANGLE.asStruct;
buf.writestring(classAsStruct ? "struct " : "class ");
writeIdentifier(cd);
if (cd.storage_class & AST.STC.final_ || (tdparent && this.storageClass & AST.STC.final_))
buf.writestring(" final");
assert(cd.baseclasses);
foreach (i, base; *cd.baseclasses)
{
buf.writestring(i == 0 ? " : public " : ", public ");
// Base classes/interfaces might depend on template parameters,
// e.g. class A(T) : B!T { ... }
if (base.sym is null)
{
base.type.accept(this);
}
else
{
writeFullName(base.sym);
}
}
if (!cd.members)
{
buf.writestring(";");
buf.writenl();
buf.writenl();
return;
}
buf.writenl();
buf.writestringln("{");
const protStash = this.currentVisibility;
this.currentVisibility = classAsStruct ? AST.Visibility.Kind.public_ : AST.Visibility.Kind.private_;
scope (exit) this.currentVisibility = protStash;
auto save = adparent;
adparent = cd;
buf.level++;
foreach (m; *cd.members)
{
m.accept(this);
}
buf.level--;
adparent = save;
buf.writestringln("};");
buf.writenl();
}
override void visit(AST.EnumDeclaration ed)
{
debug (Debug_DtoH) mixin(traceVisit!ed);
if (!shouldEmitAndMarkVisited(ed))
return;
if (ed.isSpecial())
{
//ignored("%s because it is a special C++ type", ed.toPrettyChars());
return;
}
// we need to know a bunch of stuff about the enum...
bool isAnonymous = ed.ident is null;
const isOpaque = !ed.members;
AST.Type type = ed.memtype;
if (!type && !isOpaque)
{
// check all keys have matching type
foreach (_m; *ed.members)
{
auto m = _m.isEnumMember();
if (!type)
type = m.type;
else if (m.type !is type)
{
type = null;
break;
}
}
}
EnumKind kind = getEnumKind(type);
if (isOpaque)
{
// Opaque enums were introduced in C++ 11 (workaround?)
if (global.params.cplusplus < CppStdRevision.cpp11)
{
ignored("%s because opaque enums require C++ 11", ed.toPrettyChars());
return;
}
// Opaque enum defaults to int but the type might not be set
else if (!type)
{
kind = EnumKind.Int;
}
// Cannot apply namespace workaround for non-integral types
else if (kind != EnumKind.Int && kind != EnumKind.Numeric)
{
ignored("enum %s because of its base type", ed.toPrettyChars());
return;
}
}
// determine if this is an enum, or just a group of manifest constants
bool manifestConstants = !isOpaque && (!type || (isAnonymous && kind == EnumKind.Other));
assert(!manifestConstants || isAnonymous);
writeProtection(ed.visibility.kind);
// write the enum header
if (!manifestConstants)
{
if (kind == EnumKind.Int || kind == EnumKind.Numeric)
{
buf.writestring("enum");
// D enums are strong enums, but there exists only a direct mapping
// with 'enum class' from C++-11 onwards.
if (global.params.cplusplus >= CppStdRevision.cpp11)
{
if (!isAnonymous)
{
buf.writestring(" class ");
writeIdentifier(ed);
}
if (kind == EnumKind.Numeric)
{
buf.writestring(" : ");
determineEnumType(type).accept(this);
}
}
else if (!isAnonymous)
{
buf.writeByte(' ');
writeIdentifier(ed);
}
}
else
{
buf.writestring("namespace");
if(!isAnonymous)
{
buf.writeByte(' ');
writeIdentifier(ed);
}
}
// Opaque enums have no members, hence skip the body
if (isOpaque)
{
buf.writestringln(";");
return;
}
else
{
buf.writenl();
buf.writestringln("{");
}
}
// emit constant for each member
if (!manifestConstants)
buf.level++;
foreach (_m; *ed.members)
{
auto m = _m.isEnumMember();
AST.Type memberType = type ? type : m.type;
const EnumKind memberKind = type ? kind : getEnumKind(memberType);
if (!manifestConstants && (kind == EnumKind.Int || kind == EnumKind.Numeric))
{
// C++-98 compatible enums must use the typename as a prefix to avoid
// collisions with other identifiers in scope. For consistency with D,
// the enum member `Type.member` is emitted as `Type_member` in C++-98.
if (!isAnonymous && global.params.cplusplus < CppStdRevision.cpp11)
{
writeIdentifier(ed);
buf.writeByte('_');
}
writeIdentifier(m, true);
buf.writestring(" = ");
auto ie = cast(AST.IntegerExp)m.value;
visitInteger(ie.toInteger(), memberType);
buf.writestring(",");
}
else if (global.params.cplusplus >= CppStdRevision.cpp11 &&
manifestConstants && (memberKind == EnumKind.Int || memberKind == EnumKind.Numeric))
{
buf.writestring("enum : ");
determineEnumType(memberType).accept(this);
buf.writestring(" { ");
writeIdentifier(m, true);
buf.writestring(" = ");
auto ie = cast(AST.IntegerExp)m.value;
visitInteger(ie.toInteger(), memberType);
buf.writestring(" };");
}
else
{
buf.writestring("static ");
auto target = determineEnumType(memberType);
target.accept(this);
buf.writestring(" const ");
writeIdentifier(m, true);
buf.writestring(" = ");
printExpressionFor(target, m.origValue);
buf.writestring(";");
}
buf.writenl();
}
if (!manifestConstants)
buf.level--;
// write the enum tail
if (!manifestConstants)
buf.writestring("};");
buf.writenl();
buf.writenl();
}
override void visit(AST.EnumMember em)
{
assert(em.ed);
// Members of anonymous members are reachable without referencing the
// EnumDeclaration, e.g. public import foo : someEnumMember;
if (em.ed.isAnonymous())
{
visit(em.ed);
return;
}
assert(false, "This node type should be handled in the EnumDeclaration");
}
override void visit(AST.TupleDeclaration tup)
{
debug (Debug_DtoH) mixin(traceVisit!tup);
tup.foreachVar((s) { s.accept(this); });
}
/**
* Prints a member/parameter/variable declaration into `buf`.
*
* Params:
* t = the type (used if `this.origType` is null)
* s = the symbol denoting the identifier
* canFixup = whether the identifier may be changed without affecting
* binary compatibility (forwarded to `writeIdentifier`)
*/
private void typeToBuffer(AST.Type t, AST.Dsymbol s, const bool canFixup = false)
{
debug (Debug_DtoH)
{
printf("[typeToBuffer(AST.Type, AST.Dsymbol) enter] %s sym %s\n", t.toChars(), s.toChars());
scope(exit) printf("[typeToBuffer(AST.Type, AST.Dsymbol) exit] %s sym %s\n", t.toChars(), s.toChars());
}
// The context pointer (represented as `ThisDeclaration`) is named
// `this` but accessible via `outer`
if (auto td = s.isThisDeclaration())
{
import dmd.id;
this.ident = Id.outer;
}
else
this.ident = s.ident;
auto type = origType !is null ? origType : t;
AST.Dsymbol customLength;
// Check for quirks that are usually resolved during semantic
if (tdparent)
{
// Declarations within template declarations might use TypeAArray
// instead of TypeSArray when the length is not an IntegerExp,
// e.g. int[SOME_CONSTANT]
if (auto taa = type.isTypeAArray())
{
// Try to resolve the symbol from the key if it's not an actual type
Identifier id;
if (auto ti = taa.index.isTypeIdentifier())
id = ti.ident;
if (id)
{
auto sym = findSymbol(id, adparent ? adparent : tdparent);
if (!sym)
{
// Couldn't resolve, assume actual AA
}
else if (AST.isType(sym))
{
// a real associative array, forward to visit
}
else if (auto vd = sym.isVarDeclaration())
{
// Actually a static array with length symbol
customLength = sym;
type = taa.next; // visit the element type, length is written below
}
else
{
printf("Resolved unexpected symbol while determining static array length: %s\n", sym.toChars());
fflush(stdout);
fatal();
}
}
}
}
type.accept(this);
if (this.ident)
{
buf.writeByte(' ');
// Custom identifier doesn't need further checks
if (this.ident !is s.ident)
buf.writestring(this.ident.toString());
else
writeIdentifier(s, canFixup);
}
this.ident = null;
// Size is either taken from the type or resolved above
auto tsa = t.isTypeSArray();
if (tsa || customLength)
{
buf.writeByte('[');
if (tsa)
tsa.dim.accept(this);
else
writeFullName(customLength);
buf.writeByte(']');
}
else if (t.isTypeNoreturn())
buf.writestring("[0]");
}
override void visit(AST.Type t)
{
debug (Debug_DtoH) mixin(traceVisit!t);
printf("Invalid type: %s\n", t.toPrettyChars());
assert(0);
}
override void visit(AST.TypeNoreturn t)
{
debug (Debug_DtoH) mixin(traceVisit!t);
buf.writestring("/* noreturn */ char");
}
override void visit(AST.TypeIdentifier t)
{
debug (Debug_DtoH) mixin(traceVisit!t);
// Try to resolve the referenced symbol
if (auto sym = findSymbol(t.ident))
ensureDeclared(outermostSymbol(sym));
if (t.idents.length)
buf.writestring("typename ");
writeIdentifier(t.ident, t.loc, "type", tdparent !is null);
foreach (arg; t.idents)
{
buf.writestring("::");
import dmd.root.rootobject;
// Is this even possible?
if (arg.dyncast != DYNCAST.identifier)
{
printf("arg.dyncast() = %d\n", arg.dyncast());
assert(false);
}
buf.writestring((cast(Identifier) arg).toChars());
}
}
override void visit(AST.TypeNull t)
{
debug (Debug_DtoH) mixin(traceVisit!t);
if (global.params.cplusplus >= CppStdRevision.cpp11)
buf.writestring("nullptr_t");
else
buf.writestring("void*");
}
override void visit(AST.TypeTypeof t)
{
debug (Debug_DtoH) mixin(traceVisit!t);
assert(t.exp);
if (t.exp.type)
{
t.exp.type.accept(this);
}
else if (t.exp.isThisExp())
{
// Short circuit typeof(this) => <Aggregate name>
assert(adparent);
buf.writestring(adparent.ident.toChars());
}
else
{
// Relying on C++'s typeof might produce wrong results
// but it's the best we've got here.
buf.writestring("typeof(");
t.exp.accept(this);
buf.writeByte(')');
}
}
override void visit(AST.TypeBasic t)
{
debug (Debug_DtoH) mixin(traceVisit!t);
if (t.isConst() || t.isImmutable())
buf.writestring("const ");
string typeName;
switch (t.ty)
{
case AST.Tvoid: typeName = "void"; break;
case AST.Tbool: typeName = "bool"; break;
case AST.Tchar: typeName = "char"; break;
case AST.Twchar: typeName = "char16_t"; break;
case AST.Tdchar: typeName = "char32_t"; break;
case AST.Tint8: typeName = "int8_t"; break;
case AST.Tuns8: typeName = "uint8_t"; break;
case AST.Tint16: typeName = "int16_t"; break;
case AST.Tuns16: typeName = "uint16_t"; break;
case AST.Tint32: typeName = "int32_t"; break;
case AST.Tuns32: typeName = "uint32_t"; break;
case AST.Tint64: typeName = "int64_t"; break;
case AST.Tuns64: typeName = "uint64_t"; break;
case AST.Tfloat32: typeName = "float"; break;
case AST.Tfloat64: typeName = "double"; break;
case AST.Tfloat80:
typeName = "_d_real";
hasReal = true;
break;
case AST.Tcomplex32: typeName = "_Complex float"; break;
case AST.Tcomplex64: typeName = "_Complex double"; break;
case AST.Tcomplex80:
typeName = "_Complex _d_real";
hasReal = true;
break;
// ???: This is not strictly correct, but it should be ignored
// in all places where it matters most (variables, functions, ...).
case AST.Timaginary32: typeName = "float"; break;
case AST.Timaginary64: typeName = "double"; break;
case AST.Timaginary80:
typeName = "_d_real";
hasReal = true;
break;
default:
//t.print();
assert(0);
}
buf.writestring(typeName);
}
override void visit(AST.TypePointer t)
{
debug (Debug_DtoH) mixin(traceVisit!t);
auto ts = t.next.isTypeStruct();
if (ts && !strcmp(ts.sym.ident.toChars(), "__va_list_tag"))
{
buf.writestring("va_list");
return;
}
// Pointer targets can be forward referenced
const fwdSave = forwarding;
forwarding = true;
scope (exit) forwarding = fwdSave;
t.next.accept(this);
if (t.next.ty != AST.Tfunction)
buf.writeByte('*');
if (t.isConst() || t.isImmutable())
buf.writestring(" const");
}
override void visit(AST.TypeSArray t)
{
debug (Debug_DtoH) mixin(traceVisit!t);
t.next.accept(this);
}
override void visit(AST.TypeAArray t)
{
debug (Debug_DtoH) mixin(traceVisit!t);
AST.Type.tvoidptr.accept(this);
}
override void visit(AST.TypeFunction tf)
{
debug (Debug_DtoH) mixin(traceVisit!tf);
tf.next.accept(this);
buf.writeByte('(');
buf.writeByte('*');
if (ident)
buf.writestring(ident.toChars());
ident = null;
buf.writeByte(')');
buf.writeByte('(');
foreach (i, fparam; tf.parameterList)
{
if (i)
buf.writestring(", ");
fparam.accept(this);
}
if (tf.parameterList.varargs)
{
if (tf.parameterList.parameters.length && tf.parameterList.varargs == 1)
buf.writestring(", ");
buf.writestring("...");
}
buf.writeByte(')');
}
/// Writes the type that represents `ed` into `buf`.
/// (Might not be `ed` for special enums or enums that were emitted as namespaces)
private void enumToBuffer(AST.EnumDeclaration ed)
{
debug (Debug_DtoH) mixin(traceVisit!ed);
if (ed.isSpecial())
{
if (ed.ident == DMDType.c_long)
buf.writestring("long");
else if (ed.ident == DMDType.c_ulong)
buf.writestring("unsigned long");
else if (ed.ident == DMDType.c_longlong)
buf.writestring("long long");
else if (ed.ident == DMDType.c_ulonglong)
buf.writestring("unsigned long long");
else if (ed.ident == DMDType.c_long_double)
buf.writestring("long double");
else if (ed.ident == DMDType.c_char)
buf.writestring("char");
else if (ed.ident == DMDType.c_wchar_t)
buf.writestring("wchar_t");
else if (ed.ident == DMDType.c_complex_float)
buf.writestring("_Complex float");
else if (ed.ident == DMDType.c_complex_double)
buf.writestring("_Complex double");
else if (ed.ident == DMDType.c_complex_real)
buf.writestring("_Complex long double");
else
{
//ed.print();
assert(0);
}
return;
}
const kind = getEnumKind(ed.memtype);
// Check if the enum was emitted as a real enum
if (kind == EnumKind.Int || kind == EnumKind.Numeric)
{
writeFullName(ed);
}
else
{
// Use the base type if the enum was emitted as a namespace
buf.printf("/* %s */ ", ed.ident.toChars());
ed.memtype.accept(this);
}
}
override void visit(AST.TypeEnum t)
{
debug (Debug_DtoH) mixin(traceVisit!t);
if (t.isConst() || t.isImmutable())
buf.writestring("const ");
enumToBuffer(t.sym);
}
override void visit(AST.TypeStruct t)
{
debug (Debug_DtoH) mixin(traceVisit!t);
if (t.isConst() || t.isImmutable())
buf.writestring("const ");
writeFullName(t.sym);
}
override void visit(AST.TypeDArray t)
{
debug (Debug_DtoH) mixin(traceVisit!t);
if (t.isConst() || t.isImmutable())
buf.writestring("const ");
buf.writestring("_d_dynamicArray< ");
t.next.accept(this);
buf.writestring(" >");
}
override void visit(AST.TypeInstance t)
{
visitTi(t.tempinst);
}
private void visitTi(AST.TemplateInstance ti)
{
debug (Debug_DtoH) mixin(traceVisit!ti);
// Ensure that the TD appears before the instance
if (auto td = findTemplateDeclaration(ti))
ensureDeclared(td);
foreach (o; *ti.tiargs)
{
if (!AST.isType(o))
return;
}
buf.writestring(ti.name.toChars());
buf.writeByte('<');
foreach (i, o; *ti.tiargs)
{
if (i)
buf.writestring(", ");
if (auto tt = AST.isType(o))
{
tt.accept(this);
}
else
{
//ti.print();
//o.print();
assert(0);
}
}
buf.writestring(" >");
}
override void visit(AST.TemplateDeclaration td)
{
debug (Debug_DtoH) mixin(traceVisit!td);
if (!shouldEmitAndMarkVisited(td))
return;
if (!td.parameters || !td.onemember || (!td.onemember.isStructDeclaration && !td.onemember.isClassDeclaration && !td.onemember.isFuncDeclaration))
{
visit(cast(AST.Dsymbol)td);
return;
}
// Explicitly disallow templates with non-type parameters or specialization.
foreach (p; *td.parameters)
{
if (!p.isTemplateTypeParameter() || p.specialization())
{
visit(cast(AST.Dsymbol)td);
return;
}
}
auto save = tdparent;
tdparent = td;
const bookmark = buf.length;
printTemplateParams(td);
const oldIgnored = this.ignoredCounter;
td.onemember.accept(this);
// Remove "template<...>" if the symbol could not be emitted
if (oldIgnored != this.ignoredCounter)
buf.setsize(bookmark);
tdparent = save;
}
/// Writes the template<...> header for the supplied template declaration
private void printTemplateParams(const AST.TemplateDeclaration td)
{
buf.writestring("template <");
bool first = true;
foreach (p; *td.parameters)
{
if (first)
first = false;
else
buf.writestring(", ");
buf.writestring("typename ");
writeIdentifier(p.ident, p.loc, "template parameter", true);
}
buf.writestringln(">");
}
/// Emit declarations of the TemplateMixin in the current scope
override void visit(AST.TemplateMixin tm)
{
debug (Debug_DtoH) mixin(traceVisit!tm);
auto members = tm.members;
// members are missing for instances inside of TemplateDeclarations, e.g.
// template Foo(T) { mixin Bar!T; }
if (!members)
{
if (auto td = findTemplateDeclaration(tm))
members = td.members; // Emit members of the template
else
return; // Cannot emit mixin
}
foreach (s; *members)
{
// kind is undefined without semantic
const kind = s.visible().kind;
if (kind == AST.Visibility.Kind.public_ || kind == AST.Visibility.Kind.undefined)
s.accept(this);
}
}
/**
* Finds a symbol with the identifier `name` by iterating the linked list of parent
* symbols, starting from `context`.
*
* Returns: the symbol or `null` if missing
*/
private AST.Dsymbol findSymbol(Identifier name, AST.Dsymbol context)
{
// Follow the declaration context
for (auto par = context; par; par = par.toParentDecl())
{
// Check that `name` doesn't refer to a template parameter
if (auto td = par.isTemplateDeclaration())
{
foreach (const p; *td.parameters)
{
if (p.ident == name)
return null;
}
}
if (auto mem = findMember(par, name))
{
return mem;
}
}
return null;
}
/// ditto
private AST.Dsymbol findSymbol(Identifier name)
{
AST.Dsymbol sym;
if (adparent)
sym = findSymbol(name, adparent);
if (!sym && tdparent)
sym = findSymbol(name, tdparent);
return sym;
}
/// Finds the template declaration for instance `ti`
private AST.TemplateDeclaration findTemplateDeclaration(AST.TemplateInstance ti)
{
if (ti.tempdecl)
return ti.tempdecl.isTemplateDeclaration();
assert(tdparent); // Only missing inside of templates
// Search for the TemplateDeclaration, starting from the enclosing scope
// if known or the enclosing template.
auto sym = findSymbol(ti.name, ti.parent ? ti.parent : tdparent);
return sym ? sym.isTemplateDeclaration() : null;
}
override void visit(AST.TypeClass t)
{
debug (Debug_DtoH) mixin(traceVisit!t);
// Classes are emitted as pointer and hence can be forwarded
const fwdSave = forwarding;
forwarding = true;
scope (exit) forwarding = fwdSave;
if (t.isConst() || t.isImmutable())
buf.writestring("const ");
writeFullName(t.sym);
buf.writeByte('*');
if (t.isConst() || t.isImmutable())
buf.writestring(" const");
}
/**
* Writes the function signature to `buf`.
*
* Params:
* fd = the function to print
* tf = fd's type
*/
private void funcToBuffer(AST.TypeFunction tf, AST.FuncDeclaration fd)
{
debug (Debug_DtoH)
{
printf("[funcToBuffer(AST.TypeFunction) enter] %s\n", fd.toChars());
scope(exit) printf("[funcToBuffer(AST.TypeFunction) exit] %s\n", fd.toChars());
}
auto originalType = cast(AST.TypeFunction)fd.originalType;
if (fd.isCtorDeclaration() || fd.isDtorDeclaration())
{
if (fd.isDtorDeclaration())
{
buf.writeByte('~');
}
buf.writestring(adparent.toChars());
if (!tf)
{
assert(fd.isDtorDeclaration());
buf.writestring("()");
return;
}
}
else
{
import dmd.root.string : toDString;
assert(tf.next, fd.loc.toChars().toDString());
tf.next == AST.Type.tsize_t ? originalType.next.accept(this) : tf.next.accept(this);
if (tf.isref)
buf.writeByte('&');
buf.writeByte(' ');
writeIdentifier(fd);
}
buf.writeByte('(');
foreach (i, fparam; tf.parameterList)
{
if (i)
buf.writestring(", ");
if (fparam.type == AST.Type.tsize_t && originalType)
{
fparam = originalType.parameterList[i];
}
fparam.accept(this);
}
if (tf.parameterList.varargs)
{
if (tf.parameterList.parameters.length && tf.parameterList.varargs == 1)
buf.writestring(", ");
buf.writestring("...");
}
buf.writeByte(')');
}
override void visit(AST.Parameter p)
{
debug (Debug_DtoH) mixin(traceVisit!p);
ident = p.ident;
{
// Reference parameters can be forwarded
const fwdStash = this.forwarding;
this.forwarding = !!(p.storageClass & AST.STC.ref_);
p.type.accept(this);
this.forwarding = fwdStash;
}
if (p.storageClass & (AST.STC.ref_ | AST.STC.out_))
buf.writeByte('&');
buf.writeByte(' ');
if (ident)
// FIXME: Parameter is missing a Loc
writeIdentifier(ident, Loc.initial, "parameter", true);
ident = null;
if (p.defaultArg)
{
//printf("%s %d\n", p.defaultArg.toChars, p.defaultArg.op);
buf.writestring(" = ");
printExpressionFor(p.type, p.defaultArg);
}
}
/**
* Prints `exp` as an expression of type `target` while inserting
* appropriate code when implicit conversion does not translate
* directly to C++, e.g. from an enum to its base type.
*
* Params:
* target = the type `exp` is converted to
* exp = the expression to print
* isCtor = if `exp` is a ctor argument
*/
private void printExpressionFor(AST.Type target, AST.Expression exp, const bool isCtor = false)
{
/// Determines if a static_cast is required
static bool needsCast(AST.Type target, AST.Expression exp)
{
// import std.stdio;
// writefln("%s:%s: target = %s, type = %s (%s)", exp.loc.linnum, exp.loc.charnum, target, exp.type, exp.op);
auto source = exp.type;
// DotVarExp resolve conversions, e.g from an enum to its base type
if (auto dve = exp.isDotVarExp())
source = dve.var.type;
if (!source)
// Defensively assume that the cast is required
return true;
// Conversions from enum class to base type require static_cast
if (global.params.cplusplus >= CppStdRevision.cpp11 &&
source.isTypeEnum && !target.isTypeEnum)
return true;
return false;
}
// Slices are emitted as a special struct, hence we need to fix up
// any expression initialising a slice variable/member
if (auto ta = target.isTypeDArray())
{
if (exp.isNullExp())
{
if (isCtor)
{
// Don't emit, use default ctor
}
else if (global.params.cplusplus >= CppStdRevision.cpp11)
{
// Prefer initializer list
buf.writestring("{}");
}
else
{
// Write __d_dynamic_array<TYPE>()
visit(ta);
buf.writestring("()");
}
return;
}
if (auto se = exp.isStringExp())
{
// Rewrite as <length> + <literal> pair optionally
// wrapped in a initializer list/ctor call
const initList = global.params.cplusplus >= CppStdRevision.cpp11;
if (!isCtor)
{
if (initList)
buf.writestring("{ ");
else
{
visit(ta);
buf.writestring("( ");
}
}
buf.printf("%zu, ", se.len);
visit(se);
if (!isCtor)
buf.writestring(initList ? " }" : " )");
return;
}
}
else if (auto ce = exp.isCastExp())
{
buf.writeByte('(');
if (ce.to)
ce.to.accept(this);
else if (ce.e1.type)
// Try the expression type with modifiers in case of cast(const) in templates
ce.e1.type.castMod(ce.mod).accept(this);
else
// Fallback, not necessarily correct but the best we've got here
target.accept(this);
buf.writestring(") ");
ce.e1.accept(this);
}
else if (needsCast(target, exp))
{
buf.writestring("static_cast<");
target.accept(this);
buf.writestring(">(");
exp.accept(this);
buf.writeByte(')');
}
else
{
exp.accept(this);
}
}
override void visit(AST.Expression e)
{
debug (Debug_DtoH) mixin(traceVisit!e);
// Valid in most cases, others should be overriden below
// to use the appropriate operators (:: and ->)
buf.writestring(e.toString());
}
override void visit(AST.UnaExp e)
{
debug (Debug_DtoH) mixin(traceVisit!e);
buf.writestring(expToString(e.op));
e.e1.accept(this);
}
override void visit(AST.BinExp e)
{
debug (Debug_DtoH) mixin(traceVisit!e);
e.e1.accept(this);
buf.writeByte(' ');
buf.writestring(expToString(e.op));
buf.writeByte(' ');
e.e2.accept(this);
}
/// Translates operator `op` into the C++ representation
private extern(D) static string expToString(const EXP op)
{
switch (op) with (EXP)
{
case identity: return "==";
case notIdentity: return "!=";
default:
return EXPtoString(op);
}
}
override void visit(AST.VarExp e)
{
debug (Debug_DtoH) mixin(traceVisit!e);
// Local members don't need another prefix and might've been renamed
if (e.var.isThis())
{
includeSymbol(e.var);
writeIdentifier(e.var, true);
}
else
writeFullName(e.var);
}
/// Partially prints the FQN including parent aggregates
private void printPrefix(AST.Dsymbol var)
{
if (!var || var is adparent || var.isModule())
return;
writeFullName(var);
buf.writestring("::");
}
override void visit(AST.CallExp e)
{
debug (Debug_DtoH) mixin(traceVisit!e);
// Dereferencing function pointers requires additional braces: (*f)(args)
const isFp = e.e1.isPtrExp();
if (isFp)
buf.writeByte('(');
else if (e.f)
includeSymbol(outermostSymbol(e.f));
e.e1.accept(this);
if (isFp) buf.writeByte(')');
assert(e.arguments);
buf.writeByte('(');
foreach (i, arg; *e.arguments)
{
if (i)
buf.writestring(", ");
arg.accept(this);
}
buf.writeByte(')');
}
override void visit(AST.DotVarExp e)
{
debug (Debug_DtoH) mixin(traceVisit!e);
if (auto sym = symbolFromType(e.e1.type))
includeSymbol(outermostSymbol(sym));
// Accessing members through a pointer?
if (auto pe = e.e1.isPtrExp)
{
pe.e1.accept(this);
buf.writestring("->");
}
else
{
e.e1.accept(this);
buf.writeByte('.');
}
// Should only be used to access non-static members
assert(e.var.isThis());
writeIdentifier(e.var, true);
}
override void visit(AST.DotIdExp e)
{
debug (Debug_DtoH) mixin(traceVisit!e);
e.e1.accept(this);
buf.writestring("::");
buf.writestring(e.ident.toChars());
}
override void visit(AST.ScopeExp e)
{
debug (Debug_DtoH) mixin(traceVisit!e);
// Usually a template instance in a TemplateDeclaration
if (auto ti = e.sds.isTemplateInstance())
visitTi(ti);
else
writeFullName(e.sds);
}
override void visit(AST.NullExp e)
{
debug (Debug_DtoH) mixin(traceVisit!e);
if (global.params.cplusplus >= CppStdRevision.cpp11)
buf.writestring("nullptr");
else
buf.writestring("NULL");
}
override void visit(AST.ArrayLiteralExp e)
{
debug (Debug_DtoH) mixin(traceVisit!e);
buf.writestring("arrayliteral");
}
override void visit(AST.StringExp e)
{
debug (Debug_DtoH) mixin(traceVisit!e);
if (e.sz == 2)
buf.writeByte('u');
else if (e.sz == 4)
buf.writeByte('U');
buf.writeByte('"');
foreach (i; 0 .. e.len)
{
writeCharLiteral(*buf, e.getCodeUnit(i));
}
buf.writeByte('"');
}
override void visit(AST.RealExp e)
{
debug (Debug_DtoH) mixin(traceVisit!e);
import dmd.root.ctfloat : CTFloat;
// Special case NaN and Infinity because floatToBuffer
// uses D literals (`nan` and `infinity`)
if (CTFloat.isNaN(e.value))
{
buf.writestring("NAN");
}
else if (CTFloat.isInfinity(e.value))
{
if (e.value < CTFloat.zero)
buf.writeByte('-');
buf.writestring("INFINITY");
}
else
{
import dmd.hdrgen;
// Hex floating point literals were introduced in C++ 17
const allowHex = global.params.cplusplus >= CppStdRevision.cpp17;
floatToBuffer(e.type, e.value, buf, allowHex);
}
}
override void visit(AST.IntegerExp e)
{
debug (Debug_DtoH) mixin(traceVisit!e);
visitInteger(e.toInteger, e.type);
}
/// Writes `v` as type `t` into `buf`
private void visitInteger(dinteger_t v, AST.Type t)
{
debug (Debug_DtoH) mixin(traceVisit!t);
switch (t.ty)
{
case AST.Tenum:
auto te = cast(AST.TypeEnum)t;
buf.writestring("(");
enumToBuffer(te.sym);
buf.writestring(")");
visitInteger(v, te.sym.memtype);
break;
case AST.Tbool:
buf.writestring(v ? "true" : "false");
break;
case AST.Tint8:
buf.printf("%d", cast(byte)v);
break;
case AST.Tuns8:
buf.printf("%uu", cast(ubyte)v);
break;
case AST.Tint16:
buf.printf("%d", cast(short)v);
break;
case AST.Tuns16:
case AST.Twchar:
buf.printf("%uu", cast(ushort)v);
break;
case AST.Tint32:
case AST.Tdchar:
buf.printf("%d", cast(int)v);
break;
case AST.Tuns32:
buf.printf("%uu", cast(uint)v);
break;
case AST.Tint64:
buf.printf("%lldLL", v);
break;
case AST.Tuns64:
buf.printf("%lluLLU", v);
break;
case AST.Tchar:
if (v > 0x20 && v < 0x80)
buf.printf("'%c'", cast(int)v);
else
buf.printf("%uu", cast(ubyte)v);
break;
default:
//t.print();
assert(0);
}
}
override void visit(AST.StructLiteralExp sle)
{
debug (Debug_DtoH) mixin(traceVisit!sle);
const isUnion = sle.sd.isUnionDeclaration();
sle.sd.type.accept(this);
buf.writeByte('(');
foreach(i, e; *sle.elements)
{
if (i)
buf.writestring(", ");
auto vd = sle.sd.fields[i];
// Expression may be null for unspecified elements
if (!e)
e = findDefaultInitializer(vd);
printExpressionFor(vd.type, e);
// Only emit the initializer of the first union member
if (isUnion)
break;
}
buf.writeByte(')');
}
/// Finds the default initializer for the given VarDeclaration
private static AST.Expression findDefaultInitializer(AST.VarDeclaration vd)
{
if (vd._init && !vd._init.isVoidInitializer())
return AST.initializerToExpression(vd._init);
else if (auto ts = vd.type.isTypeStruct())
{
if (!ts.sym.noDefaultCtor && !ts.sym.isUnionDeclaration())
{
// Generate a call to the default constructor that we've generated.
auto sle = new AST.StructLiteralExp(Loc.initial, ts.sym, new AST.Expressions(0));
sle.type = vd.type;
return sle;
}
else
return vd.type.defaultInitLiteral(Loc.initial);
}
else
return vd.type.defaultInitLiteral(Loc.initial);
}
static if (__VERSION__ < 2092)
{
private void ignored(const char* format, ...) nothrow
{
this.ignoredCounter++;
import core.stdc.stdarg;
if (!printIgnored)
return;
va_list ap;
va_start(ap, format);
buf.writestring("// Ignored ");
buf.vprintf(format, ap);
buf.writenl();
va_end(ap);
}
}
else
{
/// Writes a formatted message into `buf` if `printIgnored` is true
/// and increments `ignoredCounter`
pragma(printf)
private void ignored(const char* format, ...) nothrow
{
this.ignoredCounter++;
import core.stdc.stdarg;
if (!printIgnored)
return;
va_list ap;
va_start(ap, format);
buf.writestring("// Ignored ");
buf.vprintf(format, ap);
buf.writenl();
va_end(ap);
}
}
/**
* Determines whether `s` should be emitted. This requires that `sym`
* - is `extern(C[++]`)
* - is not instantiated from a template (visits the `TemplateDeclaration` instead)
*
* Params:
* sym = the symbol
*
* Returns: whether `sym` should be emitted
*/
private bool shouldEmit(AST.Dsymbol sym)
{
import dmd.aggregate : ClassKind;
debug (Debug_DtoH)
{
printf("[shouldEmitAndMarkVisited enter] %s\n", sym.toPrettyChars());
scope(exit) printf("[shouldEmitAndMarkVisited exit] %s\n", sym.toPrettyChars());
}
// Template *instances* should not be emitted
if (sym.isInstantiated())
return false;
// Matching linkage (except extern(C) classes which don't make sense)
if (linkage == LINK.cpp || (linkage == LINK.c && !sym.isClassDeclaration()))
return true;
// Check against the internal information which might be missing, e.g. inside of template declarations
if (auto dec = sym.isDeclaration())
{
const l = dec.resolvedLinkage();
return l == LINK.cpp || l == LINK.c;
}
if (auto ad = sym.isAggregateDeclaration())
return ad.classKind == ClassKind.cpp;
return false;
}
/**
* Determines whether `s` should be emitted. This requires that `sym`
* - was not visited before
* - is `extern(C[++]`)
* - is not instantiated from a template (visits the `TemplateDeclaration` instead)
* The result is cached in the visited nodes array.
*
* Params:
* sym = the symbol
*
* Returns: whether `sym` should be emitted
**/
private bool shouldEmitAndMarkVisited(AST.Dsymbol sym)
{
debug (Debug_DtoH)
{
printf("[shouldEmitAndMarkVisited enter] %s\n", sym.toPrettyChars());
scope(exit) printf("[shouldEmitAndMarkVisited exit] %s\n", sym.toPrettyChars());
}
auto statePtr = (cast(void*) sym) in visited;
// `sym` was already emitted or skipped and isn't required
if (statePtr && (*statePtr || !mustEmit))
return false;
// Template *instances* should not be emitted, forward to the declaration
if (auto ti = sym.isInstantiated())
{
auto td = findTemplateDeclaration(ti);
assert(td);
visit(td);
return false;
}
// Required or matching linkage (except extern(C) classes which don't make sense)
bool res = mustEmit || linkage == LINK.cpp || (linkage == LINK.c && !sym.isClassDeclaration());
if (!res)
{
// Check against the internal information which might be missing, e.g. inside of template declarations
if (auto dec = sym.isDeclaration())
{
const l = dec.resolvedLinkage();
res = (l == LINK.cpp || l == LINK.c);
}
}
// Remember result for later calls
if (statePtr)
*statePtr = res;
else
visited[(cast(void*) sym)] = res;
// Print a warning when the symbol is ignored for the first time
// Might not be correct if it is required by symbol the is visited
// AFTER the current node
if (!statePtr && !res)
ignored("%s %s because of linkage", sym.kind(), sym.toPrettyChars());
return res;
}
/**
* Ensures that `sym` is declared before the current position in `buf` by
* either creating a forward reference in `fwdbuf` if possible or
* calling `includeSymbol` to emit the entire declaration into `donebuf`.
*/
private void ensureDeclared(AST.Dsymbol sym)
{
auto par = sym.toParent2();
auto ed = sym.isEnumDeclaration();
// Eagerly include the symbol if we cannot create a valid forward declaration
// Forwarding of scoped enums requires C++11 or above
if (!forwarding || (par && !par.isModule()) || (ed && global.params.cplusplus < CppStdRevision.cpp11))
{
// Emit the entire enclosing declaration if any
includeSymbol(outermostSymbol(sym));
return;
}
auto ti = sym.isInstantiated();
auto td = ti ? findTemplateDeclaration(ti) : null;
auto check = cast(void*) (td ? td : sym);
// Omit redundant fwd-declaration if we already emitted the entire declaration
if (visited.get(check, false))
return;
// Already created a fwd-declaration?
if (check in forwarded)
return;
forwarded[check] = true;
// Print template<...>
if (ti)
{
auto bufSave = buf;
buf = fwdbuf;
printTemplateParams(td);
buf = bufSave;
}
// Determine the kind of symbol that is forwared: struct, ...
const(char)* kind;
if (auto ad = sym.isAggregateDeclaration())
{
// Look for extern(C++, class) <some aggregate>
if (ad.cppmangle == CPPMANGLE.def)
kind = ad.kind();
else if (ad.cppmangle == CPPMANGLE.asStruct)
kind = "struct";
else
kind = "class";
}
else if (ed)
{
// Only called from enumToBuffer, so should always be emitted as an actual enum
kind = "enum class";
}
else
kind = sym.kind(); // Should be unreachable but just to be sure
fwdbuf.writestring(kind);
fwdbuf.writeByte(' ');
fwdbuf.writestring(sym.toChars());
fwdbuf.writestringln(";");
}
/**
* Writes the qualified name of `sym` into `buf` including parent
* symbols and template parameters.
*
* Params:
* sym = the symbol
* mustInclude = whether sym may not be forward declared
*/
private void writeFullName(AST.Dsymbol sym, const bool mustInclude = false)
in
{
assert(sym);
assert(sym.ident, sym.toString());
// Should never be called directly with a TI, only onemember
assert(!sym.isTemplateInstance(), sym.toString());
}
do
{
debug (Debug_DtoH)
{
printf("[writeFullName enter] %s\n", sym.toPrettyChars());
scope(exit) printf("[writeFullName exit] %s\n", sym.toPrettyChars());
}
// Explicit `pragma(mangle, "<some string>` overrides the declared name
if (auto mn = getMangleOverride(sym))
return buf.writestring(mn);
/// Checks whether `sym` is nested in `par` and hence doesn't need the FQN
static bool isNestedIn(AST.Dsymbol sym, AST.Dsymbol par)
{
while (par)
{
if (sym is par)
return true;
par = par.toParent();
}
return false;
}
AST.TemplateInstance ti;
bool nested;
// Check if the `sym` is nested into another symbol and hence requires `Parent::sym`
if (auto par = sym.toParent())
{
// toParent() yields the template instance if `sym` is the onemember of a TI
ti = par.isTemplateInstance();
// Skip the TI because Foo!int.Foo is folded into Foo<int>
if (ti) par = ti.toParent();
// Prefix the name with any enclosing declaration
// Stop at either module or enclosing aggregate
nested = !par.isModule();
if (nested && !isNestedIn(par, adparent))
{
writeFullName(par, true);
buf.writestring("::");
}
}
if (!nested)
{
// Cannot forward the symbol when called recursively
// for a nested symbol
if (mustInclude)
includeSymbol(sym);
else
ensureDeclared(sym);
}
if (ti)
visitTi(ti);
else
buf.writestring(sym.ident.toString());
}
/// Returns: Explicit mangling for `sym` if present
extern(D) static const(char)[] getMangleOverride(const AST.Dsymbol sym)
{
if (auto decl = sym.isDeclaration())
return decl.mangleOverride;
return null;
}
}
/// Namespace for identifiers used to represent special enums in C++
struct DMDType
{
__gshared Identifier c_long;
__gshared Identifier c_ulong;
__gshared Identifier c_longlong;
__gshared Identifier c_ulonglong;
__gshared Identifier c_long_double;
__gshared Identifier c_char;
__gshared Identifier c_wchar_t;
__gshared Identifier c_complex_float;
__gshared Identifier c_complex_double;
__gshared Identifier c_complex_real;
static void _init()
{
c_long = Identifier.idPool("__c_long");
c_ulong = Identifier.idPool("__c_ulong");
c_longlong = Identifier.idPool("__c_longlong");
c_ulonglong = Identifier.idPool("__c_ulonglong");
c_long_double = Identifier.idPool("__c_long_double");
c_wchar_t = Identifier.idPool("__c_wchar_t");
c_char = Identifier.idPool("__c_char");
c_complex_float = Identifier.idPool("__c_complex_float");
c_complex_double = Identifier.idPool("__c_complex_double");
c_complex_real = Identifier.idPool("__c_complex_real");
}
}
/// Initializes all data structures used by the header generator
void initialize()
{
__gshared bool initialized;
if (!initialized)
{
initialized = true;
DMDType._init();
}
}
/// Writes `#if <content>` into the supplied buffer
void hashIf(ref OutBuffer buf, string content)
{
buf.writestring("#if ");
buf.writestringln(content);
}
/// Writes `#elif <content>` into the supplied buffer
void hashElIf(ref OutBuffer buf, string content)
{
buf.writestring("#elif ");
buf.writestringln(content);
}
/// Writes `#endif` into the supplied buffer
void hashEndIf(ref OutBuffer buf)
{
buf.writestringln("#endif");
}
/// Writes `#define <content>` into the supplied buffer
void hashDefine(ref OutBuffer buf, string content)
{
buf.writestring("#define ");
buf.writestringln(content);
}
/// Writes `#include <content>` into the supplied buffer
void hashInclude(ref OutBuffer buf, string content)
{
buf.writestring("#include ");
buf.writestringln(content);
}
/// Determines whether `ident` is a reserved keyword in C++
/// Returns: the kind of keyword or `null`
const(char*) keywordClass(const Identifier ident)
{
if (!ident)
return null;
const name = ident.toString();
switch (name)
{
// C++ operators
case "and":
case "and_eq":
case "bitand":
case "bitor":
case "compl":
case "not":
case "not_eq":
case "or":
case "or_eq":
case "xor":
case "xor_eq":
return "special operator in C++";
// C++ keywords
case "_Complex":
case "const_cast":
case "delete":
case "dynamic_cast":
case "explicit":
case "friend":
case "inline":
case "mutable":
case "namespace":
case "operator":
case "register":
case "reinterpret_cast":
case "signed":
case "static_cast":
case "typedef":
case "typename":
case "unsigned":
case "using":
case "virtual":
case "volatile":
return "keyword in C++";
// Common macros imported by this header
// stddef.h
case "offsetof":
case "NULL":
return "default macro in C++";
// C++11 keywords
case "alignas":
case "alignof":
case "char16_t":
case "char32_t":
case "constexpr":
case "decltype":
case "noexcept":
case "nullptr":
case "static_assert":
case "thread_local":
case "wchar_t":
if (global.params.cplusplus >= CppStdRevision.cpp11)
return "keyword in C++11";
return null;
// C++20 keywords
case "char8_t":
case "consteval":
case "constinit":
// Concepts-related keywords
case "concept":
case "requires":
// Coroutines-related keywords
case "co_await":
case "co_yield":
case "co_return":
if (global.params.cplusplus >= CppStdRevision.cpp20)
return "keyword in C++20";
return null;
default:
// Identifiers starting with __ are reserved
if (name.length >= 2 && name[0..2] == "__")
return "reserved identifier in C++";
return null;
}
}
/// Finds the outermost symbol if `sym` is nested.
/// Returns `sym` if it appears at module scope
ASTCodegen.Dsymbol outermostSymbol(ASTCodegen.Dsymbol sym)
{
assert(sym);
while (true)
{
auto par = sym.toParent();
if (!par || par.isModule())
return sym;
sym = par;
}
}
/// Fetches the symbol for user-defined types from the type `t`
/// if `t` is either `TypeClass`, `TypeStruct` or `TypeEnum`
ASTCodegen.Dsymbol symbolFromType(ASTCodegen.Type t)
{
if (auto tc = t.isTypeClass())
return tc.sym;
if (auto ts = t.isTypeStruct())
return ts.sym;
if (auto te = t.isTypeEnum())
return te.sym;
return null;
}
/**
* Searches `sym` for a member with the given name.
*
* This method usually delegates to `Dsymbol.search` but might also
* manually check the members if the symbol did not receive semantic
* analysis.
*
* Params:
* sym = symbol to search
* name = identifier of the requested symbol
*
* Returns: the symbol or `null` if not found
*/
ASTCodegen.Dsymbol findMember(ASTCodegen.Dsymbol sym, Identifier name)
{
if (auto mem = sym.search(Loc.initial, name, ASTCodegen.IgnoreErrors))
return mem;
// search doesn't work for declarations inside of uninstantiated
// `TemplateDeclaration`s due to the missing symtab.
if (sym.semanticRun >= ASTCodegen.PASS.semanticdone)
return null;
// Manually check the members if present
auto sds = sym.isScopeDsymbol();
if (!sds || !sds.members)
return null;
/// Recursively searches for `name` without entering nested aggregates, ...
static ASTCodegen.Dsymbol search(ASTCodegen.Dsymbols* members, Identifier name)
{
foreach (mem; *members)
{
if (mem.ident == name)
return mem;
// Look inside of private:, ...
if (auto ad = mem.isAttribDeclaration())
{
if (auto s = search(ad.decl, name))
return s;
}
}
return null;
}
return search(sds.members, name);
}
debug (Debug_DtoH)
{
/// Generates code to trace the entry and exit of the enclosing `visit` function
string traceVisit(alias node)()
{
const type = typeof(node).stringof;
const method = __traits(hasMember, node, "toPrettyChars") ? "toPrettyChars" : "toChars";
const arg = __traits(identifier, node) ~ '.' ~ method;
return `printf("[` ~ type ~ ` enter] %s\n", ` ~ arg ~ `());
scope(exit) printf("[` ~ type ~ ` exit] %s\n", ` ~ arg ~ `());`;
}
}