// Compara esta sentencia compuesta con otra y dice si son iguales
public bool Equals(ComplexSentence cs)
{
if (cs == null)
{
return(false);
}
if (this == cs)
{
return(true);
}
bool result = false;
if (cs.GetHashCode() == this.GetHashCode())
{
if (cs.GetConnective().Equals(this.GetConnective()) &&
cs.GetNumberSimplerSentences() == this.GetNumberSimplerSentences())
{
// Si la conectiva y el número de sentencias más simples coincide, asumir que hay coincidencia y pasar a comprobar CADA sentencia simple
result = true;
for (int i = 0; i < this.GetNumberSimplerSentences(); i++)
{
if (!cs.GetSimplerSentence(i).Equals(this.GetSimplerSentence(i)))
{
result = false;
break;
}
}
}
}
return(result);
}
/**
* Rutina de utilidad que creará una representación en forma de cadena de una sentencia dada y la colocará entre paréntesis si es una sentencia compleja de menor precedencia que esta sentencia compleja.
* Nota: Esta es una forma de imprimir más bonita, donde sólo añadimos paréntesis en la representación de la sintaxis concreta si se necesitan
* para asegurarnos que se puede parsear de vuelta en la representación de sintaxix abstracta equivalente que usamos aquí.
*
* @param parentConnective
* la conectiva de la sentencia padre.
* @param childSentence
* una sentencia hija más simple.
* @return una representación en forma de cadena de la sentencia, entre paréntesis si el padre tiene mayor precedencia basándonos en su conectiva.
*/
public string BracketSentenceIfNecessary(Connective parentConnective, Sentence childSentence)
{
string result = null;
if (childSentence is ComplexSentence)
{
ComplexSentence cs = (ComplexSentence)childSentence;
if (cs.GetConnective().Precedence < parentConnective.Precedence)
{
result = "(" + childSentence + ")";
}
}
if (result == null)
{
result = childSentence.ToString();
}
return(result);
}
// Faltan por poner muchos comentarios aquí...
private IList <ParseNode> GroupSimplerSentencesByConnective(
Connective connectiveToConstruct, IList <ParseNode> parseNodes)
{
IList <ParseNode> newParseNodes = new List <ParseNode>(); // En vez de ArrayList, una List normal
int numSentencesMade = 0;
// Ir desde la derecha a la izquierda en orden para hacer asociatividad a la derecha, que es lo más natural para tener por defecto en lógica proposicional.
for (int i = parseNodes.Count - 1; i >= 0; i--)
{
ParseNode parseNode = parseNodes[i];
if (parseNode.node is Connective)
{
Connective tokenConnective = (Connective)parseNode.node;
if (tokenConnective == Connective.NOT)
{
// A unary connective
if (i + 1 < parseNodes.Count && parseNodes[i + 1].node is Sentence)
{
if (tokenConnective == connectiveToConstruct)
{
ComplexSentence newSentence = new ComplexSentence(
connectiveToConstruct,
(Sentence)parseNodes[i + 1].node);
parseNodes[i] = new ParseNode(newSentence, parseNode.token);
parseNodes[i + 1] = null;
numSentencesMade++;
}
}
else
{
throw new ParserException(
"Unary connective argurment is not a sentence at input position "
+ parseNode.token.GetStartCharPositionInInput(),
parseNode.token);
}
}
else
{
// A Binary connective
if ((i - 1 >= 0 && parseNodes[i - 1].node is Sentence) &&
(i + 1 < parseNodes.Count && parseNodes[i + 1].node is Sentence))
{
// A binary connective
if (tokenConnective == connectiveToConstruct)
{
ComplexSentence newSentence = new ComplexSentence(
connectiveToConstruct,
(Sentence)parseNodes[i - 1].node,
(Sentence)parseNodes[i + 1].node);
parseNodes[i - 1] = new ParseNode(newSentence, parseNode.token);
parseNodes[i] = null;
parseNodes[i + 1] = null;
numSentencesMade++;
}
}
else
{
throw new ParserException(
"Binary connective argurments are not sentences at input position "
+ parseNode.token
.GetStartCharPositionInInput(),
parseNode.token);
}
}
}
}
for (int i = 0; i < parseNodes.Count; i++)
{
ParseNode parseNode = parseNodes[i];
if (parseNode != null)
{
newParseNodes.Add(parseNode);
}
}
// Se asegura de que no quedan tokens sin contar en esta pasada.
int toSubtract = 0;
if (connectiveToConstruct == Connective.NOT)
{
toSubtract = (numSentencesMade * 2) - numSentencesMade;
}
else
{
toSubtract = (numSentencesMade * 3) - numSentencesMade;
}
if (parseNodes.Count - toSubtract != newParseNodes.Count)
{
throw new ParserException(
"Unable to construct sentence for connective: "
+ connectiveToConstruct + " from: " + parseNodes,
GetTokens(parseNodes));
}
return(newParseNodes);
}
