/// <summary>
/// Call point to start the processing.
/// </summary>
protected override void Process()
{
MessageLogSentInvoker("===========================================");
MessageLogSentInvoker(" Comenzando proceso de análisis sintáctico");
MessageLogSentInvoker("===========================================");
SyntacticalRule startRule =
SyntacticalRulesLibrary.Instance.StartRule;
OnMatcherMatching(this,
new MatchingArgs(SyntacticalRulesLibrary.Instance.StartRule));
TokenSequence inputTokens = new TokenSequence(startTokens);
parsingResult = startRule.Match(ref inputTokens, out output);
if (inputTokens.Count > 0)
{
// Not all tokens were matched, so the parsing process
// was unsuccessfull.
parsingResult = false;
}
ProcessFinishedInvoker();
}
public void RepeaterTestCase()
{
TokenSequence sequence = new TokenSequence();
Token t = new Token("NUMBER");
t.Text = "200.9";
sequence.Append(t);
t = new Token("ADD");
t.Text = "+";
sequence.Append(t);
t = new Token("NUMBER");
t.Text = "14";
sequence.Append(t);
t = new Token("ADD");
t.Text = "+";
sequence.Append(t);
t = new Token("NUMBER");
t.Text = "28";
sequence.Append(t);
SyntacticalRule rule = new SyntacticalRule("formula");
SyntacticalExpression exp = new SyntacticalExpression();
exp.FormatString = "{0}{1}";
ExpressionTokenItem eti = new ExpressionTokenItem();
eti.TokenType = "NUMBER";
exp.Items.Add(eti);
ExpressionGroupItem group = new ExpressionGroupItem();
group.Modifier = ExpressionItemModifier.RepeatingNonCompulsory;
eti = new ExpressionTokenItem();
eti.TokenType = "ADD";
group.ChildrenItems.Add(eti);
eti = new ExpressionTokenItem();
eti.TokenType = "NUMBER";
group.ChildrenItems.Add(eti);
group.FormatString = " + {1}";
exp.Items.Add(group);
rule.Expressions.Add(exp);
string output;
bool res = rule.Match(ref sequence, out output);
Assert.IsTrue(res, "Matching wasn't succesfull");
Assert.AreEqual("200.9 + 14 + 28", output, "Output isn't correct.'");
}
/// <summary>
/// Adds a rule to the rule list.
/// </summary>
/// <param name="rule">
/// A <see cref="SyntacticalRule"/>
/// </param>
private void AddRule(SyntacticalRule rule)
{
string [] parts = rule.ToString().Split(':');
TreeIter iter = synRulesModel.AppendValues(parts[0] + " :",
parts[1],
rule);
synRulesTree.Selection.SelectIter(iter);
synRulesTree.ScrollToCell(synRulesModel.GetPath(iter),
synRulesTree.Columns[0],
true, 0.5f, 0);
}
/// <summary>
/// Removes the selected rule from the list.
/// </summary>
/// <param name="sender">
/// A <see cref="System.Object"/>
/// </param>
/// <param name="args">
/// A <see cref="EventArgs"/>
/// </param>
private void OnRmSynRuleBtnClicked(object sender, EventArgs args)
{
TreeIter selected;
synRulesTree.Selection.GetSelected(out selected);
// We retrieve the selected rule.
SyntacticalRule rule =
synRulesModel.GetValue(selected, 2) as SyntacticalRule;
ResponseType res =
ConfirmDialog.Show(syntacticalRulesManagerDialog,
"¿Realemente quieres eliminar la regla «{0}»?",
rule.Name);
if (res == ResponseType.No)
{
// The user doesn't want the removal of the rule, so we abort.
return;
}
// The user accepted, so there we go!
synRulesModel.Remove(ref selected);
}
/// <summary>
/// Launches the rule editor dialog for the selected rule.
/// </summary>
/// <param name="sender">
/// A <see cref="System.Object"/>
/// </param>
/// <param name="args">
/// A <see cref="EventArgs"/>
/// </param>
private void OnSynRuleEditBtnClicked(object sender, EventArgs args)
{
SyntacticalRuleEditorDialog dialog =
new SyntacticalRuleEditorDialog(this);
TreeIter iter;
synRulesTree.Selection.GetSelected(out iter);
dialog.Rule = synRulesModel.GetValue(iter, 2) as SyntacticalRule;
ResponseType res = dialog.Show();
if (res == ResponseType.Ok)
{
SyntacticalRule rule = dialog.Rule;
string [] parts = rule.ToString().Split(':');
synRulesModel.SetValue(iter, 0, parts[0] + " :");
synRulesModel.SetValue(iter, 1, parts[1]);
synRulesModel.SetValue(iter, 2, rule);
}
dialog.Destroy();
}
public void SumAndMultTestCase()
{
TokenSequence sequence = new TokenSequence();
Token t = new Token("NUMBER");
t.Text = "200.9";
sequence.Append(t);
t = new Token("ADD");
t.Text = "+";
sequence.Append(t);
t = new Token("NUMBER");
t.Text = "28";
sequence.Append(t);
t = new Token("MULT");
t.Text = "x";
sequence.Append(t);
t = new Token("NUMBER");
t.Text = "14";
sequence.Append(t);
SyntacticalRulesLibrary.Instance.ClearRules();
SyntacticalRule rule = new SyntacticalRule("multiplicacion");
SyntacticalRulesLibrary.Instance.AddRule(rule);
SyntacticalExpression exp = new SyntacticalExpression();
exp.FormatString = "{0}{1}";
ExpressionTokenItem eti = new ExpressionTokenItem();
eti.TokenType = "NUMBER";
exp.Items.Add(eti);
ExpressionGroupItem group = new ExpressionGroupItem();
group.Modifier = ExpressionItemModifier.RepeatingNonCompulsory;
eti = new ExpressionTokenItem();
eti.TokenType = "MULT";
group.ChildrenItems.Add(eti);
eti = new ExpressionTokenItem();
eti.TokenType = "NUMBER";
group.ChildrenItems.Add(eti);
group.FormatString = " x {1}";
exp.Items.Add(group);
rule.Expressions.Add(exp);
rule = new SyntacticalRule("formula");
SyntacticalRulesLibrary.Instance.AddRule(rule);
exp = new SyntacticalExpression();
exp.FormatString = "{0}{1}";
ExpressionRuleCallItem esi = new ExpressionRuleCallItem();
esi.RuleName = "multiplicacion";
exp.Items.Add(esi);
group = new ExpressionGroupItem();
group.Modifier = ExpressionItemModifier.RepeatingNonCompulsory;
eti = new ExpressionTokenItem();
eti.TokenType = "ADD";
group.ChildrenItems.Add(eti);
esi = new ExpressionRuleCallItem();
esi.RuleName = "multiplicacion";
group.ChildrenItems.Add(esi);
group.FormatString = " + {1}";
exp.Items.Add(group);
rule.Expressions.Add(exp);
string output;
bool res = rule.Match(ref sequence, out output);
Assert.IsTrue(res, "Matching wasn't succesfull");
Assert.AreEqual("200.9 + 28 x 14", output, "Output isn't correct.'");
}
