public override bool VisitFunctionDecl(Function function)
{
if (!base.VisitFunctionDecl(function))
{
return(false);
}
if (function.IsGenerated)
{
Action <ClassTemplateSpecialization> add =
s =>
{
if (internalSpecializations.Contains(s))
{
internalSpecializations.Remove(s);
}
specializations.Add(s);
};
ASTUtils.CheckTypeForSpecialization(function.OriginalReturnType.Type,
function, add, Context.TypeMaps);
foreach (var parameter in function.Parameters)
{
ASTUtils.CheckTypeForSpecialization(parameter.Type, function,
add, Context.TypeMaps);
}
}
return(true);
}
public override bool VisitFunctionDecl(Function function)
{
if (!base.VisitFunctionDecl(function))
{
return(false);
}
var module = function.TranslationUnit.Module;
if (function.IsGenerated)
{
ASTUtils.CheckTypeForSpecialization(function.OriginalReturnType.Type,
function, Add, Context.TypeMaps);
foreach (var parameter in function.Parameters)
{
ASTUtils.CheckTypeForSpecialization(parameter.Type, function,
Add, Context.TypeMaps);
}
}
if (!NeedsSymbol(function))
{
return(false);
}
var symbolsCodeGenerator = GetSymbolsCodeGenerator(module);
return(function.Visit(symbolsCodeGenerator));
}
private void CheckForInternalSpecialization(Declaration container, AST.Type type)
{
ASTUtils.CheckTypeForSpecialization(type, container,
specialization =>
{
if (!specializations.Contains(specialization))
{
internalSpecializations.Add(specialization);
CheckLayoutFields(specialization);
}
}, Context.TypeMaps, true);
}
private void CheckBasesForSpecialization(Class @class)
{
foreach (var @base in @class.Bases.Where(b => b.IsClass))
{
var specialization = @base.Class as ClassTemplateSpecialization;
if (specialization != null && !specialization.IsExplicitlyGenerated &&
specialization.SpecializationKind != TemplateSpecializationKind.ExplicitSpecialization)
{
ASTUtils.CheckTypeForSpecialization(@base.Type, @class, Add, Context.TypeMaps);
}
CheckBasesForSpecialization(@base.Class);
}
}
private void CheckBasesForSpecialization(Class @class)
{
foreach (var @base in @class.Bases.Where(b => b.IsClass))
{
var specialization = @base.Class as ClassTemplateSpecialization;
if (specialization != null &&
!ASTUtils.CheckTypeForSpecialization(@base.Type, @class,
AddSpecialization, Context.TypeMaps))
{
CheckForInternalSpecialization(@class, @base.Type);
}
CheckBasesForSpecialization(@base.Class);
}
}
private void CheckForInternalSpecialization(Declaration container, AST.Type type)
{
ASTUtils.CheckTypeForSpecialization(type, container,
s =>
{
if (!specializations.Contains(s))
{
internalSpecializations.Add(s);
foreach (var f in s.Fields)
{
f.Visit(this);
}
}
}, Context.TypeMaps, true);
}
public override bool VisitVariableDecl(Variable variable)
{
if (!base.VisitVariableDecl(variable))
{
return(false);
}
if (variable.Access == AccessSpecifier.Public)
{
ASTUtils.CheckTypeForSpecialization(variable.Type,
variable, AddSpecialization, Context.TypeMaps);
return(true);
}
return(true);
}
public override bool VisitFieldDecl(Field field)
{
if (!base.VisitDeclaration(field))
{
return(false);
}
ASTUtils.CheckTypeForSpecialization(field.Type, field,
s =>
{
if (!specializations.Contains(s))
{
internalSpecializations.Add(s);
}
}, Context.TypeMaps, true);
return(true);
}
public override bool VisitFunctionDecl(Function function)
{
if (!base.VisitFunctionDecl(function))
{
return(false);
}
var module = function.TranslationUnit.Module;
if (function.IsGenerated)
{
Action <ClassTemplateSpecialization> add =
s =>
{
ICollection <ClassTemplateSpecialization> specs;
if (specializations.ContainsKey(s.TranslationUnit.Module))
{
specs = specializations[s.TranslationUnit.Module];
}
else
{
specs = specializations[s.TranslationUnit.Module] =
new HashSet <ClassTemplateSpecialization>();
}
specs.Add(s);
};
ASTUtils.CheckTypeForSpecialization(function.OriginalReturnType.Type,
function, add, Context.TypeMaps);
foreach (var parameter in function.Parameters)
{
ASTUtils.CheckTypeForSpecialization(parameter.Type, function,
add, Context.TypeMaps);
}
}
if (!NeedsSymbol(function))
{
return(false);
}
var symbolsCodeGenerator = GetSymbolsCodeGenerator(module);
return(function.Visit(symbolsCodeGenerator));
}
public override bool VisitFunctionDecl(Function function)
{
if (!base.VisitFunctionDecl(function))
{
return(false);
}
if (function.IsGenerated)
{
ASTUtils.CheckTypeForSpecialization(function.OriginalReturnType.Type,
function, AddSpecialization, Context.TypeMaps);
foreach (var parameter in function.Parameters)
{
ASTUtils.CheckTypeForSpecialization(parameter.Type, function,
AddSpecialization, Context.TypeMaps);
}
}
return(true);
}
public override bool VisitFieldDecl(Field field)
{
if (!base.VisitDeclaration(field))
{
return(false);
}
if (field.Access == AccessSpecifier.Private)
{
CheckForInternalSpecialization(field, field.Type);
return(true);
}
if (!ASTUtils.CheckTypeForSpecialization(field.Type,
field, AddSpecialization, Context.TypeMaps))
{
CheckForInternalSpecialization(field, field.Type);
}
return(true);
}
public override bool VisitFunctionDecl(Function function)
{
if (!base.VisitFunctionDecl(function))
{
return(false);
}
var module = function.TranslationUnit.Module;
if (function.IsGenerated)
{
ASTUtils.CheckTypeForSpecialization(function.OriginalReturnType.Type,
function, Add, Context.TypeMaps);
foreach (var parameter in function.Parameters)
{
ASTUtils.CheckTypeForSpecialization(parameter.Type, function,
Add, Context.TypeMaps);
}
}
if (!NeedsSymbol(function))
{
return(false);
}
//Is NeedSymbol broken? Functions without symbols are included...
//Let's add these lines (raizam)
string fnName = function.OriginalName;
string mangledName = function.Mangled;
if (!(Context.Symbols.FindSymbol(ref fnName) || Context.Symbols.FindSymbol(ref mangledName)))
{
function.GenerationKind = GenerationKind.None;
return(false);
}
var symbolsCodeGenerator = GetSymbolsCodeGenerator(module);
return(function.Visit(symbolsCodeGenerator));
}
