refactored SearchExpression
This commit is contained in:
@@ -0,0 +1,198 @@
|
||||
using System.Threading;
|
||||
|
||||
namespace ParadoxSaveParser.Lib;
|
||||
|
||||
/// <summary>Thrown when a query cannot be compiled because it is malformed or uses unsupported syntax.</summary>
|
||||
public class SearchExpressionException : Exception
|
||||
{
|
||||
public SearchExpressionException(string message, ReadOnlySpan<char> part)
|
||||
: base($"{message}: '{part}'")
|
||||
{
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// A query such as <c>countries.*.technology</c>, and the expression tree compiled from it.
|
||||
/// The tree is built on the first <see cref="Compile" /> and reused afterwards; only a change
|
||||
/// of encoding touches it again, and then only to re-encode its literal keys.
|
||||
/// </summary>
|
||||
public class SearchExpressionCompilation
|
||||
{
|
||||
private readonly string _query;
|
||||
|
||||
// guards the tree while it is built or re-encoded, so parsers on several threads
|
||||
// can share one compilation
|
||||
private readonly Lock _compileLock = new();
|
||||
|
||||
private ISearchExpression? _rootNode;
|
||||
private Encoding? _currentEncoding;
|
||||
|
||||
/// <param name="query">Search query. Compiled on the first call to <see cref="Compile" />.</param>
|
||||
/// <exception cref="ArgumentException">the query is empty</exception>
|
||||
public SearchExpressionCompilation(string query)
|
||||
{
|
||||
ArgumentException.ThrowIfNullOrEmpty(query);
|
||||
_query = query;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Returns the expression tree, with its literal keys encoded the way the save is.
|
||||
/// Compiles the query on the first call, and re-encodes the tree when the encoding changes.
|
||||
/// </summary>
|
||||
/// <param name="encoding">Encoding of the strings inside the save being parsed.</param>
|
||||
/// <exception cref="SearchExpressionException">the query is malformed</exception>
|
||||
public ISearchExpression Compile(Encoding encoding)
|
||||
{
|
||||
lock (_compileLock)
|
||||
{
|
||||
if (_rootNode is null)
|
||||
_rootNode = CompilePart(_query, encoding, null);
|
||||
// keys are stored as bytes, so another encoding means encoding them again
|
||||
else if (!encoding.Equals(_currentEncoding))
|
||||
_rootNode.ReEncode(encoding);
|
||||
|
||||
_currentEncoding = encoding;
|
||||
return _rootNode;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>True if <paramref name="chars" /> holds <paramref name="c" /> at
|
||||
/// <paramref name="i" /> as syntax, not as an escaped literal.</summary>
|
||||
private static bool CharEqualsAndNotEscaped(char c, ReadOnlySpan<char> chars, int i)
|
||||
// escaped if a backslash stands in either of the two preceding positions
|
||||
=> chars[i] == c && (i < 1 || chars[i - 1] != '\\') && (i < 2 || chars[i - 2] != '\\');
|
||||
|
||||
/// <summary>Compiles one path step together with everything that follows it.</summary>
|
||||
/// <param name="tail">
|
||||
/// Step that continues the path after this one ends, or <c>null</c> if nothing follows.
|
||||
/// Used for the part written after a group, as in <c>(a|b).c</c>, where every alternative
|
||||
/// of the group continues with the same <c>.c</c>.
|
||||
/// </param>
|
||||
private static ISearchExpression CompilePart(ReadOnlySpan<char> query, Encoding encoding,
|
||||
ISearchExpression? tail)
|
||||
{
|
||||
// empty alternative, as in "(a||b)"
|
||||
if (query.IsEmpty)
|
||||
throw new SearchExpressionException("Empty expression", query);
|
||||
|
||||
// "(a|b.c)" — a group of alternatives
|
||||
if (query[0] is '(')
|
||||
return CompileGroup(query, encoding, tail);
|
||||
|
||||
// a plain step: find the '.' that ends it
|
||||
int partBeforePointLength = 0;
|
||||
while (partBeforePointLength < query.Length)
|
||||
{
|
||||
if (CharEqualsAndNotEscaped('.', query, partBeforePointLength))
|
||||
break;
|
||||
partBeforePointLength++;
|
||||
}
|
||||
|
||||
// this step, and the rest of the path that becomes its child expression
|
||||
var part = query.Slice(0, partBeforePointLength);
|
||||
// empty step, as in "a..b" or ".b"
|
||||
if (part.IsEmpty)
|
||||
throw new SearchExpressionException("Empty path step", query);
|
||||
|
||||
ReadOnlySpan<char> remaining = default;
|
||||
if (partBeforePointLength < query.Length)
|
||||
{
|
||||
remaining = query.Slice(partBeforePointLength + 1);
|
||||
if (remaining.IsEmpty)
|
||||
throw new SearchExpressionException("Path ends with '.'", query);
|
||||
}
|
||||
|
||||
// when nothing follows this step, the path continues with the tail, which may be null too
|
||||
var next = remaining.IsEmpty ? tail : CompilePart(remaining, encoding, tail);
|
||||
|
||||
// "*" — any node at this level
|
||||
if (part is "*")
|
||||
return new AnyMatchExpression(next);
|
||||
// "~" — nothing at this level
|
||||
if (part is "~")
|
||||
return NoMatchExpression.Instance;
|
||||
|
||||
// a '*' anywhere else would be a wildcard inside a key
|
||||
for (int j = 0; j < part.Length; j++)
|
||||
if (CharEqualsAndNotEscaped('*', part, j))
|
||||
throw new SearchExpressionException("Pattern matching other than '*' is not supported", part);
|
||||
|
||||
// "[7]" — match by position
|
||||
if (part[0] is '[')
|
||||
{
|
||||
if (part[^1] is not ']')
|
||||
throw new SearchExpressionException("Index step has no closing ']'", part);
|
||||
// strip the brackets
|
||||
var indexText = part.Slice(1, part.Length - 2);
|
||||
if (!int.TryParse(indexText, out int index) || index < 0)
|
||||
throw new SearchExpressionException("Index must be a non-negative number", part);
|
||||
return new IndexMatchExpression(index, next);
|
||||
}
|
||||
|
||||
// an ordinary key
|
||||
return new ExactMatchExpression(part.ToString(), encoding, next);
|
||||
}
|
||||
|
||||
/// <summary>Compiles "(a|b)", and the path written after it, if there is one.</summary>
|
||||
private static ISearchExpression CompileGroup(ReadOnlySpan<char> query, Encoding encoding,
|
||||
ISearchExpression? tail)
|
||||
{
|
||||
int close = FindGroupEnd(query);
|
||||
|
||||
// "(a|b).c" — what stands after the group continues every alternative of it
|
||||
var afterGroup = query.Slice(close + 1);
|
||||
if (!afterGroup.IsEmpty)
|
||||
{
|
||||
if (CharEqualsAndNotEscaped(')', afterGroup, 0))
|
||||
throw new SearchExpressionException("Too many closing brackets", query);
|
||||
if (!CharEqualsAndNotEscaped('.', afterGroup, 0))
|
||||
throw new SearchExpressionException("Group must be followed by '.'", query);
|
||||
|
||||
var rest = afterGroup.Slice(1);
|
||||
if (rest.IsEmpty)
|
||||
throw new SearchExpressionException("Path ends with '.'", query);
|
||||
tail = CompilePart(rest, encoding, tail);
|
||||
}
|
||||
|
||||
// cut the group into alternatives and compile each of them with that same tail
|
||||
var subExprs = new List<ISearchExpression>();
|
||||
int begin = 1;
|
||||
int depth = 0;
|
||||
for (int i = 1; i < close; i++)
|
||||
{
|
||||
if (CharEqualsAndNotEscaped('(', query, i))
|
||||
depth++;
|
||||
else if (CharEqualsAndNotEscaped(')', query, i))
|
||||
depth--;
|
||||
// a deeper '|' belongs to a nested group and is compiled with it
|
||||
else if (depth == 0 && CharEqualsAndNotEscaped('|', query, i))
|
||||
{
|
||||
subExprs.Add(CompilePart(query.Slice(begin, i - begin), encoding, tail));
|
||||
begin = i + 1;
|
||||
}
|
||||
}
|
||||
|
||||
// the last alternative has no '|' after it
|
||||
subExprs.Add(CompilePart(query.Slice(begin, close - begin), encoding, tail));
|
||||
return new MultipleMatchExpression(subExprs);
|
||||
}
|
||||
|
||||
/// <summary>Finds the ')' that closes the group opened by the first character.</summary>
|
||||
private static int FindGroupEnd(ReadOnlySpan<char> query)
|
||||
{
|
||||
int depth = 0;
|
||||
for (int i = 0; i < query.Length; i++)
|
||||
{
|
||||
if (CharEqualsAndNotEscaped('(', query, i))
|
||||
depth++;
|
||||
else if (CharEqualsAndNotEscaped(')', query, i))
|
||||
{
|
||||
depth--;
|
||||
if (depth == 0)
|
||||
return i;
|
||||
}
|
||||
}
|
||||
|
||||
throw new SearchExpressionException("Too many opening brackets", query);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user