public void AddPointIfNotExists(JumpNode node) { if (!connectedNodes.Contains(node)) { connectedNodes.Add(node); } }
private void OnPatch(CodeNode node, JumpNode from, LivenessTarget ltCur, LivenessTarget ltUnused, BitArray bCur, int bLen, ref int retPtr) { for (; ;) { if (node.Liveness == null) { throw new ArgumentNullException(); } var bNode = node.Liveness; if (!bNode.AddBitsDelSource(bCur, bLen)) { OnDone(from, ltCur, ltUnused, bCur, bLen, ref retPtr); return; } if (node.Type == CodeNodeType.Label) { OnTarget(node, from, ltCur, ltUnused, bCur, bLen, ref retPtr); return; } if (node == _functionNode) { OnDone(from, ltCur, ltUnused, bCur, bLen, ref retPtr); return; } node = node.Previous; } }
public static void JumpNode() { var a = new JumpNode("label"); var b = SerializationUtil.Reserialize(a); Assert.AreEqual(a, b); }
private void CreateInstructionNode(InstructionId instructionId, Operand[] operands) { var options = _assembler.GetInstructionOptionsAndReset(); if (instructionId.IsJump()) { LabelNode target = null; JumpNode next = null; CodeNodeFlags flags = 0; if (!options.IsSet(InstructionOptions.Unfollow)) { if (operands[0].IsLabel()) { target = _assembler.GetLabelData(operands[0].Id).ContextData; } else { options |= InstructionOptions.Unfollow; } } flags |= instructionId == InstructionId.Jmp ? CodeNodeFlags.Jmp | CodeNodeFlags.Taken : CodeNodeFlags.Jcc; if (target != null) { next = target.From; } // The 'jmp' is always taken, conditional jump can contain hint, we detect it. if (instructionId == InstructionId.Jmp) { flags |= CodeNodeFlags.Taken; } else if (options.IsSet(InstructionOptions.Taken)) { flags |= CodeNodeFlags.Taken; } var node = new JumpNode(instructionId, options, operands); node.Flags |= flags; node.Target = target; if (target != null) { node.NextJump = next; target.From = node; target.ReferenceCount++; } AddNode(node); return; } var inst = new InstructionNode(instructionId, options, operands); AddNode(inst); }
public CompiledWhile() { compiledStatement = new NodeLinkedList(); condition = new NodeLinkedList(); body = new NodeLinkedList(); var conditionalJumpNode = new ConditionalJumpNode(compiledStatement.Last, body.First); var jumpBackNode = new JumpNode(compiledStatement.First); compiledStatement.Add(condition); compiledStatement.Add(conditionalJumpNode); // De body komt dus rechtstreeks na de conditionalJumpNode (dus op de .Next property) compiledStatement.Add(body); compiledStatement.Add(jumpBackNode); }
private void OnDone(JumpNode from, LivenessTarget ltCur, LivenessTarget ltUnused, BitArray bCur, int bLen, ref int retPtr) { CodeNode node; if (ltCur != null) { node = ltCur.Node; from = ltCur.From; OnTarget(node, from, ltCur, ltUnused, bCur, bLen, ref retPtr, true); return; } retPtr++; if (retPtr >= _variableContext.ReturningList.Count) { return; } node = _variableContext.ReturningList[retPtr]; OnVisit(node, @from, null, ltUnused, bCur, bLen, ref retPtr); }
private static CodeNode GetJccFlow(JumpNode jump) { return(jump.Flags.IsSet(CodeNodeFlags.Taken) ? jump.Target : jump.Next); }
public void Visit(JumpNode node) { NextNode = node.JumpToNode; }
public void visit(JumpNode jumpNode) { //devolgendenode = jumpNode.jump; }
public void AddPoint(JumpNode node) { connectedNodes.Add(node); node.AddPointIfNotExists(this); }
private void OnVisit(CodeNode node, JumpNode from, LivenessTarget ltCur, LivenessTarget ltUnused, BitArray bCur, int bLen, ref int retPtr) { for (; ;) { if (node.Liveness != null) { if (bCur.AddBitsDelSource(node.Liveness, bCur, bLen)) { OnPatch(node, from, ltCur, ltUnused, bCur, bLen, ref retPtr); return; } OnDone(from, ltCur, ltUnused, bCur, bLen, ref retPtr); return; } var bTmp = new BitArray(bLen); bTmp.CopyBits(bCur, bLen); node.Liveness = bTmp; var map = node.VariableMap; if (map != null) { var vaCount = map.Attributes.Length; var vaList = map.Attributes; for (var i = 0; i < vaCount; i++) { var va = vaList[i]; var vd = va.VariableData; var flags = va.Flags; var localId = vd.LocalId; if ((flags & VariableFlags.WAll) != 0 && (flags & VariableFlags.RAll) == 0) { // Write-Only. bTmp.SetBit(localId); bCur.DelBit(localId); } else { // Read-Only or Read/Write. bTmp.SetBit(localId); bCur.SetBit(localId); } } } if (node.Type == CodeNodeType.Label) { OnTarget(node, from, ltCur, ltUnused, bCur, bLen, ref retPtr); return; } if (node == _functionNode) { OnDone(from, ltCur, ltUnused, bCur, bLen, ref retPtr); return; } if (node.Previous == null) { throw new ArgumentNullException(); } node = node.Previous; } }
private void OnTarget(CodeNode node, JumpNode from, LivenessTarget ltCur, LivenessTarget ltUnused, BitArray bCur, int bLen, ref int retPtr, bool jumpNext = false) { var label = node.As <LabelNode>(); if (label.ReferenceCount != 0 || jumpNext) { if (!jumpNext) { // Push a new LivenessTarget onto the stack if needed. if (ltCur == null || ltCur.Node != node) { // Allocate a new LivenessTarget object (from pool or zone). var ltTmp = ltUnused; if (ltTmp != null) { ltUnused = ltUnused.Previous; } else { ltTmp = new LivenessTarget(); } // Initialize and make current - ltTmp->from will be set later on. ltTmp.Previous = ltCur; ltTmp.Node = label; ltCur = ltTmp; from = label.From; if (from == null) { throw new ArgumentNullException(); } } else { from = ltCur.From; OnTarget(node, from, ltCur, ltUnused, bCur, bLen, ref retPtr, true); return; // goto _OnJumpNext; } } // Visit/Patch. do { if (!jumpNext) { ltCur.From = from; bCur.CopyBits(node.Liveness, bLen); if (from.Liveness == null) { node = from; OnVisit(node, from, ltCur, ltUnused, bCur, bLen, ref retPtr); } // jumpNext = true; } // Issue #25: Moved '_OnJumpNext' here since it's important to patch // code again if there are more live variables than before. jumpNext = false; if (bCur.DelBits(from.Liveness, bLen)) { node = from; OnPatch(node, from, ltCur, ltUnused, bCur, bLen, ref retPtr); return; } from = from.NextJump; } while (from != null); { // Pop the current LivenessTarget from the stack. var ltTmp = ltCur; ltCur = ltCur.Previous; ltTmp.Previous = ltUnused; ltUnused = ltTmp; } } bCur.CopyBits(node.Liveness, bLen); node = node.Previous; if (node.Flags.IsSet(CodeNodeFlags.Jmp) || !node.IsFetched()) { OnDone(from, ltCur, ltUnused, bCur, bLen, ref retPtr); return; } if (node.Liveness == null) { OnVisit(node, from, ltCur, ltUnused, bCur, bLen, ref retPtr); return; } if (bCur.DelBits(node.Liveness, bLen)) { OnPatch(node, from, ltCur, ltUnused, bCur, bLen, ref retPtr); return; } OnDone(from, ltCur, ltUnused, bCur, bLen, ref retPtr); }
private Dictionary <char, JumpNode> computeGroups(int wordStartIndex, int wordEndIndex, string keys0, string prefix, List <JumpWord> jumpWords) { // SC-Tree algorithm from vim-easymotion script with minor changes var wordCount = wordEndIndex - wordStartIndex + 1; var keyCount = keys0.Length; Dictionary <char, JumpNode> groups = new Dictionary <char, JumpNode>(); var keys = keys0; //Reverse(keys0); var keyCounts = new int[keyCount]; var keyCountsKeys = new Dictionary <char, int>(keyCount); var j = 0; foreach (char key in keys) { keyCounts[j] = 0; keyCountsKeys[key] = j; j++; } var targetsLeft = wordCount; var level = 0; var i = 0; while (targetsLeft > 0) { var childrenCount = level == 0 ? 1 : keyCount - 1; foreach (char key in keys) { keyCounts[keyCountsKeys[key]] += childrenCount; targetsLeft -= childrenCount; if (targetsLeft <= 0) { keyCounts[keyCountsKeys[key]] += targetsLeft; break; } i += 1; } level += 1; } var k = 0; var keyIndex = 0; Array.Reverse(keyCounts); foreach (int KeyCount2 in keyCounts) { if (KeyCount2 > 1) { groups[keys[keyIndex]] = new JumpNode() { jumpWordIndex = -1, childrenNodes = computeGroups(wordStartIndex + k, wordStartIndex + k + KeyCount2 - 1, Reverse(string.Copy(keys)), prefix + keys[keyIndex], jumpWords) }; } else if (KeyCount2 == 1) { groups[keys[keyIndex]] = new JumpNode() { jumpWordIndex = wordStartIndex + k, childrenNodes = null }; var jw = jumpWords[wordStartIndex + k]; string jumpLabel = prefix + keys[keyIndex]; JumpLabelUserControl adornment = null; if (jw.windowFrame == null) // winframe=null => regular textview navigation. { #if MEASUREEXECTIME if (createAdornmentUIElem == null) { createAdornmentUIElem = Stopwatch.StartNew(); } else { createAdornmentUIElem.Start(); } #endif adornment = JumpLabelUserControl.GetFreeUserControl(); adornment.setup(jumpLabel, jw.adornmentBounds, this.jumpLabelCachedSetupParams); #if MEASUREEXECTIME createAdornmentUIElem.Stop(); #endif #if MEASUREEXECTIME if (adornmentCreateStopwatch == null) { adornmentCreateStopwatch = Stopwatch.StartNew(); } else { adornmentCreateStopwatch.Start(); } #endif //TraceLine("before AddAdornment"); this.layer.AddAdornment(AdornmentPositioningBehavior.TextRelative, jw.span, null, adornment, JumpLabelAdornmentRemovedCallback); #if DEBUG_LABEL_ALGO Trace.WriteLine($"POS={jw.textViewPosDbg,5} Adding jumplabel adornment"); #endif #if MEASUREEXECTIME adornmentCreateStopwatch.Stop(); #endif } //Debug.WriteLine(jw.text + " -> |" + jumpLabel + "|"); var cj = new Jump( span: jw.span, label: jumpLabel, labelAdornment: adornment, windowFrame: jw.windowFrame, vanillaTabCaption: jw.vanillaTabCaption, windowPrimaryTextView: jw.windowPrimaryTextView ); currentJumps.Add(cj); } else { continue; } keyIndex += 1; k += KeyCount2; } return(groups); }
void Update() { base.Update(); Vector2 result = Vector2.zero; if (_shootTimer > 0) { _shootTimer -= Time.deltaTime; } if (_player) { Vector2 playerPosition = _player.transform.position; Vector2 diff = playerPosition - (Vector2)transform.position; result += (Vector2)transform.right * (diff.x * moveVelocity) * Time.fixedDeltaTime; if (Mathf.Abs(result.x) > maxSpeed) { result.x = Mathf.Sign(result.x) * maxSpeed; } if (Mathf.Abs(diff.y) > 0.5f) { result.y = Physics2D.gravity.y * moveVelocity * Time.deltaTime; } if (_shootTimer <= 0f) { var target = Physics2D.Raycast((Vector2)transform.position + diff.normalized, diff.normalized, 15); if (!target.collider || target.collider.tag == "Player") { _bulletShooter.Shoot((Vector2)transform.position + diff.normalized, diff * shootForce); _shootTimer = shootCooldown; } } } else { if (targetNode == null) { JumpNode closest = null; float minDistance = float.PositiveInfinity; foreach (JumpNode node in _platformPathfinding.nodes) { if (node == null) { continue; } float dist = Vector2.Distance(node.transform.position, transform.position); if (dist < minDistance) { closest = node; minDistance = dist; } } if (closest != null) { targetNode = closest; } } else { if (Vector2.Distance(targetNode.transform.position, transform.position) < 0.5f) { int index = Enemy.rnd.Next(targetNode.connectedNodes.Count); targetNode = targetNode.connectedNodes[index]; isJumping = false; jumpTimer = 0f; } else { if (!isJumping && Mathf.Abs(targetNode.transform.position.y - transform.position.y) < 1f) { Vector2 diff = (Vector2)targetNode.transform.position - (Vector2)transform.position; result += (Vector2)transform.right * (diff.normalized.x * moveVelocity) * Time.fixedDeltaTime; if (Mathf.Abs(result.x) > maxSpeed) { result.x = Mathf.Sign(result.x) * maxSpeed; } } else { if (!isJumping) { jumpTimer = 0; startJumpPosition = transform.position; midJumpPosition = (startJumpPosition + (Vector2)targetNode.transform.position) / 2; midJumpPosition.y = targetNode.transform.position.y > startJumpPosition.y ? targetNode.transform.position.y + 2 : startJumpPosition.y + 2; isJumping = true; } if (jumpTimer >= 1f) { isJumping = false; } if (jumpTimer <= 1f) { Vector2 endPosition = targetNode.transform.position; Vector2 lerped = cubeBezier2(startJumpPosition, midJumpPosition, midJumpPosition, endPosition, jumpTimer); Vector2 diff = lerped - (Vector2)transform.position; _rb.position = lerped; jumpTimer += Time.deltaTime; } } } } } _rb.velocity = result; }