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);
}
