Add files using upload-large-folder tool

67c066c verified over 1 year ago

13.1 kB

"""
    pygments.lexers.php
    ~~~~~~~~~~~~~~~~~~~
    Lexers for PHP and related languages.
    :copyright: Copyright 2006-2025 by the Pygments team, see AUTHORS.
    :license: BSD, see LICENSE for details.
"""

import re

from pygments.lexer import Lexer, RegexLexer, include, bygroups, default, \
    using, this, words, do_insertions, line_re
from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
    Number, Punctuation, Other, Generic
from pygments.util import get_bool_opt, get_list_opt, shebang_matches

__all__ = ['ZephirLexer', 'PsyshConsoleLexer', 'PhpLexer']


class ZephirLexer(RegexLexer):
    """
    For Zephir language source code.
    Zephir is a compiled high level language aimed
    to the creation of C-extensions for PHP.
    """

    name = 'Zephir'
    url = 'http://zephir-lang.com/'
    aliases = ['zephir']
    filenames = ['*.zep']
    version_added = '2.0'

    zephir_keywords = ['fetch', 'echo', 'isset', 'empty']
    zephir_type = ['bit', 'bits', 'string']

    flags = re.DOTALL | re.MULTILINE

    tokens = {
        'commentsandwhitespace': [
            (r'\s+', Text),
            (r'//.*?\n', Comment.Single),
            (r'/\*.*?\*/', Comment.Multiline)
        ],
        'slashstartsregex': [
            include('commentsandwhitespace'),
            (r'/(\\.|[^[/\\\n]|\[(\\.|[^\]\\\n])*])+/'
             r'([gim]+\b|\B)', String.Regex, '#pop'),
            (r'/', Operator, '#pop'),
            default('#pop')
        ],
        'badregex': [
            (r'\n', Text, '#pop')
        ],
        'root': [
            (r'^(?=\s|/)', Text, 'slashstartsregex'),
            include('commentsandwhitespace'),
            (r'\+\+|--|~|&&|\?|:|\|\||\\(?=\n)|'
             r'(<<|>>>?|==?|!=?|->|[-<>+*%&|^/])=?', Operator, 'slashstartsregex'),
            (r'[{(\[;,]', Punctuation, 'slashstartsregex'),
            (r'[})\].]', Punctuation),
            (r'(for|in|while|do|break|return|continue|switch|case|default|if|else|loop|'
             r'require|inline|throw|try|catch|finally|new|delete|typeof|instanceof|void|'
             r'namespace|use|extends|this|fetch|isset|unset|echo|fetch|likely|unlikely|'
             r'empty)\b', Keyword, 'slashstartsregex'),
            (r'(var|let|with|function)\b', Keyword.Declaration, 'slashstartsregex'),
            (r'(abstract|boolean|bool|char|class|const|double|enum|export|extends|final|'
             r'native|goto|implements|import|int|string|interface|long|ulong|char|uchar|'
             r'float|unsigned|private|protected|public|short|static|self|throws|reverse|'
             r'transient|volatile|readonly)\b', Keyword.Reserved),
            (r'(true|false|null|undefined)\b', Keyword.Constant),
            (r'(Array|Boolean|Date|_REQUEST|_COOKIE|_SESSION|'
             r'_GET|_POST|_SERVER|this|stdClass|range|count|iterator|'
             r'window)\b', Name.Builtin),
            (r'[$a-zA-Z_][\w\\]*', Name.Other),
            (r'[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?', Number.Float),
            (r'0x[0-9a-fA-F]+', Number.Hex),
            (r'[0-9]+', Number.Integer),
            (r'"(\\\\|\\[^\\]|[^"\\])*"', String.Double),
            (r"'(\\\\|\\[^\\]|[^'\\])*'", String.Single),
        ]
    }


class PsyshConsoleLexer(Lexer):
    """
    For PsySH console output, such as:
    .. sourcecode:: psysh
        >>> $greeting = function($name): string {
        ...     return "Hello, {$name}";
        ... };
        => Closure($name): string {#2371 …3}
        >>> $greeting('World')
        => "Hello, World"
    """
    name = 'PsySH console session for PHP'
    url = 'https://psysh.org/'
    aliases = ['psysh']
    version_added = '2.7'

    def __init__(self, **options):
        options['startinline'] = True
        Lexer.__init__(self, **options)

    def get_tokens_unprocessed(self, text):
        phplexer = PhpLexer(**self.options)
        curcode = ''
        insertions = []
        for match in line_re.finditer(text):
            line = match.group()
            if line.startswith('>>> ') or line.startswith('... '):
                insertions.append((len(curcode),
                                   [(0, Generic.Prompt, line[:4])]))
                curcode += line[4:]
            elif line.rstrip() == '...':
                insertions.append((len(curcode),
                                   [(0, Generic.Prompt, '...')]))
                curcode += line[3:]
            else:
                if curcode:
                    yield from do_insertions(
                        insertions, phplexer.get_tokens_unprocessed(curcode))
                    curcode = ''
                    insertions = []
                yield match.start(), Generic.Output, line
        if curcode:
            yield from do_insertions(insertions,
                                     phplexer.get_tokens_unprocessed(curcode))


class PhpLexer(RegexLexer):
    """
    For PHP source code.
    For PHP embedded in HTML, use the `HtmlPhpLexer`.
    Additional options accepted:
    `startinline`
        If given and ``True`` the lexer starts highlighting with
        php code (i.e.: no starting ``<?php`` required).  The default
        is ``False``.
    `funcnamehighlighting`
        If given and ``True``, highlight builtin function names
        (default: ``True``).
    `disabledmodules`
        If given, must be a list of module names whose function names
        should not be highlighted. By default all modules are highlighted
        except the special ``'unknown'`` module that includes functions
        that are known to php but are undocumented.
        To get a list of allowed modules have a look into the
        `_php_builtins` module:
        .. sourcecode:: pycon
            >>> from pygments.lexers._php_builtins import MODULES
            >>> MODULES.keys()
            ['PHP Options/Info', 'Zip', 'dba', ...]
        In fact the names of those modules match the module names from
        the php documentation.
    """

    name = 'PHP'
    url = 'https://www.php.net/'
    aliases = ['php', 'php3', 'php4', 'php5']
    filenames = ['*.php', '*.php[345]', '*.inc']
    mimetypes = ['text/x-php']
    version_added = ''

    # Note that a backslash is included, PHP uses a backslash as a namespace
    # separator.
    _ident_inner = r'(?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w]|[^\x00-\x7f])*'
    # But not inside strings.
    _ident_nons = r'(?:[_a-z]|[^\x00-\x7f])(?:\w|[^\x00-\x7f])*'

    flags = re.IGNORECASE | re.DOTALL | re.MULTILINE
    tokens = {
        'root': [
            (r'<\?(php)?', Comment.Preproc, 'php'),
            (r'[^<]+', Other),
            (r'<', Other)
        ],
        'php': [
            (r'\?>', Comment.Preproc, '#pop'),
            (r'(<<<)([\'"]?)(' + _ident_nons + r')(\2\n.*?\n\s*)(\3)(;?)(\n)',
             bygroups(String, String, String.Delimiter, String, String.Delimiter,
                      Punctuation, Text)),
            (r'\s+', Text),
            (r'#\[', Punctuation, 'attribute'),
            (r'#.*?\n', Comment.Single),
            (r'//.*?\n', Comment.Single),
            # put the empty comment here, it is otherwise seen as
            # the start of a docstring
            (r'/\*\*/', Comment.Multiline),
            (r'/\*\*.*?\*/', String.Doc),
            (r'/\*.*?\*/', Comment.Multiline),
            (r'(->|::)(\s*)(' + _ident_nons + ')',
             bygroups(Operator, Text, Name.Attribute)),
            (r'[~!%^&*+=|:.<>/@-]+', Operator),
            (r'\?', Operator),  # don't add to the charclass above!
            (r'[\[\]{}();,]+', Punctuation),
            (r'(new)(\s+)(class)\b', bygroups(Keyword, Text, Keyword)),
            (r'(class)(\s+)', bygroups(Keyword, Text), 'classname'),
            (r'(function)(\s*)(?=\()', bygroups(Keyword, Text)),
            (r'(function)(\s+)(&?)(\s*)',
             bygroups(Keyword, Text, Operator, Text), 'functionname'),
            (r'(const)(\s+)(' + _ident_inner + ')',
             bygroups(Keyword, Text, Name.Constant)),
            (r'(and|E_PARSE|old_function|E_ERROR|or|as|E_WARNING|parent|'
             r'eval|PHP_OS|break|exit|case|extends|PHP_VERSION|cfunction|'
             r'FALSE|print|for|require|continue|foreach|require_once|'
             r'declare|return|default|static|do|switch|die|stdClass|'
             r'echo|else|TRUE|elseif|var|empty|if|xor|enddeclare|include|'
             r'virtual|endfor|include_once|while|endforeach|global|'
             r'endif|list|endswitch|new|endwhile|not|'
             r'array|E_ALL|NULL|final|php_user_filter|interface|'
             r'implements|public|private|protected|abstract|clone|try|'
             r'catch|throw|this|use|namespace|trait|yield|'
             r'finally|match)\b', Keyword),
            (r'(true|false|null)\b', Keyword.Constant),
            include('magicconstants'),
            (r'\$\{', Name.Variable, 'variablevariable'),
            (r'\$+' + _ident_inner, Name.Variable),
            (_ident_inner, Name.Other),
            (r'(\d+\.\d*|\d*\.\d+)(e[+-]?[0-9]+)?', Number.Float),
            (r'\d+e[+-]?[0-9]+', Number.Float),
            (r'0[0-7]+', Number.Oct),
            (r'0x[a-f0-9]+', Number.Hex),
            (r'\d+', Number.Integer),
            (r'0b[01]+', Number.Bin),
            (r"'([^'\\]*(?:\\.[^'\\]*)*)'", String.Single),
            (r'`([^`\\]*(?:\\.[^`\\]*)*)`', String.Backtick),
            (r'"', String.Double, 'string'),
        ],
        'variablevariable': [
            (r'\}', Name.Variable, '#pop'),
            include('php')
        ],
        'magicfuncs': [
            # source: http://php.net/manual/en/language.oop5.magic.php
            (words((
                '__construct', '__destruct', '__call', '__callStatic', '__get', '__set',
                '__isset', '__unset', '__sleep', '__wakeup', '__toString', '__invoke',
                '__set_state', '__clone', '__debugInfo',), suffix=r'\b'),
             Name.Function.Magic),
        ],
        'magicconstants': [
            # source: http://php.net/manual/en/language.constants.predefined.php
            (words((
                '__LINE__', '__FILE__', '__DIR__', '__FUNCTION__', '__CLASS__',
                '__TRAIT__', '__METHOD__', '__NAMESPACE__',),
                suffix=r'\b'),
             Name.Constant),
        ],
        'classname': [
            (_ident_inner, Name.Class, '#pop')
        ],
        'functionname': [
            include('magicfuncs'),
            (_ident_inner, Name.Function, '#pop'),
            default('#pop')
        ],
        'string': [
            (r'"', String.Double, '#pop'),
            (r'[^{$"\\]+', String.Double),
            (r'\\([nrt"$\\]|[0-7]{1,3}|x[0-9a-f]{1,2})', String.Escape),
            (r'\$' + _ident_nons + r'(\[\S+?\]|->' + _ident_nons + ')?',
             String.Interpol),
            (r'(\{\$\{)(.*?)(\}\})',
             bygroups(String.Interpol, using(this, _startinline=True),
                      String.Interpol)),
            (r'(\{)(\$.*?)(\})',
             bygroups(String.Interpol, using(this, _startinline=True),
                      String.Interpol)),
            (r'(\$\{)(\S+)(\})',
             bygroups(String.Interpol, Name.Variable, String.Interpol)),
            (r'[${\\]', String.Double)
        ],
        'attribute': [
            (r'\]', Punctuation, '#pop'),
            (r'\(', Punctuation, 'attributeparams'),
            (_ident_inner, Name.Decorator),
            include('php')
        ],
        'attributeparams': [
            (r'\)', Punctuation, '#pop'),
            include('php')
        ],
    }

    def __init__(self, **options):
        self.funcnamehighlighting = get_bool_opt(
            options, 'funcnamehighlighting', True)
        self.disabledmodules = get_list_opt(
            options, 'disabledmodules', ['unknown'])
        self.startinline = get_bool_opt(options, 'startinline', False)

        # private option argument for the lexer itself
        if '_startinline' in options:
            self.startinline = options.pop('_startinline')

        # collect activated functions in a set
        self._functions = set()
        if self.funcnamehighlighting:
            from pygments.lexers._php_builtins import MODULES
            for key, value in MODULES.items():
                if key not in self.disabledmodules:
                    self._functions.update(value)
        RegexLexer.__init__(self, **options)

    def get_tokens_unprocessed(self, text):
        stack = ['root']
        if self.startinline:
            stack.append('php')
        for index, token, value in \
                RegexLexer.get_tokens_unprocessed(self, text, stack):
            if token is Name.Other:
                if value in self._functions:
                    yield index, Name.Builtin, value
                    continue
            yield index, token, value

    def analyse_text(text):
        if shebang_matches(text, r'php'):
            return True
        rv = 0.0
        if re.search(r'<\?(?!xml)', text):
            rv += 0.3
        return rv

	"""
	pygments.lexers.php
	~~~~~~~~~~~~~~~~~~~

	Lexers for PHP and related languages.

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

	import re

	from pygments.lexer import Lexer, RegexLexer, include, bygroups, default, \
	using, this, words, do_insertions, line_re
	from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
	Number, Punctuation, Other, Generic
	from pygments.util import get_bool_opt, get_list_opt, shebang_matches

	__all__ = ['ZephirLexer', 'PsyshConsoleLexer', 'PhpLexer']


	class ZephirLexer(RegexLexer):
	"""
	For Zephir language source code.

	Zephir is a compiled high level language aimed
	to the creation of C-extensions for PHP.
	"""

	name = 'Zephir'
	url = 'http://zephir-lang.com/'
	aliases = ['zephir']
	filenames = ['*.zep']
	version_added = '2.0'

	zephir_keywords = ['fetch', 'echo', 'isset', 'empty']
	zephir_type = ['bit', 'bits', 'string']

	flags = re.DOTALL \| re.MULTILINE

	tokens = {
	'commentsandwhitespace': [
	(r'\s+', Text),
	(r'//.*?\n', Comment.Single),
	(r'/\.?\*/', Comment.Multiline)
	],
	'slashstartsregex': [
	include('commentsandwhitespace'),
	(r'/(\\.\|[^[/\\\n]\|\[(\\.\|[^\]\\\n])*])+/'
	r'([gim]+\b\|\B)', String.Regex, '#pop'),
	(r'/', Operator, '#pop'),
	default('#pop')
	],
	'badregex': [
	(r'\n', Text, '#pop')
	],
	'root': [
	(r'^(?=\s\|/)', Text, 'slashstartsregex'),
	include('commentsandwhitespace'),
	(r'\+\+\|--\|~\|&&\|\?\|:\|\\|\\|\|\\(?=\n)\|'
	r'(<<\|>>>?\|==?\|!=?\|->\|[-<>+*%&\|^/])=?', Operator, 'slashstartsregex'),
	(r'[{(\[;,]', Punctuation, 'slashstartsregex'),
	(r'[})\].]', Punctuation),
	(r'(for\|in\|while\|do\|break\|return\|continue\|switch\|case\|default\|if\|else\|loop\|'
	r'require\|inline\|throw\|try\|catch\|finally\|new\|delete\|typeof\|instanceof\|void\|'
	r'namespace\|use\|extends\|this\|fetch\|isset\|unset\|echo\|fetch\|likely\|unlikely\|'
	r'empty)\b', Keyword, 'slashstartsregex'),
	(r'(var\|let\|with\|function)\b', Keyword.Declaration, 'slashstartsregex'),
	(r'(abstract\|boolean\|bool\|char\|class\|const\|double\|enum\|export\|extends\|final\|'
	r'native\|goto\|implements\|import\|int\|string\|interface\|long\|ulong\|char\|uchar\|'
	r'float\|unsigned\|private\|protected\|public\|short\|static\|self\|throws\|reverse\|'
	r'transient\|volatile\|readonly)\b', Keyword.Reserved),
	(r'(true\|false\|null\|undefined)\b', Keyword.Constant),
	(r'(Array\|Boolean\|Date\|_REQUEST\|_COOKIE\|_SESSION\|'
	r'_GET\|_POST\|_SERVER\|this\|stdClass\|range\|count\|iterator\|'
	r'window)\b', Name.Builtin),
	(r'[$a-zA-Z_][\w\\]*', Name.Other),
	(r'[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?', Number.Float),
	(r'0x[0-9a-fA-F]+', Number.Hex),
	(r'[0-9]+', Number.Integer),
	(r'"(\\\\\|\\[^\\]\|[^"\\])*"', String.Double),
	(r"'(\\\\\|\\[^\\]\|[^'\\])*'", String.Single),
	]
	}


	class PsyshConsoleLexer(Lexer):
	"""
	For PsySH console output, such as:

	.. sourcecode:: psysh

	>>> $greeting = function($name): string {
	... return "Hello, {$name}";
	... };
	=> Closure($name): string {#2371 …3}
	>>> $greeting('World')
	=> "Hello, World"
	"""
	name = 'PsySH console session for PHP'
	url = 'https://psysh.org/'
	aliases = ['psysh']
	version_added = '2.7'

	def __init__(self, **options):
	options['startinline'] = True
	Lexer.__init__(self, **options)

	def get_tokens_unprocessed(self, text):
	phplexer = PhpLexer(**self.options)
	curcode = ''
	insertions = []
	for match in line_re.finditer(text):
	line = match.group()
	if line.startswith('>>> ') or line.startswith('... '):
	insertions.append((len(curcode),
	[(0, Generic.Prompt, line[:4])]))
	curcode += line[4:]
	elif line.rstrip() == '...':
	insertions.append((len(curcode),
	[(0, Generic.Prompt, '...')]))
	curcode += line[3:]
	else:
	if curcode:
	yield from do_insertions(
	insertions, phplexer.get_tokens_unprocessed(curcode))
	curcode = ''
	insertions = []
	yield match.start(), Generic.Output, line
	if curcode:
	yield from do_insertions(insertions,
	phplexer.get_tokens_unprocessed(curcode))


	class PhpLexer(RegexLexer):
	"""
	For PHP source code.
	For PHP embedded in HTML, use the `HtmlPhpLexer`.

	Additional options accepted:

	`startinline`
	If given and ``True`` the lexer starts highlighting with
	php code (i.e.: no starting ``<?php`` required). The default
	is ``False``.
	`funcnamehighlighting`
	If given and ``True``, highlight builtin function names
	(default: ``True``).
	`disabledmodules`
	If given, must be a list of module names whose function names
	should not be highlighted. By default all modules are highlighted
	except the special ``'unknown'`` module that includes functions
	that are known to php but are undocumented.

	To get a list of allowed modules have a look into the
	`_php_builtins` module:

	.. sourcecode:: pycon

	>>> from pygments.lexers._php_builtins import MODULES
	>>> MODULES.keys()
	['PHP Options/Info', 'Zip', 'dba', ...]

	In fact the names of those modules match the module names from
	the php documentation.
	"""

	name = 'PHP'
	url = 'https://www.php.net/'
	aliases = ['php', 'php3', 'php4', 'php5']
	filenames = ['.php', '.php[345]', '*.inc']
	mimetypes = ['text/x-php']
	version_added = ''

	# Note that a backslash is included, PHP uses a backslash as a namespace
	# separator.
	_ident_inner = r'(?:[\\_a-z]\|[^\x00-\x7f])(?:[\\\w]\|[^\x00-\x7f])*'
	# But not inside strings.
	_ident_nons = r'(?:[_a-z]\|[^\x00-\x7f])(?:\w\|[^\x00-\x7f])*'

	flags = re.IGNORECASE \| re.DOTALL \| re.MULTILINE
	tokens = {
	'root': [
	(r'<\?(php)?', Comment.Preproc, 'php'),
	(r'[^<]+', Other),
	(r'<', Other)
	],
	'php': [
	(r'\?>', Comment.Preproc, '#pop'),
	(r'(<<<)([\'"]?)(' + _ident_nons + r')(\2\n.?\n\s)(\3)(;?)(\n)',
	bygroups(String, String, String.Delimiter, String, String.Delimiter,
	Punctuation, Text)),
	(r'\s+', Text),
	(r'#\[', Punctuation, 'attribute'),
	(r'#.*?\n', Comment.Single),
	(r'//.*?\n', Comment.Single),
	# put the empty comment here, it is otherwise seen as
	# the start of a docstring
	(r'/\\/', Comment.Multiline),
	(r'/\\.?\/', String.Doc),
	(r'/\.?\*/', Comment.Multiline),
	(r'(->\|::)(\s*)(' + _ident_nons + ')',
	bygroups(Operator, Text, Name.Attribute)),
	(r'[~!%^&*+=\|:.<>/@-]+', Operator),
	(r'\?', Operator), # don't add to the charclass above!
	(r'[\[\]{}();,]+', Punctuation),
	(r'(new)(\s+)(class)\b', bygroups(Keyword, Text, Keyword)),
	(r'(class)(\s+)', bygroups(Keyword, Text), 'classname'),
	(r'(function)(\s*)(?=\()', bygroups(Keyword, Text)),
	(r'(function)(\s+)(&?)(\s*)',
	bygroups(Keyword, Text, Operator, Text), 'functionname'),
	(r'(const)(\s+)(' + _ident_inner + ')',
	bygroups(Keyword, Text, Name.Constant)),
	(r'(and\|E_PARSE\|old_function\|E_ERROR\|or\|as\|E_WARNING\|parent\|'
	r'eval\|PHP_OS\|break\|exit\|case\|extends\|PHP_VERSION\|cfunction\|'
	r'FALSE\|print\|for\|require\|continue\|foreach\|require_once\|'
	r'declare\|return\|default\|static\|do\|switch\|die\|stdClass\|'
	r'echo\|else\|TRUE\|elseif\|var\|empty\|if\|xor\|enddeclare\|include\|'
	r'virtual\|endfor\|include_once\|while\|endforeach\|global\|'
	r'endif\|list\|endswitch\|new\|endwhile\|not\|'
	r'array\|E_ALL\|NULL\|final\|php_user_filter\|interface\|'
	r'implements\|public\|private\|protected\|abstract\|clone\|try\|'
	r'catch\|throw\|this\|use\|namespace\|trait\|yield\|'
	r'finally\|match)\b', Keyword),
	(r'(true\|false\|null)\b', Keyword.Constant),
	include('magicconstants'),
	(r'\$\{', Name.Variable, 'variablevariable'),
	(r'\$+' + _ident_inner, Name.Variable),
	(_ident_inner, Name.Other),
	(r'(\d+\.\d\|\d\.\d+)(e[+-]?[0-9]+)?', Number.Float),
	(r'\d+e[+-]?[0-9]+', Number.Float),
	(r'0[0-7]+', Number.Oct),
	(r'0x[a-f0-9]+', Number.Hex),
	(r'\d+', Number.Integer),
	(r'0b[01]+', Number.Bin),
	(r"'([^'\\](?:\\.[^'\\])*)'", String.Single),
	(r'`([^`\\](?:\\.[^`\\])*)`', String.Backtick),
	(r'"', String.Double, 'string'),
	],
	'variablevariable': [
	(r'\}', Name.Variable, '#pop'),
	include('php')
	],
	'magicfuncs': [
	# source: http://php.net/manual/en/language.oop5.magic.php
	(words((
	'__construct', '__destruct', '__call', '__callStatic', '__get', '__set',
	'__isset', '__unset', '__sleep', '__wakeup', '__toString', '__invoke',
	'__set_state', '__clone', '__debugInfo',), suffix=r'\b'),
	Name.Function.Magic),
	],
	'magicconstants': [
	# source: http://php.net/manual/en/language.constants.predefined.php
	(words((
	'__LINE__', '__FILE__', '__DIR__', '__FUNCTION__', '__CLASS__',
	'__TRAIT__', '__METHOD__', '__NAMESPACE__',),
	suffix=r'\b'),
	Name.Constant),
	],
	'classname': [
	(_ident_inner, Name.Class, '#pop')
	],
	'functionname': [
	include('magicfuncs'),
	(_ident_inner, Name.Function, '#pop'),
	default('#pop')
	],
	'string': [
	(r'"', String.Double, '#pop'),
	(r'[^{$"\\]+', String.Double),
	(r'\\([nrt"$\\]\|[0-7]{1,3}\|x[0-9a-f]{1,2})', String.Escape),
	(r'\$' + _ident_nons + r'(\[\S+?\]\|->' + _ident_nons + ')?',
	String.Interpol),
	(r'(\{\$\{)(.*?)(\}\})',
	bygroups(String.Interpol, using(this, _startinline=True),
	String.Interpol)),
	(r'(\{)(\$.*?)(\})',
	bygroups(String.Interpol, using(this, _startinline=True),
	String.Interpol)),
	(r'(\$\{)(\S+)(\})',
	bygroups(String.Interpol, Name.Variable, String.Interpol)),
	(r'[${\\]', String.Double)
	],
	'attribute': [
	(r'\]', Punctuation, '#pop'),
	(r'\(', Punctuation, 'attributeparams'),
	(_ident_inner, Name.Decorator),
	include('php')
	],
	'attributeparams': [
	(r'\)', Punctuation, '#pop'),
	include('php')
	],
	}

	def __init__(self, **options):
	self.funcnamehighlighting = get_bool_opt(
	options, 'funcnamehighlighting', True)
	self.disabledmodules = get_list_opt(
	options, 'disabledmodules', ['unknown'])
	self.startinline = get_bool_opt(options, 'startinline', False)

	# private option argument for the lexer itself
	if '_startinline' in options:
	self.startinline = options.pop('_startinline')

	# collect activated functions in a set
	self._functions = set()
	if self.funcnamehighlighting:
	from pygments.lexers._php_builtins import MODULES
	for key, value in MODULES.items():
	if key not in self.disabledmodules:
	self._functions.update(value)
	RegexLexer.__init__(self, **options)

	def get_tokens_unprocessed(self, text):
	stack = ['root']
	if self.startinline:
	stack.append('php')
	for index, token, value in \
	RegexLexer.get_tokens_unprocessed(self, text, stack):
	if token is Name.Other:
	if value in self._functions:
	yield index, Name.Builtin, value
	continue
	yield index, token, value

	def analyse_text(text):
	if shebang_matches(text, r'php'):
	return True
	rv = 0.0
	if re.search(r'<\?(?!xml)', text):
	rv += 0.3
	return rv