private Converter() {}

static NumberFormatInfo nfi;

static Type objectType;

static Type stringType;

static Type doubleType;

static Type int32Type;

static Type int64Type;

static Type flagsType;

static Type boolType;

//static Type typeType;

static Converter () {

nfi = NumberFormatInfo.InvariantInfo;

objectType = typeof(Object);

stringType = typeof(String);

int32Type = typeof(Int32);

int64Type = typeof(Int64);

doubleType = typeof(Double);

flagsType = typeof(FlagsAttribute);

boolType = typeof(Boolean);

//typeType = typeof(Type);

}

//====================================================================

// Given a builtin Python type, return the corresponding CLR type.

//====================================================================

internal static Type GetTypeByAlias(IntPtr op) {

if ((op == Runtime.PyStringType) ||

(op == Runtime.PyUnicodeType)) {

return stringType;

}

else if (op == Runtime.PyIntType) {

return int32Type;

}

else if (op == Runtime.PyLongType) {

return int64Type;

}

else if (op == Runtime.PyFloatType) {

return doubleType;

}

else if (op == Runtime.PyBoolType) {

return boolType;

}

return null;

}

//====================================================================

// Return a Python object for the given native object, converting

// basic types (string, int, etc.) into equivalent Python objects.

// This always returns a new reference. Note that the System.Decimal

// type has no Python equivalent and converts to a managed instance.

//====================================================================

internal static IntPtr ToPython(Object value, Type type) {

IntPtr result = IntPtr.Zero;

// Null always converts to None in Python.

if (value == null) {

result = Runtime.PyNone;

Runtime.Incref(result);

return result;

}

// hmm - from Python, we almost never care what the declared

// type is. we'd rather have the object bound to the actual

// implementing class.

type = value.GetType();

TypeCode tc = Type.GetTypeCode(type);

switch(tc) {

case TypeCode.Object:

result = CLRObject.GetInstHandle(value, type);

// XXX - hack to make sure we convert new-style class based

// managed exception instances to wrappers ;(

if (Runtime.wrap_exceptions) {

Exception e = value as Exception;

if (e != null) {

return Exceptions.GetExceptionInstanceWrapper(result);

}

}

return result;

case TypeCode.String:

return Runtime.PyUnicode_FromString((string)value);

case TypeCode.Int32:

return Runtime.PyInt_FromInt32((int)value);

case TypeCode.Boolean:

if ((bool)value) {

Runtime.Incref(Runtime.PyTrue);

return Runtime.PyTrue;

}

Runtime.Incref(Runtime.PyFalse);

return Runtime.PyFalse;

case TypeCode.Byte:

return Runtime.PyInt_FromInt32((int)((byte)value));

case TypeCode.Char:

return Runtime.PyUnicode_FromOrdinal((int)((char)value));

case TypeCode.Int16:

return Runtime.PyInt_FromInt32((int)((short)value));

case TypeCode.Int64:

return Runtime.PyLong_FromLongLong((long)value);

case TypeCode.Single:

// return Runtime.PyFloat_FromDouble((double)((float)value));

string ss = ((float)value).ToString(nfi);

IntPtr ps = Runtime.PyString_FromString(ss);

IntPtr op = Runtime.PyFloat_FromString(ps, IntPtr.Zero);

Runtime.Decref(ps);

return op;

case TypeCode.Double:

return Runtime.PyFloat_FromDouble((double)value);

case TypeCode.SByte:

return Runtime.PyInt_FromInt32((int)((sbyte)value));

case TypeCode.UInt16:

return Runtime.PyInt_FromInt32((int)((ushort)value));

case TypeCode.UInt32:

return Runtime.PyLong_FromUnsignedLong((uint)value);

case TypeCode.UInt64:

return Runtime.PyLong_FromUnsignedLongLong((ulong)value);

default:

result = CLRObject.GetInstHandle(value, type);

return result;

}

}

//====================================================================

// In a few situations, we don't have any advisory type information

// when we want to convert an object to Python.

//====================================================================

internal static IntPtr ToPythonImplicit(Object value) {

if (value == null) {

IntPtr result = Runtime.PyNone;

Runtime.Incref(result);

return result;

}

return ToPython(value, objectType);

}

//====================================================================

// Return a managed object for the given Python object, taking funny

// byref types into account.

//====================================================================

internal static bool ToManaged(IntPtr value, Type type,

out object result, bool setError) {

if (type.IsByRef) {

type = type.GetElementType();

}

return Converter.ToManagedValue(value, type, out result, setError);

}

internal static bool ToManagedValue(IntPtr value, Type obType,

out Object result, bool setError) {

// Common case: if the Python value is a wrapped managed object

// instance, just return the wrapped object.

ManagedType mt = ManagedType.GetManagedObject(value);

result = null;

// XXX - hack to support objects wrapped in old-style classes

// (such as exception objects).

if (Runtime.wrap_exceptions) {

if (mt == null) {

if (Runtime.PyObject_IsInstance(

value, Exceptions.Exception

) > 0) {

IntPtr p = Runtime.PyObject_GetAttrString(value, "_inner");

if (p != IntPtr.Zero) {

// This is safe because we know that the __dict__ of

// value holds a reference to _inner.

value = p;

Runtime.Decref(p);

mt = ManagedType.GetManagedObject(value);

}

}

IntPtr c = Exceptions.UnwrapExceptionClass(value);

if ((c != IntPtr.Zero) && (c != value)) {

value = c;

Runtime.Decref(c);

mt = ManagedType.GetManagedObject(value);

}

}

}

if (mt != null) {

if (mt is CLRObject) {

object tmp = ((CLRObject)mt).inst;

if (obType.IsInstanceOfType(tmp)) {

result = tmp;

return true;

}

string err = "value cannot be converted to {0}";

err = String.Format(err, obType);

Exceptions.SetError(Exceptions.TypeError, err);

return false;

}

if (mt is ClassBase) {

result = ((ClassBase)mt).type;

return true;

}

// shouldnt happen

return false;

}

if (value == Runtime.PyNone && !obType.IsValueType) {

result = null;

return true;

}

if (obType.IsArray) {

return ToArray(value, obType, out result, setError);

}

if (obType.IsEnum) {

return ToEnum(value, obType, out result, setError);

}

// Conversion to 'Object' is done based on some reasonable

// default conversions (Python string -> managed string,

// Python int -> Int32 etc.).

if (obType == objectType) {

if (Runtime.IsStringType(value)) {

return ToPrimitive(value, stringType, out result,

setError);

}

else if (Runtime.PyBool_Check(value)) {

return ToPrimitive(value, boolType, out result, setError);

}

else if (Runtime.PyInt_Check(value)) {

return ToPrimitive(value, int32Type, out result, setError);

}

else if (Runtime.PyLong_Check(value)) {

return ToPrimitive(value, int64Type, out result, setError);

}

else if (Runtime.PyFloat_Check(value)) {

return ToPrimitive(value, doubleType, out result, setError);

}

else if (Runtime.PySequence_Check(value)) {

return ToArray(value, typeof(object[]), out result,

setError);

}

if (setError) {

Exceptions.SetError(Exceptions.TypeError,

"value cannot be converted to Object"

);

}

return false;

}

return ToPrimitive(value, obType, out result, setError);

}

//====================================================================

// Convert a Python value to an instance of a primitive managed type.

//====================================================================

static bool ToPrimitive(IntPtr value, Type obType, out Object result,

bool setError) {

IntPtr overflow = Exceptions.OverflowError;

TypeCode tc = Type.GetTypeCode(obType);

result = null;

IntPtr op;

int ival;

switch(tc) {

case TypeCode.String:

string st = Runtime.GetManagedString(value);

if (st == null) {

goto type_error;

}

result = st;

return true;

case TypeCode.Int32:

// Trickery to support 64-bit platforms.

if (IntPtr.Size == 4) {

op = Runtime.PyNumber_Int(value);

// As of Python 2.3, large ints magically convert :(

if (Runtime.PyLong_Check(op) ) {

Runtime.Decref(op);

goto overflow;

}

if (op == IntPtr.Zero) {

if (Exceptions.ExceptionMatches(overflow)) {

goto overflow;

}

goto type_error;

}

ival = (int)Runtime.PyInt_AsLong(op);

Runtime.Decref(op);

result = ival;

return true;

}

else {

op = Runtime.PyNumber_Long(value);

if (op == IntPtr.Zero) {

if (Exceptions.ExceptionMatches(overflow)) {

goto overflow;

}

goto type_error;

}

long ll = (long)Runtime.PyLong_AsLongLong(op);

Runtime.Decref(op);

if ((ll == -1) && Exceptions.ErrorOccurred()) {

goto overflow;

}

if (ll > Int32.MaxValue || ll < Int32.MinValue) {

goto overflow;

}

result = (int)ll;

return true;

}

case TypeCode.Boolean:

result = (Runtime.PyObject_IsTrue(value) != 0);

return true;

case TypeCode.Byte:

if (Runtime.PyObject_TypeCheck(value, Runtime.PyStringType)) {

if (Runtime.PyString_Size(value) == 1) {

op = Runtime.PyString_AS_STRING(value);

result = (byte)Marshal.ReadByte(op);

return true;

}

goto type_error;

}

op = Runtime.PyNumber_Int(value);

if (op == IntPtr.Zero) {

if (Exceptions.ExceptionMatches(overflow)) {

goto overflow;

}

goto type_error;

}

ival = (int) Runtime.PyInt_AsLong(op);

Runtime.Decref(op);

if (ival > Byte.MaxValue || ival < Byte.MinValue) {

goto overflow;

}

byte b = (byte) ival;

result = b;

return true;

case TypeCode.SByte:

if (Runtime.PyObject_TypeCheck(value, Runtime.PyStringType)) {

if (Runtime.PyString_Size(value) == 1) {

op = Runtime.PyString_AS_STRING(value);

result = (sbyte)Marshal.ReadByte(op);

return true;

}

goto type_error;

}

op = Runtime.PyNumber_Int(value);

if (op == IntPtr.Zero) {

if (Exceptions.ExceptionMatches(overflow)) {

goto overflow;

}

goto type_error;

}

ival = (int) Runtime.PyInt_AsLong(op);

Runtime.Decref(op);

if (ival > SByte.MaxValue || ival < SByte.MinValue) {

goto overflow;

}

sbyte sb = (sbyte) ival;

result = sb;

return true;

case TypeCode.Char:

if (Runtime.PyObject_TypeCheck(value, Runtime.PyStringType)) {

if (Runtime.PyString_Size(value) == 1) {

op = Runtime.PyString_AS_STRING(value);

result = (char)Marshal.ReadByte(op);

return true;

}

goto type_error;

}

else if (Runtime.PyObject_TypeCheck(value,

Runtime.PyUnicodeType)) {

if (Runtime.PyUnicode_GetSize(value) == 1) {

op = Runtime.PyUnicode_AS_UNICODE(value);

#if (!UCS4)

// 2011-01-02: Marshal as character array because the cast

// result = (char)Marshal.ReadInt16(op); throws an OverflowException

// on negative numbers with Check Overflow option set on the project

Char[] buff = new Char[1];

Marshal.Copy(op, buff, 0, 1);

result = buff[0];

#else

// XXX this is probably NOT correct?

result = (char)Marshal.ReadInt32(op);

#endif

return true;

}

goto type_error;

}

op = Runtime.PyNumber_Int(value);

if (op == IntPtr.Zero) {

goto type_error;

}

ival = Runtime.PyInt_AsLong(op);

if (ival > Char.MaxValue || ival < Char.MinValue) {

goto overflow;

}

Runtime.Decref(op);

result = (char)ival;

return true;

case TypeCode.Int16:

op = Runtime.PyNumber_Int(value);

if (op == IntPtr.Zero) {

if (Exceptions.ExceptionMatches(overflow)) {

goto overflow;

}

goto type_error;

}

ival = (int) Runtime.PyInt_AsLong(op);

Runtime.Decref(op);

if (ival > Int16.MaxValue || ival < Int16.MinValue) {

goto overflow;

}

short s = (short) ival;

result = s;

return true;

case TypeCode.Int64:

op = Runtime.PyNumber_Long(value);

if (op == IntPtr.Zero) {

if (Exceptions.ExceptionMatches(overflow)) {

goto overflow;

}

goto type_error;

}

long l = (long)Runtime.PyLong_AsLongLong(op);

Runtime.Decref(op);

if ((l == -1) && Exceptions.ErrorOccurred()) {

goto overflow;

}

result = l;

return true;

case TypeCode.UInt16:

op = Runtime.PyNumber_Int(value);

if (op == IntPtr.Zero) {

if (Exceptions.ExceptionMatches(overflow)) {

goto overflow;

}

goto type_error;

}

ival = (int) Runtime.PyInt_AsLong(op);

Runtime.Decref(op);

if (ival > UInt16.MaxValue || ival < UInt16.MinValue) {

goto overflow;

}

ushort us = (ushort) ival;

result = us;

return true;

case TypeCode.UInt32:

op = Runtime.PyNumber_Long(value);

if (op == IntPtr.Zero) {

if (Exceptions.ExceptionMatches(overflow)) {

goto overflow;

}

goto type_error;

}

uint ui = (uint)Runtime.PyLong_AsUnsignedLong(op);

Runtime.Decref(op);

if (Exceptions.ErrorOccurred()) {

goto overflow;

}

result = ui;

return true;

case TypeCode.UInt64:

op = Runtime.PyNumber_Long(value);

if (op == IntPtr.Zero) {

if (Exceptions.ExceptionMatches(overflow)) {

goto overflow;

}

goto type_error;

}

ulong ul = (ulong)Runtime.PyLong_AsUnsignedLongLong(op);

Runtime.Decref(op);

if (Exceptions.ErrorOccurred()) {

goto overflow;

}

result = ul;

return true;

case TypeCode.Single:

op = Runtime.PyNumber_Float(value);

if (op == IntPtr.Zero) {

if (Exceptions.ExceptionMatches(overflow)) {

goto overflow;

}

goto type_error;

}

double dd = Runtime.PyFloat_AsDouble(value);

if (dd > Single.MaxValue || dd < Single.MinValue) {

goto overflow;

}

result = (float)dd;

return true;

case TypeCode.Double:

op = Runtime.PyNumber_Float(value);

if (op == IntPtr.Zero) {

goto type_error;

}

double d = Runtime.PyFloat_AsDouble(op);

Runtime.Decref(op);

if (d > Double.MaxValue || d < Double.MinValue) {

goto overflow;

}

result = d;

return true;

}

type_error:

if (setError) {

string format = "'{0}' value cannot be converted to {1}";

string tpName = Runtime.PyObject_GetTypeName(value);

string error = String.Format(format, tpName, obType);

Exceptions.SetError(Exceptions.TypeError, error);

}

return false;

overflow:

if (setError) {

string error = "value too large to convert";

Exceptions.SetError(Exceptions.OverflowError, error);

}

return false;

}

static void SetConversionError(IntPtr value, Type target) {

IntPtr ob = Runtime.PyObject_Repr(value);

string src = Runtime.GetManagedString(ob);

Runtime.Decref(ob);

string error = String.Format(

"Cannot convert {0} to {1}", src, target

);

Exceptions.SetError(Exceptions.TypeError, error);

}

//====================================================================

// Convert a Python value to a correctly typed managed array instance.

// The Python value must support the Python sequence protocol and the

// items in the sequence must be convertible to the target array type.

//====================================================================

static bool ToArray(IntPtr value, Type obType, out Object result,

bool setError) {

Type elementType = obType.GetElementType();

int size = Runtime.PySequence_Size(value);

result = null;

if (size < 0) {

if (setError) {

SetConversionError(value, obType);

}

return false;

}

Array items = Array.CreateInstance(elementType, size);

// XXX - is there a better way to unwrap this if it is a real

// array?

for (int i = 0; i < size; i++) {

Object obj = null;

IntPtr item = Runtime.PySequence_GetItem(value, i);

if (item == IntPtr.Zero) {

if (setError) {

SetConversionError(value, obType);

return false;

}

}

if (!Converter.ToManaged(item, elementType, out obj, true)) {

Runtime.Decref(item);

return false;

}

items.SetValue(obj, i);

Runtime.Decref(item);

}

result = items;

return true;

}

//====================================================================

// Convert a Python value to a correctly typed managed enum instance.

//====================================================================

static bool ToEnum(IntPtr value, Type obType, out Object result,

bool setError) {

Type etype = Enum.GetUnderlyingType(obType);

result = null;

if (!ToPrimitive(value, etype, out result, setError)) {

return false;

}

if (Enum.IsDefined(obType, result)) {

result = Enum.ToObject(obType, result);

return true;

}

if (obType.GetCustomAttributes(flagsType, true).Length > 0) {

result = Enum.ToObject(obType, result);

return true;

}

if (setError) {

string error = "invalid enumeration value";

Exceptions.SetError(Exceptions.ValueError, error);

}

return false;

}