
    xi                        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       d/var/www/html/chatbot/card-advisor-bot/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 48I
 !!--3 .eejj%--89
 $$++E2 (@(@A$004I  ((//6&&u-." $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[     )//!$uzz5==&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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 |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

dENN+	TZZ0G	 KF99D 
 fenn---""""&))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	<zzEMM)	<7;EJJ7G	<		<
**u}}
$
ZZ%--D
**u}}
$
5::%t+,r   