Maximum CD 2011 January/maximum-cd-2011-01.iso/DiscContents/calibre-0.7.26.msi/file_2360

Python Compiled Bytecode | 2010-10-31 | 15.5 KB | 561 lines

# Source Generated with Decompyle++
# File: in.pyc (Python 2.6)

import re
from pygments.filter import apply_filters, Filter
from pygments.filters import get_filter_by_name
from pygments.token import Error, Text, Other, _TokenType
from pygments.util import get_bool_opt, get_int_opt, get_list_opt, make_analysator
__all__ = [
    'Lexer',
    'RegexLexer',
    'ExtendedRegexLexer',
    'DelegatingLexer',
    'LexerContext',
    'include',
    'bygroups',
    'using',
    'this']
_default_analyse = staticmethod((lambda x: 0))

class LexerMeta(type):

    def __new__(cls, name, bases, d):
        if 'analyse_text' in d:
            d['analyse_text'] = make_analysator(d['analyse_text'])

        return type.__new__(cls, name, bases, d)



class Lexer(object):
    name = None
    aliases = []
    filenames = []
    alias_filenames = []
    mimetypes = []
    __metaclass__ = LexerMeta

    def __init__(self, **options):
        self.options = options
        self.stripnl = get_bool_opt(options, 'stripnl', True)
        self.stripall = get_bool_opt(options, 'stripall', False)
        self.ensurenl = get_bool_opt(options, 'ensurenl', True)
        self.tabsize = get_int_opt(options, 'tabsize', 0)
        self.encoding = options.get('encoding', 'latin1')
        self.filters = []
        for filter_ in get_list_opt(options, 'filters', ()):
            self.add_filter(filter_)



    def __repr__(self):
        if self.options:
            return '<pygments.lexers.%s with %r>' % (self.__class__.__name__, self.options)
        return '<pygments.lexers.%s>' % self.__class__.__name__


    def add_filter(self, filter_, **options):
        if not isinstance(filter_, Filter):
            filter_ = get_filter_by_name(filter_, **options)

        self.filters.append(filter_)


    def analyse_text(text):
        pass


    def get_tokens(self, text, unfiltered = False):
        if not isinstance(text, unicode):
            if self.encoding == 'guess':

                try:
                    text = text.decode('utf-8')
                    if text.startswith(u''):
                        text = text[len(u''):]
                except UnicodeDecodeError:
                    text = text.decode('latin1')
                except:
                    None<EXCEPTION MATCH>UnicodeDecodeError


            None<EXCEPTION MATCH>UnicodeDecodeError
            if self.encoding == 'chardet':

                try:
                    import chardet
                except ImportError:
                    raise ImportError('To enable chardet encoding guessing, please install the chardet library from http://chardet.feedparser.org/')

                enc = chardet.detect(text)
                text = text.decode(enc['encoding'])
            else:
                text = text.decode(self.encoding)

        text = text.replace('\r\n', '\n')
        text = text.replace('\r', '\n')
        if self.stripall:
            text = text.strip()
        elif self.stripnl:
            text = text.strip('\n')

        if self.tabsize > 0:
            text = text.expandtabs(self.tabsize)

        if self.ensurenl and not text.endswith('\n'):
            text += '\n'


        def streamer():
            for i, t, v in self.get_tokens_unprocessed(text):
                yield (t, v)


        stream = streamer()
        if not unfiltered:
            stream = apply_filters(stream, self.filters, self)

        return stream


    def get_tokens_unprocessed(self, text):
        raise NotImplementedError



class DelegatingLexer(Lexer):

    def __init__(self, _root_lexer, _language_lexer, _needle = Other, **options):
        self.root_lexer = _root_lexer(**options)
        self.language_lexer = _language_lexer(**options)
        self.needle = _needle
        Lexer.__init__(self, **options)


    def get_tokens_unprocessed(self, text):
        buffered = ''
        insertions = []
        lng_buffer = []
        for i, t, v in self.language_lexer.get_tokens_unprocessed(text):
            if t is self.needle:
                if lng_buffer:
                    insertions.append((len(buffered), lng_buffer))
                    lng_buffer = []

                buffered += v
                continue
            lng_buffer.append((i, t, v))

        if lng_buffer:
            insertions.append((len(buffered), lng_buffer))

        return do_insertions(insertions, self.root_lexer.get_tokens_unprocessed(buffered))



class include(str):
    pass


class combined(tuple):

    def __new__(cls, *args):
        return tuple.__new__(cls, args)


    def __init__(self, *args):
        pass



class _PseudoMatch(object):

    def __init__(self, start, text):
        self._text = text
        self._start = start


    def start(self, arg = None):
        return self._start


    def end(self, arg = None):
        return self._start + len(self._text)


    def group(self, arg = None):
        if arg:
            raise IndexError('No such group')
        arg
        return self._text


    def groups(self):
        return (self._text,)


    def groupdict(self):
        return { }



def bygroups(*args):

    def callback(lexer, match, ctx = (None,)):
        for i, action in enumerate(args):
            if action is None:
                continue
                continue
            if type(action) is _TokenType:
                data = match.group(i + 1)
                if data:
                    yield (match.start(i + 1), action, data)

            data
            if ctx:
                ctx.pos = match.start(i + 1)

            for item in action(lexer, _PseudoMatch(match.start(i + 1), match.group(i + 1)), ctx):
                if item:
                    yield item
                    continue


        if ctx:
            ctx.pos = match.end()


    return callback


class _This(object):
    pass

this = _This()

def using(_other, **kwargs):
    gt_kwargs = { }
    if 'state' in kwargs:
        s = kwargs.pop('state')
        if isinstance(s, (list, tuple)):
            gt_kwargs['stack'] = s
        else:
            gt_kwargs['stack'] = ('root', s)

    if _other is this:

        def callback(lexer, match, ctx = (None, None)):
            if kwargs:
                kwargs.update(lexer.options)
                lx = lexer.__class__(**kwargs)
            else:
                lx = lexer
            s = match.start()
            for i, t, v in lx.get_tokens_unprocessed(match.group(), **gt_kwargs):
                yield (i + s, t, v)

            if ctx:
                ctx.pos = match.end()


    else:

        def callback(lexer, match, ctx = (None, None, None)):
            kwargs.update(lexer.options)
            lx = _other(**kwargs)
            s = match.start()
            for i, t, v in lx.get_tokens_unprocessed(match.group(), **gt_kwargs):
                yield (i + s, t, v)

            if ctx:
                ctx.pos = match.end()


    return callback


class RegexLexerMeta(LexerMeta):

    def _process_state(cls, unprocessed, processed, state):
        if state in processed:
            return processed[state]
        rflags = cls.flags
        for tdef in unprocessed[state]:

            try:
                rex = re.compile(tdef[0], rflags).match
            except Exception:
                None if isinstance(tdef, include) else state in processed
                err = None if isinstance(tdef, include) else state in processed
                raise ValueError('uncompilable regex %r in state %r of %r: %s' % (tdef[0], state, cls, err))
            except:
                None if isinstance(tdef, include) else state in processed

            if len(tdef) == 2:
                new_state = None
            else:
                tdef2 = tdef[2]
                if isinstance(tdef2, str):
                    if tdef2 == '#pop':
                        new_state = -1
                    elif tdef2 in unprocessed:
                        new_state = (tdef2,)
                    elif tdef2 == '#push':
                        new_state = tdef2
                    elif tdef2[:5] == '#pop:':
                        new_state = -int(tdef2[5:])

                elif isinstance(tdef2, combined):
                    new_state = '_tmp_%d' % cls._tmpname
                    cls._tmpname += 1
                    itokens = []
                    for istate in tdef2:
                        itokens.extend(cls._process_state(unprocessed, processed, istate))

                    processed[new_state] = itokens
                    new_state = (new_state,)
                elif isinstance(tdef2, tuple):
                    for state in tdef2:
                        pass

                    new_state = tdef2

            tokens.append((rex, tdef[1], new_state))

        return tokens


    def process_tokendef(cls, name, tokendefs = None):
        processed = cls._all_tokens[name] = { }
        if not tokendefs:
            pass
        tokendefs = cls.tokens[name]
        for state in tokendefs.keys():
            cls._process_state(tokendefs, processed, state)

        return processed


    def __call__(cls, *args, **kwds):
        if not hasattr(cls, '_tokens'):
            cls._all_tokens = { }
            cls._tmpname = 0
            if hasattr(cls, 'token_variants') and cls.token_variants:
                pass
            else:
                cls._tokens = cls.process_tokendef('', cls.tokens)

        return type.__call__(cls, *args, **kwds)



class RegexLexer(Lexer):
    __metaclass__ = RegexLexerMeta
    flags = re.MULTILINE
    tokens = { }

    def get_tokens_unprocessed(self, text, stack = ('root',)):
        pos = 0
        tokendefs = self._tokens
        statestack = list(stack)
        statetokens = tokendefs[statestack[-1]]
        while None:
            for rexmatch, action, new_state in statetokens:
                m = rexmatch(text, pos)
                if m:
                    if type(action) is _TokenType:
                        yield (pos, action, m.group())
                    else:
                        for item in action(self, m):
                            yield item

                    pos = m.end()
                    if new_state is not None:
                        if isinstance(new_state, tuple):
                            for state in new_state:
                                if state == '#pop':
                                    statestack.pop()
                                    continue
                                if state == '#push':
                                    statestack.append(statestack[-1])
                                    continue
                                statestack.append(state)

                        elif isinstance(new_state, int):
                            del statestack[new_state:]
                        elif new_state == '#push':
                            statestack.append(statestack[-1])

                        statetokens = tokendefs[statestack[-1]]

                    break
                    continue
            else:

                try:
                    if text[pos] == '\n':
                        pos += 1
                        statestack = [
                            'root']
                        statetokens = tokendefs['root']
                        yield (pos, Text, u'\n')
                        continue

                    yield (pos, Error, text[pos])
                    pos += 1
                continue
                except IndexError:
                    break
                    continue


                return None



class LexerContext(object):

    def __init__(self, text, pos, stack = None, end = None):
        self.text = text
        self.pos = pos
        if not end:
            pass
        self.end = len(text)
        if not stack:
            pass
        self.stack = [
            'root']


    def __repr__(self):
        return 'LexerContext(%r, %r, %r)' % (self.text, self.pos, self.stack)



class ExtendedRegexLexer(RegexLexer):

    def get_tokens_unprocessed(self, text = None, context = None):
        tokendefs = self._tokens
        if not context:
            ctx = LexerContext(text, 0)
            statetokens = tokendefs['root']
        else:
            ctx = context
            statetokens = tokendefs[ctx.stack[-1]]
            text = ctx.text
        while None:
            for rexmatch, action, new_state in statetokens:
                m = rexmatch(text, ctx.pos, ctx.end)
                if m:
                    if type(action) is _TokenType:
                        yield (ctx.pos, action, m.group())
                        ctx.pos = m.end()
                    else:
                        for item in action(self, m, ctx):
                            yield item

                        if not new_state:
                            statetokens = tokendefs[ctx.stack[-1]]

                    if new_state is not None:
                        if isinstance(new_state, tuple):
                            ctx.stack.extend(new_state)
                        elif isinstance(new_state, int):
                            del ctx.stack[new_state:]
                        elif new_state == '#push':
                            ctx.stack.append(ctx.stack[-1])

                        statetokens = tokendefs[ctx.stack[-1]]

                    break
                    continue
            else:

                try:
                    if ctx.pos >= ctx.end:
                        break

                    if text[ctx.pos] == '\n':
                        ctx.pos += 1
                        ctx.stack = [
                            'root']
                        statetokens = tokendefs['root']
                        yield (ctx.pos, Text, u'\n')
                        ctx
                        continue

                    yield (ctx.pos, Error, text[ctx.pos])
                    ctx.pos += 1
                continue
                except IndexError:
                    break
                    continue


                return None



def do_insertions(insertions, tokens):
    insertions = iter(insertions)

    try:
        (index, itokens) = insertions.next()
    except StopIteration:
        for item in tokens:
            yield item

        return None

    realpos = None
    insleft = True
    for i, t, v in tokens:
        if realpos is None:
            realpos = i

        oldi = 0
        while insleft and i + len(v) >= index:
            tmpval = v[oldi:index - i]
            yield (realpos, t, tmpval)
            realpos += len(tmpval)
            for it_index, it_token, it_value in itokens:
                yield (realpos, it_token, it_value)
                realpos += len(it_value)

            oldi = index - i

            try:
                (index, itokens) = insertions.next()
            continue
            except StopIteration:
                insleft = False
                break
                continue


            None<EXCEPTION MATCH>StopIteration
        yield (realpos, t, v[oldi:])
        realpos += len(v) - oldi

    while insleft:
        if not realpos:
            pass
        realpos = 0
        for p, t, v in itokens:
            yield (realpos, t, v)
            realpos += len(v)


        try:
            (index, itokens) = insertions.next()
        continue
        except StopIteration:
            insleft = False
            break
            continue


        None<EXCEPTION MATCH>StopIteration