Ë
    ±éäg;  ã                   ó(   — d dl mZ d„ Zd„ Zd„ Zd„ Zy)é   )Úc_astc                 ó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 )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éÿÿÿÿ)Ú
isinstancer   ÚSwitchÚstmtÚCompoundÚcoordÚblock_itemsÚCaseÚDefaultÚappendÚ_extract_nested_caseÚstmts)Úswitch_nodeÚnew_compoundÚ	last_caseÚchilds       úV/var/www/skyplay_api_hub/venv/lib/python3.12/site-packages/pycparser/ast_transforms.pyÚfix_switch_casesr      s  € ôf �k¤5§<¡<Ô0Ð0Ð0Ü�k×&Ñ&¬¯©Ô7ØÐô —>‘> " k×&6Ñ&6×&<Ñ&<Ó=€Lð €Ið
 ×"Ñ"×.Ñ.Ò4°"ò .ˆÜ�eœeŸj™j¬%¯-©-Ð8Ô9ð
 ×$Ñ$×+Ñ+¨EÔ2Ü  ¨×(@Ñ(@ÔAØ$×0Ñ0°Ñ4‰Ið Ð Ø×(Ñ(×/Ñ/°Õ6à—‘×&Ñ& uÕ-ð.ð" $€KÔØÐó    c                 óä   — t        | j                  d   t        j                  t        j                  f«      r9|j                  | j                  j                  «       «       t        |d   |«       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   r   Úpopr   )Ú	case_nodeÚ
stmts_lists     r   r   r   c   sS   € ô �)—/‘/ !Ñ$¤u§z¡z´5·=±=Ð&AÔBØ×Ñ˜)Ÿ/™/×-Ñ-Ó/Ô0Ü˜Z¨™^¨ZÕ8ð Cr   c                 ó~  — 	 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)aK   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)ÚdeclÚfoundÚtyps      r   Úfix_atomic_specifiersr)   l   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                   |_         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&   ÚparentÚgrandparentÚnodes       r   r   r   Œ   sÈ   € ð €FØ€KØ�9‰9€DØ
Ð
Ü�dœEŸN™NÔ+°	¸T¿Z¹ZÑ0GØð	Ø ˆKØˆFØ—9‘9ˆDð Ñ
ô �fœeŸn™nÔ-Ð-Ð-Ø—y‘y€KÔØ˜Ÿ	™	Ÿ™Ñ'Ø�	‰	�‰×Ñ˜yÔ)Ø�ˆ:Ðøô ò 	ð ˜�;Òð		ús   ½B> Â>CÃCN)Ú r   r   r   r)   r   © r   r   ú<module>r1      s!   ðõ òSòl9òó@r   