private static Result<Quantity, Error<QuantityError>> GetError(
ParseSettings parseSettings,
QuantityError quantityError,
Lexemes lexemes)
{
var error = Error.From(quantityError, lexemes.Current);
if (parseSettings.ThrowOnError)
{
throw new QuantityParseException(error);
}
return Result.Error(error);
}
private Expression MultiplicativeExpression(Lexemes lexemes, Expression lhs, ParseSettings parseSettings)
{
if (lexemes.AcceptToken(Constants.Multiply) || lexemes.AcceptToken(Constants.MultiplyDot)
|| lexemes.AcceptToken(Constants.MultiplyCross))
{
var rhs = this.TryMagnitudeExpression(lexemes, parseSettings);
return this.MultiplicativeExpression(lexemes, new MultiplicationExpression(lhs, rhs), parseSettings);
}
if (lexemes.AcceptToken(Constants.Divide))
{
var rhs = this.TryMagnitudeExpression(lexemes, parseSettings);
return this.MultiplicativeExpression(lexemes, new DivisionExpression(lhs, rhs), parseSettings);
}
return lhs;
}
/// <summary>
/// Parses the specified lexeme list.
/// </summary>
/// <param name="lexemes">The lexemes.</param>
/// <param name="parseSettings">The parse settings.</param>
/// <returns>
/// The parsed expression.
/// </returns>
public Result<Expression, Error<ExpressionError>> Parse(Lexemes lexemes, ParseSettings parseSettings)
{
try
{
var expression = this.Expression(lexemes, parseSettings);
string token;
if (parseSettings.AssertEnd && !lexemes.AcceptTokenType(TokenType.End, out token))
{
throw CreateParseException(ExpressionError.EndOfDataNotFound, lexemes.Current);
}
return Result.Success(expression);
}
catch (ExpressionParseException expressionParseException)
{
if (parseSettings.ThrowOnError)
{
throw;
}
return Result.Error(expressionParseException.Error);
}
}
/// <summary>
/// Parses the specified quantity.
/// </summary>
/// <param name="lexemes">The lexemes.</param>
/// <param name="parseSettings">The parse settings.</param>
/// <returns>
/// A <see cref="Quantity" />.
/// </returns>
/// <exception cref="QuantityParseException">Exception thrown when parsing fails.</exception>
public Result<Quantity, Error<QuantityError>> Parse(Lexemes lexemes, ParseSettings parseSettings)
{
string number;
if (lexemes.AcceptTokenType(TokenType.Number, out number))
{
var value = double.Parse(number, parseSettings.CultureInfo);
var result = this.expressionParser.Parse(
lexemes,
new ParseSettings(parseSettings.CultureInfo, false, false));
if (parseSettings.AssertEnd && lexemes.AcceptTokenType(TokenType.End))
{
return GetError(parseSettings, QuantityError.EndOfDataNotFound, lexemes);
}
return Result.For(
result,
expression => new Quantity(value, this.unitFactory.Create(expression)),
error => Error.From(QuantityError.UnitNotFound, lexemes.Current, error));
}
return GetError(parseSettings, QuantityError.NumberNotFound, lexemes);
}
/// <summary>
/// Gets the unit.
/// </summary>
/// <param name="unit">The unit as a string.</param>
/// <param name="parseSettings">The parse settings.</param>
/// <returns>
/// An <see cref="IUnit" /> based on the specified <see cref="string" />.
/// </returns>
public Result<IUnit, Error<ExpressionError>> GetUnit(string unit, ParseSettings parseSettings)
{
var result = this.ParseExpression(unit, parseSettings);
return Result.For(result, this.GetUnit);
}
internal Result<Expression, Error<ExpressionError>> ParseExpression(string unit, ParseSettings parseSettings)
{
var analysisResult = this.lexicalAnalyzer.Analyze(unit, parseSettings.ThrowOnError);
if (analysisResult)
{
return this.expressionParser.Parse(analysisResult.Value, parseSettings);
}
return Result.Error(Error.From(ExpressionError.LexicalAnalysisFailed, null, analysisResult.Error));
}
/// <summary>
/// Gets the specified unit.
/// </summary>
/// <param name="unit">The unit.</param>
/// <param name="parseSettings">The parse settings.</param>
/// <returns>
/// An <see cref="IUnit" />.
/// </returns>
public static Result<IUnit, Error<ExpressionError>> GetUnitFrom(string unit, ParseSettings parseSettings)
{
EnsureInitialization();
return Instance.GetUnit(unit, parseSettings);
}
private Expression TryMultiplicativeExpression(Lexemes lexemes, ParseSettings parseSettings)
{
var expression = this.TryMagnitudeExpression(lexemes, parseSettings);
return this.MultiplicativeExpression(lexemes, expression, parseSettings);
}
private Expression Expression(Lexemes lexemes, ParseSettings parseSettings)
{
return this.TryMultiplicativeExpression(lexemes, parseSettings);
}
private ConstantExpression ConstantExpression(Lexemes lexemes, ParseSettings parseSettings)
{
string number;
if (lexemes.AcceptTokenType(TokenType.Number, out number))
{
return new ConstantExpression(double.Parse(number, parseSettings.CultureInfo));
}
throw CreateParseException(ExpressionError.NumberNotFound, lexemes.Current);
}
private Expression PrimaryExpression(Lexemes lexemes, ParseSettings parseSettings)
{
if (lexemes.AcceptToken(Constants.LeftParenthesis))
{
var expression = this.Expression(lexemes, parseSettings);
if (lexemes.AcceptToken(Constants.RightParenthesis))
{
return new ParenthesisExpression(expression);
}
throw CreateParseException(ExpressionError.RightParenthesisNotFound, lexemes.Current);
}
if (lexemes.AcceptToken(Constants.LeftWeakParenthesis))
{
var expression = this.Expression(lexemes, parseSettings);
if (lexemes.AcceptToken(Constants.RightWeakParenthesis))
{
return expression;
}
throw CreateParseException(ExpressionError.RightWeakParenthesisNotFound, lexemes.Current);
}
string identifier;
if (lexemes.AcceptTokenType(TokenType.Identifier, true, out identifier))
{
var result = this.unitExpressionParser.Parse(identifier, false);
if (result)
{
return result.Value;
}
throw CreateParseException(ExpressionError.IdentifierNotFound, lexemes.MoveToPrevious(), result.Error);
}
return this.ConstantExpression(lexemes, parseSettings);
}
private Expression MagnitudeExpression(Lexemes lexemes, Expression lhs, ParseSettings parseSettings)
{
if (lexemes.AcceptToken(Constants.Power))
{
var constantExpression = this.ConstantExpression(lexemes, parseSettings);
return this.MagnitudeExpression(
lexemes,
new MagnitudeExpression(lhs, constantExpression),
parseSettings);
}
string exponent;
if (lexemes.AcceptTokenType(TokenType.Exponent, out exponent))
{
var constantExpression =
new ConstantExpression(
double.Parse(CharacterConverter.FromExponentNotation(exponent), parseSettings.CultureInfo));
return this.MagnitudeExpression(
lexemes,
new MagnitudeExpression(lhs, constantExpression),
parseSettings);
}
return lhs;
}
private Expression TryMagnitudeExpression(Lexemes lexemes, ParseSettings parseSettings)
{
var lhs = this.PrimaryExpression(lexemes, parseSettings);
return this.MagnitudeExpression(lexemes, lhs, parseSettings);
}