public virtual void evaluateExpressionStack() { Node @operator = null; if (operatorStack.Count == 0) { throw new Exception("not operators on stack"); } @operator = operatorStack.Pop(); //TODO ensure the type is accurate. //assert false : "this needs to fail until i fix it"; if (@operator.Type.Equals(NodeType.EqualEqualType) && operandStack.Count >= 2) { NodeImpl r = (NodeImpl)operandStack.Pop(); NodeImpl l = (NodeImpl)operandStack.Pop(); ActivationFrame frame = activationFrameStack.peek(); object rReal = r.getRealValue(frame); object lreal = l.getRealValue(frame); bool equalEqualEval = rReal.Equals(lreal); BooleanNode booleanNode = new BooleanNode(); FinalNode finalNode = new FinalNode(); finalNode.DataString = equalEqualEval; booleanNode.addInst(finalNode); operandStack.Push(booleanNode); } }
public void CreateChildrenTest() { //GateNode node1 = new GateNode("A'"); //GateNode node2 = new GateNode("(A+B)'"); //GateNode node3 = new GateNode("(A+B) + C'"); //GateNode node4 = new GateNode("(A+C)'+B"); GateNode node5 = new GateNode("D*(A+C*B)'+B+C"); Dictionary <String, List <VariableNode> > variables = new Dictionary <string, List <VariableNode> >(); //variables = node1.CreateChildren(variables); //BooleanNode.PrintTree(node1); //foreach (var variable in variables.Keys) //{ // Console.WriteLine(variable); //} variables = new Dictionary <string, List <VariableNode> >(); variables = node5.CreateChildren(variables); BooleanNode.PrintTree(node5); foreach (var variable in variables.Keys) { Console.WriteLine(variable); } }
public BooleanNode Bool(string value) { BooleanNode booleanNode = new BooleanNode(); Match(TokenType.BOOL); booleanNode.Value = bool.Parse(value); return(booleanNode); }
public void Deserialize_Bool_Test(bool source) { var node = new BooleanNode(source); var res = _deserializer.Deserialize <bool>(node); Assert.That(res, Is.TypeOf <bool>()); Assert.AreEqual(source, res); }
public static void booleanInstance(BooleanNode booleanNode, ActivationFrame activationFrame, VariableDeclarationNode variableToAssignTo) { IList <Node> slotList = new List <Node>(); slotList.Add(booleanNode); interpreterCallback.execute(slotList); assignReturnValueToVariable(activationFrame, variableToAssignTo); }
public override Node visitBooleanExpression(JuliarParser.BooleanExpressionContext ctx) { BooleanNode node = new BooleanNode(); IterateOverContext iterateOverContext = new IterateOverContextAnonymousInnerClassHelper2(this, node); iterateOverContext.iterateOverChildren(ctx, this, node); node.determineBooleanComparisionType(); return(node); }
public void AST_CreateBoolean_Succeeds(bool value) { var node = new BooleanNode(value); var expectedInt = value ? 1 : 0; var expectedFloat = (float)expectedInt; Assert.Equal(ValueType.Boolean, node.ValueType); Assert.Equal(expectedInt, node.IntegerValue); Assert.True(Math.IsNearlyEqual(expectedFloat, node.FloatValue)); Assert.Equal(value, node.BooleanValue); }
/// <summary> /// At the moment should only need to be called on the eval'd result of a Condition /// </summary> private static bool ToBool(Node node) { BooleanNode bNode = node as BooleanNode; if (bNode == null) { return(false); } return(bNode.Value); }
static void EmitBoolOpCode(ILGenerator il, BooleanNode node) { if (node.Value == true) { Emit(il, OpCodes.Ldc_I4_1); } else { Emit(il, OpCodes.Ldc_I4_0); } }
private IList <Node> evalIfStatement(Node node, ActivationFrame frame, Interpreter callback) { IList <Node> instructionList = node.Instructions; int size = instructionList.Count; IList <Node> trueExpressions = new List <Node>(); BooleanNode booleanNode = getBooleanExpressionNode(instructionList, size, trueExpressions); if (booleanNode != null && booleanNode.Instructions.Count == 1) { FinalNode finalNode = (FinalNode)booleanNode.Instructions[0]; if (finalNode.IntegralType == IntegralType.jboolean) { bool? @bool = Convert.ToBoolean(finalNode.dataString()); if (@bool) { return(trueExpressions); } } } else if (booleanNode != null && booleanNode.Instructions.Count > 0) { Node currentValue = frame.popNode(); frame.pushReturnNode(null); bool?booleanResult = false; evalBooleanNode(booleanNode, frame, callback); if (frame.peekReturnNode() != null && frame.peekReturnNode() is BooleanNode) { Node booleanEvalReturnNode = frame.popNode(); FinalNode result = getFinalNodeFromAnyNode(booleanEvalReturnNode); booleanResult = Convert.ToBoolean(result.dataString()); } // TODO - FINISH THIS if (booleanResult && frame.peekReturnNode() != null) { Node returnNode = frame.popNode(); if (returnNode is BreakExprNode) { IList <Node> returnList = new List <Node>(); returnList.Add(returnNode); return(new List <>()); } } frame.pushReturnNode(currentValue); } return(new List <>()); }
public void AST_BuildBoolean_Succeeds(Element element, ValueType expectedNodeType, int expectedInt, float expectedFloat, bool expectedBool) { var node = new BooleanNode(); var rpn = new Stack <Node>(); node.Build(rpn, element, Compiler.Options.None, null, null); Assert.Equal(expectedNodeType, node.ValueType); Assert.Equal(expectedInt, node.IntegerValue); Assert.True(Math.IsNearlyEqual(expectedFloat, node.FloatValue)); Assert.Equal(expectedBool, node.BooleanValue); }
/// <summary> /// TODO: Deprecate /// Emit IntNode or DoubleNode /// </summary> /// <param name="node"></param> /// <param name="outnode"></param> private void EmitLiteralNode(LiteralNode node, out AssociativeNode outnode) { Validity.Assert(node != null); Validity.Assert(node.children.Count == 0); // Create temp identifier and assign it to the literal (IntNode or DoubleNode) to create a BinaryExpressionNode // Return the temp IdentifierNode //BinaryExpressionNode expressionNode = new BinaryExpressionNode(); AssociativeNode rightNode = null; int number; double real; bool flag; string val = node.ToScript(); // If LiternalNode is double if (Double.TryParse(val, out real)) { rightNode = new DoubleNode() { value = node.ToScript() }; } // If LiteralNode type is Int else if (Int32.TryParse(val, out number)) { rightNode = new IntNode() { value = val }; } // If LiteralNode is bool else if (Boolean.TryParse(val, out flag)) { rightNode = new BooleanNode() { value = node.ToScript() }; } /*IdentifierNode ident = CreateTempIdentifierNode(node); * expressionNode.RightNode = rightNode; * expressionNode.LeftNode = ident; * expressionNode.Optr = ProtoCore.DSASM.Operator.assign;*/ //(AstRootNode as CodeBlockNode).Body.Add(expressionNode); //outnode = expressionNode; outnode = CreateBinaryExpNode(node, rightNode); }
public void ToNodes(ICodeNode parentNode) { RootNode rootNode = parentNode.GetRootNode(); HighlightableButton highlightableButton = (GameObjectHelper.HasComponent <HighlightableButton>(this.gameObject)) ? this.GetComponent <HighlightableButton>() : null; //Checks if this blox has a param if it has creates an LogicalOperationNode instead of an BOOLeger node if (this.BloxParams.Count > 0) { LogicalOperatorBlox logicOpBlox = BloxParams[0].GetComponent <LogicalOperatorBlox>(); LogicalOperationNode logicOpNode = logicOpBlox.CreateNode(rootNode); logicOpNode.NodeName = this.GetName(); parentNode.AddChildNode(logicOpNode); } else { BooleanNode boolNode = new BooleanNode(highlightableButton, GetValueAsBoolean()); boolNode.NodeName = this.GetName(); parentNode.AddChildNode(boolNode); } }
private BooleanNode getBooleanExpressionNode(IList <Node> instructionList, int size, IList <Node> trueExpressions) { BooleanNode booleanNode = null; for (int i = 0; i < size; i++) { Node current = instructionList[i]; if (current is BooleanNode) { booleanNode = (BooleanNode)current; continue; } if (current is StatementNode) { trueExpressions.Add(current); } } return(booleanNode); }
public void ToNodes(ICodeNode parentNode) { RootNode rootNode = parentNode.GetRootNode(); IfNode ifNode = null; HighlightableButton highlightableButton = (GameObjectHelper.HasComponent <HighlightableButton>(this.gameObject)) ? this.GetComponent <HighlightableButton>() : null; // IfNode can receive either a bool variable (chosen in dropdown) or a LogicalOperatorBlox as param // If it has received a param (LogicalOperatorBlox), creates a LogicalOperationNode // and instantiates ifNode with it if (BloxParams.Count > 0) { LogicalOperatorBlox blox = BloxParams[0].GetComponent <LogicalOperatorBlox>(); LogicalOperationNode logicOpNode = blox.CreateNode(rootNode); ifNode = new IfNode(highlightableButton, logicOpNode); } // If a variable was chosen, will search for an existing BooleanNode with that same name else { // Gets the selected boolean variable string selectedBoolVarName = GameObjectHelper.GetDropdownSelectedTextValue(this.booleanVariablesDropdown); ICodeNode foundNode = rootNode.SearchChildByName(selectedBoolVarName); if (foundNode != null && GameObjectHelper.CanBeCastedAs <BooleanNode>(foundNode)) { BooleanNode boolNode = (BooleanNode)foundNode; ifNode = new IfNode(highlightableButton, boolNode); } else { throw new System.Exception("Expected " + selectedBoolVarName + " to be a boolean node"); } } parentNode.AddChildNode(ifNode); CompileChildrenToNodes(ifNode); }
public void Should_parse_boolean() { BooleanNode result = (BooleanNode)Parse("true"); Assert.Equal(true, result.Value); }
private Expression Build(BooleanNode node) { return(Expression.Constant(node.Value)); }
public virtual TAssociative VisitBooleanNode(BooleanNode node) { return(VisitAssociativeNode(node)); }
public virtual bool VisitBooleanNode(BooleanNode node) { return(DefaultVisit(node)); }
public virtual void Visit(BooleanNode node) { node.Accept(Visitor); }
public void Visit(BooleanNode node) { AddAssembly(typeof(bool).Assembly); Nodes.Push(new BooleanNode(node.Value)); _schemaFromArgs.Add(node.Value); }
public void Visit(BooleanNode node) { node.Accept(_visitor); }
public override void VisitBooleanNode(BooleanNode lnum) { Text += lnum.Val.ToString().ToLower(); }
public IfNode(HighlightableButton highlightableBlox, BooleanNode condition) : base(highlightableBlox) { Condition = condition; }
public BooleanNode(BooleanNode rhs) : base(rhs) { Value = rhs.Value; }
private void BuildGroups(IList<Token> tokens, NodeContext context) { for (int i = 0; i < tokens.Count; i++) { var token = tokens[i]; switch (token.Type) { case TokenType.Word: { var node = new TermNode(token.Text); context.AddChild(node); } break; case TokenType.BooleanAnd: { var node = new BooleanNode(BooleanType.And); context.AddChild(node); } break; case TokenType.BooleanOr: { var node = new BooleanNode(BooleanType.Or); context.AddChild(node); } break; case TokenType.Operator: { var node = new OperatorNode(token.Text); context.AddChild(node); } break; case TokenType.ParenthesisOpen: { var group = new ParenthesisGroupNode(); context.PushParent(group); } break; case TokenType.ParenthesisClose: { context.PopParent(); } break; case TokenType.Quote: // Quotes should have been removed by BuildSentences(). throw new Exception(); case TokenType.UnaryNot: { var node = new UnaryNode(UnaryType.Not); context.AddChild(node); } break; default: throw new NotImplementedException(); } } }
public virtual void VisitBooleanNode(BooleanNode node) { DefaultVisit(node); }
public void Visit(BooleanNode node) { }
public override void VisitBooleanNode(BooleanNode lnum) { throw new Exception("Logic error"); }
public void Visit(BooleanNode node) { Nodes.Push(new BooleanNode(node.Value)); }
protected void MethodCallNodeExecuteCall <T>(T objectValue, AbstractSyntaxTreeNode item) { var method = objectValue.GetType().GetMethod(((MethodCallNode)item).Name); if (method != null) { var objectList = new List <object>(); for (int parameterCount = 0; parameterCount < ((MethodCallNode)item).parameterList.Count; parameterCount++) { var parameter = ((MethodCallNode)item).parameterList[parameterCount]; if (parameter is StringNode) { var value = ((StringNode)parameter).Value; DateTime dateTime = new DateTime(); if (DateTime.TryParse(value, out dateTime)) { objectList.Add(dateTime); } else { objectList.Add(value); } } else if (parameter is DateTimeNode) { var value = ((DateTimeNode)parameter).Value; objectList.Add(value); } else if (parameter is BooleanNode) { var value = ((BooleanNode)parameter).Value; objectList.Add(value); } else if (parameter is DoubleNode) { var value = ((DoubleNode)parameter).Value; objectList.Add(value); } else if (parameter is IntegerNode) { var value = ((IntegerNode)parameter).Value; objectList.Add(value); } } var result = method.Invoke(objectValue, objectList.ToArray()); int intOutValue; double doubleOutValue; bool boolOutValue; DateTime dateTimeOutValue; if (result == null) { NullNode nullNode = new NullNode(); valueStack.Push(nullNode); } else if (int.TryParse(result.ToString(), out intOutValue)) { IntegerNode integerNode = new IntegerNode(); integerNode.Value = intOutValue; valueStack.Push(integerNode); } else if (double.TryParse(result.ToString(), out doubleOutValue)) { DoubleNode doubleNode = new DoubleNode(); doubleNode.Value = doubleOutValue; valueStack.Push(doubleNode); } else if (bool.TryParse(result.ToString(), out boolOutValue)) { BooleanNode booleanNode = new BooleanNode(); booleanNode.Value = boolOutValue; valueStack.Push(booleanNode); } else if (DateTime.TryParse(result.ToString(), out dateTimeOutValue)) { DateTimeNode dateTimeNode = new DateTimeNode(); dateTimeNode.Value = dateTimeOutValue; valueStack.Push(dateTimeNode); } else { StringNode stringNode = new StringNode(); stringNode.Value = result.ToString(); valueStack.Push(stringNode); } } }
void factor(out Node node) { node = null; if (la.kind == 2 || la.kind == 3 || la.kind == 38) { num(out node); } else if (isFunctionCall()) { functioncall(out node); } else if (isArrayAccess()) { arrayident(out node); } else if (la.kind == 27) { Get(); node = new BooleanNode() { value = ProtoCore.DSASM.Literal.True }; } else if (la.kind == 28) { Get(); node = new BooleanNode() { value = ProtoCore.DSASM.Literal.False }; } else if (la.kind == 29) { Get(); node = new NullNode(); } else if (la.kind == 32) { Get(); ExprListNode exprlist = new ExprListNode(); if (StartOf(3)) { expr(out node); exprlist.list.Add(node); while (la.kind == 30) { Get(); expr(out node); exprlist.list.Add(node); } } Expect(33); node = exprlist; } else if (la.kind == 8) { Get(); expr(out node); Expect(9); } else if (la.kind == 1) { identifierList(out node); } else { SynErr(65); } }