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); } } }