
    Mh;                     *    d dl mZ d Zd Zd Zd ZdS )   )c_astc                 &   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 )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       X/var/www/html/test/jupyter/venv/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 I
 ".4" . .eej%-899 	.
 $++E222 (@AAA$04II  (//6666&&u----#K    c                     t          | j        d         t          j        t          j        f          rD|                    | j                                                   t          |d         |           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   r   popr   )	case_node
stmts_lists     r   r   r   c   sl     )/!$uz5=&ABB 9)/--//000Z^Z888889 9r   c                 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 )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.
    T_Atomic)
_fix_atomic_specifiers_oncer   r   TypeDecltypeAttributeErrorqualsr   declnamename)declfoundtyps      r   fix_atomic_specifiersr)   l   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         |_         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&   parentgrandparentnodes       r   r   r      s     FK9D

dEN++ 		TZ0G0G	 KF9DD 	 	 	 ;		 
 fen-----yK	''	y))):s   ? AAN) r   r   r   r)   r    r   r   <module>r1      sd         S S Sl9 9 9  @    r   