/// <summary>
/// Initializes a new instance of the <see cref="ExpressionParsingServiceBase" /> class with a specified math
/// definition
/// object.
/// </summary>
/// <param name="definition">The math definition to use.</param>
protected private ExpressionParsingServiceBase(MathDefinition definition)
{
// Preconditions
Requires.NotNull(
out workingDefinition,
definition,
nameof(definition));
// Initialized internal state
constantExtractors = new LevelDictionary <Type, IConstantsExtractor>();
constantInterpreters = new LevelDictionary <Type, IConstantInterpreter>();
constantPassThroughExtractors = new LevelDictionary <Type, IConstantPassThroughExtractor>();
stringFormatters = new List <IStringFormatter>();
nonaryFunctions = new Dictionary <string, Type>();
unaryFunctions = new Dictionary <string, Type>();
binaryFunctions = new Dictionary <string, Type>();
ternaryFunctions = new Dictionary <string, Type>();
assembliesToRegister = new List <Assembly>
{
typeof(ExpressionParsingService).GetTypeInfo()
.Assembly
};
}
internal WorkingExpressionSet(
string expression,
MathDefinition mathDefinition,
Dictionary <string, Type> nonaryFunctions,
Dictionary <string, Type> unaryFunctions,
Dictionary <string, Type> binaryFunctions,
Dictionary <string, Type> ternaryFunctions,
LevelDictionary <Type, IConstantsExtractor> extractors,
LevelDictionary <Type, IConstantInterpreter> interpreters,
List <IStringFormatter> stringFormatters,
CancellationToken cancellationToken)
{
ParameterRegistry = new StandardParameterRegistry(stringFormatters);
ConstantsTable = new Dictionary <string, ConstantNodeBase>();
ReverseConstantsTable = new Dictionary <string, string>();
SymbolTable = new Dictionary <string, ExpressionSymbol>();
ReverseSymbolTable = new Dictionary <string, string>();
StringFormatters = stringFormatters;
CancellationToken = cancellationToken;
Expression = expression;
Definition = mathDefinition;
AllOperatorsInOrder = new[]
{
mathDefinition.GreaterThanOrEqualSymbol,
mathDefinition.LessThanOrEqualSymbol,
mathDefinition.GreaterThanSymbol,
mathDefinition.LessThanSymbol,
mathDefinition.NotEqualsSymbol,
mathDefinition.EqualsSymbol,
mathDefinition.XorSymbol,
mathDefinition.OrSymbol,
mathDefinition.AndSymbol,
mathDefinition.AddSymbol,
mathDefinition.SubtractSymbol,
mathDefinition.DivideSymbol,
mathDefinition.MultiplySymbol,
mathDefinition.PowerSymbol,
mathDefinition.LeftShiftSymbol,
mathDefinition.RightShiftSymbol,
mathDefinition.NotSymbol
};
NonaryFunctions = nonaryFunctions;
UnaryFunctions = unaryFunctions;
BinaryFunctions = binaryFunctions;
TernaryFunctions = ternaryFunctions;
Extractors = extractors;
Interpreters = interpreters;
FunctionRegex = new Regex(
$@"(?'functionName'.*?){Regex.Escape(mathDefinition.Parentheses.Left)}(?'expression'.*?){Regex.Escape(mathDefinition.Parentheses.Right)}");
}
public string ExtractAllConstants(
string originalExpression,
IDictionary <string, ConstantNodeBase> constantsTable,
IDictionary <string, string> reverseConstantsTable,
MathDefinition mathDefinition)
{
var stringIndicatorString = mathDefinition.StringIndicator;
var stringIndicator = mathDefinition.StringIndicator.AsSpan();
var stringIndicatorLength = stringIndicator.Length;
var escapeCharacter = mathDefinition.EscapeCharacter.AsSpan();
var escapeCharacterLength = escapeCharacter.Length;
var process = originalExpression.AsSpan();
StringBuilder?sb = null;
while (true)
{
var openingPosition = process.IndexOf(
stringIndicator,
StringComparison.CurrentCulture);
if (openingPosition == -1)
{
// No string opening
break;
}
var header = process.Slice(
0,
openingPosition);
var rest = process.Slice(openingPosition + stringIndicatorLength);
int closingPosition;
ReadOnlySpan <char> body;
do
{
closingPosition = rest.IndexOf(stringIndicator, StringComparison.CurrentCulture);
if (closingPosition != -1)
{
body = rest.Slice(
0,
closingPosition);
int occurrences = 0;
while (body.EndsWith(escapeCharacter))
{
occurrences++;
body = body.Slice(
0,
body.Length - escapeCharacterLength);
}
rest = rest.Slice(closingPosition + stringIndicatorLength);
if (occurrences % 2 == 0)
{
break;
}
}
}while (closingPosition != -1);
if (closingPosition == -1)
{
// No string closing
break;
}
// We have a proper string
body = process.Slice(
openingPosition,
process.Length - header.Length - rest.Length);
var itemName = ConstantsGenerator.GenerateStringConstant(
constantsTable,
reverseConstantsTable,
originalExpression,
stringIndicatorString,
body.ToString());
sb ??= new StringBuilder(originalExpression.Length);
#if NETSTANDARD21_OR_GREATER
sb.Append(header);
#else
sb.Append(header.ToString());
#endif
sb.Append(itemName);
process = rest;
}
if (sb == null)
{
return(originalExpression);
}
#if NETSTANDARD21_OR_GREATER
sb.Append(process);
#else
sb.Append(process.ToString());
#endif
return(sb.ToString());
}
/// <summary>
/// Initializes a new instance of the <see cref="ExpressionParsingService" /> class with a specified math definition
/// object.
/// </summary>
/// <param name="definition">The math definition to use.</param>
public ExpressionParsingService(MathDefinition definition)
: base(definition)
{
}
/// <summary> /// Extracts all constants, replacing them from the original expression. /// </summary> /// <param name="originalExpression">The original expression.</param> /// <param name="constantsTable">The constants table.</param> /// <param name="reverseConstantsTable">The reverse constants table.</param> /// <param name="mathDefinition">The math definition.</param> /// <returns>The expression, after replacement.</returns> public string ExtractAllConstants(string originalExpression, IDictionary <string, ConstantNodeBase> constantsTable, IDictionary <string, string> reverseConstantsTable, MathDefinition mathDefinition) => exponentialNotationRegex.Replace(originalExpression, "stupid", 1);
