public override void Validate(out ParserError error)
{
error = ParserError.Empty;
}
public abstract void Validate(out ParserError error);
public abstract object GetValue(Dictionary <GridCoordinates, object> childCells, out ParserError error);
private LinkedListNode <ILexem> HandleBinarOperation(LinkedListNode <ILexem> initNode, out ParserError error)
{
var curOpToken = initNode.Value as OperationToken;
var prevNode = initNode.Previous;
var nextNode = initNode.Next;
if (prevNode == null)
{
error = new ParserError($"Can't find left argument of {curOpToken.ActualValue} at: {curOpToken.Position}");
return(initNode);
}
if (nextNode == null)
{
error = new ParserError($"Can't find right argument of {curOpToken.ActualValue} at: {curOpToken.Position}");
return(initNode);
}
if (!(prevNode.Value is OpRand leftOpRand))
{
error = new ParserError($"Wrong left operand of {curOpToken.ActualValue} at: {curOpToken.Position}");
return(initNode);
}
if (!(nextNode.Value is OpRand rightOpRand))
{
error = new ParserError($"Wrong right operand of {curOpToken.ActualValue} at: {curOpToken.Position}");
return(initNode);
}
prevNode.List.Remove(prevNode);
nextNode.List.Remove(nextNode);
return(Replace(initNode, new BinarOp(curOpToken.Value, leftOpRand, rightOpRand, out error)));
}
public override object GetValue(Dictionary <GridCoordinates, object> childCells, out ParserError error)
{
try {
error = new ParserError("Something went wrong in expression");
if (expressionComponents.First.Value is OpRand opRand)
{
return(opRand.GetValue(childCells, out error));
}
if (expressionComponents.First.Value is StringToken strToken)
{
error = ParserError.Empty;
return(strToken.Value);
}
return(null);
} catch {
error = new ParserError("Wrong expression");
return(null);
}
}
public override void Validate(out ParserError error)
{
Argument.Validate(out error);
}
private object GetDivideValue(Dictionary <GridCoordinates, object> childCells, out ParserError error)
{
error = ParserError.Empty;
if (leftValue is Decimal leftNum && rightValue is Decimal rightNum)
{
if (rightNum == 0)
{
error = new ParserError("Omg, it was so predictable...\nBut it's just an error\n Infinities are bad");
return(null);
}
return(leftNum / rightNum);
}
error = new ParserError($"{OpName} operation must have number type arguments:\n" +
$" {leftValue.GetType().ToString()} and {rightValue.GetType().ToString()} were found.");
return(null);
}
private LinkedListNode <ILexem> HandleSubExpression(LinkedListNode <ILexem> lParNode, LinkedListNode <ILexem> rParNode, out ParserError error)
{
Debug.Assert(lParNode != null && rParNode != null);
Debug.Assert(lParNode.Value is SeparatorToken lSep && lSep.Value == SeparatorToken.Separator.LParen);
Debug.Assert(rParNode.Value is SeparatorToken rSep && rSep.Value == SeparatorToken.Separator.RParen);
Debug.Assert(lParNode.List == rParNode.List);
var tokens = lParNode.List;
var subExprLexems = new LinkedList <ILexem>();
var curNode = lParNode.Next;
while (curNode != rParNode)
{
var nxtNode = curNode.Next;
subExprLexems.AddLast(curNode.Value);
tokens.Remove(curNode);
curNode = nxtNode;
}
curNode = tokens.AddBefore(rParNode, new Expression(subExprLexems, out error));
tokens.Remove(lParNode);
tokens.Remove(rParNode);
return(curNode);
}
private LinkedListNode <ILexem> HandleStringTerm(LinkedListNode <ILexem> initNode, out ParserError error)
{
error = ParserError.Empty;
var posibleError = new ParserError($"Unexpected token: \" at {((Token)initNode.Value).Position}");
var tokens = initNode.List;
var strNode = initNode.Next;
if (strNode == null)
{
error = posibleError;
return(initNode);
}
if (!(strNode.Value is StringToken strToken))
{
error = posibleError;
return(initNode);
}
tokens.Remove(initNode);
strNode = Replace(strNode, new Term(strToken));
var closeQuote = strNode.Next;
if (closeQuote == null || !IsQuote(closeQuote.Value))
{
error = posibleError;
return(initNode);
}
tokens.Remove(closeQuote);
return(strNode);
}
public BinarOp(OperationToken.Operation opName, OpRand leftOpRand, OpRand rightOpRand, out ParserError error)
{
error = ParserError.Empty;
this.OpName = opName;
this.LeftOpRand = leftOpRand;
this.RightOpRand = rightOpRand;
}
private object GetLessEqValue(Dictionary <GridCoordinates, object> childCells, out ParserError error)
{
error = ParserError.Empty;
if (leftValue is bool || rightValue is bool)
{
error = new ParserError($"{OpName} operation chant have bool arguments");
}
if (leftValue is string leftStr && rightValue is string rightStr)
{
return(leftStr.Length <= rightStr.Length);
}
if (leftValue is string leftStr1 && rightValue is Decimal rightNum1)
{
return(leftStr1.Length <= rightNum1);
}
if (leftValue is Decimal leftNum && rightValue is Decimal rightNum)
{
return(leftNum <= rightNum);
}
error = new ParserError($"{OpName} operation has wrong argument types");
return(null);
}
private object GetEqualValue(Dictionary <GridCoordinates, object> childCells, out ParserError error)
{
error = ParserError.Empty;
return(leftValue.Equals(rightValue));
}
public override object GetValue(Dictionary <GridCoordinates, object> childCells, out ParserError error)
{
leftValue = LeftOpRand.GetValue(childCells, out error);
if (!error.IsEmpty)
{
return(null);
}
rightValue = RightOpRand.GetValue(childCells, out error);
if (!error.IsEmpty)
{
return(null);
}
try {
switch (OpName)
{
case OperationToken.Operation.Plus: return(GetPlusValue(childCells, out error));
case OperationToken.Operation.Minus: return(GetMinusValue(childCells, out error));
case OperationToken.Operation.Mult: return(GetMultValue(childCells, out error));
case OperationToken.Operation.Divide: return(GetDivideValue(childCells, out error));
case OperationToken.Operation.Mod: return(GetModValue(childCells, out error));
case OperationToken.Operation.Div: return(GetDivValue(childCells, out error));
case OperationToken.Operation.More: return(GetMoreValue(childCells, out error));
case OperationToken.Operation.MoreEq: return(GetMoreEqValue(childCells, out error));
case OperationToken.Operation.Less: return(GetLessValue(childCells, out error));
case OperationToken.Operation.LessEq: return(GetLessEqValue(childCells, out error));
case OperationToken.Operation.Equal: return(GetEqualValue(childCells, out error));
case OperationToken.Operation.UnEqual: return(GetUnEqualValue(childCells, out error));
default: {
error = new ParserError($"Strange binar operation{OpName.ToString()}");
return(null);
}
}
} catch (Exception e) {
error = new ParserError(e.Message);
return(null);
}
}
private object GetMinusValue(Dictionary <GridCoordinates, object> childCells, out ParserError error)
{
error = ParserError.Empty;
if (leftValue is Decimal leftNum && rightValue is Decimal rightNum)
{
return(leftNum - rightNum);
}
error = new ParserError($"{OpName} operation must have number type arguments:\n" +
$" {leftValue.GetType().ToString()} and {rightValue.GetType().ToString()} were found.");
return(null);
}
public override object GetValue(Dictionary <GridCoordinates, object> childCells, out ParserError error)
{
error = ParserError.Empty;
if (IsLogic)
{
return(AsLogic);
}
if (IsString)
{
return(AsString);
}
if (IsNumber)
{
return(AsNumber);
}
if (Value is CellNameToken cellName)
{
if (!childCells.ContainsKey(cellName.Value))
{
(string x, string y) = cellName.Value.GetStringCoords();
error = new ParserError($"Don't know the value of {x + y} cell.");
return(null);
}
return(childCells[cellName.Value]);
}
error = new ParserError($"Strange term at {Value.Position}");
return(null);
}
private LinkedListNode <ILexem> HandleIfOperation(LinkedListNode <ILexem> curNode, out ParserError error)
{
var argumentNode = curNode.Next;
if (argumentNode == null)
{
error = new ParserError($"Can't find IF arguments at: {((Token)curNode.Value).Position}");
return(curNode);
}
if (!(argumentNode.Value is Expression argExpr))
{
error = new ParserError($"IF must has arguments at: {((Token)curNode.Value).Position}");
return(curNode);
}
curNode.List.Remove(curNode);
var oprands = new OpRandsList(argExpr, out error);
if (!error.IsEmpty)
{
return(argumentNode);
}
return(Replace(argumentNode, new UnarOp(OperationToken.Operation.If, oprands, out error)));
}
private object GetMinusValue(Dictionary <GridCoordinates, object> childCells, out ParserError error)
{
object argValue = Argument.GetValue(childCells, out error);
if (!error.IsEmpty)
{
return(null);
}
if (argValue is Decimal decValue)
{
return(-decValue);
}
error = new ParserError($"Unar {OpName.ToString()} operation has wrong argument type");
return(null);
}
private LinkedListNode <ILexem> HandleUnarOperation(LinkedListNode <ILexem> curNode, out ParserError error)
{
var currentOperation = ((OperationToken)curNode.Value).Value;
var nextNode = curNode.Next;
if (nextNode == null)
{
error = new ParserError($"Can't find unar plus' argument at: {((Token)curNode.Value).Position}");
return(curNode);
}
if (curNode.Previous != null && curNode.Previous.Value is OpRand)
{
error = ParserError.Empty;
return(curNode);
}
curNode.List.Remove(curNode);
var nextOpRand = nextNode.Value as OpRand;
if (nextOpRand == null)
{
error = new ParserError($"Can't find Unar {currentOperation.ToString()} argument");
return(curNode);
}
return(Replace(nextNode, new UnarOp(currentOperation, nextOpRand, out error)));
}
public override object GetValue(Dictionary <GridCoordinates, object> childCells, out ParserError error)
{
try {
switch (OpName)
{
case OperationToken.Operation.If: return(GetIfValue(childCells, out error));
case OperationToken.Operation.Plus: return(GetPlusValue(childCells, out error));
case OperationToken.Operation.Minus: return(GetMinusValue(childCells, out error));
case OperationToken.Operation.Not: return(GetNotValue(childCells, out error));
default: {
error = new ParserError($"Unexpected UnarOperation: {OpName.ToString()}");
return(null);
}
}
} catch (Exception e) {
error = new ParserError(e.Message);
return(null);
}
}
public override object GetValue(Dictionary <GridCoordinates, object> childCells, out ParserError error)
{
error = new ParserError("Can't find value of OperandList");
return(null);
}