using System;

using System.Collections;

using System.Collections.Generic;

using System.Runtime.InteropServices;

namespace Python.Runtime

{

/// <summary>

/// Implements a Python type for managed arrays. This type is essentially

/// the same as a ClassObject, except that it provides sequence semantics

/// to support natural array usage (indexing) from Python.

/// </summary>

[Serializable]

internal sealed class ArrayObject : ClassBase

{

internal ArrayObject(Type tp) : base(tp)

{

}

internal override bool CanSubclass()

{

return false;

}

public static NewReference tp_new(BorrowedReference tp, BorrowedReference args, BorrowedReference kw)

{

if (kw != null)

{

return Exceptions.RaiseTypeError("array constructor takes no keyword arguments");

}

var self = (ArrayObject)GetManagedObject(tp)!;

if (!self.type.Valid)

{

return Exceptions.RaiseTypeError(self.type.DeletedMessage);

}

Type arrType = self.type.Value;

long[] dimensions = new long[Runtime.PyTuple_Size(args)];

if (dimensions.Length == 0)

{

return Exceptions.RaiseTypeError("array constructor requires at least one integer argument or an object convertible to array");

}

if (dimensions.Length != 1)

{

return CreateMultidimensional(arrType.GetElementType(), dimensions,

shapeTuple: args,

pyType: tp);

}

BorrowedReference op = Runtime.PyTuple_GetItem(args, 0);

// create single dimensional array

if (Runtime.PyInt_Check(op))

{

dimensions[0] = Runtime.PyLong_AsSignedSize_t(op);

if (dimensions[0] == -1 && Exceptions.ErrorOccurred())

{

Exceptions.Clear();

}

else

{

return NewInstance(arrType.GetElementType(), tp, dimensions);

}

}

// this implements casting to Array[T]

if (Converter.ToManaged(op, arrType, out object? result, true))

{

return CLRObject.GetReference(result!, tp);

}

else

{

return default;

}

}

static NewReference CreateMultidimensional(Type elementType, long[] dimensions, BorrowedReference shapeTuple, BorrowedReference pyType)

{

for (int dimIndex = 0; dimIndex < dimensions.Length; dimIndex++)

{

BorrowedReference dimObj = Runtime.PyTuple_GetItem(shapeTuple, dimIndex);

PythonException.ThrowIfIsNull(dimObj);

if (!Runtime.PyInt_Check(dimObj))

{

Exceptions.RaiseTypeError("array constructor expects integer dimensions");

return default;

}

dimensions[dimIndex] = Runtime.PyLong_AsSignedSize_t(dimObj);

if (dimensions[dimIndex] == -1 && Exceptions.ErrorOccurred())

{

Exceptions.RaiseTypeError("array constructor expects integer dimensions");

return default;

}

}

return NewInstance(elementType, pyType, dimensions);

}

static NewReference NewInstance(Type elementType, BorrowedReference arrayPyType, long[] dimensions)

{

for (int dim = 0; dim < dimensions.Length; dim++)

{

if (dimensions[dim] < 0)

{

Exceptions.SetError(Exceptions.ValueError, $"Non-negative number required (dims[{dim}])");

return default;

}

}

object result;

try

{

result = Array.CreateInstance(elementType, dimensions);

}

catch (ArgumentException badArgument)

{

Exceptions.SetError(Exceptions.ValueError, badArgument.Message);

return default;

}

catch (OverflowException overflow)

{

Exceptions.SetError(overflow);

return default;

}

catch (NotSupportedException notSupported)

{

Exceptions.SetError(notSupported);

return default;

}

catch (OutOfMemoryException oom)

{

Exceptions.SetError(Exceptions.MemoryError, oom.Message);

return default;

}

return CLRObject.GetReference(result, arrayPyType);

}

/// <summary>

/// Implements __getitem__ for array types.

/// </summary>

public static NewReference mp_subscript(BorrowedReference ob, BorrowedReference idx)

{

var obj = (CLRObject)GetManagedObject(ob)!;

var arrObj = (ArrayObject)GetManagedObject(Runtime.PyObject_TYPE(ob))!;

if (!arrObj.type.Valid)

{

return Exceptions.RaiseTypeError(arrObj.type.DeletedMessage);

}

var items = (Array)obj.inst;

Type itemType = arrObj.type.Value.GetElementType();

int rank = items.Rank;

long index;

object value;

// Note that CLR 1.0 only supports int indexes - methods to

// support long indices were introduced in 1.1. We could

// support long indices automatically, but given that long

// indices are not backward compatible and a relative edge

// case, we won't bother for now.

// Single-dimensional arrays are the most common case and are

// cheaper to deal with than multi-dimensional, so check first.

if (rank == 1)

{

if (!Runtime.PyInt_Check(idx))

{

return RaiseIndexMustBeIntegerError(idx);

}

index = Runtime.PyLong_AsSignedSize_t(idx);

if (index == -1 && Exceptions.ErrorOccurred())

{

return Exceptions.RaiseTypeError("invalid index value");

}

if (index < 0)

{

index = items.LongLength + index;

}

if (index < 0 || index >= items.LongLength)

{

Exceptions.SetError(Exceptions.IndexError, "array index out of range");

return default;

}

value = items.GetValue(index);

return ItemToPython(value, itemType);

}

// Multi-dimensional arrays can be indexed a la: list[1, 2, 3].

if (!Runtime.PyTuple_Check(idx))

{

Exceptions.SetError(Exceptions.TypeError, "invalid index value");

return default;

}

var count = Runtime.PyTuple_Size(idx);

long[] indices = new long[count];

for (int dimension = 0; dimension < count; dimension++)

{

BorrowedReference op = Runtime.PyTuple_GetItem(idx, dimension);

if (!Runtime.PyInt_Check(op))

{

return RaiseIndexMustBeIntegerError(op);

}

index = Runtime.PyLong_AsSignedSize_t(op);

if (index == -1 && Exceptions.ErrorOccurred())

{

return Exceptions.RaiseTypeError("invalid index value");

}

long len = items.GetLongLength(dimension);

if (index < 0)

{

index = len + index;

}

if (index < 0 || index >= len)

{

Exceptions.SetError(Exceptions.IndexError, "array index out of range");

return default;

}

indices[dimension] = index;

}

value = items.GetValue(indices);

return ItemToPython(value, itemType);

}

// The conversion can throw - for a type refused by an IClrTypeFilter, say -

// and that must become a Python exception rather than unwinding through it

static NewReference ItemToPython(object? value, Type itemType)

{

try

{

return Converter.ToPython(value, itemType);

}

catch (Exception e)

{

Exceptions.SetError(e);

return default;

}

}

/// <summary>

/// Implements __setitem__ for array types.

/// </summary>

public static int mp_ass_subscript(BorrowedReference ob, BorrowedReference idx, BorrowedReference v)

{

if (v.IsNull)

{

Exceptions.RaiseTypeError("'System.Array' object does not support item deletion");

return -1;

}

var obj = (CLRObject)GetManagedObject(ob)!;

var items = (Array)obj.inst;

Type itemType = obj.inst.GetType().GetElementType();

int rank = items.Rank;

long index;

if (items.IsReadOnly)

{

Exceptions.RaiseTypeError("array is read-only");

return -1;

}

if (!Converter.ToManaged(v, itemType, out object? value, true))

{

return -1;

}

if (rank == 1)

{

if (!Runtime.PyInt_Check(idx))

{

RaiseIndexMustBeIntegerError(idx);

return -1;

}

index = Runtime.PyLong_AsSignedSize_t(idx);

if (index == -1 && Exceptions.ErrorOccurred())

{

Exceptions.RaiseTypeError("invalid index value");

return -1;

}

if (index < 0)

{

index = items.LongLength + index;

}

if (index < 0 || index >= items.LongLength)

{

Exceptions.SetError(Exceptions.IndexError, "array index out of range");

return -1;

}

items.SetValue(value, index);

return 0;

}

if (!Runtime.PyTuple_Check(idx))

{

Exceptions.RaiseTypeError("invalid index value");

return -1;

}

var count = Runtime.PyTuple_Size(idx);

long[] indices = new long[count];

for (int dimension = 0; dimension < count; dimension++)

{

BorrowedReference op = Runtime.PyTuple_GetItem(idx, dimension);

if (!Runtime.PyInt_Check(op))

{

RaiseIndexMustBeIntegerError(op);

return -1;

}

index = Runtime.PyLong_AsSignedSize_t(op);

if (index == -1 && Exceptions.ErrorOccurred())

{

Exceptions.RaiseTypeError("invalid index value");

return -1;

}

long len = items.GetLongLength(dimension);

if (index < 0)

{

index = len + index;

}

if (index < 0 || index >= len)

{

Exceptions.SetError(Exceptions.IndexError, "array index out of range");

return -1;

}

indices[dimension] = index;

}

items.SetValue(value, indices);

return 0;

}

private static NewReference RaiseIndexMustBeIntegerError(BorrowedReference idx)

{

string tpName = Runtime.PyObject_GetTypeName(idx);

return Exceptions.RaiseTypeError($"array index has type {tpName}, expected an integer");

}

/// <summary>

/// Implements __contains__ for array types.

/// </summary>

public static int sq_contains(BorrowedReference ob, BorrowedReference v)

{

var obj = (CLRObject)GetManagedObject(ob)!;

Type itemType = obj.inst.GetType().GetElementType();

var items = (IList)obj.inst;

if (!Converter.ToManaged(v, itemType, out object? value, false))

{

return 0;

}

if (items.Contains(value))

{

return 1;

}

return 0;

}

#region Buffer protocol

static int GetBuffer(BorrowedReference obj, out Py_buffer buffer, PyBUF flags)

{

buffer = default;

if (flags == PyBUF.SIMPLE)

{

Exceptions.SetError(Exceptions.BufferError, "SIMPLE not implemented");

return -1;

}

if ((flags & PyBUF.F_CONTIGUOUS) == PyBUF.F_CONTIGUOUS)

{

Exceptions.SetError(Exceptions.BufferError, "only C-contiguous supported");

return -1;

}

var self = (Array)((CLRObject)GetManagedObject(obj)!).inst;

Type itemType = self.GetType().GetElementType();

bool formatRequested = (flags & PyBUF.FORMATS) != 0;

string? format = GetFormat(itemType);

if (formatRequested && format is null)

{

Exceptions.SetError(Exceptions.BufferError, "unsupported element type: " + itemType.Name);

return -1;

}

GCHandle gcHandle;

try

{

gcHandle = GCHandle.Alloc(self, GCHandleType.Pinned);

}

catch (ArgumentException ex)

{

Exceptions.SetError(Exceptions.BufferError, ex.Message);

return -1;

}

int itemSize = Marshal.SizeOf(itemType);

IntPtr[] shape = GetShape(self);

IntPtr[] strides = GetStrides(shape, itemSize);

buffer = new Py_buffer

{

buf = gcHandle.AddrOfPinnedObject(),

obj = new NewReference(obj).DangerousMoveToPointer(),

len = (IntPtr)(self.LongLength * itemSize),

itemsize = (IntPtr)itemSize,

_readonly = false,

ndim = self.Rank,

format = format,

shape = ToUnmanaged(shape),

strides = (flags & PyBUF.STRIDES) == PyBUF.STRIDES ? ToUnmanaged(strides) : IntPtr.Zero,

suboffsets = IntPtr.Zero,

_internal = (IntPtr)gcHandle,

};

return 0;

}

static void ReleaseBuffer(BorrowedReference obj, ref Py_buffer buffer)

{

if (buffer._internal == IntPtr.Zero) return;

UnmanagedFree(ref buffer.shape);

UnmanagedFree(ref buffer.strides);

UnmanagedFree(ref buffer.suboffsets);

// TODO: decref buffer.obj?

var gcHandle = (GCHandle)buffer._internal;

gcHandle.Free();

buffer._internal = IntPtr.Zero;

}

static IntPtr[] GetStrides(IntPtr[] shape, long itemSize)

{

var result = new IntPtr[shape.Length];

result[shape.Length - 1] = new IntPtr(itemSize);

for (int dim = shape.Length - 2; dim >= 0; dim--)

{

itemSize *= shape[dim + 1].ToInt64();

result[dim] = new IntPtr(itemSize);

}

return result;

}

static IntPtr[] GetShape(Array array)

{

var result = new IntPtr[array.Rank];

for (int i = 0; i < result.Length; i++)

result[i] = (IntPtr)array.GetLongLength(i);

return result;

}

static void UnmanagedFree(ref IntPtr address)

{

if (address == IntPtr.Zero) return;

Marshal.FreeHGlobal(address);

address = IntPtr.Zero;

}

static unsafe IntPtr ToUnmanaged<T>(T[] array) where T : unmanaged

{

IntPtr result = Marshal.AllocHGlobal(checked(Marshal.SizeOf(typeof(T)) * array.Length));

fixed (T* ptr = array)

{

var @out = (T*)result;

for (int i = 0; i < array.Length; i++)

@out[i] = ptr[i];

}

return result;

}

static readonly Dictionary<Type, string> ItemFormats = new()

{

[typeof(byte)] = "B",

[typeof(sbyte)] = "b",

[typeof(bool)] = "?",

[typeof(short)] = "h",

[typeof(ushort)] = "H",

// see https://github.com/pybind/pybind11/issues/1908#issuecomment-658358767

[typeof(int)] = "i",

[typeof(uint)] = "I",

[typeof(long)] = "q",

[typeof(ulong)] = "Q",

[typeof(IntPtr)] = "n",

[typeof(UIntPtr)] = "N",

// TODO: half = "e"

[typeof(float)] = "f",

[typeof(double)] = "d",

};

static string? GetFormat(Type elementType)

=> ItemFormats.TryGetValue(elementType, out string result) ? result : null;

static readonly GetBufferProc getBufferProc = GetBuffer;

static readonly ReleaseBufferProc releaseBufferProc = ReleaseBuffer;

static readonly IntPtr BufferProcsAddress = AllocateBufferProcs();

static IntPtr AllocateBufferProcs()

{

var procs = new PyBufferProcs

{

Get = Marshal.GetFunctionPointerForDelegate(getBufferProc),

Release = Marshal.GetFunctionPointerForDelegate(releaseBufferProc),

};

IntPtr result = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(PyBufferProcs)));

Marshal.StructureToPtr(procs, result, fDeleteOld: false);

return result;

}

#endregion

/// <summary>

/// <see cref="TypeManager.InitializeSlots(PyType, Type, SlotsHolder?)"/>

/// </summary>

public static void InitializeSlots(PyType type, ISet<string> initialized, SlotsHolder slotsHolder)

{

if (initialized.Add(nameof(TypeOffset.tp_as_buffer)))

{

// TODO: only for unmanaged arrays

int offset = TypeOffset.GetSlotOffset(nameof(TypeOffset.tp_as_buffer));

Util.WriteIntPtr(type, offset, BufferProcsAddress);

}

}

}

}