ServerSync/lib/pycparser/__pycache__/ast_transforms.cpython-314.pyc

+
t<10>i<00><00>Z<00>^R
IH
t
HtHtHt^
RIHtRRltRRltRRlt	R	R
lt
R#)<0C>)<04>Any<6E>List<73>Tuple<6C>cast)
<01>c_astc

<00>X<00>V^8<>dQ
h
R
\PR\P/#)<03><00>switch_node<64>return)r<00>Switch)
<01>formats
"<22>?/tmp/pip-target-zhdecbcm/lib/python/pycparser/ast_transforms.py<70>__annotate__rs&<00><00>S

<17>S

<17>%<25>,<2C>,<2C>S

<17>5<EFBFBD><<3C><<3C>S

<17>c
<04><><00>\
V\P4'gQh
\
VP\P4'gV#\P!.VPP
4p
R
pVPP;
'g.F<>p\
V\P\P34'dFV
PPV4
\W1P4V
PR,pKxVfV
PPV4
K<>VPPV4
K<>	WnV#)a<>The 'case' statements in a 'switch' come out of parsing with one
child node, so subsequent statements are just tucked to the parent
Compound. Additionally, consecutive (fall-through) case statements
come out messy. This is a peculiarity of the C grammar. The following:

    switch (myvar) {
        case 10:
            k = 10;
            p = k + 1;
            return 10;
        case 20:
        case 30:
            return 20;
        default:
            break;
    }

Creates this tree (pseudo-dump):

    Switch
        ID: myvar
        Compound:
            Case 10:
                k = 10
            p = k + 1
            return 10
            Case 20:
                Case 30:
                    return 20
            Default:
                break

The goal of this transform is to fix this mess, turning it into the
following:

    Switch
        ID: myvar
        Compound:
            Case 10:
                k = 10
                p = k + 1
                return 10
            Case 20:
            Case 30:
                return 20
            Default:
                break

A fixed AST node is returned. The argument may be modified.
N<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>)<0C>
isinstancerr<00>stmt<6D>Compound<6E>coord<72>block_items<6D>Case<73>Default<6C>append<6E>_extract_nested_case<73>stmts)r
<00>new_compound<6E>	last_case<73>childs&   r<00>fix_switch_casesr s
<00><00>f
<16>k<EFBFBD>5<EFBFBD><<3C><<3C>0<>0<>0<>0<><15>k<EFBFBD>&<26>&<26><05><0E><0E>7<>7<><1A><1A><19>><3E>><3E>"<22>k<EFBFBD>&6<>&6<>&<<3C>&<<3C>=<3D>L<EFBFBD>48<34>I<EFBFBD>
<1D>!<21>!<21>-<2D>-<2D>3<>3<><12>3<><05><15>e<EFBFBD>e<EFBFBD>j<EFBFBD>j<EFBFBD>%<25>-<2D>-<2D>8<>9<>9<>

<19>$<24>$<24>+<2B>+<2B>E<EFBFBD>2<> <20><15>(@<40>(@<40>A<>$<24>0<>0<><12>4<>I<EFBFBD><19> <20><1C>(<28>(<28>/<2F>/<2F><05>6<><19><0F><0F>&<26>&<26>u<EFBFBD>-<2D>4<>"$<24><14><16>rc

<00><><00>V^8<>dQ
h
R
\P\P,R\\P,RR/#)r	<00>	case_node<64>
stmts_listrN)rrrr<00>Node)
r
s
"rrres:<00><00>	
<<3C>	
<<3C><14>z<EFBFBD>z<EFBFBD>E<EFBFBD>M<EFBFBD>M<EFBFBD>)<29>	
<<3C>7;<3B>E<EFBFBD>J<EFBFBD>J<EFBFBD>7G<37>	
<<3C>	<09>	
<rc<04>
<00>\
VP^,\P\P34'dHVPP4pV
P
V4
\\\V4V
4R
#R
#)zsRecursively extract consecutive Case statements that are made nested
by the parser and add them to the stmts_list.
N)
rrrrr<00>poprrrr)r"r#<00>nesteds&& rrres^<00><00><12>)<29>/<2F>/<2F>!<21>$<24>u<EFBFBD>z<EFBFBD>z<EFBFBD>5<EFBFBD>=<3D>=<3D>&A<>B<>B<><1A><1F><1F>$<24>$<24>&<26><06><12><19><19>&<26>!<21><1C>T<EFBFBD>#<23>v<EFBFBD>.<2E>
<EFBFBD>;<3B>C
rc

<00><><00>V^8<>dQ
h
R
\P\P,R\P\P,/#<00>r	<00>declr)r<00>Decl<63>Typedef)
r
s
"rrrqs6<00><00>
<10>
<10>
<0F>*<2A>*<2A>u<EFBFBD>}<7D>}<7D>
$<24>
<10>
<EFBFBD>Z<EFBFBD>Z<EFBFBD>%<25>-<2D>-<2D><1F>
rc
<04>x
<00>\
V4
wr
V
'dKTp\T\P4'gTPpK/R
TP9d-R
TP9
dTPPR
4
TPfTPTnT# \
dTu#i;i
)a&
Atomic specifiers like _Atomic(type) are unusually structured,
conferring a qualifier upon the contained type.

This function fixes a decl with atomic specifiers to have a sane AST
structure, by removing spurious Typename->TypeDecl pairs and attaching
the _Atomic qualifier in the right place.
<EFBFBD>_Atomic)
<EFBFBD>_fix_atomic_specifiers_oncerr<00>TypeDecl<63>type<70>AttributeError<6F>qualsr<00>declname<6D>name)r*<00>found<6E>typs&  r<00>fix_atomic_specifiersr8qs<><00><00><0F>1<>$<24>7<><0B><04><14>u<EFBFBD><11>
<14>C<EFBFBD><18><13>e<EFBFBD>n<EFBFBD>n<EFBFBD>-<2D>-<2D>	<18><15>(<28>(<28>C<EFBFBD><11>C<EFBFBD>I<EFBFBD>I<EFBFBD><1D>)<29>4<EFBFBD>:<3A>:<3A>"=<3D><0C>
<EFBFBD>
<EFBFBD><19><19>)<29>$<24>
<EFBFBD>|<7C>|<7C><1B><1B>y<EFBFBD>y<EFBFBD><03><0C><0F>K<EFBFBD><4B><1E>
	<18><17>K<EFBFBD>
	<18>s<00>B)<00>)
B9<03>8
B9c

<00><><00>V^8<>dQ
h
R
\P\P,R\\P\P,\3,/#r))rr+r,r<00>bool)
r
s
"rrr<00>s@<00><00>
<16>
<16>
<0F>*<2A>*<2A>u<EFBFBD>}<7D>}<7D>
$<24>
<16>
<EFBFBD>5<EFBFBD>:<3A>:<3A><05>
<0A>
<0A>%<25>t<EFBFBD>+<2B>,<2C>
rc
<04><>
<00>Tp
R
pVPpVeF\V\P4'dRVP9dMT
pTp
VPpKI\V
\P4'gQh
VfQh
VP\\V4nRVPP9
d&VPPPR4
VR3# \
dTR3u#i;i
)zvPerforms one 'fix' round of atomic specifiers.
Returns (modified_decl, found) where found is True iff a fix was made.
Nr.FT)
r1rr<00>Typenamer3r2r0rrr)r*<00>parent<6E>grandparent<6E>nodes&   rr/r/<00>s<><00><00><17>F<EFBFBD><1B>K<EFBFBD><14>	<09>	<09>D<EFBFBD>
<0E>
<1A><15>d<EFBFBD>E<EFBFBD>N<EFBFBD>N<EFBFBD>+<2B>+<2B>	<09>T<EFBFBD>Z<EFBFBD>Z<EFBFBD>0G<30><11>	<1F> <20>K<EFBFBD><19>F<EFBFBD><17>9<EFBFBD>9<EFBFBD>D<EFBFBD><16>f<EFBFBD>e<EFBFBD>n<EFBFBD>n<EFBFBD>-<2D>-<2D>-<2D>-<2D><16>"<22>"<22>"<22>"&<26>)<29>)<29>D<EFBFBD><13>k<EFBFBD><1A><1F><10><04>	<09>	<09><0F><0F>'<27><0C>	<09>	<09><0F><0F><1E><1E>y<EFBFBD>)<29><0F><14>:<3A><15><><1E>	<1F><18><15>;<3B><1E>		<1F>s<00>C%<00>%C7<03>6
C7N)<0B>typingrrrr<00>rr rr8r/<00>rr<00><module>rC
s'<00>


<01>
*<2A>)<29><13>S

<17>l	
<<3C>
<10>D

r