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