Ë
    òU.j  ã                   óž  — d dl mZmZmZmZ ddlmZ dej                  dej                  fd„Zdej                  ej                  z  deej                     dd	fd
„Zdej                  ej                  z  dej                  ej                  z  fd„Zdej                  ej                  z  deej                  ej                  z  ef   fd„Zy	)é    )ÚAnyÚListÚTupleÚcasté   )Úc_astÚswitch_nodeÚreturnc                 óv  — t        | t        j                  «      sJ ‚t        | j                  t        j                  «      s| S t        j                  g | j                  j
                  «      }d}| j                  j                  xs g D ]¦  }t        |t        j                  t        j                  f«      rA|j                  j                  |«       t        ||j                  «       |j                  d   }Œn|€|j                  j                  |«       ŒŒ|j                  j                  |«       Œ¨ || _        | S )a3  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éÿÿÿÿ)Ú
isinstancer   ÚSwitchÚstmtÚCompoundÚcoordÚblock_itemsÚCaseÚDefaultÚappendÚ_extract_nested_caseÚstmts)r	   Únew_compoundÚ	last_caseÚchilds       úZC:\xampp\htdocs\tradingbinance\backend\.venv\Lib\site-packages\pycparser/ast_transforms.pyÚfix_switch_casesr      s  € ôf �k¤5§<¡<Ô0Ð0Ð0Ü�k×&Ñ&¬¯©Ô7ØÐô —>‘> " k×&6Ñ&6×&<Ñ&<Ó=€Lð 48€Ið
 ×!Ñ!×-Ñ-Ò3°Ò3ˆÜ�eœeŸj™j¬%¯-©-Ð8Ô9ð
 ×$Ñ$×+Ñ+¨EÔ2Ü  ¨×(@Ñ(@ÔAØ$×0Ñ0°Ñ4‰Ið Ð Ø×(Ñ(×/Ñ/°Õ6à—‘×&Ñ& uÕ-ð 4ð" $€KÔØÐó    Ú	case_nodeÚ
stmts_listNc                 óþ   — t        | j                  d   t        j                  t        j                  f«      rF| j                  j                  «       }|j                  |«       t        t        t        |«      |«       yy)z{Recursively extract consecutive Case statements that are made nested
    by the parser and add them to the stmts_list.
    r   N)
r   r   r   r   r   Úpopr   r   r   r   )r   r   Únesteds      r   r   r   e   s[   € ô �)—/‘/ !Ñ$¤u§z¡z´5·=±=Ð&AÔBØ—‘×$Ñ$Ó&ˆØ×Ñ˜&Ô!ÜœT¤# vÓ.°
Õ;ð Cr   Údeclc                 ó~  — 	 t        | «      \  } }|snŒ| }t        |t        j                  «      s(	 |j                  }t        |t        j                  «      sŒ(d|j                  v r)d| j                  vr| j                  j                  d«       |j                  €| j                  |_        | S # t
        $ r | cY S w xY w)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.
    Ú_Atomic)
Ú_fix_atomic_specifiers_oncer   r   ÚTypeDeclÚtypeÚAttributeErrorÚqualsr   ÚdeclnameÚname)r#   ÚfoundÚtyps      r   Úfix_atomic_specifiersr/   q   s®   € ð Ü1°$Ó7‰ˆˆeÙØð ð €CÜ˜œeŸn™nÔ-ð	Ø—(‘(ˆCô ˜œeŸn™nÕ-ð
 �C—I‘IÑ )°4·:±:Ñ"=Ø�
‰
×Ñ˜)Ô$Ø
‡|�|ÐØ—y‘yˆŒà€Køô ò 	ØŠKð	ús   ±B. Â.B<Â;B<c                 óÆ  — | }d}| j                   }|�=t        |t        j                  «      rd|j                  v rn	 |}|}|j                   }|�Œ=t        |t        j                  «      sJ ‚|€J ‚|j                   t        t        |«      _         d|j                   j                  vr%|j                   j                  j                  d«       | dfS # t
        $ r | dfcY S w xY w)z~Performs one 'fix' round of atomic specifiers.
    Returns (modified_decl, found) where found is True iff a fix was made.
    Nr%   FT)
r(   r   r   ÚTypenamer*   r)   r'   r   r   r   )r#   ÚparentÚgrandparentÚnodes       r   r&   r&   “   sÛ   € ð €FØ€KØ—	‘	€DØ
Ð
Ü�dœEŸN™NÔ+°	¸T¿Z¹ZÑ0GØð	Ø ˆKØˆFØ—9‘9ˆDð Ñ
ô �fœeŸn™nÔ-Ð-Ð-ØÐ"Ð"Ð"Ø"&§)¡)„DŒˆkÓÔØ˜Ÿ	™	Ÿ™Ñ'Ø�	‰	�‰×Ñ˜yÔ)Ø�ˆ:Ðøô ò 	ð ˜�;Òð		ús   ½C ÃC ÃC )Útypingr   r   r   r   Ú r   r   r   r   r   ÚNoder   ÚDeclÚTypedefr/   Úboolr&   © r   r   Ú<module>r<      sË   ð÷ *Ó )å ðS %§,¡,ð S°5·<±<ó Sðl	<Ø�z‰z˜EŸM™MÑ)ð	<Ø7;¸E¿J¹JÑ7Gð	<à	ó	<ðØ
�*‰*�u—}‘}Ñ
$ðà
‡Z�Z�%—-‘-ÑóðDØ
�*‰*�u—}‘}Ñ
$ðà
ˆ5�:‰:˜Ÿ™Ñ% tÐ+Ñ,ôr   