//
// PRIVATE
//
private void AssertLegalArguments(Connective connective, params Sentence[] sentences) // Sentence...
{
if (connective == null)
{
throw new ArgumentNullException("Connective must be specified."); // IllegalArgumentException
}
if (sentences == null)
{
throw new ArgumentNullException("> 0 simpler sentences must be specified."); // IllegalArgumentException
}
if (connective == Connective.NOT)
{
if (sentences.Length != 1) //en vez de Count (puede que sea incluso un array vacío... no nulo, pero vacío, ojo)
{
throw new ArgumentException("A not (~) complex sentence take exactly 1 simpler sentence not " + sentences.Length); // IllegalArgumentException
}
}
else
{
if (sentences.Length != 2)
{
throw new ArgumentException("Connective is binary (" + connective + ") but only " + sentences.Length + " simpler sentences provided"); // IllegalArgumentException
}
}
}
private ParseNode ParseConnective()
{
Token token = LookAhead(1);
Connective connective = Connective.Get(token.GetText());
Consume();
return(new ParseNode(connective, token));
}
/**
* Constructor.
*
* @param connective
* la conectiva de la sentencia compuesta
* @param sentences
* las sentencias más simples que forma la sentencia compuesta.
*/
public ComplexSentence(Connective connective, params Sentence[] sentences) // Sentence...
// Aserciones para comprobar los argumentos
{
AssertLegalArguments(connective, sentences);
this.connective = connective;
simplerSentences = new Sentence[sentences.Length];
Array.Copy(sentences, 0, simplerSentences, 0, sentences.Length); // System.arraycopy en Java, creo que los parámetros son equivalentes todos
}
/**
* 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);
}
//
// PROTECTED
//
protected bool HasConnective(Connective connective)
{
// Nota: se puede usar '==' ya que Connective es un enumerado.
return(GetConnective() == connective);
}
/**
* Constructor conveniente para sentencias binarias.
*
* @param sentenceL
* la sentencia de la izquierda.
* @param binaryConnective
* la conectiva binaria.
* @param sentenceR
* la sentencia de la derecha.
*/
public ComplexSentence(Sentence sentenceL, Connective binaryConnective, Sentence sentenceR) : this(binaryConnective, sentenceL, sentenceR)
{
}
