protected override void Expand(Node node)
{
var best = new Node(null, int.MaxValue, 0);
var node1 = AddNode(node, (-1, 0));
var node2 = AddNode(node, (1, 0));
var node3 = AddNode(node, (0, -1));
var node4 = AddNode(node, (0, 1));
if (node1 != null && node1.H < best.H)
{
best = node1;
}
if (node2 != null && node2.H < best.H)
{
best = node2;
}
if (node3 != null && node3.H < best.H)
{
best = node3;
}
if (node4 != null && node4.H < best.H)
{
best = node4;
}
if (best.Board != null)
{
_nextNode = best;
}
else
{
_nextNode = null;
}
}
protected override void Expand(Node node)
{
AddNode(node, (-1, 0));
AddNode(node, (1, 0));
AddNode(node, (0, -1));
AddNode(node, (0, 1));
}
public void Visit(AddNode node)
{
var right = Nodes.Pop();
var left = Nodes.Pop();
Nodes.Push(new AddNode(left, right));
}
public AddNode Plus()
{
AddNode addNode = new AddNode();
Match(TokenType.PLUS);
return(addNode);
}
public override ASTNode VisitArithmetic([NotNull] CoolParser.ArithmeticContext context)
{
ArithmeticOperation operators;
switch (context.op.Text)
{
case "*":
operators = new MulNode(context);
break;
case "/":
operators = new DivNode(context);
break;
case "+":
operators = new AddNode(context);
break;
case "-":
operators = new SubNode(context);
break;
default:
throw new NotSupportedException();
}
operators.LeftOperand = Visit(context.expression(0)) as ExpressionNode; // LEFT EXPRESSION
operators.RightOperand = Visit(context.expression(1)) as ExpressionNode; //RIGHT EXPRESSION
return(operators);
}
private ExpressionNode EP(ExpressionNode param)
{
if (currentToken.Type == TokenTypes.Sum)
{
currentToken = lexer.GetNextToken();
var tValue = T();
var node = new AddNode {
LeftOperand = param, RightOperand = tValue
};
return(EP(node));
}
else if (currentToken.Type == TokenTypes.Sub)
{
currentToken = lexer.GetNextToken();
var tValue = T();
var node = new SubNode {
LeftOperand = param, RightOperand = tValue
};
return(EP(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 override NodeViewModel CreateModel()
{
CombinerNode result = null;
switch (combineType)
{
case CombinerType.Add:
result = new AddNode();
break;
case CombinerType.Max:
result = new MaxNode();
break;
case CombinerType.Min:
result = new MinNode();
break;
case CombinerType.Multiply:
result = new MultiplyNode();
break;
case CombinerType.Power:
result = new PowerNode();
break;
}
result.Name = name;
result.Position = pos;
return(result);
}
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 AddSourceFilesWithGlob_UpdatesState()
{
var files = new List <string> {
TEST_DIR + "*"
};
var node = new AddNode(FileType.SOURCE, files);
Assert.True(node.Accept(visitor));
Assert.True(files.SequenceEqual(state.SourceFiles), ExpectedEqualSequencesMessage(files, state.SourceFiles));
}
public void AddNode()
{
int
val1 = 10,
val2 = 20,
result = val1 + val2;
var node = new AddNode(new ConstantNode(val1), new ConstantNode(val2));
Assert.AreEqual(node.Value, result);
}
/// <summary>
/// Attempts to add or remove a node from the addnode list.
///Or try a connection to a node once.
///Nodes added using addnode (or -connect) are protected from DoS disconnection and are not required to be
///full nodes/support SegWit as other outbound peers are(though such peers will not be synced from).
/// </summary>
/// <param name="node">The node.</param>
/// <param name="command">'add' to add a node to the list, 'remove' to remove a node from the list, 'onetry' to try a connection to the node once.</param>
/// <returns></returns>
public async Task <string> AddNode(string node, NodeCommand command)
{
AddNode addNode = new AddNode()
{
Node = node, NodeCommand = command
};
string response = await httpRequest.SendReq(MethodName.addnode, addNode);
return(response);
}
public async Task AddTest()
{
//var orderInfo = new OrderInfo();
var addReq = new AddOrderReq
{
coupon_id = "coupon100",
title = "²âÊÔ¶©µ¥",
source_ids = "s_1"
};
var addNode = new AddNode();
var idRes = await addNode.Process(addReq, 0);
}
public DomainId <IAstNode> CreateAdditionOperation(
string definition,
DomainId <ICalculationNode> leftExpression,
DomainId <ICalculationNode> rightExpression)
{
var addNode = new AddNode(
m_ids.Next,
definition,
leftExpression,
rightExpression);
return(DomainItemRegistration <IAddNode>(addNode));
}
private object Visit(AddNode node)
{
dynamic left = Visit(node.Left);
dynamic right = Visit(node.Right);
try
{
return(left + right);
}
catch (Exception error)
{
ReportError(error);
return(null);
}
}
void SimExpr(out QueryNode node)
{
QueryNode term;
Term(out term);
node = term;
while (la.kind == 8 || la.kind == 13)
{
AddOp();
node = new AddNode();
node.Add(term);
Term(out term);
node.Add(term);
}
}
/// <summary>
/// Callback for the 'add node' context menu option.
/// </summary>
/// <param name="sender">Sender object.</param>
/// <param name="args">Event data.</param>
private void OnAddNode(object sender, EventArgs args)
{
try
{
// todo: set location to context menu location
var node = new Node {
Name = graphView.DirectedGraph.NextNodeID()
};
StateNode newNode = new StateNode(node);
AddNode?.Invoke(this, new AddNodeEventArgs(newNode));
}
catch (Exception err)
{
ShowError(err);
}
}
void GraphHelper_GraphPostLoadComplete()
{
_menu = new GenericMenu();
GraphHelper.NodeRegister.ForEach(entry =>
{
// Format into a folder using slashes, if one is defined.
var formattedName = entry.Folder != string.Empty ? string.Format("{0}/{1}", entry.Folder, entry.Name) : entry.Name;
_menu.AddItem(new GUIContent(formattedName), false, () => AddNode.InvokeSafe(new AddNodeEvent(entry)));
});
_menu.AddSeparator("");
_menu.AddItem(new GUIContent("Remove All Nodes"), false, () => ClearNodes.InvokeSafe());
}
public override bool Visit(AddNode addNode)
{
var successful = true;
foreach (var fileGlob in addNode.FileGlobs)
{
if (!File.Exists(fileGlob))
{
// TODO: We only support adding full paths for now
successful = false;
continue;
}
interpreterState.SourceFiles.Add(fileGlob);
@out.Info("Added " + fileGlob + " to source");
}
return(successful);
}
public void TestAddNode()
{
// Arrange
var node1 = new ConstNode(5);
var node2 = new ConstNode(4);
var addNode = new AddNode(node1, node2);
var dictionary = new Dictionary <char, double>()
{
{ 'x', 5 }
};
// Act
var result = addNode.Eval(dictionary);
// Assert
Assert.Equal(9, result);
}
public object Visit(AddNode node)
{
return(this.Calculate(node.Value1, node.Value2,
(v1, v2) => v1 + v2,
(v1, v2) => v1 + v2,
HandleError));
object HandleError(object v1, object v2, Exception exception)
{
if (v1 is string || v2 is string)
{
return(ValueHelper.ToString(v1, _culture) + ValueHelper.ToString(v2, _culture));
}
throw new InvalidOperationException($"[{v1 ?? "(null)"} + {v2 ?? "(null)"}] failed!", exception);
}
}
public void Add(T value)
{
//First way: the Tree is empty.
if (_head == null)
{
_head = new BinaryTreeNode <T>(value);
AddNode?.Invoke("The Head created");
}
/*Second way: Tree is not empty, as result we use recursive
* algoritm to find the place for adiing a new NODE*/
else
{
AddTo(_head, value);
AddNode?.Invoke("The Node added");
}
_count++;
}
public void MutFileMutlipleCommands_CorrectTree()
{
var mutFileText = "add test \"tst.cs\",'tst2.js' list test";
var parser = BuildParser(mutFileText);
var tree = parser.mutFile();
var ast = tree.Accept(new MutASTCreatorVisitor());
var fileGlob = new List <string> {
"\"tst.cs\"", "'tst2.js'"
};
var addCommand = new AddNode(FileType.TEST, fileGlob);
var listCommand = new ListNode(FileType.TEST);
var commandList = new List <MutASTNode> {
addCommand, listCommand
};
var mutFile = new MutFileNode(commandList);
Assert.AreEqual(mutFile, ast);
}
protected override AbstractMaterialNode CreateNode(ShaderGraphBuilder builder, MaterialExpressionAdd unrealNode)
{
var node = new AddNode()
{
previewExpanded = !unrealNode.Collapsed
};
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);
}
public static void GraphTest()
{
var n = new AddNode();
var n2 = new NumberInputNode();
var numer = 152.2;
var exNum = new ExternalNumber(numer);
var exData = new ExternalData(exNum);
n2.ConnectToData(new List <ExternalData>()
{
exData
});
Print(n2.OutputSockets[0].Data);
exNum.RequestChange(130);
Print(n2.OutputSockets[0].Data);
n.InputSockets[0].ConnectTo(n2.OutputSockets[0]);
}
// Use this for initialization
void Start()
{
Patch p = new Patch();
ValueNode<float> v1 = new ValueNode<float>();
p.AddNode(v1);
v1.Output.Value = 15;
v2 = new ValueNode<float>();
p.AddNode(v2);
AddNode sum = new AddNode();
p.AddNode(sum);
p.Connect(v1.Output, sum.A);
p.Connect(v2.Output, sum.B);
patchEvaluator = new PatchEvaluator(p);
patchEvaluator.Evaluate();
}
public AstRoot Parse(ICollection <Token> tokens, ICollection <FunctionInfo> validFunctions)
{
if (tokens == null)
{
throw new ArgumentNullException(nameof(tokens));
}
IAstNode program = null;
var context = new ParserContext(tokens, validFunctions);
while (!context.Stream.Eof)
{
IAstNode currInstr;
if (TryParseTextBlock(context, out var textBlockInstr))
{
currInstr = textBlockInstr;
}
else if (TryParseBindingBlock(context, out var stmtInstr))
{
currInstr = stmtInstr;
}
else
{
throw new ParserException("Syntax error!", context.Stream);
}
if (program != null)
{
program = new AddNode(program, currInstr);
}
else
{
program = currInstr;
}
}
foreach (var token in tokens)
{
Debug.WriteLine(token);
}
return(new AstRoot(program));
}
private void AddNodeMethod(MeshNode Pnode)
{
if (this.treeView1.InvokeRequired)
{
AddNode d = new AddNode(AddNodeMethod);
this.Invoke(d, (object)Pnode);
}
else
{
if (this.treeView1.Nodes.Count > 0)
{
TreeNode[] TempNodes = this.treeView1.Nodes.Find(Pnode.IpAddress, false);
if (TempNodes.Count() > 0)
{
if (!Pnode.MacAddress.Equals(TempNodes[0].Nodes[0].ToString()))
{
TreeNode UpdateNode = new TreeNode(Pnode.MacAddress);
TempNodes[0].Nodes.Clear();
TempNodes[0].Nodes.Add(UpdateNode);
}
}
else
{
TreeNode NewTreenode = this.treeView1.Nodes.Add(Pnode.IpAddress, Pnode.IpAddress);
TreeNode SubNode = NewTreenode.Nodes.Add(Pnode.MacAddress, Pnode.MacAddress);
}
}
else
{
TreeNode NewTreenode = this.treeView1.Nodes.Add(Pnode.IpAddress, Pnode.IpAddress);
TreeNode SubNode = NewTreenode.Nodes.Add(Pnode.MacAddress, Pnode.MacAddress);
}
}
// myListBox.Items.Add(myStr1 + myStr2);
//AddNode myAddNodeDelegate = new AddNode(AddNodeMethod);
}
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);
}
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;
}
// $ANTLR end "definition"
// $ANTLR start "expression"
// E:\\SGL\\sgl4c#\\NewSGLGramma\\SGLTreeWalker.g:270:1: expression returns [AbstractNode node] : ( ^( '+' a= expression b= expression ) | ^( '-' a= expression b= expression ) | ^( '*' a= expression b= expression ) | ^( '/' a= expression b= expression ) | ^( '%' a= expression b= expression ) | ^( '^' a= expression b= expression ) | ^( INT_NEGATE a= expression ) | ^( BOOL_NEGATE a= expression ) | ^( '<' a= expression b= expression ) | ^( '<=' a= expression b= expression ) | ^( '>' a= expression b= expression ) | ^( '>=' a= expression b= expression ) | ^( '!=' a= expression b= expression ) | ^( '==' a= expression b= expression ) | ^( '&&' a= expression b= expression ) | ^( '||' a= expression b= expression ) | ^( '?' a= expression b= expression c= expression ) | IntAtom | FloatAtom | BooleanAtom | ^( STRING StringAtom ) | LayerAtom | OriginAtom | LoopTypeAtom | LoopTriggerAtom | Null | instantiateClass | lookup | unaryExpression );
public AbstractNode expression() // throws RecognitionException [1]
{
AbstractNode node = default(AbstractNode);
CommonTree IntAtom36 = null;
CommonTree FloatAtom37 = null;
CommonTree BooleanAtom38 = null;
CommonTree StringAtom39 = null;
CommonTree LayerAtom40 = null;
CommonTree OriginAtom41 = null;
CommonTree LoopTypeAtom42 = null;
CommonTree LoopTriggerAtom43 = null;
CommonTree Null44 = null;
AbstractNode a = default(AbstractNode);
AbstractNode b = default(AbstractNode);
AbstractNode c = default(AbstractNode);
AbstractNode instantiateClass45 = default(AbstractNode);
AbstractNode lookup46 = default(AbstractNode);
AbstractNode unaryExpression47 = default(AbstractNode);
try
{
// E:\\SGL\\sgl4c#\\NewSGLGramma\\SGLTreeWalker.g:271:2: ( ^( '+' a= expression b= expression ) | ^( '-' a= expression b= expression ) | ^( '*' a= expression b= expression ) | ^( '/' a= expression b= expression ) | ^( '%' a= expression b= expression ) | ^( '^' a= expression b= expression ) | ^( INT_NEGATE a= expression ) | ^( BOOL_NEGATE a= expression ) | ^( '<' a= expression b= expression ) | ^( '<=' a= expression b= expression ) | ^( '>' a= expression b= expression ) | ^( '>=' a= expression b= expression ) | ^( '!=' a= expression b= expression ) | ^( '==' a= expression b= expression ) | ^( '&&' a= expression b= expression ) | ^( '||' a= expression b= expression ) | ^( '?' a= expression b= expression c= expression ) | IntAtom | FloatAtom | BooleanAtom | ^( STRING StringAtom ) | LayerAtom | OriginAtom | LoopTypeAtom | LoopTriggerAtom | Null | instantiateClass | lookup | unaryExpression )
int alt16 = 29;
switch ( input.LA(1) )
{
case 72:
{
alt16 = 1;
}
break;
case 73:
{
alt16 = 2;
}
break;
case 74:
{
alt16 = 3;
}
break;
case 75:
{
alt16 = 4;
}
break;
case 76:
{
alt16 = 5;
}
break;
case 77:
{
alt16 = 6;
}
break;
case INT_NEGATE:
{
alt16 = 7;
}
break;
case BOOL_NEGATE:
{
alt16 = 8;
}
break;
case 68:
{
alt16 = 9;
}
break;
case 70:
{
alt16 = 10;
}
break;
case 69:
{
alt16 = 11;
}
break;
case 71:
{
alt16 = 12;
}
break;
case 67:
{
alt16 = 13;
}
break;
case 66:
{
alt16 = 14;
}
break;
case 65:
{
alt16 = 15;
}
break;
case 64:
{
alt16 = 16;
}
break;
case 62:
{
alt16 = 17;
}
break;
case IntAtom:
{
alt16 = 18;
}
break;
case FloatAtom:
{
alt16 = 19;
}
break;
case BooleanAtom:
{
alt16 = 20;
}
break;
case STRING:
{
alt16 = 21;
}
break;
case LayerAtom:
{
alt16 = 22;
}
break;
case OriginAtom:
{
alt16 = 23;
}
break;
case LoopTypeAtom:
{
alt16 = 24;
}
break;
case LoopTriggerAtom:
{
alt16 = 25;
}
break;
case Null:
{
alt16 = 26;
}
break;
case CLASS:
{
alt16 = 27;
}
break;
case LOOKUP:
{
alt16 = 28;
}
break;
case VARINC:
case VARDEC:
{
alt16 = 29;
}
break;
default:
NoViableAltException nvae_d16s0 =
new NoViableAltException("", 16, 0, input);
throw nvae_d16s0;
}
switch (alt16)
{
case 1 :
// E:\\SGL\\sgl4c#\\NewSGLGramma\\SGLTreeWalker.g:271:4: ^( '+' a= expression b= expression )
{
Match(input,72,FOLLOW_72_in_expression828);
Match(input, Token.DOWN, null);
PushFollow(FOLLOW_expression_in_expression832);
a = expression();
state.followingStackPointer--;
PushFollow(FOLLOW_expression_in_expression836);
b = expression();
state.followingStackPointer--;
Match(input, Token.UP, null);
node = new AddNode(a, b);
}
break;
case 2 :
// E:\\SGL\\sgl4c#\\NewSGLGramma\\SGLTreeWalker.g:272:4: ^( '-' a= expression b= expression )
{
Match(input,73,FOLLOW_73_in_expression845);
Match(input, Token.DOWN, null);
PushFollow(FOLLOW_expression_in_expression849);
a = expression();
state.followingStackPointer--;
PushFollow(FOLLOW_expression_in_expression853);
b = expression();
state.followingStackPointer--;
Match(input, Token.UP, null);
node = new SubNode(a, b);
}
break;
case 3 :
// E:\\SGL\\sgl4c#\\NewSGLGramma\\SGLTreeWalker.g:273:4: ^( '*' a= expression b= expression )
{
Match(input,74,FOLLOW_74_in_expression862);
Match(input, Token.DOWN, null);
PushFollow(FOLLOW_expression_in_expression866);
a = expression();
state.followingStackPointer--;
PushFollow(FOLLOW_expression_in_expression870);
b = expression();
state.followingStackPointer--;
Match(input, Token.UP, null);
node = new MultNode(a, b);
}
break;
case 4 :
// E:\\SGL\\sgl4c#\\NewSGLGramma\\SGLTreeWalker.g:274:4: ^( '/' a= expression b= expression )
{
Match(input,75,FOLLOW_75_in_expression879);
Match(input, Token.DOWN, null);
PushFollow(FOLLOW_expression_in_expression883);
a = expression();
state.followingStackPointer--;
PushFollow(FOLLOW_expression_in_expression887);
b = expression();
state.followingStackPointer--;
Match(input, Token.UP, null);
node = new DivNode(a, b);
}
break;
case 5 :
// E:\\SGL\\sgl4c#\\NewSGLGramma\\SGLTreeWalker.g:275:4: ^( '%' a= expression b= expression )
{
Match(input,76,FOLLOW_76_in_expression896);
Match(input, Token.DOWN, null);
PushFollow(FOLLOW_expression_in_expression900);
a = expression();
state.followingStackPointer--;
PushFollow(FOLLOW_expression_in_expression904);
b = expression();
state.followingStackPointer--;
Match(input, Token.UP, null);
node = new ModNode(a, b);
}
break;
case 6 :
// E:\\SGL\\sgl4c#\\NewSGLGramma\\SGLTreeWalker.g:276:4: ^( '^' a= expression b= expression )
{
Match(input,77,FOLLOW_77_in_expression913);
Match(input, Token.DOWN, null);
PushFollow(FOLLOW_expression_in_expression917);
a = expression();
state.followingStackPointer--;
PushFollow(FOLLOW_expression_in_expression921);
b = expression();
state.followingStackPointer--;
Match(input, Token.UP, null);
node = new PowNode(a, b);
}
break;
case 7 :
// E:\\SGL\\sgl4c#\\NewSGLGramma\\SGLTreeWalker.g:277:4: ^( INT_NEGATE a= expression )
{
Match(input,INT_NEGATE,FOLLOW_INT_NEGATE_in_expression930);
Match(input, Token.DOWN, null);
PushFollow(FOLLOW_expression_in_expression934);
a = expression();
state.followingStackPointer--;
Match(input, Token.UP, null);
node = new NegateIntNode(a);
}
break;
case 8 :
// E:\\SGL\\sgl4c#\\NewSGLGramma\\SGLTreeWalker.g:278:4: ^( BOOL_NEGATE a= expression )
{
Match(input,BOOL_NEGATE,FOLLOW_BOOL_NEGATE_in_expression943);
Match(input, Token.DOWN, null);
PushFollow(FOLLOW_expression_in_expression947);
a = expression();
state.followingStackPointer--;
Match(input, Token.UP, null);
node = new NegateBoolNode(a);
}
break;
case 9 :
// E:\\SGL\\sgl4c#\\NewSGLGramma\\SGLTreeWalker.g:279:4: ^( '<' a= expression b= expression )
{
Match(input,68,FOLLOW_68_in_expression956);
Match(input, Token.DOWN, null);
PushFollow(FOLLOW_expression_in_expression960);
a = expression();
state.followingStackPointer--;
PushFollow(FOLLOW_expression_in_expression964);
b = expression();
state.followingStackPointer--;
Match(input, Token.UP, null);
node = new LowerThanNode(a, b);
}
break;
case 10 :
// E:\\SGL\\sgl4c#\\NewSGLGramma\\SGLTreeWalker.g:280:4: ^( '<=' a= expression b= expression )
{
Match(input,70,FOLLOW_70_in_expression973);
Match(input, Token.DOWN, null);
PushFollow(FOLLOW_expression_in_expression977);
a = expression();
state.followingStackPointer--;
PushFollow(FOLLOW_expression_in_expression981);
b = expression();
state.followingStackPointer--;
Match(input, Token.UP, null);
node = new LowerThanEqualsNode(a, b);
}
break;
case 11 :
// E:\\SGL\\sgl4c#\\NewSGLGramma\\SGLTreeWalker.g:281:4: ^( '>' a= expression b= expression )
{
Match(input,69,FOLLOW_69_in_expression990);
Match(input, Token.DOWN, null);
PushFollow(FOLLOW_expression_in_expression994);
a = expression();
state.followingStackPointer--;
PushFollow(FOLLOW_expression_in_expression998);
b = expression();
state.followingStackPointer--;
Match(input, Token.UP, null);
node = new GreaterThanNode(a, b);
}
break;
case 12 :
// E:\\SGL\\sgl4c#\\NewSGLGramma\\SGLTreeWalker.g:282:4: ^( '>=' a= expression b= expression )
{
Match(input,71,FOLLOW_71_in_expression1007);
Match(input, Token.DOWN, null);
PushFollow(FOLLOW_expression_in_expression1011);
a = expression();
state.followingStackPointer--;
PushFollow(FOLLOW_expression_in_expression1015);
b = expression();
state.followingStackPointer--;
Match(input, Token.UP, null);
node = new GreaterThanEqualsNode(a, b);
}
break;
case 13 :
// E:\\SGL\\sgl4c#\\NewSGLGramma\\SGLTreeWalker.g:283:4: ^( '!=' a= expression b= expression )
{
Match(input,67,FOLLOW_67_in_expression1024);
Match(input, Token.DOWN, null);
PushFollow(FOLLOW_expression_in_expression1028);
a = expression();
state.followingStackPointer--;
PushFollow(FOLLOW_expression_in_expression1032);
b = expression();
state.followingStackPointer--;
Match(input, Token.UP, null);
node = new NotEqualsNode(a, b);
}
break;
case 14 :
// E:\\SGL\\sgl4c#\\NewSGLGramma\\SGLTreeWalker.g:284:4: ^( '==' a= expression b= expression )
{
Match(input,66,FOLLOW_66_in_expression1041);
Match(input, Token.DOWN, null);
PushFollow(FOLLOW_expression_in_expression1045);
a = expression();
state.followingStackPointer--;
PushFollow(FOLLOW_expression_in_expression1049);
b = expression();
state.followingStackPointer--;
Match(input, Token.UP, null);
node = new EqualsNode(a, b);
}
break;
case 15 :
// E:\\SGL\\sgl4c#\\NewSGLGramma\\SGLTreeWalker.g:285:4: ^( '&&' a= expression b= expression )
{
Match(input,65,FOLLOW_65_in_expression1058);
Match(input, Token.DOWN, null);
PushFollow(FOLLOW_expression_in_expression1062);
a = expression();
state.followingStackPointer--;
PushFollow(FOLLOW_expression_in_expression1066);
b = expression();
state.followingStackPointer--;
Match(input, Token.UP, null);
node = new AndNode(a, b);
}
break;
case 16 :
// E:\\SGL\\sgl4c#\\NewSGLGramma\\SGLTreeWalker.g:286:4: ^( '||' a= expression b= expression )
{
Match(input,64,FOLLOW_64_in_expression1075);
Match(input, Token.DOWN, null);
PushFollow(FOLLOW_expression_in_expression1079);
a = expression();
state.followingStackPointer--;
PushFollow(FOLLOW_expression_in_expression1083);
b = expression();
state.followingStackPointer--;
Match(input, Token.UP, null);
node = new OrNode(a, b);
}
break;
case 17 :
// E:\\SGL\\sgl4c#\\NewSGLGramma\\SGLTreeWalker.g:287:4: ^( '?' a= expression b= expression c= expression )
{
Match(input,62,FOLLOW_62_in_expression1092);
Match(input, Token.DOWN, null);
PushFollow(FOLLOW_expression_in_expression1096);
a = expression();
state.followingStackPointer--;
PushFollow(FOLLOW_expression_in_expression1100);
b = expression();
state.followingStackPointer--;
PushFollow(FOLLOW_expression_in_expression1104);
c = expression();
state.followingStackPointer--;
Match(input, Token.UP, null);
node = new ConditionalNode(a, b, c);
}
break;
case 18 :
// E:\\SGL\\sgl4c#\\NewSGLGramma\\SGLTreeWalker.g:288:6: IntAtom
{
IntAtom36=(CommonTree)Match(input,IntAtom,FOLLOW_IntAtom_in_expression1114);
node = new AtomNode(int.Parse(((IntAtom36 != null) ? IntAtom36.Text : null), System.Globalization.CultureInfo.InvariantCulture), ValType.Integer, IntAtom36.Line);
}
break;
case 19 :
// E:\\SGL\\sgl4c#\\NewSGLGramma\\SGLTreeWalker.g:289:4: FloatAtom
{
FloatAtom37=(CommonTree)Match(input,FloatAtom,FOLLOW_FloatAtom_in_expression1121);
node = new AtomNode(Double.Parse(((FloatAtom37 != null) ? FloatAtom37.Text : null), System.Globalization.CultureInfo.InvariantCulture), ValType.Double, FloatAtom37.Line);
}
break;
case 20 :
// E:\\SGL\\sgl4c#\\NewSGLGramma\\SGLTreeWalker.g:290:6: BooleanAtom
{
BooleanAtom38=(CommonTree)Match(input,BooleanAtom,FOLLOW_BooleanAtom_in_expression1130);
node = new AtomNode(Boolean.Parse(((BooleanAtom38 != null) ? BooleanAtom38.Text : null)), ValType.Boolean, BooleanAtom38.Line);
}
break;
case 21 :
// E:\\SGL\\sgl4c#\\NewSGLGramma\\SGLTreeWalker.g:291:4: ^( STRING StringAtom )
{
Match(input,STRING,FOLLOW_STRING_in_expression1138);
Match(input, Token.DOWN, null);
StringAtom39=(CommonTree)Match(input,StringAtom,FOLLOW_StringAtom_in_expression1140);
Match(input, Token.UP, null);
node = new AtomNode((((StringAtom39 != null) ? StringAtom39.Text : null)).Substring(1, (((StringAtom39 != null) ? StringAtom39.Text : null)).Length-2), ValType.String, StringAtom39.Line);
}
break;
case 22 :
// E:\\SGL\\sgl4c#\\NewSGLGramma\\SGLTreeWalker.g:292:4: LayerAtom
{
LayerAtom40=(CommonTree)Match(input,LayerAtom,FOLLOW_LayerAtom_in_expression1148);
node = new AtomNode(((LayerAtom40 != null) ? LayerAtom40.Text : null), ValType.Layer, LayerAtom40.Line);
}
break;
case 23 :
// E:\\SGL\\sgl4c#\\NewSGLGramma\\SGLTreeWalker.g:293:4: OriginAtom
{
OriginAtom41=(CommonTree)Match(input,OriginAtom,FOLLOW_OriginAtom_in_expression1155);
node = new AtomNode(((OriginAtom41 != null) ? OriginAtom41.Text : null), ValType.Origin, OriginAtom41.Line);
}
break;
case 24 :
// E:\\SGL\\sgl4c#\\NewSGLGramma\\SGLTreeWalker.g:294:4: LoopTypeAtom
{
LoopTypeAtom42=(CommonTree)Match(input,LoopTypeAtom,FOLLOW_LoopTypeAtom_in_expression1162);
node = new AtomNode(((LoopTypeAtom42 != null) ? LoopTypeAtom42.Text : null), ValType.LoopType, LoopTypeAtom42.Line);
}
break;
case 25 :
// E:\\SGL\\sgl4c#\\NewSGLGramma\\SGLTreeWalker.g:295:4: LoopTriggerAtom
{
LoopTriggerAtom43=(CommonTree)Match(input,LoopTriggerAtom,FOLLOW_LoopTriggerAtom_in_expression1169);
node = new AtomNode(((LoopTriggerAtom43 != null) ? LoopTriggerAtom43.Text : null), ValType.LoopTrigger, LoopTriggerAtom43.Line);
}
break;
case 26 :
// E:\\SGL\\sgl4c#\\NewSGLGramma\\SGLTreeWalker.g:297:4: Null
{
Null44=(CommonTree)Match(input,Null,FOLLOW_Null_in_expression1178);
node = new AtomNode(((Null44 != null) ? Null44.Text : null), ValType.Null, Null44.Line);
}
break;
case 27 :
// E:\\SGL\\sgl4c#\\NewSGLGramma\\SGLTreeWalker.g:298:4: instantiateClass
{
PushFollow(FOLLOW_instantiateClass_in_expression1185);
instantiateClass45 = instantiateClass();
state.followingStackPointer--;
node = instantiateClass45;
}
break;
case 28 :
// E:\\SGL\\sgl4c#\\NewSGLGramma\\SGLTreeWalker.g:299:4: lookup
{
PushFollow(FOLLOW_lookup_in_expression1192);
lookup46 = lookup();
state.followingStackPointer--;
node = lookup46;
}
break;
case 29 :
// E:\\SGL\\sgl4c#\\NewSGLGramma\\SGLTreeWalker.g:300:4: unaryExpression
{
PushFollow(FOLLOW_unaryExpression_in_expression1199);
unaryExpression47 = unaryExpression();
state.followingStackPointer--;
node = unaryExpression47;
}
break;
}
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input,re);
}
finally
{
}
return node;
}
private void buttonAdd_Click(object sender, EventArgs e)
{
AddNode?.Invoke(this, EventArgs.Empty);
}
// $ANTLR start "additiveExpression"
// JavaScript.g:302:1: additiveExpression : multiplicativeExpression ( ( ( LT )* ( '+' | '-' ) additiveExpression )=> ( LT )* ( '+' | '-' ) additiveExpression | ) ;
public JavaScriptParser.additiveExpression_return additiveExpression() // throws RecognitionException [1]
{
JavaScriptParser.additiveExpression_return retval = new JavaScriptParser.additiveExpression_return();
retval.Start = input.LT(1);
object root_0 = null;
IToken LT357 = null;
IToken char_literal358 = null;
IToken char_literal359 = null;
JavaScriptParser.multiplicativeExpression_return multiplicativeExpression356 = default(JavaScriptParser.multiplicativeExpression_return);
JavaScriptParser.additiveExpression_return additiveExpression360 = default(JavaScriptParser.additiveExpression_return);
object LT357_tree=null;
object char_literal358_tree=null;
object char_literal359_tree=null;
try
{
// JavaScript.g:303:2: ( multiplicativeExpression ( ( ( LT )* ( '+' | '-' ) additiveExpression )=> ( LT )* ( '+' | '-' ) additiveExpression | ) )
// JavaScript.g:303:4: multiplicativeExpression ( ( ( LT )* ( '+' | '-' ) additiveExpression )=> ( LT )* ( '+' | '-' ) additiveExpression | )
{
root_0 = (object)adaptor.GetNilNode();
PushFollow(FOLLOW_multiplicativeExpression_in_additiveExpression2725);
multiplicativeExpression356 = multiplicativeExpression();
state.followingStackPointer--;
if (state.failed) return retval;
if ( state.backtracking == 0 ) adaptor.AddChild(root_0, multiplicativeExpression356.Tree);
// JavaScript.g:303:29: ( ( ( LT )* ( '+' | '-' ) additiveExpression )=> ( LT )* ( '+' | '-' ) additiveExpression | )
int alt187 = 2;
alt187 = dfa187.Predict(input);
switch (alt187)
{
case 1 :
// JavaScript.g:304:3: ( ( LT )* ( '+' | '-' ) additiveExpression )=> ( LT )* ( '+' | '-' ) additiveExpression
{
// JavaScript.g:304:44: ( LT )*
do
{
int alt185 = 2;
int LA185_0 = input.LA(1);
if ( (LA185_0 == LT) )
{
alt185 = 1;
}
switch (alt185)
{
case 1 :
// JavaScript.g:304:44: LT
{
LT357=(IToken)Match(input,LT,FOLLOW_LT_in_additiveExpression2747); if (state.failed) return retval;
}
break;
default:
goto loop185;
}
} while (true);
loop185:
; // Stops C# compiler whining that label 'loop185' has no statements
// JavaScript.g:304:47: ( '+' | '-' )
int alt186 = 2;
int LA186_0 = input.LA(1);
if ( (LA186_0 == 99) )
{
alt186 = 1;
}
else if ( (LA186_0 == 100) )
{
alt186 = 2;
}
else
{
if ( state.backtracking > 0 ) {state.failed = true; return retval;}
NoViableAltException nvae_d186s0 =
new NoViableAltException("", 186, 0, input);
throw nvae_d186s0;
}
switch (alt186)
{
case 1 :
// JavaScript.g:304:48: '+'
{
char_literal358=(IToken)Match(input,99,FOLLOW_99_in_additiveExpression2752); if (state.failed) return retval;
if ( state.backtracking == 0 )
{char_literal358_tree = new AddNode(char_literal358) ;
root_0 = (object)adaptor.BecomeRoot(char_literal358_tree, root_0);
}
}
break;
case 2 :
// JavaScript.g:304:64: '-'
{
char_literal359=(IToken)Match(input,100,FOLLOW_100_in_additiveExpression2760); if (state.failed) return retval;
if ( state.backtracking == 0 )
{char_literal359_tree = new SubNode(char_literal359) ;
root_0 = (object)adaptor.BecomeRoot(char_literal359_tree, root_0);
}
}
break;
}
PushFollow(FOLLOW_additiveExpression_in_additiveExpression2767);
additiveExpression360 = additiveExpression();
state.followingStackPointer--;
if (state.failed) return retval;
if ( state.backtracking == 0 ) adaptor.AddChild(root_0, additiveExpression360.Tree);
}
break;
case 2 :
// JavaScript.g:306:2:
{
}
break;
}
}
retval.Stop = input.LT(-1);
if ( (state.backtracking==0) )
{ retval.Tree = (object)adaptor.RulePostProcessing(root_0);
adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input,re);
// Conversion of the second argument necessary, but harmless
retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
}
finally
{
}
return retval;
}