private void GenerateMacro_OptimizedBody() { AstDescription.Log.Clear(); AstDescription.Generate_Macro_UsingOptimizedCompiledBody(SelectedGMacMacro); var itemText = AstDescription.Log.ToString(); MacroCodeGenerator.ReportNormal("Optimized Body", itemText); }
public Parameters CreateParameters(AstDescription astDescription) { var nonKindSpecifiedInterfaces = astDescription .AstDeclarations .Select(g => g.Value) .Select(d => d.NamedDeclaration) .OfType <InterfaceDescription>() .Where(d => !d.Members.Any(m => m.Property != null && m.Property.Name == "kind")) .ToArray(); var nonInheritednonKindSpecifiedInterfaces = nonKindSpecifiedInterfaces .Where(nk => !astDescription .AstDeclarations .Select(g => g.Value) .Any(d => d.InheritedTypes.Any(r => r.Named != null && r.Named.Name == nk.Name))) .Select(nk => nk.Name) .ToArray(); var referredNonEnums = astDescription .ReferredDeclarations .Select(g => g.Value) .Select(d => d.NamedDeclaration) .Where(d => !(d is EnumDescription)) .Select(nk => nk.Name) .ToArray(); var result = new Parameters(); var transportModelParametersBuilder = new TransportModelParametersBuilder(new ModelSettings(this.pluginSettings)); result.TransportModel = transportModelParametersBuilder.Create(astDescription); this.AddSurrogateRootNode(result); this.Validate(result); return(result); }
private Dictionary <DescriptionModel.TypeReference, HashSet <Declaration> > GetReferenceUsages(AstDescription astDescription) { var result = new Dictionary <DescriptionModel.TypeReference, HashSet <Declaration> >(); foreach (var declaration in astDescription.AstDeclarations.Values.Concat(astDescription.ReferredDeclarations.Values)) { foreach (var reference in declaration.NamedTypeReferences) { if (!result.ContainsKey(reference)) { result.Add(reference, new HashSet <Declaration>() { declaration }); } else { result[reference].Add(declaration); } } } return(result); }
private HashSet <Declaration> BreakdownInheritanceList(string contextNamespace, DescriptionModel.TypeReference typeReference, AstDescription astDescription) { HashSet <Declaration> result = new HashSet <Declaration>(); if (this.ReferencePointsToExcludedType(typeReference, contextNamespace)) { return(result); } if (typeReference.Named != null) { var declaration = astDescription.GetReferredDeclaration(typeReference.Named.Name, contextNamespace); if (declaration == null) { throw new InvalidOperationException($"Unknown inhertiance reference {typeReference.Named.Name}"); } if (declaration.NamedDeclaration is DescriptionModel.InterfaceDescription) { result.Add(declaration); return(result); } if (declaration.NamedDeclaration is DescriptionModel.TypeAliasDescription typeAlias) { if (typeAlias.Type.Union != null) { foreach (var u in typeAlias.Type.Union.Types) { foreach (var item in this.BreakdownInheritanceList(contextNamespace, u, astDescription)) { result.Add(item); } } return(result); } } } throw new InvalidOperationException("Unable breakdown inheritance list."); }
public InheritanceModel ResolveInheritance(AstDescription astDescription) { var referenceUsages = this.GetReferenceUsages(astDescription); InheritanceModel result = new InheritanceModel(); var interfaceDeclarations = astDescription.ReferredDeclarations.Where(g => g.Value.NamedDeclaration is DescriptionModel.InterfaceDescription) .Concat(astDescription.AstDeclarations.Where(g => g.Value.NamedDeclaration is DescriptionModel.InterfaceDescription)) .Where(d => !this.settings.InterfacesMappedAsCollection.Contains(d.Value.NamedDeclaration.Name)) .ToDictionary(d => d.Key, d => d.Value); Dictionary <Declaration, HashSet <Declaration> > rawInheritanceLists = new Dictionary <Declaration, HashSet <Declaration> >(); foreach (var declaration in interfaceDeclarations.Values) { HashSet <Declaration> list = new HashSet <Declaration>(); foreach (var i in ((DescriptionModel.InterfaceDescription)declaration.NamedDeclaration).Extends) { foreach (var d in this.BreakdownInheritanceList(declaration.NamedDeclaration.Namespace, i, astDescription)) { list.Add(d); } } rawInheritanceLists.Add(declaration, list); } Dictionary <Declaration, HashSet <Declaration> > rawInheritanceListsReversed = new Dictionary <Declaration, HashSet <Declaration> >(); foreach (var d1 in rawInheritanceLists) { foreach (var d2 in d1.Value) { if (!rawInheritanceListsReversed.ContainsKey(d2)) { rawInheritanceListsReversed.Add(d2, new HashSet <Declaration>()); } rawInheritanceListsReversed[d2].Add(d1.Key); } } var pureInterfaces = interfaceDeclarations .Where(d => this.CanCollapseToEmptyInterface(d.Value, rawInheritanceLists)) .ToDictionary(d => d.Key, d => d.Value); foreach (var i in pureInterfaces) { result.CollapsedToEmptyInterface.Add(i.Value); ////interfaceDeclarations.Remove(i.Key); } var complex = new HashSet <Declaration>(interfaceDeclarations .Values .Where(d => rawInheritanceLists[d].Count > 1)); foreach (var declaration in complex) { this.ResolveForInterface(declaration, result, referenceUsages, rawInheritanceLists, rawInheritanceListsReversed, astDescription); } foreach (var declaration in interfaceDeclarations.Values.Where(i => !complex.Contains(i))) { this.ResolveForInterface(declaration, result, referenceUsages, rawInheritanceLists, rawInheritanceListsReversed, astDescription); } this.FixInterfaceImplementations(result); return(result); }
private void ResolveForInterface( Declaration declaration, InheritanceModel result, Dictionary <DescriptionModel.TypeReference, HashSet <Declaration> > usages, Dictionary <Declaration, HashSet <Declaration> > rawInheritanceLists, Dictionary <Declaration, HashSet <Declaration> > rawInheritanceListsReversed, AstDescription astDescription) { if (settings.TypesRepresentedAsInterface.Contains(declaration.GetFullName())) { result.RepresentedAsInterface.Add(declaration); } var list = new HashSet <Declaration>(rawInheritanceLists[declaration]); bool shouldContinue = true; var item = new InheritanceModelDeclaration() { OriginalDeclaration = declaration }; while (shouldContinue) { shouldContinue = false; var entities = list.Where(i => !result.CollapsedToEmptyInterface.Contains(i) && !result.CollapsedToInterface.Contains(i)).ToArray(); var emptyInterfaces = list.Where(i => result.CollapsedToEmptyInterface.Contains(i)).ToArray(); var pureInterfaces = list.Where(i => result.CollapsedToInterface.Contains(i)).ToArray(); list.Clear(); if (emptyInterfaces.Length == 0 && pureInterfaces.Length == 0) { if (entities.Length <= 1) { if (entities.Length == 1) { item.BaseDeclaration = entities[0]; } } else { var filteredEntities = entities.Where(e => !entities.Any(e1 => e != e1 && this.FirstInheritsSecond(e1, e, rawInheritanceLists))).ToArray(); if (filteredEntities.Length < entities.Length) { shouldContinue = true; foreach (var e in filteredEntities) { list.Add(e); } } else { var collapsibleToEmpty = entities.Where(e => this.CanCollapseToEmptyInterface(e, rawInheritanceLists)).ToArray(); if (collapsibleToEmpty.Length > 0) { foreach (var e in collapsibleToEmpty) { this.CollapseToEmptyInterface(e, result, rawInheritanceLists); } shouldContinue = true; } else { var collapsible = entities .Where(e => this.CanCollapseToInterface(e, rawInheritanceLists)) .OrderBy(c => rawInheritanceListsReversed.ContainsKey(c) ? rawInheritanceListsReversed[c].Count : 0) .ToArray(); if (collapsible.Length > 0) { for (var i = 0; i < Math.Min(entities.Length - 1, collapsible.Length); i++) { this.CollapseToInterface(collapsible[i], result, rawInheritanceLists); } shouldContinue = true; } } foreach (var e in entities) { list.Add(e); } } if (!shouldContinue) { throw new InvalidOperationException("Unable to resolve inheritance list."); } } } else { foreach (var e in entities) { list.Add(e); } foreach (var empty in emptyInterfaces) { var baseItems = rawInheritanceLists[empty]; if (!item.ImplementedInterfaces.Any(i => this.FirstInheritsSecond(i, empty, rawInheritanceLists))) { item.ImplementedInterfaces.Add(empty); } foreach (var baseItem in baseItems) { list.Add(baseItem); } shouldContinue = true; } foreach (var pure in pureInterfaces) { var baseItems = rawInheritanceLists[pure]; if (!item.ImplementedInterfaces.Any(i => this.FirstInheritsSecond(i, pure, rawInheritanceLists))) { item.ImplementedInterfaces.Add(pure); item.MergedDeclarations.Add(pure); } foreach (var baseItem in baseItems) { list.Add(baseItem); } shouldContinue = true; } } } result.Declarations.Add(declaration.GetName(), item); }