
    #	h;                     (    S SK Jr  S rS rS rS rg)   )c_astc                    [        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)switch_nodenew_compound	last_casechilds       J/var/www/html/env/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 I
 ""..4"4eejj%--899
 $$++E2 (@(@A$004I  ((//6&&u- 5" $    c                     [        U R                  S   [        R                  [        R                  45      (       a9  UR                  U R                  R                  5       5        [        US   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   r   popr   )	case_node
stmts_lists     r   r   r   c   sV     )//!$uzz5==&ABB)//--/0Z^Z8 Cr   c                     [        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)declfoundtyps      r   fix_atomic_specifiersr)   l   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R                   U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&   parentgrandparentnodes       r   r   r      s     FK99D

dENN++	TZZ0G	 KF99D 
 fenn----yyK		'		y):  	 ;		s   C C C N) r   r   r   r)   r    r   r   <module>r1      s!    Sl9@r   