public void Process(TranslationUnit translationUnit)
{
var funcs = translationUnit.Functions.Where(x => !x.IsInline);
if (Filter != null)
{
var filters = Array.ConvertAll(Filter.GetInvocationList(), filter => (FilterHandler)filter);
funcs = funcs.Where(func => !filters.Any(filter => filter(func)));
}
foreach (var function in funcs)
{
var functionName = function.Name;
if (!context.FunctionExportMap.TryGetValue(functionName, out FunctionExport export))
{
Console.WriteLine($"Export not found. Skipping {functionName} function.");
continue;
}
var functionDefinition = new Definitions.FunctionDefinition {
Name = functionName,
ReturnType = GetTypeDefinition(function.ReturnType.Type),
Content = function.Comment?.BriefText,
DetailedContent = function.Comment?.Text,
LibraryName = export.LibraryName,
IsConstLibraryName = export.IsConstLibraryName,
Params = function.Parameters.Select((x, i) => GetParameter(function, x, i)).ToArray(),
IsObsolete = IsObsolete(function),
ObsoleteMessage = GetObsoleteMessage(function),
CallingConvention = GetCallingConvention(function.CallingConvention),
};
context.AddUnit(functionDefinition);
}
}
public Definitions.EnumDefinition MakeDefinition(Enumeration enumeration, string name)
{
name = string.IsNullOrEmpty(enumeration.Name) ? name : enumeration.Name;
var result = new Definitions.EnumDefinition {
Name = name
};
if (context.IsKnownUnitName(name))
{
return(result);
}
context.AddUnit(result);
result.TypeName = TypeHelper.GetTypeName(enumeration.Type);
result.Content = enumeration.Comment?.BriefText;
result.Items = enumeration.Items
.Select(x =>
new Definitions.EnumItem {
Name = x.Name,
Value = EnumValueToString(result.TypeName, x.Value),
Content = x.Comment?.BriefText,
DetailedContent = x.Comment?.Text
})
.ToArray();
return(result);
}
private void MakeDefinition(Class @class, string name)
{
name = string.IsNullOrEmpty(@class.Name) ? name : @class.Name;
if (string.IsNullOrEmpty(name))
{
return;
}
Definitions.StructDefinition definition = null;
if (!(context.UnitsMap.TryGetValue(name, out var idef) && idef is Definitions.StructDefinition structDefinition))
{
definition = new Definitions.StructDefinition {
Name = name
};
context.AddUnit(definition);
}
public void Process(TranslationUnit translationUnit)
{
var macros = translationUnit.PreprocessedEntities
.OfType <MacroDefinition>()
.Where(x => !string.IsNullOrWhiteSpace(x.Expression));
if (Filter != null)
{
var filters = Array.ConvertAll(Filter.GetInvocationList(), f => (FilterHandler)f);
macros = macros.Where(m => !filters.Any(f => f(m)));
}
foreach (var macro in macros)
{
string expression = clearMacroNewLineRegex.Replace(macro.Expression, " ");
var macroDefinition = new Definitions.MacroDefinition {
Name = macro.Name,
ExprString = expression,
Content = $"{macro.Name} = {expression}",
};
try {
macroDefinition.Expr = MacroParse.MacroParser.Parse(expression);
macroDefinition.TypeName = GetMacroType(macroDefinition.Expr);
} catch {
}
context.AddUnit(macroDefinition);
}
foreach (var m in context.Units.OfType <Definitions.MacroDefinition>())
{
if (m.Expr != null && m.TypeName != null)
{
m.IsConst = IsConstMacro(m.Expr);
m.CSharpExpr = RewriteMacro(m.Expr);
}
}
}
