private int RndByRR(AlternativeSet aAlternativeSet, string aRR)
{
string[] lRRNumbs = aRR.Split(' ');
int[] RR = new int[aAlternativeSet.Count];
int Sum = 0;
int i;
//Конвертируем в int, суммируем и сохраняем функцию распределения F(x)
for (i = 0; i < aAlternativeSet.Count; i++)
{
int k = 1; //Значение по умолчанию. Если есть три альтернативы и rr="10", то подразумевается, что rr="10 1 1"
if (i < lRRNumbs.Length)
{
k = int.Parse(lRRNumbs[i]);
}
Sum += k;
RR[i] = Sum;
}
int n = mRnd.Next(Sum);
i = 0;
while (n > RR[i])
{
i++;
}
return(i);
}
public void Setup()
{
testSet = new AlternativeSet <int>(new IntegerComparer())
{
15, -7, 19, 25, 128, -72, 54, 1992
};
}
private void grammarIndexingToolStripMenuItem_Click(object sender, EventArgs e)
{
// Grammar Indexing
XmlDocument grammarIndexingFile = new XmlDocument();
XmlNode root = grammarIndexingFile.CreateElement("Root");
grammarIndexingFile.AppendChild(root);
foreach (Rule tmpRule in mGrammarDoc.mGrammar.Rules.Values)
{
XmlNode tmpRuleName = grammarIndexingFile.CreateElement(tmpRule.Name);
AlternativeSet lAlt = tmpRule.RightSide as AlternativeSet;
int cnt = 0;
if (lAlt != null)
{
cnt = lAlt.Count;
}
XmlAttribute rrAtr = grammarIndexingFile.CreateAttribute("rr");
//rrAtr.Value = "10";
string attrValue = "10";
tmpRuleName.Attributes.Append(rrAtr);
for (int i = 1; i < cnt; i++)
{
attrValue += " 1";
}
rrAtr.Value = attrValue;
tmpRuleName.Attributes.Append(rrAtr);
root.AppendChild(tmpRuleName);
}
grammarIndexingFile.Save(@"C:\grammarIndexing.xml");
}
public override IDerivation VisitInternal(AlternativeSet aAlternativeSet, DerivationContext aContext)
{
AlternativeSet lMinAlt = aAlternativeSet.getMinUsageAlternatives();
int i = mRnd.Next(lMinAlt.Count);
return(lMinAlt.GetAlternative(aContext, i));
}
public virtual IDerivation Visit(AlternativeSet aAlternativeSet, DerivationContext aContext)
{
for (int i = 0; i < aAlternativeSet.Count; i++)
{
aAlternativeSet.Phrases[i].Accept(NewContext(aAlternativeSet, aContext));
}
return(null);
}
public override IDerivation Visit(AlternativeSet aAlternativeSet, DerivationContext aContext)
{
if (!mMainObject.GeneralizedNonMandatryInclusion(aAlternativeSet))
{
return(base.Visit(aAlternativeSet, aContext));
}
return(null);
}
private IPhrase Subst(AlternativeSet alt, List <string> aOuterSymbols)
{
for (int i = 0; i < alt.Phrases.Count; i++)
{
alt.Phrases[i] = Subst(alt.Phrases[i], aOuterSymbols);
}
return(alt);
}
public virtual IDerivation Visit(AlternativeSet aAlternativeSet, DerivationContext aContext)
{
//считать конфигурацию узла и передать управление соотв. визитору
//читаем из xml
if (Generator.ConfigXml != null)
{
List <string> lXmlPathList = aContext.DerivPath;
string[] lXmlPath = lXmlPathList.ToArray();
string path = string.Join("/", lXmlPath);
//RR ряд распределения
int i = 0;
string lRR = null;
if (aContext.Generator.Options.RREnable)
{
lRR = Generator.ConfigXml.SearchAtRootOnly(lXmlPath[lXmlPath.Length - 1], "rr");
}
if (!string.IsNullOrEmpty(lRR))
{
i = RndByRR(aAlternativeSet, lRR);
return(aAlternativeSet.GetAlternative(aContext, i));
}
string lAlg = "";
lAlg = ""; // Generator.ConfigXml.Search(lXmlPath, "alg");
if (path == "Root/bodyStats/bodyStat")
{
lAlg = "enum";
}
if (!string.IsNullOrEmpty(lAlg))
{
//DerivationContext lNewCont = new DerivationContext(aContext);
IVisitor lVisitor = aContext.Visitor;
switch (lAlg)
{
case "rnd":
lVisitor = Generator.VisitorExpandRnd;
break;
case "enum":
lVisitor = Generator.VisitorExpandForceEnum;
break;
case "norm":
lVisitor = Generator.VisitorExpandNormRnd;
break;
default:
throw new ConfigurationException(
"Неправильное значение аттрибута alg в конфигурационном файле. Допустимо одно из трех: rnd, enum, norm");
}
return((lVisitor as VisitorExpandBase).VisitInternal(aAlternativeSet, aContext));
}
}
return(VisitInternal(aAlternativeSet, aContext));
}
public override IDerivation Visit(AlternativeSet aAlternativeSet, DerivationContext aContext)
{
for (int i = 0; i < aAlternativeSet.Count; i++)
{
IPhrase phr = aAlternativeSet.Phrases[i];
if (OmmitTerminals && phr is Terminal)
{
continue;
}
tEdge edge = addEdge(aContext, phr, aAlternativeSet.Parent);
edge.CustomAttributes = phr.IsCyclic ? GrammarGraphEdgeAttrs.IsCyclic : GrammarGraphEdgeAttrs.None;
phr.Accept(NewContext(aAlternativeSet, aContext));
}
return(null);
}
public AlternativeControl(AlternativeSet aAlternativeSet, List <string> aOuterSymbols)
: this()
{
_alternativeSet = aAlternativeSet;
foreach (IPhrase phrase in _alternativeSet.Phrases)
{
Border brd = new Border();
UIElement control = ControlFactory.CreateControl(phrase, aOuterSymbols);
brd.Child = control;
brd.BorderThickness = new Thickness(5);
if (phrase.IsCyclic)
{
brd.BorderBrush = Brushes.Blue;
}
else
{
brd.BorderBrush = Brushes.YellowGreen;
}
stackPanel1.Children.Add(brd);
}
}
public override IDerivation Visit(AlternativeSet aAlternativeSet, DerivationContext aContext)
{
bool allIsCyclic = true;
// allIsCyclic сохранит значение true в том и только том случае, если все логические сомножетели true
for (int i = 0; i < aAlternativeSet.Count && allIsCyclic; i++)
{
//allIsCyclic = allIsCyclic & aAlternativeSet.Phrases[i].IsCyclic;
allIsCyclic &= aAlternativeSet.Phrases[i].IsCyclic;
}
if (allIsCyclic)
{
IPhrase p = aAlternativeSet.Parent;
while (p != null && !(p is NonTerminal))
{
p = p.Parent;
}
string ruleName = (p != null) ? p.ToString() : "main";
Log += string.Format("В правиле {0} набор альтернатив {1} ошибка - все альтернативы циклические.\r\n", ruleName,
aAlternativeSet);
}
return(base.Visit(aAlternativeSet, aContext));
}
public override IDerivation Visit(AlternativeSet aAlternativeSet, DerivationContext aContext)
{
aAlternativeSet.Parent = (aContext as CyclesDetectContext).Parent;
return(base.Visit(aAlternativeSet, aContext));
}
/// Частное преобразование. Проверяет только правила состоящие из двух альтернатив.
/// Находит правила вида
/// S := A | A, S => A+ //шаблон (*1)
/// S := A | S, A => A+ //шаблон (*1')
/// B := A | A, S => A, [S] //шаблон (*2)
/// B := A | S, A [S], A //шаблон (*2')
/// и заменяет их на
/// S := A+ // {1..*}
/// B := A, [S] //{0..1}
///
///
/// stats := stat | stat, Stats //Пример (*1)
/// Exprs := Add | Add, Adds //Пример (*2)
/// struct_declaration_list := struct_declaration\ //Пример (*1')
/// | struct_declaration_list, struct_declaration
private void StatStatsTransform()
{
foreach (Rule rule in mGrammar.Rules.Values)
{
AlternativeSet alt = rule.RightSide as AlternativeSet;
if (alt != null)
{
if (alt.Phrases.Count == 2)
{
NonTerminal first_symbol_A = alt.Phrases[0] as NonTerminal;
Seqence sequence = alt.Phrases[1] as Seqence;
if (first_symbol_A != null && sequence != null && sequence.Phrases.Count == 2)
{
NonTerminal seq_symbol1 = sequence.Phrases[0] as NonTerminal;
NonTerminal seq_symbol2 = sequence.Phrases[1] as NonTerminal;
if (seq_symbol1 != null && seq_symbol2 != null)
{
NonTerminal seq_symbol_A = null;
NonTerminal seq_symbol_S = null;
int repl_i = 0;
// Структура как нужно, теперь анализируем какие символы одинаковы?
if (first_symbol_A.Text == seq_symbol1.Text)
{
seq_symbol_A = seq_symbol1;
seq_symbol_S = seq_symbol2;
repl_i = 1;
}
else if (first_symbol_A.Text == seq_symbol2.Text)
{
seq_symbol_A = seq_symbol2;
seq_symbol_S = seq_symbol1;
repl_i = 0;
}
if (seq_symbol_A != null)
{
string rule_before = rule.ToString();
if (rule.Name == seq_symbol_S.Text)
{
//Совпадение с шаблоном (*1) или (*1') найдено
// создаем квантификатор вида {stat}
QuantifiedPhrase quant = new QuantifiedPhrase(mGrammar, first_symbol_A, 1, Int32.MaxValue);
// подменяем им правую часть
rule.RightSide = quant;
}
else
{
//Совпадение с шаблоном (*2) или (*2') найдено
// создаем квантификатор вида A?
QuantifiedPhrase quant = new QuantifiedPhrase(mGrammar, seq_symbol_S, 0, 1);
// подменяем альтернативу в правой части последовательностью
rule.RightSide = sequence;
// подменяем второй элемент последовательности квантификатором
sequence.Phrases[repl_i] = quant;
}
mStatistics.AffectedRules.Add(rule.Name);
mStatistics.Log(rule_before, rule.ToString());
}
}
}
}
//GeneralizedNonMandatryInclusion(alt);
}
} //foreach
}
/// <summary>
/// 1) Ищет совпадения в начале и в конце последовательностей.
/// Если ничего не совпало выходим
/// 2) Удаляем последовательность которая короче. Если Aj короче swap = true
/// 3) Берем подпоследовательности Cp,Dq
/// 4) Мастрячим замену - если D нету, квантификатор, иначе альтернативу
/// </summary>
/// <param name="Ai">B1,...,Bn,[D1,...,Dq],E1,...,Ek</param>
/// <param name="Aj">B1,...,Bn, C1,...,Cp, E1,...,Ek</param>
/// <param name="swap">true если удаляем Aj, а не Ai</param>
/// <returns>B1,...,Bn, (C1,...,Cn)?, D1,...,Dn</returns>
private Seqence FindNonMandatryInclusion(Seqence Ai, Seqence Aj, out bool swap)
{
// 1) Ищет совпадения в начале и в конце последовательностей.
int start_len = 0; //FindEqualSeq(A1, A2, 1);
int Ci = Ai.Phrases.Count - 1;
int Cj = Aj.Phrases.Count - 1;
while (start_len <= Ci &&
start_len <= Cj &&
Ai.Phrases[start_len] is NonTerminal &&
Aj.Phrases[start_len] is NonTerminal &&
Ai.Phrases[start_len].ToString() == Aj.Phrases[start_len].ToString()
)
{
start_len++;
}
int end_len = 0; //FindEqualSeq(A1, A2, -1);
while (Ci >= start_len &&
Cj >= start_len &&
Ai.Phrases[Ci] is NonTerminal &&
Aj.Phrases[Cj] is NonTerminal &&
Ai.Phrases[Ci].ToString() == Aj.Phrases[Cj].ToString()
)
{
Ci--;
Cj--;
end_len++;
}
//Теперь у нас
//start_len=n end_len=k
// B1,...,Bn, D1,...,Dq, E1,...,Ek
// B1,...,Bn, C1,...,Cp, E1,...,Ek
// 2) Анализируем варианты
swap = (Aj.Phrases.Count < Ai.Phrases.Count); //true Aj короче - ее и удалим
if (start_len > 0 || end_len > 0)
{
if (swap)
{
Seqence At = Ai;
Ai = Aj;
Aj = At;
}
int sub_d_len = Ai.Phrases.Count - start_len - end_len;
int sub_c_len = Aj.Phrases.Count - start_len - end_len;
//Выделим D1,...,Dq из Ai
Seqence sub_d = Ai.SubSequence(start_len, sub_d_len);
//Выделим C1,...,Cp
Seqence sub_c = Aj.SubSequence(start_len, sub_c_len);
if (sub_c != null)
{
IPhrase replacement;
if (sub_d != null)
{
// Альтернатива (D|C)
if (sub_c.Count == 1 && sub_c.Phrases[0] is AlternativeSet)
{
(sub_c.Phrases[0] as AlternativeSet).Add(sub_d);
return(Aj);
}
else if (sub_d.Count == 1 && sub_d.Phrases[0] is AlternativeSet)
{
(sub_d.Phrases[0] as AlternativeSet).Add(sub_c);
swap = true;
return(Ai);
}
else
{
replacement = new AlternativeSet(mGrammar, sub_d);
(replacement as AlternativeSet).Phrases.Add(sub_c);
}
}
else
{
// Необязательная C?
replacement = new QuantifiedPhrase(mGrammar, sub_c, 0, 1);
}
return(ReplaceSubSequence(Aj, start_len, sub_c_len, replacement));
}
else
{
throw new Exception(
"FindNonMandatryInclusion. Подпоследовательность С нулевая. Такое может быть только если среди альтернатив две одинаковые последовательности, например S = A,B | A,B ");
}
} //иначе вообще нет совпадений
return(null);
}
/// <summary>
/// Проверяет правило на наличие такого шаблона:
///
/// R := A1 | A2 | ... | An
///
/// Ai := B1,...,Bn, E1,...,En
/// Aj := B1,...,Bn, C1,...,Cn, E1,...,En
///
/// => (делает преобразование)
/// remove Ai
/// Aj := B1,...,Bn, (C1,...,Cn)?, E1,...,En
///
/// Еще более общий случай:
/// Ai := B1,...,Bn, D1,...,Dq E1,...,Ek
/// Aj := B1,...,Bn, C1,...,Cp, E1,...,Ek
///
/// => (делает преобразование)
/// remove Ai
/// Aj := B1,...,Bn, (D1,...,Dq | C1,...,Cp), E1,...,Ek
///
/// </summary>
/// <param name="R">Right side of rule as AlternativeSet</param>
/// <returns>Возвращает true если в правило было внесено изменение, при этом сразу же выходит</returns>
private bool GeneralizedNonMandatryInclusion(AlternativeSet R)
{
for (int i = 0; i < R.Phrases.Count; i++) // 000
{
for (int j = 0; j < i; j++) // 100 j<i , FindNonMandatryInclusion учитывает сразу Ai,Aj и Aj,Ai
{
// 110
Seqence Ai = R.Phrases[i] as Seqence;
Seqence Aj = R.Phrases[j] as Seqence;
//argument_expression_list := assignment_expression\
// | argument_expression_list, ",", assignment_expression
//=>
//argument_expression_list := assignment_expression\
// | [ argument_expression_list, "," ], assignment_expression
//argument_expression_list := assignment_expression\
// | [ argument_expression_list, "," ], assignment_expression
//=>
//argument_expression_list := assignment_expression\
// | [ [ argument_expression_list, "," ] ], assignment_expression
//if (Ai != null && Ai.Count > 1 || Aj != null && Aj.Count > 1)
//{
// if (R.Phrases[i] is Symbol)
// {
// Ai = new Seqence(mGrammar, R.Phrases[i]);
// }
// if (R.Phrases[j] is Symbol)
// {
// Aj = new Seqence(mGrammar, R.Phrases[j]);
// }
if (Ai != null && Aj != null)
// Если встретилась НЕ последовательность, ничего страшного, продолжаем просмотр этого правила
{
bool swap;
mRule_before = mCurrentRule.ToString();
Seqence new_A = FindNonMandatryInclusion(Ai, Aj, out swap);
if (new_A != null)
{
if (!swap)
{
R.Phrases[j] = new_A;
R.Phrases.Remove(Ai);
}
else
{
R.Phrases[i] = new_A;
R.Phrases.Remove(Aj);
}
wasTransformed = true;
mStatistics.Log(mRule_before, mCurrentRule.ToString());
return(true);
}
}
//}
}
}
wasTransformed = false;
return(false);
}
public abstract IDerivation VisitInternal(AlternativeSet aAlternativeSet, DerivationContext aContext);
