634 lines
48 KiB
Plaintext
634 lines
48 KiB
Plaintext
|
Ë
|
|||
|
|
vR jA£ ã óÄ — U d dl Zd dlZd dlZd dlZd dlZddlmZ ddl ddl m
|
|||
|
|
Z
|
|||
|
|
m Z m Z m
|
|||
|
|
Z
|
|||
|
|
mZ deeef defd„Z d\ded ej& e defd
|
|||
|
|
„Zdedefd „Zdedefd „Z d]deej. e ef dedededef
|
|||
|
|
d„Zdededefd„Z d^dededefd„Z dedefd„Z dedefd„Z e « Z dd de fd eeef d eeef d ej& e d ej& e def
|
|||
|
|
d!„Z! e"d"« e"d#« fd$„Z#d%eeef de$eef fd&„Z%d%eeef de$eef fd'„Z&ee'd(< ee'd)< e% e(e)e*d*z « jW d+« « \ Z,Z-ej\ j^ ja « D � �ci c] \ } }| jc d,« |“Œ c}} Z2d-jg d.d/« Z4 e5d0„ « jW d1« Z6d2„ Z7 G d3„ d4e8« Z9eeee$eeef eeef f f Z:ee$e:e;e9ej& e< f e$e:e;e9f f Z= e"d« e"d « fd5ed6e>e= d7eeef d8eeef de?f
|
|||
|
|
d9„Z@dg fd:„ZA e5d;« jW d<« ZB e5d=« jW d>« ZC e5d?« j‰ « jW d@« ZE e5dA« jW dB« ZF e5dC« jW dD« ZG eGZH e5dE« jW dF« ZI eJ« j— « D �cg c] } eL|e« sŒ
|
|||
|
|
|‘Œ c}ZMe>e e'dG< d_d
|
|||
|
|
dHœdeeef dIeeef dJedKej& e; dLej& e; dMedefdN„ZNe9ZOe,ZPe-ZQe6ZReBZSeCZTeEZUeFZVeGZWeHZXeIZY edOeZ« Z[ edPeZ« ZN edQe« Z\ edRe« Z] edSe« Z^ edTe« Z_ edUe« Z` edVe « Za edWe!« Zb edXe%« Zc edYe&« Zd edZe7« Ze ed[e@« Zfyc c}} w c c}w )`é Né )Ú__diag__)Ú*)Ú_bslashÚ_flattenÚ_escape_regex_range_charsÚmake_compressed_reÚreplaced_by_pep8ÚexprÚreturnc ó< — t | t « r| S t | « S ©N)Ú
|
|||
|
|
isinstanceÚSuppress©r s úT/home/antigravity/intellecton/venv/lib/python3.12/site-packages/pyparsing/helpers.pyÚ _suppressionr s € ä�$œÔ!؈ Ü �D‹>Ðó Úint_exprc ó( ‡ ‡— t |dd« }|xs |}t « Šˆˆ fd„}|€ t t « j d„ « }n|j « }|j
|
|||
|
|
d« |j |d¬« |‰z j
|
|||
|
|
d‰ › d �« S )
|
|||
|
|
a$ Helper to define a counted list of expressions.
|
|||
|
|
|
|||
|
|
This helper defines a pattern of the form::
|
|||
|
|
|
|||
|
|
integer expr expr expr...
|
|||
|
|
|
|||
|
|
where the leading integer tells how many expr expressions follow.
|
|||
|
|
The matched tokens returns the array of expr tokens as a list - the
|
|||
|
|
leading count token is suppressed.
|
|||
|
|
|
|||
|
|
If ``int_expr`` is specified, it should be a pyparsing expression
|
|||
|
|
that produces an integer value.
|
|||
|
|
|
|||
|
|
Examples:
|
|||
|
|
|
|||
|
|
.. doctest::
|
|||
|
|
|
|||
|
|
>>> counted_array(Word(alphas)).parse_string('2 ab cd ef')
|
|||
|
|
ParseResults(['ab', 'cd'], {})
|
|||
|
|
|
|||
|
|
- In this parser, the leading integer value is given in binary,
|
|||
|
|
'10' indicating that 2 values are in the array:
|
|||
|
|
|
|||
|
|
.. doctest::
|
|||
|
|
|
|||
|
|
>>> binary_constant = Word('01').set_parse_action(lambda t: int(t[0], 2))
|
|||
|
|
>>> counted_array(Word(alphas), int_expr=binary_constant
|
|||
|
|
... ).parse_string('10 ab cd ef')
|
|||
|
|
ParseResults(['ab', 'cd'], {})
|
|||
|
|
|
|||
|
|
- If other fields must be parsed after the count but before the
|
|||
|
|
list items, give the fields results names and they will
|
|||
|
|
be preserved in the returned ParseResults:
|
|||
|
|
|
|||
|
|
.. doctest::
|
|||
|
|
|
|||
|
|
>>> ppc = pyparsing.common
|
|||
|
|
>>> count_with_metadata = ppc.integer + Word(alphas)("type")
|
|||
|
|
>>> typed_array = counted_array(Word(alphanums),
|
|||
|
|
... int_expr=count_with_metadata)("items")
|
|||
|
|
>>> result = typed_array.parse_string("3 bool True True False")
|
|||
|
|
>>> print(result.dump())
|
|||
|
|
['True', 'True', 'False']
|
|||
|
|
- items: ['True', 'True', 'False']
|
|||
|
|
- type: 'bool'
|
|||
|
|
ÚintExprNc óB •— |d }‰|r‰|z n t « z Š|d d …= y ©Nr )ÚEmpty)ÚsÚlÚtÚnÚ
|
|||
|
|
array_exprr s €€r Úcount_field_parse_actionz/counted_array.<locals>.count_field_parse_actionU s' ø€ à
|
|||
|
|
ˆa‰DˆØ¡Q˜˜qš¬E«GÑ3ˆ
|
|||
|
|
à
|
|||
|
|
Ša‰Dr c ó — t | d « S r )Úint©r s r ú<lambda>z counted_array.<locals>.<lambda>] s € ¼¸A¸a¹D» € r ÚarrayLenT©Úcall_during_tryz(len) z...)Údeprecate_argumentÚForwardÚWordÚnumsÚset_parse_actionÚcopyÚset_nameÚadd_parse_action)r r Úkwargsr r r s ` @r Ú
|
|||
|
|
counted_arrayr1 s˜ ù€ ôb /AØ� ˜4ó/€Gð Ò!˜€GÜ“€Jõð €Ü”t“*×-Ñ-Ñ.AÓB‰à—,‘,“.ˆØ ×Ñ�ZÔ Ø × Ñ Ð 5ÀtÐ ÔLØ �jÑ × *Ñ *¨V°D°6¸Ð+=Ó >Ð>r c ót ‡— t « Šˆfd„}| j |d¬« ‰j d| › �« ‰S )aI Helper to define an expression that is indirectly defined from
|
|||
|
|
the tokens matched in a previous expression, that is, it looks for
|
|||
|
|
a 'repeat' of a previous expression. For example::
|
|||
|
|
|
|||
|
|
.. testcode::
|
|||
|
|
|
|||
|
|
first = Word(nums)
|
|||
|
|
second = match_previous_literal(first)
|
|||
|
|
match_expr = first + ":" + second
|
|||
|
|
|
|||
|
|
will match ``"1:1"``, but not ``"1:2"``. Because this
|
|||
|
|
matches a previous literal, will also match the leading
|
|||
|
|
``"1:1"`` in ``"1:10"``. If this is not desired, use
|
|||
|
|
:class:`match_previous_expr`. Do *not* use with packrat parsing
|
|||
|
|
enabled.
|
|||
|
|
c ó° •— |s‰t « z y t |« dk( r ‰|d z y t |j « « }‰t d„ |D « « z y )Nr r c 3 ó2 K — | ] }t |« –— Œ y wr )ÚLiteral)Ú.0Útts r ú <genexpr>zImatch_previous_literal.<locals>.copy_token_to_repeater.<locals>.<genexpr>ƒ s è ø€ Ò/ 2”7˜2—;Ñ/ùó ‚)r Úlenr Úas_listÚAnd)r r r ÚtflatÚreps €r Úcopy_token_to_repeaterz6match_previous_literal.<locals>.copy_token_to_repeaterx sP ø€ ÙØ ”5“7ŠNØ ä ˆq‹6�QŠ;Ø �1�Q‘4ŠKØ ô ˜Ÿ™›Ó%ˆØ ŒsÑ/¨Ô/Ó/Ó/r Tr& ú(prev) )r) r/ r. )r r? r> s @r Úmatch_previous_literalrA e s? ø€ ô" ‹)€Cô 0ð ×ÑÐ0À$ÐÔG؇L�L�7˜4˜&Ð!Ô"Ø €Jr c óž ‡— t « Š| j « }‰|z Šˆfd„}| j |d¬« ‰j d| › �« ‰S )af Helper to define an expression that is indirectly defined from
|
|||
|
|
the tokens matched in a previous expression, that is, it looks for
|
|||
|
|
a 'repeat' of a previous expression. For example:
|
|||
|
|
|
|||
|
|
.. testcode::
|
|||
|
|
|
|||
|
|
first = Word(nums)
|
|||
|
|
second = match_previous_expr(first)
|
|||
|
|
match_expr = first + ":" + second
|
|||
|
|
|
|||
|
|
will match ``"1:1"``, but not ``"1:2"``. Because this
|
|||
|
|
matches by expressions, will *not* match the leading ``"1:1"``
|
|||
|
|
in ``"1:10"``; the expressions are evaluated first, and then
|
|||
|
|
compared, so ``"1"`` is compared with ``"10"``. Do *not* use
|
|||
|
|
with packrat parsing enabled.
|
|||
|
|
c ój •‡— t |j « « Šˆfd„}‰j |d¬« y )Nc óh •— t |j « « }|‰k7 rt | |d‰› d|› �« ‚y )Nz Expected z, found)r r; ÚParseException)r r r Ú theseTokensÚ matchTokenss €r Úmust_match_these_tokenszTmatch_previous_expr.<locals>.copy_token_to_repeater.<locals>.must_match_these_tokens¢ sA ø€ Ü" 1§9¡9£;Ó/ˆKؘkÒ)Ü$Ø�q˜I k ]°'¸+¸ ÐGóð ð *r Tr& )r r; r, )r r r rH rG r> s @€r r? z3match_previous_expr.<locals>.copy_token_to_repeaterŸ s. ù€ Ü ˜qŸy™y›{Ó+ˆ ô ð × Ñ Ð 4ÀdÐ ÕKr Tr& r@ )r) r- r/ r. )r Úe2r? r> s @r Úmatch_previous_exprrJ Š sT ø€ ô" ‹)€CØ
|
|||
|
|
�‰‹€B؈B�J€Cô
|
|||
|
|
Lð ×ÑÐ0À$ÐÔG؇L�L�7˜4˜&Ð!Ô"Ø €Jr FTÚstrsÚcaselessÚ use_regexÚ
|
|||
|
|
as_keywordc óê ‡‡— t |dd« }t |dd« }|xs |}|xr |}t |t « r,t j r t
|
|||
|
|
j
|
|||
|
|
dt d¬« |rd„ }d „ }nt j }d
|
|||
|
|
„ }t | t « r+t j t | « } | j « } n't | t « r t | « } n t! d « ‚| s
|
|||
|
|
t# « S d }
|
|||
|
|
|
|
|||
|
|
t% | « d
|
|||
|
|
z
|
|||
|
|
k r‡| |
|
|||
|
|
} t' | |
|
|||
|
|
d
|
|||
|
|
z d « D ]W \ } }
|
|||
|
|
||
|
|||
|
|
| « r | |
|
|||
|
|
| z d
|
|||
|
|
z = nEt% |
|
|||
|
|
« t% | « kD sŒ2 || |
|
|||
|
|
« sŒ<| |
|
|||
|
|
| z d
|
|||
|
|
z = | j) |
|
|||
|
|
|
|
|||
|
|
« n |
|
|||
|
|
d
|
|||
|
|
z
|
|||
|
|
}
|
|||
|
|
|
|
|||
|
|
t% | « d
|
|||
|
|
z
|
|||
|
|
k rŒ‡|rÏ|rt* j, nd } t/ d„ | D « « r ddj1 d„ | D « « › d�}ndj1 d„ | D « « }|rd|› d�}t3 ||¬« }|j5 dj1 d„ | D « « « |r3| D �ci c] }|j7 « |“Œ c}Š|j9 ˆfd„« |S dx}}||ft< || ft> | |ft@ | | ftB i||f ŠtE ˆfd „| D « « j5 dj1 | « « S c c}w # t* j: $ r t
|
|||
|
|
j
|
|||
|
|
d t d¬« Y Œ—w xY w) a Helper to quickly define a set of alternative :class:`Literal` s,
|
|||
|
|
and makes sure to do longest-first testing when there is a conflict,
|
|||
|
|
regardless of the input order, but returns
|
|||
|
|
a :class:`MatchFirst` for best performance.
|
|||
|
|
|
|||
|
|
:param strs: a string of space-delimited literals, or a collection of
|
|||
|
|
string literals
|
|||
|
|
:param caseless: treat all literals as caseless
|
|||
|
|
:param use_regex: bool - as an optimization, will
|
|||
|
|
generate a :class:`Regex` object; otherwise, will generate
|
|||
|
|
a :class:`MatchFirst` object (if ``caseless=True`` or
|
|||
|
|
``as_keyword=True``, or if creating a :class:`Regex` raises an exception)
|
|||
|
|
:param as_keyword: bool - enforce :class:`Keyword`-style matching on the
|
|||
|
|
generated expressions
|
|||
|
|
|
|||
|
|
Parameters ``asKeyword`` and ``useRegex`` are retained for pre-PEP8
|
|||
|
|
compatibility, but will be removed in a future release.
|
|||
|
|
|
|||
|
|
Example:
|
|||
|
|
|
|||
|
|
.. testcode::
|
|||
|
|
|
|||
|
|
comp_oper = one_of("< = > <= >= !=")
|
|||
|
|
var = Word(alphas)
|
|||
|
|
number = Word(nums)
|
|||
|
|
term = var | number
|
|||
|
|
comparison_expr = term + comp_oper + term
|
|||
|
|
print(comparison_expr.search_string("B = 12 AA=23 B<=AA AA>12"))
|
|||
|
|
|
|||
|
|
prints:
|
|||
|
|
|
|||
|
|
.. testoutput::
|
|||
|
|
|
|||
|
|
[['B', '=', '12'], ['AA', '=', '23'], ['B', '<=', 'AA'], ['AA', '>', '12']]
|
|||
|
|
ÚuseRegexTÚ asKeywordFz‡warn_on_multiple_string_args_to_oneof: More than one string argument passed to one_of, pass choices as a list or space-delimited stringé ©Ú
|
|||
|
|
stacklevelc óD — | j « |j « k( S r )Úupper©ÚaÚbs r r$ zone_of.<locals>.<lambda>í s € §¡£ ¨Q¯W©W«YÑ 6€ r c ó\ — |j « j | j « « S r )rV Ú
|
|||
|
|
startswithrW s r r$ zone_of.<locals>.<lambda>î s € ˜QŸW™W›Y× 1Ñ 1°!·'±'³)Ó <€ r c ó$ — |j | « S r )r[ rW s r r$ zone_of.<locals>.<lambda>ñ s € ˜QŸ\™\¨!›_€ r z7Invalid argument to one_of, expected string or iterabler r Nc 3 ó8 K — | ] }t |« d k( –— Œ yw)r N)r: ©r6 Úsyms r r8 zone_of.<locals>.<genexpr> s è ø€ Ò4 S”3�s“8˜q•=Ñ4ùs ‚ú[Ú c 3 ó2 K — | ] }t |« –— Œ y wr )r r^ s r r8 zone_of.<locals>.<genexpr> s è ø€ Ò"UÀcÔ#<¸S×#AÑ"Uùr9 ú]ú|c 3 óF K — | ] }t j |« –— Œ y wr )ÚreÚescaper^ s r r8 zone_of.<locals>.<genexpr> s è ø€ Ò B°3¤§ ¡ ¨#§Ñ Bùs ‚ !z\b(?:z)\b)Úflagsz | c 3 ó2 K — | ] }t |« –— Œ y wr )Úrepr)r6 r s r r8 zone_of.<locals>.<genexpr> s è ø€ Ò#=°¤D¨§GÑ#=ùr9 c ó0 •— ‰|d j « S r ©Úlower)r r r Ú
|
|||
|
|
symbol_maps €r r$ zone_of.<locals>.<lambda># s ø€ °ZÀÀ!ÁÇ
|
|||
|
|
Á
|
|||
|
|
à Ñ5M€ r z8Exception creating Regex for one_of, building MatchFirstc 3 ó. •K — | ] } ‰|« –— Œ y wr © )r6 r_ Úparse_element_classs €r r8 zone_of.<locals>.<genexpr>7 s øè ø€ ÒB°3Ñ)¨#×.ÑBùs ƒ)#r( r Ústr_typer Ú%warn_on_multiple_string_args_to_oneofÚwarningsÚwarnÚPyparsingDiagnosticWarningÚoperatorÚeqÚtypingÚcastÚstrÚsplitÚIterableÚlistÚ TypeErrorÚNoMatchr: Ú enumerateÚinsertrf Ú
|
|||
|
|
IGNORECASEÚallÚjoinÚRegexr. rm r/ ÚerrorÚCaselessKeywordÚCaselessLiteralÚKeywordr5 Ú
|
|||
|
|
MatchFirst)rK rL rM rN r0 rP rQ Úis_equalÚmasksÚsymbolsÚiÚcurÚjÚotherÚre_flagsÚpattÚretr_ ÚCASELESSÚKEYWORDrq rn s @@r Úone_ofr˜ ° s ù€ ôT (¨°
|
|||
|
|
¸DÓA€HÜ(¨°¸eÓD€IàÒ'˜Z€IØÒ%˜I€Hô �8œXÔ&Ü × :Ò :ä�
|
|||
|
|
‰
|
|||
|
|
ð
|
|||
|
|
;ô
|
|||
|
|
'Øð ô
|
|||
|
|
ñ Ù6ˆÙ<‰ä—;‘;ˆÙ,ˆô �$œÔ!Ü�{‰{œ3 Ó%ˆØ—*‘*“,‰Ü �Dœ(Ô #Ü�t“*‰äÐQÓRÐRÙ Ü‹yÐð
|
|||
|
|
€AØ
|
|||
|
|
Œc�'‹l˜QÑ Ò
|
|||
|
|
Ø�a‰jˆÜ! '¨!¨a©%¨'Ð"2Ó3ò ‰HˆAˆuÙ˜˜sÔ#ؘA ™E A™IÐ&ÙÜ�5‹zœC ›HÓ$©¨s°EÕ):ؘA ™E A™IÐ&Ø—‘˜q %Ô(Ùð ð
|
|||
|
|
�‰FˆAð Œc�'‹l˜QÑ Ó
|
|||
|
|
ñ Ù)1œŸ
|
|||
|
|
š
|
|||
|
|
°qˆð ÜÑ4¨GÔ4Ô4à˜2Ÿ7™7Ñ"UÈWÔ"UÓUÐVÐVWÐX‘à—x‘xÑ B¸'Ô BÓB�ñ Ø ˜v SÐ)�ä˜ HÔ-ˆCØ �L‰L˜Ÿ™Ñ#=°WÔ#=Ó=Ô >áð ;BÖ B°3˜cŸi™i›k¨3Ñ .Ò B�
|
|||
|
|
Ø×$Ñ$Ó%MÔNàˆJð Ð €Hˆwà �7Ðœ_Ø �w�;Ð ¤ Ø
|
|||
|
|
ˆ �wÐ ¤Ø
|
|||
|
|
ˆ ˜7�{Ð#¤Wð ð
|
|||
|
|
�Ðñ Ðô ÓB¸'ÔBÓ B× KÑ KØ
|
|||
|
|
�
|
|||
|
|
‰
|
|||
|
|
�7Óó ð ùò+ Cøô
|
|||
|
|
�x‰xò Ü �M‰MØJÜ*Ø ð
|
|||
|
|
ö
|
|||
|
|
ð ús% Æ B K È)J;ÉK Ê;K Ë /K2Ë1K2ÚkeyÚvaluec óB — t t t | |z « « « S )a¶ Helper to easily and clearly define a dictionary by specifying
|
|||
|
|
the respective patterns for the key and value. Takes care of
|
|||
|
|
defining the :class:`Dict`, :class:`ZeroOrMore`, and
|
|||
|
|
:class:`Group` tokens in the proper order. The key pattern
|
|||
|
|
can include delimiting markers or punctuation, as long as they are
|
|||
|
|
suppressed, thereby leaving the significant key text. The value
|
|||
|
|
pattern can include named results, so that the :class:`Dict` results
|
|||
|
|
can include named token fields.
|
|||
|
|
|
|||
|
|
Example:
|
|||
|
|
|
|||
|
|
.. doctest::
|
|||
|
|
|
|||
|
|
>>> text = "shape: SQUARE posn: upper left color: light blue texture: burlap"
|
|||
|
|
|
|||
|
|
>>> data_word = Word(alphas)
|
|||
|
|
>>> label = data_word + FollowedBy(':')
|
|||
|
|
>>> attr_expr = (
|
|||
|
|
... label
|
|||
|
|
... + Suppress(':')
|
|||
|
|
... + OneOrMore(data_word, stop_on=label)
|
|||
|
|
... .set_parse_action(' '.join))
|
|||
|
|
>>> print(attr_expr[1, ...].parse_string(text).dump())
|
|||
|
|
['shape', 'SQUARE', 'posn', 'upper left', 'color', 'light blue', 'texture', 'burlap']
|
|||
|
|
|
|||
|
|
>>> attr_label = label
|
|||
|
|
>>> attr_value = Suppress(':') + OneOrMore(data_word, stop_on=label
|
|||
|
|
... ).set_parse_action(' '.join)
|
|||
|
|
|
|||
|
|
# similar to Dict, but simpler call format
|
|||
|
|
>>> result = dict_of(attr_label, attr_value).parse_string(text)
|
|||
|
|
>>> print(result.dump())
|
|||
|
|
[['shape', 'SQUARE'], ['posn', 'upper left'], ['color', 'light blue'], ['texture', 'burlap']]
|
|||
|
|
- color: 'light blue'
|
|||
|
|
- posn: 'upper left'
|
|||
|
|
- shape: 'SQUARE'
|
|||
|
|
- texture: 'burlap'
|
|||
|
|
[0]:
|
|||
|
|
['shape', 'SQUARE']
|
|||
|
|
[1]:
|
|||
|
|
['posn', 'upper left']
|
|||
|
|
[2]:
|
|||
|
|
['color', 'light blue']
|
|||
|
|
[3]:
|
|||
|
|
['texture', 'burlap']
|
|||
|
|
|
|||
|
|
>>> print(result['shape'])
|
|||
|
|
SQUARE
|
|||
|
|
>>> print(result.shape) # object attribute access works too
|
|||
|
|
SQUARE
|
|||
|
|
>>> print(result.as_dict())
|
|||
|
|
{'shape': 'SQUARE', 'posn': 'upper left', 'color': 'light blue', 'texture': 'burlap'}
|
|||
|
|
)ÚDictÚ OneOrMoreÚGroup)r™ rš s r Údict_ofrŸ < s € ôl ” œ% e¡ Ó,Ó-Ó .Ð.r Ú as_stringc óJ — t |dd« }|xr |}t « j d„ « }|j « }d|_ |d« | z |d« z }|rd„ }nd„ }|j |« | j
|
|||
|
|
|_ |j
|
|||
|
|
t j « |S ) a) Helper to return the original, untokenized text for a given
|
|||
|
|
expression. Useful to restore the parsed fields of an HTML start
|
|||
|
|
tag into the raw tag text itself, or to revert separate tokens with
|
|||
|
|
intervening whitespace back to the original matching input text. By
|
|||
|
|
default, returns a string containing the original parsed text.
|
|||
|
|
|
|||
|
|
If the optional ``as_string`` argument is passed as
|
|||
|
|
``False``, then the return value is
|
|||
|
|
a :class:`ParseResults` containing any results names that
|
|||
|
|
were originally matched, and a single token containing the original
|
|||
|
|
matched text from the input string. So if the expression passed to
|
|||
|
|
:class:`original_text_for` contains expressions with defined
|
|||
|
|
results names, you must set ``as_string`` to ``False`` if you
|
|||
|
|
want to preserve those results name values.
|
|||
|
|
|
|||
|
|
The ``asString`` pre-PEP8 argument is retained for compatibility,
|
|||
|
|
but will be removed in a future release.
|
|||
|
|
|
|||
|
|
Example:
|
|||
|
|
|
|||
|
|
.. testcode::
|
|||
|
|
|
|||
|
|
src = "this is test <b> bold <i>text</i> </b> normal text "
|
|||
|
|
for tag in ("b", "i"):
|
|||
|
|
opener, closer = make_html_tags(tag)
|
|||
|
|
patt = original_text_for(opener + ... + closer)
|
|||
|
|
print(patt.search_string(src)[0])
|
|||
|
|
|
|||
|
|
prints:
|
|||
|
|
|
|||
|
|
.. testoutput::
|
|||
|
|
|
|||
|
|
['<b> bold <i>text</i> </b>']
|
|||
|
|
['<i>text</i>']
|
|||
|
|
ÚasStringTc ó — |S r rp )r Úlocr s r r$ z#original_text_for.<locals>.<lambda>Ÿ s € ¸3€ r FÚ_original_startÚ
|
|||
|
|
_original_endc ó4 — | |j |j S r )r¥ r¦ ©r r r s r r$ z#original_text_for.<locals>.<lambda>¤ s € a¨×(9Ñ(9¸A¿O¹OÐ&L€ r c óR — | |j d« |j d« g|d d y )Nr¥ r¦ ©Úpopr¨ s r Ú extractTextz&original_text_for.<locals>.extractText§ s( € Ø�a—e‘eÐ -Ó.°·±°Ó1GÐHÐIˆA‰a‰Dr ) r( r r, r- Ú callPreparseÚ ignoreExprsÚsuppress_warningÚ DiagnosticsÚ)warn_ungrouped_named_tokens_in_collection)r r r0 r¢ Ú locMarkerÚ endlocMarkerÚ matchExprr¬ s r Úoriginal_text_forrµ u s¤ € ôL (¨°
|
|||
|
|
¸DÓA€HàÒ%˜I€Hä“×(Ñ(Ñ)>Ó?€IØ —>‘>Ó#€LØ %€LÔ ÙÐ+Ó,¨tÑ3±lÀ?Ó6SÑS€IÙÙL‰ ò Jð × Ñ ˜{Ô+Ø × ,Ñ ,€IÔØ
|
|||
|
|
× Ñ œ{× TÑ TÔUØ Ðr c ó8 — t | « j d„ « S )zkHelper to undo pyparsing's default grouping of And expressions,
|
|||
|
|
even if all but one are non-empty.
|
|||
|
|
c ó — | d S r rp r# s r r$ zungroup.<locals>.<lambda>´ s
|
|||
|
|
€ ¸1¸Q¹4€ r )ÚTokenConverterr/ r s r Úungroupr¹ ° s € ô ˜$Ó × 0Ñ 0± Ó @Ð@r c óö — t j d›dd›�t d¬« t « j d„ « }t |d« | d« z |j
|
|||
|
|
« j « d « z « S )
|
|||
|
|
a\
|
|||
|
|
.. deprecated:: 3.0.0
|
|||
|
|
Use the :class:`Located` class instead. Note that `Located`
|
|||
|
|
returns results with one less grouping level.
|
|||
|
|
|
|||
|
|
Helper to decorate a returned token with its starting and ending
|
|||
|
|
locations in the input string.
|
|||
|
|
|
|||
|
|
This helper adds the following results names:
|
|||
|
|
|
|||
|
|
- ``locn_start`` - location where matched expression begins
|
|||
|
|
- ``locn_end`` - location where matched expression ends
|
|||
|
|
- ``value`` - the actual parsed results
|
|||
|
|
|
|||
|
|
Be careful if the input text contains ``<TAB>`` characters, you
|
|||
|
|
may want to call :meth:`ParserElement.parse_with_tabs`
|
|||
|
|
Ú locatedExprú deprecated - use ÚLocatedrR rS c ó — |S r rp )ÚssÚllr7 s r r$ z locatedExpr.<locals>.<lambda>Ï s € ¸"€ r Ú
|
|||
|
|
locn_startrš Úlocn_end)rt ru ÚPyparsingDeprecationWarningr r, rž r- Úleave_whitespace)r Úlocators r r» r» · s € ô$
|
|||
|
|
‡M�MØ Ð
|
|||
|
|
Ð-¨i¨]Ð;Ü#Øð ô ô ‹g×&Ñ&Ñ'<Ó=€GÜ Ù� Ó Ù
|
|||
|
|
ˆw‹-ñ à
|
|||
|
|
+ˆ'�,‰,‹.×
|
|||
|
|
)Ñ
|
|||
|
|
)Ó
|
|||
|
|
+¨JÓ
|
|||
|
|
7ñ 8ó ð r ú(ú)ÚopenerÚcloserÚcontentÚ ignore_exprc óþ — t |dt « }||k7 r |t u r|n|}|t u r
|
|||
|
|
t « }| |k( r t d« ‚|�€£t | t
|
|||
|
|
« �ret |t
|
|||
|
|
« �rTt
|
|||
|
|
j t | « } t
|
|||
|
|
j t |« }t | « dk( r|t |« dk( rn|�8t t | t | |z t j z d¬« z « « }nÕt t « t | |z t j z « z « }n¡|�Lt t | t! | « z t! |« z t t j d¬« z « « }nSt t t! | « t! |« z t t j d¬« z « « }n t d« ‚t j r|j# d„ « t% « }|�6|t' t) | « t+ ||z |z « z t) |« z « z }n2|t' t) | « t+ ||z « z t) |« z « z }|j- d| › |› d �« d|_ |S )
|
|||
|
|
a
|
|||
|
|
|
|||
|
|
Helper method for defining nested lists enclosed in opening and
|
|||
|
|
closing delimiters (``"("`` and ``")"`` are the default).
|
|||
|
|
|
|||
|
|
:param opener: str - opening character for a nested list
|
|||
|
|
(default= ``"("``); can also be a pyparsing expression
|
|||
|
|
|
|||
|
|
:param closer: str - closing character for a nested list
|
|||
|
|
(default= ``")"``); can also be a pyparsing expression
|
|||
|
|
|
|||
|
|
:param content: expression for items within the nested lists
|
|||
|
|
|
|||
|
|
:param ignore_expr: expression for ignoring opening and closing delimiters
|
|||
|
|
(default = :class:`quoted_string`)
|
|||
|
|
|
|||
|
|
Parameter ``ignoreExpr`` is retained for compatibility
|
|||
|
|
but will be removed in a future release.
|
|||
|
|
|
|||
|
|
If an expression is not provided for the content argument, the
|
|||
|
|
nested expression will capture all whitespace-delimited content
|
|||
|
|
between delimiters as a list of separate values.
|
|||
|
|
|
|||
|
|
Use the ``ignore_expr`` argument to define expressions that may
|
|||
|
|
contain opening or closing characters that should not be treated as
|
|||
|
|
opening or closing characters for nesting, such as quoted_string or
|
|||
|
|
a comment expression. Specify multiple expressions using an
|
|||
|
|
:class:`Or` or :class:`MatchFirst`. The default is
|
|||
|
|
:class:`quoted_string`, but if no expressions are to be ignored, then
|
|||
|
|
pass ``None`` for this argument.
|
|||
|
|
|
|||
|
|
Example:
|
|||
|
|
|
|||
|
|
.. testcode::
|
|||
|
|
|
|||
|
|
data_type = one_of("void int short long char float double")
|
|||
|
|
decl_data_type = Combine(data_type + Opt(Word('*')))
|
|||
|
|
ident = Word(alphas+'_', alphanums+'_')
|
|||
|
|
number = pyparsing_common.number
|
|||
|
|
arg = Group(decl_data_type + ident)
|
|||
|
|
LPAR, RPAR = map(Suppress, "()")
|
|||
|
|
|
|||
|
|
code_body = nested_expr('{', '}', ignore_expr=(quoted_string | c_style_comment))
|
|||
|
|
|
|||
|
|
c_function = (decl_data_type("type")
|
|||
|
|
+ ident("name")
|
|||
|
|
+ LPAR + Opt(DelimitedList(arg), [])("args") + RPAR
|
|||
|
|
+ code_body("body"))
|
|||
|
|
c_function.ignore(c_style_comment)
|
|||
|
|
|
|||
|
|
source_code = '''
|
|||
|
|
int is_odd(int x) {
|
|||
|
|
return (x%2);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
int dec_to_hex(char hchar) {
|
|||
|
|
if (hchar >= '0' && hchar <= '9') {
|
|||
|
|
return (ord(hchar)-ord('0'));
|
|||
|
|
} else {
|
|||
|
|
return (10+ord(hchar)-ord('A'));
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
'''
|
|||
|
|
for func in c_function.search_string(source_code):
|
|||
|
|
print(f"{func.name} ({func.type}) args: {func.args}")
|
|||
|
|
|
|||
|
|
|
|||
|
|
prints:
|
|||
|
|
|
|||
|
|
.. testoutput::
|
|||
|
|
|
|||
|
|
is_odd (int) args: [['int', 'x']]
|
|||
|
|
dec_to_hex (int) args: [['char', 'hchar']]
|
|||
|
|
Ú
|
|||
|
|
ignoreExprz.opening and closing strings cannot be the sameNr )ÚexactzOopening and closing arguments must be strings if no content expression is givenc óF — | d j t j « S r )ÚstripÚ
|
|||
|
|
ParserElementÚDEFAULT_WHITE_CHARSr# s r r$ z nested_expr.<locals>.<lambda>h s € ˜!˜A™$Ÿ*™*¤]×%FÑ%FÓG€ r znested z expression)r( Ú_NO_IGNORE_EXPR_GIVENÚ
|
|||
|
|
quoted_stringÚ
|
|||
|
|
ValueErrorr rr ry rz r{ r: ÚCombiner� Ú
|
|||
|
|
CharsNotInrÑ rÒ r r5 r, r) rž r Ú
|
|||
|
|
ZeroOrMorer. Úerrmsg)rÈ rÉ rÊ rË r0 rÍ r• s r Ú nested_exprrÚ Ü s‚ € ô^ !3Ø� Ô 3ó!€Jð �[Ò Ø$.Ô2GÑ$G‘[ÈZˆ
|
|||
|
|
àÔ*Ñ*Ü"“_ˆ
|
|||
|
|
à
|
|||
|
|
�ÒÜÐIÓJÐJà�Ü �fœhÕ '¬J°v¼xÕ,HÜ—[‘[¤ fÓ-ˆFÜ—[‘[¤ fÓ-ˆFÜ�6‹{˜aÒ ¤C¨£K°1Ò$4Ø Ð)Ü %Ü!Ø '˜KÜ (Ø &¨¡´-×2SÑ2SÑ SØ&'ô ñ óó ‘Gô &Ü ›Ü$Ø " V™O¬m×.OÑ.OÑ Oóñó ‘Gð Ð)Ü %Ü!Ø '˜KÜ & v›Ð .ñ /ä & v›Ð .ñ /ô )¬ ×)JÑ)JÐRSÔ Tñ Uóó ‘Gô &Ü!Ü $ V›_Ð ,Ü & v›Ð .ñ /ä (¬ ×)JÑ)JÐRSÔ Tñ Uóó ‘Gô Øaóð
|
|||
|
|
ô
|
|||
|
|
× ,Ò ,Ø × $Ñ $ÙGô
|
|||
|
|
ô ‹)€CØÐ Ø ”Ü ˜Ó ܘ cÑ)¨GÑ3Ó4ñ
|
|||
|
|
5ä˜6Ó"ñ
|
|||
|
|
#ó
|
|||
|
|
ñ
|
|||
|
|
‰ð ”Ü ˜Ó ¤:¨c°G©mÓ#<Ñ <¼|ÈFÓ?SÑ Só
|
|||
|
|
ñ
|
|||
|
|
ˆð ‡L�L�7˜6˜( 6 (¨+Ð6Ô7ð €C„JØ €Jr ú<ú>c
|
|||
|
|
óŽ ‡— t | t « r| Št | | ¬« } n | j Št t
|
|||
|
|
t dz « }|rˆt j « j t « }| | d« z t t t |t d« z |z « « « z t ddg¬« d« j d „ « z |z }n²t j « j t « t t" d
|
|||
|
|
¬ « z }| | d« z t t t |j d „ « t t d« |z « z « « « z t ddg¬« d« j d
|
|||
|
|
„ « z |z }t% t' d« | z d
|
|||
|
|
z d¬« }|j) d‰› d
|
|||
|
|
�« |j+ ˆfd„« |ddj- ‰j/ dd« j1 « j3 « « z « j) d‰› d
|
|||
|
|
�« }‰|_ ‰|_ t7 |« « |_ ||fS )zVInternal helper to construct opening and closing tag expressions,
|
|||
|
|
given a tag name)rL z_-:Útagú=ú/F)ÚdefaultÚemptyc ó — |d dk( S ©Nr rà rp r¨ s r r$ z_makeTags.<locals>.<lambda>� ó € !¡¨¡ € r rÜ )Ú
|
|||
|
|
exclude_charsc ó( — | d j « S r rl r# s r r$ z_makeTags.<locals>.<lambda>� s € ¸qÀ¹t¿z¹z»|€ r c ó — |d dk( S rä rp r¨ s r r$ z_makeTags.<locals>.<lambda>£ rå r z</)ÚadjacentrÛ c óÀ •— | j ddj ‰j dd« j « j « « z | j « « S )NÚstartra ú:ú )Ú __setitem__r… ÚreplaceÚtitler| r- )r Úresnames €r r$ z_makeTags.<locals>.<lambda>¬ sF ø€ �!—-‘-Ø �b—g‘g˜gŸo™o¨c°3Ó 7× =Ñ =Ó ?× EÑ EÓ GÓHÑ HÈ!Ï&É&Ë(ó
|
|||
|
|
€ r Úendra rì rí ) r rr rŠ Únamer* ÚalphasÚ alphanumsÚdbl_quoted_stringr- r, Ú
|
|||
|
|
remove_quotesrœ rØ rž r ÚOptrÔ Ú
|
|||
|
|
printablesrÖ r5 r. r/ r… rï rð r| rÞ ÚSkipToÚtag_body) ÚtagStrÚxmlÚ suppress_LTÚ suppress_GTÚ tagAttrNameÚ tagAttrValueÚopenTagÚcloseTagrñ s @r Ú _makeTagsr ~ s9 ø€ ô �&œ(Ô#؈ܘ¨c¨'Ô2‰à—+‘+ˆä”vœy¨5Ñ 0Ó1€KÙ
|
|||
|
|
Ü(×-Ñ-Ó/×@Ñ@Ä ÓOˆ à Ù�U‹mñ
|
|||
|
|
ä”:œe K´(¸3³-Ñ$?À,Ñ$NÓ OÓPÓQñ
|
|||
|
|
Rð (Œc�# ˜wÔ'¨Ó0×AÑAÙ+óñ
|
|||
|
|
ð ñ
|
|||
|
|
|
|||
|
|
ñ ô %×)Ñ)Ó+×<Ñ<¼]ÓKÌdÜ côO
|
|||
|
|
ñ
|
|||
|
|
ˆ ð
|
|||
|
|
Ù�U‹mñ
|
|||
|
|
äÜÜØ#×4Ñ4Ñ5KÓLÜ œh s›m¨lÑ :Ó;ñ<óóóñ
|
|||
|
|
ð (Œc�# ˜wÔ'¨Ó0×AÑAÙ+óñ
|
|||
|
|
ð ñ
|
|||
|
|
|
|||
|
|
ð ô ”w˜t“} vÑ-°Ñ3¸eÔD€Hà ×Ñ�q˜˜ �^Ô$à × Ñ ó
|
|||
|
|
ôñ
|
|||
|
|
Ø
|
|||
|
|
�—‘˜Ÿ™¨¨SÓ1×7Ñ7Ó9×?Ñ?ÓAÓBÑBóç�h��G�9˜AˆÓ ð
|
|||
|
|
ð €G„KØ€H„LÜ ™h›jÓ)€GÔØ �HÐ Ð r Útag_strc ó — t | d« S )al Helper to construct opening and closing tag expressions for HTML,
|
|||
|
|
given a tag name. Matches tags in either upper or lower case,
|
|||
|
|
attributes with namespaces and with quoted or unquoted values.
|
|||
|
|
|
|||
|
|
Example:
|
|||
|
|
|
|||
|
|
.. testcode::
|
|||
|
|
|
|||
|
|
text = '<td>More info at the <a href="https://github.com/pyparsing/pyparsing/wiki">pyparsing</a> wiki page</td>'
|
|||
|
|
# make_html_tags returns pyparsing expressions for the opening and
|
|||
|
|
# closing tags as a 2-tuple
|
|||
|
|
a, a_end = make_html_tags("A")
|
|||
|
|
link_expr = a + SkipTo(a_end)("link_text") + a_end
|
|||
|
|
|
|||
|
|
for link in link_expr.search_string(text):
|
|||
|
|
# attributes in the <A> tag (like "href" shown here) are
|
|||
|
|
# also accessible as named results
|
|||
|
|
print(link.link_text, '->', link.href)
|
|||
|
|
|
|||
|
|
prints:
|
|||
|
|
|
|||
|
|
.. testoutput::
|
|||
|
|
|
|||
|
|
pyparsing -> https://github.com/pyparsing/pyparsing/wiki
|
|||
|
|
F©r ©r s r Úmake_html_tagsr ¹ s € ô8 �W˜eÓ $Ð$r c ó — t | d« S )z½Helper to construct opening and closing tag expressions for XML,
|
|||
|
|
given a tag name. Matches tags only in the given upper/lower case.
|
|||
|
|
|
|||
|
|
Example: similar to :class:`make_html_tags`
|
|||
|
|
Tr r s r Ú
|
|||
|
|
make_xml_tagsr Ø s € ô �W˜dÓ #Ð#r Ú any_open_tagÚ
|
|||
|
|
any_close_tagz_:zany tagú;z-nbsp lt gt amp quot apos cent pound euro copyrí rd c ó6 — dt › dt t « › d�S )Nz &(?P<entity>rd z);)Ú_most_common_entitiesr Ú_htmlEntityMaprp r r r$ r$ î s € ˆlÔ0Ð1°Ô3EÄnÓ3UÐ2VÐVXÐ Y€ r zcommon HTML entityc ó@ — t j |j « S )zRHelper parser action to replace common HTML entities with their special characters)r ÚgetÚentityr¨ s r Úreplace_html_entityr ò s € ä × Ñ ˜aŸh™hÓ 'Ð'r c ó — e Zd ZdZdZdZy)ÚOpAssoczvEnumeration of operator associativity
|
|||
|
|
- used in constructing InfixNotationOperatorSpec for :class:`infix_notation`r rR N)Ú__name__Ú
|
|||
|
|
__module__Ú __qualname__Ú__doc__ÚLEFTÚRIGHTrp r r r r ÷ s „ ñTð
|
|||
|
|
€DØ
|
|||
|
|
�Er r Ú base_exprÚop_listÚlparÚrparc ó® — G d„ dt « }d|_ t « }|j | j › d�« t |t « r t |« }t |t « r t |« }||z |z j d| j › d�« }t |t « rt |t « s| t |« z }n| |z }|D �]ü }|dz dd \ } }
|
|||
|
|
} } t | t « rt j | « } t j t | « } |
|
|||
|
|
d k( r<t | t t f« rt! | « d
|
|||
|
|
k7 r t# d « ‚| \ }
|
|||
|
|
}|
|
|||
|
|
› |› d �}n| › d �}d
|
|||
|
|
|
|
|||
|
|
cxk rd k st# d« ‚ t# d« ‚| t$ j& t$ j( fvr t# d« ‚t « j |« }t j t |« }t+ g « }| t$ j& u r�|
|
|||
|
|
d
|
|||
|
|
k( r ||| z « }t || d z « }�nG|
|
|||
|
|
d
|
|||
|
|
k( rA| �$ ||| z |z « }t || |z d z « }�n |||z « }t |d « }�n|
|
|||
|
|
d k( rü ||
|
|||
|
|
z |z z |z « }t ||
|
|||
|
|
|z |z |z d z « }nÍ| t$ j( u r»|
|
|||
|
|
d
|
|||
|
|
k( r?t | t, « s t- | « } || j. |z « }t | |z « }nw|
|
|||
|
|
d
|
|||
|
|
k( rB| �# ||| z |z « }t || |z d z « }nM |||z « }t ||d z « }n0|
|
|||
|
|
d k( r+ ||
|
|||
|
|
z |z z |z « }t ||
|
|||
|
|
z |z |z |z « }d|_ |z }| r7t | t t f« r |j2 | Ž n|j3 | « |||z j |« z }|}�Œÿ ||z }|S )aë Helper method for constructing grammars of expressions made up of
|
|||
|
|
operators working in a precedence hierarchy. Operators may be unary
|
|||
|
|
or binary, left- or right-associative. Parse actions can also be
|
|||
|
|
attached to operator expressions. The generated parser will also
|
|||
|
|
recognize the use of parentheses to override operator precedences
|
|||
|
|
(see example below).
|
|||
|
|
|
|||
|
|
Note: if you define a deep operator list, you may see performance
|
|||
|
|
issues when using infix_notation. See
|
|||
|
|
:class:`ParserElement.enable_packrat` for a mechanism to potentially
|
|||
|
|
improve your parser performance.
|
|||
|
|
|
|||
|
|
Parameters:
|
|||
|
|
|
|||
|
|
:param base_expr: expression representing the most basic operand to
|
|||
|
|
be used in the expression
|
|||
|
|
:param op_list: list of tuples, one for each operator precedence level
|
|||
|
|
in the expression grammar; each tuple is of the form ``(op_expr,
|
|||
|
|
num_operands, right_left_assoc, (optional)parse_action)``, where:
|
|||
|
|
|
|||
|
|
- ``op_expr`` is the pyparsing expression for the operator; may also
|
|||
|
|
be a string, which will be converted to a Literal; if ``num_operands``
|
|||
|
|
is 3, ``op_expr`` is a tuple of two expressions, for the two
|
|||
|
|
operators separating the 3 terms
|
|||
|
|
- ``num_operands`` is the number of terms for this operator (must be 1,
|
|||
|
|
2, or 3)
|
|||
|
|
- ``right_left_assoc`` is the indicator whether the operator is right
|
|||
|
|
or left associative, using the pyparsing-defined constants
|
|||
|
|
``OpAssoc.RIGHT`` and ``OpAssoc.LEFT``.
|
|||
|
|
- ``parse_action`` is the parse action to be associated with
|
|||
|
|
expressions matching this operator expression (the parse action
|
|||
|
|
tuple member may be omitted); if the parse action is passed
|
|||
|
|
a tuple or list of functions, this is equivalent to calling
|
|||
|
|
``set_parse_action(*fn)``
|
|||
|
|
(:class:`ParserElement.set_parse_action`)
|
|||
|
|
|
|||
|
|
:param lpar: expression for matching left-parentheses; if passed as a
|
|||
|
|
str, then will be parsed as ``Suppress(lpar)``. If lpar is passed as
|
|||
|
|
an expression (such as ``Literal('(')``), then it will be kept in
|
|||
|
|
the parsed results, and grouped with them. (default= ``Suppress('(')``)
|
|||
|
|
:param rpar: expression for matching right-parentheses; if passed as a
|
|||
|
|
str, then will be parsed as ``Suppress(rpar)``. If rpar is passed as
|
|||
|
|
an expression (such as ``Literal(')')``), then it will be kept in
|
|||
|
|
the parsed results, and grouped with them. (default= ``Suppress(')')``)
|
|||
|
|
|
|||
|
|
Example:
|
|||
|
|
|
|||
|
|
.. testcode::
|
|||
|
|
|
|||
|
|
# simple example of four-function arithmetic with ints and
|
|||
|
|
# variable names
|
|||
|
|
integer = pyparsing_common.signed_integer
|
|||
|
|
varname = pyparsing_common.identifier
|
|||
|
|
|
|||
|
|
arith_expr = infix_notation(integer | varname,
|
|||
|
|
[
|
|||
|
|
('-', 1, OpAssoc.RIGHT),
|
|||
|
|
(one_of('* /'), 2, OpAssoc.LEFT),
|
|||
|
|
(one_of('+ -'), 2, OpAssoc.LEFT),
|
|||
|
|
])
|
|||
|
|
|
|||
|
|
arith_expr.run_tests('''
|
|||
|
|
5+3*6
|
|||
|
|
(5+3)*6
|
|||
|
|
(5+x)*y
|
|||
|
|
-2--11
|
|||
|
|
''', full_dump=False)
|
|||
|
|
|
|||
|
|
prints:
|
|||
|
|
|
|||
|
|
.. testoutput::
|
|||
|
|
:options: +NORMALIZE_WHITESPACE
|
|||
|
|
|
|||
|
|
|
|||
|
|
5+3*6
|
|||
|
|
[[5, '+', [3, '*', 6]]]
|
|||
|
|
|
|||
|
|
(5+3)*6
|
|||
|
|
[[[5, '+', 3], '*', 6]]
|
|||
|
|
|
|||
|
|
(5+x)*y
|
|||
|
|
[[[5, '+', 'x'], '*', 'y']]
|
|||
|
|
|
|||
|
|
-2--11
|
|||
|
|
[[['-', 2], '-', ['-', 11]]]
|
|||
|
|
c ó — e Zd Zdd„Zy)úinfix_notation.<locals>._FBc óB — | j j ||« |g fS r )r Ú try_parse)ÚselfÚinstringr¤ Ú doActionss r Ú parseImplz%infix_notation.<locals>._FB.parseImplp s € Ø �I‰I× Ñ ¨#Ô .ؘ�7ˆNr N©T)r r r r* rp r r Ú_FBr$ o s „ ô r r, z FollowedBy>Ú _expressionÚnested_r Né é rR z@if numterms=3, opExpr must be a tuple or list of two expressionsz operationsr z6operator must be unary (1), binary (2), or ternary (3)z2operator must indicate right or left associativity)r .)rR .F)Ú
|
|||
|
|
FollowedByr r) r. ró r r{ r rž rr rÑ Ú_literalStringClassry rz Útupler~ r: rÕ r r r r< rø r Úshow_in_diagramr, )r r r r! r, r• rÚ ÚlastExprÚoperDefÚopExprÚarityÚrightLeftAssocÚpaÚopExpr1ÚopExpr2Ú term_nameÚthisExprÚmatch_lookaheadr´ s r Úinfix_notationr@ s € ô|Œjô ð
|
|||
|
|
!€C„Lä
|
|||
|
|
‹)€C؇L�L�I—N‘NÐ# ;Ð/Ô0Ü�$œÔ ܘ‹~ˆÜ�$œÔ ܘ‹~ˆà˜#‘: Ñ$×.Ñ.°¸¿ ¹ Ð8HÈ Ð/TÓU€Kô
|
|||
|
|
�tœXÔ &¬:°d¼HÔ+EØ œu [Ó 1Ñ1‰à ˜{Ñ*ˆð ó L ˆØ-4°wÑ->ÀÀÐ,CÑ)ˆ��~ rÜ �fœhÔ 'Ü"×6Ñ6°vÓ>ˆFÜ—‘œ]¨FÓ3ˆØ �AŠ:Ü ˜f¤u¬d mÔ4¼¸F» ÀqÒ8HÜ ØVóð ð &Ñ ˆG�WØ"˜) G 9¨KÐ8‰Ià!˜( +Ð.ˆIà�EŒ˜QŠÜ Ð UÓVÐ Vð Ü Ð UÓVÐ Và ¤'§,¡,´·
|
|||
|
|
±
|
|||
|
|
Ð!>Ñ >Ü Ð QÓRÐ Rä")£)×"4Ñ"4°YÓ"?ˆÜ—;‘;œw¨Ó1ˆÜ ˜b›'ˆØ œWŸ\™\Ñ )ؘŠzÙ"% h°Ñ&7Ó"8�Ü ! (¨V°F©^Ñ";Ó <’ ؘ!’ØÐ%Ù&)¨(°VÑ*;¸hÑ*FÓ&G�OÜ % h°&¸8Ñ2CÀVÑ1LÑ&LÓ M’Iá&)¨(°XÑ*=Ó&>�OÜ % h¨vÑ&6Ó 7’Iؘ!’Ù"%Ø ˜wÑ&¨Ñ1°GÑ;¸hÑFó#�ô "Ø ¨(Ñ 2°WÑ <¸xÑ GÈÑ PÑPó ‘ ð œwŸ}™}Ñ
|
|||
|
|
,ؘŠzä! &¬#Ô.Ü ›[�FÙ"% f§k¡k°HÑ&<Ó"=�Ü ! &¨8Ñ"3Ó 4‘ ؘ!’ØÐ%Ù&)¨(°VÑ*;¸hÑ*FÓ&G�OÜ % h°&¸8Ñ2CÀVÑ1LÑ&LÓ M‘Iá&)¨(°XÑ*=Ó&>�OÜ % h°¸&Ñ1AÑ&AÓ B‘Iؘ!’Ù"%Ø ˜wÑ&¨Ñ1°GÑ;¸hÑFó#�ô " (¨WÑ"4°xÑ"?À'Ñ"IÈHÑ"TÓ U� ð +0ˆÔ'ð $ iÑ/ˆ á
|
|||
|
|
ܘ"œu¤d˜mÔ,Ø*� ×*Ñ*¨BÒ/à×*Ñ*¨2Ô.à�i (Ñ*×4Ñ4°YÓ?Ñ?ˆØŠðYL ð\ ˆHÑ€CØ €Jr c ó¾ ‡‡‡ — t j d›dd›�t d¬« ‰j ‰dd « ˆˆfd„Š ˆfd„}ˆfd „}ˆfd
|
|||
|
|
„}t t « j
|
|||
|
|
d « j « « }t « t « j |« z j d « }t « j |« j d
|
|||
|
|
« } t « j |« j d« }
|
|||
|
|
|r?t t |« |z t | t | « z t |« z « z |
|
|||
|
|
z « } nDt t |« t | t | « z t |« z « z t |
|
|||
|
|
« z « } | j ˆfd„« | j ˆ fd„« | j t t « z « | j d« S )aº
|
|||
|
|
.. deprecated:: 3.0.0
|
|||
|
|
Use the :class:`IndentedBlock` class instead. Note that `IndentedBlock`
|
|||
|
|
has a difference method signature.
|
|||
|
|
|
|||
|
|
Helper method for defining space-delimited indentation blocks,
|
|||
|
|
such as those used to define block statements in Python source code.
|
|||
|
|
|
|||
|
|
:param blockStatementExpr: expression defining syntax of statement that
|
|||
|
|
is repeated within the indented block
|
|||
|
|
|
|||
|
|
:param indentStack: list created by caller to manage indentation stack
|
|||
|
|
(multiple ``statementWithIndentedBlock`` expressions within a single
|
|||
|
|
grammar should share a common ``indentStack``)
|
|||
|
|
|
|||
|
|
:param indent: boolean indicating whether block must be indented beyond
|
|||
|
|
the current level; set to ``False`` for block of left-most statements
|
|||
|
|
|
|||
|
|
A valid block must contain at least one ``blockStatement``.
|
|||
|
|
|
|||
|
|
(Note that indentedBlock uses internal parse actions which make it
|
|||
|
|
incompatible with packrat parsing.)
|
|||
|
|
|
|||
|
|
Example:
|
|||
|
|
|
|||
|
|
.. testcode::
|
|||
|
|
|
|||
|
|
data = '''
|
|||
|
|
def A(z):
|
|||
|
|
A1
|
|||
|
|
B = 100
|
|||
|
|
G = A2
|
|||
|
|
A2
|
|||
|
|
A3
|
|||
|
|
B
|
|||
|
|
def BB(a,b,c):
|
|||
|
|
BB1
|
|||
|
|
def BBA():
|
|||
|
|
bba1
|
|||
|
|
bba2
|