/*multiplicative-expression-p:
| multiplicative-operators unary-expression multiplicative-expression-p
| EPSILON */
private ExpressionNode multiplicative_expression_p(ExpressionNode leftExpression)
{
printIfDebug("multiplicative_expression_p");
if (pass(multiplicativeOperatorOptions))
{
Token multiplicativeOperator = token;
consumeToken();
var unaryExpression = unary_expression();
ExpressionNode resultExpression = null;
if (multiplicativeOperator.type == TokenType.OP_MULTIPLICATION)
{
resultExpression = new MultNode(leftExpression, unaryExpression, multiplicativeOperator);
}
else if (multiplicativeOperator.type == TokenType.OP_DIVISION)
{
resultExpression = new DivNode(leftExpression, unaryExpression, multiplicativeOperator);
}
else
{
resultExpression = new ModNode(leftExpression, unaryExpression, multiplicativeOperator);
}
return(multiplicative_expression_p(resultExpression));
}
return(leftExpression);
}
private ExpressionNode TP(ExpressionNode param)
{
if (currentToken.Type == TokenTypes.Mult)
{
currentToken = lexer.GetNextToken();
var fValue = F();
var node = new MultNode {
LeftOperand = param, RightOperand = fValue
};
return(TP(node));
}
else if (currentToken.Type == TokenTypes.Div)
{
currentToken = lexer.GetNextToken();
var fValue = F();
var node = new DivNode()
{
LeftOperand = param, RightOperand = fValue
};
return(TP(node));
}
else
{
return(param);
}
}
private static (EquationNode part1, EquationNode part2) GenerateEquationTrees(IList <string> equation)
{
var(lhs1, lhs2) = GetNextNode(equation);
while (equation.Count > 0)
{
var op = GetNextOpCode(equation);
var(rhs1, rhs2) = GetNextNode(equation);
switch (op)
{
case "*":
lhs1 = new MultNode(lhs1, rhs1);
lhs2 = new MultNode(lhs2, rhs2);
break;
case "+":
lhs1 = new AddNode(lhs1, rhs1);
if (!lhs2.IsBracketNode && lhs2.GetType() == typeof(MultNode))
{
var multNode = (MultNode)lhs2;
multNode.Rhs = new AddNode(multNode.Rhs, rhs2);
}
else
{
lhs2 = new AddNode(lhs2, rhs2);
}
break;
}
}
return(lhs1, lhs2);
}
public static Node BuildExpr() {
MultNode tn = new MultNode();
PlusNode pn = new PlusNode();
pn.left = new IntNode (5);
pn.right = new IntNode (4);
tn.left = pn;
tn.right = pn;
return tn;
}
public static Node BuildExpr()
{
MultNode tn = new MultNode();
PlusNode pn = new PlusNode();
pn.left = new IntNode(5);
pn.right = new IntNode(4);
tn.left = pn;
tn.right = pn;
return(tn);
}
private void Parsing(MultNode node, StringBuilder sb, ref int lineNum)
{
Parsing(node.GetChild(0) as dynamic, sb, ref lineNum);
Parsing(node.GetChild(1) as dynamic, sb, ref lineNum);
PrintCommand(sb, "mul", ref lineNum);
}
private VarType Parsing(MultNode node, string methodName)
{
return ParseElementaryOperation(node, methodName);
}
private TypeInfo Visit(MultNode node, MethodBuilder builder, CodegenContext context)
{
return(BinaryOperatorVisit(node, builder, (x) => x.Mult(), context));
}
// throws RecognitionException [1]
// $ANTLR end "expr_pm"
// $ANTLR start "expr_dm"
// C:\\Users\\Danaice\\Desktop\\lastversion\\Dany_gramatica tiger ANTLR oficial\\tiger_grammar.g:154:1: expr_dm returns [TigerNode dm] : exp1= expr ( MULT a= expr | DIV b= expr )* ;
public TigerNode expr_dm()
{
TigerNode dm = null;
IToken MULT12 = null;
IToken DIV13 = null;
TigerNode exp1 = null;
TigerNode a = null;
TigerNode b = null;
try
{
// C:\\Users\\Danaice\\Desktop\\lastversion\\Dany_gramatica tiger ANTLR oficial\\tiger_grammar.g:154:32: (exp1= expr ( MULT a= expr | DIV b= expr )* )
// C:\\Users\\Danaice\\Desktop\\lastversion\\Dany_gramatica tiger ANTLR oficial\\tiger_grammar.g:154:34: exp1= expr ( MULT a= expr | DIV b= expr )*
{
PushFollow(FOLLOW_expr_in_expr_dm1033);
exp1 = expr();
state.followingStackPointer--;
if (state.failed) return dm;
if ( (state.backtracking==0) )
{
dm = exp1;
}
// C:\\Users\\Danaice\\Desktop\\lastversion\\Dany_gramatica tiger ANTLR oficial\\tiger_grammar.g:155:36: ( MULT a= expr | DIV b= expr )*
do
{
int alt6 = 3;
int LA6_0 = input.LA(1);
if ( (LA6_0 == MULT) )
{
alt6 = 1;
}
else if ( (LA6_0 == DIV) )
{
alt6 = 2;
}
switch (alt6)
{
case 1 :
// C:\\Users\\Danaice\\Desktop\\lastversion\\Dany_gramatica tiger ANTLR oficial\\tiger_grammar.g:155:37: MULT a= expr
{
MULT12=(IToken)Match(input,MULT,FOLLOW_MULT_in_expr_dm1073); if (state.failed) return dm;
PushFollow(FOLLOW_expr_in_expr_dm1077);
a = expr();
state.followingStackPointer--;
if (state.failed) return dm;
if ( (state.backtracking==0) )
{
dm = new MultNode(dm, a);
dm.Col=MULT12.CharPositionInLine;
dm.Row = MULT12.Line;
}
}
break;
case 2 :
// C:\\Users\\Danaice\\Desktop\\lastversion\\Dany_gramatica tiger ANTLR oficial\\tiger_grammar.g:160:37: DIV b= expr
{
DIV13=(IToken)Match(input,DIV,FOLLOW_DIV_in_expr_dm1118); if (state.failed) return dm;
PushFollow(FOLLOW_expr_in_expr_dm1122);
b = expr();
state.followingStackPointer--;
if (state.failed) return dm;
if ( (state.backtracking==0) )
{
dm = new DivNode(dm, b);
dm.Col=DIV13.CharPositionInLine;
dm.Row = DIV13.Line;
}
}
break;
default:
goto loop6;
}
} while (true);
loop6:
; // Stops C# compiler whining that label 'loop6' has no statements
}
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input,re);
}
finally
{
}
return dm;
}
private ValInfo Visit(MultNode node)
{
return(BinaryOperator(node, (x, y) => x * y));
}
private TypeDescriptor Visit(MultNode node, Context context)
{
return(MathOperator(node, context));
}
