dmd.importc

Type cAdjustParamType(Type t, Scope* sc);

C11 does not allow array or function parameters. Hence, adjust those types per C11 6.7.6.3 rules.

Parameters:

Type t	parameter type to adjust
Scope* sc	context

Returns:

adjusted type

Expression arrayFuncConv(Expression e, Scope* sc);

C11 6.3.2.1-3 Convert expression that is an array of type to a pointer to type. C11 6.3.2.1-4 Convert expression that is a function to a pointer to a function.

Parameters:

Expression e	ImportC expression to possibly convert
Scope* sc	context

Returns:

converted expression

Expression fieldLookup(Expression e, Scope* sc, Identifier id, bool arrow);

Run semantic on e. Expression e evaluates to an instance of a struct. Look up ident as a field of that struct.

Parameters:

Expression e	evaluates to an instance of a struct
Scope* sc	context
Identifier id	identifier of a field in that struct
bool arrow	-> was used

Returns:

if successful e.ident if not then ErrorExp and message is printed

Expression carraySemantic(ArrayExp ae, Scope* sc);

C11 6.5.2.1-2 Apply C semantics to E[I] expression. E1[E2] is lowered to *(E1 + E2)

Parameters:

ArrayExp ae	ArrayExp to run semantics on
Scope* sc	context

Returns:

Expression if this was a C expression with completed semantic, null if not

void addDefaultCInitializer(VarDeclaration dsym);

Determine default initializer for const global symbol.

Expression castCallAmbiguity(Expression e, Scope* sc);

Resolve cast/call grammar ambiguity.

Parameters:

Expression e	expression that might be a cast, might be a call
Scope* sc	context

Returns:

null means leave as is, !=null means rewritten AST

bool cFuncEquivalence(TypeFunction tf1, TypeFunction tf2);

Implement the C11 notion of function equivalence, which allows prototyped functions to match K+R functions, even though they are different.

Parameters:

TypeFunction tf1	type of first function
TypeFunction tf2	type of second function

Returns:

true if C11 considers them equivalent

bool cTypeEquivalence(Type t1, Type t2);

Types haven't been merged yet, because we haven't done semantic() yet. But we still need to see if t1 and t2 are the same type.

Parameters:

Type t1	first type
Type t2	second type

Returns:

true if they are equivalent types

Dsymbol handleTagSymbols(ref Scope sc, Dsymbol s, Dsymbol s2, ScopeDsymbol sds);

ImportC tag symbols sit in a parallel symbol table, so that this C code works:

struct S { a; };
int S;
struct S s;

But there are relatively few such tag symbols, so that would be a waste of memory and complexity. An additional problem is we'd like the D side to find the tag symbols with ordinary lookup, not lookup in both tables, if the tag symbol is not conflicting with an ordinary symbol. The solution is to put the tag symbols that conflict into an associative array, indexed by the address of the ordinary symbol that conflicts with it. C has no modules, so this associative array is tagSymTab[] in ModuleDeclaration. A side effect of our approach is that D code cannot access a tag symbol that is hidden by an ordinary symbol. This is more of a theoretical problem, as nobody has mentioned it when importing C headers. If someone wants to do it, too bad so sad. Change the C code. This function fixes up the symbol table when faced with adding a new symbol s when there is an existing symbol s2 with the same name. C also allows forward and prototype declarations of tag symbols, this function merges those.

Parameters:

Scope sc	context
Dsymbol s	symbol to add to symbol table
Dsymbol s2	existing declaration
ScopeDsymbol sds	symbol table

Returns:

if s and s2 are successfully put in symbol table then return the merged symbol, null if they conflict

Dsymbol handleSymbolRedeclarations(ref Scope sc, Dsymbol s, Dsymbol s2, ScopeDsymbol sds);

ImportC allows redeclarations of C variables, functions and typedefs. extern int x; int x = 3; and: extern void f(); void f() { } Attempt to merge them.

Parameters:

Scope sc	context
Dsymbol s	symbol to add to symbol table
Dsymbol s2	existing declaration
ScopeDsymbol sds	symbol table

Returns:

if s and s2 are successfully put in symbol table then return the merged symbol, null if they conflict