B
    18\	]                @   st  d dl Z d dlZd dlZd dlZd dlZd dlZd dlZd dlZd dlZd dl	Z	d dl
Z
d dlZd dlZd dlZd dlZd dlZd dlZd dlZd dlZd dlZd dlZd dlT edZdaejZejZedZG dd dZe ZG dd dZe ZG dd	 d	Ze Zd
Z e!ddZ"dd Z#e!ddZ$dd Z%ddddddZ&dddddZ'dddddZ(dd Z)dd Z*e+dj,Z-dd Z.e/d 0 1 Z2d!d" Z3d#d$ Z4d%d& Z5d'd( Z6d)d* Z7d+d, Z8d-d. Z9d/d0 Z:G d1d2 d2Z;G d3d4 d4ej<Z=G d5d6 d6e j>d7Z?G d8d9 d9e?Z@d:d; ZAd<d= ZBd>d? ZCd@dA ZDeE d dBdCdDZFddFdGZGG dHdI dIe?ZHejIdJdK ZJddMdNZKG dOdP dPZLG dQdR dRZMG dSdT dTZNG dUdV dVZOG dWdX dXZPeHe@dYZQdZd[ d\1 D ZRe@eRd]< i ZSi ZTi ZUdaVG d^d_ d_ZWddLdd`dadbdcZXd	dddeZYG dfdg dgZZG dhdi diZ[G djdk dkZ\e/dl0 1 Z]dm^dndo0 1 \Z_Z`ZaZbZcZdG dpdq dqZeG drds dsZfG dtdu duZgd
dvdwZhdxdy Zidzd{ ZjG d|d} d}eZkG d~d dekd7ZlG dd delZmG dd delZnejddLdG dd delZoG dd deoZpG dd delZqG dd delZrejdeshdG dd delZtG dd delZuG dd delZvG dd delZwG dd delZxG dd delZyG dd delZzG dd delZ{G dd delZ|G dd delZ}G dd delZ~G dd delZG dd dZG dd dZG dd dZdd Zi ZG dd delZdddddZeddLeshd eddLdLeshd eddLeeeshd eddLdLeeeshd edeshd eddLeeshd edehd eddLehd edesehd eddLeesehd [G ddÄ delZG ddń delZG ddǄ delZejddLdɍejdesehdejdesehdLd̍G dd΄ delZejdesehdejdeseehdejdehdG ddӄ delZddՄ Zddׄ ZG ddل delZdddۄZG dd݄ deZG dd߄ ded7Zeed G dd deZG dd deZG dd deZG dd deZG dd deZG dd deZG dd deZG dd deZG dd deZG dd deZG dd deZG dd deZddddZG dd dZG dd  d ZeeZdZdaVdd Zedkrpeeejdd  dS (      N)*1c               @   s   e Zd Zdd ZdS )Unspecifiedc             C   s   dS )Nz<Unspecified> )selfr   r   S/oak/stanford/groups/akundaje/marinovg/programs/Python-3.7.3/Tools/clinic/clinic.py__repr__4   s    zUnspecified.__repr__N)__name__
__module____qualname__r   r   r   r   r   r   3   s   r   c               @   s   e Zd Zdd ZdS )Nullc             C   s   dS )Nz<Null>r   )r   r   r   r   r   ;   s    zNull.__repr__N)r	   r
   r   r   r   r   r   r   r   :   s   r   c               @   s   e Zd Zdd ZdS )Unknownc             C   s   dS )Nz	<Unknown>r   )r   r   r   r   r   B   s    zUnknown.__repr__N)r	   r
   r   r   r   r   r   r   r   A   s   r   z--_text_accumulatorztext append outputc                 s   g   fdd} t   j| S )Nc                 s   d  }    | S )N )joinclear)s)textr   r   outputN   s    
z!_text_accumulator.<locals>.output)_text_accumulator_ntappend)r   r   )r   r   r   L   s    text_accumulatorztext appendc              C   s   t  \} }}t||S )a'  
    Creates a simple text accumulator / joiner.

    Returns a pair of callables:
        append, output
    "append" appends a string to the accumulator.
    "output" returns the contents of the accumulator
       joined together (''.join(accumulator)) and
       empties the accumulator.
    )r   text_accumulator_nt)r   r   r   r   r   r   r   W   s    F)filenameline_numberc            G   s   d dd |D }t \}}| r,|d n|d trb|d krFtj}ttdd rb|d krbtjj}|d k	rz|d| d  |d k	r|d	t|  |d
 || t|  | rt	
d d S )N c             S   s   g | ]}t |qS r   )str).0ar   r   r   
<listcomp>g   s    z warn_or_fail.<locals>.<listcomp>ErrorWarningblock_parserz
 in file ""z	 on line z:
)r   r   clinicr   getattrr"   r   r   printsysexit)failr   r   argsZjoinedaddr   r   r   r   warn_or_failf   s&    


r-   c             G   s   t d|| |dS )NF)r   r   )F)r-   )r   r   r+   r   r   r   warn}   s    r.   c             G   s   t d|| |dS )NT)r   r   )T)r-   )r   r   r+   r   r   r   r*      s    r*   c             C   s"   xdD ]\}}|  ||} qW | S )N))\z\\)r#   z\")'z\')replace)r   oldnewr   r   r   quoted_for_c_string   s    r4   c             C   s   d|  d S )Nr#   r   )r   r   r   r   c_repr   s    r5   z^[A-Za-z_][A-Za-z0-9_]*$c             C   s   t dd | dD S )Nc             s   s   | ]}t |V  qd S )N)is_legal_c_identifier)r   fieldr   r   r   	<genexpr>   s    z)is_legal_py_identifier.<locals>.<genexpr>.)allsplit)r   r   r   r   is_legal_py_identifier   s    r<   z
asm auto break case char const continue default do double
else enum extern float for goto if inline int long
register return short signed sizeof static struct switch
typedef typeof union unsigned void volatile while
c             C   s*   t | std|  | tkr&| d S | S )NzIllegal C identifier: {}_value)r6   r*   format
c_keywords)r   r   r   r   ensure_legal_c_identifier   s
    r@   c             C   sB   t  \}}}x&| dD ]}||  |d qW |  | S )N
)r   r;   rstrippop)r   r   r,   r   liner   r   r   rstrip_lines   s    rE   c             C   s   |  dd} |  dd} | S )N{z{{}z}})r1   )r   r   r   r   format_escape   s    rH   c       
      K   s   t  \}}x| dD ]}|d\}}}|s@|| |d q|d\}}}|r\||krn|| |d q|rtd| d  | rtd| d  || }	|	sqtt|	|}	||	 |d qW | dd S )	a4  
    Perform str.format-like substitution, except:
      * The strings substituted must be on lines by
        themselves.  (This line is the "source line".)
      * If the substitution text is empty, the source line
        is removed in the output.
      * If the field is not recognized, the original line
        is passed unmodified through to the output.
      * If the substitution text is not empty:
          * Each line of the substituted text is indented
            by the indent of the source line.
          * A newline will be added to the end.
    rA   rF   rG   zText found after {z0} block marker!  It must be on a line by itself.z(Non-whitespace characters found before {Nr$   )r   r;   	partitionr*   striptextwrapindentrE   )
r   kwargsr,   r   rD   rL   Zcurlytrailingnamevaluer   r   r   linear_format   s.    
rQ   c             C   sd   |  d}| }g }x*|D ]"}|| || |d qW |rZ|| || d|S )z
    Returns 's', with 'prefix' prepended to all lines.

    If the last line is empty, prefix is not prepended
    to it.  (If s is blank, returns s unchanged.)

    (textwrap.indent only adds to non-blank lines.)
    rA   r   )r;   rC   r   r   )r   prefixr;   lastfinalrD   r   r   r   indent_all_lines   s    	





rU   c             C   sd   |  d}| }g }x*|D ]"}|| || |d qW |rZ|| || d|S )z
    Returns 's', with 'suffix' appended to all lines.

    If the last line is empty, suffix is not appended
    to it.  (If s is blank, returns s unchanged.)
    rA   r   )r;   rC   r   r   )r   suffixr;   rS   rT   rD   r   r   r   suffix_all_lines   s    





rW   c                s   g g   fdd}xpD ]h}|  r6 | q|dkrF|  q|dkrj|  d|d  qtdt| d t qW |  tS )a  Splits a version string into a tuple of integers.

    The following ASCII characters are allowed, and employ
    the following conversions:
        a -> -3
        b -> -2
        c -> -1
    (This permits Python-style version strings such as "1.4b3".)
    c                  s4    st dt td     d S )NzUnsupported version string: r   )
ValueErrorreprr   intr   r   r   )accumulatorr   versionr   r   flush  s    zversion_splitter.<locals>.flushr9   abc   zIllegal character z in version string )isdigitr   indexrX   rY   tuple)r   r]   cr   )r[   r   r\   r   version_splitter  s    

 rd   c             C   sN   t jt| t|dd}x0t|D ]$\}\}}||k r:dS ||kr"dS q"W dS )Nr   )	fillvaluer$      )	itertoolszip_longestrd   	enumerate)Zversion1Zversion2iteratorir   br   r   r   version_comparitor,  s    rm   c               @   s   e Zd Zdd ZdS )CRenderDatac             C   sF   g | _ g | _g | _g | _g | _g | _g | _g | _d| _g | _	g | _
d S )Nreturn_value)declarationsinitializersmodificationskeywordsformat_unitsparse_argumentsimpl_parametersimpl_argumentsro   return_conversioncleanup)r   r   r   r   __init__7  s    zCRenderData.__init__N)r	   r
   r   rz   r   r   r   r   rn   6  s   rn   c               @   s    e Zd ZdZdd Zdd ZdS )FormatCounterFormatterz
    This counts how many instances of each formatter
    "replacement string" appear in the format string.

    e.g. after evaluating "string {a}, {b}, {c}, {a}"
         the counts dict would now look like
         {'a': 2, 'b': 1, 'c': 1}
    c             C   s   t  | _d S )N)collectionsCountercounts)r   r   r   r   rz   m  s    zFormatCounterFormatter.__init__c             C   s   | j |  d7  < dS )Nrf   r   )r~   )r   keyr+   rM   r   r   r   	get_valuep  s    z FormatCounterFormatter.get_valueN)r	   r
   r   __doc__rz   r   r   r   r   r   r{   d  s   r{   c               @   sB   e Zd ZdZdZdZdZdd Zej	dd Z
dd Zdd	 Zd
S )Languager   c             C   s   d S )Nr   )r   r   r   r   r   rz   {  s    zLanguage.__init__c             C   s   d S )Nr   )r   r%   
signaturesr   r   r   render~  s    zLanguage.renderc             C   s   d S )Nr   )r   rD   r   r   r   
parse_line  s    zLanguage.parse_linec                s<    fdd}|d |d d j kr*dnd}|d| d S )	Nc                s   dg}| | t }t }||  fdd}x8|j D ]*\}|krh|dkrp|d qF|d qFW x$|D ]|jdkrz|d qzW dS )ah  
            Ensures that the string found at getattr(self, attr)
            contains exactly one formatter replacement string for
            each valid field.  The list of valid fields is
            ['dsl_name'] extended by additional_fields.

            e.g.
                self.fmt = "{dsl_name} {a} {b}"

                # this passes
                self.assert_only_one('fmt', 'a', 'b')

                # this fails, the format string has a {b} in it
                self.assert_only_one('fmt', 'a')

                # this fails, the format string doesn't have a {c} in it
                self.assert_only_one('fmt', 'a', 'b', 'c')

                # this fails, the format string has two {a}s in it,
                # it must contain exactly one
                self.fmt2 = '{dsl_name} {a} {a}'
                self.assert_only_one('fmt2', 'a')

            dsl_namec                s6   | rt djj  nt djj  d S )Nz'{} {} must contain {{{}}} exactly once!z{} {} must not contain {{{}}}!)r*   r>   	__class__r	   )Zshould_be_there_but_isnt)attrrO   r   r   r   
local_fail  s
    z>Language.validate.<locals>.assert_only_one.<locals>.local_failrf   TFN)extendr&   r{   r>   r~   itemsget)r   Zadditional_fieldsfieldsrD   Zfcfr   count)r   )r   rO   r   assert_only_one  s    




z*Language.validate.<locals>.assert_only_one
start_line	stop_linez{arguments}	argumentschecksumchecksum_line)r   )r   r   r7   r   )r   r   validate  s
    0zLanguage.validateN)r	   r
   r   r   body_prefixr   r   rz   r^   abstractmethodr   r   r   r   r   r   r   r   t  s   r   )	metaclassc               @   s    e Zd ZdZdZdZdZdZdS )PythonLanguagePythonz#/*[{dsl_name} input]#z$#[{dsl_name} start generated code]*/z1#/*[{dsl_name} end generated code: {arguments}]*/N)r	   r
   r   languager   r   r   r   r   r   r   r   r     s
   r   c             c   s8   t  V  g }x&t| D ]}t|| }t |V  qW dS )z]
    Given [1, 2, 3], should yield:
       ()
       (3,)
       (2, 3)
       (1, 2, 3)
    N)rb   reversedlist)lr[   groupr   r   r   permute_left_option_groups  s
    r   c             c   s2   t  V  g }x | D ]}|| t |V  qW dS )zY
    Given [1, 2, 3], should yield:
      ()
      (1,)
      (1, 2)
      (1, 2, 3)
    N)rb   r   )r   r[   r   r   r   r   permute_right_option_groups  s
    

r   c       	      C   s   t |}g }|s| rtg }t }xTt|D ]H}xBt| D ]6}|| | }t||krXq:|t| || q:W q,W |jtd t |S )a  
    Generator function that computes the set of acceptable
    argument lists for the provided iterables of
    argument groups.  (Actually it generates a tuple of tuples.)

    Algorithm: prefer left options over right options.

    If required is empty, left must also be empty.
    )r   )	rb   AssertionErrorsetr   r   lenr,   r   sort)	leftrequiredrightresultr[   r~   rr   tr   r   r   permute_optional_groups  s    
r   c             C   s:   |   d}x |r.|d }| r&P |d= qW d|S )NrA   r   )rB   r;   rJ   r   )r   linesrD   r   r   r   &strip_leading_and_trailing_blank_lines  s    
r   )rL   c            C   s*   t | } t| } |r&t| d| } | S )z
    Reformats s:
        * removes leading and trailing blank lines
        * ensures that it does not end with a newline
        * dedents so the first nonwhite character on any line is at column "indent"
    r   )r   rK   dedentrL   )r   rL   r   r   r   normalize_snippet  s
    
r   N   c             C   s,  g }x|  dD ]
}|d\}}}|s8|| q|d\}}}|sX|| qd|krl|| qdd | dD }|d7 }t||k rdt| }	nd}	xv|r|}d	}
x8|r|
st|t|d
  |krP ||d
7 }d}
qW |s|dd | }||  |	}qW qW d|S )a"  
    A simple-minded text wrapper for C function declarations.

    It views a declaration line as looking like this:
        xxxxxxxx(xxxxxxxxx,xxxxxxxxx)
    If called with length=30, it would wrap that line into
        xxxxxxxx(xxxxxxxxx,
                 xxxxxxxxx)
    (If the declaration has zero or one parameters, this
    function won't wrap it.)

    If this doesn't work properly, it's probably better to
    start from scratch with a more sophisticated algorithm,
    rather than try and improve/debug this dumb little function.
    rA   (),c             S   s   g | ]}|  d  qS )z, )rJ   )r   xr   r   r   r   8  s    z%wrap_declarations.<locals>.<listcomp>r   z    Tr   Fz, )r;   rI   r   r   rC   rB   r   )r   lengthr   rD   rR   _Zafter_l_paren
parametersZafter_r_parenZspacesfirstr   r   r   wrap_declarations  s@    


r   c                   sp   e Zd ZdZdZdZdZdZdZ fddZd	d
 Z	dd Z
dd Zdd Zedd Zdd Zdd Z  ZS )	CLanguager   Cz/*[{dsl_name} input]r   z#[{dsl_name} start generated code]*/z0/*[{dsl_name} end generated code: {arguments}]*/c                s$   t  | t|| _t| j_d S )N)superrz   cppZMonitorr*   )r   r   )r   r   r   rz   X  s    zCLanguage.__init__c             C   s   | j | d S )N)r   Z	writeline)r   rD   r   r   r   r   ]  s    zCLanguage.parse_linec             C   sL   d }x:|D ]2}t |tr
|r8tdt| d t|  |}q
W | ||S )NzXYou may specify at most one function per block.
Found a block containing at least two:
	z and )
isinstanceFunctionr*   rY   render_function)r   r%   r   functionor   r   r   r   `  s    

zCLanguage.renderc             C   sn   t  \}}}x0|jdD ] }|d |t| |d qW |d tkrT|d n|  |d d|S )NrA   r#   z\n"
z"\n"r   )r   	docstringr;   r4   sig_end_markerrC   r   )r   fr   r,   r   rD   r   r   r   docstring_for_c_stringi  s    
z CLanguage.docstring_for_c_stringc       +         sB  t |j }|stt|d jts*t|d= dd |D }|oT|d jpT|d j}|j ph|jj	dk}|ox|d 
 }d}t|}xLt|D ]<\}	}
|
j}t	|tkrP |jdkrP |
jtk	rt||	}qW d}|jttfk}t|d	ko|d 
 o|d   o| }d
}td}|r8|js8d }}ntd}td}td}d  } }}td}td}td}td}d  fdd}dd }|sd}td}|}|r|d td }n||}n|rfd}t|d tr&|d jdkr&td}|rd } }}|}n|}||}n>d}|d j|krB|d 7 }td!| }||td"| d#d$}n|rd%}|}||d&}n|r|r|sd'}|}||td(d#d$}nd%}|}||td)d#d$}n|r|sd'}|}||td*d#d$}nd%}|}||td+d#d$}nT|s<d,}|}td-d#d$}|||}||}n&d.}|}td/d#d$}|||}||}|rd}|jtkr~|}nd0}td1}t  } d|k}!d2|k}"|"r|!st|"s| dtd3d#d$ |!s| dtd4d#d$ ||f|  }|"r||}|jr|d5|j 7 }|d6|}d}#| j }$|$sBd }%}&n>d7|$ }%d8|$ d9 }&|r|jtj krtj !|j td:}#|d k	st|r|"d;rt|d;7 }|d kr|}|r|d;7 }|d<|}||||||||%|&|#d=
}'i }(xJ|'# D ]>\})}*|*d k	std>t$|) |*r0d|* d }*|*|(|)< qW |(S )?Nr   c             S   s   g | ]
}|j qS r   )	converter)r   pr   r   r   r     s    z.CLanguage.output_templates.<locals>.<listcomp>r$   z
PyObject *FOTrf   zPyObject *return_value = NULL;z
            #define {methoddef_name}    \
                {{"{name}", (PyCFunction){c_basename}, {methoddef_flags}, {c_basename}__doc__}},
            r   zA
                PyDoc_VAR({c_basename}__doc__);
                za
                PyDoc_STRVAR({c_basename}__doc__,
                {docstring});
                zd
            static {impl_return_type}
            {c_basename}_impl({impl_parameters})
            z~
            static PyObject *
            {c_basename}({self_type}{self_name}, PyObject *args, PyObject *kwargs)
            zl
            static PyObject *
            {c_basename}({self_type}{self_name}, PyObject *args)
            z
            static PyObject *
            {c_basename}({self_type}{self_name}, PyObject *const *args, Py_ssize_t nargs)
            z
            static PyObject *
            {c_basename}({self_type}{self_name}, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
            r   c                sd   t  \}}||  | t|}|dtdd  |td x|D ]}|d || qFW | S )Nr   z
                {{
                    {return_value_declaration}
                    {declarations}
                    {initializers}
                rA   a  
                    {modifications}
                    {return_value} = {c_basename}_impl({impl_arguments});
                    {return_conversion}

                {exit_label}
                    {cleanup}
                    return return_value;
                }}
                )r   r   insertr   r   )	prototyper   r,   r   r7   )parser_body_fieldsr   r   parser_body  s    
	
z/CLanguage.output_templates.<locals>.parser_bodyc             S   s   t | ddS )Nzstatic const char * const _keywords[] = {{{keywords}, NULL}};
static _PyArg_Parser _parser = {{"{format_units}:{name}", _keywords, 0}};
{declarations})rp   )rQ   )r   r   r   r   insert_keywords  s    z3CLanguage.output_templates.<locals>.insert_keywordsZMETH_NOARGSz
                static PyObject *
                {c_basename}({self_type}{self_name}, PyObject *Py_UNUSED(ignored))
                rA   z
                    {{
                        return {c_basename}_impl({impl_arguments});
                    }}
                    METH_Ozo
                    static PyObject *
                    {c_basename}({impl_parameters})
                    argr   z
                    static PyObject *
                    {c_basename}({self_type}{self_name}, PyObject *%s)
                    z
                    if (!PyArg_Parse(%s, "{format_units}:{name}", {parse_arguments})) {{
                        goto exit;
                    }}
                       )rL   ZMETH_VARARGSz    {option_group_parsing}ZMETH_FASTCALLz
                    if (!_PyArg_UnpackStack(args, nargs, "{name}",
                        {unpack_min}, {unpack_max},
                        {parse_arguments})) {{
                        goto exit;
                    }}
                    z
                    if (!PyArg_UnpackTuple(args, "{name}",
                        {unpack_min}, {unpack_max},
                        {parse_arguments})) {{
                        goto exit;
                    }}
                    z
                    if (!_PyArg_ParseStack(args, nargs, "{format_units}:{name}",
                        {parse_arguments})) {{
                        goto exit;
                    }}
                    z
                    if (!PyArg_ParseTuple(args, "{format_units}:{name}",
                        {parse_arguments})) {{
                        goto exit;
                    }}
                    zMETH_FASTCALL|METH_KEYWORDSz
                if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
                    {parse_arguments})) {{
                    goto exit;
                }}
                zMETH_VARARGS|METH_KEYWORDSz
                if (!_PyArg_ParseTupleAndKeywordsFast(args, kwargs, &_parser,
                    {parse_arguments})) {{
                    goto exit;
                }}
                zint return_value = -1;z
                    static int
                    {c_basename}({self_type}{self_name}, PyObject *args, PyObject *kwargs)
                    ZMETH_KEYWORDSz
                    if ({self_type_check}!_PyArg_NoKeywords("{name}", kwargs)) {{
                        goto exit;
                    }}
                    z
                        if ({self_type_check}!_PyArg_NoPositional("{name}", args)) {{
                            goto exit;
                        }}
                        |z{methoddef_flags}z#if z
#endif /* z */z
                    #ifndef {methoddef_name}
                        #define {methoddef_name}
                    #endif /* !defined({methoddef_name}) */
                    ;z{return_value_declaration})
docstring_prototypedocstring_definitionimpl_prototypemethoddef_defineparser_prototypeparser_definitionimpl_definitioncpp_if	cpp_endifmethoddef_ifndefzgot a None value for template )%r   r   valuesr   r   r   self_converterr   return_convertertypeis_positional_onlyr   ri   object_converterformat_unitdefaultunspecifiedminkind
METHOD_NEWMETHOD_INITis_optionalr   r   rO   r   methoddef_flagsr1   r   	condition	full_namer%   ifndef_symbolsr,   endswithr   rY   )+r   r   r   
convertershas_option_groupsdefault_return_converter
positionalZall_boring_objectsfirst_optionalrk   r   rc   new_or_initZmeth_oZreturn_value_declarationr   r   r   r   r   r   r   Zparser_prototype_keywordZparser_prototype_varargsZparser_prototype_fastcallZ"parser_prototype_fastcall_keywordsr   r   flagsZmeth_o_prototypeargnamebodyr   Zparses_positionalZparses_keywordsr   Zconditionalr   r   dd2rO   rP   r   )r   r   output_templatesz  sX   














zCLanguage.output_templatesc             C   s$   | dk rdnd}d| t t|  S )Nr   Zleft_Zright_Zgroup_)r   abs)r   Z	adjectiver   r   r   group_to_variable_name  s    z CLanguage.group_to_variable_namec                s  t  \}}t|j }t|d jtr.|d= g }d }g }g }	g }
t}xX|D ]P}|j}||kr|}g }|dk rz|	| n|dkr|
}n
|		| |	| qLW t
j}d}|d xt||
|	D ]}t|}t||}t||}|dkr|d qdd |D }i }||d< |j|d< d	d
d |D |d< g }x|D ]}|j| q8W d||d< |d  fdd|D }d|}ddd  }t||d}||}|| qW |d d}|||j|| |d |d t| |d< d S )Nr   r$   z"switch (PyTuple_GET_SIZE(args)) {
z    case 0:
        break;
c             S   s   h | ]
}|j qS r   )r   )r   r   r   r   r   	<setcomp>.  s    z8CLanguage.render_option_group_parsing.<locals>.<setcomp>r   rO   r   c             s   s   | ]}|j jV  qd S )N)r   r   )r   r   r   r   r   r8   2  s    z8CLanguage.render_option_group_parsing.<locals>.<genexpr>rt   z, ru   c                s   g | ]}  |d  qS )z = 1;)r  )r   g)r   r   r   r   :  s    z9CLanguage.render_option_group_parsing.<locals>.<listcomp>rA   z
    case {count}:
        if (!PyArg_ParseTuple(args, "{format_units}:{name}", {parse_arguments})) {{
            goto exit;
        }}
        {group_booleans}
        break;
rf   )Zgroup_booleansz    default:
zL        PyErr_SetString(PyExc_TypeError, "{} requires {} to {} arguments");
z        goto exit;
rG   option_group_parsing)r   r   r   r   r   r   r   r   r   r   r(   maxsizer   r   r   maxrO   r   parse_argumentdiscardrQ   
format_mapr>   r   rH   )r   r   template_dictr,   r   r   groupsr   r   r   r   rS   r   Zgroup_idZ	count_minZ	count_maxsubsetr   Z	group_idsr   ru   r   r   r   )r   r   render_option_group_parsing  sl    








	
z%CLanguage.render_option_group_parsingc       #   	   C   sT  |sdS t  \}}t }|js&td|j}dd |D }| |}|d }	|dd  }
t|	jtsztdt	|j
 d d}t|
}|
o|
d	  }|jttfk}|j p|jjd
k}d}xt|d	D ]\}}|j}|d	kr|jtk	rt||}|j}||krJ|}|rJ| |}|j| |jd| d  |jd|  d}||| qW |rn|sntd d|d krd|d kr|jd i }|j
}||d< |r|jj }n|j }||d< |j!r|j!}n*|"d}|d	 dkr|  d#|}||d< d$|% }||d< | &||d< d |d<  |d< |d< |	j'| |j|| |jj|d < t(d!#|j|d"< d##|j)|d$< d##|j*|d%< d&d'#|j+ d& |d(< d#|j,|d)< d*#|j-|d+< d*#|j|d,< d*#|j|d-< t(d#|j./ |d.< t(d#|j0|d/< |j1|d0< t|d tr@d	nd}|}t|
}t2||d1< t2||d2< |rz| 3|| x|j45 D ]\}}|| } |rt6| |d3 d4} t6| |d" |d. |d$ |d% |d/ d5} d6| k}!t6| |!rd7ndd8} | 7|}"|d9krt8|"}"|j9r"t:|"|j9}"|j;r6t<|"|j;}"||" qW |=d:> S );Nr   z-We should always have a 'self' at this point!c             S   s   g | ]
}|j qS r   )r   )r   r   r   r   r   r   Y  s    z-CLanguage.render_function.<locals>.<listcomp>r   rf   zNo self parameter in !r$   z
PyObject *Fzint z = 0;Tz]You cannot use optional groups ('[' and ']')
unless all parameters are positional-only ('/').r   r   z{impl_parameters}r   r   rO   r9   __new__r   
c_basenamez{}_METHODDEFmethoddef_namer   	self_name	self_typeself_type_checkZimpl_return_typerA   rp   z

rq   rr   r#   z", "rs   rt   z, ru   rv   rw   rx   ry   ro   
unpack_min
unpack_maxr  )r  )rp   rx   rq   rr   ry   z
goto exit;zexit:)Z
exit_label>   r   r   block)?r   rn   r   r   render_parametersr   r   r   r   rY   r   r   r   r   r   r   r   r   ri   r   r   r   r   r  rw   r   rp   rv   r   r*   rC   clsrO   r  r;   r   r>   upperr   set_template_dictrH   rq   rr   rs   rt   ru   rx   rB   ry   ro   r   r  destination_buffersr   rQ   r	  r   line_prefixrU   line_suffixrW   get_destinationdump)#r   r%   r   r,   r   datar   r   Z	templatesZf_selfZselflessZ
last_groupr   r   r   r   r   rk   r   rc   r   Z
group_namer
  r   rO   r  r   r  Zignore_selfr  r  destinationtemplateZneed_exit_labelr   r   r   r   r   P  s    

"









zCLanguage.render_function)r	   r
   r   r   r   r   r   r   rz   r   r   r   r   staticmethodr  r  r   __classcell__r   r   )r   r   r   O  s    	  v]r   c             c   s2   t j}| t _z
d V  W d t j| ks&t|t _X d S )N)r(   stdoutr   )r&  saved_stdoutr   r   r   OverrideStdioWith  s    
r(  Tc             C   sD   |rdnd}d}|r d| d }| t| |t|}t|S )z.Create an re object for matching marker lines.z\w+z.+z{}({}){}^$)r>   reescapecompile)beforeafterword
whole_lineZgroup_repatternr   r   r   create_regex  s    r3  c               @   s"   e Zd ZdZdddZdd ZdS )	Blocka  
    Represents a single block of text embedded in
    another file.  If dsl_name is None, the block represents
    verbatim text, raw original text from the file, in
    which case "input" will be the only non-false member.
    If dsl_name is not None, the block represents a Clinic
    block.

    input is always str, with embedded \n characters.
    input represents the original text from the file;
    if it's a Clinic block, it is the original text with
    the body_prefix and redundant leading whitespace removed.

    dsl_name is either str or None.  If str, it's the text
    found on the start line of the block between the square
    brackets.

    signatures is either list or None.  If it's a list,
    it may only contain clinic.Module, clinic.Class, and
    clinic.Function objects.  At the moment it should
    contain at most one of each.

    output is either str or None.  If str, it's the output
    from this block, with embedded '\n' characters.

    indent is either str or None.  It's the leading whitespace
    that was found on every line of input.  (If body_prefix is
    not empty, this is the indent *after* removing the
    body_prefix.)

    preindent is either str or None.  It's the whitespace that
    was found in front of every line of input *before* the
    "body_prefix" (see the Language object).  If body_prefix
    is empty, preindent must always be empty too.

    To illustrate indent and preindent: Assume that '_'
    represents whitespace.  If the block processed was in a
    Python file, and looked like this:
      ____#/*[python]
      ____#__for a in range(20):
      ____#____print(a)
      ____#[python]*/
    "preindent" would be "____" and "indent" would be "__".

    Nr   c             C   s:   t |tst|| _|| _|p g | _|| _|| _|| _d S )N)	r   r   r   inputr   r   r   rL   	preindent)r   r5  r   r   r   rL   r6  r   r   r   rz   .  s    
zBlock.__init__c          	   C   s6   | j pd}dd }dd|d|| jd|| jdfS )	Nr   c             S   s0   t | } t| dkr,| d d d | d  S | S )N      z...r   )rY   r   )r   r   r   r   	summarize9  s    z!Block.__repr__.<locals>.summarizer   z<Block z input=z output=>)r   r   r5  r   )r   r   r9  r   r   r   r   7  s    
zBlock.__repr__)NNNr   r   )r	   r
   r   r   rz   r   r   r   r   r   r4     s   -
	r4  c               @   sP   e Zd ZdZddddZdd Zdd	 Zd
d ZdddZdd Z	dd Z
dS )BlockParserzX
    Block-oriented parser for Argument Clinic.
    Iterator, yields Block objects.
    T)verifyc            C   s   |   tt|jdd| _d | _| _|| _|j	
d\}}}|dksPtt||dd| _t||| _|| _d| _d| _d| _d| _dS )z
        "input" should be a str object
        with embedded 
 characters.

        "language" should be a Language object.
        T)keependsr   z
{dsl_name}F)r1  N)r   r|   dequer   
splitlinesr5  block_start_line_numberr   r   r   rI   r   r3  find_start_restart_rer<  last_checksum_relast_dsl_namer   first_block)r   r5  r   r<  r.  r   r/  r   r   r   rz   H  s    zBlockParser.__init__c             C   s   | S )Nr   )r   r   r   r   __iter___  s    zBlockParser.__iter__c             C   sR   xL| j st| jr.| | j}d | _d| _|S |  }| jrD|j sDqd| _|S d S )NF)r5  StopIterationr   parse_clinic_blockrE  parse_verbatim_block)r   ro   r  r   r   r   __next__b  s    zBlockParser.__next__c             C   s"   | j | }|r|dS d S )Nrf   )rB  matchlstripr   )r   rD   rK  r   r   r   is_start_lines  s    zBlockParser.is_start_lineFc             C   s,   |  j d7  _ | j }|s(| j| |S )Nrf   )r   r5  rC   r   r   )r   	lookaheadrD   r   r   r   _linew  s
    
zBlockParser._linec             C   sN   t  \}}| j| _x0| jrB|  }| |}|r8|| _P || qW t| S )N)r   r   r@  r5  rO  rM  r   r4  )r   r,   r   rD   r   r   r   r   rI  ~  s    

z BlockParser.parse_verbatim_blockc                sR  t  \}}| jd | _| jjj|d | jjj|d} fdd}xX| jr|  }||sd| 	|rfP |r|
 }||st|t|d  }|| qDW | j|kr| j}nD| jjj|ddd\}}	}
|	dkstt||
dd}|| _|| _t  \}}d }xZ| jrZ| jd	d
}||
 }|r4|dnd }|r@P || | 	|rP qW | }|ri }xHt|D ]:}|d\}}}|std| | || < qxW | jrBd|kr|d }|d }n|d }d }t|t|}||krBtd|| n2|jd	d}|  jt|8  _| jt| d }t| ||dS )Nrf   )r   c                s,   |   sdS | t d  }| p*| S )NF)
startswithr   isspace)rD   	remainder)r   r   r   is_stop_line  s    
z4BlockParser.parse_clinic_block.<locals>.is_stop_linez{arguments})r   r   F)r0  T)rN  =z)Mangled Argument Clinic marker line: {!r}r5  r   r   zChecksum mismatch!
Expected: {}
Computed: {}
Suggested fix: remove all generated code including the end marker,
or use the '-f' option.)r=  )r   )r   r   r@  r   r   r>   r   r5  rO  rM  rL  rP  r   r   rD  rC  r   rI   r3  rK  r   shlexr;   r*   rJ   r<  compute_checksumr?  r   r   r4  )r   r   Z	input_addZinput_outputr   rS  rD   Zchecksum_rer.  r   r/  Z
output_addZoutput_outputr   rK  r   r   r7   rO   equalsrP   r   Zinput_checksumcomputedZoutput_linesr   )r   r   rH    sn    
	





zBlockParser.parse_clinic_blockN)F)r	   r
   r   r   rz   rF  rJ  rM  rO  rI  rH  r   r   r   r   r;  B  s   
r;  c               @   s&   e Zd ZdddZdd Zdd ZdS )	BlockPrinterNc             C   s   || _ |pt | _d S )N)r   ioStringIOr   )r   r   r   r   r   r   rz     s    zBlockPrinter.__init__c       	      C   s>  |j }|j}|j}| jj}|d k|d kA r:tdt| |sJ|| d S || jjj	|d |d | jj
j	|d}|s|| n,x*|dD ]}|| || |d qW || jjj	|d |d d|j }d|j}|r|ds|d7 }|| d	t|dt|d}|| jjj	||d |d d S )Nz8you must specify dsl_name and output together, dsl_name )r   rA   r   zoutput={} input={}   )r   r   )r5  r   r   r   writer   rY   r   r   r>   r   r;   r   r   r   rV  r   )	r   r  r5  r   r   r]  r   rD   r   r   r   r   print_block  s8     

zBlockPrinter.print_blockc             C   s   | j | d S )N)r   r]  )r   r   r   r   r   r]  
  s    zBlockPrinter.write)N)r	   r
   r   rz   r^  r]  r   r   r   r   rY    s   
&rY  c               @   s0   e Zd ZdZdd Zdd Zdd Zdd	 Zd
S )BufferSeriesa  
    Behaves like a "defaultlist".
    When you ask for an index that doesn't exist yet,
    the object grows the list until that item exists.
    So o[n] will always work.

    Supports negative indices for actual items.
    e.g. o[-1] is an element immediately preceding o[0].
    c             C   s   d| _ g | _t| _d S )Nr   )_start_arrayr   _constructor)r   r   r   r   rz     s    zBufferSeries.__init__c                sv   | j 8 }|dk rH  j |7  _  fddt| D }| j  _d}x"|t jkrj j   qJW  j| S )Nr   c                s   g | ]}   qS r   )rb  )r   r   )r   r   r   r   "  s    z,BufferSeries.__getitem__.<locals>.<listcomp>)r`  rangera  r   r   rb  )r   rk   rR   r   )r   r   __getitem__  s    
zBufferSeries.__getitem__c             C   s   x| j D ]}|j  qW d S )N)ra  Z_textr   )r   tar   r   r   r   )  s    zBufferSeries.clearc             C   s   dd | j D }d|S )Nc             S   s   g | ]}|  qS r   )r   )r   re  r   r   r   r   .  s    z%BufferSeries.dump.<locals>.<listcomp>r   )ra  r   )r   Ztextsr   r   r   r   -  s    zBufferSeries.dumpN)r	   r
   r   r   rz   rd  r   r   r   r   r   r   r_    s
   	r_  c               @   s,   e Zd Zdd Zdd Zdd Zdd Zd	S )
Destinationc             G   s
  || _ || _|| _d}||krDtdt| d | d d|  |dkrPdnd}t||k rttd	| d
 |  t||krtd| d
 |  |dkri }|j}||d< tj	
|\}	}
|	sd}	|	|d< |
|d< tj	|\|d< |d< |d || _t | _d S )N)bufferfilesuppresszInvalid destination type z for z , must be z, rh  rf   r   z%Not enough arguments for destination z new z#Too many arguments for destination pathr9   dirnamebasenameZbasename_rootZbasename_extension)rO   r   r%   r*   rY   r   r   r   osrj  r;   splitextr	  r_  buffers)r   rO   r   r%   r+   valid_typesZextra_argumentsr   r   rk  rl  r   r   r   rz   3  s.    &zDestination.__init__c             C   s8   | j dkrdt| j }nd}dd| jd| j |dfS )Nrh  r   r   z<Destination r:  )r   rY   r   r   rO   )r   Z	file_reprr   r   r   r   M  s    
zDestination.__repr__c             C   s*   | j dkrtd| j d  | j  d S )Nrg  zCan't clear destinationz , it's not of type buffer)r   r*   rO   ro  r   )r   r   r   r   r   T  s    
zDestination.clearc             C   s
   | j  S )N)ro  r   )r   r   r   r   r   Y  s    zDestination.dumpN)r	   r
   r   rz   r   r   r   r   r   r   r   rf  2  s   rf  )r   r   c             C   s   i | ]
}t |qS r   )r   )r   rO   r   r   r   
<dictcomp>a  s    rq  zc cc cpp cxx h hh hpp hxxpyc               @   sN   e Zd ZdZdddddddZdd	 Zd
d ZdddZdd Zdd Z	dS )Clinica  
preset block
everything block
methoddef_ifndef buffer 1
docstring_prototype suppress
parser_prototype suppress
cpp_if suppress
cpp_endif suppress

preset original
everything block
methoddef_ifndef buffer 1
docstring_prototype suppress
parser_prototype suppress
cpp_if suppress
cpp_endif suppress

preset file
everything file
methoddef_ifndef file 1
docstring_prototype suppress
parser_prototype suppress
impl_definition block

preset buffer
everything buffer
methoddef_ifndef buffer 1
impl_definition block
docstring_prototype suppress
impl_prototype suppress
parser_prototype suppress

preset partial-buffer
everything buffer
methoddef_ifndef buffer 1
docstring_prototype block
impl_prototype suppress
methoddef_define block
parser_prototype block
impl_definition block

NFT)forcer<  r   c            C   s  i | _ || _|rtd |p"t|| _|| _|| _|| _t	 | _
t	 | _g | _d | _| _i | _| dd | dd | dd |r| ddd | j}t	d|dfd	|dfd
|dfd|dfd|dfd|dfd|dfd|dfd|ddfd|dff
| _g | _t | _i | _d }x| j dD ]}| }|sRq<| ^}	}
}|	dkrt	  | j|
< }q<t|rt|d }nd}| |
|}|	dkrx| jD ]}	|||	< qW q<|	| jkst|||	< q<W | ad S )Nz$Custom printers are broken right nowr   r  rg  ri  rh  z{dirname}/clinic/{basename}.hr   r   r   r   r   r   r   r   r   rf   r   rA   presetr   
everything)parsersr   r*   rY  printerr<  rt  r   r|   OrderedDictmodulesclasses	functionsr  r  destinationsadd_destinationget_destination_bufferr  destination_buffers_stackr   r   presetspresets_textrJ   r;   r   rZ   r   r%   )r   r   rx  rt  r<  r   r   ru  rD   rO   rP   optionsra   rg  r   r   r   rz     sj    












zClinic.__init__c             G   s6   || j krtdt|  t||| f| | j |< d S )NzDestination already exists: )r}  r*   rY   rf  )r   rO   r   r+   r   r   r   r~    s    
zClinic.add_destinationc             C   s$   | j |}|s tdt|  |S )NzDestination does not exist: )r}  r   r*   rY   )r   rO   r   r   r   r   r    s    zClinic.get_destinationr   c             C   s   |  |}|j| S )N)r  ro  )r   rO   itemr   r   r   r   r    s    
zClinic.get_destination_bufferc          
   C   s   | j }t|| j| jd| _x| jD ]}|j}|r|| jkrb|tksPtd|t| | | j|< | j| }y|	| W n( t
k
r   tdt    Y nX || q"W i }x| j D ]\}}|jdkrq| }	|	rtdd|	d}|jdkr8d	| d
 |_tdt| d  |d
 || q|jdkrytj|j}
yt|
 W n6 tk
r   tj|
std|j|
 Y nX | jrt |jdT}t|! | jd}t"|}t#|dks|d jdkrtdt|j d  W d Q R X W n t$k
r   Y nX d|_t%| j}|| t |jd}||j&'  W d Q R X qqW |j&' }|rt%| j}t|| j}d}xX|D ]P}|jrx6| D ]*\}}||j(krd}|j()|||_(qW || qW |r|j&' }|S )N)r<  zNo parser to handle {!r} block.z!Exception raised during parsing:
ri  r   r%   )r   r   rg  zdump rA   zDestination buffer z$ not empty at end of file, emptying.rh  z7Can't write to destination {}, can't make directory {}!Zrt)r   rf   r   z	preserve
zModified destination file z, not overwriting!ZwtFT)*rx  r;  r   r<  r"   r   rw  r   r>   parse	Exceptionr*   	traceback
format_excrB   r^  r}  r   r   r   r4  r5  r.   rY   r]  rm  rj  rk  r   makedirsFileExistsErrorisdiropenreadr   r   FileNotFoundErrorrY  r   getvaluer   r1   )r   r5  rx  r  r   parserZsecond_pass_replacementsrO   r"  r   rk  r   Zparser_2blocksZ	printer_2r   changedidZreplacementr   r   r   r    s    





$





zClinic.parsec       	      C   s   d}|  }}d}g }xx|D ]p}| | |sJ|j|}|rF| }}qd}t|ds\||fS |j|}|stdd| d  | }}qW ||fS )a  
        fields should be an iterable of field names.
        returns a tuple of (module, class).
        the module object could actually be self (a clinic object).
        this function is only ever used to find the parent of where
        a new class/module should go.
        FNTr{  zParent class or module r9   z does not exist.)r   rz  r   hasattrr{  r*   r   )	r   r   
in_classesparentmoduler  so_farr7   Zchildr   r   r   _module_and_classM  s&    


zClinic._module_and_class)N)r   )
r	   r
   r   r  rz   r~  r  r  r  r  r   r   r   r   rs  |  s   +E
Prs  zutf-8)rt  r<  r   encodingc         
   C   sH  t j| d dd  }|s,tdt|   yt| | }W n$ tk
r`   tdt|   Y nX t| d|d}| }W d Q R X t	d|j
}	|	|sd S t|||| d}
|
|}||kr|sd S t j| pd}tjd	|d
X}||}t j|t j| }t|d}|| W d Q R X t ||p6|  W d Q R X d S )Nrf   z!Can't extract file type for file z"Can't identify file type for file r   )r  r   )rt  r<  r   r9   r%   )rR   dirwb)rm  rj  rn  r*   rY   
extensionsKeyErrorr  r  r;  rA  searchrs  r  rk  tempfileTemporaryDirectoryencoder   rl  r]  r1   )r   rt  r<  r   r  	extensionr   r   rawrA  r%   cooked	directoryZtmpdirbytesZtmpfilenamer   r   r   
parse_filel  s.    


r  c             C   s0   | pd} t | d }|r,|d | }|S )Nr   zutf-8)hashlibsha1r  	hexdigest)r5  r   r   r   r   r   rV    s
    rV  c               @   s   e Zd Zdd Zdd ZdS )PythonParserc             C   s   d S )Nr   )r   r%   r   r   r   rz     s    zPythonParser.__init__c          	   C   s4   t  }t| t|j W d Q R X | |_d S )N)rZ  r[  r(  execr5  r  r   )r   r  r   r   r   r   r    s    
zPythonParser.parseN)r	   r
   r   rz   r  r   r   r   r   r    s   r  c               @   s   e Zd ZdddZdd ZdS )ModuleNc             C   s0   || _ | | _| _t | _t | _g | _d S )N)rO   r  r  r|   ry  rz  r{  r|  )r   rO   r  r   r   r   rz     s
    

zModule.__init__c             C   s"   dt | j d tt|  d S )Nz<clinic.Module z at r:  )rY   rO   r   r  )r   r   r   r   r     s    zModule.__repr__)N)r	   r
   r   rz   r   r   r   r   r   r    s   
r  c               @   s   e Zd ZdddZdd ZdS )ClassNc             C   s<   || _ || _|| _|| _|| _|p$|| _t | _g | _	d S )N)
rO   r  r  typedeftype_objectr  r|   ry  r{  r|  )r   rO   r  r  r  r  r   r   r   rz     s    

zClass.__init__c             C   s"   dt | j d tt|  d S )Nz<clinic.Class z at r:  )rY   rO   r   r  )r   r   r   r   r     s    zClass.__repr__)NNNN)r	   r
   r   rz   r   r   r   r   r   r    s   
r  a  

__abs__
__add__
__and__
__bytes__
__call__
__complex__
__delitem__
__divmod__
__eq__
__float__
__floordiv__
__ge__
__getattr__
__getattribute__
__getitem__
__gt__
__hash__
__iadd__
__iand__
__ifloordiv__
__ilshift__
__imatmul__
__imod__
__imul__
__index__
__int__
__invert__
__ior__
__ipow__
__irshift__
__isub__
__iter__
__itruediv__
__ixor__
__le__
__len__
__lshift__
__lt__
__matmul__
__mod__
__mul__
__neg__
__new__
__next__
__or__
__pos__
__pow__
__radd__
__rand__
__rdivmod__
__repr__
__rfloordiv__
__rlshift__
__rmatmul__
__rmod__
__rmul__
__ror__
__rpow__
__rrshift__
__rshift__
__rsub__
__rtruediv__
__rxor__
__setattr__
__setitem__
__str__
__sub__
__truediv__
__xor__

zI
INVALID, CALLABLE, STATIC_METHOD, CLASS_METHOD, METHOD_INIT, METHOD_NEW
r   r   c            
   @   sZ   e Zd ZdZddddededddddZdZedd Z	ed	d
 Z
dd Zdd ZdS )r   aH  
    Mutable duck type for inspect.Function.

    docstring - a str containing
        * embedded line breaks
        * text outdented to the left margin
        * no trailing whitespace.
        It will always be true that
            (not docstring) or ((not docstring[0].isspace()) and (docstring.rstrip() == docstring))
    NF)r  r  r   return_annotationr   r   coexistdocstring_onlyc            C   sn   |p
t  | _|| _|| _|| _|| _|| _|p2|| _|| _	|| _
|	pHd| _|
| _|| _d | _|| _d | _d S )Nr   )r|   ry  r   r  rO   r   r  r  r  r  r   r   r   r  r   r  Zrendered_parameters)r   r   rO   r  r  r  r   r   r  r   r   r  r  r   r   r   rz     s    

zFunction.__init__c             C   sF   | j s@g  | _ }x.| j D ] }| }|j  || qW | j S )N)__render_parameters__r   r   copyr   
pre_renderr   )r   r   r   r   r   r   r  4  s    

zFunction.render_parametersc             C   sx   | j ttfkrd S g }| j tkr,|d n2| j tkrB|d n| j tks^tdt| j  | j	rn|d d
|S )NZ
METH_CLASSZMETH_STATICzunknown kind: ZMETH_COEXISTr   )r   r   r   CLASS_METHODr   STATIC_METHODCALLABLEr   rY   r  r   )r   r   r   r   r   r   >  s    


zFunction.methoddef_flagsc             C   s   d| j  d S )Nz<clinic.Function r:  )rO   )r   r   r   r   r   M  s    zFunction.__repr__c             K   s   | j | j| j| j| j| j| j| j| j| j	| j
| jd}|| tf |}t }x*|j D ]\}}|j|d}|||< q^W ||_|S )N)rO   r  r   r  r  r   r   r  r   r   r  r  )r   )rO   r  r   r  r  r   r   r  r   r   r  r  updater   r|   ry  r   r  )r   	overridesrM   r   r   rO   rP   r   r   r   r  P  s    


zFunction.copy)N)r	   r
   r   r   _emptyr  rz   r  propertyr  r   r   r  r   r   r   r   r     s   

r   c               @   sD   e Zd ZdZeedddddZdd Zd	d
 Zdd Zdd Z	dS )	Parameterz1
    Mutable duck type of inspect.Parameter.
    Nr   )r   
annotationr   r   c      	      C   s8   || _ || _|| _|| _|| _|| _|p*d| _|| _d S )Nr   )rO   r   r   r   r   r  r   r   )	r   rO   r   r   r   r   r  r   r   r   r   r   rz   i  s    
zParameter.__init__c             C   s   d| j  d S )Nz<clinic.Parameter r:  )rO   )r   r   r   r   r   u  s    zParameter.__repr__c             C   s   | j tjjkS )N)r   inspectr  KEYWORD_ONLY)r   r   r   r   is_keyword_onlyx  s    zParameter.is_keyword_onlyc             C   s   | j tjjkS )N)r   r  r  POSITIONAL_ONLY)r   r   r   r   r   {  s    zParameter.is_positional_onlyc          	   K   s`   | j | j| j| j| j| j| j| jd}|| d|krVt		| j}|d |_||d< t
f |S )N)rO   r   r   r   r   r  r   r   r   r   )rO   r   r   r   r   r  r   r   r  r  r  )r   r  rM   r   r   r   r   r  ~  s    

zParameter.copy)
r	   r
   r   r   r  rz   r   r  r   r  r   r   r   r   r  d  s   
r  c                   s,   e Zd Zdd Zdd Z fddZ  ZS )LandMinec             C   s
   || _ d S )N)__message__)r   messager   r   r   rz     s    zLandMine.__init__c             C   s   dt | j d S )Nz
<LandMine r:  )rY   r  )r   r   r   r   r     s    zLandMine.__repr__c                s2   |dkrt  |S tdt| d | j  d S )N)r   r  z3Stepped on a land mine, trying to access attribute z:
)r   __getattribute__r*   rY   r  )r   rO   )r   r   r   r    s    zLandMine.__getattribute__)r	   r
   r   rz   r   r  r%  r   r   )r   r   r    s   r  c             C   s6   |s*| j }|ds| S |d td  }| t|< | S )N
_converter)r	   r   r   r   )r   rO   r   r   r   add_c_converter  s    
r  c             C   s"   | j dkr| j tkr| t| j < | S )N)zO&r   )r   legacy_converters)r  r   r   r   add_default_legacy_c_converter  s    


r  c                s    fdd}|S )z"
    Adds a legacy converter.
    c                s(   s
| }nt j| f} r$|t < | S )N)	functoolspartialr  )r   added_f)r   rM   r   r   closure  s    z'add_legacy_c_converter.<locals>.closurer   )r   rM   r  r   )r   rM   r   add_legacy_c_converter  s    r  c               @   s   e Zd Zdd ZdS )CConverterAutoRegisterc             C   s   t |  t|  d S )N)r  r  )r  rO   bases	classdictr   r   r   rz     s    zCConverterAutoRegister.__init__N)r	   r
   r   rz   r   r   r   r   r    s   r  c               @   s   e Zd ZdZdZdZdZeZdZ	dZ
dZdZdZdZdZdZdZdZdZdZdZefddeddd	Zd
d Zdd Zdd Zdd Zdd Zdd Zdd Zd$ddZdd Zdd Z dd Z!d d! Z"d"d# Z#dS )%
CConverterz
    For the init function, self, name, function, and default
    must be keyword-or-positional parameters.  All other
    parameters must be keyword-only.
    NNULLFTzO&)	c_default
py_defaultr  c      
      K   s   || _ || _|tk	rt| jrnt|| jtfsnt| jtr@| jj}	nddd | jD }	t	d
| jj|||	 || _|r~|| _|r|| _|tkrt	d td| _| jf | || _d S )Nz, c             s   s   | ]}|j V  qd S )N)r	   )r   r  r   r   r   r8   /	  s    z&CConverter.__init__.<locals>.<genexpr>z5{}: default value {!r} for field {} is not of type {}z6The 'annotation' parameter is not currently permitted.z<Don't access members of self.function inside converter_init!)rO   py_namer   default_typer   r   r   r	   r   r*   r>   r   r   r  r  r  r   converter_init)
r   rO   r  r   r   r  r  r  rM   Z	types_strr   r   r   rz   &	  s&    

zCConverter.__init__c             C   s   d S )Nr   )r   r   r   r   r  D	  s    zCConverter.converter_initc             C   s
   | j tk	S )N)r   r   )r   r   r   r   r   G	  s    zCConverter.is_optionalc             C   s|   || _ | j}t|}| jrdnd| }|j| | jrH|j|   |j| j	| jd | jrx|jd|    d S )N&r   )by_referencezPy_ssize_clean_t )
	parameterrO   r@   impl_by_referencerw   r   r   length_namerv   simple_declaration)r   r  r!  original_namerO   r   r   r   r   _render_selfJ	  s    zCConverter._render_selfc       	      C   s$  || _ | j}t|}|  }|j| |  }|rP|jd| d |   | 	 }|rx|j
d| d |   | r|jd n|j|j |  rd|jkr|jd | rd|jkr|jd |j| j | |j |  }|r |jd| d |  d  d S )	Nz/* initializers for z */
z/* modifications for r   r   r*  z/* Cleanup for rA   )r  rO   r@   declarationrp   r   
initializerq   rB   modifyrr   r   rs   r   rt   r  r   r  ru   ry   )	r   r  r!  r  rO   r   rq   rr   ry   r   r   r   _render_non_selfZ	  s.    zCConverter._render_non_selfc             C   s   |  || | || dS )zc
        parameter is a clinic.Parameter instance.
        data is a CRenderData instance.
        N)r  r  )r   r  r!  r   r   r   r   	  s    zCConverter.renderc             C   s   | j s
dS t| jd S )z6Computes the name of the associated "length" variable.N_length)r   r@   rO   )r   r   r   r   r  	  s    zCConverter.length_namec             C   s   | j r| jrt| jdkr0| j s$t|| j  | jrH|t| j n| jrZ|| j t| j}| j	rndnd| }|| | j
r|d|    d S )NzO&r  r   )r   r  r   r   r   r5   subclass_ofr@   rO   parse_by_referencer   r  )r   r   Z
legal_namer   r   r   r   r  	  s    



zCConverter.parse_argumentc             C   sJ   | j g}|s| j ds"|d |r0|d |t| j d|S )z
        Computes the basic declaration of the variable.
        Used in computing the prototype declaration and the
        variable declaration.
        r   r   r   )r   r   r   r@   rO   r   )r   r  r   r   r   r   r  	  s    

zCConverter.simple_declarationc             C   sv   |   g}| j}|s"| jjr"| j}|r:|d || |d | jrl|d ||   |d d|S )z;
        The C statement to declare this variable.
        z = r   z
Py_ssize_clean_t r   )	r  r  r  r   c_ignored_defaultr   r   r  r   )r   r  r   r   r   r   r  	  s    





zCConverter.declarationc             C   s   dS )z
        The C statements required to set up this variable before parsing.
        Returns a string containing this code indented at column 0.
        If no initialization is necessary, returns an empty string.
        r   r   )r   r   r   r   r  	  s    zCConverter.initializec             C   s   dS )z
        The C statements required to modify this variable after parsing.
        Returns a string containing this code indented at column 0.
        If no initialization is necessary, returns an empty string.
        r   r   )r   r   r   r   r  	  s    zCConverter.modifyc             C   s   dS )z
        The C statements required to clean up after this variable.
        Returns a string containing this code indented at column 0.
        If no cleanup is necessary, returns an empty string.
        r   r   )r   r   r   r   ry   	  s    zCConverter.cleanupc             C   s   dS )z
        A second initialization function, like converter_init,
        called just before rendering.
        You are permitted to examine self.function here.
        Nr   )r   r   r   r   r  	  s    zCConverter.pre_render)F)$r	   r
   r   r   rO   r  r   r   r   r  r  r  r  r   r  r  r   r  r  r   show_in_signaturesignature_namerz   r  r   r  r  r   r  r  r  r  r  r  ry   r  r   r   r   r   r    s@   (	
r  c               @   s,   e Zd ZdZeZdZdZehdddZ	dS )bool_converterrZ   r   0)acceptc            C   sV   |t hkrd| _n|thkr,tdt|  | jtk	rRt| j| _tt | j| _	d S )Nrk   z*bool_converter: illegal 'accept' argument )
rZ   r   objectr*   rY   r   r   boolr   r  )r   r  r   r   r   r  	  s    


zbool_converter.converter_initN)
r	   r
   r   r   r  r  r   r  r  r  r   r   r   r   r  	  s
   r  c               @   s(   e Zd ZdZeefZdZdZdd Z	dS )char_convertercharrc   z' 'c             C   s2   t | j| jr.t| jdkr.tdt| j  d S )Nrf   z&char_converter: illegal default value )r   r   r  r   r*   rY   )r   r   r   r   r  	  s    zchar_converter.converter_initN)
r	   r
   r   r   r  	bytearrayr  r   r  r  r   r   r   r   r  	  s
   r  B)bitwisec               @   s*   e Zd ZdZeZdZdZddddZdS )	unsigned_char_converterzunsigned charrl   z' 'F)r  c            C   s   |r
d| _ d S )Nr  )r   )r   r  r   r   r   r  
  s    z&unsigned_char_converter.converter_initN)	r	   r
   r   r   rZ   r  r   r  r  r   r   r   r   r  
  s
   r  c               @   s   e Zd ZdS )byte_converterN)r	   r
   r   r   r   r   r   r  
  s    r  c               @   s   e Zd ZdZeZdZdZdS )short_convertershorthr  N)r	   r
   r   r   rZ   r  r   r  r   r   r   r   r  
  s   r  c               @   s*   e Zd ZdZeZdZdZddddZdS )	unsigned_short_converterzunsigned shortHr  F)r  c            C   s   |st d d S )Nz*Unsigned shorts must be bitwise (for now).)r*   )r   r  r   r   r   r  
  s    z'unsigned_short_converter.converter_initN)	r	   r
   r   r   rZ   r  r   r  r  r   r   r   r   r  
  s
   r  r   )r  c               @   s.   e Zd ZdZeZdZdZehddddZdS )int_converterrZ   rk   r  N)r  r   c            C   s>   |t hkrd| _n|thkr,tdt|  |d kr:|| _d S )Nr   z)int_converter: illegal 'accept' argument )r   r   rZ   r*   rY   r   )r   r  r   r   r   r   r  (
  s    

zint_converter.converter_init)	r	   r
   r   r   rZ   r  r   r  r  r   r   r   r   r  !
  s
   r  c               @   s*   e Zd ZdZeZdZdZddddZdS )	unsigned_int_converterzunsigned intIr  F)r  c            C   s   |st d d S )Nz(Unsigned ints must be bitwise (for now).)r*   )r   r  r   r   r   r  6
  s    z%unsigned_int_converter.converter_initN)	r	   r
   r   r   rZ   r  r   r  r  r   r   r   r   r   0
  s
   r   c               @   s   e Zd ZdZeZdZdZdS )long_converterlongr   r  N)r	   r
   r   r   rZ   r  r   r  r   r   r   r   r  :
  s   r  c               @   s*   e Zd ZdZeZdZdZddddZdS )	unsigned_long_converterzunsigned longkr  F)r  c            C   s   |st d d S )Nz)Unsigned longs must be bitwise (for now).)r*   )r   r  r   r   r   r  F
  s    z&unsigned_long_converter.converter_initN)	r	   r
   r   r   rZ   r  r   r  r  r   r   r   r   r  @
  s
   r  c               @   s   e Zd ZdZeZdZdZdS )long_long_converterz	long longLr  N)r	   r
   r   r   rZ   r  r   r  r   r   r   r   r  J
  s   r  c               @   s*   e Zd ZdZeZdZdZddddZdS )	unsigned_long_long_converterzunsigned long longKr  F)r  c            C   s   |st d d S )Nz-Unsigned long long must be bitwise (for now).)r*   )r   r  r   r   r   r  V
  s    z+unsigned_long_long_converter.converter_initN)	r	   r
   r   r   rZ   r  r   r  r  r   r   r   r   r  P
  s
   r  c               @   s$   e Zd ZdZdZehdddZdS )Py_ssize_t_converter
Py_ssize_tr  )r  c            C   s@   |t hkrd| _t | _n$|t thkr,d| _ntdt|  d S )NnZ_Py_convert_optional_to_ssize_tz0Py_ssize_t_converter: illegal 'accept' argument )rZ   r   r  NoneTyper   r*   rY   )r   r  r   r   r   r  _
  s    
z#Py_ssize_t_converter.converter_initN)r	   r
   r   r   r  rZ   r  r   r   r   r   r
  [
  s   r
  c               @   s"   e Zd ZdZeehdddZdS )slice_index_converterr  )r  c            C   s:   |t hkrd| _n$|t thkr&d| _ntdt|  d S )NZ_PyEval_SliceIndexNotNoneZ_PyEval_SliceIndexz1slice_index_converter: illegal 'accept' argument )rZ   r   r  r*   rY   )r   r  r   r   r   r  l
  s
    
z$slice_index_converter.converter_initN)r	   r
   r   r   rZ   r  r  r   r   r   r   r  i
  s   r  c               @   s   e Zd ZdZeZdZdZdS )float_converterfloatr   z0.0N)r	   r
   r   r   r  r  r   r  r   r   r   r   r  u
  s   r  c               @   s   e Zd ZdZeZdZdZdS )double_converterdoubler   z0.0N)r	   r
   r   r   r  r  r   r  r   r   r   r   r  {
  s   r  c               @   s   e Zd ZdZeZdZdZdS )Py_complex_converterZ
Py_complexDz
{0.0, 0.0}N)r	   r
   r   r   complexr  r   r  r   r   r   r   r  
  s   r  c               @   s&   e Zd ZdZdZddddddZdS )r   z
PyObject *r   N)r   r   r  c            C   s@   |r|rt d d| _|| _n|r.d| _|| _|d k	r<|| _d S )Nz9object: Cannot pass in both 'converter' and 'subclass_of'zO&zO!)r*   r   r   r  r   )r   r   r   r  r   r   r   r  
  s    zobject_converter.converter_init)r	   r
   r   r   r   r  r   r   r   r   r   
  s   r   c               @   s   e Zd ZdS )rg  N)r	   r
   r   r   r   r   r   rg  
  s    rg  c               @   s   e Zd ZdS )rwbufferN)r	   r
   r   r   r   r   r   r  
  s    r  c               @   s   e Zd ZdS )robufferN)r	   r
   r   r   r   r   r   r  
  s    r  c             C   s   t | t|t|fS )N)	frozensetr  )typesr  zeroesr   r   r   str_converter_key
  s    r  c               @   s:   e Zd ZdZeeefZdZehdddddZ	dd	 Z
dS )
str_converterzconst char *r   NF)r  r  r  c            C   sf   t |||}t|}|s$td| || _t|| _|rb| jtd t	fkrPtd || _
d| _d| _d S )Nz/str_converter: illegal combination of argumentszQstr_converter: Argument Clinic doesn't support default values for encoded stringszchar *r  )r  str_converter_argument_mapr   r*   r   r  r   r   r   r   r  r   r  )r   r  r  r  r   r   r   r   r   r  
  s    


zstr_converter.converter_initc             C   s(   | j r$t| j}dd|d|dgS d S )Nr   zif (z) {
   PyMem_FREE(z);
}
)r  r@   rO   r   )r   rO   r   r   r   ry   
  s    
zstr_converter.cleanup)r	   r
   r   r   r   r   r  r  r   r  ry   r   r   r   r   r  
  s
   
r  )r  r  c            C   sr   |sD| dkrDi }|t hkr"||d< |r.d|d< tjtf|}|t| < t}t|||}||krftd | ||< d S )Nr   r  Tr  z8Duplicate keys specified for str_converter_argument_map!)	r   r  r  r  r  r  r  r(   r)   )r   r  r  r  rM   r  r   r   r   r   r   r   
  s    	

r   es)r  r  zes#)r  r  r  etzet#r   zs#)r  r  yzy#zzz#c               @   s   e Zd ZdZdZdS )PyBytesObject_converterzPyBytesObject *SN)r	   r
   r   r   r   r   r   r   r   r"  
  s   r"  c               @   s   e Zd ZdZdZdS )PyByteArrayObject_converterzPyByteArrayObject *YN)r	   r
   r   r   r   r   r   r   r   r$  
  s   r$  c               @   s   e Zd ZdZeeefZdZdS )unicode_converterz
PyObject *UN)	r	   r
   r   r   r   r   r  r  r   r   r   r   r   r&    s   
r&  zu#)r  ZzZ#)r  r  c               @   s0   e Zd ZdZeeefZdZehddddZ	dS )Py_UNICODE_converterzconst Py_UNICODE *uF)r  r  c            C   s0   |t thkrdnd}|r&|d7 }d| _|| _d S )Nr(  r*  r   T)r   r  r   r   )r   r  r  r   r   r   r   r    s
    z#Py_UNICODE_converter.converter_initN)
r	   r
   r   r   r   r   r  r  r   r  r   r   r   r   r)    s   
r)  zs*zz*zw*c               @   s4   e Zd ZdZdZdZdZehdddZdd	 Z	d
S )Py_buffer_converterZ	Py_bufferzy*Tz{NULL, NULL})r  c            C   sv   | j td fkrtd | j| _|ttthkr2d}n:|tthkrDd}n(|thkrTd}n|thkrdd}ntd || _	d S )Nz3The only legal default value for Py_buffer is None.zz*zs*zy*zw*z5Py_buffer_converter: illegal combination of arguments)
r   r   r*   r  r  r   rg  r  r  r   )r   r  r   r   r   r   r    s    

z"Py_buffer_converter.converter_initc             C   s   t | j}dd|d|dgS )Nr   zif (z.obj) {
   PyBuffer_Release(&z);
}
)r@   rO   r   )r   rO   r   r   r   ry   2  s    
zPy_buffer_converter.cleanupN)
r	   r
   r   r   r   r  r  rg  r  ry   r   r   r   r   r+    s   r+  c             C   sR   | j ttfkr| jrdS dS | j tkr*dS | j ttfkr<dS tdt| j  d S )N)z
PyObject *r   )z
PyObject *r  )zvoid *null)zPyTypeObject *r   zUnhandled type of function f: )	r   r  r   r  r  r  r   RuntimeErrorrY   )r   r   r   r   correct_name_for_self7  s    
r.  c             C   s&   t | \}}| jttttfkr"|S d S )N)r.  r   r   r   r  r  )r   r   r   r   r   r   !required_type_for_self_for_parserB  s    r/  c               @   sJ   e Zd ZdZdZdZddddZdd Zed	d
 Z	dd Z
dd ZdS )r   zV
    A special-case converter:
    this is the default converter used for "self".
    Nr   )r   c            C   s
   || _ d S )N)specified_type)r   r   r   r   r   r  Q  s    zself_converter.converter_initc             C   sT   | j }t|\}}|| _| jp&| jp&|| _| j j}|ttfk}|tksJ|rPd| _	d S )NF)
r   r.  r  r0  r   r   r   r   r  r  )r   r   r  default_namer   r   r   r   r   r  T  s    zself_converter.pre_renderc             C   s   t | jp| jS )N)r/  r   r   )r   r   r   r   parser_type  s    zself_converter.parser_typec             C   sp   | j jtkrdS | || | j| jkrlt|jdks:t|jd | j	ksNtd| j d |jd  |jd< dS )zc
        parameter is a clinic.Parameter instance.
        data is a CRenderData instance.
        Nrf   r   r   r   )
r   r   r  r  r   r2  r   rw   r   rO   )r   r  r!  r   r   r   r     s    zself_converter.renderc             C   s|   | j |d< | j|d< | jj}| jj}|ttfkrx|rx|jrx|tkrJ| j }nd| j }d}| jjj	|d}|
||d< d S )Nr  r  zPy_TYPE({})z/({passed_in_type} == {type_object}) &&
        )r  passed_in_typer  )rO   r2  r   r   r  r   r   r  r>   r  r	  )r   r
  r   r  r3  rD   r   r   r   r   r    s    

z self_converter.set_template_dict)r	   r
   r   r   r   r   r  r  r  r2  r   r  r   r   r   r   r   I  s   3r   c             C   s6   |s*| j }|ds| S |d td  }| t|< | S )N_return_converter)r	   r   r   return_converters)r   rO   r   r   r   add_c_return_converter  s    
r6  c               @   s   e Zd Zdd ZdS )CReturnConverterAutoRegisterc             C   s   t |  d S )N)r6  )r  rO   r  r  r   r   r   rz     s    z%CReturnConverterAutoRegister.__init__N)r	   r
   r   rz   r   r   r   r   r7    s   r7  c               @   sL   e Zd ZdZdZddddZdd Zdd	d
Zdd Zdd Z	dd Z
dS )CReturnConverterz
PyObject *N)r  c         
   K   sx   || _ y| jf | W n\ tk
rr } z>ddd | D }t| jjd | d t	|  W d d }~X Y nX d S )Nz, c             s   s"   | ]\}}|d  t | V  qdS )rT  N)rY   )r   rO   rP   r   r   r   r8     s    z,CReturnConverter.__init__.<locals>.<genexpr>r   z)
)
r  return_converter_init	TypeErrorr   r   r(   r)   r   r	   r   )r   r  rM   er   r   r   r   rz     s    zCReturnConverter.__init__c             C   s   d S )Nr   )r   r   r   r   r9    s    z&CReturnConverter.return_converter_init_return_valuec             C   sP   g }|j }|| j | jds(|d ||d  |j d| ||_d S )Nr   r   r   r   )r   r   r   rp   r   ro   )r   r!  rO   rD   r,   r   r   r   declare  s    
zCReturnConverter.declarec             C   s   |j d| d S )Nz3if (({}) && PyErr_Occurred()) {{
    goto exit;
}}
)rx   r   r>   )r   exprr!  r   r   r   err_occurred_if  s    z CReturnConverter.err_occurred_ifc             C   s   |j d| d S )Nz%if ({} == NULL) {{
    goto exit;
}}
)rx   r   r>   )r   variabler!  r   r   r   err_occurred_if_null_pointer  s    z-CReturnConverter.err_occurred_if_null_pointerc             C   s   dS )za
        function is a clinic.Function instance.
        data is a CRenderData instance.
        Nr   )r   r   r!  r   r   r   r     s    zCReturnConverter.render)r<  )r	   r
   r   r   r   rz   r9  r=  r?  rA  r   r   r   r   r   r8    s   

r8  r  c               @   s   e Zd Zdd ZdS )NoneType_return_converterc             C   s   |  | |jd  d S )Nz^
if (_return_value != Py_None) {
    goto exit;
}
return_value = Py_None;
Py_INCREF(Py_None);
)r=  rx   r   rJ   )r   r   r!  r   r   r   r     s    
z NoneType_return_converter.renderN)r	   r
   r   r   r   r   r   r   rB    s   rB  c               @   s   e Zd ZdZdd ZdS )bool_return_converterrZ   c             C   s&   |  | | d| |jd d S )Nz_return_value == -1z5return_value = PyBool_FromLong((long)_return_value);
)r=  r?  rx   r   )r   r   r!  r   r   r   r     s    
zbool_return_converter.renderN)r	   r
   r   r   r   r   r   r   r   rC    s   rC  c               @   s$   e Zd ZdZdZdZdZdd ZdS )long_return_converterr  ZPyLong_FromLongr   c          	   C   sB   |  | | d| j| |jdd| jd| jdf d S )Nz_return_value == {}-1r   zreturn_value = r   z_return_value);
)	r=  r?  r>   unsigned_castrx   r   r   conversion_fncast)r   r   r!  r   r   r   r     s    
zlong_return_converter.renderN)r	   r
   r   r   rF  rG  rE  r   r   r   r   r   rD    s
   rD  c               @   s   e Zd ZdZdZdS )int_return_converterrZ   z(long)N)r	   r
   r   r   rG  r   r   r   r   rH    s   rH  c               @   s    e Zd ZdZdZdZdd ZdS )init_return_converterz:
    Special return converter for __init__ functions.
    rZ   z(long)c             C   s   d S )Nr   )r   r   r!  r   r   r   r     s    zinit_return_converter.renderN)r	   r
   r   r   r   rG  r   r   r   r   r   rI    s   rI  c               @   s   e Zd ZdZdZdZdS )unsigned_long_return_converterzunsigned longZPyLong_FromUnsignedLongz(unsigned long)N)r	   r
   r   r   rF  rE  r   r   r   r   rJ    s   rJ  c               @   s   e Zd ZdZdZdZdS )unsigned_int_return_converterzunsigned intz(unsigned long)z(unsigned int)N)r	   r
   r   r   rG  rE  r   r   r   r   rK  !  s   rK  c               @   s   e Zd ZdZdZdS )Py_ssize_t_return_converterr  ZPyLong_FromSsize_tN)r	   r
   r   r   rF  r   r   r   r   rL  &  s   rL  c               @   s   e Zd ZdZdZdZdS )size_t_return_converterZsize_tZPyLong_FromSize_tz(size_t)N)r	   r
   r   r   rF  rE  r   r   r   r   rM  *  s   rM  c               @   s   e Zd ZdZdZdd ZdS )double_return_converterr  r   c             C   s0   |  | | d| |jd| j d  d S )Nz_return_value == -1.0z"return_value = PyFloat_FromDouble(z_return_value);
)r=  r?  rx   r   rG  )r   r   r!  r   r   r   r   4  s    
zdouble_return_converter.renderN)r	   r
   r   r   rG  r   r   r   r   r   rN  0  s   rN  c               @   s   e Zd ZdZdZdS )float_return_converterr  z(double)N)r	   r
   r   r   rG  r   r   r   r   rO  :  s   rO  c               @   s   e Zd ZdZdd ZdS ) DecodeFSDefault_return_converterzchar *c             C   s&   |  | | d| |jd d S )Nr<  z9return_value = PyUnicode_DecodeFSDefault(_return_value);
)r=  rA  rx   r   )r   r   r!  r   r   r   r   B  s    
z'DecodeFSDefault_return_converter.renderN)r	   r
   r   r   r   r   r   r   r   rP  ?  s   rP  -)r   c            C   s:   t | tjr| j} t| } t| |d}t||}| S )z
    Takes an ast.Expr node.  Compiles and evaluates it.
    Returns the result of the expression.

    globals represents the globals dict the expression
    should see.  (There's no equivalent for "locals" here.)
    eval)r   astZExprrP   Z
Expressionr-  r  FunctionType)nodeglobalsr   cofnr   r   r   eval_ast_exprI  s    	
rY  c               @   sH   e Zd Zdd Zdd Zdd Zdd Zed	d
 Zdd Z	dd Z
dS )IndentStackc             C   s   g | _ d | _d S )N)indentsmargin)r   r   r   r   rz   \  s    zIndentStack.__init__c             C   s   | j std d S )Nz3IndentStack expected indents, but none are defined.)r[  r*   )r   r   r   r   _ensure`  s    zIndentStack._ensurec             C   sB   d|krt d | }t|s2|   | jd S t|t| S )z:
        Returns the length of the line's margin.
        	z6Tab characters are illegal in the Argument Clinic DSL.r$   )r*   rL  r   r]  r[  )r   rD   strippedr   r   r   measured  s    
zIndentStack.measurec             C   s   |  |}d| }| js.| j| || _dS | jd }||krDdS ||krb| j| || _dS || jkrttd d}x(||kr| j  | jd }|d8 }qzW || _|S )z
        Infer what is now the current margin based on this line.
        Returns:
            1 if we have indented (or this is the first margin)
            0 if the margin has not changed
           -N if we have dedented N times
        r   rf   r$   r   zIllegal outdent.)r`  r[  r   r\  r*   rC   )r   rD   rL   r\  currentZoutdent_countr   r   r   inferr  s,    





zIndentStack.inferc             C   s
   t | jS )zA
        Returns how many margins are currently defined.
        )r   r[  )r   r   r   r   depth  s    zIndentStack.depthc             C   s
   | j | S )zA
        Indents a line by the currently defined margin.
        )r\  )r   rD   r   r   r   rL     s    zIndentStack.indentc             C   s.   | j }| jd }||s"td ||d S )zd
        Dedents a line by the currently defined margin.
        (The inverse of 'indent'.)
        r$   z<Cannot dedent, line does not start with the previous margin:N)r\  r[  rP  r*   )r   rD   r\  rL   r   r   r   r     s
    

zIndentStack.dedentN)r	   r
   r   rz   r]  r`  rb  r  rc  rL   r   r   r   r   r   rZ  [  s    rZ  c               @   s  e Zd Zdd Zdd Zdd Zdd Zd	d
 Zdd Zdd Z	d@ddZ
dd Zdd Zdd Zdd Zdd Zdd Zdd Zed d! Zed"d# ZdAd%d&Zd'd( Zd)d* Zed+\ZZZZZZZd,d- Z d.d/ Z!d0d1 Z"d2d3 Z#d4d5 Z$d6d7 Z%d8d9 Z&d:d; Z'd<d= Z(d>d? Z)d$S )B	DSLParserc             C   sv   || _ i | _x\t| D ]P}|d\}}}|r>t| || j|< |d\}}}|rt| || jd| < qW |   d S )NZ
directive_Zat_@)r%   
directivesr  rI   r&   reset)r   r%   rO   r   r   r   r   r   r   rz     s    zDSLParser.__init__c             C   sX   d | _ | j| _d | _d| _d| _d| _| j| _d| _	t
 | _t| _d| _d| _d| _d S )NFr   r   )r   state_dsl_startstateZparameter_indentkeyword_onlypositional_onlyr   ps_startparameter_stateZseen_positional_with_defaultrZ  rL   r  r   r  parameter_continuationpreserve_output)r   r   r   r   rg    s    zDSLParser.resetc             C   s&   t t|dk r"tdt d |  d S )Nr   z(Insufficient Clinic version!
  Version: z
  Required: )rm   r\   r*   )r   r   r   r   r   directive_version  s    zDSLParser.directive_versionc             C   sr   | d}| }| j|\}}|r.td ||jkrLtdt| d  t||}||j|< | j	j
| d S )Nr9   z#Can't nest a module inside a class!zAlready defined module r  )r;   rC   r%   r  r*   r{  rY   r  rz  r  r   r   )r   rO   r   r3   r  r  mr   r   r   directive_module  s    



zDSLParser.directive_modulec             C   s   | d}d}| }| }g }| j|\}}	|	p4|}||jkrTtdt| d  t|||	||}
|
|j|< | jj	
|
 d S )Nr9   FzAlready defined class r  )r;   rC   r%   r  r{  r*   rY   r  r  r   r   )r   rO   r  r  r   r  r  r  r  r  rc   r   r   r   directive_class  s    


zDSLParser.directive_classc             C   s6   |dkrt dt| |ddd}|| jj|< d S )N)r  r  zunknown variablez/*z*/)zblock comment startzblock comment end)r*   rY   r	  r%   __dict__)r   rO   rP   r   r   r   directive_set  s    
zDSLParser.directive_setc             G   sH   |dkr| j j|f|  d S |dkr6| j |  tdt| d S )Nr3   r   zunknown destination command)r%   r~  r  r   r*   rY   )r   rO   commandr+   r   r   r   directive_destination  s    zDSLParser.directive_destinationr   c             C   s(  | j j}|dkrD| j j|}|s6tdt| d  || d S |dkrb| j j|	  d S |dkr| j jsztd | j j
 }|| d S |dkr| jjt| | jjd d S | j |}|d	krxt|D ]}|||< qW d S ||krtd
t| d d|  |||< d S )Nru  zUnknown preset r  pushrC   z#Can't 'output pop', stack is empty!r'   rA   rv  z#Invalid command / destination name z5, must be one of:
  preset push pop print everything r   )r%   r  r  r   r*   rY   r  r  r   r  rC   r  r   pprintpformatr  r   r   )r   Zcommand_or_namer"  fdru  Zprevious_fdr   rO   r   r   r   directive_output  s8    


zDSLParser.directive_outputc             C   s   | j j| j|  d S )N)r  r   r   r%   r  r   )r   rO   r   r   r   directive_dump*  s    zDSLParser.directive_dumpc             G   s&   | j jd| | j jd d S )Nr   rA   )r  r   r   r   )r   r+   r   r   r   directive_print-  s    zDSLParser.directive_printc             C   s   | j rtd d| _ d S )Nz'Can't have preserve twice in one block!T)ro  r*   )r   r   r   r   directive_preserve1  s    zDSLParser.directive_preservec             C   s   | j tk	rtd t| _ d S )Nz9Can't set @classmethod, function is not a normal callable)r   r  r*   r  )r   r   r   r   at_classmethod6  s    
zDSLParser.at_classmethodc             C   s   | j tk	rtd t| _ d S )Nz:Can't set @staticmethod, function is not a normal callable)r   r  r*   r  )r   r   r   r   at_staticmethod;  s    
zDSLParser.at_staticmethodc             C   s   | j rtd d| _ d S )NzCalled @coexist twice!T)r  r*   )r   r   r   r   
at_coexist@  s    zDSLParser.at_coexistc             C   s   |    || _| jj| _g |_| jjj}|jd}xBt	|| jjj
D ].\}}d|krjtdt| |d | | qFW | | j | d  |j| jjt|j | jr|jrtd | j|_d S )NrA   r^  z/Tab characters are illegal in the Clinic DSL.
	)r   z?'preserve' only works for blocks that don't produce any output!)rg  r  r   Zsaved_outputr%   r"   r   r5  r;   ri   r@  r*   rY   ri  nextstate_terminalr   r   r   r   ro  )r   r  Zblock_startr   r   rD   r   r   r   r  E  s"    


zDSLParser.parsec             C   s"   |   drdS |  sdS dS )Nr   TF)rL  rP  rJ   )rD   r   r   r   ignore_line[  s
    zDSLParser.ignore_linec             C   s   t | t |   S )N)r   rJ   )rD   r   r   r   calculate_indenth  s    zDSLParser.calculate_indentNc             C   s   || _ |d k	r|  | d S )N)ri  )r   ri  rD   r   r   r   r  l  s    zDSLParser.nextc          
   C   s   |  |rd S t|}|d }| j|d }|rzy||dd    W n. tk
rt } ztt| W d d }~X Y nX d S | | j	| d S )Nr   rf   )
r  rU  r;   rf  r   r:  r*   r   r  state_modulename_name)r   rD   r   Zdirective_name	directiver;  r   r   r   rh  r  s    

zDSLParser.state_dsl_startc          
   C   s  |  sd S | j| |d\}}}|r|d\}}}|  }|  }|  }t|r|rnt|rt|rdd |dD }| }	| j	
|\}
}x"|p|
jD ]}|j|	krP qW d }|std|d|
d| td	|j td
t| d  dd |dD }| }	| j	
|\}
}|j| jkrF|j| jksNtd |j|	||
||dd| _| jj| j |p~|
j| j | | j d S |d\}}}|d\}}}|  }|  pd }t|std| |rt|std| d }|rd|}d }
yt|}
W n tk
rB   Y nX |
s^td| d |  yX| |
jd j\}}}|rtd| |t krtdt|  t | f |}W n* t!k
r   td| d |  Y nX dd |dD }| }	| j	
|\}
}|d}|d dkrH| jt"ks8|s@td t#| _nZ|d dkr| jt$ksh|sptd t%| _|st& }n|d t'krt|d d  |st( }|
std t|   d  t)|	||
|||| j| jd!| _| jj| j t*| j\}}i }|r&|d"kr&|j+|d#< t,||| jf| }| j_,t-|jt.j-j/| j|d$}|| jj0|j< |pn|
j| j | | j1 d S )%NrT  z as c             S   s   g | ]}|  qS r   )rJ   )r   r   r   r   r   r     s    z3DSLParser.state_modulename_name.<locals>.<listcomp>r9   classr  existingzcls. functionsz Couldn't find existing function r  c             S   s   g | ]}|  qS r   )rJ   )r   r   r   r   r   r     s    zZ'kind' of function and cloned function don't match!  (@classmethod/@staticmethod/@coexist)r   )rO   r   r  r  r  r   z->zIllegal function name: {}zIllegal C basename: {}zdef x() -> {}: passzBadly-formed annotation for z: r   z7Legacy converter {!r} not allowed as a return converterz%No available return converter called c             S   s   g | ]}|  qS r   )rJ   )r   r   r   r   r   r     s    r$   r  z__new__ must be a class method!rz   z?__init__ must be a normal method, not a class or static method!zH is a special method and cannot be converted to Argument Clinic!  (Yet.)z(Undefined module used in declaration of )rO   r   r  r  r  r   r   r  z
PyObject *r   )r   r   )2rJ   rL   rb  
rpartitionrI   r<   r6   r;   rC   r%   r  r|  rO   r'   r*   rY   r   r  r  r   r  r   r   r  state_function_docstringr>   rS  r  SyntaxErrorparse_converterr   returnsr5  rX   r  r   r  r   rI  unsupported_special_methodsr8  r   r.  r  r   r  r  r  r   state_parameters_start)r   rD   r.  rW  r  r   r   r  r   Zfunction_namer  r  Zexisting_functionr  r   	ast_inputrO   legacyrM   r   ZscZp_selfr   r   r   r    s    







zDSLParser.state_modulename_name   c             C   s<   |  |rd S | j|s(| | j|S d| _| | j|S )Nr   )r  rL   rb  r  r  rn  state_parameter)r   rD   r   r   r   r  L  s    
z DSLParser.state_parameters_startc             C   s8   | j | jkr4| j| _ x| jj D ]}|j |_q"W dS )z?
        Transition to the "required" parameter state.
        N)rm  ps_requiredr   r   r   r   )r   r   r   r   r   to_requiredX  s    zDSLParser.to_requiredc       !      C   s  | j r| j d |  }d| _ | |r,d S | jjdks<t| j|}|dkr^| | j|S |dkrt| | j	|S |
 }|dr|d d | _ d S | }|dkr| | d S | j| j| jfkr|   nn| j| jkr| j| _nX| j| jkr| js@|   n8| j| j| jfkrn"td| jj d	 t| j d
  d }|d\}}}|r| }d|kr| d}|std |d }|dr|d7 }|d d }||d< d|}|d\}}	}
|	s|
}d }
d }yd|}t !|}W nJ t"k
rF   yd }
d|}t !|}W n t"k
r@   Y nX Y nX |sftd| jj d |  |j#d j$}t%|j$dkrtd| jj d |  |j&s|j'rtd| jj d |  |j(s|j)rtd| jj d |  |j$d }|j*}| +|j,\}}}|
sN| j| jkr4tdt-| d  t.}d|krtd nL| j| jkrd| j| _|
 }
d}d|
}d}yzt !|}d|krG dd dt j/}| }|0| |j1}nhyt2|
}|t.krtd W nH t3k
r   Y n4 t4k
r& } ztd|
| W d d }~X Y nX |r>td t-|
  |j#d j5}t6|t j7rt|j8d!krtt9}d"}d!}nt6|t j:st6|t j;rt6|j<t j=s|>d}t6|tr|std#t-|
 d$  |
}t?}nt6|t j@rg }|}x&t6|t j@r|A|jB |j5}qW t6|t j7s<td%t-|
 d&  |A|j8 d'tC|}|>d}t6|trr|std(t-| d$  yt2|}W n t3k
r   t?}Y nX nHt D|}t-|}t6|tEd jFfrd)| }nt6|trtG|}n|}W n t"k
r0 } ztd*t-|jH  W d d }~X Y nR tItJfk
r   t?}|>d}|
}t6|trh|s|td(t-| d$  Y nX |Kd| |Kd| |rtLntM}|rd+nd}||krtd,|| || |p||| j|f|}| jNrtOjPjQntOjPjR}t6|tSrt%| jjTdkrz| j| jkr:td- |t.k	rLtd. | jr\td/ tOjPjU}| j| _| jjTV  ntd0 tP||| j||| jd1} || jjTkrtd2t-| d3  | | jjT|< d S )4Nr   r      r$   rf   r/   )r   /[]z	Function z; has an unsupported group configuration. (Unexpected state z.a)z as zInvalid 'as' clause!r   :rT  zdef x({}): passz( has an invalid parameter declaration:
	z1 has an invalid parameter declaration (comma?):
	z9 has an invalid parameter declaration (default value?):
	z; has an invalid parameter declaration (*args? **kwargs?):
	z*Can't have a parameter without a default (z#)
after a parameter with a default!r  z@You can't specify py_default without specifying a default value!Fzx = {}r  c               @   sD   e Zd ZdZdd ZeZeZe ZZe Z	Z
e ZZe ZZeZdS )z1DSLParser.state_parameter.<locals>.DetectBadNodesFc             S   s
   d| _ d S )NT)bad)r   rU  r   r   r   bad_node  s    z:DSLParser.state_parameter.<locals>.DetectBadNodes.bad_nodeN)r	   r
   r   r  r  Z
visit_CallZvisit_IfExpZvisit_ListCompZvisit_SetCompZvisit_DictCompZvisit_GeneratorExpZ
visit_DictZ	visit_SetZ
visit_ListZvisit_TupleZvisit_Starredr   r   r   r   DetectBadNodes  s   r  z+'unspecified' is not a legal default value!z<Malformed expression given as default value
{!r} caused {!r}z)Unsupported expression as default value: r  Nonez When you specify an expression (z<) as your default value,
you MUST specify a valid c_default.zUnsupported default value z  (looked like a Python constant)r9   z#When you specify a named constant (ZPy_zSyntax error: zlegacy z{} is not a valid {}converterz-A 'self' parameter cannot be marked optional.z/A 'self' parameter cannot have a default value.z2A 'self' parameter cannot be in an optional group.zVA 'self' parameter, if specified, must be the very first thing in the parameter block.)r   r   r   r   z$You can't have two parameters named r  )Wrn  rL  r  rL   rc  r   rb  r  r  state_parameter_docstring_startrB   r   parse_special_symbolrm  rl  r  r  ps_left_square_beforeps_group_beforer   ps_group_afterps_optionalr*   r   rO   r   rI   rJ   r;   r   r  r>   rS  r  r  r   r+   r   defaultskw_defaultsvarargkwargr   r  r  rY   r   ZNodeVisitorvisitr  rR  	NameErrorr  rP   r   Namer  r  ZBinOpZUnaryOpZoperandNumr   unknown	Attributer   r   r   literal_evalr  r   r5   r   rX   AttributeError
setdefaultr  r   rj  r  r  r  POSITIONAL_OR_KEYWORDr   r   r  r   )!r   rD   rL   Zc_namerO   Zhave_as_tokenrN   r   baserW  r   r  r  Zfunction_argsr  parameter_namer  rM   rP   r  r  	blacklistr;  r>  r  r  r   r  dictZ
legacy_strr   r   r   r   r   r   r  a  sP   





"















"


zDSLParser.state_parameterc                sp   t |tjr|jdi fS t |tjr0|jdi fS t |tjsDtd |jj}t	   fdd|j
D }|d|fS )NTFz@Annotations must be either a name, a function call, or a string.c                s   i | ]}t |j |jqS r   )rY  rP   r   )r   rU  )symbolsr   r   rq  ]  s    z-DSLParser.parse_converter.<locals>.<dictcomp>)r   rS  Strr   r  r  ZCallr*   funcrV  rs   )r   r  rO   rM   r   )r  r   r  P  s    zDSLParser.parse_converterc                sR  |dkr, j r"td jj d  d _ n"|dkr j j jfkrP j _n> j j jfkrl j _n"td jj d t	 j d    j
d7  _
d j_n|d	krl j
std jj d
  t fdd jj D std jj d    j
d8  _
 j j jfkr* j _n@ j j jfkrH j _n"td jj d t	 j d  n|dkrN jrtd jj d  d _ j j j j jfks j
rtd jj d t	 j d   j rtd jj d  xR jj D ]B}|jtjjkr>t|jts>td jj d  tjj|_qW d S )Nr   z	Function z uses '*' more than once.Tr  z; has an unsupported group configuration. (Unexpected state z.b)rf   r  z has a ] without a matching [.c             3   s   | ]}|j  j kV  qd S )N)r   )r   r   )r   r   r   r8   q  s    z1DSLParser.parse_special_symbol.<locals>.<genexpr>zD has an empty group.
All groups must contain at least one parameter.z.c)r  z uses '/' more than once.z.d)zI mixes keyword-only and positional-only parameters, which is unsupported.)rj  r*   r   rO   rm  rl  r  r  r  r   r   r  anyr   r   r  ps_right_square_afterrk  r  r   r  r  r  r   r   r   r  )r   symbolr   r   )r   r   r  `  sF    


"


$
$"zDSLParser.parse_special_symbolc             C   s,   t | jj| _| jjdkst| | j|S )Nr_   )r   rL   r\  parameter_docstring_indentrc  r   r  state_parameter_docstring)r   rD   r   r   r   r    s    z)DSLParser.state_parameter_docstring_startc             C   s   |  }|drd S | j|}|| jk r| j| | jjdk sHt| jjdkrb| | j	|S | jjdksrt| | j
|S | jjstttt| jj }|j}|r|d7 }|r|| j|7 }||_d S )Nr   r_   r  rf   rA   )rJ   rP  rL   r`  r  rb  rc  r   r  r  r  r   r   r   r   r   r   r   )r   rD   r_  rL   last_parameternew_docstringr   r   r   r    s&    

z#DSLParser.state_parameter_docstringc             C   sr   | j rtd| jj d  | }|dr0d S | jj}|rD|d7 }|rZ| j|	 }nd}||7 }|| j_d S )Nz	Function z has a ] without a matching [.r   rA   r   )
r   r*   r   rO   rJ   rP  r   rL   r   rB   )r   rD   r_  r  r   r   r   r    s    
z"DSLParser.state_function_docstringc                s`  | j }|jttfk}|r$|js$|jS t \} }|j}|rR|jsDt |jj	 n
 |j	  d |sxtdt
| t|d jtst|d  std|d _d}xB|dd  D ]2}| sd}n|st|rt|j|_qd|_qW dfdd}d}	d}
d}|jsDx0t|D ]$}|jjs.q| r<d}P qW d}d|d	 }td
|d  fdd}x8|D ].}|jjsq|j	stt|jt}|r|jrq| r|j }	n"|	r|
s| sd}
|d | r|sd}|d t \}}|||j t|jtrB|d |jjpP|j	}|| |j r|d |jj}|st
|jj}|| ||ks|r|d ||  qW  |d |r|d  d |js dt d  | }|dd}d}xf|D ]^}|j s"q|r2 d nd} d  |j	  d  t !t"|j# d qW | }|r|d7 }|j# }dd |$dD }t|dkr|d rt%d|j& d d d   nt|dkr|'d
 t|$d!d }|dkrt%d" |s$|(dd! |(d| d|} | | }t)||d#}|# }|S )$Nr   z(We should always have a self parameter. r   Trf   Fc                sD   d}x | k r |d7 } d7  qW x | kr>|d7 } d8  q$W |S )Nr   r  rf   r  r   )Zdesiredr   )right_bracket_countr   r   fix_right_bracket_count  s    

z;DSLParser.format_docstring.<locals>.fix_right_bracket_countr$   r   r   c                sZ   r| }dn4d|  }t | dkrB d   t | }t |7  | d S )NFr   H   rA   )r   )r   r   )r,   first_parameterrL   line_lengthr   r   add_parameter  s    z1DSLParser.format_docstring.<locals>.add_parameterz/,z*,r*  rT  r   r  r   rA   z, ]z,] z  z    c             S   s   g | ]}|  qS r   )rB   )r   rD   r   r   r   r     s    z.DSLParser.format_docstring.<locals>.<listcomp>r  zDocstring for z does not have a summary line!
z3Every non-blank function docstring must start with
z0a single line summary followed by an empty line.z{parameters}z?You may not specify {parameters} more than once in a docstring!)r   )*r   r   r   r   r   r   r  r  r   rO   rY   r   r   r   r   r  r   r   r  r   r  r   r   r  r   r  r   r  r   r   r1   rJ   rK   rL   rE   rB   r;   r*   r   r   r   rQ   )r   r   r   r   r   r   rk  r   r  Z
need_slashZadded_slashZneed_a_trailing_slashZ
added_starZlast_pr  Zis_selfZp_addZp_outputrO   rP   Zdocstring_first_lineZspacer_liner   r   Zparameters_marker_countr   )r,   r  rL   r  r  r   format_docstring  s    













 





zDSLParser.format_docstringc             C   s   |rt | jsdS | jrd| jj }|s.d}nttt|}|jt	j
jk}|rdtd| jj d  x*| jj D ]\}}|sqr|j |_qrW |  | j_dS )z;
        Called when processing the block is done.
        NTz	Function z1 specifies '*' without any parameters afterwards.)r   r   rj  r   r   r  r   r   r   r  r  r  r*   rO   r   r   rB   r  )r   rD   r   Zno_parameter_after_starr  rO   rP   r   r   r   r    s     zDSLParser.state_terminal)r   )N)*r	   r
   r   rz   rg  rp  rr  rs  ru  rw  r|  r}  r~  r  r  r  r  r  r$  r  r  r  rh  r  rc  rl  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r   r   r   r   rd    sD   

&
 G	 p* wrd  )r%   pythonc          	   C   s  dd l }|jjdk s |jjdk r*|d dd l}| }|jdddd |jdd	td
 |jdddd |jddd |jdddd |jdtt	j
dd |jdtdd || }|jr|jrtd t  |  |d g }g }td  }t }xf|D ]^}	xVd|fd|ffD ]B\}
}|	|kr4q|	|
r||	|	d t|
  f P qW qW t  td tt}tdddd  |D   tddd!d  |D   t  xd"d#|fd$d%|ffD ]\}}}t|d&  d}x |D ]\}	}t|t|}qW xt|d'd( d)D ]\}	}||	 }t||d }|sJq$t|}g }xV|j D ]H\}}|j tj!j"krd|j#tj!j$krd*%||j#}n|}|| qdW td+%|d,| q$W t  qW td- td. |d |j&r|j's
|jr*td/ t  |  |d |j(sRtd0 t  |  |d xt	)|j(D ]\}}}x"d1D ]}||krp|*| qpW x\|D ]T}|d2s|d3sqt	j+||}|j,rt| t-||j.|j. d4 qW q`W d S |js|  |d |j'rHt|jd5krHtd6 t  |  |d x8|jD ].}|j,rdt| t-||j'|j.|j. d7 qPW d S )8Nr   r_   z0Error: clinic.py requires Python 3.3 or greater.z-fz--force
store_true)actionz-oz--output)r   z-vz	--verbosez--convertersz--makez-Walk --srcdir to run over all relevant files.)r  helpz--srcdirz*The directory tree to walk in --make mode.)r   r   r  r   r   )r   nargszHUsage error: can't specify --converters and a filename at the same time.r$   z
            add_c_converter
            add_c_return_converter
            add_default_legacy_c_converter
            add_legacy_c_converter
            r4  r  zLegacy converters:z    r   c             s   s   | ]}|d    r|V  qdS )r   N)isupper)r   rc   r   r   r   r8     s    zmain.<locals>.<genexpr>c             s   s   | ]}|d    r|V  qdS )r   N)islower)r   rc   r   r   r   r8     s    Z
Convertersr  zReturn convertersr9  r  c             S   s   | d   S )Nrf   )lower)r   r   r   r   <lambda>      zmain.<locals>.<lambda>)r   z{}={!r}z
    {}({})z, zNAll converters also accept (c_default=None, py_default=None, annotation=None).z4All return converters also accept (py_default=None).z3Usage error: can't use -o or filenames with --make.z4Usage error: --srcdir must not be empty with --make.)z.svnz.gitz.hgbuildZ	externalsz.cz.h)rt  r<  rf   z2Usage error: can't use -o with multiple filenames.)r   rt  r<  )/r(   version_infomajorminorr)   argparseArgumentParseradd_argumentr   rm  curdir
parse_argsr   r   r'   print_usager   rJ   r;   rV  r   r   r   sortedr  r   r  r&   r  	signaturer   r   r   r  r  r   emptyr>   Zmaker   srcdirwalkremoverj  verboser  rt  )argvr(   r  cmdlinensr   r5  Zignoredr  rO   rV   idsr  title	attributeZlongestZ
short_namer  callabler  r   r  r  r   rootdirsfilesZrcs_dirr   rj  r   r   r   main  s    











 

r  __main__rf   )F)r   )TT)N)N)N)r^   rS  r|   
contextlibr  r   r  r  r  rZ  rg   rm  ry  r+  rU  stringr(   r  rK   r  r  r   r  r\   r  _voidr   r   r   r  r   r  r   
namedtupler   r   r   r   r-   r.   r*   r4   r5   r-  rK  r6   r<   r   rJ   r;   r?   r@   rE   rH   rQ   rU   rW   rd   rm   rn   	Formatterr{   ABCMetar   r   r   r   r   r   	lru_cacher   r   r   contextmanagerr(  r3  r4  r;  rY  r_  rf  	languagesr  r   r  r5  r%   rs  r  rV  r  r  r  r  r1   INVALIDr  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  r
  r  r  r  r  r   rg  r  r  r  r  r  r   r  r  r"  r$  r&  r)  r+  r.  r/  r   r6  r7  r8  rB  rC  rD  rH  rI  rJ  rK  rL  rM  rN  rO  rP  rY  rZ  rd  rw  r  r	   r)   r  r   r   r   r   <module>   s|  			,
.J		4     !
B 0$.
		 q!
H X)		  +



'
i
-



P        :x