3

g�wU5�@s dd
lm
Z

Gdd�de�ZdS)�
)
�c_astc@s�
eZ
dZd
Zdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zdd�Zdd�Zdldd �
Zd!d"�Zd#d$�Zd%d&�Zd'd(�Zd)d*�Zd+d,�Zd-d.�Zd/d0�Zd1d2�Zd3d4�Zd5d6�Zd7d8�Zd9d:�Zd;d<�Z d=d>�Z!d?d@�Z"dAdB�Z#dCdD�Z$dEdF�Z%dGdH�Z&dIdJ�Z'dKdL�Z(dMdN�Z)dOdP�Z*dQdR�Z+dSdT�Z,dUdV�Z-dWdX�Z.dYdZ�Z/d[d\�Z0d]d^�Z1dmd_d`�
Z2dadb�Z3gf
dcdd�
Z4dedf�Z5dgdh�Z6didj�Z7dkS)n�
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.
    c

Cs
d
|_dS)N�)
�indent_level)
�self�r�!/usr/lib/python3.6/c_generator.py�__init__szCGenerator.__init__c

Cs
d
|jS)N�
 )
r)
rrrr�_make_indents
zCGenerator._make_indentcCsd
|
jj
}t|||j�|
�
S)NZvisit_)�	__class__�__name__�getattr�
generic_visit)r�node�methodrrr�visits

zCGenerator.visitcs,|
dkrd
Sd
j�f
dd�|
j
�D�
�
SdS)N�c
3s|]\}
}�j|�
V
qdS)
N)
r)�.0Zc_name�
c)
rrr�	<genexpr>#sz+CGenerator.generic_visit.<locals>.<genexpr>)�joinZchildren)rrr)
rrrs
zCGenerator.generic_visitc
Cs|
jS)
N)
�value)r�
nrrr�visit_Constant%s
zCGenerator.visit_Constantc
Cs|
jS)
N)
�name)rrrrr�visit_ID(s
zCGenerator.visit_IDcCs$|j|
j
�
}|d
|j|
j�
dS)N�
[�
])�_parenthesize_unless_simplerrZ	subscript)rrZarrrefrrr�visit_ArrayRef+s

zCGenerator.visit_ArrayRefcCs"|j|
j
�
}||
j|j|
j�
S)
N)rr�typerZfield)rrZsrefrrr�visit_StructRef/s

zCGenerator.visit_StructRefcCs$|j|
j
�
}|d
|j|
j�
dS)N�
(�
))rrr�args)rrZfrefrrr�visit_FuncCall3s

zCGenerator.visit_FuncCallcCs\|j|
j
�
}|
jd
krd|S|
jdkr0d|S|
jdkrJd|j|
j
�
Sd|
j|fSdS)Nzp++z%s++zp--z%s--Zsizeofz
sizeof(%s)z%s%s)r�expr�opr)rrZoperandrrr�
visit_UnaryOp7s








zCGenerator.visit_UnaryOpcs<�j|
j
�f
d
d��}�j|
j�f
dd��}d||
j|fS)Nc

s�j|�
S)
N)
�_is_simple_node)
�
d)
rrr�<lambda>Fsz+CGenerator.visit_BinaryOp.<locals>.<lambda>c

s�j|�
S)
N)
r*)
r+)
rrrr,Hsz%s %s %s)�_parenthesize_if�left�rightr()rrZlval_str�rval_strr)
rr�visit_BinaryOpDs





zCGenerator.visit_BinaryOpcCs*|j|
j
d
d��}d|j|
j�
|
j|fS)Nc

Sst|t
j�S)
N)�
isinstancer�
Assignment)
rrrrr,Nsz-CGenerator.visit_Assignment.<locals>.<lambda>z%s %s %s)r-ZrvaluerZlvaluer()rrr0rrr�visit_AssignmentKs




zCGenerator.visit_AssignmentcCsd
j|
j
�
S)Nr
)r�names)rrrrr�visit_IdentifierTypeQs
zCGenerator.visit_IdentifierTypecCsJt|
t
j�rd
|j|
�
dSt|
t
j�r<d|j|
�
dS|j|
�
SdS)N�
{�
}r#r$)r2rZInitListr�ExprList)rrrrr�_visit_exprTs




zCGenerator._visit_exprFcCsL|r
|
jn|j
|
�
}|
jr.|d
|j|
j�
7}|
jrH|d|j|
j�
7}|S)Nz : z = )r�_generate_declZbitsizer�initr:)rr�no_type�
srrr�
visit_Decl\s



zCGenerator.visit_DeclcsL�j|
j
d
�
}t|
j
�
dkrH|ddj�f
dd�|
j
dd�D�
�
7}|S)Nrr
z, c
3s|]}
�j|
dd
�V
qdS)T)
r=N)
r?)r�decl)
rrrris
z,CGenerator.visit_DeclList.<locals>.<genexpr>)r�decls�lenr)rrr>r)
rr�visit_DeclListfs





zCGenerator.visit_DeclListcCs2d
}|
jr|dj
|
j�
d7}||j|
j�
7}|S)Nrr
)�storager�_generate_typer!)rrr>rrr�
visit_Typedefms




zCGenerator.visit_TypedefcCs(d
|j|
j
�
d}|d|j|
j�
S)Nr#r$r
)rEZto_typerr')rrr>rrr�
visit_Castss

zCGenerator.visit_CastcCs.g}x|
jD]}|j
|j|�
�

qWd
j|�
S)Nz, )�exprs�appendr:r)rr�visited_subexprsr'rrr�visit_ExprListws



zCGenerator.visit_ExprListcCs.g}x|
jD]}|j
|j|�
�

qWd
j|�
S)Nz, )rHrIr:r)rrrJr'rrr�visit_InitList}s



zCGenerator.visit_InitListcCs�d
}|
jr|d|
j7}|
j
r�|d7}xXt|
j
j�
D]H\}}||j7}|jr`|d|j|j�
7}|t|
j
j�
dkr4|d7}q4W|d7}|S)N�enumr
z {z = r
z, r8)r�values�	enumerateZenumeratorsrrrB)rrr>�
iZ
enumeratorrrr�
visit_Enum�s












zCGenerator.visit_Enumcsj�j|
j
�
}d
�_�j|
j�
}|
jrVdj�f
dd�|
jD�
�
}|d|d|dS|d|dSdS)Nrz;
c
3s|]}
�j|
�
V
qdS)
N)
r)r�
p)
rrrr�sz+CGenerator.visit_FuncDef.<locals>.<genexpr>�

)rr@r�bodyZparam_declsr)rrr@rTZknrdeclsr)
rr�
visit_FuncDef�s





zCGenerator.visit_FuncDefcCsFd
}x<|
jD]2}t
|tj�r,||j|�
7}q||j|�
d7}qW|S)Nrz;
)�extr2rZFuncDefr)rrr>rVrrr�
visit_FileAST�s




zCGenerator.visit_FileASTcs`�j�d
}�j
d7_
|
jr>|dj�f
dd�|
jD�
�
7}�j
d8_
|�j�d7}|S)Nz{
�rc
3s|]}
�j|
�
V
qdS)
N)
�_generate_stmt)r�stmt)
rrrr�sz,CGenerator.visit_Compound.<locals>.<genexpr>z}
)rrZblock_itemsr)rrr>r)
rr�visit_Compound�s






zCGenerator.visit_Compoundc
Csd
S)N�
;r)rrrrr�visit_EmptyStatement�s
zCGenerator.visit_EmptyStatementcsd
j�f
dd�|
j
D�
�
S)Nz, c
3s|]}
�j|
�
V
qdS)
N)
r)rZparam)
rrrr�sz-CGenerator.visit_ParamList.<locals>.<genexpr>)rZparams)rrr)
rr�visit_ParamList�s
zCGenerator.visit_ParamListcCs&d
}|
jr|d|j
|
j�
7}|dS)N�returnr
r\)r'r)rrr>rrr�visit_Return�s


zCGenerator.visit_Returnc
Csd
S)Nzbreak;r)rrrrr�visit_Break�s
zCGenerator.visit_Breakc
Csd
S)Nz	continue;r)rrrrr�visit_Continue�s
zCGenerator.visit_ContinuecCs8|j|
j
�
d
}||j|
j�
d7}||j|
j�
7}|S)Nz ? z : )r:�cond�iftrue�iffalse)rrr>rrr�visit_TernaryOp�s



zCGenerator.visit_TernaryOpcCsdd
}|
jr||j
|
j�
7}|d7}||j|
jdd�7}|
jr`||j�d7}||j|
jdd�7}|S)Nzif (z)
T)
�
add_indentzelse
)rcrrYrdrer)rrr>rrr�visit_If�s







zCGenerator.visit_IfcCs~d
}|
jr||j
|
j�
7}|d7}|
jr<|d|j
|
j�
7}|d7}|
jr^|d|j
|
j�
7}|d7}||j|
jdd�7}|S)Nzfor (r\r
z)
T)
rg)r<rrc�nextrYrZ)rrr>rrr�	visit_For�s








zCGenerator.visit_ForcCs:d
}|
jr||j
|
j�
7}|d7}||j|
jdd�7}|S)Nzwhile (z)
T)
rg)rcrrYrZ)rrr>rrr�visit_While�s




zCGenerator.visit_WhilecCsJd
}||j|
j
dd�7}||j�d7}|
jr>||j|
j�
7}|d7}|S)Nzdo
T)
rgzwhile (z);)rYrZrrcr)rrr>rrr�
visit_DoWhile�s





zCGenerator.visit_DoWhilecCs,d
|j|
j
�
d}||j|
jdd�7}|S)Nzswitch (z)
T)
rg)rrcrYrZ)rrr>rrr�visit_Switch�s


zCGenerator.visit_SwitchcCs:d
|j|
j
�
d}x |
jD]}||j|dd�7}qW|S)Nzcase z:
T)
rg)rr'�stmtsrY)rrr>rZrrr�
visit_Case�s



zCGenerator.visit_CasecCs*d
}x |
jD]}||j
|dd�7}qW|S)Nz	default:
T)
rg)rnrY)rrr>rZrrr�
visit_Default�s



zCGenerator.visit_DefaultcCs|
jd
|j
|
j�
S)Nz:
)rrYrZ)rrrrr�visit_Label�s
zCGenerator.visit_LabelcCsd
|
jdS)Nzgoto r\)
r)rrrrr�
visit_Goto�s
zCGenerator.visit_Gotoc
Csd
S)Nz...r)rrrrr�visit_EllipsisParam�s
zCGenerator.visit_EllipsisParamcCs|j|
d
�S)N�struct)
�_generate_struct_union)rrrrr�visit_Struct
s
zCGenerator.visit_StructcCs|j|
j
�
S)
N)rEr!)rrrrr�visit_Typename
s
zCGenerator.visit_TypenamecCs|j|
d
�S)N�union)
ru)rrrrr�visit_Union
s
zCGenerator.visit_UnioncCsfd
}xH|
jD]>}t
|tj�r,|d|j7}qt
|tj�r|d|jd7}qW|d|j|
j�
7}|S)Nr�
.rrz = )rr2r�ID�Constantrrr')rrr>rrrr�visit_NamedInitializer
s







z!CGenerator.visit_NamedInitializercCs
|j|
�
S)
N)
rE)rrrrr�visit_FuncDecl
s
zCGenerator.visit_FuncDeclcCs�|d
|
jpd}|
j
r~|d7}||j�7}|jd7_|d7}x|
j
D]}||j|�
7}qJW|jd8_||j�d7}|S)ze Generates code for structs and unions. name should be either
            'struct' or union.
        r
rrSrXz{
r8)rrArrrY)rrrr>r@rrrru
s









z!CGenerator._generate_struct_unioncCs�t|
�
}|r|j
d
7_
|j�}|r4|j
d
8_
|tjtjtjtjtjtj	tj
tjtjtj
tjtjtjf
kr�||j|
�
dS|tjf
kr�|j|
�
S||j|
�
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.
        rXz;
rSN)r!rrr�Declr3ZCastZUnaryOpZBinaryOpZ	TernaryOp�FuncCall�ArrayRef�	StructRefr|r{ZTypedefr9rZCompound)rrrg�typ�indentrrrrY(
s









zCGenerator._generate_stmtcCsHd
}|
jrdj
|
j�
d}|
jr4|dj
|
j�
d7}||j|
j�
7}|S)z& Generation from a Decl node.
        rr
)ZfuncspecrrDrEr!)rrr>rrrr;D
s



zCGenerator._generate_declcCs�
t|
�
}|t
jk�
rNd
}|
jr2|dj|
j�
d7}||j|
j�
7}|
jrN|
jnd
}x�t|�
D]�\}}t|t
j	�r�|dkr�t||dt
j
�r�d|d}|d|j|j�
d7}q\t|t
j��
r|dkr�t||dt
j
�r�d|d}|d|j|j
�
d7}q\t|t
j
�r\|j�
r,d	dj|j�
|f}q\d
|}q\W|�
rJ|d|7}|S|t
jk�
rf|j|
j�
S|t
jk�
r~|j|
j�
S|t
jk�
r�dj|
j�
dS|t
j	t
j
t
jfk�
r�|j|
j||
g
�S|j|
�
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.
        rr
rr
r#r$rrz* %s %s�
*N)r!rZTypeDeclZqualsrrZdeclnamerOr2Z	ArrayDeclZPtrDeclZdimZFuncDeclr%rr;ZTypenamerEZIdentifierTyper5)rrZ	modifiersr�r>ZnstrrPZmodifierrrrrEM
s@























zCGenerator._generate_typecCs&|j|
�
}||
�
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)
r:)rrZ	conditionr>rrrr-{
s


zCGenerator._parenthesize_ifcs�j|
�f
d
d��S)z. Common use case for _parenthesize_if
        c

s�j|�
S)
N)
r*)
r+)
rrrr,�
sz8CGenerator._parenthesize_unless_simple.<locals>.<lambda>)
r-)rrr)
rrr�
sz&CGenerator._parenthesize_unless_simplecCst|
t
jt
jt
jt
jt
jf�S)
z~ Returns True for nodes that are "simple" - i.e. nodes that always
            have higher precedence than operators.
        )r2rr|r{r�r�r�)rrrrrr*�
s
zCGenerator._is_simple_nodeN)
F)
F)8r
�
__module__�__qualname__�__doc__r	rrrrrr r"r&r)r1r4r6r:r?rCrFrGrKrLrQrUrWr[r]r^r`rarbrfrhrjrkrlrmrorprqrrrsrvrwryr}r~rurYr;rEr-rr*rrrrrsj




		


	.
rN)rr�objectrrrrr�<module>	s