pygments.rb 0.6.3 → 1.0.0

data/vendor/pygments-main/pygments/lexers/trafficscript.py

@@ -0,0 +1,54 @@
+# -*- coding: utf-8 -*-
+"""
+    pygments.lexers.trafficscript
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    Lexer for RiverBed's TrafficScript (RTS) language.
+
+    :copyright: Copyright 2006-2015 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+import re
+
+from pygments.lexer import RegexLexer
+from pygments.token import String, Number, Name, Keyword, Operator, Text, Comment
+
+__all__ = ['RtsLexer']
+
+
+class RtsLexer(RegexLexer):
+    """
+    For `Riverbed Stingray Traffic Manager <http://www.riverbed.com/stingray>`_
+
+    .. versionadded:: 2.1
+    """
+    name = 'TrafficScript'
+    aliases = ['rts','trafficscript']
+    filenames = ['*.rts']
+
+    tokens = {
+        'root' : [
+            (r"'(\\\\|\\[^\\]|[^'\\])*'", String),
+            (r'"', String, 'escapable-string'),
+            (r'(0x[0-9a-fA-F]+|\d+)', Number),
+            (r'\d+\.\d+', Number.Float),
+            (r'\$[a-zA-Z](\w|_)*', Name.Variable),
+            (r'(if|else|for(each)?|in|while|do|break|sub|return|import)', Keyword),
+            (r'[a-zA-Z][\w.]*', Name.Function),
+            (r'[-+*/%=,;(){}<>^.!~|&\[\]\?\:]', Operator),
+            (r'(>=|<=|==|!=|'
+             r'&&|\|\||'
+             r'\+=|.=|-=|\*=|/=|%=|<<=|>>=|&=|\|=|\^=|'
+             r'>>|<<|'
+             r'\+\+|--|=>)', Operator),
+            (r'[ \t\r]+', Text),
+            (r'#[^\n]*', Comment),
+        ],
+        'escapable-string' : [
+            (r'\\[tsn]', String.Escape),
+            (r'[^"]', String),
+            (r'"', String, '#pop'),
+        ],
+
+    }

data/vendor/pygments-main/pygments/lexers/typoscript.py

@@ -0,0 +1,225 @@
+# -*- coding: utf-8 -*-
+"""
+    pygments.lexers.typoscript
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    Lexers for TypoScript
+
+    `TypoScriptLexer`
+        A TypoScript lexer.
+
+    `TypoScriptCssDataLexer`
+        Lexer that highlights markers, constants and registers within css.
+
+    `TypoScriptHtmlDataLexer`
+        Lexer that highlights markers, constants and registers within html tags.
+
+    :copyright: Copyright 2006-2015 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+import re
+
+from pygments.lexer import RegexLexer, include, bygroups, using
+from pygments.token import Keyword, Text, Comment, Name, String, Number, \
+    Operator, Punctuation
+from pygments.lexer import DelegatingLexer
+from pygments.lexers.web import HtmlLexer, CssLexer
+
+__all__ = ['TypoScriptLexer', 'TypoScriptCssDataLexer', 'TypoScriptHtmlDataLexer']
+
+
+class TypoScriptCssDataLexer(RegexLexer):
+    """
+    Lexer that highlights markers, constants and registers within css blocks.
+
+    .. versionadded:: 2.2
+    """
+
+    name = 'TypoScriptCssData'
+    aliases = ['typoscriptcssdata']
+
+    tokens = {
+        'root': [
+            # marker: ###MARK###
+            (r'(.*)(###\w+###)(.*)', bygroups(String, Name.Constant, String)),
+            # constant: {$some.constant}
+            (r'(\{)(\$)((?:[\w\-]+\.)*)([\w\-]+)(\})',
+             bygroups(String.Symbol, Operator, Name.Constant,
+                      Name.Constant, String.Symbol)),  # constant
+            # constant: {register:somevalue}
+            (r'(.*)(\{)([\w\-]+)(\s*:\s*)([\w\-]+)(\})(.*)',
+             bygroups(String, String.Symbol, Name.Constant, Operator,
+                      Name.Constant, String.Symbol, String)),  # constant
+            # whitespace
+            (r'\s+', Text),
+            # comments
+            (r'/\*(?:(?!\*/).)*\*/', Comment),
+            (r'(?<!(#|\'|"))(?:#(?!(?:[a-fA-F0-9]{6}|[a-fA-F0-9]{3}))[^\n#]+|//[^\n]*)',
+             Comment),
+            # other
+            (r'[<>,:=.*%+|]', String),
+            (r'[\w"\-!/&;(){}]+', String),
+        ]
+    }
+
+
+class TypoScriptHtmlDataLexer(RegexLexer):
+    """
+    Lexer that highlights markers, constants and registers within html tags.
+
+    .. versionadded:: 2.2
+    """
+
+    name = 'TypoScriptHtmlData'
+    aliases = ['typoscripthtmldata']
+
+    tokens = {
+        'root': [
+            # INCLUDE_TYPOSCRIPT
+            (r'(INCLUDE_TYPOSCRIPT)', Name.Class),
+            # Language label or extension resource FILE:... or LLL:... or EXT:...
+            (r'(EXT|FILE|LLL):[^}\n"]*', String),
+            # marker: ###MARK###
+            (r'(.*)(###\w+###)(.*)', bygroups(String, Name.Constant, String)),
+            # constant: {$some.constant}
+            (r'(\{)(\$)((?:[\w\-]+\.)*)([\w\-]+)(\})',
+             bygroups(String.Symbol, Operator, Name.Constant,
+                      Name.Constant, String.Symbol)),  # constant
+            # constant: {register:somevalue}
+            (r'(.*)(\{)([\w\-]+)(\s*:\s*)([\w\-]+)(\})(.*)',
+             bygroups(String, String.Symbol, Name.Constant, Operator,
+                      Name.Constant, String.Symbol, String)),  # constant
+            # whitespace
+            (r'\s+', Text),
+            # other
+            (r'[<>,:=.*%+|]', String),
+            (r'[\w"\-!/&;(){}#]+', String),
+        ]
+    }
+
+
+class TypoScriptLexer(RegexLexer):
+    """
+    Lexer for TypoScript code.
+
+    http://docs.typo3.org/typo3cms/TyposcriptReference/
+
+    .. versionadded:: 2.2
+    """
+
+    name = 'TypoScript'
+    aliases = ['typoscript']
+    filenames = ['*.ts', '*.txt']
+    mimetypes = ['text/x-typoscript']
+
+    flags = re.DOTALL | re.MULTILINE
+
+    tokens = {
+        'root': [
+            include('comment'),
+            include('constant'),
+            include('html'),
+            include('label'),
+            include('whitespace'),
+            include('keywords'),
+            include('punctuation'),
+            include('operator'),
+            include('structure'),
+            include('literal'),
+            include('other'),
+        ],
+        'keywords': [
+            # Conditions
+            (r'(\[)(?i)(browser|compatVersion|dayofmonth|dayofweek|dayofyear|'
+             r'device|ELSE|END|GLOBAL|globalString|globalVar|hostname|hour|IP|'
+             r'language|loginUser|loginuser|minute|month|page|PIDinRootline|'
+             r'PIDupinRootline|system|treeLevel|useragent|userFunc|usergroup|'
+             r'version)([^\]]*)(\])',
+             bygroups(String.Symbol, Name.Constant, Text, String.Symbol)),
+            # Functions
+            (r'(?=[\w\-])(HTMLparser|HTMLparser_tags|addParams|cache|encapsLines|'
+             r'filelink|if|imageLinkWrap|imgResource|makelinks|numRows|numberFormat|'
+             r'parseFunc|replacement|round|select|split|stdWrap|strPad|tableStyle|'
+             r'tags|textStyle|typolink)(?![\w\-])', Name.Function),
+            # Toplevel objects and _*
+            (r'(?:(=?\s*<?\s+|^\s*))(cObj|field|config|content|constants|FEData|'
+             r'file|frameset|includeLibs|lib|page|plugin|register|resources|sitemap|'
+             r'sitetitle|styles|temp|tt_[^:.\s]*|types|xmlnews|INCLUDE_TYPOSCRIPT|'
+             r'_CSS_DEFAULT_STYLE|_DEFAULT_PI_VARS|_LOCAL_LANG)(?![\w\-])',
+             bygroups(Operator, Name.Builtin)),
+            # Content objects
+            (r'(?=[\w\-])(CASE|CLEARGIF|COA|COA_INT|COBJ_ARRAY|COLUMNS|CONTENT|'
+             r'CTABLE|EDITPANEL|FILE|FILES|FLUIDTEMPLATE|FORM|HMENU|HRULER|HTML|'
+             r'IMAGE|IMGTEXT|IMG_RESOURCE|LOAD_REGISTER|MEDIA|MULTIMEDIA|OTABLE|'
+             r'PAGE|QTOBJECT|RECORDS|RESTORE_REGISTER|SEARCHRESULT|SVG|SWFOBJECT|'
+             r'TEMPLATE|TEXT|USER|USER_INT)(?![\w\-])', Name.Class),
+            # Menu states
+            (r'(?=[\w\-])(ACTIFSUBRO|ACTIFSUB|ACTRO|ACT|CURIFSUBRO|CURIFSUB|CURRO|'
+             r'CUR|IFSUBRO|IFSUB|NO|SPC|USERDEF1RO|USERDEF1|USERDEF2RO|USERDEF2|'
+             r'USRRO|USR)', Name.Class),
+            # Menu objects
+            (r'(?=[\w\-])(GMENU_FOLDOUT|GMENU_LAYERS|GMENU|IMGMENUITEM|IMGMENU|'
+             r'JSMENUITEM|JSMENU|TMENUITEM|TMENU_LAYERS|TMENU)', Name.Class),
+            # PHP objects
+            (r'(?=[\w\-])(PHP_SCRIPT(_EXT|_INT)?)', Name.Class),
+            (r'(?=[\w\-])(userFunc)(?![\w\-])', Name.Function),
+        ],
+        'whitespace': [
+            (r'\s+', Text),
+        ],
+        'html':[
+            (r'<\S[^\n>]*>', using(TypoScriptHtmlDataLexer)),
+            (r'&[^;\n]*;', String),
+            (r'(_CSS_DEFAULT_STYLE)(\s*)(\()(?s)(.*(?=\n\)))',
+              bygroups(Name.Class, Text, String.Symbol, using(TypoScriptCssDataLexer))),
+        ],
+        'literal': [
+            (r'0x[0-9A-Fa-f]+t?',Number.Hex),
+            # (r'[0-9]*\.[0-9]+([eE][0-9]+)?[fd]?\s*(?:[^=])', Number.Float),
+            (r'[0-9]+', Number.Integer),
+            (r'(###\w+###)', Name.Constant),
+        ],
+        'label': [
+            # Language label or extension resource FILE:... or LLL:... or EXT:...
+            (r'(EXT|FILE|LLL):[^}\n"]*', String),
+            # Path to a resource
+            (r'(?![^\w\-])([\w\-]+(?:/[\w\-]+)+/?)(\S*\n)',
+             bygroups(String, String)),
+        ],
+        'punctuation': [
+            (r'[,.]', Punctuation),
+        ],
+        'operator': [
+            (r'[<>,:=.*%+|]', Operator),
+        ],
+        'structure': [
+            # Brackets and braces
+            (r'[{}()\[\]\\]', String.Symbol),
+        ],
+        'constant': [
+            # Constant: {$some.constant}
+            (r'(\{)(\$)((?:[\w\-]+\.)*)([\w\-]+)(\})',
+                bygroups(String.Symbol, Operator, Name.Constant,
+                         Name.Constant, String.Symbol)),  # constant
+            # Constant: {register:somevalue}
+            (r'(\{)([\w\-]+)(\s*:\s*)([\w\-]+)(\})',
+                bygroups(String.Symbol, Name.Constant, Operator,
+                         Name.Constant, String.Symbol)),  # constant
+            # Hex color: #ff0077
+            (r'(#[a-fA-F0-9]{6}\b|#[a-fA-F0-9]{3}\b)', String.Char)
+        ],
+        'comment': [
+            (r'(?<!(#|\'|"))(?:#(?!(?:[a-fA-F0-9]{6}|[a-fA-F0-9]{3}))[^\n#]+|//[^\n]*)',
+             Comment),
+            (r'/\*(?:(?!\*/).)*\*/', Comment),
+            (r'(\s*#\s*\n)', Comment),
+        ],
+        'other': [
+            (r'[\w"\-!/&;]+', Text),
+        ],
+    }
+
+    def analyse_text(text):
+        if '<INCLUDE_TYPOSCRIPT:' in text:
+            return 1.0

data/vendor/pygments-main/pygments/lexers/urbi.py

@@ -0,0 +1,133 @@
+# -*- coding: utf-8 -*-
+"""
+    pygments.lexers.urbi
+    ~~~~~~~~~~~~~~~~~~~~
+
+    Lexers for UrbiScript language.
+
+    :copyright: Copyright 2006-2015 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+import re
+
+from pygments.lexer import ExtendedRegexLexer, words
+from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
+    Number, Punctuation
+
+__all__ = ['UrbiscriptLexer']
+
+
+class UrbiscriptLexer(ExtendedRegexLexer):
+    """
+    For UrbiScript source code.
+
+    .. versionadded:: 1.5
+    """
+
+    name = 'UrbiScript'
+    aliases = ['urbiscript']
+    filenames = ['*.u']
+    mimetypes = ['application/x-urbiscript']
+
+    flags = re.DOTALL
+
+    # TODO
+    # - handle Experimental and deprecated tags with specific tokens
+    # - handle Angles and Durations with specific tokens
+
+    def blob_callback(lexer, match, ctx):
+        text_before_blob = match.group(1)
+        blob_start = match.group(2)
+        blob_size_str = match.group(3)
+        blob_size = int(blob_size_str)
+        yield match.start(), String, text_before_blob
+        ctx.pos += len(text_before_blob)
+
+        # if blob size doesn't match blob format (example : "\B(2)(aaa)")
+        # yield blob as a string
+        if ctx.text[match.end() + blob_size] != ")":
+            result = "\\B(" + blob_size_str + ")("
+            yield match.start(), String, result
+            ctx.pos += len(result)
+            return
+
+        # if blob is well formated, yield as Escape
+        blob_text = blob_start + ctx.text[match.end():match.end()+blob_size] + ")"
+        yield match.start(), String.Escape, blob_text
+        ctx.pos = match.end() + blob_size + 1  # +1 is the ending ")"
+
+    tokens = {
+        'root': [
+            (r'\s+', Text),
+            # comments
+            (r'//.*?\n', Comment),
+            (r'/\*', Comment.Multiline, 'comment'),
+            (r'(every|for|loop|while)(?:;|&|\||,)', Keyword),
+            (words((
+                'assert', 'at', 'break', 'case', 'catch', 'closure', 'compl',
+                'continue', 'default', 'else', 'enum', 'every', 'external',
+                'finally', 'for', 'freezeif', 'if', 'new', 'onleave', 'return',
+                'stopif', 'switch', 'this', 'throw', 'timeout', 'try',
+                'waituntil', 'whenever', 'while'), suffix=r'\b'),
+             Keyword),
+            (words((
+                'asm', 'auto', 'bool', 'char', 'const_cast', 'delete', 'double',
+                'dynamic_cast', 'explicit', 'export', 'extern', 'float', 'friend',
+                'goto', 'inline', 'int', 'long', 'mutable', 'namespace', 'register',
+                'reinterpret_cast', 'short', 'signed', 'sizeof', 'static_cast',
+                'struct', 'template', 'typedef', 'typeid', 'typename', 'union',
+                'unsigned', 'using', 'virtual', 'volatile', 'wchar_t'), suffix=r'\b'),
+             Keyword.Reserved),
+            # deprecated keywords, use a meaningfull token when available
+            (r'(emit|foreach|internal|loopn|static)\b', Keyword),
+            # ignored keywords, use a meaningfull token when available
+            (r'(private|protected|public)\b', Keyword),
+            (r'(var|do|const|function|class)\b', Keyword.Declaration),
+            (r'(true|false|nil|void)\b', Keyword.Constant),
+            (words((
+                'Barrier', 'Binary', 'Boolean', 'CallMessage', 'Channel', 'Code',
+                'Comparable', 'Container', 'Control', 'Date', 'Dictionary', 'Directory',
+                'Duration', 'Enumeration', 'Event', 'Exception', 'Executable', 'File',
+                'Finalizable', 'Float', 'FormatInfo', 'Formatter', 'Global', 'Group',
+                'Hash', 'InputStream', 'IoService', 'Job', 'Kernel', 'Lazy', 'List',
+                'Loadable', 'Lobby', 'Location', 'Logger', 'Math', 'Mutex', 'nil',
+                'Object', 'Orderable', 'OutputStream', 'Pair', 'Path', 'Pattern',
+                'Position', 'Primitive', 'Process', 'Profile', 'PseudoLazy', 'PubSub',
+                'RangeIterable', 'Regexp', 'Semaphore', 'Server', 'Singleton', 'Socket',
+                'StackFrame', 'Stream', 'String', 'System', 'Tag', 'Timeout',
+                'Traceable', 'TrajectoryGenerator', 'Triplet', 'Tuple', 'UObject',
+                'UValue', 'UVar'), suffix=r'\b'),
+             Name.Builtin),
+            (r'(?:this)\b', Name.Builtin.Pseudo),
+            # don't match single | and &
+            (r'(?:[-=+*%/<>~^:]+|\.&?|\|\||&&)', Operator),
+            (r'(?:and_eq|and|bitand|bitor|in|not|not_eq|or_eq|or|xor_eq|xor)\b',
+             Operator.Word),
+            (r'[{}\[\]()]+', Punctuation),
+            (r'(?:;|\||,|&|\?|!)+', Punctuation),
+            (r'[$a-zA-Z_]\w*', Name.Other),
+            (r'0x[0-9a-fA-F]+', Number.Hex),
+            # Float, Integer, Angle and Duration
+            (r'(?:[0-9]+(?:(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?)?'
+             r'((?:rad|deg|grad)|(?:ms|s|min|h|d))?)\b', Number.Float),
+            # handle binary blob in strings
+            (r'"', String.Double, "string.double"),
+            (r"'", String.Single, "string.single"),
+        ],
+        'string.double': [
+            (r'((?:\\\\|\\"|[^"])*?)(\\B\((\d+)\)\()', blob_callback),
+            (r'(\\\\|\\"|[^"])*?"', String.Double, '#pop'),
+        ],
+        'string.single': [
+            (r"((?:\\\\|\\'|[^'])*?)(\\B\((\d+)\)\()", blob_callback),
+            (r"(\\\\|\\'|[^'])*?'", String.Single, '#pop'),
+        ],
+        # from http://pygments.org/docs/lexerdevelopment/#changing-states
+        'comment': [
+            (r'[^*/]', Comment.Multiline),
+            (r'/\*', Comment.Multiline, '#push'),
+            (r'\*/', Comment.Multiline, '#pop'),
+            (r'[*/]', Comment.Multiline),
+        ]
+    }

data/vendor/pygments-main/pygments/lexers/varnish.py

@@ -0,0 +1,190 @@
+# -*- coding: utf-8 -*-
+"""
+    pygments.lexers.varnish
+    ~~~~~~~~~~~~~~~~~~~~~~~
+
+    Lexers for Varnish configuration
+
+    :copyright: Copyright 2006-2015 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.lexer import RegexLexer, include, bygroups, using, this, \
+    inherit, words
+from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
+    Number, Punctuation, Literal
+
+__all__ = ['VCLLexer', 'VCLSnippetLexer']
+
+
+class VCLLexer(RegexLexer):
+    """
+    For Varnish Configuration Language (VCL).
+
+    .. versionadded:: 2.2
+    """
+    name = 'VCL'
+    aliases = ['vcl']
+    filenames = ['*.vcl']
+    mimetypes = ['text/x-vclsrc']
+
+    def analyse_text(text):
+        # If the very first line is 'vcl 4.0;' it's pretty much guaranteed
+        # that this is VCL
+        if text.startswith('vcl 4.0;'):
+            return 1.0
+        # Skip over comments and blank lines
+        # This is accurate enough that returning 0.9 is reasonable.
+        # Almost no VCL files start without some comments.
+        elif '\nvcl 4\.0;' in text[:1000]:
+            return 0.9
+
+    tokens = {
+        'probe': [
+            include('whitespace'),
+            include('comments'),
+            (r'(\.\w+)(\s*=\s*)([^;]*)(;)',
+             bygroups(Name.Attribute, Operator, using(this), Punctuation)),
+            (r'\}', Punctuation, '#pop'),
+        ],
+        'acl': [
+            include('whitespace'),
+            include('comments'),
+            (r'[!/]+', Operator),
+            (r';', Punctuation),
+            (r'\d+', Number),
+            (r'\}', Punctuation, '#pop'),
+        ],
+        'backend': [
+            include('whitespace'),
+            (r'(\.probe)(\s*=\s*)(\w+)(;)',
+             bygroups(Name.Attribute, Operator, Name.Variable.Global, Punctuation)),
+            (r'(\.probe)(\s*=\s*)(\{)',
+             bygroups(Name.Attribute, Operator, Punctuation), 'probe'),
+            (r'(\.\w+\b)(\s*=\s*)([^;]*)(\s*;)',
+             bygroups(Name.Attribute, Operator, using(this), Punctuation)),
+            (r'\{', Punctuation, '#push'),
+            (r'\}', Punctuation, '#pop'),
+        ],
+        'statements': [
+            (r'(\d\.)?\d+[sdwhmy]', Literal.Date),
+            (r'(\d\.)?\d+ms', Literal.Date),
+            (r'(vcl_pass|vcl_hash|vcl_hit|vcl_init|vcl_backend_fetch|vcl_pipe|'
+             r'vcl_backend_response|vcl_synth|vcl_deliver|vcl_backend_error|'
+             r'vcl_fini|vcl_recv|vcl_purge|vcl_miss)\b', Name.Function),
+            (r'(pipe|retry|hash|synth|deliver|purge|abandon|lookup|pass|fail|ok|'
+             r'miss|fetch|restart)\b', Name.Constant),
+            (r'(beresp|obj|resp|req|req_top|bereq)\.http\.[a-zA-Z_-]+\b', Name.Variable),
+            (words((
+                'obj.status', 'req.hash_always_miss', 'beresp.backend', 'req.esi_level',
+                'req.can_gzip', 'beresp.ttl', 'obj.uncacheable', 'req.ttl', 'obj.hits',
+                'client.identity', 'req.hash_ignore_busy', 'obj.reason', 'req.xid',
+                'req_top.proto', 'beresp.age', 'obj.proto', 'obj.age', 'local.ip',
+                'beresp.uncacheable', 'req.method', 'beresp.backend.ip', 'now',
+                'obj.grace', 'req.restarts', 'beresp.keep', 'req.proto', 'resp.proto',
+                'bereq.xid', 'bereq.between_bytes_timeout', 'req.esi',
+                'bereq.first_byte_timeout', 'bereq.method', 'bereq.connect_timeout',
+                'beresp.do_gzip',  'resp.status', 'beresp.do_gunzip',
+                'beresp.storage_hint', 'resp.is_streaming', 'beresp.do_stream',
+                'req_top.method', 'bereq.backend', 'beresp.backend.name', 'beresp.status',
+                'req.url', 'obj.keep', 'obj.ttl', 'beresp.reason', 'bereq.retries',
+                'resp.reason', 'bereq.url', 'beresp.do_esi', 'beresp.proto', 'client.ip',
+                'bereq.proto', 'server.hostname', 'remote.ip', 'req.backend_hint',
+                'server.identity', 'req_top.url', 'beresp.grace', 'beresp.was_304',
+                'server.ip', 'bereq.uncacheable'), suffix=r'\b'),
+             Name.Variable),
+            (r'[!%&+*\-,/<.}{>=|~]+', Operator),
+            (r'[();]', Punctuation),
+
+            (r'[,]+', Punctuation),
+            (words(('hash_data', 'regsub', 'regsuball', 'if', 'else',
+                    'elsif', 'elif', 'synth', 'synthetic', 'ban',
+                    'return', 'set', 'unset', 'import', 'include', 'new',
+                    'rollback', 'call'), suffix=r'\b'),
+             Keyword),
+            (r'storage\.\w+\.\w+\b', Name.Variable),
+            (words(('true', 'false')), Name.Builtin),
+            (r'\d+\b', Number),
+            (r'(backend)(\s+\w+)(\s*\{)',
+             bygroups(Keyword, Name.Variable.Global, Punctuation), 'backend'),
+            (r'(probe\s)(\s*\w+\s)(\{)',
+             bygroups(Keyword, Name.Variable.Global, Punctuation), 'probe'),
+            (r'(acl\s)(\s*\w+\s)(\{)',
+             bygroups(Keyword, Name.Variable.Global, Punctuation), 'acl'),
+            (r'(vcl )(4.0)(;)$',
+             bygroups(Keyword.Reserved, Name.Constant, Punctuation)),
+            (r'(sub\s+)([a-zA-Z]\w*)(\s*\{)',
+                bygroups(Keyword, Name.Function, Punctuation)),
+            (r'([a-zA-Z_]\w*)'
+             r'(\.)'
+             r'([a-zA-Z_]\w*)'
+             r'(\s*\(.*\))',
+             bygroups(Name.Function, Punctuation, Name.Function, using(this))),
+            ('[a-zA-Z_]\w*', Name),
+            ],
+        'comment': [
+            (r'[^*/]+', Comment.Multiline),
+            (r'/\*', Comment.Multiline, '#push'),
+            (r'\*/', Comment.Multiline, '#pop'),
+            (r'[*/]', Comment.Multiline),
+            ],
+        'comments': [
+            (r'#.*$', Comment),
+            (r'/\*', Comment.Multiline, 'comment'),
+            (r'//.*$', Comment),
+        ],
+        'string': [
+            (r'"', String, '#pop'),
+            (r'[^"\n]+', String),  # all other characters
+        ],
+        'multistring': [
+            (r'[^"}]', String),
+            (r'"\}', String, '#pop'),
+            (r'["}]', String),
+        ],
+        'whitespace': [
+            (r'L?"', String, 'string'),
+            (r'\{"', String, 'multistring'),
+            (r'\n', Text),
+            (r'\s+', Text),
+            (r'\\\n', Text),  # line continuation
+        ],
+        'root': [
+            include('whitespace'),
+            include('comments'),
+            include('statements'),
+            (r'\s+', Text),
+        ],
+    }
+
+
+class VCLSnippetLexer(VCLLexer):
+    """
+    For Varnish Configuration Language snippets.
+
+    .. versionadded:: 2.2
+    """
+    name = 'VCLSnippets'
+    aliases = ['vclsnippets', 'vclsnippet']
+    mimetypes = ['text/x-vclsnippet']
+    filenames = []
+
+    def analyse_text(text):
+        # override method inherited from VCLLexer
+        return 0
+
+    tokens = {
+        'snippetspre': [
+            (r'\.\.\.+', Comment),
+            (r'(bereq|req|req_top|resp|beresp|obj|client|server|local|remote|'
+             r'storage)($|\.\*)', Name.Variable),
+        ],
+        'snippetspost': [
+            (r'(backend)\b', Keyword.Reserved),
+        ],
+        'root': [
+            include('snippetspre'),
+            inherit,
+            include('snippetspost'),
+        ],
+    }