0
0
Fork 0
This repository has been archived on 2024-10-12. You can view files and clone it, but cannot push or open issues or pull requests.
ryujinx-final/src/Spv.Generator/InstructionOperands.cs
TSRBerry 981e0c082d
[Spv.Generator] Address dotnet-format issues (#5394)
* dotnet format style --severity info

Some changes were manually reverted.

* Restore a few unused methods and variables

* Silence dotnet format IDE0052 warnings

* Address or silence dotnet format IDE1006 warnings

* Address or silence dotnet format CA1069 warnings

* Address review comments

* Address most dotnet format whitespace warnings

* Run dotnet format after rebase and remove unused usings

- analyzers
- style
- whitespace

* Add comments to disabled warnings

* Simplify properties and array initialization, Use const when possible, Remove trailing commas

* Address IDE0251 warnings

* Revert "Simplify properties and array initialization, Use const when possible, Remove trailing commas"

This reverts commit 9462e4136c0a2100dc28b20cf9542e06790aa67e.

* dotnet format whitespace after rebase

* Rename Operand.cs to IOperand.cs

* Update src/Spv.Generator/Module.cs

Co-authored-by: Ac_K <Acoustik666@gmail.com>

* Remove NotNullWhen attribute and use conditional access to avoid NRE

* Fix duplicated enum values

* Remove unread member

---------

Co-authored-by: Ac_K <Acoustik666@gmail.com>
2023-06-28 18:54:20 +02:00

72 lines
2.2 KiB
C#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
namespace Spv.Generator
{
public struct InstructionOperands
{
private const int InternalCount = 5;
public int Count;
public IOperand Operand1;
public IOperand Operand2;
public IOperand Operand3;
public IOperand Operand4;
public IOperand Operand5;
public IOperand[] Overflow;
public Span<IOperand> AsSpan()
{
if (Count > InternalCount)
{
return MemoryMarshal.CreateSpan(ref this.Overflow[0], Count);
}
else
{
return MemoryMarshal.CreateSpan(ref this.Operand1, Count);
}
}
public void Add(IOperand operand)
{
if (Count < InternalCount)
{
MemoryMarshal.CreateSpan(ref this.Operand1, Count + 1)[Count] = operand;
Count++;
}
else
{
if (Overflow == null)
{
Overflow = new IOperand[InternalCount * 2];
MemoryMarshal.CreateSpan(ref this.Operand1, InternalCount).CopyTo(Overflow.AsSpan());
}
else if (Count == Overflow.Length)
{
Array.Resize(ref Overflow, Overflow.Length * 2);
}
Overflow[Count++] = operand;
}
}
private readonly IEnumerable<IOperand> AllOperands => new[] { Operand1, Operand2, Operand3, Operand4, Operand5 }
.Concat(Overflow ?? Array.Empty<IOperand>())
.Take(Count);
public readonly override string ToString()
{
return $"({string.Join(", ", AllOperands)})";
}
public readonly string ToString(string[] labels)
{
var labeledParams = AllOperands.Zip(labels, (op, label) => $"{label}: {op}");
var unlabeledParams = AllOperands.Skip(labels.Length).Select(op => op.ToString());
var paramsToPrint = labeledParams.Concat(unlabeledParams);
return $"({string.Join(", ", paramsToPrint)})";
}
}
}