protected override ExpressionSyntaxElement ReturnMul(ExpressionSyntaxElement anary, FixedList <LexicalElement, ExpressionSyntaxElement>[] repeatOf_Cross_AndAnary)
{
ExpressionSyntaxElement left = anary;
foreach (var right in repeatOf_Cross_AndAnary)
{
BinarySyntaxElement.OperatorType op = BinarySyntaxElement.OperatorType.Cross;
switch (right.Element1.Type)
{
case LexType.Cross:
op = BinarySyntaxElement.OperatorType.Cross;
break;
case LexType.Slash:
op = BinarySyntaxElement.OperatorType.Slash;
break;
case LexType.Percent:
op = BinarySyntaxElement.OperatorType.Percent;
break;
default:
throw new NotSupportedException();
}
left = new BinarySyntaxElement(left.LexAtStart, op, left, right.Element2);
}
return(left);
}
protected override ExpressionSyntaxElement ReturnModProperty(ExpressionSyntaxElement property, Selection <ArgumentsSyntaxElement, ExpressionSyntaxElement, DotInvocationSyntaxElement>[] repeatOfArgumentsOrIndexingOrDotInvocation)
{
ExpressionSyntaxElement left = property;
foreach (var selection in repeatOfArgumentsOrIndexingOrDotInvocation)
{
if (selection.Element1.HasValue)
{
ArgumentsSyntaxElement args = selection.Element1.Value;
left = new InvokeSyntaxElement(left.LexAtStart, left, args);
}
else if (selection.Element2.HasValue)
{
ExpressionSyntaxElement index = selection.Element2.Value;
left = new IndexerSyntaxElement(left.LexAtStart, left, index);
}
else if (selection.Element3.HasValue)
{
DotInvocationSyntaxElement right = selection.Element3.Value;
List <ExpressionSyntaxElement> expressions = new List <ExpressionSyntaxElement>();
expressions.Add(left);
expressions.AddRange(right.Arguments);
left = new InvokeSyntaxElement(left.LexAtStart, new IdentifierSyntaxElement(right.Identifier), expressions);
}
else
{
throw new NotSupportedException();
}
}
return(left);
}
protected override ExpressionSyntaxElement ReturnUnary(LexicalElement[] repeatOfNot, ExpressionSyntaxElement inc)
{
ExpressionSyntaxElement right = inc;
foreach (LexicalElement left in repeatOfNot.Reverse())
{
AnarySyntaxElement.OperatorType op = AnarySyntaxElement.OperatorType.Plus;
switch (left.Type)
{
case LexType.Plus:
op = AnarySyntaxElement.OperatorType.Plus;
break;
case LexType.Minus:
op = AnarySyntaxElement.OperatorType.Minus;
break;
case LexType.Not:
op = AnarySyntaxElement.OperatorType.Not;
break;
default:
throw new NotSupportedException();
}
right = new AnarySyntaxElement(left, op, right);
}
return(right);
}
public InvokeSyntaxElement(LexicalElement lexAtStart, ExpressionSyntaxElement function, ExpressionSyntaxElement firstParameter, IList <ExpressionSyntaxElement> parameters)
: base(lexAtStart)
{
this.Function = function;
this.Parameters = new[] { firstParameter }.Union(parameters).ToArray();
this.IsDotAccess = true;
}
/// <summary>
/// for = 'for', '(', [expression|declare], ';', [expression], ';', [expression], ')', statement ;
/// </summary>
/// <param name="@for">'for'</param>
/// <param name="openPar">'('</param>
/// <param name="selection_opt">[expression|declare]</param>
/// <param name="semicolon_1">';'</param>
/// <param name="expression_opt_1">[expression]</param>
/// <param name="semicolon_2">';'</param>
/// <param name="expression_opt_2">[expression]</param>
/// <param name="closePar">')'</param>
/// <param name="statement">statement</param>
protected override ForSyntaxElement ReturnFor(LexicalElement @for, LexicalElement openPar, Optional <Selection <ExpressionSyntaxElement, MultiDeclareSyntaxElement> > selection_opt, LexicalElement semicolon_1, Optional <ExpressionSyntaxElement> expression_opt_1, LexicalElement semicolon_2, Optional <ExpressionSyntaxElement> expression_opt_2, LexicalElement closePar, SyntaxElement statement)
{
ExpressionSyntaxElement init = null;
if (selection_opt.HasValue)
{
if (selection_opt.Value.Element1.HasValue)
{
init = selection_opt.Value.Element1.Value;
}
if (selection_opt.Value.Element2.HasValue)
{
init = selection_opt.Value.Element2.Value;
}
}
ExpressionSyntaxElement cond = null;
if (expression_opt_1.HasValue)
{
cond = expression_opt_1.Value;
}
ExpressionSyntaxElement cont = null;
if (expression_opt_2.HasValue)
{
cont = expression_opt_2.Value;
}
return(new ForSyntaxElement(@for, init, cond, cont, statement));
}
public SubstituteSyntaxElement(LexicalElement lexAtStart, AccessorSyntaxElement accessor, OperatorType @operator, ExpressionSyntaxElement rightValue)
: base(lexAtStart)
{
this.Accessor = accessor;
this.Operator = @operator;
this.RightValue = rightValue;
}
public InvokeSyntaxElement(LexicalElement lexAtStart, ExpressionSyntaxElement function, IList <ExpressionSyntaxElement> parameters)
: base(lexAtStart)
{
this.Function = function;
this.Parameters = parameters.ToArray();
this.IsDotAccess = false;
}
public BinarySyntaxElement(LexicalElement lexAtStart, OperatorType @operator, ExpressionSyntaxElement left, ExpressionSyntaxElement right)
: base(lexAtStart)
{
this.Operator = @operator;
this.Left = left;
this.Right = right;
}
public DeclareSyntaxElement(LexicalElement lexAtStart, string identifier, VariableStorage.FieldProperty property, ExpressionSyntaxElement initialValue)
: base(lexAtStart)
{
this.Identifier = identifier;
this.InitialValue = initialValue;
this.Property = property;
}
public DoWhileSyntaxElement(LexicalElement lexAtStart, ExpressionSyntaxElement condition, SyntaxElement statement, bool @do)
: base(lexAtStart)
{
this.Condition = condition;
this.Statement = statement;
this.Do = @do;
}
public IfSyntaxElement(LexicalElement lexAtStart, ExpressionSyntaxElement condition, SyntaxElement then, SyntaxElement @else)
: base(lexAtStart)
{
this.Condition = condition;
this.Then = then;
this.Else = @else;
}
public ForeachSyntaxElement(LexicalElement lexAtStart, string identifier, bool declare, ExpressionSyntaxElement enumerator, SyntaxElement statement)
: base(lexAtStart)
{
this.Identifier = identifier;
this.Declare = declare;
this.Enumerator = enumerator;
this.Statement = statement;
}
public ForSyntaxElement(LexicalElement lexAtStart, ExpressionSyntaxElement initialize, ExpressionSyntaxElement condition, ExpressionSyntaxElement @continue, SyntaxElement statement)
: base(lexAtStart)
{
this.Initialize = initialize;
this.Condition = condition;
this.Continue = @continue;
this.Statement = statement;
}
public TernarySyntaxElement(LexicalElement lexAtStart, OperatorType @operator, ExpressionSyntaxElement first, ExpressionSyntaxElement second, ExpressionSyntaxElement third)
: base(lexAtStart)
{
this.Operator = @operator;
this.First = first;
this.Second = second;
this.Third = third;
}
protected override ExpressionSyntaxElement ReturnOr(ExpressionSyntaxElement and, FixedList <LexicalElement, ExpressionSyntaxElement>[] repeatOfOrAndAnd)
{
ExpressionSyntaxElement left = and;
foreach (var right in repeatOfOrAndAnd)
{
left = new BinarySyntaxElement(left.LexAtStart, BinarySyntaxElement.OperatorType.Or, left, right.Element2);
}
return(left);
}
protected override ExpressionSyntaxElement ReturnAnd(ExpressionSyntaxElement cmp, FixedList <LexicalElement, ExpressionSyntaxElement>[] repeatOfAndAndCmp)
{
ExpressionSyntaxElement left = cmp;
foreach (var right in repeatOfAndAndCmp)
{
left = new BinarySyntaxElement(left.LexAtStart, BinarySyntaxElement.OperatorType.And, left, right.Element2);
}
return(left);
}
protected override MultiExpressionSyntaxElement ReturnMultiExpression(ExpressionSyntaxElement expression, FixedList <LexicalElement, ExpressionSyntaxElement>[] repeatOfCommaAndExpression)
{
List <ExpressionSyntaxElement> expressions = new List <ExpressionSyntaxElement>();
expressions.Add(expression);
foreach (var pair in repeatOfCommaAndExpression)
{
expressions.Add(pair.Element2);
}
return(new MultiExpressionSyntaxElement(expression.LexAtStart, expressions));
}
protected override ExpressionSyntaxElement ReturnTernary(ExpressionSyntaxElement or, Optional <FixedList <LexicalElement, ExpressionSyntaxElement, LexicalElement, ExpressionSyntaxElement> > optOfQuestionAndTernaryAndColonAndTernary)
{
ExpressionSyntaxElement left = or;
if (optOfQuestionAndTernaryAndColonAndTernary.HasValue)
{
ExpressionSyntaxElement atTrue = optOfQuestionAndTernaryAndColonAndTernary.Value.Element2;
ExpressionSyntaxElement atFalse = optOfQuestionAndTernaryAndColonAndTernary.Value.Element4;
left = new TernarySyntaxElement(left.LexAtStart, TernarySyntaxElement.OperatorType.Condition, left, atTrue, atFalse);
}
return(left);
}
protected override MultiDeclareSyntaxElement ReturnDeclare(Selection <FixedList <LexicalElement, Optional <LexicalElement> >, LexicalElement> readonlyAnd_OptOfVar_OrVar, IdentifierSyntaxElement identifier, Optional <FixedList <LexicalElement, ExpressionSyntaxElement> > optOfEqualAndExpression, FixedList <LexicalElement, IdentifierSyntaxElement, Optional <FixedList <LexicalElement, ExpressionSyntaxElement> > >[] repeatOfCommaAndIdentifierAnd_OptOfEqualAndExpression)
{
LexicalElement head = new LexicalElement();
VariableStorage.FieldProperty property = new VariableStorage.FieldProperty();
if (readonlyAnd_OptOfVar_OrVar.Element1.HasValue)
{
head = readonlyAnd_OptOfVar_OrVar.Element1.Value.Element1;
property.Readonly = true;
}
else
{
head = readonlyAnd_OptOfVar_OrVar.Element2.Value;
}
List <DeclareSyntaxElement> varList = new List <DeclareSyntaxElement>();
if (optOfEqualAndExpression.HasValue)
{
DeclareSyntaxElement var1 = new DeclareSyntaxElement(identifier.LexAtStart, identifier.Identifier, property, optOfEqualAndExpression.Value.Element2);
varList.Add(var1);
}
else
{
DeclareSyntaxElement var1 = new DeclareSyntaxElement(identifier.LexAtStart, identifier.Identifier, property);
varList.Add(var1);
}
foreach (var declare in repeatOfCommaAndIdentifierAnd_OptOfEqualAndExpression)
{
DeclareSyntaxElement var2;
IdentifierSyntaxElement identifier2 = declare.Element2;
if (declare.Element3.HasValue)
{
ExpressionSyntaxElement expression2 = declare.Element3.Value.Element2;
var2 = new DeclareSyntaxElement(identifier2.LexAtStart, identifier2.Identifier, property, expression2);
}
else
{
var2 = new DeclareSyntaxElement(identifier2.LexAtStart, identifier2.Identifier, property);
}
varList.Add(var2);
}
return(new MultiDeclareSyntaxElement(head, property, varList));
}
protected override ExpressionSyntaxElement ReturnSubstitute(ExpressionSyntaxElement leftValue, Optional <FixedList <LexicalElement, ExpressionSyntaxElement> > optOf_PlusEqual_AndSubstitute)
{
if (optOf_PlusEqual_AndSubstitute.HasValue)
{
SubstituteSyntaxElement.OperatorType op = SubstituteSyntaxElement.OperatorType.Substitute;
switch (optOf_PlusEqual_AndSubstitute.Value.Element1.Type)
{
case LexType.Equal:
op = SubstituteSyntaxElement.OperatorType.Substitute;
break;
case LexType.PlusEqual:
op = SubstituteSyntaxElement.OperatorType.Add;
break;
case LexType.MinusEqual:
op = SubstituteSyntaxElement.OperatorType.Subtract;
break;
case LexType.CrossEqual:
op = SubstituteSyntaxElement.OperatorType.Multiply;
break;
case LexType.SlashEqual:
op = SubstituteSyntaxElement.OperatorType.Divide;
break;
case LexType.PercentEqual:
op = SubstituteSyntaxElement.OperatorType.Remainder;
break;
}
AccessorSyntaxElement accessor = leftValue as AccessorSyntaxElement;
if (accessor == null)
{
throw new ParseException("Only identifier or indexer can be left value", leftValue.LexAtStart);
}
leftValue = new SubstituteSyntaxElement(leftValue.LexAtStart, accessor, op, optOf_PlusEqual_AndSubstitute.Value.Element2);
}
return(leftValue);
}
protected override ExpressionSyntaxElement ReturnCmp(ExpressionSyntaxElement add, Optional <FixedList <LexicalElement, ExpressionSyntaxElement> > optOf_Le_AndAdd)
{
ExpressionSyntaxElement left = add;
if (optOf_Le_AndAdd.HasValue)
{
BinarySyntaxElement.OperatorType op = BinarySyntaxElement.OperatorType.Eq;
switch (optOf_Le_AndAdd.Value.Element1.Type)
{
case LexType.Eq:
op = BinarySyntaxElement.OperatorType.Eq;
break;
case LexType.Ne:
op = BinarySyntaxElement.OperatorType.Ne;
break;
case LexType.Gt:
op = BinarySyntaxElement.OperatorType.Gt;
break;
case LexType.Ge:
op = BinarySyntaxElement.OperatorType.Ge;
break;
case LexType.Lt:
op = BinarySyntaxElement.OperatorType.Lt;
break;
case LexType.Le:
op = BinarySyntaxElement.OperatorType.Le;
break;
default:
throw new NotSupportedException();
}
left = new BinarySyntaxElement(left.LexAtStart, op, left, optOf_Le_AndAdd.Value.Element2);
}
return(left);
}
protected override ExpressionSyntaxElement ReturnInc(ExpressionSyntaxElement modProperty, LexicalElement plusPlus)
{
IncrementSyntaxElement.OperatorType op = IncrementSyntaxElement.OperatorType.PostDec;
switch (plusPlus.Type)
{
case LexType.PlusPlus:
op = IncrementSyntaxElement.OperatorType.PostInc;
break;
case LexType.MinusMinus:
op = IncrementSyntaxElement.OperatorType.PostDec;
break;
default:
throw new NotSupportedException();
}
AccessorSyntaxElement accessor = modProperty as AccessorSyntaxElement;
if (accessor == null)
{
throw new ParseException("Only identifier or indexer can be left value", modProperty.LexAtStart);
}
return(new IncrementSyntaxElement(plusPlus, accessor, op));
}
protected override ExpressionSyntaxElement ReturnAdd(ExpressionSyntaxElement mul, FixedList <LexicalElement, ExpressionSyntaxElement>[] repeatOf_Plus_AndMul)
{
ExpressionSyntaxElement left = mul;
foreach (var right in repeatOf_Plus_AndMul)
{
BinarySyntaxElement.OperatorType op = BinarySyntaxElement.OperatorType.Plus;
switch (right.Element1.Type)
{
case LexType.Plus:
op = BinarySyntaxElement.OperatorType.Plus;
break;
case LexType.Minus:
op = BinarySyntaxElement.OperatorType.Minus;
break;
default:
throw new NotSupportedException();
}
left = new BinarySyntaxElement(left.LexAtStart, op, left, right.Element2);
}
return(left);
}
protected override ExpressionSyntaxElement ReturnIndexing(LexicalElement openBracket, ExpressionSyntaxElement expression, LexicalElement closeBracket)
{
return(expression);
}
protected override ExpressionSyntaxElement ReturnLeftValue(ExpressionSyntaxElement ternary)
{
return(ternary);
}
protected override ExpressionSyntaxElement ReturnExpression(ExpressionSyntaxElement substitute)
{
return(substitute);
}
protected override ForeachSyntaxElement ReturnForeach(LexicalElement @foreach, LexicalElement openPar, Optional <LexicalElement> optOfVar, IdentifierSyntaxElement identifier, LexicalElement @in, ExpressionSyntaxElement expression, LexicalElement closePar, SyntaxElement statement)
{
return(new ForeachSyntaxElement(@foreach, identifier.Identifier, optOfVar.HasValue, expression, statement));
}
protected override ExpressionSyntaxElement ReturnProperty(ExpressionSyntaxElement func)
{
return(func);
}
/// <summary>
/// if = 'if', '(', expression, ')', statement, ['else', statement] ;
/// </summary>
/// <param name="@if">'if'</param>
/// <param name="openPar">'('</param>
/// <param name="expression">expression</param>
/// <param name="closePar">')'</param>
/// <param name="statement">statement</param>
/// <param name="else_Statement_opt">['else', statement]</param>
protected override IfSyntaxElement ReturnIf(LexicalElement @if, LexicalElement openPar, ExpressionSyntaxElement expression, LexicalElement closePar, SyntaxElement statement, Optional <FixedList <LexicalElement, SyntaxElement> > else_Statement_opt)
{
if (else_Statement_opt.HasValue)
{
return(new IfSyntaxElement(@if, expression, statement, else_Statement_opt.Value.Element2));
}
return(new IfSyntaxElement(@if, expression, statement));
}
protected override ExpressionSyntaxElement ReturnInc(ExpressionSyntaxElement modProperty)
{
return(modProperty);
}
