org.python.core.PyInteger Maven / Gradle / Ivy
Go to download
Jython is an implementation of the high-level, dynamic, object-oriented
language Python written in 100% Pure Java, and seamlessly integrated with
the Java platform. It thus allows you to run Python on any Java platform.
// Copyright (c) Corporation for National Research Initiatives
package org.python.core;
import java.io.Serializable;
/**
* A builtin python int.
*/
public class PyInteger extends PyObject {
//~ BEGIN GENERATED REGION -- DO NOT EDIT SEE gexpose.py
/* type info */
public static final String exposed_name="int";
public static void typeSetup(PyObject dict,PyType.Newstyle marker) {
class exposed___abs__ extends PyBuiltinMethodNarrow {
exposed___abs__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___abs__(self,info);
}
public PyObject __call__() {
return((PyInteger)self).int___abs__();
}
}
dict.__setitem__("__abs__",new PyMethodDescr("__abs__",PyInteger.class,0,0,new exposed___abs__(null,null)));
class exposed___float__ extends PyBuiltinMethodNarrow {
exposed___float__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___float__(self,info);
}
public PyObject __call__() {
return((PyInteger)self).int___float__();
}
}
dict.__setitem__("__float__",new PyMethodDescr("__float__",PyInteger.class,0,0,new exposed___float__(null,null)));
class exposed___hex__ extends PyBuiltinMethodNarrow {
exposed___hex__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___hex__(self,info);
}
public PyObject __call__() {
return((PyInteger)self).int___hex__();
}
}
dict.__setitem__("__hex__",new PyMethodDescr("__hex__",PyInteger.class,0,0,new exposed___hex__(null,null)));
class exposed___int__ extends PyBuiltinMethodNarrow {
exposed___int__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___int__(self,info);
}
public PyObject __call__() {
return((PyInteger)self).int___int__();
}
}
dict.__setitem__("__int__",new PyMethodDescr("__int__",PyInteger.class,0,0,new exposed___int__(null,null)));
class exposed___invert__ extends PyBuiltinMethodNarrow {
exposed___invert__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___invert__(self,info);
}
public PyObject __call__() {
return((PyInteger)self).int___invert__();
}
}
dict.__setitem__("__invert__",new PyMethodDescr("__invert__",PyInteger.class,0,0,new exposed___invert__(null,null)));
class exposed___long__ extends PyBuiltinMethodNarrow {
exposed___long__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___long__(self,info);
}
public PyObject __call__() {
return((PyInteger)self).int___long__();
}
}
dict.__setitem__("__long__",new PyMethodDescr("__long__",PyInteger.class,0,0,new exposed___long__(null,null)));
class exposed___neg__ extends PyBuiltinMethodNarrow {
exposed___neg__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___neg__(self,info);
}
public PyObject __call__() {
return((PyInteger)self).int___neg__();
}
}
dict.__setitem__("__neg__",new PyMethodDescr("__neg__",PyInteger.class,0,0,new exposed___neg__(null,null)));
class exposed___oct__ extends PyBuiltinMethodNarrow {
exposed___oct__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___oct__(self,info);
}
public PyObject __call__() {
return((PyInteger)self).int___oct__();
}
}
dict.__setitem__("__oct__",new PyMethodDescr("__oct__",PyInteger.class,0,0,new exposed___oct__(null,null)));
class exposed___pos__ extends PyBuiltinMethodNarrow {
exposed___pos__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___pos__(self,info);
}
public PyObject __call__() {
return((PyInteger)self).int___pos__();
}
}
dict.__setitem__("__pos__",new PyMethodDescr("__pos__",PyInteger.class,0,0,new exposed___pos__(null,null)));
class exposed___add__ extends PyBuiltinMethodNarrow {
exposed___add__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___add__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyInteger)self).int___add__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__add__",new PyMethodDescr("__add__",PyInteger.class,1,1,new exposed___add__(null,null)));
class exposed___and__ extends PyBuiltinMethodNarrow {
exposed___and__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___and__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyInteger)self).int___and__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__and__",new PyMethodDescr("__and__",PyInteger.class,1,1,new exposed___and__(null,null)));
class exposed___div__ extends PyBuiltinMethodNarrow {
exposed___div__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___div__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyInteger)self).int___div__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__div__",new PyMethodDescr("__div__",PyInteger.class,1,1,new exposed___div__(null,null)));
class exposed___divmod__ extends PyBuiltinMethodNarrow {
exposed___divmod__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___divmod__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyInteger)self).int___divmod__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__divmod__",new PyMethodDescr("__divmod__",PyInteger.class,1,1,new exposed___divmod__(null,null)));
class exposed___floordiv__ extends PyBuiltinMethodNarrow {
exposed___floordiv__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___floordiv__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyInteger)self).int___floordiv__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__floordiv__",new PyMethodDescr("__floordiv__",PyInteger.class,1,1,new exposed___floordiv__(null,null)));
class exposed___lshift__ extends PyBuiltinMethodNarrow {
exposed___lshift__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___lshift__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyInteger)self).int___lshift__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__lshift__",new PyMethodDescr("__lshift__",PyInteger.class,1,1,new exposed___lshift__(null,null)));
class exposed___mod__ extends PyBuiltinMethodNarrow {
exposed___mod__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___mod__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyInteger)self).int___mod__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__mod__",new PyMethodDescr("__mod__",PyInteger.class,1,1,new exposed___mod__(null,null)));
class exposed___mul__ extends PyBuiltinMethodNarrow {
exposed___mul__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___mul__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyInteger)self).int___mul__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__mul__",new PyMethodDescr("__mul__",PyInteger.class,1,1,new exposed___mul__(null,null)));
class exposed___or__ extends PyBuiltinMethodNarrow {
exposed___or__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___or__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyInteger)self).int___or__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__or__",new PyMethodDescr("__or__",PyInteger.class,1,1,new exposed___or__(null,null)));
class exposed___radd__ extends PyBuiltinMethodNarrow {
exposed___radd__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___radd__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyInteger)self).int___radd__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__radd__",new PyMethodDescr("__radd__",PyInteger.class,1,1,new exposed___radd__(null,null)));
class exposed___rdiv__ extends PyBuiltinMethodNarrow {
exposed___rdiv__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___rdiv__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyInteger)self).int___rdiv__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__rdiv__",new PyMethodDescr("__rdiv__",PyInteger.class,1,1,new exposed___rdiv__(null,null)));
class exposed___rfloordiv__ extends PyBuiltinMethodNarrow {
exposed___rfloordiv__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___rfloordiv__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyInteger)self).int___rfloordiv__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__rfloordiv__",new PyMethodDescr("__rfloordiv__",PyInteger.class,1,1,new exposed___rfloordiv__(null,null)));
class exposed___rmod__ extends PyBuiltinMethodNarrow {
exposed___rmod__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___rmod__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyInteger)self).int___rmod__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__rmod__",new PyMethodDescr("__rmod__",PyInteger.class,1,1,new exposed___rmod__(null,null)));
class exposed___rmul__ extends PyBuiltinMethodNarrow {
exposed___rmul__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___rmul__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyInteger)self).int___rmul__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__rmul__",new PyMethodDescr("__rmul__",PyInteger.class,1,1,new exposed___rmul__(null,null)));
class exposed___rshift__ extends PyBuiltinMethodNarrow {
exposed___rshift__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___rshift__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyInteger)self).int___rshift__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__rshift__",new PyMethodDescr("__rshift__",PyInteger.class,1,1,new exposed___rshift__(null,null)));
class exposed___rsub__ extends PyBuiltinMethodNarrow {
exposed___rsub__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___rsub__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyInteger)self).int___rsub__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__rsub__",new PyMethodDescr("__rsub__",PyInteger.class,1,1,new exposed___rsub__(null,null)));
class exposed___rtruediv__ extends PyBuiltinMethodNarrow {
exposed___rtruediv__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___rtruediv__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyInteger)self).int___rtruediv__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__rtruediv__",new PyMethodDescr("__rtruediv__",PyInteger.class,1,1,new exposed___rtruediv__(null,null)));
class exposed___sub__ extends PyBuiltinMethodNarrow {
exposed___sub__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___sub__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyInteger)self).int___sub__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__sub__",new PyMethodDescr("__sub__",PyInteger.class,1,1,new exposed___sub__(null,null)));
class exposed___truediv__ extends PyBuiltinMethodNarrow {
exposed___truediv__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___truediv__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyInteger)self).int___truediv__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__truediv__",new PyMethodDescr("__truediv__",PyInteger.class,1,1,new exposed___truediv__(null,null)));
class exposed___xor__ extends PyBuiltinMethodNarrow {
exposed___xor__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___xor__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyInteger)self).int___xor__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__xor__",new PyMethodDescr("__xor__",PyInteger.class,1,1,new exposed___xor__(null,null)));
class exposed___rxor__ extends PyBuiltinMethodNarrow {
exposed___rxor__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___rxor__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyInteger)self).int___rxor__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__rxor__",new PyMethodDescr("__rxor__",PyInteger.class,1,1,new exposed___rxor__(null,null)));
class exposed___rrshift__ extends PyBuiltinMethodNarrow {
exposed___rrshift__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___rrshift__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyInteger)self).int___rrshift__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__rrshift__",new PyMethodDescr("__rrshift__",PyInteger.class,1,1,new exposed___rrshift__(null,null)));
class exposed___ror__ extends PyBuiltinMethodNarrow {
exposed___ror__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___ror__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyInteger)self).int___ror__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__ror__",new PyMethodDescr("__ror__",PyInteger.class,1,1,new exposed___ror__(null,null)));
class exposed___rand__ extends PyBuiltinMethodNarrow {
exposed___rand__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___rand__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyInteger)self).int___rand__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__rand__",new PyMethodDescr("__rand__",PyInteger.class,1,1,new exposed___rand__(null,null)));
class exposed___rpow__ extends PyBuiltinMethodNarrow {
exposed___rpow__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___rpow__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyInteger)self).int___rpow__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__rpow__",new PyMethodDescr("__rpow__",PyInteger.class,1,1,new exposed___rpow__(null,null)));
class exposed___rlshift__ extends PyBuiltinMethodNarrow {
exposed___rlshift__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___rlshift__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyInteger)self).int___rlshift__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__rlshift__",new PyMethodDescr("__rlshift__",PyInteger.class,1,1,new exposed___rlshift__(null,null)));
class exposed___rdivmod__ extends PyBuiltinMethodNarrow {
exposed___rdivmod__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___rdivmod__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyInteger)self).int___rdivmod__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__rdivmod__",new PyMethodDescr("__rdivmod__",PyInteger.class,1,1,new exposed___rdivmod__(null,null)));
class exposed___cmp__ extends PyBuiltinMethodNarrow {
exposed___cmp__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___cmp__(self,info);
}
public PyObject __call__(PyObject arg0) {
int ret=((PyInteger)self).int___cmp__(arg0);
if (ret==-2) {
throw Py.TypeError("int"+".__cmp__(x,y) requires y to be '"+"int"+"', not a '"+(arg0).getType().fastGetName()+"'");
}
return Py.newInteger(ret);
}
}
dict.__setitem__("__cmp__",new PyMethodDescr("__cmp__",PyInteger.class,1,1,new exposed___cmp__(null,null)));
class exposed___pow__ extends PyBuiltinMethodNarrow {
exposed___pow__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___pow__(self,info);
}
public PyObject __call__(PyObject arg0,PyObject arg1) {
PyObject ret=((PyInteger)self).int___pow__(arg0,arg1);
if (ret==null)
return Py.NotImplemented;
return ret;
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyInteger)self).int___pow__(arg0,null);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__pow__",new PyMethodDescr("__pow__",PyInteger.class,1,2,new exposed___pow__(null,null)));
class exposed___nonzero__ extends PyBuiltinMethodNarrow {
exposed___nonzero__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___nonzero__(self,info);
}
public PyObject __call__() {
return Py.newBoolean(((PyInteger)self).int___nonzero__());
}
}
dict.__setitem__("__nonzero__",new PyMethodDescr("__nonzero__",PyInteger.class,0,0,new exposed___nonzero__(null,null)));
class exposed___reduce__ extends PyBuiltinMethodNarrow {
exposed___reduce__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___reduce__(self,info);
}
public PyObject __call__() {
return((PyInteger)self).int___reduce__();
}
}
dict.__setitem__("__reduce__",new PyMethodDescr("__reduce__",PyInteger.class,0,0,new exposed___reduce__(null,null)));
class exposed___repr__ extends PyBuiltinMethodNarrow {
exposed___repr__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___repr__(self,info);
}
public PyObject __call__() {
return new PyString(((PyInteger)self).int_toString());
}
}
dict.__setitem__("__repr__",new PyMethodDescr("__repr__",PyInteger.class,0,0,new exposed___repr__(null,null)));
class exposed___str__ extends PyBuiltinMethodNarrow {
exposed___str__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___str__(self,info);
}
public PyObject __call__() {
return new PyString(((PyInteger)self).int_toString());
}
}
dict.__setitem__("__str__",new PyMethodDescr("__str__",PyInteger.class,0,0,new exposed___str__(null,null)));
class exposed___hash__ extends PyBuiltinMethodNarrow {
exposed___hash__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___hash__(self,info);
}
public PyObject __call__() {
return Py.newInteger(((PyInteger)self).int_hashCode());
}
}
dict.__setitem__("__hash__",new PyMethodDescr("__hash__",PyInteger.class,0,0,new exposed___hash__(null,null)));
dict.__setitem__("__new__",new PyNewWrapper(PyInteger.class,"__new__",-1,-1) {
public PyObject new_impl(boolean init,PyType subtype,PyObject[]args,String[]keywords) {
return int_new(this,init,subtype,args,keywords);
}
});
}
//~ END GENERATED REGION -- DO NOT EDIT SEE gexpose.py
public static PyObject int_new(PyNewWrapper new_, boolean init, PyType subtype,
PyObject[] args, String[] keywords) {
ArgParser ap = new ArgParser("int", args, keywords, new String[] { "x",
"base" }, 0);
PyObject x = ap.getPyObject(0, null);
int base = ap.getInt(1, -909);
if (new_.for_type == subtype) {
if (x == null) {
return Py.Zero;
}
if (base == -909) {
return asPyInteger(x);
}
if (!(x instanceof PyString)) {
throw Py.TypeError("int: can't convert non-string with explicit base");
}
return Py.newInteger(((PyString) x).atoi(base));
} else {
if (x == null) {
return new PyIntegerDerived(subtype, 0);
}
if (base == -909) {
PyObject intOrLong = asPyInteger(x);
if (intOrLong instanceof PyInteger) {
return new PyIntegerDerived(subtype, ((PyInteger) intOrLong).getValue());
} else {
throw Py.OverflowError("long int too large to convert to int");
}
}
if (!(x instanceof PyString)) {
throw Py
.TypeError("int: can't convert non-string with explicit base");
}
return new PyIntegerDerived(subtype, ((PyString) x).atoi(base));
}
} // xxx
/**
* @return the result of x.__int__
* @throws Py.Type error if x.__int__ throws an Py.AttributeError
*/
private static PyObject asPyInteger(PyObject x) {
try {
return x.__int__();
} catch (PyException pye) {
if (!Py.matchException(pye, Py.AttributeError))
throw pye;
throw Py.TypeError("int() argument must be a string or a number");
}
}
private static final PyType INTTYPE = PyType.fromClass(PyInteger.class);
private int value;
public PyInteger(PyType subType, int v) {
super(subType);
value = v;
}
public PyInteger(int v) {
this(INTTYPE, v);
}
public int getValue() {
return value;
}
public String safeRepr() throws PyIgnoreMethodTag {
return "'int' object";
}
public String toString() {
return int_toString();
}
final String int_toString() {
return Integer.toString(getValue());
}
public int hashCode() {
return int_hashCode();
}
final int int_hashCode() {
return getValue();
}
private static void err_ovf(String msg) {
try {
Py.OverflowWarning(msg);
} catch (PyException exc) {
if (Py.matchException(exc, Py.OverflowWarning))
throw Py.OverflowError(msg);
}
}
public boolean __nonzero__() {
return int___nonzero__();
}
final boolean int___nonzero__() {
return getValue() != 0;
}
public Object __tojava__(Class c) {
if (c == Integer.TYPE || c == Number.class ||
c == Object.class || c == Integer.class ||
c == Serializable.class)
{
return new Integer(getValue());
}
if (c == Boolean.TYPE || c == Boolean.class)
return new Boolean(getValue() != 0);
if (c == Byte.TYPE || c == Byte.class)
return new Byte((byte)getValue());
if (c == Short.TYPE || c == Short.class)
return new Short((short)getValue());
if (c == Long.TYPE || c == Long.class)
return new Long(getValue());
if (c == Float.TYPE || c == Float.class)
return new Float(getValue());
if (c == Double.TYPE || c == Double.class)
return new Double(getValue());
return super.__tojava__(c);
}
public int __cmp__(PyObject other) {
return int___cmp__(other);
}
final int int___cmp__(PyObject other) {
if (!canCoerce(other))
return -2;
int v = coerce(other);
return getValue() < v ? -1 : getValue() > v ? 1 : 0;
}
public Object __coerce_ex__(PyObject other) {
if (other instanceof PyInteger)
return other;
else
return Py.None;
}
private static final boolean canCoerce(PyObject other) {
return other instanceof PyInteger;
}
private static final int coerce(PyObject other) {
if (other instanceof PyInteger)
return ((PyInteger) other).getValue();
else
throw Py.TypeError("xxx");
}
public PyObject __add__(PyObject right) {
return int___add__(right);
}
final PyObject int___add__(PyObject right) {
if (!canCoerce(right))
return null;
int rightv = coerce(right);
int a = getValue();
int b = rightv;
int x = a + b;
if ((x^a) >= 0 || (x^b) >= 0)
return Py.newInteger(x);
err_ovf("integer addition");
return new PyLong((long) a + (long)b);
}
public PyObject __radd__(PyObject left) {
return int___radd__(left);
}
final PyObject int___radd__(PyObject left) {
return __add__(left);
}
private static PyObject _sub(int a, int b) {
int x = a - b;
if ((x^a) >= 0 || (x^~b) >= 0)
return Py.newInteger(x);
err_ovf("integer subtraction");
return new PyLong((long) a - (long)b);
}
public PyObject __sub__(PyObject right) {
return int___sub__(right);
}
final PyObject int___sub__(PyObject right) {
if (!canCoerce(right))
return null;
return _sub(getValue(), coerce(right));
}
public PyObject __rsub__(PyObject left) {
return int___rsub__(left);
}
final PyObject int___rsub__(PyObject left) {
if (!canCoerce(left))
return null;
return _sub(coerce(left), getValue());
}
public PyObject __mul__(PyObject right) {
return int___mul__(right);
}
final PyObject int___mul__(PyObject right) {
if (right instanceof PySequence)
return ((PySequence) right).repeat(getValue());
if (!canCoerce(right))
return null;
int rightv = coerce(right);
double x = (double)getValue();
x *= rightv;
//long x = ((long)getValue())*((PyInteger)right).getValue();
//System.out.println("mul: "+this+" * "+right+" = "+x);
if (x <= Integer.MAX_VALUE && x >= Integer.MIN_VALUE)
return Py.newInteger((int)x);
err_ovf("integer multiplication");
return __long__().__mul__(right);
}
public PyObject __rmul__(PyObject left) {
return int___rmul__(left);
}
final PyObject int___rmul__(PyObject left) {
return __mul__(left);
}
// Getting signs correct for integer division
// This convention makes sense when you consider it in tandem with modulo
private static int divide(int x, int y) {
if (y == 0)
throw Py.ZeroDivisionError("integer division or modulo by zero");
if (y == -1 && x < 0 && x == -x) {
err_ovf("integer division: "+x+" + "+y);
}
int xdivy = x / y;
int xmody = x - xdivy * y;
/* If the signs of x and y differ, and the remainder is non-0,
* C89 doesn't define whether xdivy is now the floor or the
* ceiling of the infinitely precise quotient. We want the floor,
* and we have it iff the remainder's sign matches y's.
*/
if (xmody != 0 && ((y ^ xmody) < 0) /* i.e. and signs differ */) {
xmody += y;
--xdivy;
//assert(xmody && ((y ^ xmody) >= 0));
}
return xdivy;
}
public PyObject __div__(PyObject right) {
return int___div__(right);
}
final PyObject int___div__(PyObject right) {
if (!canCoerce(right))
return null;
if (Options.divisionWarning > 0)
Py.warning(Py.DeprecationWarning, "classic int division");
return Py.newInteger(divide(getValue(), coerce(right)));
}
public PyObject __rdiv__(PyObject left) {
return int___rdiv__(left);
}
final PyObject int___rdiv__(PyObject left) {
if (!canCoerce(left))
return null;
if (Options.divisionWarning > 0)
Py.warning(Py.DeprecationWarning, "classic int division");
return Py.newInteger(divide(coerce(left), getValue()));
}
public PyObject __floordiv__(PyObject right) {
return int___floordiv__(right);
}
final PyObject int___floordiv__(PyObject right) {
if (!canCoerce(right))
return null;
return Py.newInteger(divide(getValue(), coerce(right)));
}
public PyObject __rfloordiv__(PyObject left) {
return int___rfloordiv__(left);
}
final PyObject int___rfloordiv__(PyObject left) {
if (!canCoerce(left))
return null;
return Py.newInteger(divide(coerce(left), getValue()));
}
public PyObject __truediv__(PyObject right) {
return int___truediv__(right);
}
final PyObject int___truediv__(PyObject right) {
if (right instanceof PyInteger)
return __float__().__truediv__(right);
else if(right instanceof PyLong)
return int___long__().__truediv__(right);
else
return null;
}
public PyObject __rtruediv__(PyObject left) {
return int___rtruediv__(left);
}
final PyObject int___rtruediv__(PyObject left) {
if (left instanceof PyInteger)
return left.__float__().__truediv__(this);
else if(left instanceof PyLong)
return left.__truediv__(int___long__());
else
return null;
}
private static int modulo(int x, int y, int xdivy) {
return x - xdivy*y;
}
public PyObject __mod__(PyObject right) {
return int___mod__(right);
}
final PyObject int___mod__(PyObject right) {
if (!canCoerce(right))
return null;
int rightv = coerce(right);
int v = getValue();
return Py.newInteger(modulo(v, rightv, divide(v, rightv)));
}
public PyObject __rmod__(PyObject left) {
return int___rmod__(left);
}
final PyObject int___rmod__(PyObject left) {
if (!canCoerce(left))
return null;
int leftv = coerce(left);
int v = getValue();
return Py.newInteger(modulo(leftv, v, divide(leftv, v)));
}
public PyObject __divmod__(PyObject right) {
return int___divmod__(right);
}
final PyObject int___divmod__(PyObject right) {
if (!canCoerce(right))
return null;
int rightv = coerce(right);
int v = getValue();
int xdivy = divide(v, rightv);
return new PyTuple(new PyObject[] {
Py.newInteger(xdivy),
Py.newInteger(modulo(v, rightv, xdivy))
});
}
final PyObject int___rdivmod__(PyObject left){
if (!canCoerce(left))
return null;
int leftv = coerce(left);
int v = getValue();
int xdivy = divide(leftv, v);
return new PyTuple(new PyObject[] {
Py.newInteger(xdivy),
Py.newInteger(modulo(leftv, v, xdivy))
});
}
public PyObject __pow__(PyObject right, PyObject modulo) {
return int___pow__(right,modulo);
}
final PyObject int___pow__(PyObject right, PyObject modulo) {
if (!canCoerce(right))
return null;
if (modulo != null && !canCoerce(modulo))
return null;
return _pow(getValue(), coerce(right), modulo, this, right);
}
public PyObject __rpow__(PyObject left, PyObject modulo) {
if (!canCoerce(left))
return null;
if (modulo != null && !canCoerce(modulo))
return null;
return _pow(coerce(left), getValue(), modulo, left, this);
}
final PyObject int___rpow__(PyObject left){
return __rpow__(left, null);
}
private static PyObject _pow(int value, int pow, PyObject modulo,
PyObject left, PyObject right) {
int mod = 0;
long tmp = value;
boolean neg = false;
if (tmp < 0) {
tmp = -tmp;
neg = (pow & 0x1) != 0;
}
long result = 1;
if (pow < 0) {
if (value != 0)
return left.__float__().__pow__(right, modulo);
else
throw Py.ZeroDivisionError("cannot raise 0 to a " +
"negative power");
}
if (modulo != null) {
mod = coerce(modulo);
if (mod == 0) {
throw Py.ValueError("pow(x, y, z) with z==0");
}
}
// Standard O(ln(N)) exponentiation code
while (pow > 0) {
if ((pow & 0x1) != 0) {
result *= tmp;
if (mod != 0) {
result %= (long)mod;
}
if (result > Integer.MAX_VALUE) {
err_ovf("integer exponentiation");
return left.__long__().__pow__(right, modulo);
}
}
pow >>= 1;
if (pow == 0)
break;
tmp *= tmp;
if (mod != 0) {
tmp %= (long)mod;
}
if (tmp > Integer.MAX_VALUE) {
err_ovf("integer exponentiation");
return left.__long__().__pow__(right, modulo);
}
}
int ret = (int)result;
if (neg)
ret = -ret;
// Cleanup result of modulo
if (mod != 0) {
ret = modulo(ret, mod, divide(ret, mod));
}
return Py.newInteger(ret);
}
public PyObject __lshift__(PyObject right) {
return int___lshift__(right);
}
final PyObject int___lshift__(PyObject right) {
int rightv;
if (right instanceof PyInteger)
rightv = ((PyInteger) right).getValue();
else if (right instanceof PyLong)
return int___long__().__lshift__(right);
else
return null;
if (rightv > 31)
return Py.newInteger(0);
else if(rightv < 0)
throw Py.ValueError("negative shift count");
return Py.newInteger(getValue() << rightv);
}
final PyObject int___rlshift__(PyObject left) {
int leftv;
if (left instanceof PyInteger)
leftv = ((PyInteger) left).getValue();
else if (left instanceof PyLong)
return left.__rlshift__(int___long__());
else
return null;
if (getValue() > 31)
return Py.newInteger(0);
else if(getValue() < 0)
throw Py.ValueError("negative shift count");
return Py.newInteger(leftv << getValue());
}
public PyObject __rshift__(PyObject right) {
return int___rshift__(right);
}
final PyObject int___rshift__(PyObject right) {
int rightv;
if (right instanceof PyInteger)
rightv = ((PyInteger) right).getValue();
else if (right instanceof PyLong)
return int___long__().__rshift__(right);
else
return null;
if (rightv < 0)
throw Py.ValueError("negative shift count");
return Py.newInteger(getValue() >> rightv);
}
final PyObject int___rrshift__(PyObject left) {
int leftv;
if (left instanceof PyInteger)
leftv = ((PyInteger)left).getValue();
else if(left instanceof PyLong)
return left.__rshift__(int___long__());
else
return null;
if(getValue() < 0)
throw Py.ValueError("negative shift count");
return Py.newInteger(leftv >> getValue());
}
public PyObject __and__(PyObject right) {
return int___and__(right);
}
final PyObject int___and__(PyObject right) {
int rightv;
if (right instanceof PyInteger)
rightv = ((PyInteger) right).getValue();
else if (right instanceof PyLong)
return int___long__().__and__(right);
else
return null;
return Py.newInteger(getValue() & rightv);
}
final PyObject int___rand__(PyObject left){
return int___and__(left);
}
public PyObject __xor__(PyObject right) {
return int___xor__(right);
}
final PyObject int___xor__(PyObject right) {
int rightv;
if (right instanceof PyInteger)
rightv = ((PyInteger) right).getValue();
else if (right instanceof PyLong)
return int___long__().__xor__(right);
else
return null;
return Py.newInteger(getValue() ^ rightv);
}
final PyObject int___rxor__(PyObject left){
int leftv;
if (left instanceof PyInteger)
leftv = ((PyInteger)left).getValue();
else if(left instanceof PyLong)
return left.__rxor__(int___long__());
else
return null;
return Py.newInteger(leftv ^ getValue());
}
public PyObject __or__(PyObject right) {
return int___or__(right);
}
final PyObject int___or__(PyObject right) {
int rightv;
if (right instanceof PyInteger)
rightv = ((PyInteger) right).getValue();
else if (right instanceof PyLong)
return int___long__().__or__(right);
else
return null;
return Py.newInteger(getValue() | rightv);
}
final PyObject int___ror__(PyObject left){
return int___or__(left);
}
public PyObject __neg__() {
return int___neg__();
}
final PyObject int___neg__() {
int x = -getValue();
if (getValue() < 0 && x < 0)
err_ovf("integer negation");
return Py.newInteger(x);
}
public PyObject __pos__() {
return int___pos__();
}
final PyObject int___pos__() {
return Py.newInteger(getValue());
}
public PyObject __abs__() {
return int___abs__();
}
final PyObject int___abs__() {
if (getValue() >= 0)
return Py.newInteger(getValue());
else
return __neg__();
}
public PyObject __invert__() {
return int___invert__();
}
final PyObject int___invert__() {
return Py.newInteger(~getValue());
}
public PyObject __int__() {
return int___int__();
}
final PyInteger int___int__() {
return Py.newInteger(getValue());
}
public PyLong __long__() {
return int___long__();
}
final PyLong int___long__() {
return new PyLong(getValue());
}
public PyFloat __float__() {
return int___float__();
}
final PyFloat int___float__() {
return new PyFloat((double)getValue());
}
public PyComplex __complex__() {
return new PyComplex((double)getValue(), 0.);
}
public PyString __oct__() {
return int___oct__();
}
final PyString int___oct__() {
if (getValue() < 0) {
return new PyString(
"0"+Long.toString(0x100000000l+(long)getValue(), 8));
} else if (getValue() > 0) {
return new PyString("0"+Integer.toString(getValue(), 8));
} else
return new PyString("0");
}
public PyString __hex__() {
return int___hex__();
}
final PyString int___hex__() {
if (getValue() < 0) {
return new PyString(
"0x"+Long.toString(0x100000000l+(long)getValue(), 16));
} else {
return new PyString("0x"+Integer.toString(getValue(), 16));
}
}
public boolean isMappingType() { return false; }
public boolean isSequenceType() { return false; }
public long asLong(int index) throws PyObject.ConversionException {
return getValue();
}
public int asInt(int index) throws PyObject.ConversionException {
return getValue();
}
/**
* Used for pickling.
*
* @return a tuple of (class, (Integer))
*/
public PyObject __reduce__() {
return int___reduce__();
}
final PyObject int___reduce__() {
return new PyTuple(new PyObject[]{
getType(),
new PyTuple(new PyObject[]{
Py.newInteger(getValue())
})
});
}
}