# Exception handling

import copy

import atexit

import sys

import traceback

import format

import strings

import term

import util

def reraise(e=None): raise

def raise_(e): raise e

def sys_traceback():

    '''Note that Python tracebacks seems to have a bug that truncates them to

    only a few stack frames. See <http://bugs.python.org/issue7378>.'''

    return sys.exc_info()[2]

        # can't just return pointer to traceback because it will change :-(

def has_tracebacks(e): return hasattr(e, 'tracebacks')

def add_traceback(e):

    '''Adds current traceback to an exception if it doesn't already have one'''

    traceback_ = sys_traceback() # get first in case later code throws exception

    if not has_tracebacks(e): e.tracebacks = []

    if util.list_get(e.tracebacks, 0) == traceback_: return

    e.tracebacks.insert(0, traceback_) # tracebacks have most recent call last

def get_traceback_str(traceback_):

    return ''.join(traceback.format_exception(None, None, traceback_)[:-1])

        # remove final "None" line ("exception name")

def get_e_tracebacks_str(e):

    traceback_ = sys_traceback() # get first in case later code throws exception

    try: tracebacks = e.tracebacks

    except AttributeError: tracebacks = [traceback_]

    return ''.join(get_traceback_str(t) for t in tracebacks)

def e_msg(e):

    assert len(e.args) == 1

    assert util.is_str(e.args[0])

    return strings.ustr(e.args[0]).rstrip()

def e_str(e): return e.__class__.__name__+': '+e_msg(e)

def add_msg(e, msg):

    e.args = (e_msg(e)+'\n'+strings.ustr(msg),)

def repl_msg(e, **repls): e.args = (e_msg(e) % repls,)

def e_ct_exit_status(e_ct): return min(e_ct, 255)

class ExceptionWithCause(Exception):

    def __init__(self, msg, cause=None, cause_newline=False):

        add_traceback(self)

        if cause != None:

            if cause_newline: msg += '\ncause'

            msg += ': '+str_(cause)

        Exception.__init__(self, msg)

        self.cause = cause

def str_(e, first_line_only=False):

    if isinstance(e, SyntaxError):

        # format_exception_only() provides special formatting for SyntaxErrors.

        msg = (u''.join(traceback.format_exception_only(type(e), e))).rstrip()

    else:

        # Avoid traceback exception-formatting functions because they escape

        # non-ASCII characters with \x, causing exception parsers to read an

        # incorrect, escaped value.

        msg = e_str(e)

    if first_line_only: msg = msg.partition('\n')[0]

    return msg

def print_ex(e, emph=True, detail=True, plain=False):

    if plain:

        emph = False

        detail = False

    msg = str_(e)+'\n'

    if detail: msg += get_e_tracebacks_str(e)

    if emph:

        first_line, nl, rest = msg.partition('\n')

        msg = term.error(first_line)+nl+rest

    sys.stderr.write(strings.to_raw_str(msg))

class ExTracker:

    def __init__(self):

        self.e_ct = 0

    def msg(self): return 'Encountered '+str(self.e_ct)+' error(s)'

    def track(self, e, **format):

        self.e_ct += 1

        print_ex(e, **format)

    def exit(self):

        if self.e_ct > 0: raise SystemExit(e_ct_exit_status(self.e_ct))

class ExPercentTracker(ExTracker):

    def __init__(self, iter_text='iteration'):

        ExTracker.__init__(self)

        self.iter_text = iter_text

        self.iter_ct = None

        self.err_iter_ct = None

        self.last_iter_num = None

    def add_iters(self, iter_ct):

        if self.iter_ct == None: self.iter_ct = 0

        self.iter_ct += iter_ct

    def track(self, e, iter_num=None, **format):

        if iter_num != None:

            if iter_num != self.last_iter_num: # a new iter produced an error

                if self.err_iter_ct == None: self.err_iter_ct = 0

                self.err_iter_ct += 1

                self.last_iter_num = iter_num

        ExTracker.track(self, e, **format)

    def msg(self):

        msg = ExTracker.msg(self)

        iter_text_plural = self.iter_text+'(s)'

        numerator = self.e_ct

        if self.err_iter_ct != None:

            msg += ' in '+format.int2str(self.err_iter_ct)

            numerator = self.err_iter_ct

        if self.iter_ct != None and self.iter_ct > 0:

            msg += ('/'+format.int2str(self.iter_ct)+' '+iter_text_plural+' = '

            +format.to_percent(float(numerator)/self.iter_ct))

        return msg