public static PyObject EnvironmentError__str__(PyObject self, PyObject[] args, String[] kwargs) {
PyObject errno = self.__findattr__("errno");
PyObject strerror = self.__findattr__("strerror");
PyObject filename = self.__findattr__("filename");
PyString result;
if (filename.__nonzero__()) {
result = Py.newString("[Errno %s] %s: %s");
result = (PyString) result.__mod__(new PyTuple(errno, strerror, filename.__repr__()));
} else if (errno.__nonzero__() && strerror.__nonzero__()) {
result = Py.newString("[Errno %s] %s");
result = (PyString) result.__mod__(new PyTuple(errno, strerror));
} else {
return PyBaseException.TYPE.invoke("__str__", self, args, kwargs);
}
return result;
}
public void __delattr__(String name) {
PyType self_type = getType();
PyObject impl = self_type.lookup("__delattr__");
if (impl != null) {
impl.__get__(this, self_type).__call__(PyString.fromInterned(name));
return;
}
super.__delattr__(name);
}
public String read(int n) throws IOException {
if (n < 0) {
n = (int) (file.length() - filePosition);
if (n < 0) n = 0;
}
byte[] buf = new byte[n];
n = readBytes(buf, 0, n);
if (n < 0) n = 0;
return PyString.from_bytes(buf, 0, n);
}
public void __setattr__(String name, PyObject value) {
PyType self_type = getType();
PyObject impl = self_type.lookup("__setattr__");
if (impl != null) {
impl.__get__(this, self_type).__call__(PyString.fromInterned(name), value);
// CPython does not support instance-acquired finalizers.
// So we don't check for __del__ here.
return;
}
super.__setattr__(name, value);
}
public void setDict(PyObject newDict) {
if (newDict instanceof PyStringMap || newDict instanceof PyDictionary) {
dict = newDict;
if (dict.__finditem__(PyString.fromInterned("__del__")) != null
&& !JyAttribute.hasAttr(this, JyAttribute.FINALIZE_TRIGGER_ATTR)) {
FinalizeTrigger.ensureFinalizer(this);
}
} else {
throw Py.TypeError("__dict__ must be set to a Dictionary " + newDict.getClass().getName());
}
}
public void write(String s) throws IOException {
byte[] bytes = PyString.to_bytes(s);
int n = bytes.length;
int i = 0;
while (i < n) {
int sz = n - i;
sz = sz > MAX_WRITE ? MAX_WRITE : sz;
ostream.write(bytes, i, sz);
i += sz;
}
}
public PyObject __findattr_ex__(String name) {
PyType self_type = getType();
// TODO: We should speed this up. As the __getattribute__ slot almost never
// changes, it is a good candidate for caching, as PyClass does with
// __getattr__. See #1102.
PyObject getattribute = self_type.lookup("__getattribute__");
PyString py_name = null;
PyException firstAttributeError = null;
try {
if (getattribute != null) {
py_name = PyString.fromInterned(name);
return getattribute.__get__(this, self_type).__call__(py_name);
} else {
Py.Warning(String.format("__getattribute__ not found on type %s", self_type.getName()));
PyObject ret = super.__findattr_ex__(name);
if (ret != null) {
return ret;
} // else: pass through to __getitem__ invocation
}
} catch (PyException e) {
if (!Py.matchException(e, Py.AttributeError)) {
throw e;
} else {
firstAttributeError = e; // saved to avoid swallowing custom AttributeErrors
// and pass through to __getattr__ invocation.
}
}
PyObject getattr = self_type.lookup("__getattr__");
if (getattr != null) {
if (py_name == null) {
py_name = PyString.fromInterned(name);
}
return getattr.__get__(this, self_type).__call__(py_name);
}
if (firstAttributeError != null) {
throw firstAttributeError;
}
return null;
}
public String read(int n) throws IOException {
if (n == 0)
// nothing to do
return "";
if (n < 0) {
// read until we hit EOF
byte buf[] = new byte[1024];
StringBuffer sbuf = new StringBuffer();
for (int read = 0; read >= 0; read = istream.read(buf))
sbuf.append(PyString.from_bytes(buf, 0, read));
return sbuf.toString();
}
// read the next chunk available, but make sure it's at least
// one byte so as not to trip the `empty string' return value
// test done by the caller
// int avail = istream.available();
// n = (n > avail) ? n : avail;
byte buf[] = new byte[n];
int read = istream.read(buf);
if (read < 0)
// EOF encountered
return "";
return PyString.from_bytes(buf, 0, read);
}
public void write(String s) throws IOException {
byte[] b = PyString.to_bytes(s);
int len = b.length;
// If the amount of data is small (less than a full buffer)...
if (len < buffer.length) {
// If any of the data fits within the buffer...
int spaceInBuffer = 0;
int copyLength = 0;
if (filePosition >= bufferStart)
spaceInBuffer = (int) ((bufferStart + buffer.length) - filePosition);
if (spaceInBuffer > 0) {
// Copy as much as possible to the buffer.
copyLength = (spaceInBuffer > len) ? len : spaceInBuffer;
System.arraycopy(b, 0, buffer, (int) (filePosition - bufferStart), copyLength);
bufferModified = true;
long myDataEnd = filePosition + copyLength;
dataEnd = myDataEnd > dataEnd ? myDataEnd : dataEnd;
dataSize = (int) (dataEnd - bufferStart);
filePosition += copyLength;
}
// If there is any data remaining, move to the
// new position and copy to the new buffer.
if (copyLength < len) {
seek(filePosition, 0);
System.arraycopy(
b, copyLength, buffer, (int) (filePosition - bufferStart), len - copyLength);
bufferModified = true;
long myDataEnd = filePosition + (len - copyLength);
dataEnd = myDataEnd > dataEnd ? myDataEnd : dataEnd;
dataSize = (int) (dataEnd - bufferStart);
filePosition += (len - copyLength);
}
} else {
// ...or write a lot of data...
// Flush the current buffer, and write this data to the file.
if (bufferModified) {
flush();
bufferStart = dataEnd = dataSize = 0;
}
file.write(b, 0, len);
filePosition += len;
}
}
@ExposedSet(name = "func_name")
public void setFuncName(PyString func_name) {
__name__ = func_name.asString();
}
public void write(String s) throws IOException {
ostream.write(PyString.to_bytes(s));
}
final PyObject file___iternext__() {
PyString s = new PyString(readline());
if (s.__len__() == 0) return null;
return s;
}
@ExposedClassMethod(doc = BuiltinDocs.float_fromhex_doc)
public static PyObject float_fromhex(PyType type, PyObject o) {
// XXX: I'm sure this could be shortened/simplified, but Double.parseDouble() takes
// non-hex strings and requires the form 0xNUMBERpNUMBER for hex input which
// causes extra complexity here.
String message = "invalid hexadecimal floating-point string";
boolean negative = false;
PyString s = o.__str__();
String value = s.getString().trim().toLowerCase();
if (value.length() == 0) {
throw Py.ValueError(message);
} else if (value.equals("nan") || value.equals("-nan") || value.equals("+nan")) {
return NAN;
} else if (value.equals("inf")
|| value.equals("infinity")
|| value.equals("+inf")
|| value.equals("+infinity")) {
return new PyFloat(Double.POSITIVE_INFINITY);
} else if (value.equals("-inf") || value.equals("-infinity")) {
return new PyFloat(Double.NEGATIVE_INFINITY);
}
// Strip and record + or -
if (value.charAt(0) == '-') {
value = value.substring(1);
negative = true;
} else if (value.charAt(0) == '+') {
value = value.substring(1);
}
if (value.length() == 0) {
throw Py.ValueError(message);
}
// Append 0x if not present.
if (!value.startsWith("0x") && !value.startsWith("0X")) {
value = "0x" + value;
}
// reattach - if needed.
if (negative) {
value = "-" + value;
}
// Append p if not present.
if (value.indexOf('p') == -1) {
value = value + "p0";
}
try {
double d = Double.parseDouble(value);
if (Double.isInfinite(d)) {
throw Py.OverflowError("hexadecimal value too large to represent as a float");
}
return new PyFloat(d);
} catch (NumberFormatException n) {
throw Py.ValueError(message);
}
}
