/// <summary>
/// Aplica o operador de atribuição.
/// </summary>
/// <param name="leftVariable">O primeiro argumento.</param>
/// <param name="rightValue">O segundo argumento.</param>
/// <returns>O resultado da aplicação do operador.</returns>
/// <exception cref="ExpressionInterpreterException">Se a aplicação do operador falhar.</exception>
private AMathematicsObject Assign(AMathematicsObject leftVariable, AMathematicsObject rightValue)
{
if (leftVariable.MathematicsType != EMathematicsType.NAME)
{
throw new ExpressionInterpreterException("All assigns must be attributed to a name.");
}
else
{
return(new AssignMathematicsObject(leftVariable, rightValue, this.mediator));
}
}
/// <summary>
/// Averigua se uma atribuição é recursiva.
/// </summary>
/// <param name="name">O nome da atribuição.</param>
/// <param name="value">O valor da atribuição.</param>
/// <returns>Verdadeiro se a atribuição é recursiva e falso caso contrário.</returns>
private bool IsAssignementRecursive(NameMathematicsObject name, AMathematicsObject value)
{
if (value.MathematicsType == EMathematicsType.INTEGER_VALUE ||
value.MathematicsType == EMathematicsType.DOUBLE_VALUE ||
value.MathematicsType == EMathematicsType.BOOLEAN_VALUE)
{
return(false);
}
else
{
throw new NotImplementedException();
}
}
/// <summary>
/// Instancia um novo objecto do tipo <see cref="BooleanConditionMathematicsObject"/>.
/// </summary>
/// <param name="leftObject">O primeiro membro da condição.</param>
/// <param name="rightObject">O segundo membro da condição.</param>
/// <param name="conditionType">O tipo da condição.</param>
/// <exception cref="ExpressionInterpreterException">Se a condição não for binária.</exception>
public BooleanConditionMathematicsObject(
AMathematicsObject leftObject,
AMathematicsObject rightObject,
EMathematicsConditionType conditionType)
: base(conditionType, EMathematicsType.CONDITION, false)
{
if (conditionType == EMathematicsConditionType.BOOLEAN_VALUE)
{
throw new ExpressionInterpreterException("Condition must be binary.");
}
this.leftObject = leftObject;
this.rightObject = rightObject;
}
/// <summary>
/// Instancia um novo objecto do tipo<see cref="AssignMathematicsObject"/>.
/// </summary>
/// <param name="leftObject">O objecto a ser atribuído.</param>
/// <param name="rightObject">O objecto a atribuir.</param>
/// <param name="mediator">O mediador.</param>
/// <exception cref="ExpressionInterpreterException">
/// Se o objecto atribuído for nulo.
/// </exception>
public AssignMathematicsObject(
AMathematicsObject leftObject,
AMathematicsObject rightObject,
MathematicsInterpreterMediator mediator)
: base(EMathematicsType.ASSIGN)
{
if (leftObject == null)
{
throw new ExpressionInterpreterException("Left object must be non null within an assignement.");
}
else
{
this.leftObject = leftObject;
this.rightObject = rightObject;
this.mediator = mediator;
}
}
/// <summary>
/// Atribui o nome.
/// </summary>
/// <param name="name">O nome.</param>
/// <param name="value">O valor.</param>
/// <exception cref="ExpressionInterpreterException">Se a atribuição for recursiva.</exception>
public void Assign(NameMathematicsObject name, AMathematicsObject value)
{
if (this.IsAssignementRecursive(name, value))
{
throw new ExpressionInterpreterException("Recursive assignment.");
}
else
{
if (this.assignements.ContainsKey(name))
{
this.assignements[name] = value;
}
else
{
this.assignements.Add(name, value);
}
}
}
/// <summary>
/// Função de transição inicial - estado 0.
/// </summary>
/// <param name="reader">O leitor de símbolos.</param>
/// <returns>O próximo estado.</returns>
private IState <string, string> StartTransition(ISymbolReader <string, string> reader)
{
var readed = reader.Get();
var topScopeDefinition = this.scopeDefinitionStack.Pop();
if (readed.SymbolType == "eof")
{
if (!string.IsNullOrEmpty(this.currentItem))
{
var symbolReader = new StringSymbolReader(new StringReader(this.currentItem), false);
this.lastExpressionResult = this.expressionReader.Parse(symbolReader);
this.currentItem = string.Empty;
if (this.lastExpressionResult.IsFunctionObject)
{
((AMathematicsFunctionObject)this.lastExpressionResult).Evaulate();
}
}
if (topScopeDefinition.ScopeType != EScopeType.MAIN)
{
this.currentResult.InterpreterMessageStatus = EMathematicsInterpreterStatus.WAITING;
this.currentResult.InterpreterResultMessage = "Sentence is incomplete. Scope delimiters don't match.";
if (topScopeDefinition.ScopeType == EScopeType.WHILE)
{
var whileCondition = topScopeDefinition.ConditionExpression;
if (whileCondition.AssertCondition())
{
(reader as StringSymbolReader).RestoreToMemento(topScopeDefinition.ScopeStartMemento);
}
}
else if (topScopeDefinition.ScopeType == EScopeType.FOR)
{
var updateExpression = topScopeDefinition.UpdateExpression;
updateExpression.Evaulate();
var forCondition = topScopeDefinition.ConditionExpression;
if (forCondition.AssertCondition())
{
(reader as StringSymbolReader).RestoreToMemento(topScopeDefinition.ScopeStartMemento);
}
}
this.scopeDefinitionStack.Push(topScopeDefinition);
return(this.stateList[1]);
}
else
{
this.currentResult.InterpreterMessageStatus = EMathematicsInterpreterStatus.COMPLETED;
this.currentResult.InterpreterResultMessage = this.lastExpressionResult.ToString();
return(this.stateList[1]);
}
}
else if (readed.SymbolType == "semi_colon")
{
var symbolReader = new StringSymbolReader(new StringReader(this.currentItem), false);
this.lastExpressionResult = this.expressionReader.Parse(symbolReader);
this.currentItem = string.Empty;
if (this.lastExpressionResult.IsFunctionObject)
{
((AMathematicsFunctionObject)this.lastExpressionResult).Evaulate();
}
if (topScopeDefinition.ScopeType == EScopeType.WHILE)
{
var whileCondition = topScopeDefinition.ConditionExpression;
if (whileCondition.AssertCondition())
{
(reader as StringSymbolReader).RestoreToMemento(topScopeDefinition.ScopeStartMemento);
}
}
else if (topScopeDefinition.ScopeType == EScopeType.FOR)
{
var updateExpression = topScopeDefinition.UpdateExpression;
updateExpression.Evaulate();
var forCondition = topScopeDefinition.ConditionExpression;
if (forCondition.AssertCondition())
{
(reader as StringSymbolReader).RestoreToMemento(topScopeDefinition.ScopeStartMemento);
}
}
this.scopeDefinitionStack.Push(topScopeDefinition);
}
else if (readed.SymbolType == "left_brace")
{
var innerScope = new ScopeDefinition()
{
ScopeType = EScopeType.INNER
};
this.scopeDefinitionStack.Push(topScopeDefinition);
this.scopeDefinitionStack.Push(innerScope);
}
else if (readed.SymbolType == "right_brace")
{
if (topScopeDefinition.ScopeType == EScopeType.MAIN)
{
return(this.SetupErrorAndQuit("Scope delimiters don't match."));
}
else if (topScopeDefinition.ScopeType == EScopeType.INNER)
{
return(this.stateList[0]);
}
else if (topScopeDefinition.ScopeType == EScopeType.WHILE)
{
var whileCondition = topScopeDefinition.ConditionExpression;
if (whileCondition.AssertCondition())
{
(reader as StringSymbolReader).RestoreToMemento(topScopeDefinition.ScopeStartMemento);
this.scopeDefinitionStack.Push(topScopeDefinition);
}
}
else if (topScopeDefinition.ScopeType == EScopeType.FOR)
{
var updateExpression = topScopeDefinition.UpdateExpression;
updateExpression.Evaulate();
var forCondition = topScopeDefinition.ConditionExpression;
if (forCondition.AssertCondition())
{
(reader as StringSymbolReader).RestoreToMemento(topScopeDefinition.ScopeStartMemento);
this.scopeDefinitionStack.Push(topScopeDefinition);
}
}
}
else if (readed.SymbolType == "while")
{
this.scopeDefinitionStack.Push(topScopeDefinition);
this.scopeDefinitionStack.Push(new ScopeDefinition()
{
ScopeType = EScopeType.WHILE
});
return(this.stateList[5]);
}
else if (readed.SymbolType == "if")
{
this.scopeDefinitionStack.Push(topScopeDefinition);
this.scopeDefinitionStack.Push(new ScopeDefinition()
{
ScopeType = EScopeType.IF_ELSE
});
return(this.stateList[5]);
}
else if (readed.SymbolType == "for")
{
this.scopeDefinitionStack.Push(topScopeDefinition);
this.scopeDefinitionStack.Push(new ScopeDefinition()
{
ScopeType = EScopeType.FOR
});
return(this.stateList[7]);
}
else if (readed.SymbolType == "else")
{
this.scopeDefinitionStack.Push(topScopeDefinition);
return(this.SetupErrorAndQuit("Unexpected word else."));
}
else
{
this.scopeDefinitionStack.Push(topScopeDefinition);
this.currentItem += readed.SymbolValue;
}
return(this.stateList[0]);
}
/// <summary>
/// Aplica o operador de conjunção lógica.
/// </summary>
/// <param name="leftVariable">O primeiro argumento.</param>
/// <param name="rightValue">O segundo argumento.</param>
/// <returns>O resultado da aplicação do operador.</returns>
/// <exception cref="ExpressionInterpreterException">Se a aplicação do operador falhar.</exception>
private AMathematicsObject LogicalConjunction(AMathematicsObject leftVariable, AMathematicsObject rightValue)
{
throw new NotImplementedException();
}
/// <summary>
/// Aplica o operador de comparaçáo de inferioridade ou igualdade.
/// </summary>
/// <param name="leftVariable">O primeiro argumento.</param>
/// <param name="rightValue">O segundo argumento.</param>
/// <returns>O resultado da aplicação do operador.</returns>
/// <exception cref="ExpressionInterpreterException">Se a aplicação do operador falhar.</exception>
private AMathematicsObject LesserOrEqualThan(AMathematicsObject leftVariable, AMathematicsObject rightValue)
{
throw new NotImplementedException();
}
/// <summary>
/// Aplica o operador de comparação de superioridade.
/// </summary>
/// <param name="leftVariable">O primeiro argumento.</param>
/// <param name="rightValue">O segundo argumento.</param>
/// <returns>O resultado da aplicação do operador.</returns>
/// <exception cref="ExpressionInterpreterException">Se a aplicação do operador falhar.</exception>
private AMathematicsObject GreaterThan(AMathematicsObject leftVariable, AMathematicsObject rightValue)
{
throw new NotImplementedException();
}
/// <summary>
/// Aplica o operador de comparação de igualdade.
/// </summary>
/// <param name="leftVariable">O primeiro argumento.</param>
/// <param name="rightValue">O segundo argumento.</param>
/// <returns>O resultado da aplicação do operador.</returns>
/// <exception cref="ExpressionInterpreterException">Se a aplicação do operador falhar.</exception>
private AMathematicsObject AreEqual(AMathematicsObject leftVariable, AMathematicsObject rightValue)
{
throw new NotImplementedException();
}
/// <summary>
/// Aplica o operador de obter simétrico.
/// </summary>
/// <param name="value">O argumento.</param>
/// <returns>O resultado da aplicação do operador.</returns>
/// <exception cref="ExpressionInterpreterException">Se a aplicação do operador falhar.</exception>
private AMathematicsObject Symmetric(AMathematicsObject value)
{
throw new NotImplementedException();
}
/// <summary>
/// Aplica o operador de exponenciação.
/// </summary>
/// <param name="leftValue">O primeiro argumento.</param>
/// <param name="rightValue">O segundo argumento.</param>
/// <returns>O resultado da aplicação do operador.</returns>
/// <exception cref="ExpressionInterpreterException">Se a aplicação do operador falhar.</exception>
private AMathematicsObject Exponentiate(AMathematicsObject leftValue, AMathematicsObject rightValue)
{
throw new NotImplementedException();
}
/// <summary>
/// Aplica o operador de multiplicação.
/// </summary>
/// <param name="leftValue">O primeiro argumento.</param>
/// <param name="rightValue">O segundo argumento.</param>
/// <returns>O resultado da aplicação do operador.</returns>
/// <exception cref="ExpressionInterpreterException">Se a aplicação do operador falhar.</exception>
private AMathematicsObject Multiply(AMathematicsObject leftValue, AMathematicsObject rightValue)
{
throw new NotImplementedException();
}
/// <summary>
/// Aplica o operador de subtracção.
/// </summary>
/// <param name="leftValue">O primeiro argumento.</param>
/// <param name="rightValue">O segundo argumento.</param>
/// <returns>O resultado da aplicação do operador.</returns>
/// <exception cref="ExpressionInterpreterException">Se a aplicação do operador falhar.</exception>
private AMathematicsObject Subtract(AMathematicsObject leftValue, AMathematicsObject rightValue)
{
throw new NotImplementedException();
}
/// <summary>
/// Tenta obter o valor atribuído ao nome.
/// </summary>
/// <param name="name">O nome.</param>
/// <param name="value">A referência que recebe o valor.</param>
/// <returns>Veradeiro caso o nome esteja atribuído e falso caso contrário.</returns>
public bool TryGetValue(NameMathematicsObject name, out AMathematicsObject value)
{
return(this.assignements.TryGetValue(name, out value));
}
