/// <summary>
/// definition = 'nonterminal', "=", expressions, ";" ;
/// </summary>
/// <param name="nonterminal">'nonterminal'</param>
/// <param name="equal">"="</param>
/// <param name="expressions">expressions</param>
/// <param name="semicolon">";"</param>
protected override DefinitionElement ReturnDefinition(GeneratorLexElement nonterminal, GeneratorLexElement equal, ExpressionsElement expressions, GeneratorLexElement semicolon)
{
DefinitionElement ret = new DefinitionElement(nonterminal, expressions);
ret.Expression.setRootDefinition(ret);
return(ret);
}
protected ElementElement ParseElement()
{
GeneratorLexElement var1 = _Reader.PeekOrThrow("element", GeneratorLexType.OpenBrace, GeneratorLexType.OpenBracket, GeneratorLexType.OpenPar, GeneratorLexType.Terminal, GeneratorLexType.Nonterminal);
if (var1.Type == GeneratorLexType.OpenBrace)
{
RepeatElement var2 = this.ParseRepeat();
return(this.ReturnElement(var2));
}
else if (var1.Type == GeneratorLexType.OpenBracket)
{
OptionElement var3 = this.ParseOption();
return(this.ReturnElement(var3));
}
else if (var1.Type == GeneratorLexType.OpenPar)
{
GroupElement var4 = this.ParseGroup();
return(this.ReturnElement(var4));
}
else if (var1.Type == GeneratorLexType.Terminal || var1.Type == GeneratorLexType.Nonterminal)
{
LiteralElement var5 = this.ParseLiteral();
return(this.ReturnElement(var5));
}
else
{
throw _Reader.Error("element", GeneratorLexType.OpenBrace, GeneratorLexType.OpenBracket, GeneratorLexType.OpenPar, GeneratorLexType.Terminal, GeneratorLexType.Nonterminal);
}
}
protected SourceElement ParseSource()
{
List <Selection <DefinitionElement, GeneratorLexElement> > var1 = new List <Selection <DefinitionElement, GeneratorLexElement> >();
for (Optional <GeneratorLexElement> var2 = _Reader.Peek(); var2.HasValue && (var2.Value.Type == GeneratorLexType.Comment || var2.Value.Type == GeneratorLexType.Nonterminal); var2 = _Reader.Peek())
{
Selection <DefinitionElement, GeneratorLexElement> var3 = default(Selection <DefinitionElement, GeneratorLexElement>);
GeneratorLexElement var4 = _Reader.PeekOrThrow("source", GeneratorLexType.Nonterminal, GeneratorLexType.Comment);
if (var4.Type == GeneratorLexType.Nonterminal)
{
DefinitionElement var5 = this.ParseDefinition();
Selection <DefinitionElement, GeneratorLexElement> var6 = new Selection <DefinitionElement, GeneratorLexElement>(var5);
var3 = var6;
}
else if (var4.Type == GeneratorLexType.Comment)
{
GeneratorLexElement var7 = _Reader.ReadOrThrow("source", GeneratorLexType.Comment);
Selection <DefinitionElement, GeneratorLexElement> var8 = new Selection <DefinitionElement, GeneratorLexElement>(var7);
var3 = var8;
}
else
{
throw _Reader.Error("source", GeneratorLexType.Nonterminal, GeneratorLexType.Comment);
}
var1.Add(var3);
}
Selection <DefinitionElement, GeneratorLexElement>[] var9;
var9 = var1.ToArray();
return(this.ReturnSource(var9));
}
protected RepeatElement ParseRepeat()
{
GeneratorLexElement var1 = _Reader.ReadOrThrow("repeat", GeneratorLexType.OpenBrace);
ExpressionsElement var2 = this.ParseExpressions();
GeneratorLexElement var3 = _Reader.ReadOrThrow("repeat", GeneratorLexType.CloseBrace);
return(this.ReturnRepeat(var1, var2, var3));
}
protected OptionElement ParseOption()
{
GeneratorLexElement var1 = _Reader.ReadOrThrow("option", GeneratorLexType.OpenBracket);
ExpressionsElement var2 = this.ParseExpressions();
GeneratorLexElement var3 = _Reader.ReadOrThrow("option", GeneratorLexType.CloseBracket);
return(this.ReturnOption(var1, var2, var3));
}
protected GroupElement ParseGroup()
{
GeneratorLexElement var1 = _Reader.ReadOrThrow("group", GeneratorLexType.OpenPar);
ExpressionsElement var2 = this.ParseExpressions();
GeneratorLexElement var3 = _Reader.ReadOrThrow("group", GeneratorLexType.ClosePar);
return(this.ReturnGroup(var1, var2, var3));
}
protected DefinitionElement ParseDefinition()
{
GeneratorLexElement var1 = _Reader.ReadOrThrow("definition", GeneratorLexType.Nonterminal);
GeneratorLexElement var2 = _Reader.ReadOrThrow("definition", GeneratorLexType.Equal);
ExpressionsElement var3 = this.ParseExpressions();
GeneratorLexElement var4 = _Reader.ReadOrThrow("definition", GeneratorLexType.Semicolon);
return(this.ReturnDefinition(var1, var2, var3, var4));
}
protected ElementsElement ParseElements()
{
ElementElement var1 = this.ParseElement();
List <FixedList <GeneratorLexElement, ElementElement> > var2 = new List <FixedList <GeneratorLexElement, ElementElement> >();
for (Optional <GeneratorLexElement> var3 = _Reader.Peek(); var3.HasValue && (var3.Value.Type == GeneratorLexType.Comma); var3 = _Reader.Peek())
{
FixedList <GeneratorLexElement, ElementElement> var4 = default(FixedList <GeneratorLexElement, ElementElement>);
GeneratorLexElement var5 = _Reader.ReadOrThrow("elements", GeneratorLexType.Comma);
ElementElement var6 = this.ParseElement();
FixedList <GeneratorLexElement, ElementElement> var7 = new FixedList <GeneratorLexElement, ElementElement>(var5, var6);
var4 = var7;
var2.Add(var4);
}
FixedList <GeneratorLexElement, ElementElement>[] var8;
var8 = var2.ToArray();
return(this.ReturnElements(var1, var8));
}
protected LiteralElement ParseLiteral()
{
GeneratorLexElement var1 = _Reader.PeekOrThrow("literal", GeneratorLexType.Terminal, GeneratorLexType.Nonterminal);
if (var1.Type == GeneratorLexType.Terminal)
{
GeneratorLexElement var2 = _Reader.ReadOrThrow("literal", GeneratorLexType.Terminal);
return(this.ReturnLiteral_Terminal(var2));
}
else if (var1.Type == GeneratorLexType.Nonterminal)
{
GeneratorLexElement var3 = _Reader.ReadOrThrow("literal", GeneratorLexType.Nonterminal);
return(this.ReturnLiteral_Nonterminal(var3));
}
else
{
throw _Reader.Error("literal", GeneratorLexType.Terminal, GeneratorLexType.Nonterminal);
}
}
/// <summary> /// definition = 'nonterminal', "=", expressions, ";" ; /// </summary> /// <param name="nonterminal">'nonterminal'</param> /// <param name="equal">"="</param> /// <param name="expressions">expressions</param> /// <param name="semicolon">";"</param> protected abstract DefinitionElement ReturnDefinition(GeneratorLexElement nonterminal, GeneratorLexElement equal, ExpressionsElement expressions, GeneratorLexElement semicolon);
/// <summary>
/// group = '(', expressions, ')' ;
/// </summary>
/// <param name="openPar">'('</param>
/// <param name="expressions">expressions</param>
/// <param name="closePar">')'</param>
protected override GroupElement ReturnGroup(GeneratorLexElement openBrace, ExpressionsElement expressions, GeneratorLexElement closeBrace)
{
return(new GroupElement(expressions));
}
/// <summary>
/// literal = 'nonterminal' ;
/// </summary>
/// <param name="nonterminal">'nonterminal'</param>
protected override LiteralElement ReturnLiteral_Nonterminal(GeneratorLexElement nonterminal)
{
return(new LiteralElement(nonterminal));
}
/// <summary>
/// 既定のコンストラクタ
/// </summary>
/// <param name="left">非終端記号</param>
/// <param name="expression">式</param>
public DefinitionElement(GeneratorLexElement left, ExpressionsElement expression)
{
_left = left;
_expression = expression;
}
/// <summary>
/// 既定のコンストラクタ
/// </summary>
/// <param name="literal"></param>
public LiteralElement(GeneratorLexElement literal)
{
_literal = literal;
}
/// <summary>
/// option = '[', expressions, ']' ;
/// </summary>
/// <param name="openBracket">'['</param>
/// <param name="expressions">expressions</param>
/// <param name="closeBracket">']'</param>
protected override OptionElement ReturnOption(GeneratorLexElement openBrace, ExpressionsElement expressions, GeneratorLexElement closeBrace)
{
return(new OptionElement(expressions));
}
/// <summary>
/// repeat = '{', expressions, '}' ;
/// </summary>
/// <param name="openBrace">'{'</param>
/// <param name="expressions">expressions</param>
/// <param name="closeBrace">'}'</param>
protected abstract RepeatElement ReturnRepeat(GeneratorLexElement openBrace, ExpressionsElement expressions, GeneratorLexElement closeBrace);
/// <summary> /// literal = 'nonterminal' ; /// </summary> /// <param name="nonterminal">'nonterminal'</param> protected abstract LiteralElement ReturnLiteral_Nonterminal(GeneratorLexElement nonterminal);
/// <summary>
/// group = '(', expressions, ')' ;
/// </summary>
/// <param name="openPar">'('</param>
/// <param name="expressions">expressions</param>
/// <param name="closePar">')'</param>
protected abstract GroupElement ReturnGroup(GeneratorLexElement openPar, ExpressionsElement expressions, GeneratorLexElement closePar);
/// <summary> /// option = '[', expressions, ']' ; /// </summary> /// <param name="openBracket">'['</param> /// <param name="expressions">expressions</param> /// <param name="closeBracket">']'</param> protected abstract OptionElement ReturnOption(GeneratorLexElement openBracket, ExpressionsElement expressions, GeneratorLexElement closeBracket);
/// <summary>
/// repeat = '{', expressions, '}' ;
/// </summary>
/// <param name="openBrace">'{'</param>
/// <param name="expressions">expressions</param>
/// <param name="closeBrace">'}'</param>
protected override RepeatElement ReturnRepeat(GeneratorLexElement openBrace, ExpressionsElement expressions, GeneratorLexElement closeBrace)
{
return(new RepeatElement(expressions));
}
