/// <summary>
/// selection = elements, {'|', elements} ;
/// </summary>
/// <param name="elements">elements</param>
/// <param name="repetition">{'|', elements}</param>
protected override SelectionElement ReturnSelection(ElementsElement elements, FixedList <GeneratorLexElement, ElementsElement>[] repetition)
{
List <ElementsElement> list = new List <ElementsElement>();
list.Add(elements);
list.AddRange(repetition.Select(p => p.Element2));
return(new SelectionElement(list));
}
void firstFollowing(ScriptParserGenerator gen, DefinitionElement root, TextWriter writer, DefinitionContent content)
{
writer.WriteLine(string.Format(" {0}: first:<{1}> following:<{2}>", content, joinStr(content.GetFirstTerminals(gen)), joinStr(content.GetFollowingTerminals(gen))));
SelectionElement s = content as SelectionElement;
if (s != null)
{
foreach (ElementsElement elems in s.Candidates)
{
firstFollowing(gen, root, writer, elems);
}
}
ExpressionsElement ex = content as ExpressionsElement;
if (ex != null)
{
foreach (ElementsElement elems in ex.Selection.Candidates)
{
firstFollowing(gen, root, writer, elems);
}
}
ElementsElement es = content as ElementsElement;
if (es != null)
{
foreach (ElementElement elem in es.Elements)
{
firstFollowing(gen, root, writer, elem);
}
}
RepeatElement r = content as RepeatElement;
if (r != null)
{
firstFollowing(gen, root, writer, r.InnerExpression);
}
OptionElement o = content as OptionElement;
if (o != null)
{
firstFollowing(gen, root, writer, o.InnerExpression);
}
GroupElement g = content as GroupElement;
if (g != null)
{
firstFollowing(gen, root, writer, g.InnerExpression);
}
LiteralElement l = content as LiteralElement;
}
public int GetHashCode(DefinitionContent obj)
{
SelectionElement s = obj as SelectionElement;
if (s != null)
{
// ハッシュ値計算できないので適当
return(15773);
}
ExpressionsElement ex = obj as ExpressionsElement;
if (ex != null)
{
return(this.GetHashCode(ex.Selection));
}
ElementsElement es = obj as ElementsElement;
if (es != null)
{
return(es.Elements.Sum(e => this.GetHashCode(e)));
}
RepeatElement r = obj as RepeatElement;
if (r != null)
{
return(1744579 + this.GetHashCode(r.InnerExpression));
}
OptionElement o = obj as OptionElement;
if (o != null)
{
return(3234551 + this.GetHashCode(o.InnerExpression));
}
GroupElement g = obj as GroupElement;
if (g != null)
{
return(this.GetHashCode(g.InnerExpression));
}
LiteralElement l = obj as LiteralElement;
if (l != null)
{
return(l.InnerWord.GetHashCode() + l.Literal.Type.GetHashCode());
}
Debug.Assert(false);
return(7);
}
protected SelectionElement ParseSelection()
{
ElementsElement var1 = this.ParseElements();
List <FixedList <GeneratorLexElement, ElementsElement> > var2 = new List <FixedList <GeneratorLexElement, ElementsElement> >();
for (Optional <GeneratorLexElement> var3 = _Reader.Peek(); var3.HasValue && (var3.Value.Type == GeneratorLexType.VSlash); var3 = _Reader.Peek())
{
FixedList <GeneratorLexElement, ElementsElement> var4 = default(FixedList <GeneratorLexElement, ElementsElement>);
GeneratorLexElement var5 = _Reader.ReadOrThrow("selection", GeneratorLexType.VSlash);
ElementsElement var6 = this.ParseElements();
FixedList <GeneratorLexElement, ElementsElement> var7 = new FixedList <GeneratorLexElement, ElementsElement>(var5, var6);
var4 = var7;
var2.Add(var4);
}
FixedList <GeneratorLexElement, ElementsElement>[] var8;
var8 = var2.ToArray();
return(this.ReturnSelection(var1, var8));
}
/// <summary>
/// selection = elements, {'|', elements} ;
/// </summary>
/// <param name="elements">elements</param>
/// <param name="repetition">{'|', elements}</param>
protected abstract SelectionElement ReturnSelection(ElementsElement elements, FixedList <GeneratorLexElement, ElementsElement>[] repetition);
public void WriteParseCode(TextWriter writer, ScriptParserGenerator generator)
{
writer.Write(ScriptParserGenerator.GetAccessibilityString(generator.Settings.ParseMethodAccessibility));
writer.Write(" ");
writer.Write(generator.GetReturnClassIdentifier(this.DefinitionName));
writer.Write(" ");
writer.Write(generator.GetParseMethodIdentifier(this.DefinitionName));
writer.WriteLine("() {");
generator.IndentCount = 1;
generator.InitializeVariableIndex(1);
IDictionary <ElementsElement, MethodSignature> methods = this.GetReturnParameterSignaturesAndElements(generator);
if (false)
{
// 普通のコード
if (this.Expression.Selection.Candidates.Count >= 2)
{
IList <string> firsts = this.Expression.Selection.GetFirstTerminals(generator);
string peekVar;
writer.WriteLine(generator.GetCodeOfPeekOrThrow(this.DefinitionName, firsts, out peekVar));
Dictionary <string, string> usedFirsts = new Dictionary <string, string>();
foreach (ElementsElement elems in this.Expression.Selection.Candidates)
{
IList <string> innerFirsts = elems.GetFirstTerminals(generator);
foreach (string first in innerFirsts)
{
string usingPoint;
if (usedFirsts.TryGetValue(first, out usingPoint))
{
string context = string.Format("'{0}' の定義", this.DefinitionName);
string message = string.Format("<{1}> 内の <{0}> は <{2}> によって隠されます", first, elems.ToString(), usingPoint);
generator.Warn(context, message);
}
else
{
usedFirsts[first] = elems.ToString();
}
}
writer.WriteLine(generator.GetCodeOfIfLexisIn(peekVar, innerFirsts));
List <string> arguments = new List <string>();
foreach (ElementElement elem in elems.Elements)
{
string var = elem.WriteParseCode(writer, generator);
arguments.Add(var);
}
writer.WriteLine(generator.GetCodeOfReturnMethod(methods[elems].MethodName, arguments));
writer.Write(generator.GetCodeOfCloseBlock());
writer.Write(generator.GetCodeOfSingleElse());
}
writer.WriteLine(generator.GetCodeOfOpenBlock());
writer.WriteLine(generator.GetCodeOfThrowNew("System.NotImplementedException", ScriptParserGenerator.EscapeString(this.DefinitionName)));
writer.WriteLine(generator.GetCodeOfCloseBlock());
}
else
{
ElementsElement elems = this.Expression.Selection.Candidates.First();
IList <string> innerFirsts = elems.GetFirstTerminals(generator);
List <string> arguments = new List <string>();
foreach (ElementElement elem in elems.Elements)
{
string var = elem.WriteParseCode(writer, generator);
arguments.Add(var);
}
writer.WriteLine(generator.GetCodeOfReturnMethod(methods[elems].MethodName, arguments));
}
}
else
{
// 前半部分が同じSelectionをツリー状に探索するようにするために
// SelectionSubCandidateを作る
List <SelectionSubCandidate> subCandidates = new List <SelectionSubCandidate>();
foreach (ElementsElement candidate in this.Expression.Selection.Candidates)
{
subCandidates.Add(new SelectionSubCandidate(candidate));
}
SelectionSubCandidate.writeParseCodeAux(writer, generator, subCandidates, (candidateAtEmpty, writer2, generator2) => {
writer.WriteLine(generator.GetCodeOfReturnMethod(methods[candidateAtEmpty.OriginalElements].MethodName, candidateAtEmpty.TemporaryVariables));
});
}
writer.Write("}");
}
private SelectionSubCandidate(ElementsElement original, IEnumerable <string> temporaryVariables, IEnumerable <ElementElement> restElements)
{
_originalElements = original;
_temporaryVariables = temporaryVariables.ToArray();
_restElements = new List <ElementElement>(restElements);
}
public SelectionSubCandidate(ElementsElement elements)
{
_originalElements = elements;
_temporaryVariables = new string[0];
_restElements = elements.Elements.ToList();
}
public bool Equals(DefinitionContent x, DefinitionContent y)
{
GroupElement x1 = x as GroupElement;
if (x1 != null)
{
return(this.Equals(x1.InnerExpression, y));
}
GroupElement y1 = y as GroupElement;
if (y1 != null)
{
return(this.Equals(x, y1.InnerExpression));
}
ExpressionsElement x2 = x as ExpressionsElement;
if (x2 != null)
{
return(this.Equals(x2.Selection, y));
}
ExpressionsElement y2 = y as ExpressionsElement;
if (y2 != null)
{
return(this.Equals(x, y2.Selection));
}
SelectionElement x3 = x as SelectionElement;
SelectionElement y3 = y as SelectionElement;
if (x3 != null && y3 != null)
{
// ∀x0(∈ x) x0 ∈ y かつ ∀y0(∈ y) y0 ∈ x ならば x = y
return(x3.Candidates.All(x0 => y3.Candidates.Any(y0 => this.Equals(x0, y0))) && y3.Candidates.All(y0 => x3.Candidates.Any(x0 => this.Equals(x0, y0))));
}
ElementsElement x4 = x as ElementsElement;
ElementsElement y4 = y as ElementsElement;
if (x4 != null && y4 != null)
{
if (x4.Elements.Count != y4.Elements.Count)
{
return(false);
}
return(CollectionEx.Zip(x4.Elements, y4.Elements, (x0, y0) => this.Equals(x0, y0)).All(eq => eq));
}
RepeatElement x5 = x as RepeatElement;
RepeatElement y5 = y as RepeatElement;
if (x5 != null && y5 != null)
{
return(this.Equals(x5.InnerExpression, y5.InnerExpression));
}
OptionElement x6 = x as OptionElement;
OptionElement y6 = y as OptionElement;
if (x6 != null && y6 != null)
{
return(this.Equals(x6.InnerExpression, y6.InnerExpression));
}
LiteralElement x7 = x as LiteralElement;
LiteralElement y7 = y as LiteralElement;
if (x7 != null && y7 != null)
{
return(x7.Literal.Type == y7.Literal.Type && x7.InnerWord == y7.InnerWord);
}
if (x == null && y == null)
{
return(true);
}
if (x == null || y == null)
{
return(false);
}
return(false);
}
