/opt/cloudlinux/venv/lib/python3.11/site-packages/pyparsing/__pycache__
Edit: /opt/cloudlinux/venv/lib/python3.11/site-packages/pyparsing/__pycache__/helpers.cpython-311.pyc (53635B)
s U d dl Zd dlZd dlZddlmZ ddlT ddlmZm Z m
Z
dXddd e e e
f d
e e e
f d ed ej e d
ej e dede
fdZ dYddd e
dej e
dej e
de
fdZd e
de
fdZd e
de
fdZ dZdddde ej e e f deded ed ed ede
fd Zd e
d!e
de
fd"Z d[dd#d e
d$ed%ede
fd&Zd e
de
fd'Zd e
de
fd(Zd)d*d e f e d+d,e e e
f d-e e e
f d.ej e
d/e
d0e
de
f d1Z e d2 e d3 fd4Z d5e e e
f de e
e
f fd6Z d5e e e
f de e
e
f fd7Z!e
e"d8< e
e"d9< e e#e$e%d:z & d; \ Z'Z(d< ej) j* + D Z, e-d=d>. e, z d?z & d@ Z/dA Z0 G dB dCe1 Z2e e
e e e e
e f e e
e f f f Z3e e e3ee2ej e4 f e e3ee2f f Z5 e d) e d* fdDe
dEe6e5 dFe e e
f dGe e e
f de
f
dHZ7dg fdIZ8 e9 e-dJ dKz & dL Z: e-dM & dN Z; e-dO < & dP Z= e-dQ & dR Z> e9 e-dJ dKz e>z & dS Z? e?Z@ e-dT & dU ZA dV eB C D ZDe6e
e"dW< eZEeZFeZGeZHeZIeZJeZKe ZLe ZMe!ZNe'e(cZOZPe/ZQe0ZRe2ZSe7ZTe:ZUe;ZVe=ZWe>ZXe?ZYe@ZZeAZ[dS )\ N )__diag__)*)_bslash_flatten_escape_regex_range_chars,F)allow_trailing_delimexprdelimcombineminmaxr
returnc t | t rt | } d t | t | |r"d t | nd }|st | }||dk rt d |dz }| |||k rt d |dz }| || z ||f z }|r|t | z
}|r"t | | S | | S ) a/ Helper to define a delimited list of expressions - the delimiter
defaults to ','. By default, the list elements and delimiters can
have intervening whitespace, and comments, but this can be
overridden by passing ``combine=True`` in the constructor. If
``combine`` is set to ``True``, the matching tokens are
returned as a single token string, with the delimiters included;
otherwise, the matching tokens are returned as a list of tokens,
with the delimiters suppressed.
If ``allow_trailing_delim`` is set to True, then the list may end with
a delimiter.
Example::
delimited_list(Word(alphas)).parse_string("aa,bb,cc") # -> ['aa', 'bb', 'cc']
delimited_list(Word(hexnums), delim=':', combine=True).parse_string("AA:BB:CC:DD:EE") # -> ['AA:BB:CC:DD:EE']
z {expr} [{delim} {expr}]...{end}z [{}] )r r endNr zmin must be greater than 0z)max must be greater than, or equal to min)
isinstancestr_type
ParserElement_literalStringClassformatstrcopy
streamlineSuppress
ValueErrorOptCombineset_name)r r r
r r r
dlNamedelimited_list_exprs c/builddir/build/BUILD/cloudlinux-venv-1.0.12/venv/lib/python3.11/site-packages/pyparsing/helpers.pydelimited_listr$ sY 4 $!! 7 0066
.
5
5
''))
*
*%jj*> FGNN3u:: & & &B 6 F
77 9:: : q
?sczz HII I q %$,S!99 *s5zz) 4*++44V<<<"++F333 )intExprint_exprr& c b |p|}t fd}|)t t d }n| }| d | |d |z dt z dz 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.
Example::
counted_array(Word(alphas)).parse_string('2 ab cd ef') # -> ['ab', 'cd']
# in this parser, the leading integer value is given in binary,
# '10' indicating that 2 values are in the array
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') # -> ['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:
count_with_metadata = 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())
# prints
# ['True', 'True', 'False']
# - items: ['True', 'True', 'False']
# - type: 'bool'
c R |d }|r|z n
t z |d d = d S Nr )Empty)sltn
array_exprr s r# count_field_parse_actionz/counted_array.
.count_field_parse_actions s6
aDQ3qEGG3
aaaDDDr% Nc , t | d S r* )intr. s r# z counted_array..{ s AaD r% arrayLenT)call_during_tryz(len) z...)ForwardWordnumsset_parse_actionr r add_parse_actionr )r r' r& r1 r0 s ` @r#
counted_arrayr= G s R !GJ t**--.A.ABB,,.. Z 5t LLL j * *8c$ii+?%+G H HHr% c t fd}| |d dt | z S )a9 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::
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 |r_t | dk r
|d z d S t | }t d |D z d S t z d S )Nr r c 3 4 K | ]}t | V d S N)Literal).0tts r# zImatch_previous_literal..copy_token_to_repeater.. s( 77272;;777777r% )lenr as_listAndr+ )r, r- r. tflatreps r# copy_token_to_repeaterz6match_previous_literal..copy_token_to_repeater s{ 1vv{{qt !--s77777777777 577NNNNr% T
callDuringTry(prev) )r8 r< r r )r rK rJ s @r# match_previous_literalrO se ))C 0EEELLSYY&''' Jr% c t | }|z fd}| |d dt | z S )aW 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::
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 t | fd} |d d S )Nc t | }|k r%t | |d | d S )NzExpected {}, found{})r rG ParseExceptionr )r, r- r. theseTokens matchTokenss r# must_match_these_tokenszTmatch_previous_expr..copy_token_to_repeater..must_match_these_tokens sU "199;;//Kk))$q077 [QQ *)r% TrL )r rG r; )r, r- r. rV rU rJ s @r# rK z3match_previous_expr..copy_token_to_repeater sT qyy{{++ 4D IIIIIr% TrL rN )r8 r r< r r )r e2rK rJ s @r# match_previous_exprrX s ))C
BBJC
J
J
J
J
J 0EEELLSYY&''' Jr% T)useRegex asKeywordstrscaseless use_regex
as_keywordrY rZ c |p|}|o|}t |t r(t j r t dd |rd }d }|rt nt nd }d }|rt nt g }t | t r|
}n4t | t rt | }nt d |st S t d |D rd
} | t! | d z
k r|| }
t# || d z d D ]I\ } } || |
r || | z d z = n3 ||
| r!|| | z d z = | | | nJ| d z
} | t! | d z
k |r#|r t& j nd
}
t+ d
|D r3d d d |D }n d d |D }|rd | }t1 ||
d | }|r$d |D | fd |S # t& j $ r t dd Y nw xY wt9 fd|D d | S )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.
Parameters:
- ``strs`` - a string of space-delimited literals, or a collection of
string literals
- ``caseless`` - treat all literals as caseless - (default= ``False``)
- ``use_regex`` - as an optimization, will
generate a :class:`Regex` object; otherwise, will generate
a :class:`MatchFirst` object (if ``caseless=True`` or ``asKeyword=True``, or if
creating a :class:`Regex` raises an exception) - (default= ``True``)
- ``as_keyword`` - enforce :class:`Keyword`-style matching on the
generated expressions - (default= ``False``)
- ``asKeyword`` and ``useRegex`` are retained for pre-PEP8 compatibility,
but will be removed in a future release
Example::
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::
[['B', '=', '12'], ['AA', '=', '23'], ['B', '<=', 'AA'], ['AA', '>', '12']]
z`More than one string argument passed to one_of, pass choices as a list or space-delimited string )
stacklevelc V | | k S rA )upperabs r# r5 zone_of.. s qwwyyAGGII 5 r% c t | | S rA )rc
startswithrd s r# r5 zone_of.. s$ QWWYY 1 1!'')) < < r% c | |k S rA rd s r# r5 zone_of.. s
qAv r% c , | | S rA )rh rd s r# r5 zone_of.. s Q\\!__ r% z7Invalid argument to one_of, expected string or iterablec 3 < K | ]}t | d k V dS r NrF rC syms r# rE zone_of.. s,
+
+C3s88a<
+
+
+
+
+
+r% r r Nc 3 < K | ]}t | d k V dS rm rn ro s r# rE zone_of..& s, 44S3s88q=444444r% z[{}]r c 3 4 K | ]}t | V d S rA )r ro s r# rE zone_of..) s+ NNs 5c : :NNNNNNr% |c 3 > K | ]}t j | V d S rA )reescapero s r# rE zone_of.., s* B B3 # B B B B B Br% z
\b(?:{})\b)flagsz | c 8 i | ]}| |S rj lowerro s r#
zone_of..7 s" B B B3ciikk3 B B Br% c D |d S r* ry )r, r- r.
symbol_maps r# r5 zone_of..8 s Z!
5M r% z8Exception creating Regex for one_of, building MatchFirstc 3 . K | ]} | V d S rA rj )rC rp parseElementClasss r# rE zone_of..B s/ @@'',,@@@@@@r% ) r r r %warn_on_multiple_string_args_to_oneofwarningswarnCaselessKeywordCaselessLiteralKeywordrB splitIterablelist TypeErrorNoMatchanyrF enumerateinsertru
IGNORECASEallr joinRegexr r< error
MatchFirst)r[ r\ r] r^ rY rZ isequalmaskssymbolsicurjotherre_flagspattretr r} s @@r# one_ofr s R 'ZI%IH 8X&&
:
;
>55<</8 MOOo%%,,'0 =GGgG$!! S**,, D( # # St**QRRR yy
+
+7
+
+
+++
#g,,"""!*C %ga!egg&6 7 7
575#&& A *EU3&& A *NN1e,,,E
Q #g,,""" )18
q 44G44444
C }}GGNNgNNNNN xx B B' B B BBB
2$++D11H---66uzz'7J7JKKC
O C B' B B B
$$%M%M%M%MNNNJx MMJWX
@@@@@@@ @ @ I I
7 s 3C J +KKkeyvaluec Z 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::
text = "shape: SQUARE posn: upper left color: light blue texture: burlap"
attr_expr = (label + Suppress(':') + OneOrMore(data_word, stop_on=label).set_parse_action(' '.join))
print(attr_expr[1, ...].parse_string(text).dump())
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())
print(result['shape'])
print(result.shape) # object attribute access works too
print(result.as_dict())
prints::
[['shape', 'SQUARE'], ['posn', 'upper left'], ['color', 'light blue'], ['texture', 'burlap']]
- color: 'light blue'
- posn: 'upper left'
- shape: 'SQUARE'
- texture: 'burlap'
SQUARE
SQUARE
{'color': 'light blue', 'shape': 'SQUARE', 'posn': 'upper left', 'texture': 'burlap'}
)Dict OneOrMoreGroup)r r s r# dict_ofr G s' J %e ,,-- . ..r% )asString as_stringr c N |o|}t d }| }d|_ |d | z |d z }|rd }nd }| | | 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 astring 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::
src = "this is test bold text normal text "
for tag in ("b", "i"):
opener, closer = make_html_tags(tag)
patt = original_text_for(opener + SkipTo(closer) + closer)
print(patt.search_string(src)[0])
prints::
[' bold text ']
['text']
c |S rA rj )r, locr. s r# r5 z#original_text_for.. s 3 r% F_original_start
_original_endc * | |j |j S rA )r r r, r- r. s r# r5 z#original_text_for.. s a(9AO(K&L r% c r | | d | d g|d d < d S )Nr r popr s r# extractTextz&original_text_for..extractText s9 aee -..1G1GGHIAaaaDDDr% )r+ r; r callPreparse ignoreExprssuppress_warning Diagnostics)warn_ungrouped_named_tokens_in_collection)r r r locMarker endlocMarker matchExprr s r# original_text_forr o s D %IH(()>)>??I >>##L %L +,,t3ll?6S6SSI JLL J J J {+++ ,I
{ TUUU r% c H t | d S )zkHelper to undo pyparsing's default grouping of And expressions,
even if all but one are non-empty.
c | d S r* rj r4 s r# r5 zungroup.. s
1Q4 r% )TokenConverterr< )r s r# ungroupr s" $ 0 0 @ @@r% c t d }t |d | d z | d z S )a
(DEPRECATED - future code should use the Located class)
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 ```` characters, you
may want to call :class:`ParserElement.parseWithTabs`
Example::
wd = Word(alphas)
for match in locatedExpr(wd).searchString("ljsdf123lksdjjf123lkkjj1222"):
print(match)
prints::
[[0, 'ljsdf', 5]]
[[8, 'lksdjjf', 15]]
[[18, 'lkkjj', 23]]
c |S rA rj )ssllrD s r# r5 z locatedExpr.. s " r%
locn_startr locn_end)r+ r; r r leaveWhitespace)r locators r# locatedExprr st 6 gg&&'<'<==G
$w--
*',,..
(
(
*
*:
6
6 7 r% ())
ignoreExpropenerclosercontent ignore_exprr c ||k r|t k r|n|}| |k rt d |t | t rt |t rt | dk rt | dk r|Ut t
| t | |z t j z d z
d }n;t t | |z t j z
d z }n|pt t
| t | z t | z t t j d z
d }n{t t
t | t | z t t j d z
d }nt d t }|F|t t! | t# ||z |z z t! | z z }nB|t t! | t# ||z z t! | z z }| d
| |d |S ) a&
Helper method for defining nested lists enclosed in opening and
closing delimiters (``"("`` and ``")"`` are the default).
Parameters:
- ``opener`` - opening character for a nested list
(default= ``"("``); can also be a pyparsing expression
- ``closer`` - closing character for a nested list
(default= ``")"``); can also be a pyparsing expression
- ``content`` - expression for items within the nested lists
(default= ``None``)
- ``ignore_expr`` - expression for ignoring opening and closing delimiters
(default= :class:`quoted_string`)
- ``ignoreExpr`` - this pre-PEP8 argument 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::
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(delimited_list(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("%(name)s (%(type)s) args: %(args)s" % func)
prints::
is_odd (int) args: [['int', 'x']]
dec_to_hex (int) args: [['char', 'hchar']]
z.opening and closing strings cannot be the sameNr )exactc 6 | d S r* stripr4 s r# r5 z nested_expr..( 1 r% c 6 | d S r* r r4 s r# r5 z nested_expr.., r r% c 6 | d S r* r r4 s r# r5 z nested_expr..6 r r% c 6 | d S r* r r4 s r# r5 z nested_expr..> r r% zOopening and closing arguments must be strings if no content expression is givenznested z expression)
quoted_stringr r r rF r r
CharsNotInr DEFAULT_WHITE_CHARSr; emptyr rB r8 r r
ZeroOrMorer )r r r r r r s r# nested_exprr s T [ $.-//$A$A[[z
IJJJ fh ' ' % Jvx,H,H % 6{{a CKK1$4$4 ) %! 'K ( &-2S S&' '&'='=>> G $jjllZ -*KK. .&&'='=>> ?GG ) %! 'K &v . / &v . / ) )JRS T T T U '&'='=>> G &! $V__ , &v . / ( )JRS T T T U '&'='=>>
G a
))C V z*s*:W*D E E EQWHXHX X
hv&&C'M)B)BBXfEUEUUVVVLLLVVVVV<=== Jr% <>c
t | t r| t | | } n| j t t
t dz }|rt t }| | d z t t t |t d z |z z t ddg d d z |z }nt t t t" d
z }| | d z t t t | d t t d |z z z t ddg d d
z |z }t% t' d | z d
z d }| dz | fd |dd dd z dz }|_ |_ t7 | |_ ||fS )zRInternal helper to construct opening and closing tag expressions, given a tag name)r\ z_-:tag=/F)defaultr c |d dk S Nr r rj r s r# r5 z_makeTags..^ ! r% r )
exclude_charsc 6 | d S r* ry r4 s r# r5 z_makeTags..l s qtzz|| r% c |d dk S r rj r s r# r5 z_makeTags..r r r% zc | dd dd z | S )Nstartr : ) __setitem__r replacetitler r )r. resnames r# r5 z_makeTags..{ sY !-- bgggooc3 7 7 = = ? ? E E G GHH H!&&((
r% r r r r z) r r r namer9 alphas alphanumsdbl_quoted_stringr r;
remove_quotesr r r r r r
printablesr rB r r< r r r r r SkipTotag_body) tagStrxml suppress_LT suppress_GT tagAttrName tagAttrValueopenTagcloseTagr s @r# _makeTagsr N s &(## c'222+vy5 011K
(--//@@ OO fUmm
:eK(3--$?,$N O OPPQQ
R (c#w'''00AA++
%))++<<]KKd cO
O
O
fUmm
#445K5KLL hsmml :;;<
(c#w'''00AA++
wt}}v-3eDDDH Vg%&&&
x
S117799??AABBB hw !!
GKHL hhjj))G H r% tag_strc " t | d S )aP 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::
text = 'More info at the pyparsing wiki page | '
# 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 tag (like "href" shown here) are
# also accessible as named results
print(link.link_text, '->', link.href)
prints::
pyparsing -> https://github.com/pyparsing/pyparsing/wiki
Fr r s r# make_html_tagsr
s 0 We $ $$r% c " t | d S )zHelper 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 Wd # ##r% any_open_tag
any_close_tagz_:zany tagc @ i | ]\ }}| d | S );)rstrip)rC kvs r# r{ r{ s( KKKtq!!((3--KKKr% z &(?Prs z);zcommon HTML entityc @ t | j S )zRHelper parser action to replace common HTML entities with their special characters)_htmlEntityMapgetentityr4 s r# replace_html_entityr s ah ' ''r% c e Zd ZdZdZdS )OpAssocr r` N)__name__
__module__ __qualname__LEFTRIGHTrj r% r# r r s D
EEEr% r base_exprop_listlparrparc Z G d dt }d|_ t }t |t rt | }t |t rt | }t |t
rt |t
s| t
||z |z z }n | ||z |z z }t | D ]V\ }}|dz dd \ } }
} } t | t rt
| } |
dk rZt | t t f rt | dk rt d | \ }
}d
|
| }nd | }d |
cxk rdk sn t d
| t j t j fvrt d t | }| t j u r|
d k r) ||| z t
|| d z z }n|
dk rW| / ||| z |z t
|| |z d z z }nc |||z t
|d z }n=|
dk r@ |||
z |z |z |z t
|t) |
|z |z |z z z }n| t j u r|
d k rKt | t* st+ | } || j |z t
| |z z }n|
dk rX| . ||| z |z t
|| |z d z z }na |||z t
||d z z }n9|
dk r3 |||
z |z |z |z t
||
z |z |z |z z }| r._FBTc @ | j || |g fS rA )r try_parse)selfinstringr doActionss r# parseImplz%infix_notation.._FB.parseImpl( s# I # . . .7Nr% NT)r r r r, rj r% r# _FBr& ' s( r% r. z FollowedBy>rA N r` z@if numterms=3, opExpr must be a tuple or list of two expressionsz {}{} termz{} termr z6operator must be unary (1), binary (2), or ternary (3)z2operator must indicate right or left associativity)r .)r` .)
FollowedByr r8 r r r r r r r r tupler rF r r r r r r r r r r; setName)r r! r" r# r. r lastExprr operDefopExprarityrightLeftAssocpaopExpr1opExpr2 term_namethisExprr s r# infix_notationr> s b j
!CL
))C$ ~~$ ~~
tX & & 3:dH+E+E 3 uTCZ$%6 7 77 s
T 12 (( < <
7-4w->,C)~r fh ' ' ?"66v>>F A:: fudm44
F q8H8H V & GW#**7G< > > QRR R #II . .y 9 9 W\ ) )zz C6 1 2 2U8fVn;T5U5U U !% #Hv$5$@ A AE FX$5v#>>E E !II !$Hx$7 8 85&AQ;R;R RII! C w&1G;hF (Yw/AG/Kh/V%W%WWXX Y w}
,
,zz!&#.. ) [[F C h 6 7 7%@Q:R:R R !% #Hv$5$@ A AE FX$5v#>>E E !II !$Hx$7 8 85 8F#33< < !II ! C w&1G;hF (W,x7'AHLMM N /"udm,,
/* *B///**2...i(*33I>>>HC Jr% c dd fd fd}fd}fd}t t d }t t | z d }t | d } t | d }
|rSt t | |z t | t | z t | z z |
z } n\t t | t | t | z t | z z t |
z } |
fd
| fd | t t z | d S )
a
(DEPRECATED - use IndentedBlock class instead)
Helper method for defining space-delimited indentation blocks,
such as those used to define block statements in Python source code.
Parameters:
- ``blockStatementExpr`` - expression defining syntax of statement that
is repeated within the indented block
- ``indentStack`` - list created by caller to manage indentation stack
(multiple ``statementWithIndentedBlock`` expressions within a single
grammar should share a common ``indentStack``)
- ``indent`` - boolean indicating whether block must be indented beyond
the current level; set to ``False`` for block of left-most statements
(default= ``True``)
A valid block must contain at least one ``blockStatement``.
(Note that indentedBlock uses internal parse actions which make it
incompatible with packrat parsing.)
Example::
data = '''
def A(z):
A1
B = 100
G = A2
A2
A3
B
def BB(a,b,c):
BB1
def BBA():
bba1
bba2
bba3
C
D
def spam(x,y):
def eggs(z):
pass
'''
indentStack = [1]
stmt = Forward()
identifier = Word(alphas, alphanums)
funcDecl = ("def" + identifier + Group("(" + Opt(delimitedList(identifier)) + ")") + ":")
func_body = indentedBlock(stmt, indentStack)
funcDef = Group(funcDecl + func_body)
rvalue = Forward()
funcCall = Group(identifier + "(" + Opt(delimitedList(rvalue)) + ")")
rvalue << (funcCall | identifier | Word(nums))
assignment = Group(identifier + "=" + rvalue)
stmt << (funcDef | assignment | identifier)
module_body = stmt[1, ...]
parseTree = module_body.parseString(data)
parseTree.pprint()
prints::
[['def',
'A',
['(', 'z', ')'],
':',
[['A1'], [['B', '=', '100']], [['G', '=', 'A2']], ['A2'], ['A3']]],
'B',
['def',
'BB',
['(', 'a', 'b', 'c', ')'],
':',
[['BB1'], [['def', 'BBA', ['(', ')'], ':', [['bba1'], ['bba2'], ['bba3']]]]]],
'C',
'D',
['def',
'spam',
['(', 'x', 'y', ')'],
':',
[[['def', 'eggs', ['(', 'z', ')'], ':', [['pass']]]]]]]
Nc " d d d < d S Nrj )
backup_stacks indentStacks r# reset_stackz"indentedBlock..reset_stack s &r* AAAr% c |t | k rd S t || }|d k r.|d k rt | |d t | |d d S )NrB zillegal nestingznot a peer entry)rF colrS r, r- r. curColrD s r# checkPeerIndentz&indentedBlock..checkPeerIndent sp A;; FQ [_ $ $ B''$Q+<=== A'9:: : % $r% c t || }|d k r | d S t | |d )NrB znot a subentry)rG appendrS rH s r# checkSubIndentz%indentedBlock..checkSubIndent sL Q KO # # v & & & & & A'788 8r% c |t | k rd S t || }r|v st | |d |d k r d S d S )Nznot an unindentrB )rF rG rS r rH s r#
checkUnindentz$indentedBlock..checkUnindent sv A;; FQ :+ 5 5 A'899 9 KO # # OO $ #r% z INDENTr UNINDENTc : r d od nd S rA r )rC s r# r5 z indentedBlock.. s" -I
!!"%%.$T r% c S rA rj )re rf cdrE s r# r5 z indentedBlock.. s
kkmm r% zindented block)rL r LineEndset_whitespace_charssuppressr+ r; r r r r< set_fail_actionignorer )
blockStatementExprrD indentrC rJ rM rO NLrP PEERUNDENTsmExprrE s
` ` @r#
indentedBlockra { sX l QQQ (((+ + + + + +; ; ; ; ;9 9 9 9 9
79911%88AACC D DBgg00 @@@
J
J8
T
TF 77 # #O 4 4 = =b A AD
WW
%
%m
4
4
=
=j
I
IF
GG
u%7 8 883r77BCC
D
GGu%7 8 883r77BCC
D&kk
IIII ;;;;<<< g 1222 ??+ , ,,r% z/\*(?:[^*]|\*(?!/))*z*/zC style commentzz HTML commentz.*z rest of linez//(?:\\\n|[^\n])*z
// commentzC++ style commentz#.*zPython style commentc < g | ]}t |t |S rj )r r )rC r s r#
rc % s7 ' ' '
*Q
">">'' ' 'r% _builtin_exprs)r FNNrA )FTFr- )\
html.entitieshtmlru typingr r coreutilr r r Unionr r boolOptionalr3 r$ r= rO rX r r r r r r r r r r Tupler
r __annotations__r9 r r r r
r entitieshtml5itemsr r r common_html_entityr Enumr InfixNotationOperatorArgType ParseActionInfixNotationOperatorSpecListr> ra r c_style_comment html_commentleave_whitespace rest_of_linedbl_slash_commentcpp_style_commentjava_style_commentpython_style_commentvarsvaluesrd
delimitedList countedArraymatchPreviousLiteralmatchPreviousExproneOfdictOforiginalTextFor
nestedExpr makeHTMLTags makeXMLTags
anyOpenTag anyCloseTagcommonHTMLEntityreplaceHTMLEntityopAssoc
infixNotation
cStyleComment htmlComment
restOfLinedblSlashCommentcppStyleCommentjavaStyleCommentpythonStyleCommentrj r% r# r s&
> > > > > > > > > > (+ $ $ 64 "'64 64 64
]"
#64 m# $64 64
64
64 64 64 64 64 64v 049I /3 9I 9I 9I
9Iom,9I _]
+ 9I
9I 9I 9I 9Ix = B!m !
! ! ! !L | | | |
$c)
*|| | |
| | | | | |~%/ %/} %/ %/ %/ %/ %/R ,02EI2 2 2
2$(2>B22 2 2 2jA- AM A A A A m
H ),(+.2!. } !.
} } } #}$ %} #}$ %} _]
+} }
} } } } }@ (0x}}((3-- 7 7 7 7 t%
3
%
&%
=- '(% % % %6$
3
%
&$
=- '($ $ $ $ ,nDT!""++I66 m LKt}/B/H/H/J/JKKKU>CHH^,D,DDtKLLUU
( ( (
d
%3eM3$6 7}c?Q9R RSS " $ $ &
$
$ '/hsmm&.hsmm b b b
+
,b ]"
#b ]"
# b
b b b bJ ;?b L- L- L- L-` '%% 7884?@@II $u'((11.AA &uU||,,..77GG E.//88 FF 1G E
!""T),==
( P& $ uV}}--.DEE 0
' 'tvv}}' ' ']#
- ' #
&
K% '
##% ) r%