/// <summary> /// Process all of the reachable children and return the list of found items /// </summary> /// <param name="originalToProcess"></param> /// <remarks></remarks> private List <NativeSymbolRelationship> FindAllReachableChildrenImpl(IEnumerable <NativeSymbol> originalToProcess) { List <NativeSymbolRelationship> found = new List <NativeSymbolRelationship>(); Dictionary <NativeSymbol, bool> map = new Dictionary <NativeSymbol, bool>(); Queue <NativeSymbol> toVisit = new Queue <NativeSymbol>(originalToProcess); // First add in all of the original symbols with no parents foreach (NativeSymbol orig in originalToProcess) { found.Add(new NativeSymbolRelationship(null, orig)); } while (toVisit.Count > 0) { NativeSymbol cur = toVisit.Dequeue(); if (map.ContainsKey(cur)) { continue; } map[cur] = true; foreach (NativeSymbol child in cur.GetChildren()) { found.Add(new NativeSymbolRelationship(cur, child)); toVisit.Enqueue(child); } } return(found); }
public List <NativeSymbolRelationship> FindAllNativeSymbolRelationships(NativeSymbol ns) { List <NativeSymbol> list = new List <NativeSymbol>(); list.Add(ns); return(FindAllNativeSymbolRelationships(list)); }
public void CollapseTypedefs(NativeSymbol ns) { foreach (NativeSymbolRelationship rel in _it.FindAllNativeSymbolRelationships(ns)) { CollapseTypedefsImpl(rel.Parent, rel.Symbol); } }
public NativeGlobalSymbol(NativeName name, NativeSymbol symbol) { Contract.Requires(name.SymbolKind == symbol.Kind); Contract.Requires(name.Name == symbol.Name); Contract.Requires(name == NativeNameUtil.GetName(symbol)); Name = name; Symbol = symbol; }
private void TestRoundTrip(NativeSymbol symbol) { var storage = new BasicSymbolStorage(); var name = NativeNameUtil.GetName(symbol); var globalSymbol = new NativeGlobalSymbol(name, symbol); storage.Add(globalSymbol); TestRoundTrip(storage); }
/// <summary> /// Renames matching defined types and named types to the new name /// </summary> /// <param name="ns"></param> /// <param name="oldName"></param> /// <param name="newName"></param> /// <remarks></remarks> public void RenameTypeSymbol(NativeSymbol ns, string oldName, string newName) { foreach (NativeSymbol sym in _it.FindAllNativeSymbols(ns)) { if ((sym.Category == NativeSymbolCategory.Defined || sym.Kind == NativeSymbolKind.NamedType) && 0 == string.CompareOrdinal(sym.Name, oldName)) { sym.Name = newName; } } }
public static NativeName GetName(NativeSymbol symbol) { NativeName name; if (!TryGetName(symbol, out name)) { throw new Exception($"Unable to create name for {symbol.Name} {symbol.Kind}"); } return(name); }
public static string Convert(NativeSymbol sym) { string str = sym.Name; foreach (NativeSymbol child in sym.GetChildren()) { str += "(" + Convert(child) + ")"; } return(str); }
public List <NativeSymbol> FindAllNativeSymbols(NativeSymbol ns) { if (ns == null) { throw new ArgumentNullException("ns"); } List <NativeSymbol> list = new List <NativeSymbol>(); list.Add(ns); return(FindAllNativeSymbols(list)); }
private void EnsureIsParent(NativeSymbol sym, List <NativeSymbolRelationship> list) { foreach (NativeSymbolRelationship rel in list) { if (object.ReferenceEquals(sym, rel.Parent)) { return; } } throw new Exception("Could Not find the symbol"); }
public static bool TryGetName(NativeSymbol symbol, out NativeName name) { NativeNameKind kind; if (!TryGetNativeNameKind(symbol.Kind, out kind)) { name = NativeName.Nil; return(false); } name = new NativeName(symbol.Name, kind); return(true); }
private bool IsResolved(NativeSymbol ns, Dictionary <NativeSymbol, bool?> map) { ThrowIfNull(ns); ThrowIfNull(map); // See if this has already been calculated bool?ret = false; if (map.TryGetValue(ns, out ret)) { if (ret.HasValue) { return(ret.Value); } else { // We're in a recursive call to the same type. Return true here because if another type is // not resolved then this will fall out return(true); } } // If there are no immediate children then the type is most definately resolved NativeSymbolIterator it = new NativeSymbolIterator(); List <NativeSymbol> children = new List <NativeSymbol>(ns.GetChildren()); if (children.Count == 0) { return(true); } // Add an entry into the map to indicate that we are exploring this type map.Add(ns, null); ret = true; foreach (NativeSymbol child in children) { if (!child.IsImmediateResolved || !IsResolved(child, map)) { ret = false; break; } } // Save the success map[ns] = ret; return(ret.Value); }
private string Print(NativeSymbol ns) { if (ns == null) { return("<Nothing>"); } string str = ns.Name; foreach (NativeSymbol child in ns.GetChildren()) { str += "(" + Print(child) + ")"; } return(str); }
private bool TryGetValueCore(string name, out NativeSymbol symbol, out bool loadedFromNextLookup) { if (_storage.TryGetValue(name, out symbol)) { loadedFromNextLookup = false; return(true); } if (_nextSymbolLookup.TryGetValue(name, out symbol)) { loadedFromNextLookup = true; return(true); } loadedFromNextLookup = false; return(false); }
private void CollapseTypedefsImpl(NativeSymbol ns, NativeSymbol child) { if (ns == null) { return; } ThrowIfNull(child); if (child.Kind == NativeSymbolKind.TypeDefType) { NativeTypeDef typedef = (NativeTypeDef)child; if (typedef.RealType != null) { ns.ReplaceChild(child, typedef.RealType); } } }
private void CollapseNamedTypesImpl(NativeSymbol ns, NativeSymbol child) { if (ns == null) { return; } ThrowIfNull(child); if (child.Kind == NativeSymbolKind.NamedType) { NativeNamedType namedNt = (NativeNamedType)child; if (namedNt.RealType != null) { ns.ReplaceChild(child, namedNt.RealType); } } }
/// <summary> /// Try and resolve the unresolved values in the system. /// </summary> private ResolveResult ResolveCoreValues(ErrorProvider ep) { var succeeded = true; var needMoreWork = false; foreach (NativeValue nValue in this.FindUnresolvedNativeValues()) { var loadedFromNextLookup = false; switch (nValue.ValueKind) { case NativeValueKind.SymbolValue: { NativeSymbol symbol = null; if (TryGetValueCore(nValue.Name, out symbol, out loadedFromNextLookup)) { nValue.Value = symbol; } } break; case NativeValueKind.SymbolType: { NativeType type = null; if (TryFindTypeCore(nValue.Name, out type, out loadedFromNextLookup)) { nValue.Value = type; } } break; } if (!nValue.IsImmediateResolved) { ep.AddError($"Failed to resolve value '{nValue.Name}'"); succeeded = false; } if (loadedFromNextLookup) { needMoreWork = true; } } return(new ResolveResult(succeeded, needMoreWork)); }
/// <summary> /// Convert a NativeValueExpression into managed code and make it the initialization expression of /// the passed in member. /// /// If the code is unable to generate a valid expression for the member it will make the expression /// a stringized version of the original native expression. It will add information in the comments /// about why it could not properly generate the expression. Lastly it will generate incompatible types /// to force a compile error /// </summary> /// <param name="member"></param> /// <param name="ntExpr"></param> /// <returns></returns> /// <remarks></remarks> public bool GenerateInitExpression(CodeMemberField member, NativeSymbol target, NativeValueExpression ntExpr) { if (ntExpr == null) { member.Comments.Add(new CodeCommentStatement("Error: No value expression", true)); member.InitExpression = new CodePrimitiveExpression(string.Empty); member.Type = new CodeTypeReference(typeof(int)); return(false); } member.Comments.Add(new CodeCommentStatement(string.Format("{0} -> {1}", member.Name, ntExpr.Expression), true)); // It's not legal for a symbol to be used as part of it's initialization expression in most languages. // There for we need to mark it as the initialization member so the generated will output NULL in it's place _symbolValueMap.Add(target.Name, target); try { Exception ex = null; CodeExpression expr; CodeTypeReference typeRef; if (TryGenerateValueExpression(ntExpr, out expr, out typeRef, out ex)) { member.InitExpression = expr; member.Type = typeRef; return(true); } else { member.Comments.Add(new CodeCommentStatement(string.Format("Error generating expression: {0}", ex.Message), true)); member.InitExpression = new CodePrimitiveExpression(ntExpr.Expression); member.Type = new CodeTypeReference(typeof(string)); return(false); } } finally { _symbolValueMap.Remove(target.Name); } }
private CodeExpression GenerateValueExpressionLeaf(ExpressionNode node, ref CodeTypeReference leafType) { ThrowIfNull(node); var ntVal = NativeValue.TryCreateForLeaf(node, _bag); if (ntVal == null) { throw new InvalidOperationException("Expected a NativeValue"); } if (!ntVal.IsValueResolved) { throw new InvalidOperationException(string.Format("Value {0} is not resolved", ntVal.Name)); } switch (ntVal.ValueKind) { case NativeValueKind.Number: leafType = new CodeTypeReference(ntVal.Value.GetType()); return(new CodePrimitiveExpression(ntVal.Value)); case NativeValueKind.Boolean: leafType = new CodeTypeReference(typeof(bool)); return(new CodePrimitiveExpression(ntVal.Value)); case NativeValueKind.String: leafType = new CodeTypeReference(typeof(string)); return(new CodePrimitiveExpression(ntVal.Value)); case NativeValueKind.Character: leafType = new CodeTypeReference(typeof(char)); return(new CodePrimitiveExpression(ntVal.Value)); case NativeValueKind.SymbolValue: NativeSymbol ns = ntVal.SymbolValue; // Prevent the generation of a circular reference if (_symbolValueMap.ContainsKey(ns.Name)) { leafType = new CodeTypeReference(typeof(object)); return(new CodePrimitiveExpression(null)); } switch (ns.Kind) { case NativeSymbolKind.Constant: leafType = CalculateConstantType((NativeConstant)ns); return(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(TransformConstants.NativeConstantsName), ns.Name)); case NativeSymbolKind.EnumType: leafType = this.GenerateTypeReference((NativeEnum)ns); return(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(ns.Name), ntVal.Name)); default: throw new InvalidOperationException(string.Format("Generation of {0} not supported as a value", ns.Kind)); } case NativeValueKind.SymbolType: throw new InvalidOperationException("Types are not supported as leaf nodes"); default: ThrowInvalidEnumValue(ntVal.ValueKind); return(null); } }
public NativeSymbolRelationship(NativeSymbol parent, NativeSymbol symbol) { Parent = parent; Symbol = symbol; }
public static bool TryGetValue(this INativeSymbolLookup lookup, string name, out NativeSymbol symbol) => lookup.TryGetGlobalSymbol(new NativeName(name, NativeNameKind.Constant), out symbol) || lookup.TryGetGlobalSymbol(new NativeName(name, NativeNameKind.EnumValue), out symbol);
private void VerifyTree(NativeSymbol ns, string str) { string realStr = Print(ns); Assert.Equal(str, realStr); }