public NodeFactory() { builtin["Anchor"] = new AnchorNode(); builtin["Appearance"] = new AppearanceNode(); builtin["Background"] = new BackgroundNode(); builtin["Box"] = new BoxNode(); builtin["Color"] = new ColorNode(); builtin["Cone"] = new ConeNode(); builtin["Coordinate"] = new CoordinateNode(); builtin["CoordinateInterpolator"] = new CoordinateInterpolatorNode(); builtin["Cylinder"] = new CylinderNode(); builtin["DirectionalLight"] = new DirectionalLightNode(); builtin["Extrusion"] = new ExtrusionNode(); builtin["Group"] = new GroupNode(); builtin["Collision"] = new CollisionNode(); builtin["Switch"] = new SwitchNode(); builtin["IndexedFaceSet"] = new IndexedFaceSetNode(); builtin["IndexedLineSet"] = new IndexedLineSetNode(); builtin["Material"] = new MaterialNode(); builtin["NavigationInfo"] = new NavigationInfoNode(); builtin["OrientationInterpolator"] = new OrientationInterpolatorNode(); builtin["Normal"] = new NormalNode(); builtin["PixelTexture"] = new PixelTextureNode(); builtin["PointLight"] = new PointLightNode(); builtin["PositionInterpolator"] = new PositionInterpolatorNode(); builtin["ScalarInterpolator"] = new ScalarInterpolationNode(); builtin["Shape"] = new ShapeNode(); builtin["Sphere"] = new SphereNode(); builtin["TextureCoordinate"] = new TextureCoordinateNode(); builtin["TimeSensor"] = new TimeSensorNode(); builtin["Transform"] = new TransformNode(); builtin["Viewpoint"] = new ViewpointNode(); builtin["WorldInfo"] = new WorldInfoNode(); }
public SwitchNode Switch() { var @switch = new SwitchNode(); this.Add(@switch); return(@switch); }
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); }
void GeneratePipes(SwitchNode switchNode) { switchNode.childs.ForEach((Node child) => { float xdiff = Mathf.Abs(switchNode.coordinates.x - child.coordinates.x); float ydiff = Mathf.Abs(switchNode.coordinates.y - child.coordinates.y); int xcoeff = switchNode.coordinates.x - child.coordinates.x > 0 ? -1 : 1; int ycoeff = switchNode.coordinates.y - child.coordinates.y > 0 ? -1 : 1; for (int i = 1; i < xdiff; i++) { var horizontalPipe = Instantiate(pipeHorizontal) as GameObject; horizontalPipe.transform.position = new Vector2(switchNode.coordinates.x + i * xcoeff, child.coordinates.y); } for (int i = 1; i < ydiff; i++) { var horizontalPipe = Instantiate(pipeVertical) as GameObject; horizontalPipe.transform.position = new Vector2(child.coordinates.x, switchNode.coordinates.y + i * ycoeff); } if (child.GetType() == typeof(SwitchNode)) { GeneratePipes((SwitchNode)child); } }); }
public void Accept(SwitchNode node) { table.EnterScope(); var endLabel = nextLabel(); node.Value.Visit(this); for (int i = 0; i < node.Cases.Count; i++) { emit(node.Value.SourceLocation, InstructionType.Duplicate); } foreach (var case_ in node.Cases) { var falseLabel = nextLabel(); case_.C.Visit(this); emit(case_.C.SourceLocation, InstructionType.BinaryOperation, (int)case_.BinaryOperation); emit(case_.C.SourceLocation, InstructionType.JumpIfFalse, falseLabel); case_.Stmt.Visit(this); emit(node.Value.SourceLocation, InstructionType.Jump, endLabel); emitLabel(case_.Stmt.SourceLocation, falseLabel); } node.Default.Visit(this); emitLabel(node.SourceLocation, endLabel); table.LeaveScope(); }
/// <summary> /// Gets the switch node instance with given node name. /// </summary> /// <param name="name">The name of switch node.</param> /// <returns>The switch node instance</returns> /// <feature>http://tizen.org/feature/machine_learning.inference</feature> /// <exception cref="NotSupportedException">Thrown when the feature is not supported.</exception> /// <exception cref="ArgumentException">Thrown when the method failed due to an invalid parameter.</exception> /// <since_tizen> 8 </since_tizen> public SwitchNode GetSwitch(string name) { NNStreamer.CheckNNStreamerSupport(); /* Check the parameter */ if (string.IsNullOrEmpty(name)) { throw NNStreamerExceptionFactory.CreateException(NNStreamerError.InvalidParameter, "Node name is invalid"); } SwitchNode node; if (_nodeList.ContainsKey(name)) { if (_nodeList[name].Type != NodeType.Switch) { throw NNStreamerExceptionFactory.CreateException(NNStreamerError.InvalidParameter, name + " is not a switch node"); } node = (SwitchNode)_nodeList[name]; } else { node = new SwitchNode(name, this); _nodeList.Add(name, node); } return(node); }
public SwitchBuilder(SwitchNode switchnode) { node = switchnode; DotDefinition = new List <IDotElement>(); CreateNode(); CreateEndNode(); CreateEdgeToFirstChildren(); CreateEdgeToNextSibling(); }
public static TreeNode GetAllActionNode() { TypesB1Node nodeAction = new TypesB1Node(); nodeAction.Text = nodeAction.KNXMainNumber + "." + nodeAction.KNXSubNumber + " " + nodeAction.Name; nodeAction.Nodes.Add(SwitchNode.GetActionNode()); return(nodeAction); }
protected override void VisitSwitch <TChoice>(SwitchNode <TChoice> switchNode) { AddNode(switchNode); AddLink(switchNode, switchNode.DefaultCase, "Default"); foreach (var valueNodePair in switchNode.Cases) { AddLink(switchNode, valueNodePair.Value, Categories.NormalFlowEdge, valueNodePair.Key?.ToString() ?? ""); } }
public override IDriverNode CreateDriverNode(IDriverContext ctx) { IDriverNode driverNode = null; switch (ctx.NodeInstance.This2NodeTemplateNavigation.Key) { case "light-bulb-switch": driverNode = new SwitchNode(ctx, Accessory.Services[1].Characteristics.Single(a => a.Type == CharacteristicBase.OnType), Driver); break; case "light-bulb-brightness": var brigthness = Accessory.CreateBrightness(); driverNode = new LightSwitch(ctx, Driver, brigthness); break; case "light-bulb-hue": var hue = Accessory.CreateHue(); driverNode = new LightSwitch(ctx, Driver, hue); break; case "power-outlet-switch": driverNode = new SwitchNode(ctx, Accessory.Services[1].Characteristics.Single(a => a.Type == CharacteristicBase.OnType), Driver); break; case "contact-sensor": driverNode = new BaseNode(ctx, Accessory.Services[1].Characteristics .Single(a => a.Type == CharacteristicBase.ContactSensorStateType), Driver); break; case "switch": driverNode = new SwitchNode(ctx, Accessory.Services[1].Characteristics.Single(a => a.Type == CharacteristicBase.OnType), Driver); break; case "temperature-sensor": driverNode = new BaseNode(ctx, Accessory.Services[1].Characteristics .Single(a => a.Type == CharacteristicBase.CurrentTemperatureType), Driver); break; case "switch-status": case "power-outlet-status": case "light-bulb-status": driverNode = new StateNode(ctx, Accessory.Services[1].Characteristics.Single(a => a.Type == CharacteristicBase.OnType), Driver); break; } return(driverNode); }
private void __ProcessSwitchNode(IDNodeBase _node) { SwitchNode node = (SwitchNode)_node; if (m_scenario.CheckSwitch(node.SwitchName)) { m_scenario.AdvanceByNode(node.GetTrueNext()); } else { m_scenario.AdvanceByNode(node.GetFalseNext()); } }
private Statement ProcessSwitchStatement(SwitchNode node) { Expression condition = expressionBuilder.BuildExpression(node.Condition); if (condition is MemberExpression) { condition = expressionBuilder.TransformMemberExpression((MemberExpression)condition); } SwitchStatement statement = new SwitchStatement(condition); foreach (SwitchSectionNode switchSectionNode in node.Cases) { SwitchGroup group = new SwitchGroup(); foreach (StatementNode caseNode in switchSectionNode.Labels) { if (caseNode is CaseLabelNode) { CaseLabelNode labelNode = (CaseLabelNode)caseNode; Expression labelValue = expressionBuilder.BuildExpression(labelNode.Value); if (labelValue is MemberExpression) { labelValue = expressionBuilder.TransformMemberExpression((MemberExpression)labelValue); } group.AddCase(labelValue); } else { Debug.Assert(caseNode is DefaultLabelNode); group.AddDefaultCase(); } } foreach (StatementNode statementNode in switchSectionNode.Statements) { Statement childStatement = BuildStatement(statementNode); if (childStatement != null) { group.AddStatement(childStatement); } } statement.AddSwitchGroup(group); } return(statement); }
// Update is called once per frame void Update() { if (!GameManager.IsGameRunning()) { return; } if (this.IsOutOfCameraBounds()) { DestroyAndNotify(); return; } if (nodeToVisit == null) { nodeToVisit = lastVisitedSwitchNode.GetNextNode(); } if (nodeToVisit != null && (new Vector2(transform.position.x, transform.position.y) - nodeToVisit.coordinates).sqrMagnitude <= 0.1) { // check where to go this.transform.position = nodeToVisit.coordinates; if (nodeToVisit.GetType() == typeof(SwitchNode)) { direction = ((SwitchNode)nodeToVisit).GetDirectionVector(); lastVisitedSwitchNode = (SwitchNode)nodeToVisit; nodeToVisit = null; } else { BeerTag beerTag = TagResolver.GetTagByName(gameObject.tag); GameObject houseSpriteObj = GameObject.Find("HouseNode#" + nodeToVisit.nodeId); HouseHandler houseHandler = houseSpriteObj.GetComponent <HouseHandler>() as HouseHandler; BeerTag houseBeerTag = houseHandler.getBeerTag(); if (beerTag == houseBeerTag) { houseHandler.addLiter(); houseHandler.CheckAndReset(); GameManager.UpdateScore(1); } DestroyAndNotify(); } } Vector2 translation = Time.deltaTime * beerSpeed * direction; this.transform.Translate(translation); }
private void AddNodeSwitch(ViewNode pNode) { if (null != pNode) { if ((MyConst.View.KnxPageType == pNode.Name) || (MyConst.Controls.KnxGroupBoxType == pNode.Name)) { SwitchNode node = new SwitchNode(); //pNode.Nodes.Add(node); this.cqpo.ExecuteCommand(new TreeNodeAdd(this.tvPage, pNode, node, -1)); NodeAddEventArgs arg = new NodeAddEventArgs(); arg.mPageNode = this.CurPageNode; arg.mParentNode = pNode; arg.mNode = node; AddNodeNotify(node, arg); } } }
public void Visit(SwitchNode switchNode) { switchNode.Value.Parent = switchNode; switchNode.Value.Accept(this); var loop = _currentLoop; _currentLoop = LoopType.Case; foreach (var switchCase in switchNode.Cases) { switchCase.Expression.Parent = switchNode; switchCase.Expression.Accept(this); switchCase.Expression.Parent = switchNode; switchCase.Body.Accept(this); } if (switchNode.DefaultCase != null) { switchNode.DefaultCase.Parent = switchNode; switchNode.DefaultCase.Accept(this); } _currentLoop = loop; }
public void Switch(SwitchNode switcher) { //RotateVector transform.position = switcher.GoalPos; switch (switcher.VectorType) { case VectorType.Finish: Finish(); break; case VectorType.SwitchScreen: switcher.SwitchCam(); UpdateGoal(switcher); currentVectorType = VectorType.Forward; break; case VectorType.Backward: case VectorType.Forward: case VectorType.Left: case VectorType.Right: currentVectorType = switcher.VectorType; UpdateGoal(switcher); break; } }
void GenerateSprites(BeerTree bt) { SwitchNode startNode = bt.start; GenerateSprite(startNode); }
BeerTree MapGenerator(int numberOfSwitches) { SwitchNode parentSwitch = new SwitchNode(new Vector2(0.0f, 0.0f), "SWITCH_ROOT", new Switch(), true); BeerTree bT = new BeerTree(parentSwitch); int numOfSwitches = numberOfSwitches; float y = 0.0f; int idSwitchCounter = 1; int numOfHouses = 0; int idHouseCounter = 1; for (int i = 0; i < numOfSwitches; i++) { y = y - 3; SwitchNode newSwitch = new SwitchNode(new Vector2(0.0f, y), "SWITCH_" + idSwitchCounter++, new Switch(), false); if (i == numOfSwitches - 1) { lastSwitchYcoordinate = y; } numOfHouses = RandomUtils.GetRandomNumber(1, 4); if (i == 0) { bT.AddSwitch(newSwitch, "SWITCH_ROOT"); } else { bT.AddSwitch(newSwitch, parentSwitch.nodeId); } parentSwitch = newSwitch; switch (numOfHouses) { case 1: { HouseNode leftHouse = new HouseNode(new House(), new Vector2(-5.0f, newSwitch.coordinates.y), "HOUSE_" + idHouseCounter++); bT.AddHouse(leftHouse, newSwitch.nodeId); break; } case 2: { HouseNode rightHouse = new HouseNode(new House(), new Vector2(5.0f, newSwitch.coordinates.y), "HOUSE_" + idHouseCounter++); bT.AddHouse(rightHouse, newSwitch.nodeId); break; } default: { HouseNode leftHouse = new HouseNode(new House(), new Vector2(-5.0f, newSwitch.coordinates.y), "HOUSE_" + idHouseCounter++); bT.AddHouse(leftHouse, newSwitch.nodeId); HouseNode rightHouse = new HouseNode(new House(), new Vector2(5.0f, newSwitch.coordinates.y), "HOUSE_" + idHouseCounter++); bT.AddHouse(rightHouse, newSwitch.nodeId); break; } } } return(bT); }
/// <summary> /// 按 KNX 控件类型,给树上添加控件节点 /// </summary> /// <param name="parentNode"></param> /// <param name="knxControl"></param> private static void AddControlNode(ContainerNode parentNode, KNXControlBase knxControl /*, UIEditor.Entity.ViewNode.PropertiesChangedDelegate proChangedDelegate*/) { switch (knxControl.GetType().Name) { case MyConst.Controls.KnxBlindsType: var blindsNode = new BlindsNode(knxControl as KNXBlinds); //blindsNode.PropertiesChangedEvent += proChangedDelegate; parentNode.Nodes.Add(blindsNode); break; case MyConst.Controls.KnxLabelType: var labelNode = new LabelNode(knxControl as KNXLabel); //labelNode.PropertiesChangedEvent += proChangedDelegate; parentNode.Nodes.Add(labelNode); break; case MyConst.Controls.KnxSceneButtonType: var sceneButtonNode = new SceneButtonNode(knxControl as KNXSceneButton); //sceneButtonNode.PropertiesChangedEvent += proChangedDelegate; parentNode.Nodes.Add(sceneButtonNode); break; case MyConst.Controls.KnxSliderSwitchType: var sliderSwitchNode = new SliderSwitchNode(knxControl as KNXSliderSwitch); //sliderSwitchNode.PropertiesChangedEvent += proChangedDelegate; parentNode.Nodes.Add(sliderSwitchNode); break; case MyConst.Controls.KnxSwitchType: var switchNode = new SwitchNode(knxControl as KNXSwitch); //switchNode.PropertiesChangedEvent += proChangedDelegate; parentNode.Nodes.Add(switchNode); break; case MyConst.Controls.KnxValueDisplayType: var valueDisplayNode = new ValueDisplayNode(knxControl as KNXValueDisplay); //valueDisplayNode.PropertiesChangedEvent += proChangedDelegate; parentNode.Nodes.Add(valueDisplayNode); break; case MyConst.Controls.KnxTimerButtonType: var timerButton = new TimerButtonNode(knxControl as KNXTimerButton); //timerButton.PropertiesChangedEvent += proChangedDelegate; parentNode.Nodes.Add(timerButton); break; case MyConst.Controls.KnxDigitalAdjustment: var digitalAdjustment = new DigitalAdjustmentNode(knxControl as KNXDigitalAdjustment); //digitalAdjustment.PropertiesChangedEvent += proChangedDelegate; parentNode.Nodes.Add(digitalAdjustment); break; case MyConst.Controls.KnxGroupBoxType: var groupBox = new GroupBoxNode(knxControl as KNXGroupBox); //groupBox.PropertiesChangedEvent += proChangedDelegate; parentNode.Nodes.Add(groupBox); KNXGroupBox knxGroupBox = knxControl as KNXGroupBox; if (knxGroupBox.Controls != null && knxGroupBox.Controls.Count > 0) { foreach (var item in knxGroupBox.Controls) { AddControlNode(groupBox, item /*, proChangedDelegate*/); } } break; default: MessageBox.Show(ResourceMng.GetString("Message39") + knxControl.GetType().Name, ResourceMng.GetString("Message6"), MessageBoxButtons.OK, MessageBoxIcon.Error); break; } }
void GeneratePipes(BeerTree bt) { SwitchNode startNode = bt.start; GeneratePipes(startNode); }
// Use this for initialization void Start() { beerTree = LevelLoader.getInstance().GetBeerTree(); direction = new Vector2(0.0f, -1.0f); lastVisitedSwitchNode = beerTree.getRootNode(); }
public void Add(SwitchNode switchNode) { this.parts.Add(switchNode); }
public SwitchCompiler(SwitchNode node) { this.node = node; }
private static ViewNode ImportControlNode(BackgroundWorker worker, ContainerNode parentNode, KNXControlBase knx, string ResImgDir) { ViewNode node = null; switch (knx.GetType().Name) { case MyConst.Controls.KnxBlindsType: node = new BlindsNode(knx as KNXBlinds, worker, ResImgDir); break; case MyConst.Controls.KnxLabelType: node = new LabelNode(knx as KNXLabel, worker, ResImgDir); break; case MyConst.Controls.KnxSceneButtonType: node = new SceneButtonNode(knx as KNXSceneButton, worker, ResImgDir); break; case MyConst.Controls.KnxSliderSwitchType: node = new SliderSwitchNode(knx as KNXSliderSwitch, worker, ResImgDir); break; case MyConst.Controls.KnxSwitchType: node = new SwitchNode(knx as KNXSwitch, worker, ResImgDir); break; case MyConst.Controls.KnxValueDisplayType: node = new ValueDisplayNode(knx as KNXValueDisplay, worker, ResImgDir); break; case MyConst.Controls.KnxTimerButtonType: node = new TimerButtonNode(knx as KNXTimerButton, worker, ResImgDir); break; case MyConst.Controls.KnxDigitalAdjustmentType: node = new DigitalAdjustmentNode(knx as KNXDigitalAdjustment, worker, ResImgDir); break; case MyConst.Controls.KnxImageButtonType: node = new ImageButtonNode(knx as KNXImageButton, worker, ResImgDir); break; case MyConst.Controls.KnxShutterType: node = new ShutterNode(knx as KNXShutter, worker, ResImgDir); break; case MyConst.Controls.KnxDimmerType: node = new DimmerNode(knx as KNXDimmer, worker, ResImgDir); break; case MyConst.Controls.KnxWebCamViewerType: node = new WebCamerNode(knx as KNXWebCamer, worker, ResImgDir); break; case MyConst.Controls.KnxMediaButtonType: node = new MediaButtonNode(knx as KNXMediaButton, worker, ResImgDir); break; case MyConst.Controls.KnxAirConditionType: node = new AirConditionNode(knx as KNXAirCondition, worker, ResImgDir); break; case MyConst.Controls.KnxHVACType: node = new HVACNode(knx as KNXHVAC, worker, ResImgDir); break; case MyConst.Controls.KnxGroupBoxType: node = new GroupBoxNode(knx as KNXGroupBox, worker, ResImgDir); KNXGroupBox knxGroupBox = knx as KNXGroupBox; if (knxGroupBox.Controls != null && knxGroupBox.Controls.Count > 0) { foreach (var item in knxGroupBox.Controls) { ImportControlNode(worker, node as ContainerNode, item, ResImgDir); } } break; default: MessageBox.Show(UIResMang.GetString("Message39") + knx.GetType().Name, UIResMang.GetString("Message6"), MessageBoxButtons.OK, MessageBoxIcon.Error); break; } if (null != parentNode) { parentNode.Nodes.Add(node); } return(node); }
private SyntaxNode Node(SyntaxType parent, int start, int end, List <Token> tokens, List <Error> compileErrors) { switch (parent) { case SyntaxType.Program: { SyntaxNode node = new ProgramNode(); for (var i = start; i < end; i++) { switch (tokens[i].Type) { case TokenType.ClassDeclaration: { var newStart = i + 1; var left = 1; var right = 0; while (left != right) { i++; if (i >= end) { compileErrors.Add(new Error("Missing end of class declaration")); return(null); } switch (tokens[i].Type) { case TokenType.ClassDeclaration: case TokenType.InterfaceDeclaration: left++; break; case TokenType.ClassEndDeclaration: right++; break; } } var childNode = Node(SyntaxType.Class, newStart, i, tokens, compileErrors); if (childNode == null) { return(null); } node.Nodes.Add(childNode); break; } case TokenType.InterfaceDeclaration: { var newStart = i + 1; var left = 1; var right = 0; while (left != right) { i++; if (i >= end) { compileErrors.Add(new Error("Missing end of interface declaration")); return(null); } switch (tokens[i].Type) { case TokenType.ClassDeclaration: case TokenType.InterfaceDeclaration: left++; break; case TokenType.ClassEndDeclaration: right++; break; } } var childNode = Node(SyntaxType.Interface, newStart, i, tokens, compileErrors); if (childNode == null) { return(null); } node.Nodes.Add(childNode); break; } default: { if (IsTokenWhiteSpace(tokens[i])) { continue; } compileErrors.Add(new Error("Unexpected expression in program body")); return(null); } } } return(node); } case SyntaxType.Class: { SyntaxNode node = new ClassNode(tokens[start - 1], tokens[end]); for (var i = start; i < end; i++) { switch (tokens[i].Type) { case TokenType.MethodDeclaration: { var newStart = i + 1; var left = 1; var right = 0; while (left != right) { i++; if (i >= end) { compileErrors.Add(new Error("Missing end of method declaration")); return(null); } switch (tokens[i].Type) { case TokenType.MethodDeclaration: case TokenType.MainMethodDeclaration: left++; break; case TokenType.MethodEndDeclaration: right++; break; } } var childNode = Node(SyntaxType.MethodDeclaring, newStart, i, tokens, compileErrors); if (childNode == null) { return(null); } node.Nodes.Add(childNode); break; } case TokenType.MainMethodDeclaration: { var newStart = i + 1; var left = 1; var right = 0; while (left != right) { i++; if (i >= end) { compileErrors.Add(new Error("Missing end of main method declaration")); return(null); } switch (tokens[i].Type) { case TokenType.MethodDeclaration: case TokenType.MainMethodDeclaration: left++; break; case TokenType.MethodEndDeclaration: right++; break; } } var childNode = Node(SyntaxType.MainMethodDeclaring, newStart, i, tokens, compileErrors); if (childNode == null) { return(null); } node.Nodes.Add(childNode); break; } default: { if (IsTokenWhiteSpace(tokens[i])) { continue; } compileErrors.Add(new Error("Unexpected expression in class body")); return(null); } } } return(node); } case SyntaxType.Interface: { SyntaxNode node = new InterfaceNode(tokens[start - 1], tokens[end]); for (var i = start; i < end; i++) { if (tokens[i].Type == TokenType.MethodDeclaration) { node.Nodes.Add(new InterfaceMethodNode(tokens[i])); } else if (IsTokenWhiteSpace(tokens[i])) { } else { compileErrors.Add(new Error("Unexpected expression in interface body")); return(null); } } return(node); } case SyntaxType.MethodDeclaring: case SyntaxType.MainMethodDeclaring: { SyntaxNode node = new MethodNode(tokens[start - 1], tokens[end], parent == SyntaxType.MainMethodDeclaring); Node(parent, start, end, tokens, compileErrors, node, "method"); return(node); } case SyntaxType.Switch: { SyntaxNode node = new SwitchNode(tokens[start - 1], tokens[end]); Node(parent, start, end, tokens, compileErrors, node, "switch"); return(node); } case SyntaxType.SwitchCase: { SyntaxNode node = new SwitchCase(tokens[start - 1], tokens[start - 1].Type == TokenType.SwitchDefaultCase); Node(parent, start, end, tokens, compileErrors, node, "switch case"); return(node); } case SyntaxType.IfTruePart: { SyntaxNode node = new IfTrueNode(tokens[start - 1].Childs[0]); Node(parent, start, end, tokens, compileErrors, node, "if"); return(node); } case SyntaxType.IfFalsePart: { SyntaxNode node = new IfElseNode(); Node(parent, start, end, tokens, compileErrors, node, "else"); return(node); } case SyntaxType.ElifPart: { SyntaxNode node = new ElifNode(tokens[start - 1].Childs[0]); Node(parent, start, end, tokens, compileErrors, node, "else-if"); return(node); } case SyntaxType.For: { SyntaxNode node = new ForNode(tokens[start - 1], tokens[end]); Node(parent, start, end, tokens, compileErrors, node, "for"); return(node); } case SyntaxType.Foreach: { SyntaxNode node = new ForeachNode(tokens[start - 1], tokens[end]); Node(parent, start, end, tokens, compileErrors, node, "foreach"); return(node); } case SyntaxType.While: { SyntaxNode node = new WhileNode(tokens[start - 1].Childs[0]); Node(parent, start, end, tokens, compileErrors, node, "while"); return(node); } case SyntaxType.DoWhile: { SyntaxNode node = new DoWhileNode(tokens[end].Childs[0]); Node(parent, start, end, tokens, compileErrors, node, "do-while"); return(node); } default: { compileErrors.Add(new Error("Not implemented parser behaviour")); return(null); } } }
public object Process(Parser parser, SortedDictionary <string, object> parameters) { if (parser.CurrenToken.Type == TokenType.PmSemicolon) { parser.NextToken(); return(null); } else if (parser.CurrenToken.Type == TokenType.KwIf) { parser.NextToken(); if (parser.CurrenToken.Type == TokenType.PmLeftParent) { parser.NextToken(); var _evaluation = (ExpressionNode) new AssignmentExpression().Process(parser, parameters); if (parser.CurrenToken.Type == TokenType.PmRightParent) { parser.NextToken(); var _ifCode = (List <StatementNode>) new Statementp().Process(parser, parameters); var _ifNotCode = (ElseNode) new IfNot().Process(parser, parameters); var _if = new IfNode { EvaluationNode = _evaluation, IfCode = _ifCode, IfNotCode = _ifNotCode }; return(_if); } else { throw new ParserException("This was expected ) Received: [" + parser.CurrenToken.LexemeVal + "], Row: " + parser.CurrenToken.Row + ", Column: " + parser.CurrenToken.Column); } } else { throw new ParserException("This was expected ( Received: [" + parser.CurrenToken.LexemeVal + "], Row: " + parser.CurrenToken.Row + ", Column: " + parser.CurrenToken.Column); } } else if (parser.CurrenToken.Type == TokenType.KwWhile) { parser.NextToken(); if (parser.CurrenToken.Type == TokenType.PmLeftParent) { parser.NextToken(); var _evaluation = (ExpressionNode) new AssignmentExpression().Process(parser, parameters); if (parser.CurrenToken.Type == TokenType.PmRightParent) { parser.NextToken(); var _whileCode = (List <StatementNode>) new Statementp().Process(parser, parameters); var _while = new WhileNode { EvaluationNode = _evaluation, CodeNode = _whileCode }; return(_while); } else { throw new ParserException("This was expected ) Received: [" + parser.CurrenToken.LexemeVal + "], Row: " + parser.CurrenToken.Row + ", Column: " + parser.CurrenToken.Column); } } else { throw new ParserException("This was expected ( Received: [" + parser.CurrenToken.LexemeVal + "], Row: " + parser.CurrenToken.Row + ", Column: " + parser.CurrenToken.Column); } } else if (parser.CurrenToken.Type == TokenType.KwFor) { parser.NextToken(); if (parser.CurrenToken.Type == TokenType.PmLeftParent) { parser.NextToken(); var _for = (ForNode) new ForConditions().Process(parser, parameters); if (parser.CurrenToken.Type == TokenType.PmRightParent) { parser.NextToken(); var _forCode = (List <StatementNode>) new Statementp().Process(parser, parameters); _for.CodeNode = _forCode; return(_for); } else { throw new ParserException("This was expected ) Received: [" + parser.CurrenToken.LexemeVal + "], Row: " + parser.CurrenToken.Row + ", Column: " + parser.CurrenToken.Column); } } else { throw new ParserException("This was expected ( Received: [" + parser.CurrenToken.LexemeVal + "], Row: " + parser.CurrenToken.Row + ", Column: " + parser.CurrenToken.Column); } } else if (parser.CurrenToken.Type == TokenType.KwBreak) { parser.NextToken(); if (parser.CurrenToken.Type == TokenType.PmSemicolon) { parser.NextToken(); return(new BreakNode()); } else { throw new ParserException("This was expected ; Received: [" + parser.CurrenToken.LexemeVal + "], Row: " + parser.CurrenToken.Row + ", Column: " + parser.CurrenToken.Column); } } else if (parser.CurrenToken.Type == TokenType.KwContinue) { parser.NextToken(); if (parser.CurrenToken.Type == TokenType.PmSemicolon) { parser.NextToken(); return(new ContinueNode()); } else { throw new ParserException("This was expected ; Received: [" + parser.CurrenToken.LexemeVal + "], Row: " + parser.CurrenToken.Row + ", Column: " + parser.CurrenToken.Column); } } else if (parser.CurrenToken.Type == TokenType.KwThrow) { var _throw = new ThrowStatement().Process(parser, parameters); if (parser.CurrenToken.Type == TokenType.PmSemicolon) { parser.NextToken(); return(_throw); } else { throw new ParserException("This was expected ; Received: [" + parser.CurrenToken.LexemeVal + "], Row: " + parser.CurrenToken.Row + ", Column: " + parser.CurrenToken.Column); } } else if (parser.CurrenToken.Type == TokenType.KwSwitch) { parser.NextToken(); if (parser.CurrenToken.Type == TokenType.PmLeftParent) { parser.NextToken(); var _evaluation = (ExpressionNode) new AssignmentExpression().Process(parser, parameters); if (parser.CurrenToken.Type == TokenType.PmRightParent) { parser.NextToken(); if (parser.CurrenToken.Type == TokenType.PmLeftCurlyBracket) { parser.NextToken(); var _caseBlock = (BaseCaseNode) new CaseBlock().Process(parser, parameters); if (parser.CurrenToken.Type == TokenType.PmRightCurlyBracket) { parser.NextToken(); var _switch = new SwitchNode { EvaluationNode = _evaluation, CaseBlockNode = _caseBlock }; return(_switch); } else { throw new ParserException("This was expected } Received: [" + parser.CurrenToken.LexemeVal + "], Row: " + parser.CurrenToken.Row + ", Column: " + parser.CurrenToken.Column); } } else { throw new ParserException("This was expected { Received: [" + parser.CurrenToken.LexemeVal + "], Row: " + parser.CurrenToken.Row + ", Column: " + parser.CurrenToken.Column); } } else { throw new ParserException("This was expected ) Received: [" + parser.CurrenToken.LexemeVal + "], Row: " + parser.CurrenToken.Row + ", Column: " + parser.CurrenToken.Column); } } else { throw new ParserException("This was expected ( Received: [" + parser.CurrenToken.LexemeVal + "], Row: " + parser.CurrenToken.Row + ", Column: " + parser.CurrenToken.Column); } } else if (parser.CurrenToken.Type == TokenType.KwDo) { parser.NextToken(); var _doWhileCode = (List <StatementNode>) new Statementp().Process(parser, parameters); if (parser.CurrenToken.Type == TokenType.KwWhile) { parser.NextToken(); if (parser.CurrenToken.Type == TokenType.PmLeftParent) { parser.NextToken(); var _evaluation = (ExpressionNode) new AssignmentExpression().Process(parser, parameters); if (parser.CurrenToken.Type == TokenType.PmRightParent) { parser.NextToken(); var _doWhile = new DoWhileNode { EvaluationNode = _evaluation, CodeNode = _doWhileCode }; return(_doWhile); } else { throw new ParserException("This was expected ) Received: [" + parser.CurrenToken.LexemeVal + "], Row: " + parser.CurrenToken.Row + ", Column: " + parser.CurrenToken.Column); } } else { throw new ParserException("This was expected ( Received: [" + parser.CurrenToken.LexemeVal + "], Row: " + parser.CurrenToken.Row + ", Column: " + parser.CurrenToken.Column); } } else { throw new ParserException("This was expected the token: while, Received: [" + parser.CurrenToken.LexemeVal + "], Row: " + parser.CurrenToken.Row + ", Column: " + parser.CurrenToken.Column); } } else if (parser.CurrenToken.Type == TokenType.KwReturn) { parser.NextToken(); var _returnEp = (List <ExpressionNode>) new ExpressionOpt().Process(parser, parameters); if (parser.CurrenToken.Type == TokenType.PmSemicolon) { parser.NextToken(); var _return = new ReturnNode { ReturnExpressionNode = _returnEp }; return(_return); } else { throw new ParserException("This was expected ; Received: [" + parser.CurrenToken.LexemeVal + "], Row: " + parser.CurrenToken.Row + ", Column: " + parser.CurrenToken.Column); } } else if (parser.CurrenToken.Type == TokenType.KwTry) { parser.NextToken(); var _tryCode = (List <StatementNode>) new CompoundStatement().Process(parser, parameters); var _try = (TryNode) new CatchBlock().Process(parser, parameters); var _finally = (FinallyNode) new FinallyBlock().Process(parser, parameters); _try.FinallyCode = _finally; _try.TryCode = _tryCode; return(_try); } else { var _varEp = new VariablesOrExpression().Process(parser, parameters); if (parser.CurrenToken.Type == TokenType.PmSemicolon) { parser.NextToken(); return(_varEp); } else { throw new ParserException("This was expected ; Received: [" + parser.CurrenToken.LexemeVal + "], Row: " + parser.CurrenToken.Row + ", Column: " + parser.CurrenToken.Column); } } }
private void UpdateGoal(SwitchNode rotate) { currentMoveVector = (rotate.NextGoal.GoalPos - rotate.GoalPos).normalized; currentGoal = rotate.NextGoal; }
public SwitchNode Switch() { var @switch = new SwitchNode(); this.Add(@switch); return @switch; }
// Start is called before the first frame update void Start() { socketClient = new SocketClient(); socketServer = GameObject.FindObjectOfType <SocketServer>(); maker = GameObject.FindObjectOfType <SpeechBubbleMaker>(); uniwinc = GameObject.FindObjectOfType <UniWindowController>(); Node root = new MenuNode(); Node setting = new Node("せってい", 1); root.AddChild(setting); var setTransparent = new SwitchNode("背景透過中だよ", "背景透過してないよ", 1, uniwinc.isTransparent); setting.AddCallback(() => { setTransparent.ON = uniwinc.isTransparent; }); setTransparent.AddCallback(() => { uniwinc.isTransparent = setTransparent.ON; }); setting.AddChild(setTransparent); var setTopmost = new SwitchNode("最前面固定するよ", "最前面固定しないよ", 1, uniwinc.isTopmost); setting.AddCallback(() => { setTopmost.ON = uniwinc.isTopmost; }); setTopmost.AddCallback(() => { uniwinc.isTopmost = setTopmost.ON; }); setting.AddChild(setTopmost); var setTranslucent = new SwitchNode("半透明だよ", "半透明じゃないよ", 1, false); setTranslucent.AddCallback(() => { canvasGroup.alpha = setTranslucent.ON ? 0.5f : 1.0f; }); setting.AddChild(setTranslucent); var setRandspeak = new SwitchNode("話すよー", "黙ってるよ...", +1); setRandspeak.AddCallback(() => { if (setRandspeak.ON) { maker.StopSpeak(); } else { maker.StartSpeak(); } }); setting.AddChild(setRandspeak); Node remocon = new Node("リモコン", 1); // root.AddChild(remocon); Node right_off = new Node("明かりを消す?", 1); right_off.AddCallback(() => { HttpCommunicator hc = new HttpCommunicator(); var url = "https://api.switch-bot.com/v1.0/devices/01-202101071744-43895891/commands"; // hc.GetHttpAsync() }); Node sensor = new Node("Sensor", 1); // root.AddChild(sensor); PythonExecutor pyexe = GameObject.FindObjectOfType <PythonExecutor>(); socketServer.AddCommand("speak", mes => { maker.GenerateFromThread(1, mes, 3, 1); }); socketServer.AddCommand("long_speak", mes => { maker.GenerateFromThread(1, mes, -1, 1); }); socketServer.AddCommand("echo", mes => { pyexe.SendCmd("nothing"); }); Node sensor_mes = new Node("Lauching..."); sensor.AddChild(sensor_mes); pyexe.AddCommand("log", (mes) => { Debug.Log("[python][log] " + mes); }); sensor.AddCallback(() => { sensor_mes.Text = "Lauching..."; pyexe.ExecuteOnThread(); //実行 Observable.Interval(TimeSpan.FromSeconds(1)).Subscribe(_ => { pyexe.p_WriteInputData("echo Message from C#"); }); }); Node clock = new Node("Clock", 1); root.AddChild(clock); Node clock_display = new Node("--:--", 1); clock.AddChild(clock_display); IDisposable clock_update = null; clock.AddCallback(() => { clock_update = Observable.Interval(TimeSpan.FromSeconds(0.1)).Subscribe(_ => { if (clock_display.speechBubble == null) { clock_update.Dispose(); return; } //clock_display.Text = DateTime.Now.ToShortTimeString(); clock_display.Text = DateTime.Now.ToLongTimeString(); }).AddTo(this); }); Node tool = new Node("Tool", 1); root.AddChild(tool); //Node bluetooth = new Node("Bluetooth\n ON"); //tool.AddChild(bluetooth); Node pyexecutor_interface = new Node("pyexecutor"); tool.AddChild(pyexecutor_interface); Node gui_start = new Node("GUIStart"); pyexecutor_interface.AddChild(gui_start); pyexe.AddCommand("launched", (mes) => { gui_start.Text = "GUI Launched"; }); gui_start.AddCallback(() => { gui_start.Text = "GUI Started"; pyexe.SendCmd("gui_start"); }); Node socketClientTest = new Node("SocketClient\nTest"); socketClientTest.AddCallback(() => { Task.Run(socketClient.ConnentionTest); }); tool.AddChild(socketClientTest); Node shutdown = new Node("Shutdown"); shutdown.AddCallback(() => { #if UNITY_EDITOR UnityEditor.EditorApplication.isPlaying = false; #elif UNITY_STANDALONE UnityEngine.Application.Quit(); #endif }); tool.AddChild(shutdown); Node speaktest = new Node("speaktest"); tool.AddChild(speaktest); Node title1 = new Node("精密計測工学2\n レポート"); speaktest.AddChild(title1); // Node title2 = new Node("精密計測工学2"); // speaktest.AddChild(title2); root.GenerateBubble(2); }
public Word Visit(SwitchNode switchNode) { ControlStack.Push(ControlType.Switch);//Push into control stack var result = switchNode.Flag.Accept(this); if (IsError(result)) { ControlStack.Pop(); return(result); } PyObj pyObjFlag; if (IsMemoryBlock(result))//comentar ese if else si se hace la desereferencia en atomic expr. { pyObjFlag = ((MemoryBlock)result).Value; } else { pyObjFlag = (PyObj)result; } //pyObj = (PyObj)result;//Descomentar esta linea si se hace la desereferencia en atomic expr. var switchElements = new AstNode[switchNode.SwitchElements.Count]; switchNode.SwitchElements.CopyTo(switchElements); //Caso que dio true a pyObjFlag cuando se comparar con == int? trueCaseIndex = null; int? defaultIndex = null; SwitchLabel switchLabel; PyObj pyObjCase; MyBoolean caseEvaluationResult; for (int i = 0; i < switchElements.Length; i++) { //Quitar comentario si se desea que no puedan venir declaraciones dentro del if //if (switchElements[i].GetNodeType() == NodeType.Declaration) //{ // ControlStack.Pop(); // return ErrorFactory.DeclarationInSwitch(switchElements[i]); //} if (switchElements[i].GetNodeType() != NodeType.SwitchLabel) { continue; } result = switchElements[i].Accept(this); if (IsError(result)) { ControlStack.Pop(); return(result); } switchLabel = (SwitchLabel)result; if (switchLabel.GetLabelType() == LabelType.Default) { if (defaultIndex != null) { ControlStack.Pop(); return(ErrorFactory.MultipleDefaultInSwitch(switchElements[i])); } else { defaultIndex = i; } } else { pyObjCase = switchLabel.Value; result = pyObjFlag.BinaryOperation(BinaryOperator.PyEquals, pyObjCase); if (IsError(result)) { ControlStack.Pop(); return(ErrorFactory.Create(switchElements[i], (MyError)result)); } if (((PyObj)result).GetMyType() != TypeConstants.BOOLEAN) { ControlStack.Pop(); return(ErrorFactory.NotValidOperationInSwitch(switchElements[i])); } caseEvaluationResult = (MyBoolean)result; if (caseEvaluationResult.Bool) { if (trueCaseIndex != null) { ControlStack.Pop(); return(ErrorFactory.MultipleTrueCasesInSwitch(switchElements[i])); } else { trueCaseIndex = i; } } } } int startIndex = switchElements.Length; if (trueCaseIndex != null) { startIndex = (int)trueCaseIndex; } else if (defaultIndex != null) { startIndex = (int)defaultIndex; } for (int i = startIndex; i < switchElements.Length; i++) { if (switchElements[i].GetNodeType() == NodeType.SwitchLabel) { continue; } result = switchElements[i].Accept(this); if (IsJumper(result)) { var jumper = (Jumper)result; if (jumper.CanJump(ControlType.Switch)) { if (!jumper.WasPopped())//Chapuz alto en el caso que retorne un jumper que no este metido dentro de ningun scope { ControlStack.Pop(); } return(null); } if (jumper.WasPopped())//Chapuz Alto para que no haga pop until mas de una vez cuando hay bloques adentro de bloques { return(jumper); } if (ControlStack.PopUntil(jumper)) { return(jumper); } else { ErrorFactory.NotValidJumper(switchElements[i], jumper); } } } return(null); }
protected StatementNode ParseStatement(List <Token> tokens, ref int index, CompilerNode owner) { BlockNode block = null; do { if (index >= tokens.Count) { throw new ParserException(tokens.Last(), ParserException.Kind.EndOfStream); } var token = tokens[index]; StatementNode statement = null; var type = GetTypeFromToken(owner, token.text); if (type != null) { var decl = new DeclarationNode(block); decl.type = type; index++; decl.identifier = ExpectIdentifier(tokens, ref index, false); if (ExpectOptional(tokens, ref index, "=")) { var node = new AssignmentNode(owner); node.identifier = decl.identifier; node.expr = ParseExpression(tokens, ref index, block); statement = node; } ExpectDelimiter(tokens, ref index, ";"); } else { switch (token.text) { case "{": { index++; block = new BlockNode(owner); owner = block; break; } case "return": { index++; var node = new ReturnNode(owner); node.expr = ParseExpression(tokens, ref index, node); ExpectDelimiter(tokens, ref index, ";"); statement = node; break; } case "if": { index++; ExpectDelimiter(tokens, ref index, "("); BlockNode parent = (block != null) ? block : owner as BlockNode; if (parent == null) { throw new ParserException(token, ParserException.Kind.UnexpectedToken); } var node = new IfNode(parent); node.expr = ParseExpression(tokens, ref index, parent); ExpectDelimiter(tokens, ref index, ")"); node.trueBranch = ParseStatement(tokens, ref index, parent); if (ExpectOptional(tokens, ref index, "else")) { node.falseBranch = ParseStatement(tokens, ref index, parent); } statement = node; break; } case "switch": { index++; var node = new SwitchNode(block); statement = node; ExpectDelimiter(tokens, ref index, "("); node.expr = ParseExpression(tokens, ref index, node); ExpectDelimiter(tokens, ref index, ")"); ExpectDelimiter(tokens, ref index, "{"); var keys = new HashSet <string>(); do { if (tokens[index].text == "}") { break; } if (ExpectOptional(tokens, ref index, "default")) { ExpectDelimiter(tokens, ref index, ":"); var st = ParseStatement(tokens, ref index, node); node.defaultBranch = st; } else { ExpectKeyword(tokens, ref index, "case"); LiteralKind litKind; var val = ExpectLiteral(tokens, ref index, out litKind); var key = val.ToString(); if (keys.Contains(key)) { throw new ParserException(tokens[index], ParserException.Kind.DuplicatedLabel); } var lit = new LiteralExpressionNode(node); lit.kind = litKind; lit.value = val; ExpectDelimiter(tokens, ref index, ":"); var st = ParseStatement(tokens, ref index, node); node.cases[lit] = st; keys.Add(key); } }while (true); ExpectDelimiter(tokens, ref index, "}"); break; } default: { throw new ParserException(tokens[index], ParserException.Kind.UnexpectedToken); } } } if (block == null) { return(statement); } else if (statement != null) { block.statements.Add(statement); } } while (tokens[index].text != "}"); index++; return(block); }