public BinaryExpression(Location location, Expression left, Expression right, BinaryOperation operation)
: base(location)
{
this.left = left;
this.right = right;
this.operation = operation;
}
public TernaryExpression(Location location, Expression left, Expression middle, Expression right, TernaryOperation operation)
: base(location)
{
this.operation = operation;
this.left = left;
this.middle = middle;
this.right = right;
}
public Parameter(Mode mode, Expression expression)
{
Mode = mode;
Expression = expression;
}
public UnaryExpression(Location location, Expression sub, UnaryOperation operation)
: base(location)
{
this.sub = sub;
this.operation = operation;
}
public ModifiedExpression(Location location, Expression original, Mode mode)
: base(location)
{
Original = original;
Mode = mode;
}
public Object CreateObject(NonterminalToken token, LALRParser argParser)
{
Expression expression;
Operation op;
Modifier mod;
Parameter paramA;
Parameter paramB;
EquStatement equ;
Statement statement;
ContainerStatement statements;
ForRofContainerStatement forrof;
List<LabelName> labels;
List<string> comments;
string labell;
switch (token.Rule.Id)
{
#region Comment
case (int)RuleConstants.RULE_EOL:
//<eol> ::= <eolSingle>
comments = new List<string>();
if (token.Tokens[0].UserObject != null)
{
string c = (string)token.Tokens[0].UserObject;
comments.Add(c.Replace("\r", ""));
}
return comments;
case (int)RuleConstants.RULE_EOL2:
//<eol> ::= <eol> <eolSingle>
comments = (List<string>)token.Tokens[0].UserObject;
if (token.Tokens[1].UserObject != null)
{
string c = (string)token.Tokens[1].UserObject;
comments.Add(c.Replace("\r", ""));
}
return comments;
case (int)RuleConstants.RULE_EOLSINGLE_NEWLINE:
//<eolSingle> ::= NewLine
return token.Tokens[0].UserObject;
case (int)RuleConstants.RULE_EOLOPTIONAL2:
//<eolOptional> ::=
comments = new List<string>();
return comments;
case (int)RuleConstants.RULE_EOLOPTIONAL:
//<eolOptional> ::= <eol>
return token.Tokens[0].UserObject;
#endregion
#region Null
case (int)RuleConstants.RULE_EOLSINGLE_COMMENT_LINE:
//<eolSingle> ::= Comment Line
case (int)RuleConstants.RULE_STATEMENT:
//<Statement> ::= <Pin>
case (int)RuleConstants.RULE_STATEMENT2:
//<Statement> ::= <Org>
case (int)RuleConstants.RULE_EXPRESSIONOPTIONAL:
// <ExpressionOptional> ::= <Expression>
case (int)RuleConstants.RULE_EXPRESSIONOPTIONAL2:
// <ExpressionOptional> ::=
return null;
#endregion
#region Forward
case (int)RuleConstants.RULE_MODEOPTIONAL:
// <ModeOptional> ::= <Mode>
case (int)RuleConstants.RULE_OPERATION:
//<Operation> ::= <Operation0>
case (int)RuleConstants.RULE_OPERATION2:
//<Operation> ::= <Operation1>
case (int)RuleConstants.RULE_OPERATION3:
//<Operation> ::= <Operation2>
case (int)RuleConstants.RULE_EXPRESSION:
//<Expression> ::= <Or Exp>
case (int)RuleConstants.RULE_OREXP:
//<Or Exp> ::= <And Exp>
case (int)RuleConstants.RULE_ANDEXP:
//<And Exp> ::= <BinOr Exp>
case (int)RuleConstants.RULE_BINOREXP:
//<BinOr Exp> ::= <BinXor Exp>
case (int)RuleConstants.RULE_BINXOREXP:
//<BinXor Exp> ::= <BinAnd Exp>
case (int)RuleConstants.RULE_BINANDEXP:
// <BinAnd Exp> ::= <Equate Exp>
case (int)RuleConstants.RULE_EQUATEEXP:
//<Equate Exp> ::= <Compare Exp>
case (int)RuleConstants.RULE_COMPAREEXP:
//<Compare Exp> ::= <Shift Exp>
case (int)RuleConstants.RULE_SHIFTEXP:
//<Shift Exp> ::= <Add Exp>
case (int)RuleConstants.RULE_ADDEXP:
//<Add Exp> ::= <Mult Exp>
case (int)RuleConstants.RULE_MULTEXP:
//<Mult Exp> ::= <Negate Exp>
case (int)RuleConstants.RULE_NEGATEEXP:
//<Negate Exp> ::= <Value>
case (int)RuleConstants.RULE_VALUE:
// <Value> ::= <Label>
case (int)RuleConstants.RULE_LABELSOPTIONAL:
//<LabelsOptional> ::= <Labels>
case (int)RuleConstants.RULE_STATEMENT3:
//<Statement> ::= <Equ>
case (int)RuleConstants.RULE_STATEMENT6:
// <Statement> ::= <Assert>
return token.Tokens[0].UserObject;
#endregion
#region Statements
case (int)RuleConstants.RULE_START:
//<Start> ::= <eolOptional> <AllStatements> <EndOptional>
comments = (List<string>)token.Tokens[0].UserObject;
ProcessComments(comments);
if (endSymbol<2)
endSymbol = 2;
statements = (ContainerStatement)token.Tokens[1].UserObject;
statement = (Statement)token.Tokens[2].UserObject;
if (statement!=null)
{
statements.Add(statement);
}
return statements;
case (int)RuleConstants.RULE_ALLSTATEMENTS:
//<AllStatements> ::= <Statement>
statement = (Statement)token.Tokens[0].UserObject;
statements = new ContainerStatement(statement, token.Location);
return statements;
case (int)RuleConstants.RULE_ALLSTATEMENTSOPTIONAL:
//<AllStatementsOptional> ::= <AllStatements> <eol>
statements = (ContainerStatement)token.Tokens[0].UserObject;
comments = (List<string>)token.Tokens[1].UserObject;
statements.AppendComments(comments);
return statements;
case (int)RuleConstants.RULE_ALLSTATEMENTS3:
//<AllStatements> ::= <AllStatements> <eol> <Statement>
statements = (ContainerStatement)token.Tokens[0].UserObject;
statement = (Statement)token.Tokens[2].UserObject;
comments = (List<string>)token.Tokens[1].UserObject;
statements.AppendComments(comments);
statements.Add(statement);
return statements;
case (int)RuleConstants.RULE_ALLSTATEMENTS4:
//<AllStatements> ::= <AllStatements> <eol> <For>
statements = (ContainerStatement)token.Tokens[0].UserObject;
comments = (List<string>)token.Tokens[1].UserObject;
statements.AppendComments(comments);
forrof = (ForRofContainerStatement)token.Tokens[2].UserObject;
statements.Add(forrof);
return statements;
case (int)RuleConstants.RULE_ALLSTATEMENTS2:
//<AllStatements> ::= <For>
statements = new ContainerStatement(token.Location);
forrof = (ForRofContainerStatement)token.Tokens[0].UserObject;
statements.Add(forrof);
return statements;
case (int)RuleConstants.RULE_ALLSTATEMENTSOPTIONAL2:
//<AllStatementsOptional> ::=
statements = new ContainerStatement(token.Location);
return statements;
case (int)RuleConstants.RULE_FOR_FOR_ROF2:
// <For> ::= <Labels> <eol> for <Expression> <eol> <AllStatementsOptional> rof <ExpressionOptional>
labels = ((List<LabelName>)token.Tokens[0].UserObject);
expression = (Expression)token.Tokens[3].UserObject;
comments = (List<string>)token.Tokens[4].UserObject;
statement = (Statement)token.Tokens[5].UserObject;
forrof = CreateForrof(comments, expression, statement, labels, token);
return forrof;
case (int)RuleConstants.RULE_FOR_FOR_ROF:
// <For> ::= <LabelsOptional> for <Expression> <eol> <AllStatementsOptional> rof <ExpressionOptional>
labels = ((List<LabelName>)token.Tokens[0].UserObject);
expression = (Expression)token.Tokens[2].UserObject;
comments = (List<string>)token.Tokens[3].UserObject;
statement = (Statement)token.Tokens[4].UserObject;
forrof = CreateForrof(comments, expression, statement, labels, token);
return forrof;
case (int)RuleConstants.RULE_ASSERT_ATASSERT:
// <Assert> ::= @assert <Expression>
expression = (Expression)token.Tokens[1].UserObject;
return new AssertStatement(expression, token.Location);
#endregion
#region Operation Statements
case (int)RuleConstants.RULE_STATEMENT4:
//<Statement> ::= <LabelsOptional> <Operation>
labels = (List<LabelName>)token.Tokens[0].UserObject;
statement = (InstructionStatement)token.Tokens[1].UserObject;
statement.Labels = labels;
foreach (LabelName label in labels)
{
variables[label.Name] = label;
}
return statement;
case (int)RuleConstants.RULE_STATEMENT5:
//<Statement> ::= <Labels> <eol> <Operation>
labels = (List<LabelName>)token.Tokens[0].UserObject;
statement = (InstructionStatement)token.Tokens[2].UserObject;
statement.Labels = labels;
foreach (LabelName label in labels)
{
variables[label.Name] = label;
}
return statement;
#endregion
#region Simple Statements
case (int)RuleConstants.RULE_MODEOPTIONAL2:
// <ModeOptional> ::=
return Mode.NULL;
case (int)RuleConstants.RULE_PIN_PIN:
//<Pin> ::= Pin <Expression>
pin = (Expression)token.Tokens[1].UserObject;
return null;
case (int)RuleConstants.RULE_ENDOPTIONAL:
//<EndOptional> ::= <eol>
case (int)RuleConstants.RULE_ENDOPTIONAL2:
//<EndOptional> ::=
case (int)RuleConstants.RULE_ENDOPTIONAL_END:
//<EndOptional> ::= <eol> End <eolOptional>
if (endSymbol < 2)
endSymbol = 2;
return null;
case (int)RuleConstants.RULE_ENDOPTIONAL_END3:
//<EndOptional> ::= <eol> <Labels> End <eolOptional>
case (int)RuleConstants.RULE_ENDOPTIONAL_END5:
//<EndOptional> ::= <eol> <Labels> <eol> End <eolOptional>
if (endSymbol < 2)
endSymbol = 2;
labels = (List<LabelName>)token.Tokens[1].UserObject;
labels.Add(new LabelName(token.Tokens[1].Location, "#end#"));
statement = new EquStatement(null, token.Location);
statement.Labels = labels;
return statement;
case (int)RuleConstants.RULE_ENDOPTIONAL_END2:
//<EndOptional> ::= <eol> End <Expression> <eolOptional>
org = (Expression)token.Tokens[2].UserObject;
if (endSymbol < 2)
endSymbol = 2;
return null;
case (int)RuleConstants.RULE_ENDOPTIONAL_END4:
//<EndOptional> ::= <eol> <Labels> End <Expression> <eolOptional>
org = (Expression)token.Tokens[3].UserObject;
if (endSymbol < 2)
endSymbol = 2;
labels = (List<LabelName>)token.Tokens[1].UserObject;
labels.Add(new LabelName(token.Tokens[1].Location, "#end#"));
statement = new EquStatement(null, token.Location);
statement.Labels = labels;
return statement;
case (int)RuleConstants.RULE_ENDOPTIONAL_END6:
//<EndOptional> ::= <eol> <Labels> <eol> End <Expression> <eolOptional>
org = (Expression)token.Tokens[4].UserObject;
if (endSymbol < 2)
endSymbol = 2;
labels = (List<LabelName>)token.Tokens[1].UserObject;
labels.Add(new LabelName(token.Tokens[1].Location, "#end#"));
statement = new EquStatement(null, token.Location);
statement.Labels = labels;
return statement;
case (int)RuleConstants.RULE_ORG_ORG:
//<Org> ::= Org <Expression>
org = (Expression)token.Tokens[1].UserObject;
return null;
case (int)RuleConstants.RULE_EQU_EQU:
// <Equ> ::= <Labels> Equ <ModeOptional> <Expression>
labels = (List<LabelName>)token.Tokens[0].UserObject;
expression = (Expression)token.Tokens[3].UserObject;
Mode mode = (Mode)token.Tokens[2].UserObject;
if (mode!=Mode.NULL)
{
expression = new ModifiedExpression(token.Tokens[2].Location, expression, mode);
}
equ = new EquStatement(expression, token.Location);
equ.Labels = labels;
foreach (LabelName label in labels)
{
CheckName(label.Name, token.Tokens[1].Location);
variables[label.Name] = expression;
}
return equ;
case (int)RuleConstants.RULE_EQU_EQU2:
// <Equ> ::= <Labels> <eol> Equ <ModeOptional> <Expression>
labels = (List<LabelName>)token.Tokens[0].UserObject;
expression = (Expression)token.Tokens[4].UserObject;
equ = new EquStatement(expression, token.Location);
equ.Labels = labels;
foreach (LabelName label in labels)
{
CheckName(label.Name, token.Tokens[2].Location);
variables[label.Name] = expression;
}
return equ;
#endregion
#region Labels
case (int)RuleConstants.RULE_LABEL:
// <Label> ::= <Modifier>
labell = token.Tokens[0].UserObject as string;
if (labell == null)
{
labell = token.Tokens[0].UserObject.ToString();
}
// CheckName(labell, token.Tokens[0].Location);
return new LabelName(token.Tokens[0].Location, labell);
case (int)RuleConstants.RULE_LABEL_LABEL_AMP:
// <Label> ::= Label & <Modifier>
labell = token.Tokens[2].UserObject as string;
if (labell == null)
{
labell = token.Tokens[2].UserObject.ToString();
}
return new ComposedLabelName(token.Tokens[0].Location, (string)token.Tokens[0].UserObject, labell);
case (int)RuleConstants.RULE_LABEL_AMP_LABEL:
// <Label> ::= <Modifier> & Label
labell = token.Tokens[0].UserObject as string;
if (labell == null)
{
labell = token.Tokens[0].UserObject.ToString();
}
return new ComposedLabelName(token.Tokens[0].Location, labell, (string)token.Tokens[2].UserObject);
case (int)RuleConstants.RULE_LABEL_LABEL:
// <Label> ::= Label
labell = (string)token.Tokens[0].UserObject;
// CheckName(labell, token.Tokens[0].Location);
return new LabelName(token.Tokens[0].Location, labell);
case (int)RuleConstants.RULE_LABEL_LABEL_AMP_LABEL:
// <Label> ::= Label & Label
return new ComposedLabelName(token.Tokens[0].Location, (string)token.Tokens[0].UserObject, (string)token.Tokens[2].UserObject);
case (int)RuleConstants.RULE_LABELSOPTIONAL2:
//<LabelsOptional> ::=
labels = new List<LabelName>();
return labels;
case (int)RuleConstants.RULE_LABELS:
// <Labels> ::= <Label>
labels = new List<LabelName>();
labels.Add((LabelName)token.Tokens[0].UserObject);
return labels;
case (int)RuleConstants.RULE_LABELS2:
// <Labels> ::= <Labels> <eol> <Label>
labels = (List<LabelName>)token.Tokens[0].UserObject;
labels.Add((LabelName)token.Tokens[2].UserObject);
return labels;
case (int)RuleConstants.RULE_LABELS3:
// <Labels> ::= <Labels> <Label>
labels = (List<LabelName>)token.Tokens[0].UserObject;
labels.Add((LabelName)token.Tokens[1].UserObject);
return labels;
#endregion
#region Operations
case (int)RuleConstants.RULE_OPERATION0:
//<Operation0> ::= <Operator0>
op = (Operation)token.Tokens[0].UserObject;
paramA = new Parameter();
paramB = new Parameter();
mod = Modifier.NULL;
return new InstructionStatement(op, mod, paramA, paramB, token.Tokens[0].Location);
case (int)RuleConstants.RULE_OPERATION0_DOT2:
// <Operation0> ::= <Operator0> . <Modifier>
op = (Operation)token.Tokens[0].UserObject;
mod = (Modifier)token.Tokens[2].UserObject;
paramA = new Parameter();
paramB = new Parameter();
return new InstructionStatement(op, mod, paramA, paramB, token.Tokens[0].Location);
case (int)RuleConstants.RULE_OPERATION0_COMMA:
//<Operation0> ::= <Operator0> <Parameter> , <Parameter>
op = (Operation)token.Tokens[0].UserObject;
paramA = (Parameter)token.Tokens[1].UserObject;
paramB = (Parameter)token.Tokens[3].UserObject;
mod = Modifier.NULL;
return new InstructionStatement(op, mod, paramA, paramB, token.Tokens[0].Location);
case (int)RuleConstants.RULE_OPERATION0_DOT_COMMA:
//<Operation0> ::= <Operator0> . <Modifier> <Parameter> , <Parameter>
op = (Operation)token.Tokens[0].UserObject;
mod = (Modifier)token.Tokens[2].UserObject;
paramA = (Parameter)token.Tokens[3].UserObject;
paramB = (Parameter)token.Tokens[5].UserObject;
return new InstructionStatement(op, mod, paramA, paramB, token.Tokens[0].Location);
case (int)RuleConstants.RULE_OPERATION02:
//<Operation0> ::= <Operator0> <Parameter>
case (int)RuleConstants.RULE_OPERATION1:
//<Operation1> ::= <Operator1> <Parameter>
op = (Operation)token.Tokens[0].UserObject;
if (op == Operation.DAT)
{
paramA = new Parameter();
paramA.Mode = Mode.Immediate;
paramB = (Parameter)token.Tokens[1].UserObject;
}
else
{
paramA = (Parameter)token.Tokens[1].UserObject;
paramB = new Parameter();
}
mod = Modifier.NULL;
return new InstructionStatement(op, mod, paramA, paramB, token.Tokens[0].Location);
case (int)RuleConstants.RULE_OPERATION0_DOT:
//<Operation0> ::= <Operator0> . <Modifier> <Parameter>
case (int)RuleConstants.RULE_OPERATION1_DOT:
//<Operation1> ::= <Operator1> . <Modifier> <Parameter>
op = (Operation)token.Tokens[0].UserObject;
mod = (Modifier)token.Tokens[2].UserObject;
if (op == Operation.DAT)
{
paramA = new Parameter();
paramA.Mode = Mode.Immediate;
paramB = (Parameter)token.Tokens[3].UserObject;
}
else
{
paramA = (Parameter)token.Tokens[3].UserObject;
paramB = new Parameter();
}
return new InstructionStatement(op, mod, paramA, paramB, token.Tokens[0].Location);
case (int)RuleConstants.RULE_OPERATION1_COMMA:
//<Operation1> ::= <Operator1> <Parameter> , <Parameter>
op = (Operation)token.Tokens[0].UserObject;
paramA = (Parameter)token.Tokens[1].UserObject;
paramB = (Parameter)token.Tokens[3].UserObject;
mod = Modifier.NULL;
return new InstructionStatement(op, mod, paramA, paramB, token.Tokens[0].Location);
case (int)RuleConstants.RULE_OPERATION1_DOT_COMMA:
//<Operation1> ::= <Operator1> . <Modifier> <Parameter> , <Parameter>
op = (Operation)token.Tokens[0].UserObject;
mod = (Modifier)token.Tokens[2].UserObject;
paramA = (Parameter)token.Tokens[3].UserObject;
paramB = (Parameter)token.Tokens[5].UserObject;
return new InstructionStatement(op, mod, paramA, paramB, token.Tokens[0].Location);
case (int)RuleConstants.RULE_OPERATION2_COMMA:
//<Operation2> ::= <Operator2> <Parameter> , <Parameter>
op = (Operation)token.Tokens[0].UserObject;
paramA = (Parameter)token.Tokens[1].UserObject;
paramB = (Parameter)token.Tokens[3].UserObject;
mod = Modifier.NULL;
return new InstructionStatement(op, mod, paramA, paramB, token.Tokens[0].Location);
case (int)RuleConstants.RULE_OPERATION2_DOT_COMMA:
//<Operation2> ::= <Operator2> . <Modifier> <Parameter> , <Parameter>
op = (Operation)token.Tokens[0].UserObject;
mod = (Modifier)token.Tokens[2].UserObject;
paramA = (Parameter)token.Tokens[3].UserObject;
paramB = (Parameter)token.Tokens[5].UserObject;
return new InstructionStatement(op, mod, paramA, paramB, token.Tokens[0].Location);
#endregion
#region Parameters
case (int)RuleConstants.RULE_PARAMETER:
//<Parameter> ::= <Expression>
return new Parameter(Mode.NULL, (Expression)token.Tokens[0].UserObject);
case (int)RuleConstants.RULE_PARAMETER2:
//<Parameter> ::= <Mode> <Expression>
return new Parameter((Mode)token.Tokens[0].UserObject, (Expression)token.Tokens[1].UserObject);
#endregion
#region Mode
case (int)RuleConstants.RULE_MODE_NUM:
//<Mode> ::= #
//todo: Create a new object using the stored user objects.
return Mode.Immediate;
case (int)RuleConstants.RULE_MODE_DOLLAR:
//<Mode> ::= $
return Mode.Direct;
case (int)RuleConstants.RULE_MODE_AT:
//<Mode> ::= @
return Mode.IndirectB;
case (int)RuleConstants.RULE_MODE_LT:
//<Mode> ::= <
return Mode.PreDecIndirectB;
case (int)RuleConstants.RULE_MODE_GT:
//<Mode> ::= >
return Mode.PostIncIndirectB;
case (int)RuleConstants.RULE_MODE_LBRACE:
//<Mode> ::= {
return Mode.PreDecIndirectA;
case (int)RuleConstants.RULE_MODE_RBRACE:
//<Mode> ::= }
return Mode.PostIncIndirectA;
case (int)RuleConstants.RULE_MODE_TIMES:
//<Mode> ::= *
return Mode.IndirectA;
#endregion
#region Operator
case (int)RuleConstants.RULE_OPERATOR0_NOP:
//<Operator0> ::= Nop
return Operation.NOP;
case (int)RuleConstants.RULE_OPERATOR1_JMP:
//<Operator1> ::= Jmp
return Operation.JMP;
case (int)RuleConstants.RULE_OPERATOR1_DAT:
//<Operator2> ::= Dat
return Operation.DAT;
case (int)RuleConstants.RULE_OPERATOR1_SPL:
//<Operator2> ::= Spl
return Operation.SPL;
case (int)RuleConstants.RULE_OPERATOR2_MOV:
//<Operator2> ::= Mov
return Operation.MOV;
case (int)RuleConstants.RULE_OPERATOR2_ADD:
//<Operator2> ::= Add
return Operation.ADD;
case (int)RuleConstants.RULE_OPERATOR2_SUB:
//<Operator2> ::= Sub
return Operation.SUB;
case (int)RuleConstants.RULE_OPERATOR2_MUL:
//<Operator2> ::= Mul
return Operation.MUL;
case (int)RuleConstants.RULE_OPERATOR2_DIV:
//<Operator2> ::= Div
return Operation.DIV;
case (int)RuleConstants.RULE_OPERATOR2_MOD:
//<Operator2> ::= Mod
return Operation.MOD;
case (int)RuleConstants.RULE_OPERATOR2_JMZ:
//<Operator2> ::= Jmz
return Operation.JMZ;
case (int)RuleConstants.RULE_OPERATOR2_JMN:
//<Operator2> ::= Jmn
return Operation.JMN;
case (int)RuleConstants.RULE_OPERATOR2_DJN:
//<Operator2> ::= Djn
return Operation.DJN;
case (int)RuleConstants.RULE_OPERATOR2_SLT:
//<Operator2> ::= Slt
return Operation.SLT;
case (int)RuleConstants.RULE_OPERATOR2_SNE:
//<Operator2> ::= Sne
return Operation.SNE;
case (int)RuleConstants.RULE_OPERATOR2_LDP:
//<Operator2> ::= Ldp
return Operation.LDP;
case (int)RuleConstants.RULE_OPERATOR2_STP:
//<Operator2> ::= Stp
return Operation.STP;
case (int)RuleConstants.RULE_OPERATOR2_CMP:
//<Operator2> ::= Cmp
return Operation.CMP;
case (int)RuleConstants.RULE_OPERATOR2_SEQ:
//<Operator2> ::= Seq
return Operation.CMP;
#endregion
#region Modifiers
case (int)RuleConstants.RULE_MODIFIER_I:
//<Modifier> ::= I
return Modifier.I;
case (int)RuleConstants.RULE_MODIFIER_A:
//<Modifier> ::= A
return Modifier.A;
case (int)RuleConstants.RULE_MODIFIER_B:
//<Modifier> ::= B
return Modifier.B;
case (int)RuleConstants.RULE_MODIFIER_AB:
//<Modifier> ::= AB
return Modifier.AB;
case (int)RuleConstants.RULE_MODIFIER_BA:
//<Modifier> ::= BA
return Modifier.BA;
case (int)RuleConstants.RULE_MODIFIER_F:
//<Modifier> ::= F
return Modifier.F;
case (int)RuleConstants.RULE_MODIFIER_X:
//<Modifier> ::= X
return Modifier.X;
#endregion
#region Expressions
case (int)RuleConstants.RULE_EXPRESSION_QUESTION_COLON:
//<Expression> ::= <Or Exp> ? <Expression> : <Expression>
return
new TernaryExpression(token.Tokens[1].Location,
(Expression)token.Tokens[0].UserObject,
(Expression)token.Tokens[2].UserObject,
(Expression)token.Tokens[4].UserObject,
TernaryExpression.TernaryOperation.If);
case (int)RuleConstants.RULE_OREXP_PIPEPIPE:
//<Or Exp> ::= <Or Exp> || <And Exp>
return
new BinaryExpression(token.Tokens[1].Location,
(Expression)token.Tokens[0].UserObject,
(Expression)token.Tokens[2].UserObject, BinaryExpression.BinaryOperation.Or);
case (int)RuleConstants.RULE_ANDEXP_AMPAMP:
//<And Exp> ::= <And Exp> && <BinOr Exp>
return
new BinaryExpression(token.Tokens[1].Location,
(Expression)token.Tokens[0].UserObject,
(Expression)token.Tokens[2].UserObject,
BinaryExpression.BinaryOperation.And);
case (int)RuleConstants.RULE_BINOREXP_PIPE:
//<BinOr Exp> ::= <BinOr Exp> | <BinXor Exp>
return
new BinaryExpression(token.Tokens[1].Location,
(Expression)token.Tokens[0].UserObject,
(Expression)token.Tokens[2].UserObject,
BinaryExpression.BinaryOperation.BinOr);
case (int)RuleConstants.RULE_BINXOREXP_CARET:
//<BinXor Exp> ::= <BinXor Exp> ^ <BinAnd Exp>
return
new BinaryExpression(token.Tokens[1].Location,
(Expression)token.Tokens[0].UserObject,
(Expression)token.Tokens[2].UserObject,
BinaryExpression.BinaryOperation.BinXor);
case (int)RuleConstants.RULE_BINANDEXP_AMPAMPAMP:
// <BinAnd Exp> ::= <BinAnd Exp> &&& <Equate Exp>
return
new BinaryExpression(token.Tokens[1].Location,
(Expression)token.Tokens[0].UserObject,
(Expression)token.Tokens[2].UserObject,
BinaryExpression.BinaryOperation.BinAnd);
case (int)RuleConstants.RULE_EQUATEEXP_EQEQ:
//<Equate Exp> ::= <Equate Exp> == <Compare Exp>
return
new BinaryExpression(token.Tokens[1].Location,
(Expression)token.Tokens[0].UserObject,
(Expression)token.Tokens[2].UserObject,
BinaryExpression.BinaryOperation.CompareEq);
case (int)RuleConstants.RULE_EQUATEEXP_LTGT:
//<Equate Exp> ::= <Equate Exp> <> <Compare Exp>
case (int)RuleConstants.RULE_EQUATEEXP_EXCLAMEQ:
//<Equate Exp> ::= <Equate Exp> != <Compare Exp>
return
new BinaryExpression(token.Tokens[1].Location,
(Expression)token.Tokens[0].UserObject,
(Expression)token.Tokens[2].UserObject,
BinaryExpression.BinaryOperation.CompareNe);
case (int)RuleConstants.RULE_COMPAREEXP_LT:
//<Compare Exp> ::= <Compare Exp> < <Shift Exp>
return
new BinaryExpression(token.Tokens[1].Location,
(Expression)token.Tokens[0].UserObject,
(Expression)token.Tokens[2].UserObject,
BinaryExpression.BinaryOperation.CompareLt);
case (int)RuleConstants.RULE_COMPAREEXP_GT:
//<Compare Exp> ::= <Compare Exp> > <Shift Exp>
return
new BinaryExpression(token.Tokens[1].Location,
(Expression)token.Tokens[0].UserObject,
(Expression)token.Tokens[2].UserObject,
BinaryExpression.BinaryOperation.CompareGt);
case (int)RuleConstants.RULE_COMPAREEXP_LTEQ:
//<Compare Exp> ::= <Compare Exp> <= <Shift Exp>
return
new BinaryExpression(token.Tokens[1].Location,
(Expression)token.Tokens[0].UserObject,
(Expression)token.Tokens[2].UserObject,
BinaryExpression.BinaryOperation.CompareLe);
case (int)RuleConstants.RULE_COMPAREEXP_GTEQ:
//<Compare Exp> ::= <Compare Exp> >= <Shift Exp>
return
new BinaryExpression(token.Tokens[1].Location,
(Expression)token.Tokens[0].UserObject,
(Expression)token.Tokens[2].UserObject,
BinaryExpression.BinaryOperation.CompareGe);
case (int)RuleConstants.RULE_SHIFTEXP_LTLT:
//<Shift Exp> ::= <Shift Exp> << <Add Exp>
return
new BinaryExpression(token.Tokens[1].Location,
(Expression)token.Tokens[0].UserObject,
(Expression)token.Tokens[2].UserObject,
BinaryExpression.BinaryOperation.Shl);
case (int)RuleConstants.RULE_SHIFTEXP_GTGT:
//<Shift Exp> ::= <Shift Exp> >> <Add Exp>
return
new BinaryExpression(token.Tokens[1].Location,
(Expression)token.Tokens[0].UserObject,
(Expression)token.Tokens[2].UserObject,
BinaryExpression.BinaryOperation.Shr);
case (int)RuleConstants.RULE_ADDEXP_PLUS:
//<Expression> ::= <Expression> + <Mult Exp>
return
new BinaryExpression(token.Tokens[1].Location,
(Expression)token.Tokens[0].UserObject,
(Expression)token.Tokens[2].UserObject,
BinaryExpression.BinaryOperation.Plus);
case (int)RuleConstants.RULE_ADDEXP_MINUS:
//<Expression> ::= <Expression> - <Mult Exp>
return
new BinaryExpression(token.Tokens[1].Location,
(Expression)token.Tokens[0].UserObject,
(Expression)token.Tokens[2].UserObject,
BinaryExpression.BinaryOperation.Minus);
case (int)RuleConstants.RULE_MULTEXP_TIMES:
//<Mult Exp> ::= <Mult Exp> * <Negate Exp>
return
new BinaryExpression(token.Tokens[1].Location,
(Expression)token.Tokens[0].UserObject,
(Expression)token.Tokens[2].UserObject,
BinaryExpression.BinaryOperation.Multiply);
case (int)RuleConstants.RULE_MULTEXP_DIV:
//<Mult Exp> ::= <Mult Exp> / <Negate Exp>
return
new BinaryExpression(token.Tokens[1].Location,
(Expression)token.Tokens[0].UserObject,
(Expression)token.Tokens[2].UserObject,
BinaryExpression.BinaryOperation.Divide);
case (int)RuleConstants.RULE_MULTEXP_PERCENT:
//<Mult Exp> ::= <Mult Exp> % <Negate Exp>
return
new BinaryExpression(token.Tokens[1].Location,
(Expression)token.Tokens[0].UserObject,
(Expression)token.Tokens[2].UserObject,
BinaryExpression.BinaryOperation.Modulo);
case (int)RuleConstants.RULE_NEGATEEXP_MINUS:
//<Negate Exp> ::= - <Value>
return
new UnaryExpression(token.Tokens[0].Location,
(Expression)token.Tokens[1].UserObject,
UnaryExpression.UnaryOperation.Negate);
case (int)RuleConstants.RULE_NEGATEEXP_PLUS:
//<Negate Exp> ::= + <Value>
return token.Tokens[1].UserObject;
case (int)RuleConstants.RULE_VALUE_INTEGER:
//<Value> ::= Integer
return new Value(token.Tokens[0].Location, (string)token.Tokens[0].UserObject);
case (int)RuleConstants.RULE_VALUE_LPARAN_RPARAN:
//<Value> ::= ( <Expression> )
return
new UnaryExpression(token.Tokens[0].Location, (Expression)token.Tokens[1].UserObject,
UnaryExpression.UnaryOperation.Brackets);
#endregion
}
throw new RuleException("Unknown rule");
}
private ForRofContainerStatement CreateForrof(List<string> comments, Expression expression, Statement statement, List<LabelName> statementlabels, NonterminalToken token)
{
ForRofContainerStatement forrof;
forrof = new ForRofContainerStatement(token.Location);
forrof.Comments = comments;
forrof.Labels = statementlabels;
forrof.Add(statement);
LabelName l = new LabelName(expression.Location, "#forof" + rofforCounter);
if (statementlabels.Count > 0)
{
l = statementlabels[statementlabels.Count - 1];
}
else
{
statementlabels.Add(l);
}
//for label could be reused
//CheckName(l, token.Tokens[1].Location);
variables[l.Name] = expression;
//for label could be reused
//CheckName(l, token.Tokens[1].Location);
forrof.LimitName = l.Name + "#" + rofforCounter + "#limit";
variables[forrof.LimitName] = expression;
rofforCounter++;
return forrof;
}
public EquStatement(Expression expression, Location location)
: base(location)
{
this.expression = expression;
}