
     
zi                        S SK JrJrJrJr  SSKJr  S\R                  S\R                  4S jrS\R                  \R                  -  S\\R                     SS	4S
 jrS\R                  \R                  -  S\R                  \R                  -  4S jrS\R                  \R                  -  S\\R                  \R                  -  \4   4S jrg	)    )AnyListTuplecast   )c_astswitch_nodereturnc                    [        U [        R                  5      (       d   e[        U R                  [        R                  5      (       d  U $ [        R                  " / U R                  R
                  5      nSnU R                  R                  =(       d    /  H  n[        U[        R                  [        R                  45      (       aA  UR                  R                  U5        [        X1R                  5        UR                  S   nMs  Uc  UR                  R                  U5        M  UR                  R                  U5        M     Xl        U $ )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)r	   new_compound	last_casechilds       K/var/www/html/venv/lib/python3.13/site-packages/pycparser/ast_transforms.pyfix_switch_casesr      s   f k5<<0000k&&77 >>"k&6&6&<&<=L 48I
 !!--33eejj%--899
 $$++E2 (@(@A$004I  ((//6&&u- 4" $    	case_node
stmts_listNc                    [        U R                  S   [        R                  [        R                  45      (       aF  U R                  R                  5       nUR                  U5        [        [        [        U5      U5        gg)zsRecursively 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^     )//!$uzz5==&ABB$$&&!T#v.
; Cr   declc                     [        U 5      u  pU(       d  OM  U n[        U[        R                  5      (       d.   UR                  n[        U[        R                  5      (       d  M.  SUR                  ;   a+  SU R                  ;  a  U R                  R                  S5        UR                  c  U R                  Ul        U $ ! [
         a    U s $ f = f)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  Cenn--	((C enn--
 CII)4::"=

)$
||yyK  	K	s   C CCc                    U nSnU R                   nUbF  [        U[        R                  5      (       a  SUR                  ;   a  O UnUnUR                   nUb  MF  [        U[        R                  5      (       d   eUc   eUR                   [        [        U5      l         SUR                   R                  ;  a%  UR                   R                  R                  S5        U S4$ ! [
         a    U S4s $ f = f)zvPerforms 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

dENN++	TZZ0G	 KF99D 
 fenn----""""&))Dk		'		y):  	 ;		s   C" "C32C3)typingr   r   r   r    r   r   r   r   r   Noder   DeclTypedefr/   boolr&    r   r   <module>r<      s    * ) S%,, S5<< Sl	<zzEMM)	<7;EJJ7G	<		<
**u}}
$
ZZ%--D
**u}}
$
5::%t+,r   