private void UpdateForMissingQualifierConversionFunction(Moniker moniker) { // Check if a compatible one is good for the TargetFrameworks foreach (var compatibleMoniker in NugetFrameworkMonikers.CompatibilityMatrix[moniker]) { if (TargetFrameworkWithFallbacks.ContainsKey(compatibleMoniker) && !TargetFrameworkWithFallbacks.ContainsKey(moniker)) { // Add the framework as compatible with this package for now. TargetFrameworkWithFallbacks.Add(compatibleMoniker, moniker); break; } } }
/// <summary> /// Writes a PathAtom /// </summary> public virtual void Write(PathAtom value) { Start <PathAtom>(); Write(value.StringId.Value); End(); }
/// <summary> /// Internal api to try to create a RelativePath from a string. /// </summary> /// <remarks>This function serves as an internal overload for tryCreate when called from AbsolutePath so we do not get the DotDotOutOfScope error when traversing beyond the root.</remarks> /// <param name="table">StringTable instance.</param> /// <param name="relativePath">Relative path to pass in.</param> /// <param name="result">Output relative path after parsing.</param> /// <param name="characterWithError">Output the character that had the error.</param> /// <param name="allowDotDotOutOfScope">Whether to allow the function to parse .. beyond the root.</param> /// <returns>Return the parser result indicating success, or what was wrong with the parsing.</returns> internal static ParseResult TryCreateInternal <T>(StringTable table, T relativePath, out RelativePath result, out int characterWithError, bool allowDotDotOutOfScope = false) where T : struct, ICharSpan <T> { Contract.Requires(table != null); Contract.Ensures((Contract.Result <ParseResult>() == ParseResult.Success) == Contract.ValueAtReturn(out result).IsValid); using (var wrap = Pools.GetStringIdList()) { List <StringId> components = wrap.Instance; int index = 0; int start = 0; while (index < relativePath.Length) { var ch = relativePath[index]; // trivial reject of invalid characters if (!IsValidRelativePathChar(ch)) { characterWithError = index; result = Invalid; return(ParseResult.FailureDueToInvalidCharacter); } if (ch == '\\' || ch == '/') { // found a component separator if (index > start) { // make a path atom out of [start..index] PathAtom.ParseResult papr = PathAtom.TryCreate( table, relativePath.Subsegment(start, index - start), out PathAtom atom, out int charError); if (papr != PathAtom.ParseResult.Success) { characterWithError = index + charError; result = Invalid; return(ParseResult.FailureDueToInvalidCharacter); } components.Add(atom.StringId); } // skip over the slash index++; start = index; continue; } if (ch == '.' && index == start) { // component starts with a . if ((index == relativePath.Length - 1) || (relativePath[index + 1] == '\\') || (relativePath[index + 1] == '/')) { // component is a sole . so skip it index += 2; start = index; continue; } if (relativePath[index + 1] == '.') { // component starts with .. if ((index == relativePath.Length - 2) || (relativePath[index + 2] == '\\') || (relativePath[index + 2] == '/')) { // component is a sole .. so try to go up if (components.Count == 0 && !allowDotDotOutOfScope) { characterWithError = index; result = Invalid; return(ParseResult.FailureDueToDotDotOutOfScope); } if (components.Count != 0) { components.RemoveAt(components.Count - 1); } index += 3; start = index; continue; } } } index++; } if (index > start) { // make a path atom out of [start..index] PathAtom.ParseResult papr = PathAtom.TryCreate( table, relativePath.Subsegment(start, index - start), out PathAtom atom, out int charError); if (papr != PathAtom.ParseResult.Success) { characterWithError = index + charError; result = Invalid; return(ParseResult.FailureDueToInvalidCharacter); } components.Add(atom.StringId); } result = new RelativePath(components.ToArray()); characterWithError = -1; return(ParseResult.Success); } }