U

G�
\-l�@s"
dZd
dl
Z
d
dlmZmZmZmZmZmZm	Z	m
Z

d
dlmZm
Z
mZmZmZmZmZmZmZmZ
d
dlmZmZ
d
dlmZ
d
dlmZ
dd	d
ddd
dgZGdd�de�ZGdd	�d	e�Z Gdd
�d
e�Z!Gdd�de�Z"Gdd�de�Z#Gdd�de�Z$Gdd
�d
e�Z%Gdd�de�Z&dS)z�
    pygments.lexers.dotnet
    ~~~~~~~~~~~~~~~~~~~~~~

    Lexers for .net languages.

    :copyright: Copyright 2006-2017 by the Pygments team, see AUTHORS.
    :license: BSD, see LICENSE for details.
�N)�
RegexLexer�DelegatingLexer�bygroups�include�using�this�default�words)
�Punctuation�Text�Comment�Operator�Keyword�Name�String�Number�Literal�Other)�get_choice_opt�	iteritems)
�	unistring)
�XmlLexer�CSharpLexer�NemerleLexer�BooLexer�
VbNetLexer�CSharpAspxLexer�VbNetAspxLexer�FSharpLexerc@s�
eZ
dZd
ZdZddgZdg
Zdg
Zej	ej
BejBZdde
�d	d
ddd
�dde
�d	d
ddd
ddddd�
dde
�d	d
dddd
�dde
�d	d
dddd
ddddd�dd�ZiZdZee�
D�
]
\ZZdededeee�
ejee�fdejfd efd!efd"ejfd#ej fd$efd%efd&efd'e!fd(e!fd)e!j"fd*e#fd+ej$fd,ee%ee%�fd-e%fd.ee%e�fd/e%j&fd0ee%e�d1fd2ee%e�d3feefgeej'd4fe(d4�
gd5ed4fd6ed7ej)d4fgd8�ee<q�d9d:�Z*d;S)<ra�
    For `C# <http://msdn2.microsoft.com/en-us/vcsharp/default.aspx>`_
    source code.

    Additional options accepted:

    `unicodelevel`
      Determines which Unicode characters this lexer allows for identifiers.
      The possible values are:

      * ``none`` -- only the ASCII letters and numbers are allowed. This
        is the fastest selection.
      * ``basic`` -- all Unicode characters from the specification except
        category ``Lo`` are allowed.
      * ``full`` -- all Unicode characters as specified in the C# specs
        are allowed.  Note that this means a considerable slowdown since the
        ``Lo`` category has more than 40,000 characters in it!

      The default value is ``basic``.

      .. versionadded:: 0.8
    zC#Zcsharpzc#z*.csz
text/x-csharp�@?[_a-zA-Z]\w*�@?[_�Lu�Ll�Lt�Lm�Nl�
]�
[�Nd�Pc�Cf�Mn�Mc�]*�	@?(?:_|[^�Lo�])�[^�Znone�basicZfullT�^([ \t]*(?:�(?:\[\])?\s+)+?)(�
)(\s*)(\()�^\s*\[.*?\]�[^\S\n]+�\\\n�//.*?\n�/[*].*?[*]/�\n�[~!%^&*()+=|\[\]:;,.<>/?-]�[{}]�
@"(""|[^"])*"�"(\\\\|\\"|[^"\n])*["\n]�
'\\.'|'[^\\]'zA[0-9](\.[0-9]*)?([eE][+-][0-9]+)?[flFLdD]?|0[xX][0-9a-fA-F]+[Ll]?�Z#[ \t]*(if|endif|else|elif|define|undef|line|error|warning|region|endregion|pragma)\b.*?\n�\b(extern)(\s+)(alias)\ba(abstract|as|async|await|base|break|by|case|catch|checked|const|continue|default|delegate|do|else|enum|event|explicit|extern|false|finally|fixed|for|foreach|goto|if|implicit|in|interface|internal|is|let|lock|new|null|on|operator|out|override|params|private|protected|public|readonly|ref|return|sealed|sizeof|stackalloc|static|switch|this|throw|true|try|typeof|unchecked|unsafe|virtual|void|while|get|set|new|partial|yield|add|remove|value|alias|ascending|descending|from|group|into|orderby|select|thenby|where|join|equals)\b�(global)(::)zk(bool|byte|char|decimal|double|dynamic|float|int|long|object|sbyte|short|string|uint|ulong|ushort|var)\b\??z(class|struct)(\s+)�class�(namespace|using)(\s+)�	namespace�#pop�(?=\()�
(�|\.)+)�rootrErGc
KsLt|
d
t
|j�
d�}||jkr.|j�|�
|_n|j||_tj|f
|
�

dS�NZunicodelevelr3�	r�list�tokensZ_all_tokens�	__class__Zprocess_tokendefZ_tokensr�__init__��self�options�level�rW�8/usr/lib/python3/dist-packages/pygments/lexers/dotnet.pyrR�s



zCSharpLexer.__init__N)+�__name__�
__module__�__qualname__�__doc__�name�aliases�	filenames�	mimetypes�re�	MULTILINE�DOTALL�UNICODE�flags�uni�combine�	allexcept�levelsrP�token_variantsr�	levelname�cs_identrrrr�Functionrr
�	Attributer�Single�	Multiliner�Charr�Preprocr�Type�Classr�	NamespacerRrWrWrWrXrs�





�

���
�
��
����


�
��











��
��

�

�,

�
��6c!@s�eZ
dZd
ZdZdg
Zdg
Zdg
Zej	ej
BejBZdde
�dd	d
dd�d
de
�dd	d
ddddddd�
dde
�dd	d
ddd�dde
�dd	d
dddddddd�dd�ZiZdZee�
D�]\ZZdededeee�
ejee�fdejfdefd efd!ejfd"ej fd#efd$e!d%fd&e!d'fd(e!d)fd*ed+e"fd,e"fd-eefd.eee�d/fd0efd1efd2e!fd3e!fd4e!j#fd5e$fd6e$fd7ej%fd8ee"ee"�fd9e"fd:ee"e�fd;e"j&fd<ed=eee"j&�fd>ee"e�d?fd@ee"e�dAfeefgeej'dBfg
dCedBfdDedEej(dBfgdFe!fd-eefd.eee�d/fdGe!fdHe!dBfgdIe!fd-eefd.eee�d/fd(e!dJfdKe!dBfgdLe!fd(e!dJfdKe!dBfgdMe"fdNefeefdOe$fdPedJfdQedBfgdR�ee<q�dSdT�Z)dUS)Vra�
    For `Nemerle <http://nemerle.org>`_ source code.

    Additional options accepted:

    `unicodelevel`
      Determines which Unicode characters this lexer allows for identifiers.
      The possible values are:

      * ``none`` -- only the ASCII letters and numbers are allowed. This
        is the fastest selection.
      * ``basic`` -- all Unicode characters from the specification except
        category ``Lo`` are allowed.
      * ``full`` -- all Unicode characters as specified in the C# specs
        are allowed.  Note that this means a considerable slowdown since the
        ``Lo`` category has more than 40,000 characters in it!

      The default value is ``basic``.

    .. versionadded:: 1.5
    ZNemerleZnemerlez*.nztext/x-nemerlerr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2Tr4r5r6r7r8r9r:r;r<z\$\s*"�
splice-stringz\$\s*<#�splice-string2z<#�recursive-stringz	(<\[)\s*(z:)?z\]\>z\$z(\$)(\()�splice-string-contentr=r>r?r@rAz0[xX][0-9a-fA-F]+[Ll]?z*[0-9](\.[0-9]*)?([eE][+-][0-9]+)?[flFLdD]?rBrCa�
(abstract|and|as|base|catch|def|delegate|enum|event|extern|false|finally|fun|implements|interface|internal|is|macro|match|matches|module|mutable|new|null|out|override|params|partial|private|protected|public|ref|sealed|static|syntax|this|throw|true|try|type|typeof|virtual|volatile|when|where|with|assert|assert2|async|break|checked|continue|do|else|ensures|for|foreach|if|late|lock|new|nolate|otherwise|regexp|repeat|requires|return|surroundwith|unchecked|unless|using|while|yield)\brDzo(bool|byte|char|decimal|double|float|int|long|object|sbyte|short|string|uint|ulong|ushort|void|array|list)\b\??z	(:>?)\s*(z\??)z"(class|struct|variant|module)(\s+)rErFrGrHrIrJrKz[^"$]z\\"�
"z[^#<>$]�#pushz#>z[^#<>]zif|matchz[~!%^&*+=|\[\]:;,.<>/?-\\"$ ]�\d+�\(�\))rLrErGrvrwrxryc
KsLt|
d
t
|j�
d�}||jkr.|j�|�
|_n|j||_tj|f
|
�

dSrMrNrSrWrWrXrR
s

�
zNemerleLexer.__init__N)*rYrZr[r\r]r^r_r`rarbrcrdrerfrgrhrirPrjrrkrlrrrrrmrr
rnrrorprrrqrrrrsrtrurRrWrWrWrXr�s�





�

���
�
��
����


�
��












�






�
��
�


�
�

��=
�
�




�
�	




�
�	

�




��cc@sL
eZ
dZd
ZdZdg
Zdg
Zdg
Zdefde	j
fde	jd	fd
efdefdefd
e
jfdejfdejfde
fdefdefdeee�dfdeee�dfdeee�dfdejfdejfdejfdej
fdefdejfdefd ejfd!ejfd"ejjfd#ejfgde	jd$fd%e	jd&fd'e	jfd(e	jfgdejd&fg
dejd&fg
d)ejd&fg
d*�Zd+S),rz<
    For `Boo <http://boo.codehaus.org/>`_ source code.
    ZBooZbooz*.booz
text/x-boo�\s+z	(#|//).*$z/[*]�commentz[]{}:(),.;[]r9z\\z(in|is|and|or|not)\bz/(\\\\|\\/|[^/\s])/z@/(\\\\|\\/|[^/])*/z=~|!=|==|<<|>>|[-+/*%=<>&^|]aO
(as|abstract|callable|constructor|destructor|do|import|enum|event|final|get|interface|internal|of|override|partial|private|protected|public|return|set|static|struct|transient|virtual|yield|super|and|break|cast|continue|elif|else|ensure|except|for|given|goto|if|in|is|isa|not|or|otherwise|pass|raise|ref|try|unless|when|while|from|as)\bzdef(?=\s+\(.*?\))z
(def)(\s+)�funcnamez(class)(\s+)�	classnamez(namespace)(\s+)rGz�(?<!\.)(true|false|null|self|__eval__|__switch__|array|assert|checked|enumerate|filter|getter|len|lock|map|matrix|max|min|normalArrayIndexing|print|property|range|rawArrayIndexing|required|typeof|unchecked|using|yieldAll|zip)\bz"""(\\\\|\\"|.*?)"""z"(\\\\|\\"|[^"]*?)"z'(\\\\|\\'|[^']*?)'z[a-zA-Z_]\w*z%(\d+\.\d*|\d*\.\d+)([fF][+-]?[0-9]+)?z[0-9][0-9.]*(ms?|d|h|s)z0\d+z0x[a-fA-F0-9]+z\d+Lr|r{z[*]/rHz[^/*]z[*/]z[a-zA-Z_][\w.]*)rLr�r�r�rGN) rYrZr[r\r]r^r_r`rrrorpr
r
�WordrZRegexrrr�Builtin�Doubler�Float�Oct�Hex�IntegerZLongrmrtrurPrWrWrWrXr+
s`














�



�









�'




�
�
�
��c@s�
eZ
dZd
ZdZddgZddgZddgZd	e�	d
ddd
�dde�	d
ddd
ddddd�	dZ
ejej
BZdejfdefdefdefdefdejfdefdejfeddd d!�efd"ed#fd$ed%fd&eee�d'fd(eee�d)fd*eee�d+fd,ejfd-ejfd.efd/ed0fd1efe
d2efd3ejfd4ej fd5ej!fd6ej!fd7ej!fgd8efd9ed:fd;efge
ej"d:fe#d:�
ge
ej$d:fg
e
ej%d:fg
e
ej&fd<ej&fe#d:�
gdefd=ed:fe#d:�
gd>�Z'd?d@�Z(dAS)Brzm
    For
    `Visual Basic.NET <http://msdn2.microsoft.com/en-us/vbasic/default.aspx>`_
    source code.
    zVB.netzvb.netZvbnetz*.vbz*.basztext/x-vbnetz
text/x-vbaz[_r"r#r$r%r&r'r(r)r*r+r,r-z	^\s*<.*?>rr<z
rem\b.*?\nz'.*?\nz�#If\s.*?\sThen|#ElseIf\s.*?\sThen|#Else|#End\s+If|#Const|#ExternalSource.*?\n|#End\s+ExternalSource|#Region.*?\n|#End\s+Region|#ExternalChecksumz[(){}!#,.:]z9Option\s+(Strict|Explicit|Compare)\s+(On|Off|Binary|Text))lZ
AddHandlerZAliasZByRefZByValZCallZCaseZCatchZCBoolZCByteZCCharZCDateZCDecZCDblZCIntZCLngZCObjZContinueZCSByteZCShortZCSngZCStrZCTypeZCUIntZCULngZCUShortZDeclareZDefaultZDelegateZ
DirectCastZDoZEachZElseZElseIfZEndIfZErase�ErrorZEventZExit�FalseZFinallyZForZFriendZGetZGlobalZGoSubZGoToZHandlesZIfZ
ImplementsZInheritsZ	InterfaceZLetZLibZLoopZMeZMustInheritZMustOverrideZMyBaseZMyClassZ	NarrowingZNewZNextZNotZNothingZNotInheritableZNotOverridableZOfZOnr
ZOptionZOptionalZ	OverloadsZOverridableZ	OverridesZ
ParamArrayZPartialZPrivateZ	ProtectedZPublicZ
RaiseEventZReadOnlyZReDimZ
RemoveHandlerZResumeZReturnZSelect�SetZShadowsZSharedroZStaticZStepZStopZSyncLockZThenZThrowZTo�TrueZTryZTryCastZWendZUsingZWhenZWhileZWideningZWithZ
WithEventsZ	WriteOnlyz(?<!\.)z\b)�prefix�suffixz(?<!\.)End\b�endz(?<!\.)(Dim|Const)\b�dimz#(?<!\.)(Function|Sub|Property)(\s+)r�z"(?<!\.)(Class|Structure|Enum)(\s+)r�z&(?<!\.)(Module|Namespace|Imports)(\s+)rGz|(?<!\.)(Boolean|Byte|Char|Date|Decimal|Double|Integer|Long|Object|SByte|Short|Single|String|Variant|UInteger|ULong|UShort)\bzU(?<!\.)(AddressOf|And|AndAlso|As|GetType|In|Is|IsNot|Like|Mod|Or|OrElse|TypeOf|Xor)\bzE&=|[*]=|/=|\\=|\^=|\+=|-=|<<=|>>=|<<|>>|:=|<=|>=|<>|[-&*/\\^+=<>\[\]]rz�stringz_\nz	[%&@!#$]?z#.*?#z"(\d+\.\d*|\d*\.\d+)(F[+-]?[0-9]+)?z\d+([SILDFR]|US|UI|UL)?z&H[0-9a-f]+([SILDFR]|US|UI|UL)?z&O[0-7]+([SILDFR]|US|UI|UL)?�""z"C?rH�[^"]+�\.z?(Function|Sub|Property|Class|Structure|Enum|Module|Namespace)\b)rLr�r�r�r�rGr�c

Cst�
d
|tj�rdSdS)Nz^\s*(#If|Module|Namespace)g�?)ra�searchrb�
�textrWrWrX�analyse_text�
s

zVbNetLexer.analyse_textN))rYrZr[r\r]r^r_r`rfrgZuni_namerarb�
IGNORECASErerrnrrrrr
rZDeclarationr	rrsr
r�rrZDaterr�r��VariablerrmrtrurPr�rWrWrWrXrn
s�




�

���




�

���


�
�
��
��







�;

�

�
�
�

�

���Wc@sfeZ
dZd
ZdZgZgZejZ	dde
eje
ej�fde
ee�
e
ee�
�fdee�
fdee�
fgi
ZdS)	�GenericAspxLexerz"
    Lexer for ASP.NET pages.
    zaspx-genrLz(<%[@=#]?)(.*?)(%>)z(<script.*?>)(.*?)(</script>)z
(.+?)(?=<)z.+N)rYrZr[r\r]r_r`rarcrerrZTagrrrrPrWrWrWrXr��
s







�


��r�csFeZ
dZd
ZdZdg
ZddddddgZgZ�f
d	d
�Zdd�Z	�Z
S)
rz9
    Lexer for highlighting C# within ASP.NET pages.
    zaspx-cs�*.aspx�*.asax�*.ascx�*.ashx�*.asmx�*.axdc
stt
|�jttf|
�

dS�
N)�superrrRrr��rTrU�
rQrWrXrR�
s

�zCSharpAspxLexer.__init__c

Cs4t�
d
|tj�dk	rdSt�
d|tj�dk	r0dSdS)NzPage\s*Language="C#"皙�����?zscript[^>]+language=["\']C#�333333�?�rar��
Ir�rWrWrXr�
s



zCSharpAspxLexer.analyse_text�rYrZr[r\r]r^r_r`rRr��
__classcell__rWrWr�rXr�
s



csFeZ
dZd
ZdZdg
ZddddddgZgZ�f
d	d
�Zdd�Z	�Z
S)
rzG
    Lexer for highlighting Visual Basic.net within ASP.NET pages.
    zaspx-vbr�r�r�r�r�r�c
stt
|�jttf|
�

dSr�)r�rrRrr�r�r�rWrXrRs

�zVbNetAspxLexer.__init__c

Cs4t�
d
|tj�dk	rdSt�
d|tj�dk	r0dSdS)NzPage\s*Language="Vb"r�zscript[^>]+language=["\']vbr�r�r�rWrWrXr�s



zVbNetAspxLexer.analyse_textr�rWrWr�rXrs



cB@s�eZ
dZd
ZdZdg
ZddgZdg
Zddd	d
ddd
ddddddddddddddddddd d!d"d#d$d%d&d'd(d)d*d+d,d-d.d/d0d1d2d3d4d5d6d7d8d9d:d;d<d=d>d?d@dAdBdCdDdEdFdGdHgBZedIdJdKdLdMdNdOdPdQdRdSdTdUdVdWdXdYdZd[d\d]d^d_d`dadbg7Zdcdddedfdgdhdidjdkdldmdndodpdqdrdsdtdudvdwdxdydzd{d|d}d~dd�d�d�d�d�d�d�d�d�d�d�d�d�d�g+Z	d�Z
d�d�d�gZd�Zd�Z
d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�gZd�ejfd�ejfd�ejfd�ejfgd�efd�ejjfd�ejd�fd�efd�ejfd�ejfd�ed�fd�ed�fd�ed�fd�ed�fd�eeeej�fd�eeeej�fd�eeeej�fd�eeeeeej�fd�dĠe�
efd�efd�dĠe	�
e fd�e
ee
fe fd�dĠe�
e j!fd�dĠe�
ej"fd�ej#fd�efd�e$j%fd�e$j&fd�e$j'fd�e$j(fd�e$j)fd�ej*fd�ej*fd�efd�ej+d�fd�ejfg d�efdpefd�ejfd�ed�fd�ed�fe,dփ
gd�efd�ed�fd�ed�fd�ed�fd�ed�fd�ed�fd�efgd�efe-dރ
d�efd�efd�ed�fgd�efd�efd�efd�ed�fgd�efd�efd�ed�fd�efgd�Z.d�S)�rz�
    For the F# language (version 3.0).

    AAAAACK Strings
    http://research.microsoft.com/en-us/um/cambridge/projects/fsharp/manual/spec.html#_Toc335818775

    .. versionadded:: 1.5
    ZFSharpZfsharpz*.fsz*.fsiz
text/x-fsharpZabstract�as�assert�baseZbeginrErZdelegatezdo!ZdoZdoneZdowncastZdownto�elif�elser�Z	exceptionZexternZfalse�finally�forZfunctionZfun�global�ifZinheritZinlineZ	interfaceZinternal�inZlazyzlet!Zlet�match�member�moduleZmutablerG�newZnullZof�open�overrideZprivateZpublicZreczreturn!�returnZselectZstaticZstructZthen�to�true�try�typeZupcastzuse!Zuse�valZvoidZwhen�while�withzyield!�yieldZatomic�break�checkedZ	componentZconstZ
constraint�constructor�continueZeagerZeventZexternalZfixedZfunctorr�methodZmixin�objectZparallelZprocessZ	protectedZpureZsealedZtailcallZtraitZvirtualZvolatilez!=�
#z&&�
&r}r~z\*z\+�
,z-\.z->�
-z\.\.r�z::z:=z:>�
:z;;�
;z<-z<\]�
<z>\]�
>z\?\?z\?z\[<z\[\|z\[z\]�
_�
`z\{z\|\]z\|z\}�
~z<@@z<@�
=z@>z@@>z[!$%&*+\./:<=>?@^|~-]�and�or�notz[!?~]z[=<>@^|&+\*/$%-]ZsbyteZbyte�charZ	nativeintZ
unativeintZfloat32Zsingle�floatZdoubleZint8Zuint8Zint16Zuint16Zint32Zuint32Zint64Zuint64ZdecimalZunit�boolr�rOZexn�obj�enumz\\[\\"\'ntbrafv]z
\\[0-9]{3}z\\u[0-9a-fA-F]{4}z\\U[0-9a-fA-F]{8}rz	\(\)|\[\]z \b(?<!\.)([A-Z][\w\']*)(?=\s*\.)�dottedz\b([A-Z][\w\']*)z///.*?\nr:z
\(\*(?!\))r�z@"�lstringz"""�tqsrzz\b(open|module)(\s+)([\w.]+)z\b(let!?)(\s+)(\w+)z\b(type)(\s+)(\w+)z&\b(member|override)(\s+)(\w+)(\.)(\w+)z\b(%s)\b�
|z``([^`\n\r\t]|`[^`\n\r\t])+``z(%s)z
(%s|%s)?%sz3#[ \t]*(if|endif|else|line|nowarn|light|\d+)\b.*?\nz
[^\W\d][\w']*z\d[\d_]*[uU]?[yslLnQRZINGmM]?z-0[xX][\da-fA-F][\da-fA-F_]*[uU]?[yslLn]?[fF]?z0[oO][0-7][0-7_]*[uU]?[yslLn]?z0[bB][01][01_]*[uU]?[yslLn]?z/-?\d[\d_]*(.[\d_]*)?([eE][+\-]?\d[\d_]*)[fFmM]?z9'(?:(\\[\\\"'ntbr ])|(\\[0-9]{3})|(\\x[0-9a-fA-F]{2}))'B?z'.'�
'z@?"z[~?][a-z][\w\']*:z[A-Z][\w\']*(?=\s*\.)z[A-Z][\w\']*rHz
[a-z_][\w\']*z	[^(*)@"]+z\(\*r{z\*\)z[(*)@]z[^\\"]+�escape-sequencer9r<z"B?r�r�z"""B?)r�rLr�r�r�r�r�N)/rYrZr[r\r]r^r_r`�keywordsZkeyoptsZ	operatorsZword_operatorsZprefix_symsZ
infix_symsZ
primitivesrZEscaperrr�ZPseudoruZDocrrorrr�rtr
rm�joinr
r�rsrrrr�r�r�ZBinr�rqr�rrrPrWrWrWrXrs

	










�




�


�






�


�



�





�
�
�
�






�




�
�

�2



�





�



�


�


��)'r\raZpygments.lexerrrrrrrrr	Zpygments.tokenr
rrr
rrrrrrZ
pygments.utilrrZpygmentsrrfZpygments.lexers.htmlr�__all__rrrrr�rrrrWrWrWrX�<module>s(	(0

�r Cm