www.eklavya.in - Cubjrnet7

upload mass deface mass delete console info server
name : printers.cpython-39.opt-1.pyc
a

�fL�@s&ddlZddlZddlZddlZddlZddlZejddkrPeZe	Z
eZe
ZnGdd�d�Zddlm
Z
mZdazddlZWney�daYn0dazddlZeejd�r�daWney�Yn0d	d
�Zdadd
�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�ZGdd�de�ZGdd�d�Z dd�Z!d d!�Z"d"d#�Z#Gd$d%�d%�Z$d&d'�Z%d(d)�Z&Gd*d+�d+�Z'Gd,d-�d-�Z(Gd.d/�d/e(�Z)Gd0d1�d1e(�Z*Gd2d3�d3�Z+Gd4d5�d5�Z,Gd6d7�d7�Z-Gd8d9�d9�Z.Gd:d;�d;�Z/Gd<d=�d=�Z0Gd>d?�d?�Z1Gd@dA�dA�Z2GdBdC�dCe�Z3dDdE�Z4GdFdG�dG�Z5GdHdI�dI�Z6dJdK�Z7GdLdM�dM�Z8GdNdO�dO�Z9GdPdQ�dQ�Z:GdRdS�dS�Z;GdTdU�dU�Z<GdVdW�dW�Z=GdXdY�dYe�Z>GdZd[�d[e�Z?Gd\d]�d]�Z@Gd^d_�d_�ZAGd`da�da�ZBGdbdc�dce�ZCddde�ZDGdfdg�dgeC�ZEGdhdi�dieC�ZFGdjdk�dkeC�ZGGdldm�dmeC�ZHGdndo�do�ZIGdpdq�dq�ZJGdrds�ds�ZKGdtdu�du�ZLGdvdw�dw�ZMGdxdy�dy�ZNGdzd{�d{�ZOGd|d}�d}�ZPGd~d�de�ZQGd�d��d�e�ZRdaSGd�d��d�e�ZTd�d��ZUGd�d��d�e�ZVd�d��ZWd�d��ZXd�d��ZYd�d��ZZeZ�dS)��N�c@seZdZdZdd�ZdS)�Iteratora:Compatibility mixin for iterators

        Instead of writing next() methods for iterators, write
        __next__() methods and use this mixin to make them work in
        Python 2 as well as Python 3.

        Idea stolen from the "six" documentation:
        <http://pythonhosted.org/six/#six.Iterator>
        cCs|��S�N)�__next__��self�r�1/usr/share/gcc-11/python/libstdcxx/v6/printers.py�next<sz
Iterator.nextN)�__name__�
__module__�__qualname__�__doc__r
rrrr	r1s
r)�imap�izipTFZTypePrintercCsv|��}d|j|f}zt�|�WSty4Yn0|��}t|�r\|djr\|dj}qt	dt
|�|f��qdS)Nz%s::%srzCannot find type %s::%s)�strip_typedefs�tag�gdb�lookup_type�RuntimeError�fields�len�
is_base_class�type�
ValueError�str)Zorig�name�typ�searchrrrr	�	find_typeUsrz__8::cGs�d�|d�dd�|D���}zt�|�WStjy�}z\tr�t|vr�|�ddtd�}zt�|�WWYd}~Stjy�Yn0|�WYd}~n
d}~00dS)z7
    Lookup template specialization templ<args...>
    z{}<{}>�, cSsg|]}t|��qSr)r)�.0�arrr	�
<listcomp>m�z%lookup_templ_spec.<locals>.<listcomp>�::�N)�format�joinrr�error�_versioned_namespace�replace)Ztempl�args�t�errr	�lookup_templ_specisr/cCs�d|vrd|}zt|d�}Wn|�d�}Yn0|��}zt||�WStjy�}zbt|d�r�t|ddd�r�|�dd	d
�}zt||�WWYd}~Stjy�Yn0WYd}~dSd}~00dS)z�
    Lookup specialization of template NODENAME corresponding to CONTAINERTYPE.
    e.g. if NODENAME is '_List_node' and CONTAINERTYPE is std::list<int>
    then return the type std::_List_node<int>.
    Returns None if not found.
    r%�std::�
value_typerZstdzstd::__cxx1998zstd::__debugZ__gnu_debugz
::__cxx1998::r&N)r�template_argumentrr/rr)�is_member_of_namespacer+)�nodenameZ
containertype�valtyper.rrr	�lookup_node_type~s(
�r6cGs>t|tj�rt|�}t|�}|D]}|�|d�r dSq dS)z�
    Test whether a type is a member of one of the specified namespaces.
    The type can be specified as a string or a gdb.Type object.
    r%TF)�
isinstancer�Typer�strip_versioned_namespace�
startswith)rZ
namespaces�	namespacerrr	r3�sr3cCs6t|tj�r|j}tr"dt|f}t�d||�duS)z1Test if a type is a given template instantiation.z(%s)?%sz
^std::%s<.*>$N)r7rr8rr*�re�match)�x�
template_namerrr	�is_specialization_of�s
r@cCstr|�td�S|S)N�)r*r+��typenamerrr	r9�sr9cCsRt|�}|�dd�}d}dD]}|�||d|�}q|d}|�|d|�}|S)zARemove known inline namespaces from the canonical name of a type.�std::__cxx11::r0�std::experimental::)Zfundamentals_v1Zfundamentals_v2r%zfilesystem::zv1::)r9r+)�type_strZexpt_nsZlfts_nsZfs_nsrrr	�strip_inline_namespaces�srGcCs<d}g}z|�|�|��Wn|YS0|d7}qdS)z,Return a type's template arguments as a listrr&N)�appendr2)�type_obj�n�
template_argsrrr	�get_template_arg_list�s
rLc@s(eZdZdZdd�Zdd�Zdd�ZdS)	�SmartPtrIteratorz?An iterator for smart pointer types with a single 'child' valuecCs
||_dSr��val�rrOrrr	�__init__�szSmartPtrIterator.__init__cCs|Srrrrrr	�__iter__�szSmartPtrIterator.__iter__cCs$|jdurt�d|j|_}d|fS)Nzget()�rO�
StopIterationrPrrr	r�s
zSmartPtrIterator.__next__N�rrr
rrQrRrrrrr	rM�srMc@s(eZdZdZdd�Zdd�Zdd�ZdS)	�SharedPointerPrinterzPrint a shared_ptr or weak_ptrcCst|�|_||_|d|_dS�N�_M_ptr)r9rCrO�pointer�rrCrOrrr	rQ�s
zSharedPointerPrinter.__init__cCs
t|j�Sr)rMrYrrrr	�children�szSharedPointerPrinter.childrencCsjd}|jdd}|dkrL|d}|d}|dkr<d|}nd||d	f}d
|jt|jj�d��|fS)N�emptyZ_M_refcountZ_M_pirZ_M_use_countZ
_M_weak_countzexpired, weak count %dzuse count %d, weak count %dr&z%s<%s> (%s))rOrCrrr2)r�stateZ	refcountsZusecountZ	weakcountrrr	�	to_string�s
zSharedPointerPrinter.to_stringN�rrr
rrQr[r^rrrr	rV�srVcCs�|j��}|djs&tdt|j���|�|dj�}|j��}t|�dkr^tdt|j���|djdkrt|dS|djr�|�|dj�Stdt|j���dS)zBReturn the tuple element stored in a _Tuple_impl<N, T> base class.���z-Unsupported implementation for std::tuple: %sr�_M_head_implN)rrrrr�castrr)rO�basesZ	head_baserrrr	�_tuple_impl_get�s



rdcCsdtt|j��}||krtd��|�|j��dj�}|dkr\|�|j��dj�}|d8}q4t|�S)z5Return the result of std::get<n>(val) on a std::tuplez0Out of range index for std::get<N> on std::tuplerr&)rrLrrrbrrd)rJrOZ
tuple_size�noderrr	�	tuple_gets
rfcCsd|j��dj��}t|d�s(t|d�r6|dd}n$t|d�rJ|d}ntdt|���td|�S)z3Return the result of val.get() on a std::unique_ptrrZ__uniq_ptr_dataZ__uniq_ptr_impl�_M_t�tuplez-Unsupported implementation for unique_ptr: %s)rrrr@rrrf)rOZ	impl_typeZtuple_memberrrr	�unique_ptr_gets
�

ric@s(eZdZdZdd�Zdd�Zdd�ZdS)	�UniquePointerPrinterzPrint a unique_ptrcCs
||_dSrrNrZrrr	rQ'szUniquePointerPrinter.__init__cCstt|j��Sr)rMrirOrrrr	r[*szUniquePointerPrinter.childrencCs|jj�d�}d�t|��S)Nrzstd::unique_ptr<{}>)rOrr2r'r�rr-rrr	r^-szUniquePointerPrinter.to_stringNr_rrrr	rj$srjcCs|dj�|�����S)z8Returns the value held in a __gnu_cxx::__aligned_membuf.�
_M_storage)�addressrbrY�dereference)Zbufr5rrr	�get_value_from_aligned_membuf1srocCsnzJ|j��dj}|dkr$|dWS|dkrH|j�d�}t|d|�WSWnYn0tdt|j���dS)z-Returns the value held in an _List_node<_Val>r&�_M_datarlr�!Unsupported implementation for %sN�rrrr2rorr�re�memberr5rrr	�get_value_from_list_node5s
ruc@s8eZdZdZGdd�de�Zdd�Zdd�Zdd	�Zd
S)�StdListPrinterzPrint a std::listc@s$eZdZdd�Zdd�Zdd�ZdS)zStdListPrinter._iteratorcCs"||_|d|_|j|_d|_dS�N�_M_nextr)�nodetype�baserm�head�count�rryr{rrr	rQHs
z!StdListPrinter._iterator.__init__cCs|Srrrrrr	rRNsz!StdListPrinter._iterator.__iter__cCsR|j|jkrt�|j�|j���}|d|_|j}|jd|_t|�}d||fS)Nrxr&�[%d])rzr{rTrbryrnr|ru)r�eltr|rOrrr	rQs
z!StdListPrinter._iterator.__next__N�rrr
rQrRrrrrr	�	_iteratorGsr�cCst|�|_||_dSr�r9rCrOrZrrr	rQ[s
zStdListPrinter.__init__cCs(td|jj���}|�||jdd�S)N�
_List_node�_M_impl�_M_node�r6rOrrYr��rryrrr	r[_szStdListPrinter.childrencCs0|jdd}|d|jkr&d|jSd|jS)Nr�r�rx�empty %s�%s)rOrmrC)rZheadnoderrr	r^cs
zStdListPrinter.to_stringN�	rrr
rrr�rQr[r^rrrr	rvDs
rvc@seZdZdd�Zdd�ZdS)�NodeIteratorPrintercCs$||_||_||_t||j�|_dSr)rOrC�contnamer6rry)rrCrOr�r4rrr	rQjszNodeIteratorPrinter.__init__cCs:|jdsd|jS|jd�|j�����}tt|��S)Nr�z(non-dereferenceable iterator for std::%s)rOr�rbryrYrnrru�rrerrr	r^ps

zNodeIteratorPrinter.to_stringN)rrr
rQr^rrrr	r�isr�c@seZdZdZdd�ZdS)�StdListIteratorPrinterzPrint std::list::iteratorcCst�|||dd�dS)N�listr��r�rQrZrrr	rQyszStdListIteratorPrinter.__init__N�rrr
rrQrrrr	r�vsr�c@seZdZdZdd�ZdS)�StdFwdListIteratorPrinterz!Print std::forward_list::iteratorcCst�|||dd�dS)N�forward_list�_Fwd_list_noder�rZrrr	rQs�z"StdFwdListIteratorPrinter.__init__Nr�rrrr	r�|sr�c@s8eZdZdZGdd�de�Zdd�Zdd�Zdd	�Zd
S)�StdSlistPrinterzPrint a __gnu_cxx::slistc@s$eZdZdd�Zdd�Zdd�ZdS)zStdSlistPrinter._iteratorcCs||_|dd|_d|_dS)N�_M_headrxr�ryrzr|r}rrr	rQ�sz"StdSlistPrinter._iterator.__init__cCs|Srrrrrr	rR�sz"StdSlistPrinter._iterator.__iter__cCsL|jdkrt�|j�|j���}|d|_|j}|jd|_d||dfS)Nrrxr&r~rp)rzrTrbryrnr|)rrr|rrr	r�s

z"StdSlistPrinter._iterator.__next__Nr�rrrr	r��sr�cCs
||_dSrrNrZrrr	rQ�szStdSlistPrinter.__init__cCs td|jj�}|�|��|j�S)N�__gnu_cxx::_Slist_node)r6rOrr�rYr�rrr	r[�szStdSlistPrinter.childrencCs|jdddkrdSdS)Nr�rxrzempty __gnu_cxx::slistz__gnu_cxx::slistrNrrrr	r^�szStdSlistPrinter.to_stringNr�rrrr	r��s
r�c@s eZdZdZdd�Zdd�ZdS)�StdSlistIteratorPrinterz Print __gnu_cxx::slist::iteratorcCs
||_dSrrNrZrrr	rQ�sz StdSlistIteratorPrinter.__init__cCs<|jdsdStd|jj���}t|jd�|���d�S)Nr�z1non-dereferenceable iterator for __gnu_cxx::slistr�rp)rOr6rrYrrbrnr�rrr	r^�s
z!StdSlistIteratorPrinter.to_stringN�rrr
rrQr^rrrr	r��sr�c@s@eZdZdZGdd�de�Zdd�Zdd�Zdd	�Zd
d�Z	dS)
�StdVectorPrinterzPrint a std::vectorc@s$eZdZdd�Zdd�Zdd�ZdS)zStdVectorPrinter._iteratorcCs^||_|rH|d|_d|_|d|_|d|_|j��j}d|j|_n||_||_d|_	dS)N�_M_pr�	_M_offset�)
�bitvec�item�so�finish�fornr�sizeof�isizer|)r�startr�r��ityperrr	rQ�s


z#StdVectorPrinter._iterator.__init__cCs|Srrrrrr	rR�sz#StdVectorPrinter._iterator.__iter__cCs�|j}|jd|_|jr�|j|jkr4|j|jkr4t�t|j��d|j>@�}|jd|_|j|j	krv|jd|_d|_d||fS|j|jkr�t�|j��}|jd|_d||fSdS)Nr&rr~)
r|r�r�r�r�r�rT�boolrnr�)rr|rrrr	r�s 
z#StdVectorPrinter._iterator.__next__Nr�rrrr	r��sr�cCs*t|�|_||_|j�d�jtjk|_dS�Nr)	r9rCrOrr2�coderZTYPE_CODE_BOOL�is_boolrZrrr	rQ�s
zStdVectorPrinter.__init__cCs$|�|jdd|jdd|j�S)Nr��_M_start�	_M_finish)r�rOr�rrrr	r[�s�zStdVectorPrinter.childrenc	Cs�|jdd}|jdd}|jdd}|jr�|jddd}|jddd}|jddd}|��j}d|j}||||}|||}d|jt|�t|�fSd	|jt||�t||�fSdS)
Nr�r�r�Z_M_end_of_storager�r�r�z"%s<bool> of length %d, capacity %dz%s of length %d, capacity %d)rOr�rnrr�rC�int)	rr�r��endr�r�Zbl�lengthZcapacityrrr	r^�s"

��zStdVectorPrinter.to_stringcCsdS�N�arrayrrrrr	�display_hint�szStdVectorPrinter.display_hintN)
rrr
rrr�rQr[r^r�rrrr	r��s%r�c@s eZdZdZdd�Zdd�ZdS)�StdVectorIteratorPrinterzPrint std::vector::iteratorcCs
||_dSrrNrZrrr	rQ�sz!StdVectorIteratorPrinter.__init__cCs |jdsdSt|jd���S)NZ
_M_currentz,non-dereferenceable iterator for std::vector�rOrrnrrrr	r^�s
z"StdVectorIteratorPrinter.to_stringNr�rrrr	r��sr�c@s eZdZdZdd�Zdd�ZdS)�StdBitIteratorPrinterz?Print std::vector<bool>'s _Bit_iterator and _Bit_const_iteratorcCs
||_dSrrNrZrrr	rQszStdBitIteratorPrinter.__init__cCs.|jdsdSt|jd��d|jd>@�S)Nr�z2non-dereferenceable iterator for std::vector<bool>r&r��rOr�rnrrrr	r^s

�zStdBitIteratorPrinter.to_stringNr�rrrr	r�sr�c@s eZdZdZdd�Zdd�ZdS)�StdBitReferencePrinterz"Print std::vector<bool>::referencecCs
||_dSrrNrZrrr	rQszStdBitReferencePrinter.__init__cCs*|jdsdSt|jd��|jd@�S)Nr�z$invalid std::vector<bool>::referenceZ_M_maskr�rrrr	r^s
z StdBitReferencePrinter.to_stringNr�rrrr	r�sr�c@s8eZdZdZGdd�de�Zdd�Zdd�Zdd	�Zd
S)�StdTuplePrinterzPrint a std::tuplec@s0eZdZedd��Zdd�Zdd�Zdd�Zd	S)
zStdTuplePrinter._iteratorcCsNt|�dkr"t|djd�rBdSn t|�dkr2dSt|�dkrBdStd��dS)Nrr&Z__tuple_baseTrFz4Top of tuple tree does not consist of a single node.)rr@rr)�nodesrrr	�_is_nonempty_tuplesz,StdTuplePrinter._iterator._is_nonempty_tuplecCs:||_|jj��}|�|�r0|j�|dj�|_d|_dSr�)r{rrr�rbr|)rr{r�rrr	rQ(s

z"StdTuplePrinter._iterator.__init__cCs|Srrrrrr	rR3sz"StdTuplePrinter._iterator.__iter__cCs�|js
t�|jj��}t|�dkr&t�t|�dkr:td��t|�dkr`|j�|dj�}d|_n&|j�|dj�}|j�|dj�|_|jd|_|j��}t|�dks�|djdkr�d|j|fSd|j|dfSdS)Nrrz/Cannot parse more than 2 nodes in a tuple tree.r&rar~)	r{rTrrrrrbr|r)rr��implrrrr	r6s"	
z"StdTuplePrinter._iterator.__next__N)rrr
�staticmethodr�rQrRrrrrr	r�s


r�cCst|�|_||_dSrr�rZrrr	rQ_s
zStdTuplePrinter.__init__cCs|�|j�Sr)r�rOrrrr	r[cszStdTuplePrinter.childrencCs(t|jj���dkrd|jSd|jS)Nrr�z
%s containing)rrOrrrCrrrr	r^fs
zStdTuplePrinter.to_stringNr�rrrr	r�s
Cr�c@s0eZdZdZdd�Zdd�Zdd�Zdd	�Zd
S)�StdStackOrQueuePrinterz Print a std::stack or std::queuecCst|�|_t�|d�|_dS)N�c)r9rCr�default_visualizer�
visualizerrZrrr	rQns
zStdStackOrQueuePrinter.__init__cCs
|j��Sr)r�r[rrrr	r[rszStdStackOrQueuePrinter.childrencCsd|j|j��fS)Nz%s wrapping: %s)rCr�r^rrrr	r^us�z StdStackOrQueuePrinter.to_stringcCst|jd�r|j��SdS)Nr�)�hasattrr�r�rrrr	r�ys
z#StdStackOrQueuePrinter.display_hintN)rrr
rrQr[r^r�rrrr	r�ks
r�c@s0eZdZdZdd�Zdd�Zdd�Zdd	�Zd
S)�RbtreeIteratorzf
    Turn an RB-tree-based container (std::map, std::set etc.) into
    a Python iterable object.
    cCs2|ddd|_|dddd|_d|_dS)Nrgr�Z
_M_node_countZ	_M_header�_M_leftr)�sizerer|)rZrbtreerrr	rQ�szRbtreeIterator.__init__cCs|Srrrrrr	rR�szRbtreeIterator.__iter__cCs
t|j�Sr)r�r�rrrr	�__len__�szRbtreeIterator.__len__cCs�|j|jkrt�|j}|jd|_|j|jkr�|j}|��drh|��d}|��dr�|��d}qLnB|��d}||��dkr�|}|��d}qt|��d|kr�|}||_|S)Nr&Z_M_rightr�Z	_M_parent)r|r�rTrern)r�resultre�parentrrr	r�s$zRbtreeIterator.__next__N)rrr
rrQrRr�rrrrr	r�~s
r�cCsnzJ|j��dj}|dkr$|dWS|dkrH|j�d�}t|d|�WSWnYn0tdt|j���dS)z0Returns the value held in an _Rb_tree_node<_Val>r&Z_M_value_fieldrlrrqNrrrsrrr	�get_value_from_Rb_tree_node�s
r�c@s eZdZdZdd�Zdd�ZdS)�StdRbtreeIteratorPrinterz2Print std::map::iterator, std::set::iterator, etc.cCs"||_td|jj�}|��|_dS�N�
_Rb_tree_node)rOr6rrY�	link_type)rrCrOryrrr	rQ�sz!StdRbtreeIteratorPrinter.__init__cCs0|jdsdS|jd�|j���}tt|��S)Nr�z6non-dereferenceable iterator for associative container)rOrbr�rnrr�r�rrr	r^�s
z"StdRbtreeIteratorPrinter.to_stringNr�rrrr	r��sr�c@s eZdZdZdd�Zdd�ZdS)�StdDebugIteratorPrinterz,Print a debug enabled version of an iteratorcCs
||_dSrrNrZrrr	rQ�sz StdDebugIteratorPrinter.__init__cCsbt�d�}|jj�d�}|j�|�d}|s<t|j�|��S|jd|dkrRdSt|j�|��S)Nz __gnu_debug::_Safe_iterator_baserZ_M_sequenceZ
_M_versionzinvalid iterator)rrrOrr2rbr)rZ	base_typer�Zsafe_seqrrr	r^�s
z!StdDebugIteratorPrinter.to_stringNr�rrrr	r��sr�cCs|dkrdSd|S)zDReturn either "1 element" or "N elements" depending on the argument.r&z	1 elementz%d elementsr)Znumrrr	�num_elements�sr�c@s@eZdZdZGdd�de�Zdd�Zdd�Zdd	�Zd
d�Z	dS)
�
StdMapPrinterz!Print a std::map or std::multimapc@s$eZdZdd�Zdd�Zdd�ZdS)zStdMapPrinter._itercCs||_d|_||_dSr���rbiterr|r�rr�rrrr	rQ�szStdMapPrinter._iter.__init__cCs|Srrrrrr	rR�szStdMapPrinter._iter.__iter__cCsh|jddkr@t|j�}|�|j���}t|�}||_|d}n
|jd}d|j|f}|jd|_|S)Nrr�first�secondr~r&)r|r
r�rbrrnr��pair)rrJr�r�rrr	r�s


zStdMapPrinter._iter.__next__Nr�rrrr	�_iter�sr�cCst|�|_||_dSrr�rZrrr	rQ�s
zStdMapPrinter.__init__cCsd|jttt|j���fS�N�
%s with %s�rCr�rr�rOrrrr	r^�s�zStdMapPrinter.to_stringcCs$td|jj���}|�t|j�|�Sr��r6rOrrYr�r�r�rrr	r[�szStdMapPrinter.childrencCsdS�N�maprrrrr	r�szStdMapPrinter.display_hintN�
rrr
rrr�rQr^r[r�rrrr	r��sr�c@s8eZdZdZGdd�de�Zdd�Zdd�Zdd	�Zd
S)�
StdSetPrinterz!Print a std::set or std::multisetc@s$eZdZdd�Zdd�Zdd�ZdS)zStdSetPrinter._itercCs||_d|_||_dSr�r�r�rrr	rQ	szStdSetPrinter._iter.__init__cCs|Srrrrrr	rRszStdSetPrinter._iter.__iter__cCs@t|j�}|�|j���}t|�}d|j|f}|jd|_|S)Nr~r&)r
r�rbrrnr�r|)rr�r�rrr	rs
zStdSetPrinter._iter.__next__Nr�rrrr	r�sr�cCst|�|_||_dSrr�rZrrr	rQs
zStdSetPrinter.__init__cCsd|jttt|j���fSr�r�rrrr	r^s�zStdSetPrinter.to_stringcCs$td|jj���}|�t|j�|�Sr�r�r�rrr	r[#szStdSetPrinter.childrenN)	rrr
rrr�rQr^r[rrrr	r�s
r�c@s(eZdZdZdd�Zdd�Zdd�ZdS)	�StdBitsetPrinterzPrint a std::bitsetcCst|�|_||_dSrr�rZrrr	rQ*s
zStdBitsetPrinter.__init__cCs
d|jS)Nr�rBrrrr	r^.szStdBitsetPrinter.to_stringc	Cs�z|jd}WngYS0|j}|jtjkr>|��j}n|g}|j}|j|}g}d}||kr�||}d}|dkr�|d@dkr�|�d||d|df�|d}|d?}qp|d}q\|S)NZ_M_wrr&r~r�)rOrr�r�TYPE_CODE_ARRAY�targetr�rH)	rZwordsZwtypeZtsizeZnwordsr�Zbyte�w�bitrrr	r[3s,



zStdBitsetPrinter.childrenN)rrr
rrQr^r[rrrr	r�'sr�c@s@eZdZdZGdd�de�Zdd�Zdd�Zdd	�Zd
d�Z	dS)
�StdDequePrinterzPrint a std::dequec@s$eZdZdd�Zdd�Zdd�ZdS)zStdDequePrinter._itercCs(||_||_||_||_||_d|_dSr�)re�pr��last�buffer_sizer|)rrer�r�r�r�rrr	rQYszStdDequePrinter._iter.__init__cCs|Srrrrrr	rRaszStdDequePrinter._iter.__iter__cCsr|j|jkrt�d|j|j��f}|jd|_|jd|_|j|jkrn|jd|_|jd|_|j|j|_|S)Nr~r&r)r�r�rTr|rnr�rer�)rr�rrr	rdszStdDequePrinter._iter.__next__Nr�rrrr	r�Xsr�cCsHt|�|_||_|j�d�|_|jj}|dkr>td|�|_nd|_dS)Nrir&)	r9rCrOrr2Zelttyper�r�r�)rrCrOr�rrr	rQvs
zStdDequePrinter.__init__cCsx|jdd}|jdd}|d|dd}|d|d}|d|d}|j|||}d	|jtt|��fS)
Nr�r�r�r�r&�_M_last�_M_cur�_M_firstr�)rOr�rCr��long)rr�r�Zdelta_nZdelta_sZdelta_er�rrr	r^�szStdDequePrinter.to_stringcCs@|jdd}|jdd}|�|d|d|d|d|j�S)Nr�r�r�r�r�r�)rOr�r�)rr�r�rrr	r[�s

�zStdDequePrinter.childrencCsdSr�rrrrr	r��szStdDequePrinter.display_hintNr�rrrr	r�Us
r�c@s eZdZdZdd�Zdd�ZdS)�StdDequeIteratorPrinterzPrint std::deque::iteratorcCs
||_dSrrNrZrrr	rQ�sz StdDequeIteratorPrinter.__init__cCs |jdsdSt|jd���S)Nr�z+non-dereferenceable iterator for std::dequer�rrrr	r^�s
z!StdDequeIteratorPrinter.to_stringNr�rrrr	r��sr�c@s(eZdZdZdd�Zdd�Zdd�ZdS)	�StdStringPrinterz&Print a std::basic_string of some kindcCs||_|�d�dk|_dS)Nz::__cxx11::basic_stringr`)rO�find�
new_stringrZrrr	rQ�szStdStringPrinter.__init__cCs�|jj}|jtjkr|��}|jdd}|jrL|jd}|�|j���}n<|�	���}t�
t|�d���}|�|�d}|�
�d}t|d�r�|j|d�S|j|d�S)	NZ_M_dataplusr�Z_M_string_lengthz::_Repr&Z	_M_length�lazy_string�r�)rOrr�r�
TYPE_CODE_REFr�r�rbr�unqualifiedrrrYrnr�r��string)rr�ptrr�ZrealtypeZreptype�headerrrr	r^�s

zStdStringPrinter.to_stringcCsdS�Nr�rrrrr	r��szStdStringPrinter.display_hintN�rrr
rrQr^r�rrrr	r��sr�c@s$eZdZdd�Zdd�Zdd�ZdS)�Tr1HashtableIteratorcCsf|d|_d|_|d|_t|jd���|_d|_|j|jkrb|j|j|_|jrTqb|jd|_q2dS)NZ
_M_bucketsrZ_M_bucket_countZ_Noder&)�buckets�bucket�bucket_countrrrY�	node_typere)r�	hashtablerrr	rQ�s

zTr1HashtableIterator.__init__cCs|Srrrrrr	rR�szTr1HashtableIterator.__iter__cCs�|jdkrt�|j�|j�}|��d}|��d|_|jdkr||jd|_|j|jkr||j|j|_|jrnq||jd|_qL|S)NrZ_M_vrxr&)rerTrbr�rnr�r�r�)rrer�rrr	r�s

zTr1HashtableIterator.__next__Nr�rrrr	r��sr�c@s$eZdZdd�Zdd�Zdd�ZdS)�StdHashtableIteratorcCsR|dd|_|j�d�}|j�d��d�}tdt|�|r>dnd�}|��|_dS)	NZ_M_before_begin�_M_nxtr&�	rzstd::__detail::_Hash_node�trueZfalse)rerr2r/rrYr�)rr�r5�cachedr�rrr	rQ�s

�zStdHashtableIterator.__init__cCs|Srrrrrr	rR�szStdHashtableIterator.__iter__cCsR|jdkrt�|j�|j���}|d|_|dj}|�|j�d����}|��S)Nrrrl)	rerTrbr�rnrmrr2rY)rr�valptrrrr	r�s


zStdHashtableIterator.__next__Nr�rrrr	r�src@s<eZdZdZdd�Zdd�Zdd�Zedd	��Zd
d�Z	dS)
�Tr1UnorderedSetPrinterz0Print a std::unordered_set or tr1::unordered_setcCst|�|_||_dSrr�rZrrr	rQ�s
zTr1UnorderedSetPrinter.__init__cCs|j�d�r|jS|jdS�N�std::tr1Z_M_h�rCr:rOrrrr	r��sz Tr1UnorderedSetPrinter.hashtablecCs|��d}d|jt|�fS�NZ_M_element_countr��r�rCr��rr|rrr	r^sz Tr1UnorderedSetPrinter.to_stringcCsd|S�Nr~r��irrr	�format_countsz#Tr1UnorderedSetPrinter.format_countcCs@t|jt���}|j�d�r.t|t|����St|t	|����S�Nr)
rr�	itertoolsr|rCr:rr�r�r)r�counterrrr	r[	szTr1UnorderedSetPrinter.childrenN)
rrr
rrQr�r^r�rr[rrrr	r�s
rc@s\eZdZdZdd�Zdd�Zdd�Zedd	��Zed
d��Z	edd
��Z
dd�Zdd�ZdS)�Tr1UnorderedMapPrinterz0Print a std::unordered_map or tr1::unordered_mapcCst|�|_||_dSrr�rZrrr	rQs
zTr1UnorderedMapPrinter.__init__cCs|j�d�r|jS|jdSrr	rrrr	r�sz Tr1UnorderedMapPrinter.hashtablecCs|��d}d|jt|�fSr
rrrrr	r^sz Tr1UnorderedMapPrinter.to_stringccs|D]}|D]
}|VqqdSrr)r�rrrrr	�flattenszTr1UnorderedMapPrinter.flattencCs|d|dfS�Nr�r�r)rrrr	�
format_one%sz!Tr1UnorderedMapPrinter.format_onecCsd|Sr
rrrrr	r)sz#Tr1UnorderedMapPrinter.format_countcCsdt|jt���}|j�d�r@|�t|jt|�	����}t
||�S|�t|jt|�	����}t
||�Sr)rrrr|rCr:rrr�r�rr)rr�datarrr	r[-s
zTr1UnorderedMapPrinter.childrencCsdSr�rrrrr	r�8sz#Tr1UnorderedMapPrinter.display_hintN)
rrr
rrQr�r^r�rrrr[r�rrrr	rs


rc@s8eZdZdZGdd�de�Zdd�Zdd�Zdd	�Zd
S)�StdForwardListPrinterzPrint a std::forward_listc@s$eZdZdd�Zdd�Zdd�ZdS)zStdForwardListPrinter._iteratorcCs||_|d|_d|_dSrwr�r}rrr	rQ?s
z(StdForwardListPrinter._iterator.__init__cCs|Srrrrrr	rRDsz(StdForwardListPrinter._iterator.__iter__cCsl|jdkrt�|j�|j���}|d|_|j}|jd|_|dj}|�|j�d��	��}d||��fS)Nrrxr&rlr~)
rzrTrbryrnr|rmrr2rY)rrr|rrrr	rGs


z(StdForwardListPrinter._iterator.__next__Nr�rrrr	r�>sr�cCs||_t|�|_dSr)rOr9rCrZrrr	rQRszStdForwardListPrinter.__init__cCs(td|jj���}|�||jdd�S)Nr�r�r�r�r�rrr	r[VszStdForwardListPrinter.childrencCs*|jddddkr d|jSd|jS)Nr�r�rxrr�r�)rOrCrrrr	r^Zs
zStdForwardListPrinter.to_stringNr�rrrr	r;s
rc@sBeZdZdZd
dd�Zdd�ZGdd�de�Zd	d
�Zdd�Z	dS)�SingleObjContainerPrinterz7Base class for printers of containers of single objectsNcCs||_||_||_dSr)�contained_valuer��hint)rrOZvizrrrr	rQbsz"SingleObjContainerPrinter.__init__cCs(tst|�Stj�tj��|�p&t|�S)z4Return TYPE as a string after applying type printers)�_use_type_printingrr�types�apply_type_recognizers�get_type_recognizers)rrrrr	�
_recognizegs��z$SingleObjContainerPrinter._recognizec@s$eZdZdd�Zdd�Zdd�ZdS)z$SingleObjContainerPrinter._containedcCs
||_dSrrNrPrrr	rQpsz-SingleObjContainerPrinter._contained.__init__cCs|Srrrrrr	rRssz-SingleObjContainerPrinter._contained.__iter__cCs"|jdurt�|j}d|_d|fS)Nz[contained value]rS)rZretvalrrr	rvs

z-SingleObjContainerPrinter._contained.__next__Nr�rrrr	�
_containedosr"cCs6|jdur|�d�St|jd�r*|j��S|�|j�S)Nr[)rr"r�r�r[rrrr	r[}s



z"SingleObjContainerPrinter.childrencCs(t|jd�r"t|jd�r"|j��S|jS)Nr[r�)r�r�r�rrrrr	r��s

�
z&SingleObjContainerPrinter.display_hint)N)
rrr
rrQr!rr"r[r�rrrr	r_s
rcCsN|��j}tjddkr"t|�}nt|�}zt�|�jj	WSYdS0dS)z>Find the name of the function referred to by the gdb.Value f, rrN)
rnrm�sys�version_infor�r�rZblock_for_pc�functionr)�frrr	�function_pointer_to_name�s

r'cs(eZdZdZ�fdd�Zdd�Z�ZS)�StdExpAnyPrinterz*Print a std::any or std::experimental::anycsLt|�|_t�dd|jd�|_||_d|_d}d}|jd}|dk�r6t|�}|s`td|j��d�|�}t�	||�}|s�td|j��|�
d�}	d	|	vr�t�d
tt�
d	����|�
d��}	t�
|	�}
|
�d�|_d}d|	vr�|jdd
j}n(d|	v�r
|jdd}ntd|j��|�|j�����}t�|�}tt|��||�dS)Nz&^std::experimental::fundamentals_v\d::rEr&Z
_M_managerrzInvalid function pointer in %szi({0}::_Manager_\w+<.*>)::_S_manage\((enum )?{0}::_Op, (const {0}|{0} const) ?\*, (union )?{0}::_Arg ?\*\)zUnknown manager function in %szstd::stringzstd::string(?!\w)z::_Manager_internalrlZ	_M_bufferz::_Manager_externalrX)r9rCr<�subrO�contained_typer'rr'r=�grouprrrrr2rmrbrYrnr��superr(rQ)rrCrOrr�Zmgr�funcZrx�mZmgrnameZmgrtyper��	__class__rr	rQ�sH
�

���
"


zStdExpAnyPrinter.__init__cCsT|jdurd|jSd|j}t|jd�r8||j��S|�|j�}|tt|��S)N�%s [no contained value]z%s containing r[)r*rCr�r�r^r!r9r)r�descr5rrr	r^�s


zStdExpAnyPrinter.to_string�rrr
rrQr^�
__classcell__rrr/r	r(�s.r(cs(eZdZdZ�fdd�Zdd�Z�ZS)�StdExpOptionalPrinterz4Print a std::optional or std::experimental::optionalcs�|�|j�d��}t|�}t�dd||d�|_|d}|j�d�rR|d}|}n*|d}|d}z|d}WnYn0t�	|�}|s�d}t
t|��||�dS)	Nrz0^std::(experimental::|)(fundamentals_v\d::|)(.*)z
std::\1\3<%s>r&�
_M_payloadzstd::experimental�
_M_engaged�_M_value)
r!rr2r9r<r)rCr:rr�r,r5rQ)rrCrOr5ZpayloadZengagedrr�r/rr	rQ�s(
�
zStdExpOptionalPrinter.__init__cCs:|jdurd|jSt|jd�r4d|j|j��fS|jS)Nr1r[z%s containing %s)rrCr�r�r^rrrr	r^�s

�zStdExpOptionalPrinter.to_stringr3rrr/r	r5�sr5cs(eZdZdZ�fdd�Zdd�Z�ZS)�StdVariantPrinterzPrint a std::variantcs�t|j�}t|��_d�jd��fdd�|D��f�_|d�_�jt|�kr`d�_d}d}n@|t�j��_|dddj	}|�
�j�����}t
�|�}tt���||d	�dS)
Nz%s<%s>r csg|]}��|��qSr)r!)r!Zaltrrr	r#r$z.StdVariantPrinter.__init__.<locals>.<listcomp>Z_M_indexZ_M_ur�rlr�)rLrr9rCr(�indexrr*r�rmrbrYrnrr�r,r9rQ)rrCrOZalternativesrr�Zaddrr/rr	rQs

$

zStdVariantPrinter.__init__cCsH|jdurd|jSt|jd�r8d|j|j|j��fSd|j|jfS)Nr1r[z%s [index %d] containing %sz
%s [index %d])rrCr�r�r:r^rrrr	r^s


�zStdVariantPrinter.to_stringr3rrr/r	r9�sr9cs(eZdZdZ�fdd�Zdd�Z�ZS)�StdNodeHandlePrinterzPrint a container node handlecs�|j�d�|_|j�d��d�}t|jd�|_|j�d�|jk|_|d}|r~|jrbt|���}nt	|d|j�}t
�|�}nd}d}|d}|dr�|d	nd|_t
t|��||d
�dS)Nr&rrr�rXrlZ_M_allocr7r6r�)rr2r1r@r�is_rb_tree_node�is_map_noder�rnrorr�Zallocr,r;rQ)rrCrOryZnodeptrrr�Zoptallocr/rr	rQs&��zStdNodeHandlePrinter.__init__cCsfd}|js|d7}|jr"|d7}n|d7}|jrZ|d7}t|jd�rVd||j��fS|Sd|SdS)	Nznode handle for z
unordered r��setz
 with elementr[z%s = %sr�)r<r=rr�r�r^)rr2rrr	r^1s
zStdNodeHandlePrinter.to_stringr3rrr/r	r;sr;c@s(eZdZdZdd�Zdd�Zdd�ZdS)	�StdExpStringViewPrinterzFPrint a std::basic_string_view or std::experimental::basic_string_viewcCs
||_dSrrNrZrrr	rQEsz StdExpStringViewPrinter.__init__cCs6|jd}|jd}t|d�r*|j|d�S|j|d�S)NZ_M_str�_M_lenr�r�)rOr�r�r�)rr�rrrr	r^Hs



z!StdExpStringViewPrinter.to_stringcCsdSr�rrrrr	r�Osz$StdExpStringViewPrinter.display_hintNr�rrrr	r?Bsr?c@s@eZdZdZdd�Zdd�Zdd�ZGdd	�d	e�Zd
d�Z	dS)
�StdExpPathPrinterz+Print a std::experimental::filesystem::pathcCsB||_||_|jddd}|jddd}t||�|_dS)N�_M_cmptsr�r�r�)rOrCr��	num_cmpts)rrCrOr�r�rrr	rQUs
zStdExpPathPrinter.__init__cCs:t|jd�}|dd�dkr"dS|dd�dkr6dSdS)NZ_M_type����	_Root_dir�root-directory����
_Root_name�	root-name)rrOrkrrr	�
_path_type\szStdExpPathPrinter._path_typecCs8d|jd}|jdkr0|��}|r0d||f}d|S)Nr��_M_pathnamer�%s [%s]z!experimental::filesystem::path %s)rOrCrJ�r�pathr-rrr	r^ds
zStdExpPathPrinter.to_stringc@s$eZdZdd�Zdd�Zdd�ZdS)zStdExpPathPrinter._iteratorcCs,||_|dd|_|dd|_d|_dS)Nr�r�r�r)�pathtyper�r�r|)rZcmptsrOrrr	rQmsz$StdExpPathPrinter._iterator.__init__cCs|Srrrrrr	rRssz$StdExpPathPrinter._iterator.__iter__cCsd|j|jkrt�|j��}|j}|jd|_|jd|_|d}t|j|���}|sX|}d||fS�Nr&rKz[%s])r�r�rTrnr|rArOrJ�rr�r|rNr-rrr	rvs
z$StdExpPathPrinter._iterator.__next__Nr�rrrr	r�lsr�cCs|�|jd|j�S)NrB)r�rOrCrrrr	r[�szStdExpPathPrinter.childrenN�
rrr
rrQrJr^rr�r[rrrr	rARsrAc@s@eZdZdZdd�Zdd�Zdd�ZGdd	�d	e�Zd
d�Z	dS)
�StdPathPrinterzPrint a std::filesystem::pathcCsP||_||_t|jdd�}|�t�d��d@|_|jdkrF||_nd|_dS)NrBr�Z	uintptr_t�r)rOrCrirbrrrr�)rrCrOr�rrr	rQ�s
zStdPathPrinter.__init__cCsHt|j�t�|jd���}|dd�dkr0dS|dd�dkrDdSdS)Nz::_TyperDrErFrGrHrI)rrrbrrrCrkrrr	rJ�szStdPathPrinter._path_typecCs8d|jd}|jdkr0|��}|r0d||f}d|S)Nr�rKrrLzfilesystem::path %s)rOrrJrMrrr	r^�s
zStdPathPrinter.to_stringc@s$eZdZdd�Zdd�Zdd�ZdS)zStdPathPrinter._iteratorc	Cs�||_|r�t�d�}t�|d�}t�d�}|�|���}|��}ttjd�rbtd|j	|j
�}n
d|j	}|�|���|}|�|���|_|j||_d|_
nd|_d|_dS)Nr�z::_Cmpt�char�alignofrr)rOrrrbrYrnr�r8�maxr�rVr�r�r|)	rr�rOZint_typeZ	cmpt_typeZ	char_typer�Zsizeof_Impl�beginrrr	rQ�s 


z!StdPathPrinter._iterator.__init__cCs|Srrrrrr	rR�sz!StdPathPrinter._iterator.__iter__cCsd|j|jkrt�|j��}|j}|jd|_|jd|_|d}t|j|���}|sX|}d||fSrP)r�r�rTrnr|rSrOrJrQrrr	r�s
z!StdPathPrinter._iterator.__next__Nr�rrrr	r��sr�cCs|�|j|j�Sr)r�r�rCrrrr	r[�szStdPathPrinter.childrenNrRrrrr	rS�s
(rSc@s8eZdZdZdd�ZGdd�de�Zdd�Zdd	�Zd
S)�StdPairPrinterz?Print a std::pair object, with 'first' and 'second' as childrencCs
||_dSrrNrZrrr	rQ�szStdPairPrinter.__init__c@s(eZdZdZdd�Zdd�Zdd�ZdS)	zStdPairPrinter._iterz?An iterator for std::pair types. Returns 'first' then 'second'.cCs||_d|_dS)Nr�)rO�whichrPrrr	rQ�szStdPairPrinter._iter.__init__cCs|Srrrrrr	rR�szStdPairPrinter._iter.__iter__cCs8|jdurt�|j}|dkr$d|_nd|_||j|fSr)rZrTrO)rrZrrr	r�s
zStdPairPrinter._iter.__next__NrUrrrr	r��sr�cCs|�|j�Sr)r�rOrrrr	r[�szStdPairPrinter.childrencCsdSrrrrrr	r^�szStdPairPrinter.to_stringN)	rrr
rrQrr�r[r^rrrr	rY�s
rYc@s eZdZdZdd�Zdd�ZdS)�StdCmpCatPrinterz"Print a comparison category objectcCs&||�d�dd�|_|d|_dS)N�:r&r8)�rfindrCrOrZrrr	rQ�szStdCmpCatPrinter.__init__cCsD|jdkr|jdkrd}nddddd�}|t|j�}d	�|j|�S)
N�strong_orderingrZequalZ	unorderedZlessZ
equivalentZgreater)rr`rr&zstd::{}::{})rCrOr�r')rr�namesrrr	r^�s
zStdCmpCatPrinter.to_stringNr�rrrr	r[�sr[c@sTeZdZdZdZdd�Zedd��Zedd��Z	ed	d
��Z
edd��Zd
d�ZdS)�StdErrorCodePrinterz/Print a std::error_code or std::error_conditionNcCsJ||_t|�|_tjdurFzddl}dt_WntyDdt_Yn0dS)NrTF)rOr9rCr`�_system_is_posix�posix�ImportError)rrCrOrbrrr	rQs


zStdErrorCodePrinter.__init__cCs&t�|�}|dur"|jtjkr"|SdSr)rrr�ZTYPE_CODE_ENUM)rrrrr	�_find_errc_enums
z#StdErrorCodePrinter._find_errc_enumc	Cs�gd�}|D]z}|d}dtfD]d}d�|�}t�d�||��d}|dur ||��jkr d|}|�d�||��}||fSq qd	S)
N)�streamZsocketzip::resolverz_category()rAzstd::{}experimental::net::v1z{}::{}::__crznet::z{}::{}_errc)NN)r*r'rZ
lookup_symbol�valuermrd)	�cls�catZnet_catsr�r-�nsZsymr�enumrrr	�_match_net_ts_categorys
z*StdErrorCodePrinter._match_net_ts_categorycCs�d}d}d}|�|�\}}|dur.d|||fS|j��}|j�d�rLd}d}|j�d�rbd}|j}|j�d�r|d	}|�d
�}|j�d�r�d}|�d
�}|dur�zWnYn0||j||fS)z(Return details of a std::error_category.NFz::generic_error_category�genericTz::system_error_category�systemz::future_error_categoryZfuturezstd::future_errcz::io_error_category�iozstd::io_errc)rk�dynamic_typer�r�endswithrard)rgrhrrj�is_errnor-rrrr	�_category_info$s2


z"StdErrorCodePrinter._category_infocCs|�d�dS)zEStrip any nested-name-specifier from NAME to give an unqualified namer%r`)�split)rrrr	�_unqualified_nameOsz%StdErrorCodePrinter._unqualified_namec	Cs�|jd}|jd}|�|�\}}}}|dkrVddd�}|||�|j�krV|jdSt|�}|r�|dkr�ztjt|�}Wq�Yq�0n|dur�|�t|�|���}|dur�d|}n|}d	|j||fS)
Nr8Z_M_catrrmrl)�
error_code�error_conditionz = { }z"%s"z
%s = {%s: %s})	rOrrrtrCr�errnoZ	errorcoder�rb)	rrfrhrZalt_namerjrqZdefault_catsZstrvalrrr	r^Ts*

�

zStdErrorCodePrinter.to_string)
rrr
rrarQr�rd�classmethodrkrrrtr^rrrr	r`�s


*
r`c@s@eZdZdZGdd�de�Zdd�Zdd�Zdd	�Zd
d�Z	dS)
�StdSpanPrinterzPrint a std::spanc@s$eZdZdd�Zdd�Zdd�ZdS)zStdSpanPrinter.iteratorcCsd|_||_||_dSr�)r|rXr�)rrXr�rrr	rQrsz StdSpanPrinter.iterator.__init__cCs|Srrrrrr	rRwsz StdSpanPrinter.iterator.__iter__cCs8|j|jkrt�|j}|jd|_d||j|��fS)Nr&r~)r|r�rTrXrnrrrr	rzs
z StdSpanPrinter.iterator.__next__Nr�rrrr	�iteratorqsrzcCsLt|�|_||_t�d�}|j�d�|kr:|dd|_n|j�d�|_dS)Nzstatic_cast<std::size_t>(-1)r&Z	_M_extentZ_M_extent_value)r9rCrOrZparse_and_evalrr2r�)rrCrOZsize_maxrrr	rQ�s

zStdSpanPrinter.__init__cCsd|j|jfS�Nz%s of length %d�rCr�rrrr	r^�szStdSpanPrinter.to_stringcCs|�|jd|j�SrW)rzrOr�rrrr	r[�szStdSpanPrinter.childrencCsdSr�rrrrr	r��szStdSpanPrinter.display_hintN)
rrr
rrrzrQr^r[r�rrrr	ryns	ryc@s0eZdZdZdd�Zdd�Zdd�Zdd	�Zd
S)�StdInitializerListPrinterzPrint a std::initializer_listcCs||_||_|d|_dS)Nr@)rCrOr�rZrrr	rQ�sz"StdInitializerListPrinter.__init__cCsd|j|jfSr{r|rrrr	r^�sz#StdInitializerListPrinter.to_stringcCst�|jd|j�S)NZ_M_array)ryrzrOr�rrrr	r[�sz"StdInitializerListPrinter.childrencCsdSr�rrrrr	r��sz&StdInitializerListPrinter.display_hintN)rrr
rrQr^r[r�rrrr	r}�s
r}cs$eZdZ�fdd�Zdd�Z�ZS)�	RxPrintercs$tt|���||_||_d|_dS�NT)r,r~rQrr%�enabled)rrr%r/rr	rQ�szRxPrinter.__init__cCs:|js
dS|jjtjkr,ttjd�r,|��}|�|j	|�S)N�referenced_value)
r�rr�rr�r��Valuer�r%r)rrfrrr	�invoke�szRxPrinter.invoke)rrr
rQr�r4rrr/r	r~�sr~csHeZdZ�fdd�Zdd�Zdd�Zdd�Zed	d
��Zdd�Z	�Z
S)
�Printercs6tt|���||_g|_i|_d|_t�d�|_	dS)NTz^([a-zA-Z0-9_:]+)(<.*>)?$)
r,r�rQr�subprinters�lookupr�r<�compile�compiled_rx)rrr/rr	rQ�szPrinter.__init__cCs<|j�|�std|��t||�}|j�|�||j|<dS)Nz0libstdc++ programming error: "%s" does not match)r�r=rr~r�rHr�)rrr%�printerrrr	�add�s

zPrinter.addcCs:|�|||�tr6t�ddt|�}|�|||�dS)Nz^(std|__gnu_cxx)::z\g<0>%s)r�r*r<r))rrzrr%Zvbaserrr	�add_version�szPrinter.add_versioncCs$|�|||�|�|d||�dS)Nz__cxx1998::)r�)rrzrr%rrr	�
add_container�szPrinter.add_containercCs&|jtjkr|��}|����}|jSr)r�rr�r�r�rr)rrrr	�get_basic_type�szPrinter.get_basic_typecCsr|�|j�}|sdS|j�|�}|s(dS|�d�}|jjtjkrTttj	d�rT|�
�}||jvrn|j|�|�SdS)Nr&r�)
r�rr�r=r+r�rr�r�r�r�r�r�)rrOrCr=�basenamerrr	�__call__�s

zPrinter.__call__)rrr
rQr�r�r�r�r�r�r4rrr/r	r��s


r�c@s0eZdZdZdd�ZGdd�de�Zdd�ZdS)	�TemplateTypePrinteral
    A type printer for class templates with default template arguments.

    Recognizes specializations of class templates and prints them without
    any template arguments that use a default template argument.
    Type printers are recursively applied to the template arguments.

    e.g. replace "std::vector<T, std::allocator<T> >" with "std::vector<T>".
    cCs||_||_d|_dSr)r�defargsr��rrr�rrr	rQszTemplateTypePrinter.__init__c@s(eZdZdZdd�Zdd�Zdd�ZdS)	zTemplateTypePrinter._recognizerz-The recognizer class for TemplateTypePrinter.cCs||_||_dSr)rr�r�rrr	rQsz(TemplateTypePrinter._recognizer.__init__c		Cs�|jdurdS|j�|j�s dSt|�}g}d}tt|��D]�}||}|j�|�}|dur�|j|�}z|t	�
|�kr~WdSWn&t	jy�|j|kr�YdSYn0d}q<|r�dS|�|�
|��q<|jd|j�d��}t|�}|dd�|�dS)a
            If type_obj is a specialization of self.name that uses all the
            default template arguments for the class template, then return
            a string representation of the type without default arguments.
            Otherwise, return None.
            NFTr�<r �>)rr:rrL�rangerr��getr'rrr)rH�_recognize_subtyper�rGr()	rrIrKZdisplayed_argsZrequire_defaultedrJZtargZdefargr?rrr	�	recognizes2


z)TemplateTypePrinter._recognizer.recognizecCs�|jtjkr|�|���dS|jtjkrj|�|���}t|����d�rR|dSd||�	�ddfS|jtj
kr�|�|���dSttd�r�|jtjkr�|�|���dStj
�tj
��|�}|r�|St|�S)zxConvert a gdb.Type to a string by applying recognizers,
            or if that fails then simply converting to a string.�*z[]z%s[%d]r&�&�TYPE_CODE_RVALUE_REFz&&)r�rZ
TYPE_CODE_PTRr�r�r�rrrpr�r�r�r�rrr )rrIrFrrr	r�Es$

�z2TemplateTypePrinter._recognizer._recognize_subtypeN)rrr
rrQr�r�rrrr	�_recognizers1r�cCs|�|j|j�S�z1Return a recognizer object for this type printer.)r�rr�rrrr	�instantiate\szTemplateTypePrinter.instantiateN�rrr
rrQ�objectr�r�rrrr	r��s
Pr�cs~td||�}tj�||�td||�}tj�||�trzdt�t�fdd�|��D��}t�||�}tj�||�dS)a�
    Add a type printer for a class template with default template arguments.

    Args:
        name (str): The template-name of the class template.
        defargs (dict int:string) The default template arguments.

    Types in defargs can refer to the Nth template-argument using {N}
    (with zero-based indices).

    e.g. 'unordered_map' has these defargs:
    { 2: 'std::hash<{0}>',
      3: 'std::equal_to<{0}>',
      4: 'std::allocator<std::pair<const {0}, {1}> >' }

    r0zstd::__debug::c3s"|]\}}||�d��fVqdS)r0N)r+)r!rJ�d�rirr	�	<genexpr>|s�z0add_one_template_type_printer.<locals>.<genexpr>N)r�rr�register_type_printerr*�dict�items)�objrr�r�rr�r	�add_one_template_type_printer`s�r�c@s0eZdZdZdd�ZGdd�de�Zdd�ZdS)	�FilteringTypePrintera�
    A type printer that uses typedef names for common template specializations.

    Args:
        match (str): The class template to recognize.
        name (str): The typedef-name that will be used instead.

    Checks if a specialization of the class template 'match' is the same type
    as the typedef 'name', and prints it as 'name' instead.

    e.g. if an instantiation of std::basic_istream<C, T> is the same type as
    std::istream then print it as std::istream.
    cCs||_||_d|_dSr)r=rr��rr=rrrr	rQ�szFilteringTypePrinter.__init__c@s eZdZdZdd�Zdd�ZdS)z FilteringTypePrinter._recognizerz.The recognizer class for FilteringTypePrinter.cCs||_||_d|_dSr)r=rrIr�rrr	rQ�sz)FilteringTypePrinter._recognizer.__init__cCsf|jdurdS|jdurN|j�|j�s*dSzt�|j���|_WnYn0|j|krbt|j�SdS)z�
            If type_obj starts with self.match and is the same type as
            self.name then return self.name, otherwise None.
            N)	rrIr:r=rrrrrG)rrIrrr	r��s



z*FilteringTypePrinter._recognizer.recognizeN)rrr
rrQr�rrrr	r��sr�cCs|�|j|j�Sr�)r�r=rrrrr	r��sz FilteringTypePrinter.instantiateNr�rrrr	r��sr�cCsPtd|d|�}tj�||�trLdt}t||||�}tj�||�dS)Nr0)r�rrr�r*)r�r=rr�rirrr	�add_one_type_printer�sr�cCs�tsdSdD]H}t|d|d�t|d|d�t|dd|d�t|d|d�qdD]T}d	D]}t|d
|||�qbdD],}t|d
|||�t|d|||�q�qZd
D]j}dD]}t||d||d�q�dD]>}t||d||d�dD]}t||||||�q�q�q�t|dd�dD]}t|d|��q0t|dd�t|dd�t|dd�t|dd�t|dd�t|dd �t|d!d"�t|d!d#�t|d$d%�d&}dD]}t||d||d��q�t|d'd(d)i�t|d*d(d+i�t|d,d(d+i�t|d-d(d+i�t|d.d(d+i�t|d/d(d+i�t|d0d1d2d3��t|d4d1d2d3��t|d5d1d+d6��t|d7d1d+d6��t|d8d9d:d2d;��t|d<d9d:d2d;��t|d=d9d:d+d>��t|d?d9d:d+d>��dS)@N)rAr��u8�u16�u32�basic_stringr�z__cxx11::basic_string�	__cxx11::�basic_string_viewZstring_view)rAr�)	ZiosZ	streambufZistreamZostreamZiostreamZfilebufZifstreamZofstreamZfstreamZbasic_)Z	stringbufZ
istringstreamZ
ostringstreamZstringstreamz__cxx11::basic_)rAr�Zbasic_regexZregex)r��sZwcZwsZ
match_resultsr=)Z	sub_matchZregex_iteratorZregex_token_iteratorZfposZ	streampos)ZnanosecondsZmicrosecondsZmillisecondsZsecondsZminutesZhoursZdurationZlinear_congruential_engineZminstd_rand0Zminstd_randZmersenne_twister_engineZmt19937Z
mt19937_64Zsubtract_with_carry_engineZ
ranlux24_baseZ
ranlux48_baseZdiscard_block_engineZranlux24Zranlux48Zshuffle_order_engineZknuth_bzexperimental::fundamentals_v1::�
unique_ptrr&zstd::default_delete<{0}>�dequezstd::allocator<{0}>r�r�z
__cxx11::list�vectorr�zstd::less<{0}>z)std::allocator<std::pair<{0} const, {1}>>)rrT�multimapr>)r&r�multiset�
unordered_mapzstd::hash<{0}>zstd::equal_to<{0}>)rrT��unordered_multimap�
unordered_set)r&rrT�unordered_multiset)rr�r�)r�Zchr>ZabiZdurrirrr	�register_type_printers�s�
�

����������������r�cCs8trtj�|t�n|dur t}|j�t�t|�dS)z4Register libstdc++ pretty-printers with objfile Obj.N)�_use_gdb_pprZprintingZregister_pretty_printer�libstdcxx_printerZpretty_printersrHr�)r�rrr	�register_libstdcxx_printerssr�cCsdtd�at�ddt�t�ddt�t�ddt�t�ddt�t�ddt�t�ddt�t�ddt�t�dd	t�t�dd
t	�t�ddt
�t�ddt�t�dd
t�t�ddt�t�ddt	�t�ddt�t�ddt
�t�ddt�ttjd��r t�ddt�t�ddt�t�dt�t�dt�t�dt�t�dt�t�dt�t�dt	�t�dt�t�dt�t�dt	�t�dt�t�d t
�t�d!t�t�dd"t�t�dd#t�t�dd$t�t�dd%t�t�dd&t�t�dd't�t�dd(t�t�d)d"t�t�d)d#t�t�d)d$t�t�d)d%t�t�d)d&t�t�d)d't�t�dd*t�t�d+t�t�d,t�t�d-t�t�d.t�t�d/t�t�d0d1t�t�d0d2t�t�d0d3t�t�d4d5t�t�d6d5t�t�d7d5t�t�d8d5t�t�dd1t�t�dd2t�t�dd3t�t�dd9t�t�dd:t�t�dd;t �t�dd<t �t�dd=t �t�dd>t!�t�d?d@t"�t�ddAt#�t�ddBt#�t�ddCt$�t�ddDt$�t�ddEt%�t�ddFt%�t�d?dGt&�t�ddHt'�t�ddIt'�t�ddJt(�t�d?dKt)�t�ddLt*�t�ddMt*�t�dNt+�dS)ONzlibstdc++-v6r0r�rDZbitsetr�r�r�r�r�r�Zpriority_queueZqueuerhr>�stackr�r�rorurvzstd::__debug::bitsetzstd::__debug::dequezstd::__debug::listzstd::__debug::mapzstd::__debug::multimapzstd::__debug::multisetzstd::__debug::priority_queuezstd::__debug::queuezstd::__debug::setzstd::__debug::stackzstd::__debug::unique_ptrzstd::__debug::vectorZ
shared_ptrZweak_ptrr�r�r�r�r�z
std::tr1::Zinitializer_listzstd::__debug::unordered_mapzstd::__debug::unordered_setz std::__debug::unordered_multimapz std::__debug::unordered_multisetzstd::__debug::forward_listz$std::experimental::fundamentals_v1::�anyZoptionalr�z#std::experimental::filesystem::v1::rNz,std::experimental::filesystem::v1::__cxx11::zstd::filesystem::zstd::filesystem::__cxx11::ZvariantZ_Node_handleZpartial_orderingZ
weak_orderingr^�spanz__gnu_cxx::ZslistZ_List_iteratorZ_List_const_iteratorZ_Rb_tree_iteratorZ_Rb_tree_const_iteratorZ_Deque_iteratorZ_Deque_const_iteratorZ__normal_iteratorZ
_Bit_iteratorZ_Bit_const_iteratorZ_Bit_referenceZ_Slist_iteratorZ_Fwd_list_iteratorZ_Fwd_list_const_iteratorz__gnu_debug::_Safe_iterator),r�r�r�r�r�r�r�rvr�r�rYr�r�rjr�r�rr�r`r�rVrrrr}r(r5r?rArSr9r;r[ryr�r�r�r�r�r�r�r�r�r�rrrr	�build_libstdcxx_dictionary,sZ���������������������������������������������r�)[rrr<r#�osrwr$r�rr�r�ziprr�r�r�Zgdb.printingrcrZ	gdb.typesr�rrr*r/r6r3r@r9rGrLrMrVrdrfrirjrorurvr�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�rrrrrr'r(r5r9r;r?rArSrYr[r`ryr}r~r�r�r�r�r�r�r�r�r�rrrr	�<module>s�

	

%
!GR')#.@!,$,:")4I p&@d!4`'
Cubjrnet7 Shell
