Add templates for int, float, str method classes

Mostly unchanged from VSJ4. [skip-ci]

Author: jeff5

rt4core/src/main/javaTemplate/uk/co/farowl/vsj4/runtime/PyFloatBinops.java

@@ -0,0 +1,41 @@
+// Copyright (c)2025 Jython Developers.
+// Licensed to PSF under a contributor agreement.
+package uk.co.farowl.vsj4.runtime;
+
+import java.math.BigInteger;
+import static uk.co.farowl.vsj4.runtime.PyLong.convertToDouble;
+import static uk.co.farowl.vsj4.runtime.PyFloat.nonzero;
+
+// $OBJECT_GENERATOR$ PyFloatGenerator
+
+/**
+ * This class contains static methods implementing operations on the
+ * Python {@code float} object, supplementary to those defined in
+ * {@link PyFloat} and {@link PyFloatMethods}. These exist in order to
+ * support {@code CallSite} creation.
+ * <p>
+ * Implementations are not allowed to return {@link Py#NotImplemented}.
+ * If a binary operation is not defined here, for the pair of Java
+ * classes that type the arguments, the operation is not defined for the
+ * pair of their Python types.
+ * <p>
+ * When matching, we allow a signature here to match if it matches a
+ * type assignable in Java to the class of the argument in question.
+ * Types providing this compatibility must not be too broad,
+ * {@code Object} for example, as this would make it necessary to return
+ * {@link Py#NotImplemented}.
+ * <p>
+ * It follows that if a signature {@code f(A, B)} appears, where
+ * {@code A} is an accepted implementation of Python type {@code P}, and
+ * {@code B} is an accepted implementation of Python type {@code Q},
+ * {@code f(a, b)} must be present, or a signature with compatible
+ * types, for every accepted implementation {@code a} of {@code P} and
+ * {@code b} of {@code Q}. It is the responsibility of the script
+ * generating this class to ensure this condition is satisfied.
+ */
+class PyFloatBinops {
+
+    private PyFloatBinops() {}  // no instances
+
+    // $SPECIAL_BINOPS$ --------------------------------------------
+}

rt4core/src/main/javaTemplate/uk/co/farowl/vsj4/runtime/PyFloatMethods.java

@@ -0,0 +1,60 @@
+// Copyright (c)2025 Jython Developers.
+// Licensed to PSF under a contributor agreement.
+package uk.co.farowl.vsj4.runtime;
+
+// $OBJECT_GENERATOR$ PyFloatGenerator
+
+import uk.co.farowl.vsj4.runtime.PyUtil.NoConversion;
+import static uk.co.farowl.vsj4.runtime.PyFloat.nonzero;
+import static uk.co.farowl.vsj4.runtime.PyFloat.floordiv;
+import static uk.co.farowl.vsj4.runtime.PyFloat.mod;
+import static uk.co.farowl.vsj4.runtime.PyFloat.divmod;
+
+/**
+ * This class contains static methods implementing operations on the
+ * Python {@code float} object, supplementary to those defined in
+ * {@link PyFloat}.
+ * <p>
+ * These methods may cause creation of descriptors in the dictionary of
+ * the type. Those with reserved names in the data model will also fill
+ * slots in the {@code Operations} object for the type.
+ * <p>
+ * Implementations of binary operations defined here will have
+ * {@code Object} as their second argument, and should return
+ * {@link Py#NotImplemented} when the type in that position is not
+ * supported.
+ */
+class PyFloatMethods {
+
+    PyFloatMethods() {}  // no instances
+
+    // $SPECIAL_METHODS$ ---------------------------------------------
+
+    // plumbing ------------------------------------------------------
+
+    /**
+     * Convert an object to a Java double. Conversion to a double may
+     * raise an exception that is propagated to the caller. If the
+     * method throws the special exception {@link NoConversion}, the
+     * caller must catch it, and will normally return
+     * {@link Py#NotImplemented}.
+     * 
+     * @param v to convert
+     * @return converted to {@code double}
+     * @throws NoConversion v is not a {@code float} or {@code int}
+     * @throws PyBaseException (OverflowError) v is an {@code int} too
+     *     large to be a {@code float}
+     */
+    static double toDouble(Object v)
+            throws NoConversion, PyBaseException {
+        // Check against supported types, most likely first
+        if (v instanceof Double)
+            return ((Double)v).doubleValue();
+        else if (v instanceof PyFloat)
+            return ((PyFloat)v).value;
+        else
+            // BigInteger, PyLong, Boolean, etc.
+            // or throw PyObjectUtil.NO_CONVERSION;
+            return PyLong.convertToDouble(v);
+    }
+}

rt4core/src/main/javaTemplate/uk/co/farowl/vsj4/runtime/PyLongBinops.java

@@ -0,0 +1,47 @@
+// Copyright (c)2025 Jython Developers.
+// Licensed to PSF under a contributor agreement.
+package uk.co.farowl.vsj4.runtime;
+
+// $OBJECT_GENERATOR$ PyLongGenerator
+
+import java.math.BigInteger;
+import static java.math.BigInteger.ZERO;
+import static java.math.BigInteger.ONE;
+import static uk.co.farowl.vsj4.runtime.PyLongMethods.toInt;
+import static uk.co.farowl.vsj4.runtime.PyLongMethods.divide;
+import static uk.co.farowl.vsj4.runtime.PyLongMethods.modulo;
+import static uk.co.farowl.vsj4.runtime.PyLongMethods.divmod;
+import static uk.co.farowl.vsj4.runtime.PyLongMethods.trueDivide;
+
+
+/**
+ * This class contains static methods implementing operations on the
+ * Python {@code long} object, supplementary to those defined in
+ * {@link PyLong} and {@link PyLongMethods}. These exist in order to
+ * support {@code CallSite} creation.
+ * <p>
+ * Implementations are not allowed to return {@link Py#NotImplemented}.
+ * If a binary operation is not defined here, for the pair of Java
+ * classes that type the arguments, the operation is not defined for the
+ * pair of their Python types.
+ * <p>
+ * When matching, we allow a signature here to match if it matches a
+ * type assignable in Java to the class of the argument in question.
+ * Types providing this compatibility must not be too broad,
+ * {@code Object} for example, as this would make it necessary to return
+ * {@link Py#NotImplemented}.
+ * <p>
+ * It follows that if a signature {@code f(A, B)} appears, where
+ * {@code A} is an accepted implementation of Python type {@code P}, and
+ * {@code B} is an accepted implementation of Python type {@code Q},
+ * {@code f(a, b)} must be present, or a signature with compatible
+ * types, for every accepted implementation {@code a} of {@code P} and
+ * {@code b} of {@code Q}. It is the responsibility of the script
+ * generating this class to ensure this condition is satisfied.
+ */
+class PyLongBinops {
+
+    private PyLongBinops() {}  // no instances
+
+    // $SPECIAL_BINOPS$ --------------------------------------------
+}