| Server IP : 127.0.0.1 / Your IP : 216.73.216.109 Web Server : Apache/2.4.54 (Win64) OpenSSL/1.1.1q PHP/8.1.10 System : Windows NT DESKTOP-E5T4RUN 10.0 build 19045 (Windows 10) AMD64 User : SERVERWEB ( 0) PHP Version : 8.1.10 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : OFF | Perl : OFF | Python : OFF | Sudo : OFF | Pkexec : OFF Directory : C:/cygwin64/lib/python3.9/site-packages/pygments/lexers/__pycache__/ |
Upload File : |
a
SҼa8m � @ s d Z ddlZddlmZmZmZmZmZmZm Z m
Z
ddl m Z m
Z
mZmZmZmZmZmZmZmZ ddlmZ ddlmZ ddlm Z g d�Z G d d
� d
e�Z G d d � d e�Z G d
d� de�Z G dd� de�Z!G dd� de�Z"G dd� de�Z#G dd� de�Z$G dd� de�Z%dS )z�
pygments.lexers.dotnet
~~~~~~~~~~~~~~~~~~~~~~
Lexers for .net languages.
:copyright: Copyright 2006-2021 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)� unistring)�XmlLexer)� CSharpLexer� NemerleLexer�BooLexer�
VbNetLexer�CSharpAspxLexer�VbNetAspxLexer� FSharpLexerc @ s� e Zd ZdZdZddgZdgZdgZej ej
B ej B Z dde
�d d
d d d
� d d e
�d d
d d d
ddddd�
d de
�d d
d d dd
� d d e
�d d
d d dd
ddddd� d d�Zi ZdZe�� D �]
\ZZd e d e d eee�ejee �fd ej fd efd!efd"e j fd#e j fd$efd%e fd&e fd'e!fd(e!fd)e!j"fd*e#fd+e j$fd,ee%ee%�fd-e%fd.ee%e �fd/e%j&fd0ee%e�d1fd2ee%e�d3feefgeej'd4fe(d4�gd5ed4fd6e d7 ej)d4fgd8�ee< q�d9d:� Z*d;S )<r a�
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�[~!%^&*()+=|\[\]:;,.<>/?-]�[{}]�
@"(""|[^"])*"z!\$?"(\\\\|\\[^\\]|[^"\\\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�(?=\()�(�|\.)+)�rootrC rE c K sP t |dt| j�d�}|| jvr.| j�|�| _n | j| | _tj| fi |�� d S �NZ unicodelevelr2 � r �list�tokensZ _all_tokens� __class__Zprocess_tokendefZ_tokensr �__init__��self�options�level� rU �:/usr/lib/python3.9/site-packages/pygments/lexers/dotnet.pyrP � s
zCSharpLexer.__init__N)+�__name__�
__module__� __qualname__�__doc__�name�aliases� filenames� mimetypes�re� MULTILINE�DOTALL�UNICODE�flags�uni�combine� allexcept�levelsrN �token_variants�items� levelname�cs_identr r r r �Functionr r
� Attributer �Single� Multiliner �Charr �Preprocr �Type�Classr � NamespacerP rU rU rU rV r s� �������
����
������ � ��,
��� 6r c ! @ s� e Zd ZdZdZdgZdgZdgZej ej
B ej B Z dde
�dd d
d d � d
d e
�dd d
d d ddddd�
d de
�dd d
d dd � d d e
�dd d
d dd ddddd� d d�Zi ZdZe�� D �]\ZZde d e d eee�ejee �fd ej fd efd efd!e j fd"e j fd#efd$e!d%fd&e!d'fd(e!d)fd*e d+ e"fd,e"fd-e efd.eee �d/fd0e fd1e fd2e!fd3e!fd4e!j#fd5e$fd6e$fd7e j%fd8ee"ee"�fd9e"fd:ee"e �fd;e"j&fd<e d= ee e"j&�fd>ee"e�d?fd@ee"e�dAfeefg eej'dBfgdCedBfdDe dE ej(dBfgdFe!fd-e efd.eee �d/fdGe!fdHe!dBfgdIe!fd-e efd.eee �d/fd(e!dJfdKe!dBfgdLe!fd(e!dJfdKe!dBfgdMe"fdNe feefdOe$fdPe dJfdQe dBfgdR�ee< q�dSdT� Z)dUdV� Z*dWS )Xr a�
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-nemerler r r r! r" r# r$ r% r& r' r( r) r* r+ r, r- r. r/ r0 r1 Tr3 r4 r5 r6 r7 r8 r9 r: r; z\$\s*"�
splice-stringz\$\s*<#�splice-string2z<#�recursive-stringz (<\[)\s*(z:)?z\]\>z\$z(\$)(\()�splice-string-contentr< r= r> z "(\\\\|\\[^\\]|[^"\\\n])*["\n]r? z0[xX][0-9a-fA-F]+[Ll]?z*[0-9](\.[0-9]*)?([eE][+-][0-9]+)?[flFLdD]?r@ rA a� (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)\brB zo(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+)rC rD rE rF rG rH rI z[^"$]z\\"�"z[^#<>$]�#pushz#>z[^#<>]zif|matchz [~!%^&*+=|\[\]:;,.<>/?-\\"$ ]�\d+�\(�\))rJ rC rE ru rv rw rx c K sP t |dt| j�d�}|| jvr.| j�|�| _n | j| | _tj| fi |�� d S rK rL rQ rU rU rV rP s �
zNemerleLexer.__init__c C s d}d| v r|d7 }|S )zUNemerle is quite similar to Python, but @if is relatively uncommon
elsewhere.r z@ifg�������?rU ��text�resultrU rU rV � analyse_text) s zNemerleLexer.analyse_textN)+rW rX rY rZ r[ r\ r] r^ r_ r` ra rb rc rd re rf rg rN rh ri rj rk r r r r rl r r
rm r rn ro r r rp r rq rr rs rt rP r� rU rU rU rV r � s� �������
����
���
��� � �
�
�
��=
��
��
�� ��� c r c @ sL e Zd ZdZdZdgZdgZdgZdefde j
fde j d fd
e fd efd efd
e
jfdejfdejfde
fdefdefdeee�dfdeee�dfdeee�dfdejfdejfdejfd ej
fd efd ejfd efd ejfd!ejfd"ejjfd#ejfgde j d$fd%e j d&fd'e j fd(e j fgd ej d&fgd ej d&fgd)ej d&fgd*�Z d+S ),r z<
For `Boo <http://boo.codehaus.org/>`_ source code.
ZBooZbooz*.booz
text/x-boo�\s+z (#|//).*$z/[*]�commentz []{}:(),.;[]r8 z\\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+)rE z�(?<!\.)(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{ rz z[*]/rF z[^/*]z[*/]z[a-zA-Z_][\w.]*)rJ r� r� r� rE N) rW rX rY rZ r[ r\ r] r^ r r rn ro r
r
�Wordr ZRegexr r r �Builtin�Doubler �Float�Oct�Hex�IntegerZLongrl rs rt rN rU rU rU rV r 4 s`
��
�'
�
�
�
��r c @ s� e Zd ZdZdZddgZddgZddgZd e� d
d d d
� d d e� d
d d d
ddddd� d Z
e j e j
B Zdejfdefdefdefdefdejfd efd ejfed d d d!�efd"ed#fd$ed%fd&eee�d'fd(eee�d)fd*eee�d+fd,ejfd-ejfd.efd/e d0fd1efe
d2 efd3e j fd4e j fd5e j!fd6e j!fd7e j!fgd8e fd9e d:fd;e fge
ej"d:fe#d:�ge
ej$d:fge
ej%d:fge
ej&fd<ej&fe#d:�gdefd=ed:fe#d:�gd>�Z'd?d@� Z(dAS )Br zm
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*<.*?>r� r; 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�Error�EventZExit�FalseZFinallyZForZFriendZGetZGlobalZGoSubZGoToZHandlesZIfZ
ImplementsZInheritsZ InterfaceZLetZLibZLoopZMeZ MustInheritZ MustOverrideZMyBaseZMyClassZ NarrowingZNewZNextZNotZNothingZNotInheritableZNotOverridableZOfZOnr
ZOption�OptionalZ OverloadsZ OverridableZ OverridesZ
ParamArrayZPartialZPrivateZ ProtectedZPublicZ
RaiseEventZReadOnlyZReDimZ
RemoveHandlerZResumeZReturnZSelect�SetZShadowsZSharedrn ZStaticZStepZStopZSyncLockZThenZThrowZTo�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+)rE z|(?<!\.)(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&=|[*]=|/=|\\=|\^=|\+=|-=|<<=|>>=|<<|>>|:=|<=|>=|<>|[-&*/\\^+=<>\[\]]ry �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?rF �[^"]+�\.z?(Function|Sub|Property|Class|Structure|Enum|Module|Namespace)\b)rJ r� r� r� r� rE r� c C s t �d| t j�rdS d S )Nz^\s*(#If|Module|Namespace)g �?)r_ �searchr` �r rU rU rV r� � s zVbNetLexer.analyse_textN))rW rX rY rZ r[ r\ r] r^ rd re Zuni_namer_ r` �
IGNORECASErc r rm r r rq r
r Z Declarationr r rr r
r� r r ZDater r� r� �Variabler rl rs rt rN r� rU rU rU rV r w s� ���� ����
�
�
����
�;�
�
�
�����Wr c @ sf e Zd ZdZdZg Zg ZejZ dde
e j e
e j �fde
ee�e
ee��fdee�fdee�fgiZdS ) �GenericAspxLexerz"
Lexer for ASP.NET pages.
zaspx-genrJ z(<%[@=#]?)(.*?)(%>)z (<script.*?>)(.*?)(</script>)z
(.+?)(?=<)z.+N)rW rX rY rZ r[ r] r^ r_ ra rc r r ZTagr r r rN rU rU rU rV r� � s
�
��r� c s> e Zd ZdZdZdgZg d�Zg Z� fdd�Zdd� Z � Z
S )r z9
Lexer for highlighting C# within ASP.NET pages.
zaspx-cs�z*.aspxz*.asaxz*.ascxz*.ashxz*.asmxz*.axdc s t � jttfi |�� d S �N)�superrP r r� �rR rS �rO rU rV rP s zCSharpAspxLexer.__init__c C s4 t �d| t j�d urdS t �d| t j�d ur0dS d S )NzPage\s*Language="C#"皙�����?zscript[^>]+language=["\']C#�333333�?�r_ r� �Ir� rU rU rV r� s z CSharpAspxLexer.analyse_text� rW rX rY rZ r[ r\ r] r^ rP r� �
__classcell__rU rU r� rV r � s r c s> e Zd ZdZdZdgZg d�Zg Z� fdd�Zdd� Z � Z
S )r zG
Lexer for highlighting Visual Basic.net within ASP.NET pages.
zaspx-vbr� c s t � jttfi |�� d S r� )r� rP r r� r� r� rU rV rP s zVbNetAspxLexer.__init__c C s4 t �d| t j�d urdS t �d| t j�d ur0dS d S )NzPage\s*Language="Vb"r� zscript[^>]+language=["\']vbr� r� r� rU rU rV r� s zVbNetAspxLexer.analyse_textr� rU rU r� rV r s r c " @ s� e Zd ZdZdZddgZddgZdgZg d�Zeg d �7 Zg d
�Z d Z
g d �Z d
Z dZ
g d�Zdejfdejfdejfdejfgdefdejjfdejdfdefdejfdejfded fd ed fd ed fd!ed"fd#eeeej�fd$eeeej�fd%eeeej �fd&eeeee ej �fd'd(� e� efd)efd*d(� e � e fd+e
e e
f e fd'd(� e � e j!fd'd(� e� ej"fd,ej#fd-efd.e$j%fd/e$j&fd0e$j'fd1e$j(fd2e$j)fd3ej*fd4ej*fd5efd6ej+d"fd7ejfg defd8e fd9ejfd:ed;fd<ed;fe,d;�gd=efd>ed?fd@ed;fd ed fd ed fd!ed"fdAefgdBefe-dC�dDefdEefdFed;fgdGefdEefdHefdFed;fgdGefdEefdIed;fd!efgdJ�Z.dKdL� Z/dMS )Nr z`
For the `F# language <https://fsharp.org/>`_ (version 3.0).
.. versionadded:: 1.5
zF#Zfsharpzf#z*.fsz*.fsiz
text/x-fsharp)BZabstract�as�assert�baseZbeginrC r Zdelegatezdo!ZdoZdoneZdowncastZdownto�elif�elser� � exceptionZexternZfalse�finally�for�functionZfun�global�ifZinheritZinlineZ interfaceZinternal�inZlazyzlet!Zlet�match�member�moduleZmutablerE �newZnullZof�open�overrideZprivateZpublicZreczreturn!�returnZselectZstatic�structZthen�to�true�try�typeZupcastzuse!Zuse�valZvoidZwhen�while�withzyield!�yield)Zatomic�break�checkedZ component�constZ
constraint� constructor�continueZeagerZeventZexternal�fixedZfunctorr �methodZmixin�objectZparallelZprocessZ protectedZpureZsealedZtailcallZtraitZvirtualZvolatile)+z!=�#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� rM Zexn�obj�enumz\\[\\"\'ntbrafv]z
\\[0-9]{3}z\\u[0-9a-fA-F]{4}z\\U[0-9a-fA-F]{8}r� z \(\)|\[\]z \b(?<!\.)([A-Z][\w\']*)(?=\s*\.)�dottedz\b([A-Z][\w\']*)z///.*?\nr9 z
\(\*(?!\))r� z@"�lstringz"""�tqsry r� z \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]?z 0[oO][0-7][0-7_]*[uU]?[yslLn]?z 0[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\']*:r� z[A-Z][\w\']*(?=\s*\.)z [A-Z][\w\']*rF z
[a-z_][\w\']*z [^(*)@"]+z\(\*rz z\*\)z[(*)@]z[^\\"]+�escape-sequencer8 r; z"B?r� r� z"""B?)r� rJ r� r� r� r� r� c C s( d}d| v r|d7 }d| v r$|d7 }|S )zSF# doesn't have that many unique features -- |> and <| are weak
indicators.r z|>g�������?z<|rU r~ rU rU rV r� � s zFSharpLexer.analyse_textN)0rW rX rY rZ r[ r\ r] r^ �keywordsZkeyoptsZ operatorsZword_operatorsZ prefix_symsZ
infix_symsZ
primitivesr ZEscaper r r� ZPseudort ZDocr rn r r r� rs r
rl �joinr
r� rr rq r r� r� r� ZBinr� rp r� r r rN r� rU rU rU rV r % s� �
� � � �����
�2�
� ����`r )&rZ r_ Zpygments.lexerr r r r r r r r Zpygments.tokenr
r r r
r r r r r r Z
pygments.utilr Zpygmentsr rd Zpygments.lexers.htmlr �__all__r r r r r� r r r rU rU rU rV �<module> s (0 r *Cm