""" error handling features, just a way of displaying errors
import py
log = py.log.Producer("error")
py.log.setconsumer("error", ansi_log)
source = graph.source
except AttributeError:
class AnnotatorError(Exception):
func.func_code.co_filename, func.func_code.co_firstlineno)
except (AttributeError, TypeError):
import traceback
errmsg = ["Error:\n"]
t.about(block, FileLike())
log.ERROR(''.join(errmsg))
class StructError(Exception):
"Interp-level error that gets mapped to an app-level struct.error."
def at_applevel(self, space):
from pypy.interpreter.error import OperationError
w_module = space.getbuiltinmodule('struct')
w_error = space.getattr(w_module, space.wrap('error'))
return OperationError(w_error, space.wrap(self.msg))
class StructOverflowError(StructError):
def at_applevel(self, space):
from pypy.interpreter.error import OperationError
return OperationError(space.w_OverflowError, space.wrap(self.msg))
class OperationError(Exception):
OperationError instances have three attributes (and no .args),
s = self._w_value
if self.__class__ is not OperationError and s is None:
def errorstr(self, space, use_repr=False):
self.print_app_tb_only(file)
print >> file, '(application-level)', self.errorstr(space)
def normalize_exception(self, space):
"""Normalize the OperationError. In other words, fix w_type and/or
space.wrap(msg))
except OperationError:
def _compute_value(self):
raise NotImplementedError
return _status
elif _statusstatus == _status.ERROR:
raise BacktrackException(_status.error)
elif (_statusstatus == _status.INPROGRESS or
_result = None
_error = None
_status.result = _result
_status.error = _error
_status.result = _result
_status.error = _error
_status.result = None
_error = _exc.error
_status.error = _error
_status.status = _status.ERROR
raise BacktrackException(_error)
return _status
elif _statusstatus == _status.ERROR:
raise BacktrackException(_status.error)
_startingpos = self._pos
_result = None
_error = None
_status.result = _result
_status.error = _error
_status.result = None
_error = _exc.error
_status.error = _error
_status.status = _status.ERROR
raise BacktrackException(_error)
def SPACE(self):
return _status
elif _statusstatus == _status.ERROR:
raise BacktrackException(_status.error)
def _PyObject_Del(space, op):
raise NotImplementedError
@cpython_api([rffi.CCHARP], Py_ssize_t, error=CANNOT_FAIL)
~Py_buffer.format."""
raise NotImplementedError
given shape with the given number of bytes per element."""
raise NotImplementedError
memoryview object."""
raise NotImplementedError
new bytes object."""
raise NotImplementedError
@cpython_api([PyObject], rffi.INT_real, error=CANNOT_FAIL)
currently allowed to create subclasses of memoryview."""
raise NotImplementedError
# XXX: show string offset and offending character for all errors
c = self.string[self.index + 1]
except IndexError:
raise error, "bogus escape (end of line)"
if len(escape) != 4:
raise ValueError
if not state.checkgroup(group):
raise error, "cannot refer to open group"
return GROUPREF, group
raise ValueError
return LITERAL, ord(escape[1])
except ValueError:
pass
raise error, "bogus escape: %s" % repr(escape)
else:
raise error, "pattern not properly closed"
mh.error(format, ...) # print error message -- can be overridden
f.error(format, ...) # same as mh.error(format, ...)
__all__ = ["MH","Error","Folder","Message"]
class Error(Exception):
def makefolder(self, name):
"""Create a new folder (or raise os.error if it cannot be created)."""
"""Delete a folder. This removes files in the folder but not
subdirectories. Raise os.error if deleting the folder itself fails."""
def error(self, *args):
"""Error message handler."""
self.mh.error(*args)
import threading
except ImportError:
ERR = logging.getLogger("ERR")
ERR.setLevel(logging.ERROR)
ERR.log(logging.CRITICAL, m())
ERR.error(m())
INF.log(logging.CRITICAL, m())
INF.error(m())
DEB.log(logging.CRITICAL, m())
DEB.error(m())
('ERR', 'CRITICAL', '1'),
('ERR', 'ERROR', '2'),
('INF', 'CRITICAL', '3'),
('INF', 'ERROR', '4'),
('DEB', 'CRITICAL', '7'),
('DEB', 'ERROR', '8'),
from warnings import warnpy3k
warnpy3k("In 3.x, the macerrors module is removed.", stacklevel=2)
fontNotOutlineErr = -32615 #bitmap font passed to routine that does outlines only
kURL68kNotSupportedError = -30788 #kURL68kNotSupportedError
kURLAccessNotAvailableError = -30787 #kURLAccessNotAvailableError
kURLInvalidConfigurationError = -30786 #kURLInvalidConfigurationError
kURLExtensionFailureError = -30785 #kURLExtensionFailureError
kURLFileEmptyError = -30783 #kURLFileEmptyError
kURLInvalidCallError = -30781 #kURLInvalidCallError
kURLUnsettablePropertyError = -30780 #kURLUnsettablePropertyError
kURLPropertyBufferTooSmallError = -30779 #kURLPropertyBufferTooSmallError
kURLUnknownPropertyError = -30778 #kURLUnknownPropertyError
kURLPropertyNotYetKnownError = -30777 #kURLPropertyNotYetKnownError
kURLAuthenticationError = -30776 #kURLAuthenticationError
kURLServerBusyError = -30775 #kURLServerBusyError
Keyword argument _attributes: AppleEvent attribute dictionary
Returns: Error code for each file added
if _arguments.get('errn', 0):
raise aetools.Error, aetools.decodeerror(_arguments)
Keyword argument _attributes: AppleEvent attribute dictionary
Returns: Errors for each file whose syntax was checked
if _arguments.get('errn', 0):
raise aetools.Error, aetools.decodeerror(_arguments)
if _arguments.get('errn', 0):
raise aetools.Error, aetools.decodeerror(_arguments)
if _arguments.get('errn', 0):
raise aetools.Error, aetools.decodeerror(_arguments)
if _arguments: raise TypeError, 'No optional args expected'
if _arguments.get('errn', 0):
raise aetools.Error, aetools.decodeerror(_arguments)
if (writer == null)
Helpers.raise_OSError(Errno.EBADF);
if (reader == null)
Helpers.raise_OSError(Errno.EBADF);
private static int fdcount;
private static Dictionary<int, string> ErrorMessages;
{
ErrorMessages = new Dictionary<int, string>();
FileDescriptors[1] = new TextFile(null, Console.In, Console.Out);
FileDescriptors[2] = new TextFile(null, Console.In, Console.Error);
private static void raise_OSError(int errno, string msg)
{
ErrorMessages[errno] = msg;
Helpers.raise_OSError(errno);
#define CHECK_STATUS(name) if (status != 0) { perror(name); error = 1; }
# ifdef THREAD_STACK_SIZE
# error "THREAD_STACK_SIZE defined but _POSIX_THREAD_ATTR_STACKSIZE undefined"
{
int status, error = 0;
{
int status, error = 0;
if (error)
{
int status, error = 0;
/* 'error' is ignored;
CHECK_STATUS already printed an error message */
}
main_arg = 'arg%d' % (signature.index(unicode0),)
except ValueError:
if res == -1:
raise OSError(rposix.get_errno(), "%s failed" % name)
if res == -1:
raise OSError(rposix.get_errno(), "%s failed" % name)
if childpid == -1:
raise OSError(rposix.get_errno(), "os_spawnve failed")
if newfd == -1:
raise OSError(rposix.get_errno(), "dup failed")
rposix.validate_fd(fd)
error = rffi.cast(lltype.Signed, os_dup2(rffi.cast(rffi.INT, fd),
rffi.cast(rffi.INT, newfd)))
if error == -1:
raise OSError(rposix.get_errno(), "dup2 failed")
raises(re.error, re.sub, 'x', r'\1', 'x')
raises(re.error, re.sub, 'x', r'\8', 'x')
raises(re.error, re.sub, 'x', r'\9', 'x')
raises(re.error, re.sub, 'x', r'\11', 'x')
raises(re.error, re.sub, 'x', r'\18', 'x')
raises(re.error, re.sub, 'x', r'\1a', 'x')
raises(re.error, re.sub, 'x', r'\90', 'x')
raises(re.error, re.sub, 'x', r'\99', 'x')
raises(re.error, re.sub, 'x', r'\118', 'x') # r'\11' + '8'
def test_symbolic_refs(self):
raises(re.error, re.sub, '(?P<a>x)', '\g<a', 'xx')
raises(re.error, re.sub, '(?P<a>x)', '\g<', 'xx')
raises(re.error, re.sub, '(?P<a>x)', '\g', 'xx')
raises(re.error, re.sub, '(?P<a>x)', '\g<a a>', 'xx')
class BacktrackException(Exception):
def __init__(self, error=None):
self.error = error
if not we_are_translated():
Exception.__init__(self, error)
assert pos >= 0
uptoerror = source[:pos]
lineno = uptoerror.count("\n")
columnno = pos - uptoerror.rfind("\n")
return lineno, columnno
def nice_error_message(self, filename='<filename>', source=""):
expected = failure_reasons[0]
result.append("ParseError: expected %s" % (expected, ))
else:
def test_error_character(self):
excinfo = py.test.raises(BacktrackException, p.b)
assert excinfo.value.error.pos == 0
assert excinfo.value.error.expected == ['a']
def test_error_or(self):
assert excinfo.value.error.pos == 1
assert excinfo.value.error.expected == ['a']
def test_error_star(self):
excinfo = py.test.raises(BacktrackException, p.b)
assert excinfo.value.error.pos == 2
assert excinfo.value.error.expected == ['b']
from pypy.rlib import rfloat, unroll
from pypy.interpreter.error import OperationError
y = f(x)
except OverflowError:
raise OperationError(space.w_OverflowError,
space.wrap("math range error"))
except ValueError:
raise OperationError(space.w_ValueError,
space.wrap("math domain error"))
return space.wrap(y)
r = f(x)
except OverflowError:
raise OperationError(space.w_OverflowError,
space.wrap("math range error"))
except ValueError: