public Node SimpleType()
{
switch (CurrentToken)
{
case TokenCategory.INT:
var intType = new IntNode()
{
AnchorToken = Expect(TokenCategory.INT)
};
return(intType);
case TokenCategory.STR:
var strType = new StrNode()
{
AnchorToken = Expect(TokenCategory.STR)
};
return(strType);
case TokenCategory.BOOL:
var boolType = new BoolNode()
{
AnchorToken = Expect(TokenCategory.BOOL)
};
return(boolType);
default:
throw new SyntaxError(firstOfDeclaration,
tokenStream.Current);
}
}
public override Node VisitTypeExpr(ML4DParser.TypeExprContext context)
{
ExpressionNode node;
switch (context.value.Type)
{
case ML4DLexer.INUM:
node = new IntNode(int.Parse(context.value.Text));
break;
case ML4DLexer.FNUM:
node = new DoubleNode(double.Parse(context.value.Text, CultureInfo.InvariantCulture));
break;
case ML4DLexer.BOOLVAL:
node = new BoolNode(bool.Parse(context.value.Text));
break;
case ML4DLexer.ID:
node = new IDNode(context.value.Text);
break;
default:
throw new NotSupportedException($"The value {context.value.Text}, is not allowed.");
}
return(node);
}
public void testAI2()
{
int answerAI = -1;
// build tree...
Node action3 = new ActionNode(3);
Node action6 = new ActionNode(6);
// action3 = new ActionNode(7);
// yesnode, falsenode, bool
// Node root0 = new DecisionNode(action3, action6, false);
// yesnode, falsenode, testint, min, max
// Node root1 = new DecisionNode(action3, action6, 12, 11, 11);
Node root1 = new TestNode(action3, action6, 0, 0, 0);
answerAI = root1.RunNode();
Node root0 = new BoolNode(action3, action6, true);
answerAI = root0.RunNode();
Debug.Log("OUTPUT OF AI TREE: " + answerAI);
}
// Update is called once per frame
void Update()
{
monitor.Update();
if (!monitor.IsConnected)
{
legJointAngles = null;
app.ShowDiscovery();
}
else if (legJointAngles == null && monitor.rootNode != null)
{
connected = true;
testTrajectoryNode = monitor.rootNode.FindNode("/Insect/TestTrajectory") as BoolNode;
// Initialize leg joint nodes.
legJointAngles = new LegJoints[RobotController.NumLegs];
bool ok = true;
for (int legId = 0; legId < RobotController.NumLegs; ++legId)
{
legJointAngles[legId] = new LegJoints();
ok &= legJointAngles[legId].LookupNodes(monitor.rootNode, legId);
}
if (!ok)
{
// Error ?
app.ShowDiscovery();
}
}
}
public void Disconnect()
{
testTrajectoryNode = null;
legJointAngles = null;
connected = false;
monitor.Close();
}
public void Visit(BoolNode node)
{
if (!scope.IsDefinedType("Bool", out node.StaticType))
{
errors.Add(SemanticError.NotDeclaredType(new TypeNode(node.Line, node.Column, "Int")));
}
}
public void GenerateCode(BoolNode node, ICIL_CodeGenerator codeGenerator)
{
#region .CODE
var value = codeGenerator.DefineVariable();
codeGenerator.AddLocalVariable(
new CIL_LocalVariable(value));
codeGenerator.AddInstruction(
new Assign(value, node.Value));
//boolObj
node.Holder = codeGenerator.DefineVariable();
codeGenerator.AddLocalVariable(
new CIL_LocalVariable((Variable)node.Holder));
codeGenerator.AddInstruction(
new Allocate((Variable)node.Holder, $"{BuiltIn.Bool}"));
codeGenerator.AddInstruction(
new SetAttr((Variable)node.Holder,
$"{Attribute.Bool_value}",
value));
#endregion
}
public void CheckSemantic(BoolNode node, IScope scope = null)
{
if (TypeTable.IsDefinedType("Bool", out var type))
{
node.ComputedType = type;
}
}
public static TreeNode GetAllTypeNode()
{
TypesB1Node nodeType = new TypesB1Node();
nodeType.Text = nodeType.KNXMainNumber + "." + nodeType.KNXSubNumber + " " + nodeType.Name;
nodeType.Nodes.Add(SwitchNode.GetTypeNode());
nodeType.Nodes.Add(BoolNode.GetTypeNoe());
nodeType.Nodes.Add(EnableNode.GetTypeNode());
nodeType.Nodes.Add(RampNode.GetTypeNode());
nodeType.Nodes.Add(AlarmNode.GetTypeNode());
nodeType.Nodes.Add(BinaryValueNode.GetTypeNode());
nodeType.Nodes.Add(StepNode.GetTypeNode());
nodeType.Nodes.Add(UpDownNode.GetTypeNode());
nodeType.Nodes.Add(OpenCloseNode.GetTypeNode());
nodeType.Nodes.Add(StartNode.GetTypeNode());
nodeType.Nodes.Add(StateNode.GetTypeNode());
nodeType.Nodes.Add(InvertNode.GetTypeNode());
nodeType.Nodes.Add(DimSendStyleNode.GetTypeNode());
nodeType.Nodes.Add(InputSourceNode.GetTypeNode());
nodeType.Nodes.Add(ResetNode.GetTypeNode());
nodeType.Nodes.Add(AckNode.GetTypeNode());
nodeType.Nodes.Add(TriggerNode.GetTypeNode());
nodeType.Nodes.Add(OccupancyNode.GetTypeNode());
nodeType.Nodes.Add(WindowDoorNode.GetTypeNode());
nodeType.Nodes.Add(LogicalFunctionNode.GetTypeNode());
nodeType.Nodes.Add(SceneABNode.GetTypeNode());
nodeType.Nodes.Add(ShutterBlindsModeNode.GetTypeNode());
nodeType.Nodes.Add(HeatCoolNode.GetTypeNode());
return(nodeType);
}
public void Visit(BoolNode node)
{
Code.Add(new AssignConstToVarCodeLine(VariableManager.PeekVariableCounter(), node.Value ? 1 : 0));
if (object_return_type)
{
Code.Add(new AssignStrToVarCodeLine(return_type, "Bool"));
}
}
public void Visit(BoolNode node)
{
IC.Add(new AssignmentConstantToVariable(VariableManager.PeekVariableCounter(), node.Value ? 1 : 0));
if (special_object_return_type)
{
SetReturnType("Bool");
}
}
private BoolNode ParseBool()
{
Expect(TokenType.TRUE, TokenType.FALSE);
var b = new BoolNode(Position(), Current().Type == TokenType.TRUE);
Next();
return(b);
}
public void VisitBool(BoolNode node)
{
UpdateLine(node);
if (node.Value)
{
asm.PushTrue();
}
else
{
asm.PushFalse();
}
}
/// <summary>
/// This visits a bool node
/// It checks if the value is either true or false
/// </summary>
/// <param name="boolNode">The name of the node</param>
/// <returns>Returns the bool value</returns>
public override object Visit(BoolNode boolNode)
{
string boolVal = "";
if (boolNode.Value)
{
boolVal += " true";
}
else
{
boolVal += " false";
}
return(boolVal);
}
private bool isCorrect(DataPoint p, Formula f)
{
interpreter.numericInputs = p.integerData;
interpreter.logicalInputs = p.logicData;
switch (data.schema.outputsType[outputIndex])
{
case DataType.numerical:
NumericNode n = (NumericNode)f.entryNode;
return(n.eval(interpreter) == p.integerData[p.integerData.Count - 1]);
case DataType.logic:
BoolNode m = (BoolNode)f.entryNode;
return(m.eval(interpreter) == p.logicData[p.logicData.Count - 1]);
default: return(false);
}
}
public static BoolNode createBoolLogicOperator(BoolExpType type, BoolNode parram1,
BoolNode parram2)
{
switch (type)
{
case BoolExpType.boolExpAND:
return(new BoolANDOperator(parram1, parram2));
case BoolExpType.boolExpOR:
return(new BoolOROperator(parram1, parram2));
case BoolExpType.boolExpXOR:
return(new BoolXOROperator(parram1, parram2));
default:
throw new Exception();
}
}
void ReplaceNode(ITree parent, int index, object val, SimpleTypeEnum type)
{
CommonTree node = null;
var token = new CommonToken(-1, val.ToString());
switch (type)
{
case SimpleTypeEnum.Bool:
node = new BoolNode(token);
break;
case SimpleTypeEnum.Byte:
node = new ByteNode(token);
break;
case SimpleTypeEnum.Char:
node = new CharNode(token);
break;
case SimpleTypeEnum.Int:
node = new IntegerNode(token);
break;
case SimpleTypeEnum.Float:
node = new FloatNode(token);
break;
case SimpleTypeEnum.Double:
node = new RealNode(token);
break;
default:
throw new ArgumentOutOfRangeException("type", type, null);
}
parent.ReplaceChildren(index, index, node);
}
public string Visit(BoolNode node) => ASTHelper.PrintToken(node.Token);
public static DirectiveNode createDirectiveWHILE(BoolNode condition, DirectiveNode body)
{
return(new directiveWHILE(condition, body));
}
public virtual T VisitBool(BoolNode boolNode)
{
throw new NotImplementedException();
}
/// <summary>
/// This method prints the boolNode
/// </summary>
/// <param name="boolNode">The node to print.</param>
/// <returns>Returns null</returns>
public override object Visit(BoolNode boolNode)
{
Print("Bool");
return(null);
}
// values public abstract TReturn Visit(BoolNode node, TData data);
public override void Visit(BoolNode node)
{
Emit(node.Value.ToString().ToLower());
}
// values
public override TReturn Visit(BoolNode node, TData data)
{
return(default(TReturn));
}
private TypeInfo Visit(BoolNode node, MethodBuilder builder, CodegenContext context)
{
builder.LoadBool(node.Value);
return(SimpleType.Bool);
}
public override string VisitBool(BoolNode boolNode)
{
return(boolNode.Value.ToString());
}
/// <summary>
/// This method type checks the BoolNode node in the AST.
/// </summary>
/// <param name="boolNode">The node to check.</param>
/// <returns>Bool type context</returns>
public override object Visit(BoolNode boolNode)
{
return(new TypeContext(BOOL));
}
public static DirectiveNode createDirectiveIfELSE(BoolNode condition, DirectiveNode thenBranch, DirectiveNode elseBranch)
{
return(new directiveIFELSE(condition, thenBranch, elseBranch));
}
public virtual void VisitBoolNode(BoolNode val)
{
}
public override void VisitBoolNode(BoolNode v) => Text += v.Value.ToString().ToLower();
public static Node NewBool(bool b)
{
BoolNode node = new BoolNode(b);
return node;
}
