HEX

File: //opt/alt/python37/lib/python3.7/site-packages/pycparser/__pycache__/c_generator.cpython-37.pyc
B

��flE�@s ddlmZGdd�de�ZdS)�)�c_astc@s6eZdZdZd�dd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdddddddddddd d d!d!d"d"d"d#�Zd$d%�Zd&d'�Zd(d)�Zd*d+�Zd�d,d-�Zd.d/�Zd0d1�Zd2d3�Zd4d5�Zd6d7�Zd8d9�Zd:d;�Zd<d=�Zd>d?�Zd@dA�ZdBdC�ZdDdE�Z dFdG�Z!dHdI�Z"dJdK�Z#dLdM�Z$dNdO�Z%dPdQ�Z&dRdS�Z'dTdU�Z(dVdW�Z)dXdY�Z*dZd[�Z+d\d]�Z,d^d_�Z-d`da�Z.dbdc�Z/ddde�Z0dfdg�Z1dhdi�Z2djdk�Z3dldm�Z4dndo�Z5dpdq�Z6drds�Z7dtdu�Z8dvdw�Z9dxdy�Z:dzd{�Z;d|d}�Z<d�d~d�Z=d�d��Z>gd�fd�d��Z?d�d��Z@d�d��ZAd�d��ZBd�S)��
CGeneratorz� Uses the same visitor pattern as c_ast.NodeVisitor, but modified to
        return a value from each visit method, using string accumulation in
        generic_visit.
    FcCsd|_||_dS)z� Constructs C-code generator

            reduce_parentheses:
                if True, eliminates needless parentheses on binary operators
        �N)�indent_level�reduce_parentheses)�selfr�r�F/opt/alt/python37/lib/python3.7/site-packages/pycparser/c_generator.py�__init__szCGenerator.__init__cCs
d|jS)N� )r)rrrr	�_make_indentszCGenerator._make_indentcCsd|jj}t|||j�|�S)NZvisit_)�	__class__�__name__�getattr�
generic_visit)r�node�methodrrr	�visitszCGenerator.visitcs,|dkrdSd��fdd�|��D��SdS)N�c3s|]\}}��|�VqdS)N)r)�.0Zc_name�c)rrr	�	<genexpr>'sz+CGenerator.generic_visit.<locals>.<genexpr>)�join�children)rrr)rr	r#szCGenerator.generic_visitcCs|jS)N)�value)r�nrrr	�visit_Constant)szCGenerator.visit_ConstantcCs|jS)N)�name)rrrrr	�visit_ID,szCGenerator.visit_IDcCsd}|jr|d|j7}|S)Nz#pragmar)�string)rr�retrrr	�visit_Pragma/szCGenerator.visit_PragmacCs$|�|j�}|d|�|j�dS)N�[�])�_parenthesize_unless_simplerrZ	subscript)rrZarrrefrrr	�visit_ArrayRef5szCGenerator.visit_ArrayRefcCs"|�|j�}||j|�|j�S)N)r$r�typer�field)rrZsrefrrr	�visit_StructRef9szCGenerator.visit_StructRefcCs$|�|j�}|d|�|j�dS)N�(�))r$rr�args)rrZfrefrrr	�visit_FuncCall=szCGenerator.visit_FuncCallcCs\|jdkrd|�|j�S|�|j�}|jdkr8d|S|jdkrJd|Sd|j|fSdS)N�sizeofz
sizeof(%s)zp++z%s++zp--z%s--z%s%s)�opr�exprr$)rrZoperandrrr	�
visit_UnaryOpAs


zCGenerator.visit_UnaryOprr��������	)z||z&&�|�^�&z==z!=�>z>=�<z<=z>>z<<�+�-�*�/�%cs@���j��fdd��}���j��fdd��}d|�j|fS)Ncs6��|�p2�jo2t|tj�o2�j|j�j�jkS)N)�_is_simple_noder�
isinstancer�BinaryOp�precedence_mapr.)�d)rrrr	�<lambda>ks
z+CGenerator.visit_BinaryOp.<locals>.<lambda>cs6��|�p2�jo2t|tj�o2�j|j�j�jkS)N)rCrrDrrErFr.)rG)rrrr	rHws
z%s %s %s)�_parenthesize_if�left�rightr.)rrZlval_str�rval_strr)rrr	�visit_BinaryOp_s

zCGenerator.visit_BinaryOpcCs*|�|jdd��}d|�|j�|j|fS)NcSst|tj�S)N)rDr�
Assignment)rrrr	rH�z-CGenerator.visit_Assignment.<locals>.<lambda>z%s %s %s)rIZrvaluerZlvaluer.)rrrLrrr	�visit_Assignment|s
zCGenerator.visit_AssignmentcCsd�|j�S)Nr)r�names)rrrrr	�visit_IdentifierType�szCGenerator.visit_IdentifierTypecCsJt|tj�rd|�|�dSt|tj�r<d|�|�dS|�|�SdS)N�{�}r)r*)rDrZInitListr�ExprList)rrrrr	�_visit_expr�s
zCGenerator._visit_exprcCsL|r
|jn|�|�}|jr.|d|�|j�7}|jrH|d|�|j�7}|S)Nz : z = )r�_generate_declZbitsizer�initrV)rr�no_type�srrr	�
visit_Decl�szCGenerator.visit_DeclcsL��|jd�}t|j�dkrH|dd��fdd�|jdd�D��7}|S)Nrrz, c3s|]}�j|dd�VqdS)T)rYN)r[)r�decl)rrr	r�sz,CGenerator.visit_DeclList.<locals>.<genexpr>)r�decls�lenr)rrrZr)rr	�visit_DeclList�s
zCGenerator.visit_DeclListcCs2d}|jr|d�|j�d7}||�|j�7}|S)Nrr)�storager�_generate_typer&)rrrZrrr	�
visit_Typedef�s
zCGenerator.visit_TypedefcCs,d|j|jdd�d}|d|�|j�S)Nr)F)�
emit_declnamer*r)raZto_typer$r/)rrrZrrr	�
visit_Cast�szCGenerator.visit_CastcCs.g}x|jD]}|�|�|��qWd�|�S)Nz, )�exprs�appendrVr)rr�visited_subexprsr/rrr	�visit_ExprList�szCGenerator.visit_ExprListcCs.g}x|jD]}|�|�|��qWd�|�S)Nz, )rerfrVr)rrrgr/rrr	�visit_InitList�szCGenerator.visit_InitListcCs|j|dd�S)N�enum)r)�_generate_struct_union_enum)rrrrr	�
visit_Enum�szCGenerator.visit_EnumcCsd�|�|j��S)Nz_Alignas({}))�formatr�	alignment)rrrrr	�
visit_Alignas�szCGenerator.visit_AlignascCs<|jsdj|��|jd�Sdj|��|j|�|j�d�SdS)Nz{indent}{name},
)�indentrz{indent}{name} = {value},
)rprr)rrmrrr)rrrrr	�visit_Enumerator�s
zCGenerator.visit_Enumeratorcsj��|j�}d�_��|j�}|jrVd��fdd�|jD��}|d|d|dS|d|dSdS)Nrz;
c3s|]}��|�VqdS)N)r)r�p)rrr	r�sz+CGenerator.visit_FuncDef.<locals>.<genexpr>�
)rr\r�bodyZparam_declsr)rrr\rtZknrdeclsr)rr	�
visit_FuncDef�szCGenerator.visit_FuncDefcCsfd}x\|jD]R}t|tj�r,||�|�7}qt|tj�rL||�|�d7}q||�|�d7}qW|S)Nrrsz;
)�extrDrZFuncDefrZPragma)rrrZrvrrr	�
visit_FileAST�szCGenerator.visit_FileASTcs`���d}�jd7_|jr>|d��fdd�|jD��7}�jd8_|���d7}|S)Nz{
r1rc3s|]}��|�VqdS)N)�_generate_stmt)r�stmt)rrr	r�sz,CGenerator.visit_Compound.<locals>.<genexpr>z}
)rrZblock_itemsr)rrrZr)rr	�visit_Compound�szCGenerator.visit_CompoundcCs$d|�|j�d|�|j�dS)Nr)z){rT)rr&rX)rrrrr	�visit_CompoundLiteral�sz CGenerator.visit_CompoundLiteralcCsdS)N�;r)rrrrr	�visit_EmptyStatement�szCGenerator.visit_EmptyStatementcsd��fdd�|jD��S)Nz, c3s|]}��|�VqdS)N)r)r�param)rrr	r�sz-CGenerator.visit_ParamList.<locals>.<genexpr>)r�params)rrr)rr	�visit_ParamList�szCGenerator.visit_ParamListcCs&d}|jr|d|�|j�7}|dS)N�returnrr|)r/r)rrrZrrr	�visit_Return�szCGenerator.visit_ReturncCsdS)Nzbreak;r)rrrrr	�visit_Break�szCGenerator.visit_BreakcCsdS)Nz	continue;r)rrrrr	�visit_Continue�szCGenerator.visit_ContinuecCsHd|�|j�d}|d|�|j�d7}|d|�|j�d7}|S)Nr)z) ? z) : r*)rV�cond�iftrue�iffalse)rrrZrrr	�visit_TernaryOp�szCGenerator.visit_TernaryOpcCsdd}|jr||�|j�7}|d7}||j|jdd�7}|jr`||��d7}||j|jdd�7}|S)Nzif (z)
T)�
add_indentzelse
)r�rrxr�r�r)rrrZrrr	�visit_IfszCGenerator.visit_IfcCs~d}|jr||�|j�7}|d7}|jr<|d|�|j�7}|d7}|jr^|d|�|j�7}|d7}||j|jdd�7}|S)Nzfor (r|rz)
T)r�)rXrr��nextrxry)rrrZrrr	�	visit_For
szCGenerator.visit_ForcCs:d}|jr||�|j�7}|d7}||j|jdd�7}|S)Nzwhile (z)
T)r�)r�rrxry)rrrZrrr	�visit_WhileszCGenerator.visit_WhilecCsJd}||j|jdd�7}||��d7}|jr>||�|j�7}|d7}|S)Nzdo
T)r�zwhile (z);)rxryrr�r)rrrZrrr	�
visit_DoWhileszCGenerator.visit_DoWhilecCs>d}||�|j�7}|jr2|d7}||�|j�7}|d7}|S)Nz_Static_assert(�,r*)rr��message)rrrZrrr	�visit_StaticAssert$szCGenerator.visit_StaticAssertcCs,d|�|j�d}||j|jdd�7}|S)Nzswitch (z)
T)r�)rr�rxry)rrrZrrr	�visit_Switch-szCGenerator.visit_SwitchcCs:d|�|j�d}x |jD]}||j|dd�7}qW|S)Nzcase z:
T)r�)rr/�stmtsrx)rrrZryrrr	�
visit_Case2szCGenerator.visit_CasecCs*d}x |jD]}||j|dd�7}qW|S)Nz	default:
T)r�)r�rx)rrrZryrrr	�
visit_Default8szCGenerator.visit_DefaultcCs|jd|�|j�S)Nz:
)rrxry)rrrrr	�visit_Label>szCGenerator.visit_LabelcCsd|jdS)Nzgoto r|)r)rrrrr	�
visit_GotoAszCGenerator.visit_GotocCsdS)Nz...r)rrrrr	�visit_EllipsisParamDszCGenerator.visit_EllipsisParamcCs|�|d�S)N�struct)rk)rrrrr	�visit_StructGszCGenerator.visit_StructcCs|�|j�S)N)rar&)rrrrr	�visit_TypenameJszCGenerator.visit_TypenamecCs|�|d�S)N�union)rk)rrrrr	�visit_UnionMszCGenerator.visit_UnioncCs^d}x@|jD]6}t|tj�r,|d|j7}q|d|�|�d7}qW|d|�|j�7}|S)Nr�.r"r#z = )rrDr�IDrrVr/)rrrZrrrr	�visit_NamedInitializerPsz!CGenerator.visit_NamedInitializercCs
|�|�S)N)ra)rrrrr	�visit_FuncDeclZszCGenerator.visit_FuncDeclcCs|j|dd�S)NF)rc)ra)rrrrr	�visit_ArrayDecl]szCGenerator.visit_ArrayDeclcCs|j|dd�S)NF)rc)ra)rrrrr	�visit_TypeDecl`szCGenerator.visit_TypeDeclcCs|j|dd�S)NF)rc)ra)rrrrr	�
visit_PtrDeclcszCGenerator.visit_PtrDeclcCs�|dkr|j}|j}n(|dks"t�|jdkr0dn|jj}|j}|d|jpLd}|dk	r�|d7}||��7}|jd7_|d7}|||�7}|jd8_||��d	7}|S)
zq Generates code for structs, unions, and enums. name should be
            'struct', 'union', or 'enum'.
        )r�r�rjNrrrsr1z{
rT)	r]�_generate_struct_union_body�AssertionError�valuesZenumerators�_generate_enum_bodyrrr)rrr�membersZ
body_functionrZrrr	rkfs z&CGenerator._generate_struct_union_enumcsd��fdd�|D��S)Nrc3s|]}��|�VqdS)N)rx)rr\)rrr	rsz9CGenerator._generate_struct_union_body.<locals>.<genexpr>)r)rr�r)rr	r�~sz&CGenerator._generate_struct_union_bodycs$d��fdd�|D��dd�dS)Nrc3s|]}��|�VqdS)N)r)rr)rrr	r�sz1CGenerator._generate_enum_body.<locals>.<genexpr>���rs)r)rr�r)rr	r��szCGenerator._generate_enum_bodycCs�t|�}|r|jd7_|��}|r4|jd8_|tjtjtjtjtjtj	tj
tjtjtj
tjtjtjf
kr�||�|�dS|tjfkr�|�|�S|tjfkr�||�|�S||�|�dSdS)z� Generation from a statement node. This method exists as a wrapper
            for individual visit_* methods to handle different treatment of
            some statements in this context.
        r1z;
rsN)r&rrr�DeclrNZCastZUnaryOprEZ	TernaryOp�FuncCall�ArrayRef�	StructRef�Constantr�ZTypedefrUrZCompoundZIf)rrr��typrprrr	rx�s"

zCGenerator._generate_stmtcCsfd}|jrd�|j�d}|jr4|d�|j�d7}|jrR||�|jd�d7}||�|j�7}|S)z& Generation from a Decl node.
        rrr)Zfuncspecrr`Zalignrrar&)rrrZrrr	rW�szCGenerator._generate_declTc	Cst|�}|tjk�r�d}|jr2|d�|j�d7}||�|j�7}|jrR|rR|jnd}�xt|�D�]\}}t|tj	�r�|dkr�t||dtj
�r�d|d}|d7}|jr�|d�|j�d7}||�|j�d7}qbt|tj
��r,|dk�rt||dtj
��rd|d}|d|�|j�d7}qbt|tj
�rb|j�rdd	d�|j�|�rZd|ndf}qbd
|}qbW|�r�|d|7}|S|tjk�r�|�|j�S|tjk�r�|j|j|d�S|tjk�r�d�|j�dS|tj	tj
tj
fk�r|j|j||g|d�S|�|�SdS)
z� Recursive generation from a type node. n is the type node.
            modifiers collects the PtrDecl, ArrayDecl and FuncDecl modifiers
            encountered on the way down to a TypeDecl, to allow proper
            generation from it.
        rrrrr)r*r"r#z* %s%sr@)rcN)r&rZTypeDeclZqualsrrZdeclname�	enumeraterDZ	ArrayDeclZPtrDeclZ	dim_qualsZdimZFuncDeclr+r�rWZTypenameraZIdentifierTyperQ)	rr�	modifiersrcr�rZZnstr�i�modifierrrr	ra�sN
zCGenerator._generate_typecCs&|�|�}||�rd|dS|SdS)z� Visits 'n' and returns its string representation, parenthesized
            if the condition function applied to the node returns True.
        r)r*N)rV)rr�	conditionrZrrr	rI�s
zCGenerator._parenthesize_ifcs��|�fdd��S)z. Common use case for _parenthesize_if
        cs��|�S)N)rC)rG)rrr	rH�rOz8CGenerator._parenthesize_unless_simple.<locals>.<lambda>)rI)rrr)rr	r$�sz&CGenerator._parenthesize_unless_simplecCst|tjtjtjtjtjf�S)z~ Returns True for nodes that are "simple" - i.e. nodes that always
            have higher precedence than operators.
        )rDrr�r�r�r�r�)rrrrr	rC�szCGenerator._is_simple_nodeN)F)F)F)Cr�
__module__�__qualname__�__doc__r
rrrrrr!r%r(r,r0rFrMrPrRrVr[r_rbrdrhrirlrorqrurwrzr{r}r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�rkr�r�rxrWrarIr$rCrrrr	rs�




	
	


5
rN)rr�objectrrrrr	�<module>	s