org.python.core.exceptions Maven / Gradle / Ivy

// Copyright 2001 Finn Bock

package org.python.core;

/**
 * The builtin exceptions module. The entire module should be imported from
 * python. None of the methods defined here should be called from java.
 */

public class exceptions implements ClassDictInit {

    public static String __doc__ = "Python's standard exception class hierarchy.\n"
            + "\n"
            + "Here is a rundown of the class hierarchy.  The classes found here are\n"
            + "inserted into both the exceptions module and the `built-in' module. "
            + "It is\n"
            + "recommended that user defined class based exceptions be derived from the\n"
            + "`Exception' class, although this is currently not enforced.\n"
            + "\n"
            + "Exception\n"
            + " |\n"
            + " +-- SystemExit\n"
            + " +-- StopIteration\n"
            + " +-- StandardError\n"
            + " |    |\n"
            + " |    +-- KeyboardInterrupt\n"
            + " |    +-- ImportError\n"
            + " |    +-- EnvironmentError\n"
            + " |    |    |\n"
            + " |    |    +-- IOError\n"
            + " |    |    +-- OSError\n"
            + " |    |         |\n"
            + " |    |         +-- WindowsError\n"
            + " |    |\n"
            + " |    +-- EOFError\n"
            + " |    +-- RuntimeError\n"
            + " |    |    |\n"
            + " |    |    +-- NotImplementedError\n"
            + " |    |\n"
            + " |    +-- NameError\n"
            + " |    |    |\n"
            + " |    |    +-- UnboundLocalError\n"
            + " |    |\n"
            + " |    +-- AttributeError\n"
            + " |    +-- SyntaxError\n"
            + " |    |    |\n"
            + " |    |    +-- IndentationError\n"
            + " |    |         |\n"
            + " |    |         +-- TabError\n"
            + " |    |\n"
            + " |    +-- TypeError\n"
            + " |    +-- AssertionError\n"
            + " |    +-- LookupError\n"
            + " |    |    |\n"
            + " |    |    +-- IndexError\n"
            + " |    |    +-- KeyError\n"
            + " |    |\n"
            + " |    +-- ArithmeticError\n"
            + " |    |    |\n"
            + " |    |    +-- OverflowError\n"
            + " |    |    +-- ZeroDivisionError\n"
            + " |    |    +-- FloatingPointError\n"
            + " |    |\n"
            + " |    +-- ValueError\n"
            + " |    |    |\n"
            + " |    |    +-- UnicodeError\n"
            + " |    |\n"
            + " |    +-- ReferenceError\n"
            + " |    +-- SystemError\n"
            + " |    +-- MemoryError\n"
            + " |\n"
            + " +---Warning\n"
            + "      |\n"
            + "      +-- UserWarning\n"
            + "      +-- DeprecationWarning\n"
            + "      +-- SyntaxWarning\n"
            + "      +-- OverflowWarning\n" + "      +-- RuntimeWarning";

    private exceptions() {
        ;
    }

    /** Internal use only. Do not call this method explicit. */
    public static void classDictInit(PyObject dict) {
        dict.invoke("clear");
        dict.__setitem__("__name__", new PyString("exceptions"));
        dict.__setitem__("__doc__", new PyString(__doc__));

        ThreadState ts = Py.getThreadState();
        if (ts.systemState == null) {
            ts.systemState = Py.defaultSystemState;
        }
        // Push frame
        PyFrame frame = new PyFrame(null, new PyStringMap());
        frame.f_back = ts.frame;
        if (frame.f_builtins == null) {
            if (frame.f_back != null) {
                frame.f_builtins = frame.f_back.f_builtins;
            } else {
                frame.f_builtins = ts.systemState.builtins;
            }
        }
        ts.frame = frame;

        buildClass(dict, "Exception", null, "Exception",
                "Proposed base class for all exceptions.");

        buildClass(dict, "StandardError", "Exception", "empty__init__",
                "Base class for all standard Python exceptions.");

        buildClass(dict, "SyntaxError", "StandardError", "SyntaxError",
                "Invalid syntax");

        buildClass(dict, "IndentationError", "SyntaxError", "empty__init__",
                "Improper indentation");

        buildClass(dict, "TabError", "IndentationError", "empty__init__",
                "Improper mixture of spaces and tabs.");

        buildClass(dict, "EnvironmentError", "StandardError",
                "EnvironmentError", "Base class for I/O related errors.");

        buildClass(dict, "IOError", "EnvironmentError", "empty__init__",
                "I/O operation failed.");

        buildClass(dict, "OSError", "EnvironmentError", "empty__init__",
                "OS system call failed.");

        buildClass(dict, "RuntimeError", "StandardError", "empty__init__",
                "Unspecified run-time error.");

        buildClass(dict, "NotImplementedError", "RuntimeError",
                "empty__init__",
                "Method or function hasn't been implemented yet.");

        buildClass(dict, "SystemError", "StandardError", "empty__init__",
                "Internal error in the Python interpreter.\n\n"
                        + "Please report this to the Python maintainer, "
                        + "along with the traceback,\n"
                        + "the Python version, and the hardware/OS "
                        + "platform and version.");

        buildClass(dict, "ReferenceError", "StandardError", "empty__init__",
                "Weak ref proxy used after referent went away.");

        buildClass(dict, "EOFError", "StandardError", "empty__init__",
                "Read beyond end of file.");

        buildClass(dict, "ImportError", "StandardError", "empty__init__",
                "Import can't find module, or can't find name in module.");

        buildClass(dict, "TypeError", "StandardError", "empty__init__",
                "Inappropriate argument type.");

        buildClass(dict, "ValueError", "StandardError", "empty__init__",
                "Inappropriate argument value (of correct type).");

        buildClass(dict, "UnicodeError", "ValueError", "empty__init__",
                "Unicode related error.");

        buildClass(dict, "KeyboardInterrupt", "StandardError", "empty__init__",
                "Program interrupted by user.");

        buildClass(dict, "AssertionError", "StandardError", "empty__init__",
                "Assertion failed.");

        buildClass(dict, "ArithmeticError", "StandardError", "empty__init__",
                "Base class for arithmetic errors.");

        buildClass(dict, "OverflowError", "ArithmeticError", "empty__init__",
                "Result too large to be represented.");

        buildClass(dict, "FloatingPointError", "ArithmeticError",
                "empty__init__", "Floating point operation failed.");

        buildClass(dict, "ZeroDivisionError", "ArithmeticError",
                "empty__init__",
                "Second argument to a division or modulo operation "
                        + "was zero.");

        buildClass(dict, "LookupError", "StandardError", "empty__init__",
                "Base class for lookup errors.");

        buildClass(dict, "IndexError", "LookupError", "empty__init__",
                "Sequence index out of range.");

        buildClass(dict, "KeyError", "LookupError", "empty__init__",
                "Mapping key not found.");

        buildClass(dict, "AttributeError", "StandardError", "empty__init__",
                "Attribute not found.");

        buildClass(dict, "NameError", "StandardError", "empty__init__",
                "Name not found globally.");

        buildClass(dict, "UnboundLocalError", "NameError", "empty__init__",
                "Local name referenced but not bound to a value.");

        buildClass(dict, "MemoryError", "StandardError", "empty__init__",
                "Out of memory.");

        buildClass(dict, "SystemExit", "Exception", "SystemExit",
                "Request to exit from the interpreter.");

        buildClass(dict, "StopIteration", "Exception", "empty__init__",
                "Signal the end from iterator.next().");

        buildClass(dict, "Warning", "Exception", "empty__init__",
                "Base class for warning categories.");

        buildClass(dict, "UserWarning", "Warning", "empty__init__",
                "Base class for warnings generated by user code.");

        buildClass(dict, "DeprecationWarning", "Warning", "empty__init__",
                "Base class for warnings about deprecated features.");

        buildClass(dict, "SyntaxWarning", "Warning", "empty__init__",
                "Base class for warnings about dubious syntax.");

        buildClass(dict, "RuntimeWarning", "Warning", "empty__init__",
                "Base class for warnings about dubious runtime behavior.");

        buildClass(dict, "OverflowWarning", "Warning", "empty__init__",
                "Base class for warnings about numeric overflow.");

        ts.frame = ts.frame.f_back;
    }

    // An empty __init__ method
    public static PyObject empty__init__(PyObject[] arg, String[] kws) {
        PyObject dict = new PyStringMap();
        dict.__setitem__("__module__", new PyString("exceptions"));
        return dict;
    }

    public static PyObject Exception(PyObject[] arg, String[] kws) {
        PyObject dict = empty__init__(arg, kws);
        dict.__setitem__("__init__", getJavaFunc("Exception__init__"));
        dict.__setitem__("__str__", getJavaFunc("Exception__str__"));
        dict.__setitem__("__getitem__", getJavaFunc("Exception__getitem__"));
        return dict;
    }

    public static void Exception__init__(PyObject[] arg, String[] kws) {
        ArgParser ap = new ArgParser("__init__", arg, kws, "self", "args");
        PyObject self = ap.getPyObject(0);
        PyObject args = ap.getList(1);

        self.__setattr__("args", args);
    }

    public static PyString Exception__str__(PyObject[] arg, String[] kws) {
        ArgParser ap = new ArgParser("__str__", arg, kws, "self");
        PyObject self = ap.getPyObject(0);

        PyObject args = self.__getattr__("args");
        if (!args.__nonzero__()) {
            return new PyString("");
        } else if (args.__len__() == 1) {
            return args.__getitem__(0).__str__();
        } else {
            return args.__str__();
        }
    }

    public static PyObject Exception__getitem__(PyObject[] arg, String[] kws) {
        ArgParser ap = new ArgParser("__getitem__", arg, kws, "self", "i");
        PyObject self = ap.getPyObject(0);
        PyObject i = ap.getPyObject(1);

        return self.__getattr__("args").__getitem__(i);
    }

    public static PyObject SyntaxError(PyObject[] arg, String[] kws) {
        PyObject __dict__ = empty__init__(arg, kws);
        __dict__.__setitem__("filename", Py.None);
        __dict__.__setitem__("lineno", Py.None);
        __dict__.__setitem__("offset", Py.None);
        __dict__.__setitem__("text", Py.None);
        __dict__.__setitem__("msg", new PyString(""));

        __dict__.__setitem__("__init__", getJavaFunc("SyntaxError__init__"));
        __dict__.__setitem__("__str__", getJavaFunc("SyntaxError__str__"));
        return __dict__;
    }

    public static void SyntaxError__init__(PyObject[] arg, String[] kws) {
        ArgParser ap = new ArgParser("__init__", arg, kws, "self", "args");
        PyObject self = ap.getPyObject(0);
        PyObject args = ap.getList(1);

        self.__setattr__("args", args);
        if (args.__len__() >= 1) {
            self.__setattr__("msg", args.__getitem__(0));
        }
        if (args.__len__() == 2) {
            PyObject info = args.__getitem__(1);
            try {
                PyObject[] tmp = Py.unpackSequence(info, 4);
                self.__setattr__("filename", tmp[0]);
                self.__setattr__("lineno", tmp[1]);
                self.__setattr__("offset", tmp[2]);
                self.__setattr__("text", tmp[3]);
            } catch (PyException exc) {
                ;
            }
        }
    }

    public static PyString SyntaxError__str__(PyObject[] arg, String[] kws) {
        ArgParser ap = new ArgParser("__init__", arg, kws, "self", "args");
        PyObject self = ap.getPyObject(0);
        PyString str = self.__getattr__("msg").__str__();
        PyObject filename = basename(self.__findattr__("filename"));
        PyObject lineno = self.__findattr__("lineno");
        if (filename instanceof PyString && lineno instanceof PyInteger) {
            return new PyString(str + " (" + filename + ", line " + lineno
                    + ")");
        } else if (filename instanceof PyString) {
            return new PyString(str + " (" + filename + ")");
        } else if (lineno instanceof PyInteger) {
            return new PyString(str + " (line " + lineno + ")");
        }
        return str;
    }

    private static PyObject basename(PyObject filename) {
        if (filename instanceof PyString) {
            int i = ((PyString) filename).rfind(java.io.File.separator);
            if (i >= 0) {
                return filename.__getslice__(new PyInteger(i + 1),
                        new PyInteger(Integer.MAX_VALUE));
            }
        }
        return filename;
    }

    public static PyObject EnvironmentError(PyObject[] arg, String[] kws) {
        PyObject dict = empty__init__(arg, kws);
        dict.__setitem__("__init__", getJavaFunc("EnvironmentError__init__"));
        dict.__setitem__("__str__", getJavaFunc("EnvironmentError__str__"));
        return dict;
    }

    public static void EnvironmentError__init__(PyObject[] arg, String[] kws) {
        ArgParser ap = new ArgParser("__init__", arg, kws, "self", "args");
        PyObject self = ap.getPyObject(0);
        PyObject args = ap.getList(1);

        self.__setattr__("args", args);
        self.__setattr__("errno", Py.None);
        self.__setattr__("strerror", Py.None);
        self.__setattr__("filename", Py.None);
        if (args.__len__() == 3) {
            // open() errors give third argument which is the filename. BUT,
            // so common in-place unpacking doesn't break, e.g.:
            //
            // except IOError, (errno, strerror):
            //
            // we hack args so that it only contains two items. This also
            // means we need our own __str__() which prints out the filename
            // when it was supplied.
            PyObject[] tmp = Py.unpackSequence(args, 3);
            self.__setattr__("errno", tmp[0]);
            self.__setattr__("strerror", tmp[1]);
            self.__setattr__("filename", tmp[2]);
            self.__setattr__("args", args.__getslice__(Py.Zero, Py
                    .newInteger(2), Py.One));
        }
        if (args.__len__() == 2) {
            // common case: PyErr_SetFromErrno()
            PyObject[] tmp = Py.unpackSequence(args, 2);
            self.__setattr__("errno", tmp[0]);
            self.__setattr__("strerror", tmp[1]);
        }
    }

    public static PyString EnvironmentError__str__(PyObject[] arg, String[] kws) {
        ArgParser ap = new ArgParser("__init__", arg, kws, "self");
        PyObject self = ap.getPyObject(0);

        if (self.__getattr__("filename") != Py.None) {
            return Py.newString("[Errno %s] %s: %s").__mod__(
                    new PyTuple(new PyObject[] { self.__getattr__("errno"),
                            self.__getattr__("strerror"),
                            self.__getattr__("filename") })).__str__();
        } else if (self.__getattr__("errno").__nonzero__()
                && self.__getattr__("strerror").__nonzero__()) {
            return Py.newString("[Errno %s] %s").__mod__(
                    new PyTuple(new PyObject[] { self.__getattr__("errno"),
                            self.__getattr__("strerror") })).__str__();
        } else {
            return Exception__str__(arg, kws);
        }
    }

    public static PyObject SystemExit(PyObject[] arg, String[] kws) {
        PyObject dict = empty__init__(arg, kws);
        dict.__setitem__("__init__", getJavaFunc("SystemExit__init__"));
        return dict;
    }

    public static void SystemExit__init__(PyObject[] arg, String[] kws) {
        ArgParser ap = new ArgParser("__init__", arg, kws, "self", "args");
        PyObject self = ap.getPyObject(0);
        PyObject args = ap.getList(1);

        self.__setattr__("args", args);
        if (args.__len__() == 0) {
            self.__setattr__("code", Py.None);
        } else if (args.__len__() == 1) {
            self.__setattr__("code", args.__getitem__(0));
        } else {
            self.__setattr__("code", args);
        }
    }

    private static PyObject getJavaFunc(String name) {
        return Py.newJavaFunc(exceptions.class, name);
    }

    private static PyObject buildClass(PyObject dict, String classname,
            String superclass, String classCodeName, String doc) {
        PyObject[] sclass = Py.EmptyObjects;
        if (superclass != null) {
            sclass = new PyObject[] { dict
                    .__getitem__(new PyString(superclass)) };
        }
        PyObject cls = Py.makeClass(classname, sclass, Py.newJavaCode(
                exceptions.class, classCodeName), new PyString(doc));
        dict.__setitem__(classname, cls);
        return cls;
    }
}