protected override void Visit(SpecialNode specialNode) { string name = NameUtility.GetName(specialNode.Element.Name); if (!this.SpecialNodeMap.ContainsKey(name)) { throw new CompilerException(string.Format("Unknown special node {0}", specialNode.Element.Name)); } Action <SpecialNode, SpecialNodeInspector> action = this.SpecialNodeMap[name]; action(specialNode, new SpecialNodeInspector(specialNode)); }
private void VisitUnless(SpecialNode specialNode, SpecialNodeInspector inspector) { var conditionAttr = inspector.TakeAttribute("condition") ?? inspector.TakeAttribute("unless"); var unlessChunk = new ConditionalChunk { Type = ConditionalType.Unless, Condition = AsCode(conditionAttr), Position = Locate(inspector.OriginalNode) }; Chunks.Add(unlessChunk); using (new Frame(this, unlessChunk.Body)) Accept(specialNode.Body); }
private void VisitGlobal(SpecialNode specialNode) { var typeAttr = specialNode.Element.Attributes.FirstOrDefault(attr => attr.Name == "type"); var type = typeAttr != null?AsCode(typeAttr) : (Snippets)"object"; foreach (var attr in specialNode.Element.Attributes.Where(a => a != typeAttr)) { AddUnordered(new GlobalVariableChunk { Type = type, Name = attr.Name, Value = AsTextOrientedCode(attr) }); } }
public void VisitNode(INodeVisitor visitor, IList <Node> body, IList <Chunk> chunks) { var registerTarget = string.Format( @"RegisterTarget(""{0}"", ""{1}"", ""{2}"", __target_{3});", _idAttribute.Value, _classAttribute != null ? _classAttribute.Value : "", _descriptionAttribute != null ? _descriptionAttribute.Value : "", _targetExtensionCount); if (_targetAttribute != null) { registerTarget += Environment.NewLine + string.Format( @"RegisterTarget(""{0}"", ""{1}"", null, null);", _targetAttribute.Value, _idAttribute.Value); } var beginLambda = string.Format( @"__target_{0} = () => {{", _targetExtensionCount); const string endLambda = "};"; var startingTarget = string.Format( @"StartingTarget(""{0}"");", _idAttribute.Value); var nameAttribute = new AttributeNode("name", _idAttribute.QuotChar, _idAttribute.Nodes) { OriginalNode = _idAttribute }; var macroAttributes = _targetElement.Attributes .Where(x => x != _idAttribute && x != _classAttribute && x != _descriptionAttribute) .Concat(new[] { nameAttribute }) .ToList(); var macroElement = new SpecialNode(new ElementNode("macro", macroAttributes, false)); var onceAttribute = new AttributeNode("once", _idAttribute.QuotChar, _idAttribute.Nodes); var testElement = new SpecialNode(new ElementNode("test", new[] { onceAttribute }, false)); macroElement.Body.Add(testElement); testElement.Body = body; testElement.Body.Insert(0, new StatementNode(startingTarget)); visitor.Accept(new StatementNode(beginLambda)); visitor.Accept(testElement); visitor.Accept(new StatementNode(endLambda)); visitor.Accept(new StatementNode(registerTarget)); }
protected override void Visit(SpecialNode specialNode) { string name = NameUtility.GetName(specialNode.Element.Name); if (!string.IsNullOrEmpty(specialNode.Element.PreceedingWhitespace) && this.specialNodeMap.ContainsKey(name)) { var action = this.specialNodeMap[name]; action(specialNode, new SpecialNodeInspector(specialNode)); } base.Visit(specialNode); }
private void VisitUnless(SpecialNode specialNode, SpecialNodeInspector inspector) { AttributeNode attr = inspector.TakeAttribute("condition") ?? inspector.TakeAttribute("unless"); ConditionalChunk item = new ConditionalChunk { Type = ConditionalType.Unless, Condition = this.AsCode(attr), Position = this.Locate(inspector.OriginalNode) }; this.Chunks.Add(item); using (new Frame(this, item.Body)) { base.Accept(specialNode.Body); } }
protected void VisitIf(SpecialNode specialNode, SpecialNodeInspector inspector) { if (!this.FirstChildBeginsWithNewline(specialNode)) { List <Node> list = new List <Node> { new TextNode(specialNode.Element.PreceedingWhitespace) }; if (specialNode.Body != null) { list.AddRange(specialNode.Body); } specialNode.Body = list; } specialNode.Element.PreceedingWhitespace = string.Empty; }
protected override void Visit(SpecialNode specialNode) { var inspector = new SpecialNodeInspector(specialNode); if (inspector.Name == "use") { var file = inspector.TakeAttribute("file"); if (file != null) { References.Add(new FileReference { File = file.Value, UseFileNode = specialNode }); } } Accept(specialNode.Body); }
public LinkedNodeList() { head = new SpecialNode(); head.prev = new SpecialNode(); head.prev.name = ""; head.path = "€"; head.name = parents[parentIndex++]; head.selfLoopPS = string.Empty; head.targetLoopPS = string.Empty; head.targetLoopName = string.Empty; head.next = new List <SpecialNode>(); NCGG = new NodeChart(); lastStates = new List <string>(); current = head; }
/// <summary> /// The decode nas list. /// </summary> /// <param name="asnCode"> /// The asn code. /// </param> /// <param name="speValue"> /// The spe value. /// </param> /// <returns> /// The <see cref="string"/>. /// </returns> private string DecodeNasList(string asnCode, SpecialNode speValue) { var nasList = this.GetNasList(asnCode, speValue.DecodePort); var nasDecoder = this.GetDecoder(speValue.DecodeDll); foreach (var nasStream in nasList) { var stream = this.DecodeByteStream(nasStream, nasDecoder, speValue.DecodePdu); var nasString = "(需二次解析码流)" + nasStream; asnCode = asnCode.Replace(nasStream, nasString); asnCode = asnCode + '\n' + stream; } return(asnCode); }
private void VisitElseIf(SpecialNode specialNode, SpecialNodeInspector inspector) { if (!SatisfyElsePrecondition()) { throw new CompilerException("An 'elseif' may only follow an 'if' or 'elseif'."); } var conditionAttr = inspector.TakeAttribute("condition"); var elseIfChunk = new ConditionalChunk { Type = ConditionalType.ElseIf, Condition = AsCode(conditionAttr), Position = Locate(inspector.OriginalNode) }; Chunks.Add(elseIfChunk); using (new Frame(this, elseIfChunk.Body)) Accept(specialNode.Body); }
public void Fill_in_argument_by_type_with_ObjectFactory() { ObjectFactory.Initialize(x => { x.For <IView>().Use <View>(); }); var theNode = new SpecialNode(); var theTrade = new Trade(); var command = ObjectFactory.Container .With(typeof(Node), theNode) .With(theTrade) .GetInstance <Command>(); command.View.ShouldBeOfType <View>(); theNode.ShouldBeTheSameAs(command.Node); theTrade.ShouldBeTheSameAs(command.Trade); }
SpecialNode CreateTailNode(int x, int y) { SpecialNode spNode = new SpecialNode(); spNode.node = GetNode(x, y); spNode.obj = new GameObject(); spNode.obj.transform.parent = tailParent.transform; spNode.obj.transform.position = spNode.node.worldPosition; spNode.obj.transform.localScale = Vector3.one * .95f; SpriteRenderer renderer = spNode.obj.AddComponent <SpriteRenderer>(); renderer.sprite = playerSprite; renderer.sortingOrder = 1; return(spNode); }
protected void VisitIf(SpecialNode specialNode, SpecialNodeInspector inspector) { if (!FirstChildBeginsWithNewline(specialNode)) { var newBody = new List <Node>(); newBody.Add(new TextNode(specialNode.Element.PreceedingWhitespace)); if (specialNode.Body != null) { newBody.AddRange(specialNode.Body); } specialNode.Body = newBody; } specialNode.Element.PreceedingWhitespace = string.Empty; }
public void Fill_in_argument_by_type_with_Container() { var container = new Container(x => x.For <IView>().Use <View>()); var theNode = new SpecialNode(); var theTrade = new Trade(); var command = container .With(typeof(Node), theNode) .With(theTrade) .GetInstance <Command>(); command.View.ShouldBeOfType <View>(); theNode.ShouldBeTheSameAs(command.Node); theTrade.ShouldBeTheSameAs(command.Trade); }
public void Fill_in_argument_by_type() { var container = new Container(x => { x.ForRequestedType <IView>().TheDefaultIsConcreteType <View>(); }); var theNode = new SpecialNode(); var theTrade = new Trade(); var command = container .With(typeof(Node), theNode) .With(theTrade) .GetInstance <Command>(); Assert.IsInstanceOfType(typeof(View), command.View); Assert.AreSame(theNode, command.Node); Assert.AreSame(theTrade, command.Trade); }
public void Fill_in_argument_by_type_with_ObjectFactory() { ObjectFactory.Initialize(x => { x.ForRequestedType <IView>().TheDefaultIsConcreteType <View>(); }); var theNode = new SpecialNode(); var theTrade = new Trade(); var command = ObjectFactory .With(typeof(Node), theNode) .With(theTrade) .GetInstance <Command>(); Assert.IsInstanceOfType(typeof(View), command.View); Assert.AreSame(theNode, command.Node); Assert.AreSame(theTrade, command.Trade); }
private void VisitGlobal(SpecialNode specialNode) { AttributeNode typeAttr = specialNode.Element.Attributes.FirstOrDefault <AttributeNode>(attr => attr.Name == "type"); Snippets snippets = (typeAttr != null) ? this.AsCode(typeAttr) : "object"; foreach (AttributeNode node in from a in specialNode.Element.Attributes where a != typeAttr select a) { GlobalVariableChunk chunk = new GlobalVariableChunk { Type = snippets, Name = node.Name, Value = this.AsTextOrientedCode(node) }; this.AddUnordered(chunk); } }
private void VisitIf(SpecialNode specialNode, SpecialNodeInspector inspector) { var conditionAttr = inspector.TakeAttribute("condition") ?? inspector.TakeAttribute("if"); var onceAttr = inspector.TakeAttribute("once"); if (conditionAttr == null && onceAttr == null) { throw new CompilerException("Element must contain an if, condition, or once attribute"); } Frame ifFrame = null; if (conditionAttr != null) { var ifChunk = new ConditionalChunk { Type = ConditionalType.If, Condition = AsCode(conditionAttr), Position = Locate(inspector.OriginalNode) }; Chunks.Add(ifChunk); ifFrame = new Frame(this, ifChunk.Body); } Frame onceFrame = null; if (onceAttr != null) { var onceChunk = new ConditionalChunk { Type = ConditionalType.Once, Condition = onceAttr.AsCodeInverted(), Position = Locate(inspector.OriginalNode) }; Chunks.Add(onceChunk); onceFrame = new Frame(this, onceChunk.Body); } Accept(specialNode.Body); if (onceFrame != null) { onceFrame.Dispose(); } if (ifFrame != null) { ifFrame.Dispose(); } }
private void PopSpecial(string name) { if (this._stack.Count == 0) { throw new CompilerException(string.Format("Unexpected end element {0}", name)); } this._nodes = this._stack.Pop(); SpecialNode node = this.Nodes.Last <Node>() as SpecialNode; if (node == null) { throw new CompilerException(string.Format("Unexpected end element {0}", name)); } if (node.Element.Name != name) { throw new CompilerException(string.Format("End element {0} did not match {1}", name, node.Element.Name)); } }
private void VisitElseIf(SpecialNode specialNode, SpecialNodeInspector inspector) { if (!this.SatisfyElsePrecondition()) { throw new CompilerException("An 'elseif' may only follow an 'if' or 'elseif'."); } AttributeNode attr = inspector.TakeAttribute("condition"); ConditionalChunk item = new ConditionalChunk { Type = ConditionalType.ElseIf, Condition = this.AsCode(attr), Position = this.Locate(inspector.OriginalNode) }; this.Chunks.Add(item); using (new Frame(this, item.Body)) { base.Accept(specialNode.Body); } }
private void VisitIf(SpecialNode specialNode, SpecialNodeInspector inspector) { AttributeNode attr = inspector.TakeAttribute("condition") ?? inspector.TakeAttribute("if"); AttributeNode node2 = inspector.TakeAttribute("once"); if ((attr == null) && (node2 == null)) { throw new CompilerException("Element must contain an if, condition, or once attribute"); } Frame frame = null; if (attr != null) { ConditionalChunk item = new ConditionalChunk { Type = ConditionalType.If, Condition = this.AsCode(attr), Position = this.Locate(inspector.OriginalNode) }; this.Chunks.Add(item); frame = new Frame(this, item.Body); } Frame frame2 = null; if (node2 != null) { ConditionalChunk chunk3 = new ConditionalChunk { Type = ConditionalType.Once, Condition = node2.AsCodeInverted(), Position = this.Locate(inspector.OriginalNode) }; this.Chunks.Add(chunk3); frame2 = new Frame(this, chunk3.Body); } base.Accept(specialNode.Body); if (frame2 != null) { frame2.Dispose(); } if (frame != null) { frame.Dispose(); } }
private bool FirstChildBeginsWithNewline(SpecialNode node) { if (node == null || node.Body == null || node.Body.Count == 0) { return(false); } var firstChild = node.Body[0]; if (firstChild == null) { return(false); } var textNode = firstChild as TextNode; if (textNode != null) { return(textNode.Text.IndexOf("\r\n") == 0 || textNode.Text.IndexOf("\n") == 0); } var elementNode = firstChild as ElementNode; if (elementNode == null) { var specialNode = firstChild as SpecialNode; if (specialNode != null) { elementNode = specialNode.Element; } } if (elementNode != null) { return(elementNode.PreceedingWhitespace.IndexOf("\r\n") == 0 || elementNode.PreceedingWhitespace.IndexOf("\n") == 0); } return(false); }
private bool FirstChildBeginsWithNewline(SpecialNode node) { if (((node == null) || (node.Body == null)) || (node.Body.Count == 0)) { return(false); } Node node2 = node.Body[0]; if (node2 == null) { return(false); } TextNode node3 = node2 as TextNode; if (node3 != null) { if (node3.Text.IndexOf("\r\n") != 0) { return(node3.Text.IndexOf("\n") == 0); } return(true); } ElementNode element = node2 as ElementNode; if (element == null) { SpecialNode node5 = node2 as SpecialNode; if (node5 != null) { element = node5.Element; } } if (element == null) { return(false); } if (element.PreceedingWhitespace.IndexOf("\r\n") != 0) { return(element.PreceedingWhitespace.IndexOf("\n") == 0); } return(true); }
private void PopSpecial(string name) { if (_stack.Count == 0) { throw new CompilerException(string.Format("Unexpected end element {0}", name)); } _nodes = _stack.Pop(); SpecialNode special = Nodes.Last() as SpecialNode; if (special == null) { throw new CompilerException(string.Format("Unexpected end element {0}", name)); } if (special.Element.Name != name) { throw new CompilerException(string.Format("End element {0} did not match {1}", name, special.Element.Name)); } }
private void VisitCache(SpecialNode specialNode, SpecialNodeInspector inspector) { var keyAttr = inspector.TakeAttribute("key"); var expiresAttr = inspector.TakeAttribute("expires"); var signalAttr = inspector.TakeAttribute("signal"); var chunk = new CacheChunk { Position = Locate(specialNode.Element) }; if (keyAttr != null) { chunk.Key = AsCode(keyAttr); } else { chunk.Key = "\"\""; } if (expiresAttr != null) { chunk.Expires = AsCode(expiresAttr); } else { chunk.Expires = ""; } if (signalAttr != null) { chunk.Signal = AsCode(signalAttr); } else { chunk.Signal = ""; } Chunks.Add(chunk); using (new Frame(this, chunk.Body)) Accept(inspector.Body); }
public void AddChild(SpecialNode n, bool gotoNext) { if (gotoNext) { current.next.Add(n); if (current == head) { current = current.next[Yrow]; } else { current = current.next[0]; } current.next = new List <SpecialNode>(); } else { current.next.Add(n); if (current == head) { current = current.next[Yrow]; } else { current = current.next[0]; } SpecialNode garbageNode = new SpecialNode(); garbageNode.name = parents[parentIndex++]; garbageNode.next = null; garbageNode.prev = current; garbageNode.path = "€"; garbageNode.targetLoopName = string.Empty; garbageNode.targetLoopPS = string.Empty; garbageNode.selfLoopPS = ""; garbageNode.isFinal = false; current.next = new List <SpecialNode>(); current.next.Add(garbageNode); lastStates.Add(garbageNode.name); } }
protected override void Visit(ExtensionNode node) { ExtensionNode item = new ExtensionNode(node.Element, node.Extension); AttributeNode node3 = item.Element.Attributes.FirstOrDefault <AttributeNode>(attr => this.IsSpecialAttribute(node.Element, attr)); if (node3 != null) { SpecialNode node4 = this.CreateWrappingNode(node3, item.Element); item.Element.Attributes.Remove(node3); this.Nodes.Add(node4); base.PushFrame(node4.Body, new Frame()); } this.Nodes.Add(item); base.PushFrame(item.Body, new Frame()); base.Accept(node.Body); base.PopFrame(); if (node3 != null) { base.PopFrame(); } }
private void VisitFor(SpecialNode specialNode, SpecialNodeInspector inspector) { var eachAttr = inspector.TakeAttribute("each"); var forEachChunk = new ForEachChunk { Code = AsCode(eachAttr), Position = Locate(specialNode.Element) }; Chunks.Add(forEachChunk); using (new Frame(this, forEachChunk.Body)) { foreach (var attr in inspector.Attributes) { Chunks.Add(new AssignVariableChunk { Name = attr.Name, Value = AsCode(attr), Position = Locate(attr) }); } Accept(specialNode.Body); } }
private TreeNode CreateNode(SpecialNode specialNode) { var treeNode = new TreeNode(); treeNode.Tag = specialNode; switch (specialNode) { case SpecialNode.DummyNode: treeNode.Text = "Dummy"; break; case SpecialNode.DirectCopiesRecursive: treeNode.Text = "Direct copies (recursive)"; break; case SpecialNode.DirectCopies: treeNode.Text = "Direct copies"; break; case SpecialNode.Reads: treeNode.Text = "Other variables in operations reading this variable"; break; case SpecialNode.Writes: treeNode.Text = "Other variables in operations writing to this variable"; break; default: treeNode.Text = "Invalid Node"; specialNode = SpecialNode.Invalid; treeNode.Tag = specialNode; break; } if (specialNode != SpecialNode.DummyNode && specialNode != SpecialNode.Invalid) { treeNode.Nodes.Add(CreateNode(SpecialNode.DummyNode)); } return(treeNode); }
public void Fill_in_argument_by_type_with_ObjectFactory() { ObjectFactory.Initialize(x => { x.For<IView>().Use<View>(); }); var theNode = new SpecialNode(); var theTrade = new Trade(); var command = ObjectFactory.Container .With(typeof (Node), theNode) .With(theTrade) .GetInstance<Command>(); command.View.ShouldBeOfType<View>(); theNode.ShouldBeTheSameAs(command.Node); theTrade.ShouldBeTheSameAs(command.Trade); }
public void Fill_in_argument_by_type() { var container = new Container(x => { x.For<IView>().Use<View>(); }); var theNode = new SpecialNode(); var theTrade = new Trade(); var command = container .With(typeof (Node), theNode) .With(theTrade) .GetInstance<Command>(); command.View.ShouldBeOfType<View>(); theNode.ShouldBeTheSameAs(command.Node); theTrade.ShouldBeTheSameAs(command.Trade); }
public void Fill_in_argument_by_type() { var container = new Container(x => { x.ForRequestedType<IView>().TheDefaultIsConcreteType<View>(); }); var theNode = new SpecialNode(); var theTrade = new Trade(); var command = container .With(typeof (Node), theNode) .With(theTrade) .GetInstance<Command>(); Assert.IsInstanceOfType(typeof (View), command.View); Assert.AreSame(theNode, command.Node); Assert.AreSame(theTrade, command.Trade); }
public void Fill_in_argument_by_type_with_ObjectFactory() { ObjectFactory.Initialize(x => { x.ForRequestedType<IView>().TheDefaultIsConcreteType<View>(); }); var theNode = new SpecialNode(); var theTrade = new Trade(); var command = ObjectFactory .With(typeof (Node), theNode) .With(theTrade) .GetInstance<Command>(); Assert.IsInstanceOfType(typeof (View), command.View); Assert.AreSame(theNode, command.Node); Assert.AreSame(theTrade, command.Trade); }