/// <summary>
/// Try parse a <see cref="LanguageVersion"/> from a string input, returning default if input was null.
/// </summary>
public static bool TryParse(string version, out LanguageVersion result)
{
if (version == null)
{
result = LanguageVersion.Default;
return(true);
}
switch (CaseInsensitiveComparison.ToLower(version))
{
case "default":
result = LanguageVersion.Default;
return(true);
case "latest":
result = LanguageVersion.Latest;
return(true);
case "latestmajor":
result = LanguageVersion.LatestMajor;
return(true);
case "preview":
result = LanguageVersion.Preview;
return(true);
case "1":
case "1.0":
result = MetaLanguageVersion.Meta1;
return(true);
default:
result = LanguageVersion.Default;
return(false);
}
}
public Builder(IEnumerable <StringSlice> values)
{
// TODO(cyrusn): Properly handle unicode normalization here.
var distinctValues = values.Where(v => v.Length > 0).Distinct(StringSliceComparer.OrdinalIgnoreCase).ToArray();
var charCount = values.Sum(v => v.Length);
_concatenatedLowerCaseWords = new char[charCount];
_wordSpans = new TextSpan[distinctValues.Length];
var characterIndex = 0;
for (int i = 0; i < distinctValues.Length; i++)
{
var value = distinctValues[i];
_wordSpans[i] = new TextSpan(characterIndex, value.Length);
foreach (var ch in value)
{
_concatenatedLowerCaseWords[characterIndex] = CaseInsensitiveComparison.ToLower(ch);
characterIndex++;
}
}
// We will have one node for each string value that we are adding.
_builderNodes = new BuilderNode[distinctValues.Length];
_compactEdges = new Edge[distinctValues.Length * CompactEdgeAllocationSize];
}
public IList <string> Find(string value, int?threshold = null)
{
if (_nodes.Length == 0)
{
return(SpecializedCollections.EmptyList <string>());
}
var lowerCaseCharacters = ArrayPool <char> .GetArray(value.Length);
try
{
for (var i = 0; i < value.Length; i++)
{
lowerCaseCharacters[i] = CaseInsensitiveComparison.ToLower(value[i]);
}
threshold ??= WordSimilarityChecker.GetThreshold(value);
var result = new List <string>();
Lookup(_nodes[0], lowerCaseCharacters, value.Length, threshold.Value, result, recursionCount: 0);
return(result);
}
finally
{
ArrayPool <char> .ReleaseArray(lowerCaseCharacters);
}
}
public static bool TryParse(string version, out SarifVersion result)
{
if (version == null)
{
result = SarifVersion.Default;
return(true);
}
switch (CaseInsensitiveComparison.ToLower(version))
{
case "default":
result = SarifVersion.Default;
return(true);
case "latest":
result = SarifVersion.Latest;
return(true);
case "1":
case "1.0":
result = SarifVersion.Sarif1;
return(true);
case "2":
case "2.1":
result = SarifVersion.Sarif2;
return(true);
default:
result = SarifVersion.Default;
return(false);
}
}
public static int LastIndexOf(this SourceText text, string value, int startIndex, bool caseSensitive)
{
var normalized = caseSensitive ? value : CaseInsensitiveComparison.ToLower(value);
startIndex = startIndex + normalized.Length > text.Length
? text.Length - normalized.Length
: startIndex;
for (var i = startIndex; i >= 0; i--)
{
var match = true;
for (var j = 0; j < normalized.Length; j++)
{
// just use indexer of source text. perf of indexer depends on actual implementation of SourceText.
// * all of our implementation at editor layer should provide either O(1) or O(logn).
//
// only one implementation we have that could have bad indexer perf is CompositeText with heavily modified text
// at compiler layer but I believe that being used in find all reference will be very rare if not none.
if (!Match(normalized[j], text[i + j], caseSensitive))
{
match = false;
break;
}
}
if (match)
{
return(i);
}
}
return(-1);
}
private static bool EqualsOrdinalIgnoreCase(char thisChar, char otherChar)
{
// Do a fast check first before converting to lowercase characters.
return
(thisChar == otherChar ||
CaseInsensitiveComparison.ToLower(thisChar) == CaseInsensitiveComparison.ToLower(otherChar));
}
private static EditorConfigFile Parse(IEnumerable <string> lines)
{
var parsedOptions = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
foreach (var line in lines)
{
if (string.IsNullOrWhiteSpace(line) || IsComment(line))
{
continue;
}
var propMatches = s_propertyMatcher.Matches(line);
if (propMatches.Count > 0 && propMatches[0].Success)
{
var key = propMatches[0].Groups["key"].Value;
var value = propMatches[0].Groups["value"].Value;
Debug.Assert(!string.IsNullOrEmpty(key));
Debug.Assert(string.Equals(key, key.Trim(), StringComparison.Ordinal));
Debug.Assert(string.Equals(value, value.Trim(), StringComparison.Ordinal));
key = CaseInsensitiveComparison.ToLower(key);
if (s_reservedKeys.Contains(key) || s_reservedValues.Contains(value))
{
value = CaseInsensitiveComparison.ToLower(value);
}
parsedOptions[key] = value ?? "";
continue;
}
}
return(new EditorConfigFile(parsedOptions));
}
private static char[] ConvertToLowercaseArray(string text)
{
var array = ArrayPool<char>.GetArray(text.Length);
for (int i = 0; i < text.Length; i++)
{
array[i] = CaseInsensitiveComparison.ToLower(text[i]);
}
return array;
}
internal static int GetCaseInsensitiveFNVHashCode(string text, int start, int length)
{
int hashCode = Hash.FnvOffsetBias;
int end = start + length;
for (int i = start; i < end; i++)
{
hashCode = unchecked ((hashCode ^ CaseInsensitiveComparison.ToLower(text[i])) * Hash.FnvPrime);
}
return(hashCode);
}
internal int CompareToOrdinalIgnoreCase(StringSlice other)
{
var thisEnd = this._span.End;
var otherEnd = other._span.End;
for (int i = this._span.Start, j = other._span.Start;
i < thisEnd && j < otherEnd;
i++, j++)
{
var diff =
CaseInsensitiveComparison.ToLower(this._underlyingString[i]) -
CaseInsensitiveComparison.ToLower(other._underlyingString[j]);
if (diff != 0)
{
return(diff);
}
}
// Choose the one that is shorter if their prefixes match so far.
return(this.Length - other.Length);
}
public static CompilationCategorizedAnalyzerConfigOptions Parse(SourceText text)
{
var parsedOptions = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
foreach (var textLine in text.Lines)
{
var line = textLine.ToString();
if (string.IsNullOrWhiteSpace(line) || IsComment(line))
{
continue;
}
var propMatches = s_propertyMatcher.Matches(line);
if (propMatches.Count > 0 && propMatches[0].Groups.Count > 1)
{
var key = propMatches[0].Groups[1].Value;
var value = propMatches[0].Groups[2].Value;
Debug.Assert(!string.IsNullOrEmpty(key));
Debug.Assert(key == key.Trim());
Debug.Assert(value == value.Trim());
key = CaseInsensitiveComparison.ToLower(key);
if (s_reservedKeys.Contains(key) || s_reservedValues.Contains(value))
{
value = CaseInsensitiveComparison.ToLower(value);
}
parsedOptions[key] = value;
continue;
}
}
return(CompilationCategorizedAnalyzerConfigOptions.Create(parsedOptions));
}
public static bool TryParse(string?version, out LanguageVersion result)
{
if (version == null)
{
result = LanguageVersion.Default;
return(true);
}
switch (CaseInsensitiveComparison.ToLower(version))
{
case "default":
result = LanguageVersion.Default;
return(true);
case "latest":
result = LanguageVersion.Latest;
return(true);
case "latestmajor":
result = LanguageVersion.LatestMajor;
return(true);
case "preview":
result = LanguageVersion.Preview;
return(true);
case "1":
case "1.0":
case "iso-1":
result = LanguageVersion.CSharp1;
return(true);
case "2":
case "2.0":
case "iso-2":
result = LanguageVersion.CSharp2;
return(true);
case "3":
case "3.0":
result = LanguageVersion.CSharp3;
return(true);
case "4":
case "4.0":
result = LanguageVersion.CSharp4;
return(true);
case "5":
case "5.0":
result = LanguageVersion.CSharp5;
return(true);
case "6":
case "6.0":
result = LanguageVersion.CSharp6;
return(true);
case "7":
case "7.0":
result = LanguageVersion.CSharp7;
return(true);
case "7.1":
result = LanguageVersion.CSharp7_1;
return(true);
case "7.2":
result = LanguageVersion.CSharp7_2;
return(true);
case "7.3":
result = LanguageVersion.CSharp7_3;
return(true);
case "8":
case "8.0":
result = LanguageVersion.CSharp8;
return(true);
case "9":
case "9.0":
result = LanguageVersion.CSharp9;
return(true);
default:
result = LanguageVersion.Default;
return(false);
}
}
private static bool Match(char normalizedLeft, char right, bool caseSensitive)
{
return(caseSensitive ? normalizedLeft == right : normalizedLeft == CaseInsensitiveComparison.ToLower(right));
}
