[SpecialName]

public static void PerformModuleReload(PythonContext/*!*/ context, PythonDictionary/*!*/ dict) {

context.EnsureModuleException("structerror", dict, "error", "struct");

}

#region Public API

public const string __doc__ = null;

[PythonType, Documentation("Represents a compiled struct pattern")]

public class Struct : IWeakReferenceable {

private Format[] _formats; // the various formatting options for the compiled struct

private bool _isStandardized; // true if the format is in standardized mode

private bool _isLittleEndian; // true if the format is in little endian mode

private int _encodingCount = -1; // the number of objects consumed/produced by the format

private int _encodingSize = -1; // the number of bytes read/produced by the format

private WeakRefTracker _tracker; // storage for weak proxy's

private void InitializeFrom(Struct s) {

format = s.format;

_formats = s._formats;

_isStandardized = s._isStandardized;

_isLittleEndian = s._isLittleEndian;

_encodingCount = s._encodingCount;

_encodingSize = s._encodingSize;

_tracker = s._tracker;

}

internal Struct(CodeContext/*!*/ context, [NotNull]string/*!*/ fmt) {

__init__(context, fmt);

}

#region Python construction

[Documentation("creates a new uninitialized struct object - all arguments are ignored")]

public Struct(params object[] args) {

}

[Documentation("creates a new uninitialized struct object - all arguments are ignored")]

public Struct([ParamDictionary]IDictionary<object, object> kwArgs, params object[] args) {

}

[Documentation("initializes or re-initializes the compiled struct object with a new format")]

public void __init__(CodeContext/*!*/ context, object fmt) {

format = FormatObjectToString(fmt);

Struct s;

bool gotIt;

lock (_cache) {

gotIt = _cache.TryGetValue(format, out s);

}

InitializeFrom(gotIt ? s : CompileAndCache(context, format));

}

#endregion

#region Public API

[Documentation("gets the current format string for the compiled Struct")]

public string format { get; private set; }

[Documentation("returns a string consisting of the values serialized according to the format of the struct object")]

public Bytes/*!*/ pack(CodeContext/*!*/ context, params object[] values) {

if (values.Length != _encodingCount) {

throw Error(context, $"pack requires exactly {_encodingCount} arguments");

}

int curObj = 0;

var buffer = new byte[_encodingSize];

using var res = new MemoryStream(buffer);

foreach (Format curFormat in _formats) {

if (!_isStandardized) {

// In native mode, align to {size}-byte boundaries

int nativeSize = curFormat.NativeSize;

int alignLength = Align((int)res.Position, nativeSize);

int padLength = alignLength - (int)res.Position;

res.WriteByteCount((byte)'\0', padLength);

}

switch (curFormat.Type) {

case FormatType.PadByte:

res.WriteByteCount((byte)'\0', curFormat.Count);

break;

case FormatType.Bool:

res.WriteByte((byte)(GetBoolValue(context, curObj++, values) ? 1 : 0));

break;

case FormatType.Char:

for (int j = 0; j < curFormat.Count; j++) {

res.WriteByte((byte)GetCharValue(context, curObj++, values));

}

break;

case FormatType.SignedChar:

for (int j = 0; j < curFormat.Count; j++) {

res.WriteByte((byte)GetSByteValue(context, curObj++, values));

}

break;

case FormatType.UnsignedChar:

for (int j = 0; j < curFormat.Count; j++) {

res.WriteByte(GetByteValue(context, curObj++, values));

}

break;

case FormatType.Short:

for (int j = 0; j < curFormat.Count; j++) {

WriteShort(res, _isLittleEndian, GetShortValue(context, curObj++, values));

}

break;

case FormatType.UnsignedShort:

for (int j = 0; j < curFormat.Count; j++) {

WriteUShort(res, _isLittleEndian, GetUShortValue(context, curObj++, values));

}

break;

case FormatType.Int:

for (int j = 0; j < curFormat.Count; j++) {

WriteInt(res, _isLittleEndian, GetIntValue(context, curObj++, values));

}

break;

case FormatType.UnsignedInt:

for (int j = 0; j < curFormat.Count; j++) {

WriteUInt(res, _isLittleEndian, GetULongValue(context, curObj++, values, "unsigned int"));

}

break;

case FormatType.UnsignedLong:

for (int j = 0; j < curFormat.Count; j++) {

WriteUInt(res, _isLittleEndian, GetULongValue(context, curObj++, values, "unsigned long"));

}

break;

case FormatType.Pointer:

for (int j = 0; j < curFormat.Count; j++) {

WritePointer(res, _isLittleEndian, GetPointer(context, curObj++, values));

}

break;

case FormatType.SignedNetPointer:

for (int j = 0; j < curFormat.Count; j++) {

WriteSignedNetPointer(res, _isLittleEndian, GetSignedNetPointer(context, curObj++, values));

}

break;

case FormatType.UnsignedNetPointer:

for (int j = 0; j < curFormat.Count; j++) {

WriteUnsignedNetPointer(res, _isLittleEndian, GetUnsignedNetPointer(context, curObj++, values));

}

break;

case FormatType.SignedSizeT:

for (int j = 0; j < curFormat.Count; j++) {

WriteInt(res, _isLittleEndian, GetSignedSizeT(context, curObj++, values));

}

break;

case FormatType.SizeT:

for (int j = 0; j < curFormat.Count; j++) {

WriteUInt(res, _isLittleEndian, GetSizeT(context, curObj++, values));

}

break;

case FormatType.LongLong:

for (int j = 0; j < curFormat.Count; j++) {

WriteLong(res, _isLittleEndian, GetLongValue(context, curObj++, values));

}

break;

case FormatType.UnsignedLongLong:

for (int j = 0; j < curFormat.Count; j++) {

WriteULong(res, _isLittleEndian, GetULongLongValue(context, curObj++, values));

}

break;

case FormatType.Double:

for (int j = 0; j < curFormat.Count; j++) {

WriteDouble(res, _isLittleEndian, GetDoubleValue(context, curObj++, values));

}

break;

case FormatType.Float:

for (int j = 0; j < curFormat.Count; j++) {

WriteFloat(res, _isLittleEndian, (float)GetDoubleValue(context, curObj++, values));

}

break;

case FormatType.CString:

WriteString(res, curFormat.Count, GetStringValue(context, curObj++, values));

break;

case FormatType.PascalString:

WritePascalString(res, curFormat.Count - 1, GetStringValue(context, curObj++, values));

break;

}

}

return Bytes.Make(buffer);

}

[Documentation("Stores the deserialized data into the provided array")]

public void pack_into(CodeContext/*!*/ context, [NotNull]ArrayModule.array/*!*/ buffer, int offset, params object[] args) {

byte[] existing = buffer.ToByteArray();

if (offset + size > existing.Length) {

throw Error(context, $"pack_into requires a buffer of at least {size} bytes");

}

var data = pack(context, args).UnsafeByteArray;

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

existing[i + offset] = data[i];

}

buffer.Clear();

buffer.FromStream(new MemoryStream(existing));

}

public void pack_into(CodeContext/*!*/ context, [NotNull]ByteArray/*!*/ buffer, int offset, params object[] args) {

IList<byte> existing = buffer.UnsafeByteList;

if (offset + size > existing.Count) {

throw Error(context, $"pack_into requires a buffer of at least {size} bytes");

}

var data = pack(context, args).UnsafeByteArray;

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

existing[i + offset] = data[i];

}

}

[Documentation("deserializes the string using the structs specified format")]

public PythonTuple/*!*/ unpack(CodeContext/*!*/ context, [BytesLike][NotNull]IList<byte> @string) {

if (@string.Count != size) {

throw Error(context, $"unpack requires a bytes object of length {size}");

}

var data = @string;

int curIndex = 0;

var res = new object[_encodingCount];

var res_idx = 0;

foreach (Format curFormat in _formats) {

if (!_isStandardized) {

// In native mode, align to {size}-byte boundaries

int nativeSize = curFormat.NativeSize;

if (nativeSize > 0) {

curIndex = Align(curIndex, nativeSize);

}

}

switch (curFormat.Type) {

case FormatType.PadByte:

curIndex += curFormat.Count;

break;

case FormatType.Bool:

for (int j = 0; j < curFormat.Count; j++) {

res[res_idx++] = CreateBoolValue(context, ref curIndex, data);

}

break;

case FormatType.Char:

for (int j = 0; j < curFormat.Count; j++) {

res[res_idx++] = Bytes.FromByte(CreateCharValue(context, ref curIndex, data));

}

break;

case FormatType.SignedChar:

for (int j = 0; j < curFormat.Count; j++) {

res[res_idx++] = (int)(sbyte)CreateCharValue(context, ref curIndex, data);

}

break;

case FormatType.UnsignedChar:

for (int j = 0; j < curFormat.Count; j++) {

res[res_idx++] = (int)CreateCharValue(context, ref curIndex, data);

}

break;

case FormatType.Short:

for (int j = 0; j < curFormat.Count; j++) {

res[res_idx++] = (int)CreateShortValue(context, ref curIndex, _isLittleEndian, data);

}

break;

case FormatType.UnsignedShort:

for (int j = 0; j < curFormat.Count; j++) {

res[res_idx++] = (int)CreateUShortValue(context, ref curIndex, _isLittleEndian, data);

}

break;

case FormatType.Int:

for (int j = 0; j < curFormat.Count; j++) {

res[res_idx++] = CreateIntValue(context, ref curIndex, _isLittleEndian, data);

}

break;

case FormatType.UnsignedInt:

case FormatType.UnsignedLong:

for (int j = 0; j < curFormat.Count; j++) {

res[res_idx++] = BigIntegerOps.__int__(CreateUIntValue(context, ref curIndex, _isLittleEndian, data));

}

break;

case FormatType.Pointer:

for (int j = 0; j < curFormat.Count; j++) {

if (IntPtr.Size == 4) {

res[res_idx++] = CreateIntValue(context, ref curIndex, _isLittleEndian, data);

} else {

res[res_idx++] = BigIntegerOps.__int__(CreateLongValue(context, ref curIndex, _isLittleEndian, data));

}

}

break;

case FormatType.SignedNetPointer:

for (int j = 0; j < curFormat.Count; j++) {

if (IntPtr.Size == 4) {

res[res_idx++] = new IntPtr(CreateIntValue(context, ref curIndex, _isLittleEndian, data));

} else {

res[res_idx++] = new IntPtr(CreateLongValue(context, ref curIndex, _isLittleEndian, data));

}

}

break;

case FormatType.UnsignedNetPointer:

for (int j = 0; j < curFormat.Count; j++) {

if (IntPtr.Size == 4) {

res[res_idx++] = new UIntPtr(CreateUIntValue(context, ref curIndex, _isLittleEndian, data));

} else {

res[res_idx++] = new UIntPtr(CreateULongValue(context, ref curIndex, _isLittleEndian, data));

}

}

break;

case FormatType.SignedSizeT:

for (int j = 0; j < curFormat.Count; j++) {

res[res_idx++] = CreateIntValue(context, ref curIndex, _isLittleEndian, data);

}

break;

case FormatType.SizeT:

for (int j = 0; j < curFormat.Count; j++) {

res[res_idx++] = CreateUIntValue(context, ref curIndex, _isLittleEndian, data);

}

break;

case FormatType.LongLong:

for (int j = 0; j < curFormat.Count; j++) {

res[res_idx++] = BigIntegerOps.__int__(CreateLongValue(context, ref curIndex, _isLittleEndian, data));

}

break;

case FormatType.UnsignedLongLong:

for (int j = 0; j < curFormat.Count; j++) {

res[res_idx++] = BigIntegerOps.__int__(CreateULongValue(context, ref curIndex, _isLittleEndian, data));

}

break;

case FormatType.Float:

for (int j = 0; j < curFormat.Count; j++) {

res[res_idx++] = CreateFloatValue(context, ref curIndex, _isLittleEndian, data);

}

break;

case FormatType.Double:

for (int j = 0; j < curFormat.Count; j++) {

res[res_idx++] = CreateDoubleValue(context, ref curIndex, _isLittleEndian, data);

}

break;

case FormatType.CString:

res[res_idx++] = CreateString(context, ref curIndex, curFormat.Count, data);

break;

case FormatType.PascalString:

res[res_idx++] = CreatePascalString(context, ref curIndex, curFormat.Count - 1, data);

break;

}

}

System.Diagnostics.Debug.Assert(res_idx == res.Length);

return PythonTuple.MakeTuple(res);

}

public PythonTuple/*!*/ unpack(CodeContext/*!*/ context, [NotNull]ArrayModule.array/*!*/ buffer)

=> unpack(context, buffer.ToByteArray());

[Documentation("reads the current format from the specified array")]

public PythonTuple/*!*/ unpack_from(CodeContext/*!*/ context, [BytesLike][NotNull]IList<byte>/*!*/ buffer, int offset = 0) {

int bytesAvail = buffer.Count - offset;

if (bytesAvail < size) {

throw Error(context, $"unpack_from requires a buffer of at least {size} bytes");

}

return unpack(context, buffer.Substring(offset, size));

}

[Documentation("reads the current format from the specified array")]

public PythonTuple/*!*/ unpack_from(CodeContext/*!*/ context, [NotNull]ArrayModule.array/*!*/ buffer, int offset = 0) {

return unpack_from(context, buffer.ToByteArray(), offset);

}

[Documentation("iteratively unpack the current format from the specified array.")]

public PythonUnpackIterator iter_unpack(CodeContext/*!*/ context, [BytesLike][NotNull]IList<byte>/*!*/ buffer, int offset = 0) {

return new PythonUnpackIterator(this, context, buffer, offset);

}

[Documentation("iteratively unpack the current format from the specified array.")]

public PythonUnpackIterator iter_unpack(CodeContext/*!*/ context, [NotNull]ArrayModule.array/*!*/ buffer, int offset = 0) {

return new PythonUnpackIterator(this, context, buffer, offset);

}

[Documentation("gets the number of bytes that the serialized string will occupy or are required to deserialize the data")]

public int size {

get {

return _encodingSize;

}

}

#endregion

#region IWeakReferenceable Members

WeakRefTracker IWeakReferenceable.GetWeakRef() {

return _tracker;

}

bool IWeakReferenceable.SetWeakRef(WeakRefTracker value) {

return Interlocked.CompareExchange(ref _tracker, value, null) == null;

}

void IWeakReferenceable.SetFinalizer(WeakRefTracker value) {

_tracker = value;

}

#endregion

#region Implementation Details

private static Struct CompileAndCache(CodeContext/*!*/ context, string/*!*/ fmt) {

List<Format> res = new List<Format>();

int count = 1;

bool fLittleEndian = BitConverter.IsLittleEndian;

bool fStandardized = false;

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

switch (fmt[i]) {

case 'x': // pad byte

res.Add(new Format(FormatType.PadByte, count));

count = 1;

break;

case '?': // bool

res.Add(new Format(FormatType.Bool, count));

count = 1;

break;

case 'c': // char

res.Add(new Format(FormatType.Char, count));

count = 1;

break;

case 'b': // signed char

res.Add(new Format(FormatType.SignedChar, count));

count = 1;

break;

case 'B': // unsigned char

res.Add(new Format(FormatType.UnsignedChar, count));

count = 1;

break;

case 'h': // short

res.Add(new Format(FormatType.Short, count));

count = 1;

break;

case 'H': // unsigned short

res.Add(new Format(FormatType.UnsignedShort, count));

count = 1;

break;

case 'i': // int

case 'l': // long

res.Add(new Format(FormatType.Int, count));

count = 1;

break;

case 'I': // unsigned int

res.Add(new Format(FormatType.UnsignedInt, count));

count = 1;

break;

case 'L': // unsigned long

res.Add(new Format(FormatType.UnsignedLong, count));

count = 1;

break;

case 'q': // long long

res.Add(new Format(FormatType.LongLong, count));

count = 1;

break;

case 'Q': // unsigned long long

res.Add(new Format(FormatType.UnsignedLongLong, count));

count = 1;

break;

case 'f': // float

res.Add(new Format(FormatType.Float, count));

count = 1;

break;

case 'd': // double

res.Add(new Format(FormatType.Double, count));

count = 1;

break;

case 's': // char[]

res.Add(new Format(FormatType.CString, count));

count = 1;

break;

case 'p': // pascal char[]

res.Add(new Format(FormatType.PascalString, count));

count = 1;

break;

case 'P': // void *

res.Add(new Format(FormatType.Pointer, count));

count = 1;

break;

case 'r': // IntPtr

if (fStandardized) {

// r and R don't exist in standard sizes

throw Error(context, "bad char in struct format");

}

res.Add(new Format(FormatType.SignedNetPointer, count));

count = 1;

break;

case 'R': // UIntPtr

if (fStandardized) {

// r and R don't exist in standard sizes

throw Error(context, "bad char in struct format");

}

res.Add(new Format(FormatType.UnsignedNetPointer, count));

count = 1;

break;

case 'n': // ssize_t

if (fStandardized) {

// n and N don't exist in standard sizes

throw Error(context, "bad char in struct format");

}

res.Add(new Format(FormatType.SignedSizeT, count));

count = 1;

break;

case 'N': // size_t

if (fStandardized) {

// n and N don't exist in standard sizes

throw Error(context, "bad char in struct format");

}

res.Add(new Format(FormatType.SizeT, count));

count = 1;

break;

case ' ': // white space, ignore

case '\t':

break;

case '=': // native

if (i != 0) throw Error(context, "unexpected byte order");

fStandardized = true;

break;

case '@': // native

if (i != 0) throw Error(context, "unexpected byte order");

break;

case '<': // little endian

if (i != 0) throw Error(context, "unexpected byte order");

fLittleEndian = true;

fStandardized = true;

break;

case '>': // big endian

case '!': // big endian

if (i != 0) throw Error(context, "unexpected byte order");

fLittleEndian = false;

fStandardized = true;

break;

default:

if (char.IsDigit(fmt[i])) {

count = 0;

while (char.IsDigit(fmt[i])) {

count = count * 10 + (fmt[i] - '0');

i++;

}

if (char.IsWhiteSpace(fmt[i])) Error(context, "white space not allowed between count and format");

i--;

break;

}

throw Error(context, "bad char in struct format");

}

}

// store the new formats

var s = new Struct() {

format = fmt,

_formats = res.ToArray(),

_isStandardized = fStandardized,

_isLittleEndian = fLittleEndian,

};

s.InitCountAndSize();

lock (_cache) {

_cache.Add(fmt, s);

}

return s;

}

private void InitCountAndSize() {

var encodingCount = 0;

var encodingSize = 0;

foreach (Format format in _formats) {

if (format.Type != FormatType.PadByte) {

if (format.Type != FormatType.CString && format.Type != FormatType.PascalString) {

encodingCount += format.Count;

} else {

encodingCount++;

}

}

if (!_isStandardized) {

// In native mode, align to {size}-byte boundaries

encodingSize = Align(encodingSize, format.NativeSize);

}

encodingSize += GetNativeSize(format.Type) * format.Count;

}

_encodingCount = encodingCount;

_encodingSize = encodingSize;

}

#endregion

#region Internal helpers

internal static Struct Create(string/*!*/ format) {

Struct res = new Struct();

res.__init__(DefaultContext.Default, format); // default context is only used for errors, this better be an error free format.

return res;

}

#endregion

}

[PythonType("unpack_iterator"), Documentation("Represents an iterator returned by _struct.iter_unpack()")]

public class PythonUnpackIterator : System.Collections.IEnumerator, System.Collections.IEnumerable {

private object _iter_current;

private int _next_offset;

private readonly CodeContext _context;

private readonly IList<byte> _buffer;

private readonly int _start_offset;

private readonly Struct _owner;

private PythonUnpackIterator() { }

internal PythonUnpackIterator(Struct/*!*/ owner, CodeContext/*!*/ context, IList<byte>/*!*/ buffer, int offset) {

_context = context;

_buffer = buffer;

_start_offset = offset;

_owner = owner;

Reset();

ValidateBufferLength();

}

internal PythonUnpackIterator(Struct/*!*/ owner, CodeContext/*!*/ context, ArrayModule.array/*!*/ buffer, int offset) {

_context = context;

_buffer = buffer.ToByteArray();

_start_offset = offset;

_owner = owner;

Reset();

ValidateBufferLength();

}

private void ValidateBufferLength() {

if (_buffer.Count - _start_offset < _owner.size) {

throw Error(_context, $"iterative unpacking requires a buffer of a multiple of {_owner.size} bytes");

}

}

#region IEnumerable

[PythonHidden]

public System.Collections.IEnumerator GetEnumerator() {

return this;

}

#endregion

#region IEnumerator

[PythonHidden]

public object Current => _iter_current;

[PythonHidden]

public bool MoveNext() {

if (_buffer.Count - _next_offset < _owner.size) {

return false;

}

_iter_current = _owner.unpack_from(_context, _buffer, _next_offset);

_next_offset += _owner.size;

return true;

}

[PythonHidden]

public void Reset() {

_iter_current = null;

_next_offset = _start_offset;

}

#endregion

public object __iter__() {

return this;

}

public object __next__() {

if (!MoveNext()) {

throw PythonOps.StopIteration();

}

return Current;

}

public int __length_hint__() {

return (_buffer.Count - _next_offset) / _owner.size;

}

}

#endregion

#region Compiled Format

/// <summary>

/// Enum which specifies the format type for a compiled struct

/// </summary>

private enum FormatType {

PadByte,

Bool,

Char,

SignedChar,

UnsignedChar,