|
Server : Apache System : Linux iad1-shared-b8-43 6.6.49-grsec-jammy+ #10 SMP Thu Sep 12 23:23:08 UTC 2024 x86_64 User : dh_edsupp ( 6597262) PHP Version : 8.2.26 Disable Function : NONE Directory : /lib/python3/dist-packages/pygments/lexers/__pycache__/ |
Upload File : |
o
���a�q � @ s d Z ddlZddlmZmZmZmZmZmZm Z m
Z
ddl m Z m
Z
mZmZmZmZmZmZmZmZmZ ddlmZ ddlmZ ddl m 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�
Whitespace)�get_choice_opt)� unistring)�XmlLexer)� CSharpLexer� NemerleLexer�BooLexer�
VbNetLexer�CSharpAspxLexer�VbNetAspxLexer� FSharpLexerc @ s e Zd ZdZdZg d�ZdgZdgZej 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 eeee�ejee �fd eeej �fd efd ee e�fd!e j fd"e j!fd#efd$e fd%e fd&e"fd'e"fd(e"j#fd)e$fd*ee j%ee j%e j%e�fd+ee&ee&�fd,e&fd-ee&e �fd.e&j'fd/ee&e�d0fd1ee&e�d2feefgeej(d3fe)d3�gd4e d3fd5e d6 ej*d3fgd7�ee< qed8d9� 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#)�csharpzc#�csz*.csz
text/x-csharp�@?[_a-zA-Z]\w*�@?[_�Lu�Ll�Lt�Lm�Nl�]�[�Nd�Pc�Cf�Mn�Mc�]*� @?(?:_|[^�Lo�])�[^��none�basic�fullT�
^([ \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]?zb(#)([ \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�(?=\()�(�|\.)+)�rootrG rI c K �P t |dt| j�d�}|| jvr| j�|�| _n| j| | _tj| fi |�� d S �N� unicodelevelr6 � r �list�tokens� _all_tokens� __class__�process_tokendef�_tokensr �__init__��self�options�level� r^ �8/usr/lib/python3/dist-packages/pygments/lexers/dotnet.pyrY � s
zCSharpLexer.__init__N),�__name__�
__module__� __qualname__�__doc__�name�aliases� filenames� mimetypes�re� MULTILINE�DOTALL�UNICODE�flags�uni�combine� allexcept�levelsrT �token_variants�items� levelname�cs_identr r r r r �Functionr
� Attributer r �Single� Multiliner �Charr �Preprocr �Type�Classr � NamespacerY r^ r^ r^ r_ r s� �������
����
���� � ��� � ��
.�� � 8r c ! @ s0 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 eeee�ejee �fd eeej �fd efd ee e�fd!e j fd"e j!fd#efd$ee"ee"�d%fd&ee"ee"�d'fd(e"d)fd*e d+ ee#ee#�fd,e#fd-e efd.eee �d/fd0e fd1e fd2e"fd3e"fd4e"j$fd5e%fd6e%fd7ee j&ee j&�d8fd9ee#ee#�fd:e#fd;ee#e �fd<e#j'fd=e d> ee ee#j'�fd?ee#e�d@fdAee#e�dBfeefg eej(dCfgdDe j&fdEefd#edCfgdFe dCfdGe dH ej)dCfgdIe"fd-e efd.eee �d/fdJe"fdKe"dCfgdLe"fd-e efd.eee �d/fd(e"dMfdNe"dCfgdOe"fd(e"dMfdNe"dCfgdPe#fdQe feefdRe%fdSe dMfdTe dCfgdU�ee< qddVdW� Z*dXdY� Z+dZS )[r 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
�Nemerle�nemerlez*.nztext/x-nemerler! r" r# r$ r% r& r' r( r) r* r+ r, r- r. r/ r0 r1 r2 r3 r4 Tr8 r9 r: r; r< r= r> r? r@ z (\$)(\s*)(")�
splice-stringz
(\$)(\s*)(<#)�splice-string2z<#�recursive-stringz (<\[)(\s*)(z:)?z\]\>z\$z(\$)(\()�splice-string-contentrA rB rC z "(\\\\|\\[^\\]|[^"\\\n])*["\n]rD z0[xX][0-9a-fA-F]+[Ll]?z*[0-9](\.[0-9]*)?([eE][+-][0-9]+)?[flFLdD]?zY(#)([ \t]*)(if|endif|else|elif|define|undef|line|error|warning|region|endregion|pragma)\b�preprocrE 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)\brF 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+)rG rH rI rJ z\w+z[ \t]+rK rL rM z[^"$]z\\"�"z[^#<>$]�#pushz#>z[^#<>]zif|matchz [~!%^&*+=|\[\]:;,.<>/?-\\"$ ]�\d+�\(�\))rN rG r� rI r� r� r� r� c K rO rP rR rZ r^ r^ r_ rY ( 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�������?r^ ��text�resultr^ r^ r_ � analyse_text3 s zNemerleLexer.analyse_textN),r` ra rb rc rd re rf rg rh ri rj rk rl rm rn ro rp rT rq rr rs rt r r r r r ru r
rv r r rw rx r r ry r rz r{ r| r} rY r� r^ r^ r^ r_ r � s �������
����
���� � ��
�� � �
�
�
��
@���
��
�� �� �k r c @ sR e Zd ZdZdZdgZdgZdgZdefde j
fde j d fd
e fd e
ee�fd efd
ejfdejfdejfdefdefdefde
ee�dfde
ee�dfde
ee�dfdejfdejfdejfd ej
fd efd ejfd efd ejfd!ejfd"ejj fd#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.
�Boo�booz*.booz
text/x-boo�\s+z (#|//).*$z/[*]�commentz []{}:(),.;[]r= 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+)rI 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� r� z[*]/rJ z[^/*]z[*/]z[a-zA-Z_][\w.]*)rN r� r� r� rI N)!r` ra rb rc rd re rf rg r r rw rx r
r r r
�Wordr �Regexr r �Builtin�Doubler �Float�Oct�Hex�Integer�Longru r| r} rT r^ r^ r^ r_ r > sb
��
�
'
�
�
�
�
�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 Zdejfdefdefdeee�fdeee�fdejfd efd eejeejeej�fed d d d!�efd"ed#fd$ed%fd&eee�d'fd(eee�d)fd*eee�d+fd,ejfd-ejfd.efd/e d0fd1ee e�fe
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.net�vbnetz*.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.*?)(\n)z
('.*?)(\n)z�#If\s.*?\sThen|#ElseIf\s.*?\sThen|#Else|#End\s+If|#Const|#ExternalSource.*?\n|#End\s+ExternalSource|#Region.*?\n|#End\s+Region|#ExternalChecksumz [(){}!#,.:]z?(Option)(\s+)(Strict|Explicit|Compare)(\s+)(On|Off|Binary|Text))l�
AddHandler�Alias�ByRef�ByVal�Call�Case�Catch�CBool�CByte�CChar�CDate�CDec�CDbl�CInt�CLng�CObj�Continue�CSByte�CShort�CSng�CStr�CType�CUInt�CULng�CUShort�Declare�Default�Delegate�
DirectCast�Do�Each�Else�ElseIf�EndIf�Erase�Error�Event�Exit�False�Finally�For�Friend�Get�Global�GoSub�GoTo�Handles�If�
Implements�Inherits� Interface�Let�Lib�Loop�Me� MustInherit� MustOverride�MyBase�MyClass� Narrowing�New�Next�Not�Nothing�NotInheritable�NotOverridable�Of�Onr
�Option�Optional� Overloads� Overridable� Overrides�
ParamArray�Partial�Private� Protected�Public�
RaiseEvent�ReadOnly�ReDim�
RemoveHandler�Resume�Return�Select�Set�Shadows�Sharedrw �Static�Step�Stop�SyncLock�Then�Throw�To�True�Try�TryCast�Wend�Using�When�While�Widening�With�
WithEvents� 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+)rI 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&=|[*]=|/=|\\=|\^=|\+=|-=|<<=|>>=|<<|>>|:=|<=|>=|<>|[-&*/\\^+=<>\[\]]r� �stringz(_)(\n)z [%&@!#$]?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?rJ �[^"]+�\.z?(Function|Sub|Property|Class|Structure|Enum|Module|Namespace)\b)rN r r r� r� rI r
c C s t �d| t j�r
dS d S )Nz^\s*(#If|Module|Namespace)g �?)rh �searchri �r� r^ r^ r_ r� � s �zVbNetLexer.analyse_textN)*r` ra rb rc rd re rf rg rm rn �uni_namerh ri �
IGNORECASErl r rv r r r rz r
r � Declarationr r{ r
r� r r r �Dater r� r� �Variabler ru r| r} rT r� r^ r^ r^ r_ r � s� ���� �
����
�
�
����
�<�
�
�
����� Xr 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-genrN z(<%[@=#]?)(.*?)(%>)z (<script.*?>)(.*?)(</script>)z
(.+?)(?=<)z.+N)r` ra rb rc rd rf rg rh rj rl r r �Tagr r r rT r^ r^ r^ r_ r � s
�
��r c �> 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 � t � jttfi |�� d S �N)�superrY r r �r[ r\ �rV r^ r_ rY � zCSharpAspxLexer.__init__c C �4 t �d| t j�d ur dS t �d| t j�d urdS d S )NzPage\s*Language="C#"皙�����?zscript[^>]+language=["\']C#�333333�?�rh r �Ir r^ r^ r_ r� �
�z CSharpAspxLexer.analyse_text� r` ra rb rc rd re rf rg rY r� �
__classcell__r^ r^ r r_ r � r c r )r zG
Lexer for highlighting Visual Basic.net within ASP.NET pages.
zaspx-vbr c r r )r rY r r r r r^ r_ rY % r zVbNetAspxLexer.__init__c C r! )NzPage\s*Language="Vb"r" zscript[^>]+language=["\']vbr# r$ r r^ r^ r_ r� ( r& zVbNetAspxLexer.analyse_textr' r^ r^ r r_ r r) r c @ s� e Zd ZdZdZddgZddgZdgZg d�Zeg d �7 Zg d
�Z d Z
g d �Z d
Z dZ
g d�Zdejfdejfdejfdejfgg def�dejjf�dejdf�def�deeje�f�deeje�f�ded f�d ed f�d ed f�d!ed"f�d#eeeej�f�d$eeeej�f�d%eeeej �f�d&eeeee ej �f�d'd(� e� ef�d)ef�d*d(� e � e f�d+e
e e
f e f�d'd(� e � e j!f�d'd(� e� ej"f�d,eej#eej#ej#e�f�d-ef�d.e$j%f�d/e$j&f�d0e$j'f�d1e$j(f�d2e$j)f�d3ej*f�d4ej*f�d5ef�d6ej+d"f�d7ejf�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#�fsharpzf#z*.fsz*.fsiz
text/x-fsharp)B�abstract�as�assert�base�beginrG r �delegatezdo!�do�done�downcast�downto�elif�elser
� exception�extern�false�finally�for�function�fun�global�if�inherit�inline� interface�internal�in�lazyzlet!�let�match�member�module�mutablerI �new�null�of�open�override�private�public�reczreturn!�return�select�static�struct�then�to�true�try�type�upcastzuse!�use�val�void�when�while�withzyield!�yield)�atomic�break�checked� component�const�
constraint� constructor�continue�eager�event�external�fixed�functorr �method�mixin�object�parallel�process� protected�pure�sealed�tailcall�trait�virtual�volatile)+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[=<>@^|&+\*/$%-])�sbyte�byte�char� nativeint�
unativeint�float32�single�float�double�int8�uint8�int16�uint16�int32�uint32�int64�uint64�decimal�unit�boolr rS �exn�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 (///.*?)(\n)z (//.*?)(\n)z
\(\*(?!\))r� z@"�lstringz"""�tqsr� 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)?%sz;(#)([ \t]*)(if|endif|else|line|nowarn|light|\d+)\b(.*?)(\n)z
[^\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\']*rJ z
[a-z_][\w\']*z [^(*)@"]+z\(\*r� z\*\)z[(*)@]z[^\\"]+�escape-sequencez\\\nr@ z"B?r r
z"""B?)r� rN 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<|r^ r� r^ r^ r_ r� � s zFSharpLexer.analyse_textN)0r` ra rb rc rd re rf rg �keywords�keyopts� operators�word_operators� prefix_syms�
infix_syms�
primitivesr �Escaper r r� �Pseudor} r �Docr rw r r r| r
ru �joinr
r� r{ rz r r� r� r� �Binr� ry r� r r rT r� r^ r^ r^ r_ r 0 s ��
�������
� � � �� �� ���������� ��� �"�#�$�%�&��)��+�,�
.�0�3�
� ���� ar )'rc rh �pygments.lexerr r r r r r r r �pygments.tokenr
r r r
r r r r r r r �
pygments.utilr �pygmentsr rm �pygments.lexers.htmlr �__all__r r r r r r r r r^ r^ r^ r_ �<module> s" (4 t 2Cn