
    Pi                     *   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d	S )    )AnyListTuplecast   )c_astswitch_nodereturnc                 &   t          | t          j                  sJ t          | j        t          j                  s| S t          j        g | j        j                  }d}| j        j        pg D ]}t          |t          j        t          j        f          r=|j        	                    |           t          ||j                   |j        d         }e||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       l/home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/lib/python3.11/site-packages/pycparser/ast_transforms.pyfix_switch_casesr      s   f k5<00000k&77  >"k&6&<==L 48I
 !-3 . .eej%-899 	.
 $++E222 (@AAA$04II  (//6666&&u----#K    	case_node
stmts_listNc                    t          | j        d         t          j        t          j        f          rS| j                                        }|                    |           t          t          t          |          |           dS dS )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   sw     )/!$uz5=&ABB <$$&&&!!!T#v..
;;;;;< <r   declc                 T   	 t          |           \  } }|sn| }t          |t          j                  s5	 |j        }n# t
          $ r | cY S w xY wt          |t          j                  5d|j        v r#d| j        vr| j                            d           |j        | j	        |_        | S )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.
    T_Atomic)
_fix_atomic_specifiers_oncer   r   TypeDecltypeAttributeErrorqualsr   declnamename)r#   foundtyps      r   fix_atomic_specifiersr/   q   s    1$77e 	 Cen-- 	(CC 	 	 	KKK	 en-- 
 CI)4:"="=
)$$$
|yKs   = AAc                    | }d}| j         }|Gt          |t          j                  r
d|j        v rn#	 |}|}|j         }n# t
          $ r | dfcY S w xY w|Gt          |t          j                  sJ |J |j         t          t          |          _         d|j         j        vr|j         j        	                    d           | dfS )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

dEN++ 		TZ0G0G	 KF9DD 	 	 	 ;		 
 fen-----""""&)Dk	''	y))):s   ? AA)typingr   r   r   r    r   r   r   r   r   Noder   DeclTypedefr/   boolr&    r   r   <module>r<      s'   * ) ) ) ) ) ) ) ) ) ) )      S%, S5< S S S Sl	<zEM)	<7;EJ7G	<		< 	< 	< 	<
*u}
$
Z%-   D
*u}
$
5:%t+,     r   