
    Yh;                     (    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       i/var/www/django-portfolio.reubendavern.link/venv/lib/python3.12/site-packages/pycparser/ast_transforms.pyfix_switch_casesr      s   f k5<<000k&&7 >>"k&6&6&<&<=L I
 ""..4" .eejj%--89
 $$++E2 (@(@A$004I  ((//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     )//!$uzz5==&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enn-	((C enn-
 CII)4::"=

)$
||yy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99D

dENN+	TZZ0G	 KF99D 
 fenn---yyK		'		y):  	 ;		s   B> >CCN) r   r   r   r)   r    r   r   <module>r1      s!    Sl9@r   