Beispiel #1
0
 public static string SimpleRepr(object self)
 {
     return(String.Format("<{0} object at {1}>",
                          PythonTypeOps.GetName(self),
                          PythonOps.HexId(self)));
 }
Beispiel #2
0
        public static object __new__(CodeContext /*!*/ context, PythonType cls, object x)
        {
            object value = null;

            if (x is string)
            {
                value = ParseFloat((string)x);
            }
            else if (x is Extensible <string> )
            {
                if (!PythonTypeOps.TryInvokeUnaryOperator(context, x, "__float__", out value))
                {
                    value = ParseFloat(((Extensible <string>)x).Value);
                }
            }
            else if (x is char)
            {
                value = ParseFloat(ScriptingRuntimeHelpers.CharToString((char)x));
            }
            else if (x is Complex)
            {
                throw PythonOps.TypeError("can't convert complex to float; use abs(z)");
            }
            else
            {
                object d = PythonOps.CallWithContext(context, PythonOps.GetBoundAttr(context, x, "__float__"));
                if (d is double)
                {
                    value = d;
                }
                else if (d is Extensible <double> )
                {
                    value = ((Extensible <double>)d).Value;
                }
                else
                {
                    throw PythonOps.TypeError("__float__ returned non-float (type {0})", PythonTypeOps.GetName(d));
                }
            }

            if (cls == TypeCache.Double)
            {
                return(value);
            }
            else
            {
                return(cls.CreateInstance(context, value));
            }
        }
        /// <summary>
        /// Implements the default __reduce_ex__ method as specified by PEP 307 case 3 (new-style instance, protocol 2)
        /// </summary>
        private static PythonTuple ReduceProtocol2(CodeContext /*!*/ context, object self)
        {
            PythonType myType = DynamicHelpers.GetPythonType(self);

            object state;

            object[] funcArgs;

            object func = context.LanguageContext.NewObject;

            object getNewArgsCallable;

            if (PythonOps.TryGetBoundAttr(context, myType, "__getnewargs__", out getNewArgsCallable))
            {
                // TypeError will bubble up if __getnewargs__ isn't callable
                PythonTuple newArgs = PythonOps.CallWithContext(context, getNewArgsCallable, self) as PythonTuple;
                if (newArgs == null)
                {
                    throw PythonOps.TypeError("__getnewargs__ should return a tuple");
                }
                funcArgs    = new object[1 + newArgs.Count];
                funcArgs[0] = myType;
                for (int i = 0; i < newArgs.Count; i++)
                {
                    funcArgs[i + 1] = newArgs[i];
                }
            }
            else
            {
                funcArgs = new object[] { myType };
            }

            if (!PythonTypeOps.TryInvokeUnaryOperator(context,
                                                      self,
                                                      "__getstate__",
                                                      out state))
            {
                object        dict;
                IPythonObject ipo = self as IPythonObject;
                if (ipo != null)
                {
                    dict = ipo.Dict;
                }
                else if (!PythonOps.TryGetBoundAttr(context, self, "__dict__", out dict))
                {
                    dict = null;
                }

                PythonDictionary initializedSlotValues = GetInitializedSlotValues(self);
                if (initializedSlotValues != null && initializedSlotValues.Count == 0)
                {
                    initializedSlotValues = null;
                }

                if (dict == null && initializedSlotValues == null)
                {
                    state = null;
                }
                else if (dict != null && initializedSlotValues == null)
                {
                    state = dict;
                }
                else if (dict != null && initializedSlotValues != null)
                {
                    state = PythonTuple.MakeTuple(dict, initializedSlotValues);
                }
                else /*dict == null && initializedSlotValues != null*/ state {
Beispiel #4
0
        public static object __new__(CodeContext context, PythonType cls, object x)
        {
            Extensible <string> es;

            if (x is string)
            {
                return(ReturnObject(context, cls, ParseBigIntegerSign((string)x, 10)));
            }
            else if ((es = x as Extensible <string>) != null)
            {
                object value;
                if (PythonTypeOps.TryInvokeUnaryOperator(context, x, "__long__", out value))
                {
                    return(ReturnObject(context, cls, (BigInteger)value));
                }

                return(ReturnObject(context, cls, ParseBigIntegerSign(es.Value, 10)));
            }
            if (x is double)
            {
                return(ReturnObject(context, cls, DoubleOps.__long__((double)x)));
            }
            if (x is int)
            {
                return(ReturnObject(context, cls, (BigInteger)(int)x));
            }
            if (x is BigInteger)
            {
                return(ReturnObject(context, cls, x));
            }

            if (x is Complex)
            {
                throw PythonOps.TypeError("can't convert complex to long; use long(abs(z))");
            }

            if (x is decimal)
            {
                return(ReturnObject(context, cls, (BigInteger)(decimal)x));
            }

            object     result;
            int        intRes;
            BigInteger bigintRes;

            if (PythonTypeOps.TryInvokeUnaryOperator(context, x, "__long__", out result) &&
                !Object.ReferenceEquals(result, NotImplementedType.Value))
            {
                if (result is int || result is BigInteger ||
                    result is Extensible <int> || result is Extensible <BigInteger> )
                {
                    return(ReturnObject(context, cls, result));
                }
                else
                {
                    throw PythonOps.TypeError("__long__ returned non-long (type {0})", PythonTypeOps.GetName(result));
                }
            }
            else if (PythonOps.TryGetBoundAttr(context, x, "__trunc__", out result))
            {
                result = PythonOps.CallWithContext(context, result);
                if (Converter.TryConvertToInt32(result, out intRes))
                {
                    return(ReturnObject(context, cls, (BigInteger)intRes));
                }
                else if (Converter.TryConvertToBigInteger(result, out bigintRes))
                {
                    return(ReturnObject(context, cls, bigintRes));
                }
                else
                {
                    throw PythonOps.TypeError("__trunc__ returned non-Integral (type {0})", PythonTypeOps.GetName(result));
                }
            }

            throw PythonOps.TypeError("long() argument must be a string or a number, not '{0}'",
                                      DynamicHelpers.GetPythonType(x).Name);
        }
Beispiel #5
0
        private static object FastNew(CodeContext /*!*/ context, object o, int @base = 10)
        {
            Extensible <BigInteger> el;

            if (o is string)
            {
                return(__new__(null, (string)o, @base));
            }
            if (o is double)
            {
                return(DoubleOps.__int__((double)o));
            }
            if (o is int)
            {
                return(o);
            }
            if (o is bool)
            {
                return(((bool)o) ? 1 : 0);
            }
            if (o is BigInteger)
            {
                int res;
                if (((BigInteger)o).AsInt32(out res))
                {
                    return(ScriptingRuntimeHelpers.Int32ToObject(res));
                }
                return(o);
            }

            if ((el = o as Extensible <BigInteger>) != null)
            {
                int res;
                if (el.Value.AsInt32(out res))
                {
                    return(ScriptingRuntimeHelpers.Int32ToObject(res));
                }
                return(el.Value);
            }

            if (o is float)
            {
                return(DoubleOps.__int__((double)(float)o));
            }

            if (o is Complex)
            {
                throw PythonOps.TypeError("can't convert complex to int; use int(abs(z))");
            }

            if (o is Int64)
            {
                Int64 val = (Int64)o;
                if (Int32.MinValue <= val && val <= Int32.MaxValue)
                {
                    return((Int32)val);
                }
                else
                {
                    return((BigInteger)val);
                }
            }
            else if (o is UInt32)
            {
                UInt32 val = (UInt32)o;
                if (val <= Int32.MaxValue)
                {
                    return((Int32)val);
                }
                else
                {
                    return((BigInteger)val);
                }
            }
            else if (o is UInt64)
            {
                UInt64 val = (UInt64)o;
                if (val <= Int32.MaxValue)
                {
                    return((Int32)val);
                }
                else
                {
                    return((BigInteger)val);
                }
            }
            else if (o is Decimal)
            {
                Decimal val = (Decimal)o;
                if (Int32.MinValue <= val && val <= Int32.MaxValue)
                {
                    return((Int32)val);
                }
                else
                {
                    return((BigInteger)val);
                }
            }
            else if (o is Enum)
            {
                return(((IConvertible)o).ToInt32(null));
            }

            if (o is Extensible <string> es)
            {
                // __int__ takes precedence, call it if it's available...
                object value;
                if (PythonTypeOps.TryInvokeUnaryOperator(DefaultContext.Default, es, "__int__", out value))
                {
                    return(value);
                }

                // otherwise call __new__ on the string value
                return(__new__(null, es.Value, @base));
            }

            object     result;
            int        intRes;
            BigInteger bigintRes;

            if (PythonTypeOps.TryInvokeUnaryOperator(context, o, "__int__", out result) &&
                !Object.ReferenceEquals(result, NotImplementedType.Value))
            {
                if (result is int || result is BigInteger ||
                    result is Extensible <int> || result is Extensible <BigInteger> )
                {
                    return(result);
                }
                else
                {
                    throw PythonOps.TypeError("__int__ returned non-Integral (type {0})", PythonTypeOps.GetName(result));
                }
            }
            else if (PythonOps.TryGetBoundAttr(context, o, "__trunc__", out result))
            {
                result = PythonOps.CallWithContext(context, result);
                if (result is int || result is BigInteger ||
                    result is Extensible <int> || result is Extensible <BigInteger> )
                {
                    return(result);
                }
                else if (Converter.TryConvertToInt32(result, out intRes))
                {
                    return(intRes);
                }
                else if (Converter.TryConvertToBigInteger(result, out bigintRes))
                {
                    return(bigintRes);
                }
                else
                {
                    throw PythonOps.TypeError("__trunc__ returned non-Integral (type {0})", PythonTypeOps.GetName(result));
                }
            }

            throw PythonOps.TypeError("int() argument must be a string or a number, not '{0}'", PythonTypeOps.GetName(o));
        }
Beispiel #6
0
        internal static void CheckInitArgs(CodeContext context, IDictionary <object, object> dict, object[] args, object self)
        {
            if (((args != null && args.Length > 0) || (dict != null && dict.Count > 0)))
            {
                PythonType pt            = DynamicHelpers.GetPythonType(self);
                bool       hasObjectInit = pt.HasObjectInit(context);
                bool       hasObjectNew  = pt.HasObjectNew(context);

                // NoneType seems to get some special treatment (None.__init__('abc') works)
                if (hasObjectNew && self != null)
                {
                    throw PythonOps.TypeError("object.__init__() takes no parameters");
                }
                else if ((!hasObjectNew && !hasObjectInit) || self == null)
                {
                    PythonOps.Warn(context, PythonExceptions.DeprecationWarning, "object.__init__() takes no parameters for type {0}", PythonTypeOps.GetName(self));
                }
            }
        }
Beispiel #7
0
        public static object __new__(CodeContext context, PythonType cls, [Optional] object?real, [Optional] object?imag)
        {
            if (real == null)
            {
                throw PythonOps.TypeError($"complex() first argument must be a string or a number, not '{PythonTypeOps.GetName(real)}'");
            }
            if (imag == null)
            {
                throw PythonOps.TypeError($"complex() second argument must be a number, not '{PythonTypeOps.GetName(real)}'");
            }

            Complex imag2;

            if (imag is Missing)
            {
                imag2 = Complex.Zero;
            }
            else
            {
                if (real is string)
                {
                    throw PythonOps.TypeError("complex() can't take second arg if first is a string");
                }
                if (imag is string)
                {
                    throw PythonOps.TypeError("complex() second arg can't be a string");
                }
                if (!Converter.TryConvertToComplex(imag, out imag2))
                {
                    throw PythonOps.TypeError($"complex() second argument must be a number, not '{PythonTypeOps.GetName(real)}'");
                }
            }

            Complex real2;

            if (real is Missing)
            {
                real2 = Complex.Zero;
            }
            else if (real is string)
            {
                real2 = LiteralParser.ParseComplex((string)real);
            }
            else if (real is Extensible <string> )
            {
                real2 = LiteralParser.ParseComplex(((Extensible <string>)real).Value);
            }
            else if (real is Complex)
            {
                if (imag is Missing && cls == TypeCache.Complex)
                {
                    return(real);
                }
                else
                {
                    real2 = (Complex)real;
                }
            }
            else if (!Converter.TryConvertToComplex(real, out real2))
            {
                throw PythonOps.TypeError($"complex() first argument must be a string or a number, not '{PythonTypeOps.GetName(real)}'");
            }

            double real3 = real2.Real - imag2.Imaginary;
            double imag3 = real2.Imaginary + imag2.Real;

            if (cls == TypeCache.Complex)
            {
                return(new Complex(real3, imag3));
            }
            else
            {
                return(cls.CreateInstance(context, real3, imag3));
            }
        }
Beispiel #8
0
 internal static IList <byte> CoerceBytes(object obj)
 {
     if (!(obj is IList <byte> ret))
     {
         throw PythonOps.TypeError("a bytes-like object is required, not '{0}'", PythonTypeOps.GetName(obj));
     }
     return(ret);
 }
Beispiel #9
0
        private static PythonTuple ReduceProtocol2(CodeContext /*!*/ context, object self)
        {
            // builtin types which can't be pickled (due to tp_itemsize != 0)
            if (self is MemoryView)
            {
                throw PythonOps.TypeError("can't pickle memoryview objects");
            }

            PythonType myType = DynamicHelpers.GetPythonType(self);

            object?state;

            object?[] funcArgs;

            var copyreg = context.LanguageContext.GetCopyRegModule();
            var func    = PythonOps.GetBoundAttr(context, copyreg, "__newobj__");

            if (PythonOps.TryGetBoundAttr(context, myType, "__getnewargs__", out object?getNewArgsCallable))
            {
                // TypeError will bubble up if __getnewargs__ isn't callable
                if (!(PythonOps.CallWithContext(context, getNewArgsCallable, self) is PythonTuple newArgs))
                {
                    throw PythonOps.TypeError("__getnewargs__ should return a tuple");
                }
                funcArgs    = new object[1 + newArgs.Count];
                funcArgs[0] = myType;
                for (int i = 0; i < newArgs.Count; i++)
                {
                    funcArgs[i + 1] = newArgs[i];
                }
            }
            else
            {
                funcArgs = new object[] { myType };
            }

            if (!PythonTypeOps.TryInvokeUnaryOperator(context,
                                                      self,
                                                      "__getstate__",
                                                      out state))
            {
                object?dict;
                if (self is IPythonObject ipo)
                {
                    dict = ipo.Dict;
                }
                else if (!PythonOps.TryGetBoundAttr(context, self, "__dict__", out dict))
                {
                    dict = null;
                }

                PythonDictionary?initializedSlotValues = GetInitializedSlotValues(self);
                if (initializedSlotValues != null && initializedSlotValues.Count == 0)
                {
                    initializedSlotValues = null;
                }

                if (dict == null && initializedSlotValues == null)
                {
                    state = null;
                }
                else if (dict != null && initializedSlotValues == null)
                {
                    state = dict;
                }
                else if (dict != null && initializedSlotValues != null)
                {
                    state = PythonTuple.MakeTuple(dict, initializedSlotValues);
                }
                else /*dict == null && initializedSlotValues != null*/ state {
Beispiel #10
0
        public static string __format__(CodeContext /*!*/ context, object self, [NotNull] string /*!*/ formatSpec)
        {
            if (formatSpec != string.Empty)
            {
                throw PythonOps.TypeError("unsupported format string passed to {0}.__format__", PythonTypeOps.GetName(self));
            }

            return(PythonOps.ToString(context, self));
        }