// 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); }