internal GreenNode ToListNode() { switch (this.Count) { case 0: return(null); case 1: return(_nodes[0].Value); case 2: return(InternalSyntax.SyntaxList.List(_nodes[0].Value, _nodes[1].Value)); case 3: return(InternalSyntax.SyntaxList.List(_nodes[0].Value, _nodes[1].Value, _nodes[2].Value)); default: var tmp = new ArrayElement <GreenNode> [this.Count]; for (int i = 0; i < this.Count; i++) { tmp[i].Value = _nodes[i].Value; } return(InternalSyntax.SyntaxList.List(tmp)); } }
public static object LinyeeMRealloc <T>(LinyeeState L, T[] old_block, int new_size) { int unmanaged_size = (int)GetUnmanagedSize(typeof(T)); int old_size = (old_block == null) ? 0 : old_block.Length; int osize = old_size * unmanaged_size; int nsize = new_size * unmanaged_size; T[] new_block = new T[new_size]; for (int i = 0; i < Math.Min(old_size, new_size); i++) { new_block[i] = old_block[i]; } for (int i = old_size; i < new_size; i++) { new_block[i] = (T)System.Activator.CreateInstance(typeof(T)); } if (CanIndex(typeof(T))) { for (int i = 0; i < new_size; i++) { ArrayElement elem = new_block[i] as ArrayElement; Debug.Assert(elem != null, String.Format("Need to derive type {0} from ArrayElement", typeof(T).ToString())); elem.SetIndex(i); elem.SetArray(new_block); } } SubtractTotalBytes(L, osize); AddTotalBytes(L, nsize); return(new_block); }
internal WithManyChildrenBase(ObjectReader reader) : base(reader) { this.children = ArrayElement <CSharpSyntaxNode> .MakeElementArray((CSharpSyntaxNode[])reader.ReadValue()); this.InitializeChildren(); }
private void AddLexedTokenSlot() { // shift tokens to left if we are far to the right // don't shift if reset points have fixed locked tge starting point at the token in the window if (this.tokenOffset > (this.lexedTokens.Length >> 1) && (this.resetStart == -1 || this.resetStart > this.firstToken)) { int shiftOffset = (this.resetStart == -1) ? this.tokenOffset : this.resetStart - this.firstToken; int shiftCount = this.tokenCount - shiftOffset; Debug.Assert(shiftOffset > 0); if (shiftCount > 0) { Array.Copy(this.lexedTokens, shiftOffset, this.lexedTokens, 0, shiftCount); } this.firstToken += shiftOffset; this.tokenCount -= shiftOffset; this.tokenOffset -= shiftOffset; } else { var tmp = new ArrayElement <SyntaxToken> [this.lexedTokens.Length * 2]; Array.Copy(this.lexedTokens, tmp, this.lexedTokens.Length); this.lexedTokens = tmp; } }
private void Grow() { var tmp = new ArrayElement <SyntaxListBuilder> [freeList.Length * 2]; Array.Copy(freeList, tmp, freeList.Length); freeList = tmp; }
private void Grow(int size) { var tmp = new ArrayElement <GreenNode> [size]; Array.Copy(_nodes, tmp, _nodes.Length); _nodes = tmp; }
/// <summary> /// Combine a set of array elements to form a multi-draw compatible element. /// </summary> /// <param name="multiElements"> /// A <see cref="IEnumerable{IElement}"/> that specifies all elements to be drawn using multi-draw /// primitive. /// </param> /// <returns> /// It returns a <see cref="IElement"/> that allow drawing <paramref name="multiElements"/> at once /// using the multi-draw primitive. /// </returns> public IElement CombineArrayElements(IEnumerable <IElement> multiElements) { if (multiElements == null) { throw new ArgumentNullException("multiElements"); } List <int> multiOffsets = new List <int>(); List <int> multiCounts = new List <int>(); PrimitiveType?multiPrimitive = null; foreach (IElement element in multiElements) { ArrayElement arrayElement = (ArrayElement)element; if (multiPrimitive.HasValue && (multiPrimitive.Value != arrayElement.ElementsMode)) { throw new ArgumentException("multi-draw with multiple element modes", "multiElements"); } multiPrimitive = arrayElement.ElementsMode; multiOffsets.Add((int)arrayElement.ElementOffset); multiCounts.Add((int)arrayElement.ElementCount); } if (multiPrimitive.HasValue == false) { throw new ArgumentException("no items", "multiElements"); } return(new MultiArrayElement(this, multiPrimitive.Value, multiOffsets.ToArray(), multiCounts.ToArray())); }
/// <summary> /// Initializes a new instance of the <see cref="WithManyChildrenBase"/> class. /// </summary> /// <param name="children">An array containing the list's children.</param> internal WithManyChildrenBase(ArrayElement<SyntaxNode>[] children) { SlotCount = children.Length; this.children = children; for (int i = 0; i < children.Length; i++) ChangeParent(children[i]); }
internal static GreenNode List(GreenNode[] nodes, int count) { ArrayElement <GreenNode>[] array = new ArrayElement <GreenNode> [count]; for (int i = 0; i < count; i++) { Debug.Assert(nodes[i] != null); array[i].Value = nodes[i]; } return(List(array)); }
internal static CSharpSyntaxNode List(CSharpSyntaxNode[] nodes, int count) { var array = new ArrayElement<CSharpSyntaxNode>[count]; for (int i = 0; i < count; i++) { Debug.Assert(nodes[i] != null); array[i].Value = nodes[i]; } return List(array); }
/// <summary> /// Initializes a new instance of the <see cref="WithManyChildrenBase"/> class from /// the specified binary reader. /// </summary> /// <param name="reader">The binary reader with which to deserialize the object.</param> /// <param name="version">The file version of the data being read.</param> internal WithManyChildrenBase(BinaryReader reader, Int32 version) : base(reader, version) { var children = reader.ReadSyntaxNodeArray(version); if (children != null) { for (int i = 0; i < children.Length; i++) ChangeParent(children[i]); } this.children = children; }
internal static CSharpSyntaxNode List(CSharpSyntaxNode[] nodes, int count) { var array = new ArrayElement <CSharpSyntaxNode> [count]; for (int i = 0; i < count; i++) { Debug.Assert(nodes[i] != null); array[i].Value = nodes[i]; } return(List(array)); }
internal static SyntaxList List(SyntaxNode[] nodes, int count) { var array = new ArrayElement<SyntaxNode>[count]; Debug.Assert(array.Length == count); for (var i = 0; i < count; i++) { array[i].Value = nodes[i]; Debug.Assert(array[i].Value != null); } return List(array); }
private static int[] CalculateOffsets(ArrayElement<CSharpSyntaxNode>[] children) { int n = children.Length; var childOffsets = new int[n]; int offset = 0; for (int i = 0; i < n; i++) { childOffsets[i] = offset; offset += children[i].Value.FullWidth; } return childOffsets; }
public void SetCommentToUriParameters(ArrayElement uriParameters, ApiDescription api) { if (Cannavigator() && api.ActionDescriptor is ControllerActionDescriptor controller) { var id = GetCommentIdForMethod(controller.MethodInfo); var methodNode = navigator.SelectSingleNode(string.Format(MemberXPath, id)); if (methodNode == null) { return; } ApplyParamsXmlToActionParameters(uriParameters, methodNode); } }
private void ApplyResponsesXmlToResponses(ArrayElement responses, XPathNodeIterator responseNodes) { while (responseNodes.MoveNext()) { var code = responseNodes.Current.GetAttribute("code", ""); var response = responses.TryGetElement <Response>(code); if (response == null) { continue; } response.Description.Value = XmlCommentsTextHelper.Humanize(responseNodes.Current.InnerXml); } }
internal WithManyChildrenBase(ObjectReader reader) : base(reader) { var length = reader.ReadInt32(); this.children = new ArrayElement<GreenNode>[length]; for (var i = 0; i < length; i++) { this.children[i].Value = (GreenNode)reader.ReadValue(); } this.InitializeChildren(); }
internal static SyntaxList List(ArrayElement<CSharpSyntaxNode>[] children) { // "WithLotsOfChildren" list will alocate a separate array to hold // precomputed node offsets. It may not be worth it for smallish lists. if (children.Length < 10) { return new WithManyChildren(children); } else { return new WithLotsOfChildren(children); } }
internal static GreenNode List(GreenNode?[] nodes, int count) { var array = new ArrayElement <GreenNode> [count]; for (int i = 0; i < count; i++) { var node = nodes[i]; RoslynDebug.Assert(node is object); array[i].Value = node; } return(List(array)); }
private void ApplyParamsXmlToActionParameters(ArrayElement queryParameters, XPathNavigator methodNode) { if (!queryParameters.HasElements) { return; } foreach (var item in queryParameters.Elements) { var paramNode = methodNode.SelectSingleNode(string.Format(ParamXPath, item.Key)); if (paramNode != null && item is Parameter p) { p.Description.Value = XmlCommentsTextHelper.Humanize(paramNode.InnerXml); } } }
//NOTE: there is no opposite conversion operator T -> ArrayElement<T> // // that is because it is preferred to update array elements in-place // "elements[i].Value = v" results in much better code than "elements[i] = (ArrayElement<T>)v" // // The reason is that x86 ABI requires that structs must be returned in // a return buffer even if they can fit in a register like this one. // Also since struct contains a reference, the write to the buffer is done with a checked GC barrier // as JIT does not know if the write goes to a stack or a heap location. // Assigning to Value directly easily avoids all this redundancy. public static ArrayElement <T>[] MakeElementArray(T[] items) { if (items == null) { return(null); } var array = new ArrayElement <T> [items.Length]; for (var i = 0; i < items.Length; i++) { array[i].Value = items[i]; } return(array); }
public void TestIfMarshallerConvertsBetweenTheSameTypeStructureOnlyArrayInsteadOfLists() { ListElement element = new ListElement(); element.stringelements = new List <string>() { "Test", "Test1" }; element.intelements = new int[] { 1, 2, 3 }; String marshalledResult = marshaller.MarshallObject(element); ArrayElement result = marshaller.UnmarshallObject <ArrayElement>(marshalledResult); foreach (String stringelement in result.stringelements) { Assert.IsNotNull(element.stringelements.Find(e => stringelement.Equals(e))); } }
public void TestIfMarshallerConvertsBetweenTheSameTypeStructureOnlyListInsteadOfArray() { ArrayElement element = new ArrayElement(); element.stringelements = new String[] { "Test", "Test1" }; element.intelements = new List<int>() { 1, 2, 3 }; String marshalledResult = marshaller.MarshallObject(element); ListElement result = marshaller.UnmarshallObject<ListElement>(marshalledResult); Assert.AreEqual<int>(element.stringelements.Length, result.stringelements.Count); foreach (String stringelement in element.stringelements) { Assert.IsNotNull(result.stringelements.Find(e => stringelement.Equals(e))); } }
internal WithManyWeakChildren(InternalSyntax.SyntaxList.WithManyChildrenBase green, SyntaxNode parent, int position) : base(green, parent, position) { int count = green.SlotCount; _children = new ArrayElement<WeakReference<SyntaxNode>>[count]; var childOffsets = new int[count]; int childPosition = position; var greenChildren = green.children; for (int i = 0; i < childOffsets.Length; ++i) { childOffsets[i] = childPosition; childPosition += greenChildren[i].Value.FullWidth; } _childPositions = childOffsets; }
public SyntaxTriviaList ToList() { if (this._count > 0) { if (this._previous != null) { this.Grow(this._count); } switch (this._count) { case 1: return(new SyntaxTriviaList(default(SyntaxToken), _nodes[0].UnderlyingNode, position: 0, index: 0)); case 2: return(new SyntaxTriviaList(default(SyntaxToken), Syntax.InternalSyntax.SyntaxList.List( (Syntax.InternalSyntax.CSharpSyntaxNode)_nodes[0].UnderlyingNode, (Syntax.InternalSyntax.CSharpSyntaxNode)_nodes[1].UnderlyingNode), position: 0, index: 0)); case 3: return(new SyntaxTriviaList(default(SyntaxToken), Syntax.InternalSyntax.SyntaxList.List( (Syntax.InternalSyntax.CSharpSyntaxNode)_nodes[0].UnderlyingNode, (Syntax.InternalSyntax.CSharpSyntaxNode)_nodes[1].UnderlyingNode, (Syntax.InternalSyntax.CSharpSyntaxNode)_nodes[2].UnderlyingNode), position: 0, index: 0)); default: { var tmp = new ArrayElement <Syntax.InternalSyntax.CSharpSyntaxNode> [_count]; for (int i = 0; i < this._count; i++) { tmp[i].Value = (Syntax.InternalSyntax.CSharpSyntaxNode) this._nodes[i].UnderlyingNode; } return(new SyntaxTriviaList(default(SyntaxToken), Syntax.InternalSyntax.SyntaxList.List(tmp), position: 0, index: 0)); } } } else { return(default(SyntaxTriviaList)); } }
internal static GreenNode Concat(GreenNode left, GreenNode right) { if (left == null) { return(right); } if (right == null) { return(left); } var leftList = left as SyntaxList; var rightList = right as SyntaxList; if (leftList != null) { if (rightList != null) { var tmp = new ArrayElement <GreenNode> [left.SlotCount + right.SlotCount]; leftList.CopyTo(tmp, 0); rightList.CopyTo(tmp, left.SlotCount); return(List(tmp)); } else { var tmp = new ArrayElement <GreenNode> [left.SlotCount + 1]; leftList.CopyTo(tmp, 0); tmp[left.SlotCount].Value = right; return(List(tmp)); } } else if (rightList != null) { var tmp = new ArrayElement <GreenNode> [rightList.SlotCount + 1]; tmp[0].Value = left; rightList.CopyTo(tmp, 1); return(List(tmp)); } else { return(List(left, right)); } }
public void TestIfMarshallerConvertsBetweenTheSameTypeStructureOnlyListInsteadOfArray() { ArrayElement element = new ArrayElement(); element.stringelements = new String[] { "Test", "Test1" }; element.intelements = new List <int>() { 1, 2, 3 }; String marshalledResult = marshaller.MarshallObject(element); ListElement result = marshaller.UnmarshallObject <ListElement>(marshalledResult); Assert.AreEqual <int>(element.stringelements.Length, result.stringelements.Count); foreach (String stringelement in element.stringelements) { Assert.IsNotNull(result.stringelements.Find(e => stringelement.Equals(e))); } }
public SyntaxNodeOrTokenList ToList() { if (_count > 0) { switch (_count) { case 1: if (_nodes[0].IsToken) { return(new SyntaxNodeOrTokenList( InternalSyntax.SyntaxList.List(new[] { _nodes[0] }).CreateRed(), index: 0)); } else { return(new SyntaxNodeOrTokenList(_nodes[0].CreateRed(), index: 0)); } case 2: return(new SyntaxNodeOrTokenList( InternalSyntax.SyntaxList.List(_nodes[0], _nodes[1]).CreateRed(), index: 0)); case 3: return(new SyntaxNodeOrTokenList( InternalSyntax.SyntaxList.List(_nodes[0], _nodes[1], _nodes[2]).CreateRed(), index: 0)); default: ArrayElement <GreenNode>[] tmp = new ArrayElement <GreenNode> [_count]; for (int i = 0; i < _count; i++) { tmp[i].Value = _nodes[i]; } return(new SyntaxNodeOrTokenList(InternalSyntax.SyntaxList.List(tmp).CreateRed(), index: 0)); } } else { return(default(SyntaxNodeOrTokenList)); } }
public SyntaxNodeOrTokenList ToList() { if (this.count > 0) { switch (this.count) { case 1: if (nodes[0].IsToken) { return(new SyntaxNodeOrTokenList( Syntax.InternalSyntax.SyntaxList.List(new[] { nodes[0] }).CreateRed(), index: 0)); } else { return(new SyntaxNodeOrTokenList(nodes[0].CreateRed(), index: 0)); } case 2: return(new SyntaxNodeOrTokenList( Syntax.InternalSyntax.SyntaxList.List(nodes[0], nodes[1]).CreateRed(), index: 0)); case 3: return(new SyntaxNodeOrTokenList( Syntax.InternalSyntax.SyntaxList.List(nodes[0], nodes[1], nodes[2]).CreateRed(), index: 0)); default: var tmp = new ArrayElement <Syntax.InternalSyntax.CSharpSyntaxNode> [count]; for (int i = 0; i < this.count; i++) { tmp[i].Value = nodes[i]; } return(new SyntaxNodeOrTokenList(Syntax.InternalSyntax.SyntaxList.List(tmp).CreateRed(), index: 0)); } } else { return(default(SyntaxNodeOrTokenList)); } }
private string returnMessage(bool[] selectedarray) { int Cnt = 0; StringBuilder Mess = new StringBuilder(); foreach (var ArrayElement in selectedarray) { if (bool.FalseString == ArrayElement.ToString()) { var result = (from u in FldNames where u[2] == Cnt.ToString() select u).FirstOrDefault(); Mess.Append(result[1] + Environment.NewLine); } Cnt += 1; } return(Mess.ToString()); }
/// <summary> /// Returns the a variable, accessing its address plus offset with '[]' /// </summary> public override void Execute() { // Take id Variable vble = this.Machine.TDS.SolveToVariable( this.Machine.ExecutionStack.Pop() ); // Take offset Variable offset = this.Machine.TDS.SolveToVariable( this.Machine.ExecutionStack.Pop() ); if ( vble != null ) { var vbleAsPtr = vble as PtrVariable; // If the vble at the right is a reference, dereference it if ( vbleAsPtr != null ) { vble = this.Machine.TDS.LookForAddress( vbleAsPtr.IntValue.Value ); } // Chk var ptrType = vble.Type as Ptr; if ( ptrType == null ) { throw new TypeMismatchException( vble.Name.Name ); } if ( !offset.Type.IsArithmetic() ) { throw new TypeMismatchException( offset.LiteralValue.ToString() ); } // Store in the ArrayElement vble and end Variable result = new ArrayElement( vble, ptrType, offset.LiteralValue.GetValueAsInt(), this.Machine ); this.Machine.ExecutionStack.Push( result ); } else { throw new EngineException( "invalid rvalue" ); } return; }
public SyntaxTriviaList ToList() { if (_count > 0) { switch (_count) { case 1: return(new SyntaxTriviaList(default(SyntaxToken), _nodes[0].UnderlyingNode, position: 0, index: 0)); case 2: return(new SyntaxTriviaList(default(SyntaxToken), InternalSyntax.SyntaxList.List( _nodes[0].UnderlyingNode, _nodes[1].UnderlyingNode), position: 0, index: 0)); case 3: return(new SyntaxTriviaList(default(SyntaxToken), InternalSyntax.SyntaxList.List( _nodes[0].UnderlyingNode, _nodes[1].UnderlyingNode, _nodes[2].UnderlyingNode), position: 0, index: 0)); default: { ArrayElement <GreenNode>[] tmp = new ArrayElement <GreenNode> [_count]; for (int i = 0; i < _count; i++) { tmp[i].Value = _nodes[i].UnderlyingNode; } return(new SyntaxTriviaList(default(SyntaxToken), InternalSyntax.SyntaxList.List(tmp), position: 0, index: 0)); } } } else { return(default(SyntaxTriviaList)); } }
internal Syntax.InternalSyntax.CSharpSyntaxNode ToListNode() { switch (this.Count) { case 0: return null; case 1: return (Syntax.InternalSyntax.CSharpSyntaxNode)nodes[0].Value; case 2: return Syntax.InternalSyntax.SyntaxList.List((Syntax.InternalSyntax.CSharpSyntaxNode)nodes[0].Value, (Syntax.InternalSyntax.CSharpSyntaxNode)nodes[1].Value); case 3: return Syntax.InternalSyntax.SyntaxList.List((Syntax.InternalSyntax.CSharpSyntaxNode)nodes[0].Value, (Syntax.InternalSyntax.CSharpSyntaxNode)nodes[1].Value, (Syntax.InternalSyntax.CSharpSyntaxNode)nodes[2].Value); default: var tmp = new ArrayElement<Syntax.InternalSyntax.CSharpSyntaxNode>[this.Count]; for (int i = 0; i < this.Count; i++) { tmp[i].Value = (Syntax.InternalSyntax.CSharpSyntaxNode)nodes[i].Value; } return Syntax.InternalSyntax.SyntaxList.List(tmp); } }
internal GreenNode ToListNode() { switch (this.Count) { case 0: return(null); case 1: return(_nodes[0]); case 2: return(SyntaxList.List(_nodes[0], _nodes[1])); case 3: return(SyntaxList.List(_nodes[0], _nodes[1], _nodes[2])); default: var tmp = new ArrayElement <GreenNode> [this.Count]; Array.Copy(_nodes, tmp, this.Count); return(SyntaxList.List(tmp)); } }
public static Element GetElementFromObject(object model) { Element element = null; if (model == null) { element = new NullElement(); } else { var type = model.GetType(); if (Array.IndexOf(Constants.NumberTypes, type) >= 0) { element = new NumberElement(); } else if (Array.IndexOf(Constants.StringTypes, type) >= 0) { element = new StringElement(); } else if (Array.IndexOf(Constants.BooleanTypes, type) >= 0) { element = new BooleanElement(); } else if (typeof(IEnumerable).IsAssignableFrom(type)) { element = new ArrayElement(); } else { element = new ObjectElement(); } element.PopulateElement(model); } return(element); }
/// <summary> /// Concatenates two syntax nodes into a single list. /// </summary> /// <param name="left">The left node.</param> /// <param name="right">The right node.</param> /// <returns>A node that represents the concatenation of the specified nodes.</returns> internal static SyntaxNode Concat(SyntaxNode left, SyntaxNode right) { if (left == null) return right; if (right == null) return left; var temp = default(ArrayElement<SyntaxNode>[]); var leftList = left as SyntaxList; var rightList = right as SyntaxList; if (leftList != null) { if (rightList != null) { temp = new ArrayElement<SyntaxNode>[left.SlotCount + right.SlotCount]; leftList.CopyTo(temp, 0); rightList.CopyTo(temp, left.SlotCount); return List(temp); } temp = new ArrayElement<SyntaxNode>[left.SlotCount + 1]; leftList.CopyTo(temp, 0); temp[left.SlotCount].Value = right; return List(temp); } if (rightList != null) { temp = new ArrayElement<SyntaxNode>[rightList.SlotCount + 1]; temp[0].Value = left; rightList.CopyTo(temp, 1); return List(temp); } return List(left, right); }
public static object luaM_realloc_ <T>(lua_State L, T[] old_block, int new_size) { int unmanaged_size = (int)GetUnmanagedSize(typeof(T)); int old_size = (old_block == null) ? 0 : old_block.Length; int osize = old_size * unmanaged_size; int nsize = new_size * unmanaged_size; T[] new_block = new T[new_size]; for (int i = 0; i < Math.Min(old_size, new_size); i++) { new_block[i] = old_block[i]; } for (int i = old_size; i < new_size; i++) { new_block[i] = (T)System.Activator.CreateInstance(typeof(T)); } if (CanIndex(typeof(T))) { //FIXME:added T test = (T)System.Activator.CreateInstance(typeof(T)); Debug.Assert(test is ArrayElement, String.Format("Need to derive type {0} from ArrayElement", typeof(T).ToString())); for (int i = 0; i < new_size; i++) { ArrayElement elem = new_block[i] as ArrayElement; //FIXME:??? //Debug.Assert(elem != null, String.Format("Need to derive type {0} from ArrayElement", typeof(T).ToString())); if (elem != null) { elem.set_index(i); elem.set_array(new_block); } } } SubtractTotalBytes(L, osize); AddTotalBytes(L, nsize); return(new_block); }
public SyntaxTriviaList ToList() { if (this.count > 0) { if (this.previous != null) { this.Grow(this.count); } switch (this.count) { case 1: return new SyntaxTriviaList(default(SyntaxToken), nodes[0].UnderlyingNode, position: 0, index: 0); case 2: return new SyntaxTriviaList(default(SyntaxToken), Syntax.InternalSyntax.SyntaxList.List( (Syntax.InternalSyntax.CSharpSyntaxNode)nodes[0].UnderlyingNode, (Syntax.InternalSyntax.CSharpSyntaxNode)nodes[1].UnderlyingNode), position: 0, index: 0); case 3: return new SyntaxTriviaList(default(SyntaxToken), Syntax.InternalSyntax.SyntaxList.List( (Syntax.InternalSyntax.CSharpSyntaxNode)nodes[0].UnderlyingNode, (Syntax.InternalSyntax.CSharpSyntaxNode)nodes[1].UnderlyingNode, (Syntax.InternalSyntax.CSharpSyntaxNode)nodes[2].UnderlyingNode), position: 0, index: 0); default: { var tmp = new ArrayElement<Syntax.InternalSyntax.CSharpSyntaxNode>[count]; for (int i = 0; i < this.count; i++) { tmp[i].Value = (Syntax.InternalSyntax.CSharpSyntaxNode)this.nodes[i].UnderlyingNode; } return new SyntaxTriviaList(default(SyntaxToken), Syntax.InternalSyntax.SyntaxList.List(tmp), position: 0, index: 0); } } } else { return default(SyntaxTriviaList); } }
internal abstract void CopyTo(ArrayElement<CSharpSyntaxNode>[] array, int offset);
public SyntaxTriviaList ToList() { if (_count > 0) { switch (_count) { case 1: return new SyntaxTriviaList(default(SyntaxToken), _nodes[0].UnderlyingNode, position: 0, index: 0); case 2: return new SyntaxTriviaList(default(SyntaxToken), InternalSyntax.SyntaxList.List( _nodes[0].UnderlyingNode, _nodes[1].UnderlyingNode), position: 0, index: 0); case 3: return new SyntaxTriviaList(default(SyntaxToken), InternalSyntax.SyntaxList.List( _nodes[0].UnderlyingNode, _nodes[1].UnderlyingNode, _nodes[2].UnderlyingNode), position: 0, index: 0); default: { var tmp = new ArrayElement<GreenNode>[_count]; for (int i = 0; i < _count; i++) { tmp[i].Value = _nodes[i].UnderlyingNode; } return new SyntaxTriviaList(default(SyntaxToken), InternalSyntax.SyntaxList.List(tmp), position: 0, index: 0); } } } else { return default(SyntaxTriviaList); } }
internal override void CopyTo(ArrayElement<GreenNode>[] array, int offset) { Array.Copy(this.children, 0, array, offset, this.children.Length); }
internal SeparatedWithManyWeakChildren(InternalSyntax.SyntaxList green, SyntaxNode parent, int position) : base(green, parent, position) { _children = new ArrayElement<WeakReference<SyntaxNode>>[(((green.SlotCount + 1) >> 1) - 1)]; }
public GType Resolve() { if (IsJVMGenerate || IsCLRGenerate) { return(this); } if (IsCLRType && IsJVMType) { return(this); } if (IsCLRType && JVMSubst != null) { return(JVMSubst); } if (IsJVMType && CLRSubst != null) { return(CLRSubst); } if (IsArray) { if (ArrayElement.CLRType == typeof(string)) { JVMSubst = Repository.RegisterClass(String._class).MakeArray(); return(JVMSubst); } GType subst = ArrayElement.Resolve().MakeArray(); if (IsCLRType) { JVMSubst = subst; } else { CLRSubst = subst; } return(subst); } if (IsRootType) { return(this); } if (Base != null) { GType subst = Base.Resolve(); if (!subst.IsRootType) { if (IsCLRType) { JVMSubst = subst; } else { CLRSubst = subst; } return(subst); } } /* * foreach (GType ifc in Interfaces) * { * GType subst = ifc.Resolve(); * if (IsCLRType && ifc.IsJVMType) * { * JVMSubst = subst; * return subst; * } * if (IsJVMType && ifc.IsCLRType) * { * CLRSubst = subst; * return subst; * } * }*/ if (IsCLRType) { JVMSubst = Repository.systemObject; return(Repository.systemObject); } else { CLRSubst = Repository.javaLangObject; return(Repository.javaLangObject); } }
internal override void WriteTo(ObjectWriter writer) { base.WriteTo(writer); writer.WriteValue(ArrayElement <CSharpSyntaxNode> .MakeArray(this.children)); }
private void BuildConfigWithValues(UnityConfigurationSection s) { var ctorElement = new ConstructorElement(); ctorElement.Parameters.Add(new ParameterElement { Name = "defaultDependency" }); ctorElement.Parameters.Add(new ParameterElement { Name = "namedDependency", Value = new DependencyElement { Name = "someName" } }); ctorElement.Parameters.Add(new ParameterElement() { Name = "typedDependency", Value = new DependencyElement() { TypeName = "SomeOtherType" } }); ctorElement.Parameters.Add(new ParameterElement() { Name = "valueDependency", Value = new ValueElement { Value = "someValue" } }); ctorElement.Parameters.Add(new ParameterElement() { Name = "valueWithTypeConverter", Value = new ValueElement { Value = "someValue", TypeConverterTypeName = "MyConverter" } }); ctorElement.Parameters.Add(new ParameterElement() { Name = "optionalValue", Value = new OptionalElement() { Name = "dependencyKey", TypeName = "DependencyType" } }); ctorElement.Parameters.Add(new ParameterElement() { Name = "emptyArrayValue", Value = new ArrayElement() }); ctorElement.Parameters.Add(new ParameterElement() { Name = "typedEmptyArrayValue", Value = new ArrayElement { TypeName = "MyElementType" } }); var arrayWithValues = new ArrayElement(); arrayWithValues.Values.Add(new DependencyElement()); arrayWithValues.Values.Add(new ValueElement() { Value = "something" }); arrayWithValues.Values.Add(new DependencyElement() { Name = "dependencyName" }); ctorElement.Parameters.Add(new ParameterElement() { Name = "arrayWithValues", Value = arrayWithValues }); var registration = new RegisterElement { TypeName = "someType" }; registration.InjectionMembers.Add(ctorElement); var container = new ContainerElement(); container.Registrations.Add(registration); s.Containers.Add(container); }
/// <summary> /// Initializes a new instance of the <see cref="WithManyChildren"/> class. /// </summary> /// <param name="children">An array containing the list's children.</param> internal WithManyChildren(ArrayElement<SyntaxNode>[] children) : base(children) { }
/// <summary> /// Copies the list to the specified array. /// </summary> /// <param name="array">The array to which to copy the list.</param> /// <param name="offset">The offset at which to begin copying.</param> internal abstract void CopyTo(ArrayElement<SyntaxNode>[] array, Int32 offset);
/// <summary> /// Creates a list from the specified array. /// </summary> /// <param name="nodes">The array of nodes from which to create the list.</param> /// <returns>The list that was created.</returns> internal static SyntaxList List(ArrayElement<SyntaxNode>[] nodes) { return (nodes.Length < 10) ? new WithManyChildren(nodes) : (WithManyChildrenBase)new WithLotsOfChildren(nodes); }
internal WithManyChildren(ArrayElement<GreenNode>[] children) : base(children) { }
internal WithManyChildren(DiagnosticInfo[] diagnostics, SyntaxAnnotation[] annotations, ArrayElement<GreenNode>[] children) : base(diagnostics, annotations, children) { }
internal static CSharpSyntaxNode Concat(CSharpSyntaxNode left, CSharpSyntaxNode right) { if (left == null) { return right; } if (right == null) { return left; } var leftList = left as SyntaxList; var rightList = right as SyntaxList; if (leftList != null) { if (rightList != null) { var tmp = new ArrayElement<CSharpSyntaxNode>[left.SlotCount + right.SlotCount]; leftList.CopyTo(tmp, 0); rightList.CopyTo(tmp, left.SlotCount); return List(tmp); } else { var tmp = new ArrayElement<CSharpSyntaxNode>[left.SlotCount + 1]; leftList.CopyTo(tmp, 0); tmp[left.SlotCount].Value = right; return List(tmp); } } else if (rightList != null) { var tmp = new ArrayElement<CSharpSyntaxNode>[rightList.SlotCount + 1]; tmp[0].Value = left; rightList.CopyTo(tmp, 1); return List(tmp); } else { return List(left, right); } }
internal WithManyChildrenBase(DiagnosticInfo[] diagnostics, SyntaxAnnotation[] annotations, ArrayElement<GreenNode>[] children) : base(diagnostics, annotations) { this.children = children; this.InitializeChildren(); }
/// <summary> /// Creates a list from the specified array. /// </summary> /// <param name="nodes">The array of nodes from which to create the list.</param> /// <param name="count">The number of nodes in the array to copy into the created list.</param> /// <returns>The list that was created.</returns> internal static SyntaxList List(SyntaxNode[] nodes, Int32 count) { var array = new ArrayElement<SyntaxNode>[count]; for (int i = 0; i < count; i++) array[i].Value = nodes[i]; return List(array); }
public SyntaxNodeOrTokenList ToList() { if (this.count > 0) { switch (this.count) { case 1: if (nodes[0].IsToken) { return new SyntaxNodeOrTokenList( Syntax.InternalSyntax.SyntaxList.List(new[] { nodes[0] }).CreateRed(), index: 0); } else { return new SyntaxNodeOrTokenList(nodes[0].CreateRed(), index: 0); } case 2: return new SyntaxNodeOrTokenList( Syntax.InternalSyntax.SyntaxList.List(nodes[0], nodes[1]).CreateRed(), index: 0); case 3: return new SyntaxNodeOrTokenList( Syntax.InternalSyntax.SyntaxList.List(nodes[0], nodes[1], nodes[2]).CreateRed(), index: 0); default: var tmp = new ArrayElement<Syntax.InternalSyntax.CSharpSyntaxNode>[count]; for (int i = 0; i < this.count; i++) { tmp[i].Value = nodes[i]; } return new SyntaxNodeOrTokenList(Syntax.InternalSyntax.SyntaxList.List(tmp).CreateRed(), index: 0); } } else { return default(SyntaxNodeOrTokenList); } }
public RuntimeElement(Element element, GenericElement generic, ArrayElement array) : base(element.Let(IsGenericTypeSpecification.Default, generic) .Let(IsArraySpecification.Default, array)) { }
internal WithManyChildrenBase(ArrayElement<GreenNode>[] children) { this.children = children; this.InitializeChildren(); }
internal WithLotsOfChildren(ArrayElement<CSharpSyntaxNode>[] children) : base(children) { _childOffsets = CalculateOffsets(children); }
internal override void CopyTo(ArrayElement<GreenNode>[] array, int offset) { array[offset].Value = _child0; array[offset + 1].Value = _child1; array[offset + 2].Value = _child2; }
/// <inheritdoc/> internal override void CopyTo(ArrayElement<SyntaxNode>[] array, Int32 offset) { Array.Copy(children, 0, array, offset, children.Length); }
static void Main() { int[,] matrix = { {1,3,2,2,2,4}, {3,3,3,2,4,4}, {4,3,1,2,3,3}, {4,3,1,3,3,1}, {4,3,3,3,1,1} }; bool[,] visited=new bool[matrix.GetLength(0),matrix.GetLength(1)]; int largestArea = 0; Stack stack=new Stack(); for (int i = 0; i < matrix.GetLength(0); i++) { for (int j = 0; j < matrix.GetLength(1); j++) { if (visited[i, j]) { continue; } ArrayElement current = new ArrayElement(i,j); stack.Push(current); int currentArea=0; int value = matrix[i, j]; while (stack.Count != 0) { ArrayElement peek = (ArrayElement)stack.Peek(); int currentRow=peek.row, currentCol=peek.column; currentArea++; visited[currentRow, currentCol] = true; stack.Pop(); //UpperLeft Diagonal if (currentRow - 1 >= 0 && currentCol - 1 >= 0 && !visited[currentRow - 1, currentCol - 1] && matrix[currentRow - 1, currentCol - 1] == value) { stack.Push(new ArrayElement(currentRow - 1, currentCol - 1)); visited[currentRow - 1, currentCol - 1] = true; } //Upper if (currentRow - 1 >= 0 && !visited[currentRow - 1, currentCol] && matrix[currentRow - 1, currentCol] == value) { stack.Push(new ArrayElement(currentRow - 1, currentCol)); visited[currentRow - 1, currentCol] = true; } //UpperRight Diagonal if (currentRow - 1 >= 0 && currentCol + 1 <= 5 && !visited[currentRow - 1, currentCol + 1] && matrix[currentRow - 1, currentCol + 1] == value) { stack.Push(new ArrayElement(currentRow - 1, currentCol + 1)); visited[currentRow - 1, currentCol + 1] = true; } //Left if (currentCol - 1 >= 0 && !visited[currentRow, currentCol - 1] && matrix[currentRow, currentCol - 1] == value) { stack.Push(new ArrayElement(currentRow, currentCol - 1)); visited[currentRow , currentCol - 1] = true; } //Right if (currentCol + 1 <= 5 && !visited[currentRow, currentCol + 1] && matrix[currentRow, currentCol + 1] == value) { stack.Push(new ArrayElement(currentRow, currentCol + 1)); visited[currentRow , currentCol + 1] = true; } //LowerLeft Diagonal if (currentRow + 1 <= 4 && currentCol - 1 >= 0 && !visited[currentRow + 1, currentCol - 1] && matrix[currentRow + 1, currentCol - 1] == value) { stack.Push(new ArrayElement(currentRow + 1, currentCol - 1)); visited[currentRow + 1, currentCol - 1] = true; } //Lower if (currentRow + 1 <= 4 && !visited[currentRow + 1, currentCol] && matrix[currentRow + 1, currentCol] == value) { stack.Push(new ArrayElement(currentRow + 1, currentCol)); visited[currentRow + 1, currentCol] = true; } //LowerRight Diagonal if (currentRow + 1 <= 4 && currentCol + 1 <= 5 && !visited[currentRow + 1, currentCol + 1] && matrix[currentRow + 1, currentCol + 1] == value) { stack.Push(new ArrayElement(currentRow + 1, currentCol + 1)); visited[currentRow + 1, currentCol + 1] = true; } } if (currentArea>largestArea) { largestArea = currentArea; } } } Console.WriteLine("The largest Area is {0}!" ,largestArea); }