private AstNode Expression()
{
// EXPRESSION = TERM (ADD | SUBTRACT TERM)* (COMPARISON TERM)
var node = Term();
var ops = new[] { Tokens.Add, Tokens.Subtract };
while (ops.Contains(_currentToken.Type))
{
var token = _currentToken;
Eat(token.Type);
if (token.Type == Tokens.Add)
{
node = new AddNode(node, Term());
}
else if (token.Type == Tokens.Subtract)
{
node = new SubtractNode(node, Term());
}
}
if (Tokens.IsComparison(_currentToken.Type))
{
var token = _currentToken;
if (token.Type == Tokens.Equal)
{
Eat(Tokens.Equal);
node = new EqualToNode(node, Term());
}
else if (token.Type == Tokens.NotEqual)
{
Eat(Tokens.NotEqual);
node = new NotEqualToNode(node, Term());
}
else if (token.Type == Tokens.GreaterThan)
{
Eat(Tokens.GreaterThan);
node = new GreaterThanNode(node, Term());
}
else if (token.Type == Tokens.GreaterThanOrEqualTo)
{
Eat(Tokens.GreaterThanOrEqualTo);
node = new GreaterThanOrEqualToNode(node, Term());
}
else if (token.Type == Tokens.LessThan)
{
Eat(Tokens.LessThan);
node = new LessThanNode(node, Term());
}
else if (token.Type == Tokens.LessThanOrEqualTo)
{
Eat(Tokens.LessThanOrEqualTo);
node = new LessThanOrEqualToNode(node, Term());
}
}
return(node);
}
public void SubtractNode()
{
int
val1 = 10,
val2 = 20,
result = val1 - val2;
var node = new SubtractNode(new ConstantNode(val1), new ConstantNode(val2));
Assert.AreEqual(node.Value, result);
}
public DomainId <IAstNode> CreateSubtractionOperation(
string definition,
DomainId <ICalculationNode> leftExpression,
DomainId <ICalculationNode> rightExpression)
{
var subtractNode = new SubtractNode(
m_ids.Next,
definition,
leftExpression,
rightExpression);
return(DomainItemRegistration <ISubtractNode>(subtractNode));
}
private object Visit(SubtractNode node)
{
dynamic left = Visit(node.Left);
dynamic right = Visit(node.Right);
try
{
return(left - right);
}
catch (Exception error)
{
ReportError(error);
return(null);
}
}
protected override AbstractMaterialNode CreateNode(ShaderGraphBuilder builder, MaterialExpressionSubtract unrealNode)
{
var node = new SubtractNode()
{
previewExpanded = false
};
if (unrealNode.A == null)
{
node.FindInputSlot <DynamicVectorMaterialSlot>(0).value = new Vector4(unrealNode.ConstA, 0);
}
if (unrealNode.B == null)
{
node.FindInputSlot <DynamicVectorMaterialSlot>(1).value = new Vector4(unrealNode.ConstB, 0);
}
return(node);
}
private static void TestExpTree()
{
AddNode <Real> root = new AddNode <Real>();
MultiplyNode <Real> c1 = new MultiplyNode <Real>();
SubtractNode <Real> c2 = new SubtractNode <Real>();
DivideNode <Real> c3 = new DivideNode <Real>();
root.LeftChild = c1;
root.RightChild = c2;
c1.LeftChild = new ConstantNode <Real>(2);
c1.RightChild = c3;
c2.LeftChild = new ConstantNode <Real>(7);
c2.RightChild = new ConstantNode <Real>(4);
c3.LeftChild = new ConstantNode <Real>(8);
c3.RightChild = new ConstantNode <Real>(16);
Console.WriteLine(root.ToString() + " = " + root.Evaluate());
}
private Node ParseAdditive()
{
var lNode = this.ParseMultiplicative();
while (this.AreMoreTokens)
{
if (this.currentToken.Equals(TokenType.Symbol, "+"))
{
this.ReadNextToken();
lNode = new AddNode(lNode, this.ParseMultiplicative());
}
else if (this.currentToken.Equals(TokenType.Symbol, "-"))
{
this.ReadNextToken();
lNode = new SubtractNode(lNode, this.ParseMultiplicative());
}
else
{
break;
}
}
return(lNode);
}
public void Visit(SubtractNode node)
{
BinaryOperator(
node,
"-",
() => VariableType.INTEGER,
new List<VariableType> { VariableType.INTEGER });
}
public abstract T Visit(SubtractNode node);
public double CalcSubtractNode(SubtractNode node)
{
return((double)(node.NodeA.value - node.NodeB.value));
}
public void Visit(SubtractNode node)
{
BinaryNode(node, Bytecode.SUB);
}
