/// <summary>
/// Adds a child to the node.
/// </summary>
/// <param name="childNode">
/// A <see cref="SequenceNode"/>
/// </param>
public void AddChildSequence(SequenceNode childNode)
{
AddChildSequenceArgs _args = new AddChildSequenceArgs(childNode);
Application.Invoke(this,
_args,
delegate(object sender, EventArgs args)
{
AddChildSequenceArgs a = args as AddChildSequenceArgs;
a.ChildNode.NodeName =
String.Format("{0}.{1}", this.NodeName, this.ChildCount + 1);
this.AddChild(a.ChildNode);
if (widget != null)
{
// We expand the node
widget.ExpandAll();
widget.ColumnsAutosize();
}
});
}
public SequenceAddedArgs(SequenceNode sequence)
{
this.sequence = sequence;
}
public AddChildSequenceArgs(SequenceNode childNode)
{
this.childNode= childNode;
}
/// <summary>
/// Adds a child to the node.
/// </summary>
/// <param name="childNode">
/// A <see cref="SequenceNode"/>
/// </param>
public void AddChildSequence(SequenceNode childNode)
{
AddChildSequenceArgs _args = new AddChildSequenceArgs(childNode);
Application.Invoke(this,
_args,
delegate(object sender, EventArgs args)
{
AddChildSequenceArgs a = args as AddChildSequenceArgs;
a.ChildNode.NodeName =
String.Format("{0}.{1}",this.NodeName,this.ChildCount+1);
this.AddChild(a.ChildNode);
if(widget!=null)
{
// We expand the node
widget.ExpandAll();
widget.ColumnsAutosize();
}
});
}
private void SequenceAddedInvoker(SequenceNode sequence)
{
if(SequenceAdded !=null)
SequenceAdded(this, new SequenceAddedArgs(sequence));
}
/// <summary>
/// Matches a given token sequence into one or more Tokens.
/// </summary>
/// <param name="sequence">
/// The token sequence (possibly) containing tokens.
/// </param>
private void MatchTokens(SequenceNode node)
{
TokenSequence discarded = new TokenSequence();
TokenSequence accepted = new TokenSequence();
SequenceNode acceptedNode = new SequenceNode(accepted, view);
SequenceNode discardedNode = new SequenceNode(discarded, view);
TokenSequence sequence = node.Sequence;
node.AddChildSequence(acceptedNode);
foreach (Token t in sequence)
{
accepted.Append(t);
}
NodeBeingProcessedInvoker(node);
SuspendByStep();
bool found = false;
Token foundToken = null;
bool discardedNodeAdded = false;
MessageLogSentInvoker("===== Tratando la secuencia {0} =====",
node.NodeName);
while(accepted.Count > 0 && !found)
{
foreach (LexicalRule rule in lexicalRules)
{
found = rule.Match(accepted, out foundToken);
MessageLogSentInvoker("¿La regla «{0}» acepta la secuencia ({1})?: {2}",
rule.Name,
accepted.ToString(),
found?"Sí":"No");
SequenceBeingMatchedInvoker(foundToken, rule, found);
SuspendByStep();
if(found)
{
// We search no more.
break;
}
Thread.Sleep(50);
}
// We check if a token was found
if(!found)
{
// We remove the token from the input sequence and add it
// at the beggining of the discarded set.
int lastIndex = accepted.Count -1;
if(!discardedNodeAdded)
{
// If we haven't done so, we add the discarded sequence.
node.AddChildSequence(discardedNode);
discardedNodeAdded = true;
}
this.MatchingFailedInvoker();
MessageLogSentInvoker("Se elimina el último símbolo de la secuencia {0} para seguir probando.",
accepted.ToString());
discarded.Prepend(accepted[lastIndex]);
accepted.RemoveAt(lastIndex);
}
else
{
// We found a token, so we stop searching and add
// the token to the result.
acceptedNode.FoundToken = foundToken;
}
}
if(found && discarded.Count > 0)
{
MessageLogSentInvoker("Se tratará la secuencia de símbolos descartados.");
// We follow the recursive path.
MatchTokens(discardedNode);
}
else if(found && discarded.Count ==0)
{
// Only one token was found, we assimilate the acceptedNode
// with its parent.
node.FoundToken = foundToken;
node.RemoveSequenceChildren();
}
else
{
// If nothing was found, we remove the children.
node.RemoveSequenceChildren();
MessageLogSentInvoker("No se pudo reconocer la secuencia {0}.",
node.Sequence.ToString());
}
StepDoneInvoker();
SuspendByNode();
}
/// <summary>
/// Processes the tokens given as an input to the controller.
/// </summary>
/// <returns>
/// The list of sequences of contiguous tokens.
/// </returns>
private List<SequenceNode> GetTokenSequences()
{
List<SequenceNode> tokenSequences = new List<SequenceNode>();
SequenceNode node = null;
Token lastToken = null;
Token currentToken = null;
// All the tokens must be in one sequence.
while(this.tokens.Count > 0)
{
TokenSequence foundSequence = null;
currentToken = tokens[0];
NodeBeingProcessedInvoker(null);
if(tokenSequences.Count ==0)
TokenCheckedInvoker(null, currentToken);
foreach (SequenceNode storedNode in tokenSequences)
{
// We search the stored sequences so we may find one that
// has the same baseline as the one being checked.
storedNode.Select();
this.MessageLogSentInvoker("Comprobando si «{0}» puede formar parte de la secuencia {1}",
currentToken.Text,
storedNode.NodeName);
lastToken = storedNode.Sequence.Last;
TokenCheckedInvoker(new TokenSequence(storedNode.Sequence),
currentToken);
if(tokenSequences.Count>1)
SuspendByStep();
if(currentToken.CloseFollows(lastToken))
{
foundSequence = storedNode.Sequence;
break;
}
Thread.Sleep(50);
}
if(foundSequence == null)
{
// If the symbols aren't contiguous, a new sequence has
// commenced.
foundSequence = new TokenSequence();
node = new SequenceNode(foundSequence, view);
tokenSequences.Add(node);
node.NodeName = tokenSequences.Count.ToString();
SequenceAddedInvoker(node);
MessageLogSentInvoker("===== Secuencia {0} añadida =====",
node.NodeName);
}
// We add the token to the current sequence, and remove it
// from the inital token list.
foundSequence.Append(currentToken);
MessageLogSentInvoker("Símbolo «{0}» añadido a la secuencia {1}",
currentToken.Text,
node.NodeName);
StepDoneInvoker();
SuspendByNode();
tokens.RemoveAt(0);
}
return tokenSequences;
}
/// <summary>
/// Gets the tokens of a given node.
/// </summary>
/// <param name="node">
/// A <see cref="SequencedNode"/>
/// </param>
/// <returns>
/// A <see cref="List`1"/>
/// </returns>
private List<Token> GetTokens(SequenceNode node)
{
List<Token> res = new List<Token>();
if(node.ChildCount ==0)
{
// It should have a token;
res.Add(node.FoundToken);
}
else
{
for(int i = 0; i< node.ChildCount; i++)
{
res.AddRange(GetTokens(node[i] as SequenceNode));
}
}
return res;
}
/// <summary>
/// Sets a <see cref="SequenceNode"/> that will be analyzed lexically.
/// </summary>
/// <param name="node">
/// A <see cref="SequenceNode"/>
/// </param>
public void SetSequenceForTokenizing(SequenceNode node)
{
sequenceForTokenizing = node;
}
private void OnSequencesNVButtonPress(object sender,
ButtonPressEventArgs args)
{
if(processFinished && args.Event.Button == 3)
{
TreePath path = new TreePath();
// Obtenemos el treepath con las coordenadas del cursor.
sequencesNV.GetPathAtPos(System.Convert.ToInt16 (args.Event.X),
System.Convert.ToInt16 (args.Event.Y),
out path);
if( path != null)
{
// We try only if a node was found.
SequenceNode node =
(SequenceNode)(sequencesModel.GetNode(path));
selectedNode = node;
sequenceNodeMenu.Popup();
}
}
}
/// <summary>
/// Checks a node for errors.
/// </summary>
/// <param name="node">
/// The node to be checked.
/// </param>
/// <returns>
/// A list with the errors causes.
/// </returns>
private List<string> CheckNodeErrors(SequenceNode node)
{
List<string> res = new List<string>();
if(node.ChildCount > 0)
{
// If the node has children, we check them.
for(int i=0; i<node.ChildCount; i++)
{
res.AddRange(CheckNodeErrors(node[i] as SequenceNode));
}
}
else
{
if(node.FoundToken == null)
{
res.Add(String.Format("· La secuencia {0} no encajó con ninguna regla léxica definida.",
node.NodeName));
}
}
return res;
}
public AddChildSequenceArgs(SequenceNode childNode)
{
this.childNode = childNode;
}
