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);
}
}
