[GR-34916] Intrinsify python_cext - PyLong/Float/Complex/Number_XXX.

PullRequest: graalpython/2041

Author: tomasstupka

graalpython/com.oracle.graal.python.cext/src/abstract.c

@@ -58,11 +58,7 @@ static PyObject* null_error(void) {
 
 UPCALL_ID(PyNumber_Check);
 int PyNumber_Check(PyObject *o) {
-    PyObject *result = UPCALL_CEXT_O(_jls_PyNumber_Check, native_to_java(o));
-    if(result == Py_True) {
-    	return 1;
-    }
-    return 0;
+    return UPCALL_CEXT_I(_jls_PyNumber_Check, native_to_java(o));
 }
 
 typedef PyObject *(*unaryop_fun_t)(PyObject *, int32_t);

graalpython/com.oracle.graal.python.test/src/tests/cpyext/test_abstract.py

@@ -51,8 +51,26 @@ def _safe_check(v, type_check):
 
 def _reference_checknumber(args):
     v = args[0]
+    if isinstance(v, str):
+        return False
     return _safe_check(v, lambda x: isinstance(int(x), int)) or _safe_check(v, lambda x: isinstance(float(x), float))
 
+def _reference_tobase(args):
+    n = args[0]
+    base = args[1]
+    if base not in (2, 8, 10, 16):
+        raise SystemError("PyNumber_ToBase: base must be 2, 8, 10 or 16")
+    if not hasattr(n, "__index__"):
+        raise TypeError
+    b_index = n.__index__()
+    if base == 2:
+        return bin(b_index)
+    elif base == 8:
+        return oct(b_index)
+    elif base == 10:
+        return str(b_index)
+    elif base == 16:
+        return hex(b_index)
 
 def _reference_index(args):
     v = args[0]
@@ -205,6 +223,7 @@ def _default_unarop_args():
         (False,),
         (True,),
         ("hello",),
+        ("1",),
         ((1, 2, 3),),
         (0x7fffffff,),
         (0xffffffffffffffffffffffffffffffff,),
@@ -259,6 +278,55 @@ def compile_module(self, name):
         cmpfunc=unhandled_error_compare
     )
 
+    test_PyNumber_ToBase = CPyExtFunction(
+        _reference_tobase,
+        lambda: (
+            (2, 0),
+            ("hello", 0),
+            (1.1, 0),
+            (NoNumber(), 0),
+            (2, 0),
+            (2, 0),
+            (2, 2),
+            (2, 8),
+            (2, 10),
+            (2, 16),
+            ("1", 2),
+            ("1", 8),
+            ("1", 10),
+            ("1", 16),
+            (1.1, 2),
+            (1.1, 8),
+            (1.1, 10),
+            (1.1, 16),
+            (False, 2),
+            (False, 8),
+            (False, 10),
+            (False, 16),
+            (True, 16),
+            ("hello, ", 2),
+            ("hello, ", 8),
+            ("hello, ", 10),
+            ("hello, ", 16),
+            (DummyIntable(), 2),
+            (DummyIntable(), 8),
+            (DummyIntable(), 10),
+            (DummyIntable(), 16),
+            (DummyIntSubclass(), 2),
+            (DummyIntSubclass(), 8),
+            (DummyIntSubclass(), 10),
+            (DummyIntSubclass(), 16),
+            (NoNumber(), 2),
+            (NoNumber(), 8),
+            (NoNumber(), 10),
+            (NoNumber(), 16),
+        ),
+        resultspec="O",
+        argspec='Oi',
+        arguments=["PyObject* n", "int base"],
+        cmpfunc=unhandled_error_compare
+    )
+
     test_PyNumber_Add = CPyExtFunction(
         lambda args: args[0] + args[1],
         lambda: (
@@ -482,6 +550,7 @@ def compile_module(self, name):
             (1,),
             (-1,),
             (1.0,),
+            ("1",),
             (0x7FFFFFFF,),
             (0x7FFFFFFFFFFFFFFF,),
             (DummyIntable(),),
@@ -522,6 +591,7 @@ def compile_module(self, name):
             (1,),
             (-1,),
             (1.0,),
+            ("1",),
             (0x7FFFFFFF,),
             (0x7FFFFFFFFFFFFFFF,),
             (DummyIntable(),),

graalpython/com.oracle.graal.python.test/src/tests/cpyext/test_complex.py

@@ -65,7 +65,11 @@ def _reference_realasdouble(args):
             raise SystemError
         else:
             return -1.0
-
+        
+def _reference_fromdoubles(args):
+    if isinstance(args[0], float) and isinstance(args[1], float):
+        return complex(args[0], args[1])
+    raise SystemError
 
 class DummyNonComplex():
     pass
@@ -167,3 +171,15 @@ def compile_module(self, name):
         arguments=["PyObject* obj"],
         cmpfunc=unhandled_error_compare
     )
+    
+    test_PyComplex_FromDoubles = CPyExtFunction(
+        _reference_fromdoubles,
+        lambda: (
+            (float(0.0), float(2.0), ),
+            (1.0, 2.0, ),
+        ),
+        resultspec="O",
+        argspec='dd',
+        arguments=["double r", "double i"],
+        cmpfunc=unhandled_error_compare
+    )

graalpython/com.oracle.graal.python.test/src/tests/cpyext/test_long.py

@@ -41,7 +41,12 @@
 from . import CPyExtTestCase, CPyExtFunction, CPyExtFunctionOutVars, unhandled_error_compare, GRAALPYTHON
 __dir__ = __file__.rpartition("/")[0]
 
-
+def raise_Py6_SystemError():
+    if sys.version_info.minor >= 6:
+        raise SystemError
+    else:
+        return -1
+    
 def _reference_aslong(args):
     # We cannot be sure if we are on 32-bit or 64-bit architecture. So, assume the smaller one.
     n = int(args[0])
@@ -88,6 +93,14 @@ def _reference_fromlong(args):
     n = args[0]
     return n
 
+def _reference_sign(args):
+    n = args[0]
+    if n==0:
+        return 0
+    elif n < 0:
+        return -1
+    else:
+        return 1
 
 class DummyNonInt():
     pass
@@ -395,3 +408,19 @@ def compile_module(self, name):
         argspec="OniiO",
         arguments=["PyObject* object", "Py_ssize_t n", "int little_endian", "int is_signed", "PyObject* unused"],
     )
+    
+    test__PyLong_Sign = CPyExtFunction(
+        _reference_sign,
+        lambda: (
+            (0,),
+            (-1,),
+            (0xffffffff,),
+            (0xfffffffffffffffffffffff,),
+            (True,),
+            (False,),
+        ),
+        resultspec="i",
+        argspec='O',
+        arguments=["PyObject* o"],
+        cmpfunc=unhandled_error_compare
+    )

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/BuiltinConstructors.java

@@ -356,7 +356,7 @@ public PByteArray setEmpty(Object cls, @SuppressWarnings("unused") Object arg) {
                                     "Create a complex number from a real part and an optional imaginary part.\n" +
                                     "This is equivalent to (real + imag*1j) where imag defaults to 0.")
     @GenerateNodeFactory
-    public abstract static class ComplexNode extends PythonBuiltinNode {
+    public abstract static class ComplexNode extends PythonTernaryBuiltinNode {
 
         @Child private IsBuiltinClassProfile isPrimitiveProfile = IsBuiltinClassProfile.create();
         @Child private IsBuiltinClassProfile isComplexTypeProfile;

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/BuiltinFunctions.java

@@ -91,6 +91,8 @@
 import com.oracle.graal.python.builtins.PythonBuiltins;
 import com.oracle.graal.python.builtins.modules.BuiltinFunctionsFactory.GetAttrNodeFactory;
 import com.oracle.graal.python.builtins.modules.BuiltinFunctionsFactory.GlobalsNodeFactory;
+import com.oracle.graal.python.builtins.modules.BuiltinFunctionsFactory.HexNodeFactory;
+import com.oracle.graal.python.builtins.modules.BuiltinFunctionsFactory.OctNodeFactory;
 import com.oracle.graal.python.builtins.modules.WarningsModuleBuiltins.WarnNode;
 import com.oracle.graal.python.builtins.modules.io.IOModuleBuiltins;
 import com.oracle.graal.python.builtins.modules.io.IONodes;
@@ -611,6 +613,10 @@ protected String longToString(long x) {
         protected String prefix() {
             return "0o";
         }
+
+        public static OctNode create() {
+            return OctNodeFactory.create();
+        }
     }
 
     // hex(object)
@@ -634,6 +640,10 @@ protected String longToString(long x) {
         protected String prefix() {
             return "0x";
         }
+
+        public static HexNode create() {
+            return HexNodeFactory.create();
+        }
     }
 
     // callable(object)