File Manager

Hackfut Security File Manager

Current Path: /usr/lib/python2.6/site-packages/pygments/lexers

usr / lib / python2.6 / site-packages / pygments / lexers /

📁 ..
📄 __init__.py(7.17 KB)
📄 __init__.pyc(7.54 KB)
📄 __init__.pyo(7.54 KB)
📄 _clbuiltins.py(13.69 KB)
📄 _clbuiltins.pyc(16.65 KB)
📄 _clbuiltins.pyo(16.65 KB)
📄 _luabuiltins.py(6.88 KB)
📄 _luabuiltins.pyc(7.64 KB)
📄 _luabuiltins.pyo(7.64 KB)
📄 _mapping.py(22.15 KB)
📄 _mapping.pyc(31.18 KB)
📄 _mapping.pyo(31.18 KB)
📄 _phpbuiltins.py(103.65 KB)
📄 _phpbuiltins.pyc(84.19 KB)
📄 _phpbuiltins.pyo(84.19 KB)
📄 _vimbuiltins.py(38.92 KB)
📄 _vimbuiltins.pyc(38.12 KB)
📄 _vimbuiltins.pyo(38.12 KB)
📄 agile.py(58.74 KB)
📄 agile.pyc(45.28 KB)
📄 agile.pyo(45.28 KB)
📄 asm.py(10.92 KB)
📄 asm.pyc(9.21 KB)
📄 asm.pyo(9.21 KB)
📄 compiled.py(79.65 KB)
📄 compiled.pyc(60.27 KB)
📄 compiled.pyo(60.27 KB)
📄 dotnet.py(13.76 KB)
📄 dotnet.pyc(12.63 KB)
📄 dotnet.pyo(12.63 KB)
📄 functional.py(28.15 KB)
📄 functional.pyc(23.8 KB)
📄 functional.pyo(23.8 KB)
📄 math.py(16.44 KB)
📄 math.pyc(16.71 KB)
📄 math.pyo(16.71 KB)
📄 other.py(92.77 KB)
📄 other.pyc(72.23 KB)
📄 other.pyo(72.23 KB)
📄 parsers.py(22.8 KB)
📄 parsers.pyc(19.95 KB)
📄 parsers.pyo(19.95 KB)
📄 special.py(3.01 KB)
📄 special.pyc(3.72 KB)
📄 special.pyo(3.72 KB)
📄 templates.py(40.98 KB)
📄 templates.pyc(46.87 KB)
📄 templates.pyo(46.87 KB)
📄 text.py(53.03 KB)
📄 text.pyc(43.83 KB)
📄 text.pyo(43.83 KB)
📄 web.py(30.43 KB)
📄 web.pyc(26.68 KB)
📄 web.pyo(26.68 KB)

Editing: special.py

# -*- coding: utf-8 -*-
"""
    pygments.lexers.special
    ~~~~~~~~~~~~~~~~~~~~~~~

Special lexers.

:copyright: Copyright 2006-2009 by the Pygments team, see AUTHORS.
    :license: BSD, see LICENSE for details.
"""

import re
import cStringIO

from pygments.lexer import Lexer
from pygments.token import Token, Error, Text
from pygments.util import get_choice_opt, b

__all__ = ['TextLexer', 'RawTokenLexer']

class TextLexer(Lexer):
    """
    "Null" lexer, doesn't highlight anything.
    """
    name = 'Text only'
    aliases = ['text']
    filenames = ['*.txt']
    mimetypes = ['text/plain']

def get_tokens_unprocessed(self, text):
        yield 0, Text, text

_ttype_cache = {}

line_re = re.compile(b('.*?\n'))

class RawTokenLexer(Lexer):
    """
    Recreate a token stream formatted with the `RawTokenFormatter`.  This
    lexer raises exceptions during parsing if the token stream in the
    file is malformed.

Additional options accepted:

`compress`
        If set to ``"gz"`` or ``"bz2"``, decompress the token stream with
        the given compression algorithm before lexing (default: ``""``).
    """
    name = 'Raw token data'
    aliases = ['raw']
    filenames = []
    mimetypes = ['application/x-pygments-tokens']

def __init__(self, **options):
        self.compress = get_choice_opt(options, 'compress',
                                       ['', 'none', 'gz', 'bz2'], '')
        Lexer.__init__(self, **options)

def get_tokens(self, text):
        if isinstance(text, unicode):
            # raw token stream never has any non-ASCII characters
            text = text.encode('ascii')
        if self.compress == 'gz':
            import gzip
            gzipfile = gzip.GzipFile('', 'rb', 9, cStringIO.StringIO(text))
            text = gzipfile.read()
        elif self.compress == 'bz2':
            import bz2
            text = bz2.decompress(text)

# do not call Lexer.get_tokens() because we do not want Unicode
        # decoding to occur, and stripping is not optional.
        text = text.strip(b('\n')) + b('\n')
        for i, t, v in self.get_tokens_unprocessed(text):
            yield t, v

def get_tokens_unprocessed(self, text):
        length = 0
        for match in line_re.finditer(text):
            try:
                ttypestr, val = match.group().split(b('\t'), 1)
            except ValueError:
                val = match.group().decode(self.encoding)
                ttype = Error
            else:
                ttype = _ttype_cache.get(ttypestr)
                if not ttype:
                    ttype = Token
                    ttypes = ttypestr.split('.')[1:]
                    for ttype_ in ttypes:
                        if not ttype_ or not ttype_[0].isupper():
                            raise ValueError('malformed token name')
                        ttype = getattr(ttype, ttype_)
                    _ttype_cache[ttypestr] = ttype
                val = val[2:-2].decode('unicode-escape')
            yield length, ttype, val
            length += len(val)

Hackfut Security File Manager

Editing: special.py

Upload File

Create Folder